Share
Watch Connectivity è un nuovo framework di comunicazione rilasciato insieme a iOS 9 e watchOS 2. Lo scopo principale è quello di trasferire facilmente e facilmente le informazioni tra un'applicazione Apple Watch e l'applicazione iOS principale.
Il framework offre molte funzionalità diverse. Poche settimane fa, Jorge Costa ha scritto sulla possibilità di inviare messaggi tra un'applicazione iOS e un'applicazione Apple Watch. In questo tutorial, ingrandiremo il trasferimento dei dati in background.
La capacità di inviare messaggi è progettata per i dati che sono necessari immediatamente dall'altro dispositivo. Al contrario, i trasferimenti in background sono più adatti per pezzi di dati più grandi che non sono necessari immediatamente dalla controparte. Un'eccezione a questo è rappresentata dalle informazioni sulla complicazione, di cui parleremo più avanti in questo tutorial.
Questo tutorial richiede che tu stia utilizzando Xcode 7 su OS X 10.10 o successivo. Dovrai anche scaricare il progetto iniziale da GitHub.
Per utilizzare il framework Watch Connectivity, sia la tua app iOS che watchOS devono avere una classe conforme a WCSessionDelegate protocollo e che configura correttamente il valore predefinito WCSession. I metodi del WCSessionDelegate Il protocollo gestisce la ricezione di tutti i dati tramite il framework Watch Connectivity e consente di assumere il controllo dei nuovi dati nell'applicazione.
Apri il progetto iniziale in Xcode e modifica AppDelegate.swift. In alto, aggiungi quanto segue importare dichiarazione:
importare WatchConnectivity
Successivamente, aggiorna la definizione della classe di AppDelegate classe per renderlo conforme al WCSessionDelegate protocollo.
class AppDelegate: UIResponder, UIApplicationDelegate, WCSessionDelegate
Dichiariamo anche una proprietà di tipo WCSession! nel AppDelegate classe per memorizzare un riferimento al valore predefinito WCSession oggetto.
var session: WCSession!
Infine, aggiorna il applicazione (_: didFinishLaunchingWithOptions :) metodo come mostrato di seguito.
func application (application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool session = WCSession.defaultSession () session.delegate = self se WCSession.isSupported () session.activateSession () restituisce true
Nel applicazione (_: didFinishLaunchingWithOptions :), otteniamo un riferimento al valore predefinito WCSession oggetto, impostare il delegato della sessione nell'app AppDelegate istanza e, se supportata, attiva la sessione. Il è supportato metodo di classe controlla se l'app watchOS corrispondente alla tua app per iOS è installata o meno su un Apple Watch accoppiato ed è in grado di inviare dati.
La configurazione per il lato watchOS è molto simile. Aperto ExtensionDelegate.swift e sostituire il suo contenuto con il seguente:
import WatchKit import WatchConnectivity class ExtensionDelegate: NSObject, WKExtensionDelegate, WCSessionDelegate var session: WCSession! func applicationDidFinishLaunching () session = WCSession.defaultSession () session.delegate = self session.activateSession () func applicationDidBecomeActive () func applicationWillResignActive ()
Noterai che non chiamiamo è supportato sul WCSession classe prima di attivare la sessione. Questo perché questo metodo restituisce sempre vero sul lato watchOS.
Per verificare che tutto funzioni correttamente, esegui l'app Apple Watch su uno dei due simulatori come mostrato di seguito.
Successivamente, esegui la tua app iOS sullo stesso tipo di simulatore iPhone che hai selezionato durante l'esecuzione dell'app watch.
Una volta avviata l'app per iOS, il simulatore di Apple Watch dovrebbe tornare al quadrante come mostrato nell'immagine seguente.
Con il valore predefinito WCSession oggetto correttamente configurato, è tempo per noi di inviare alcuni dati tra iOS e l'applicazione Apple Watch.
Aperto TableViewController.swift e aggiungi la seguente riga di codice alla fine del CreateNewItem (_ :) metodo:
WCSession.defaultSession (). TransferUserInfo (voce)
Il transferUserInfo (_ :) metodo accetta un dizionario come unico parametro. Una volta chiamato questo metodo, il dizionario delle informazioni utente che hai fornito viene aggiunto alla coda di informazioni da trasferire.
Sia iOS che watchOS lavorano insieme per trasferire le informazioni in un momento opportuno. Il sistema combinato prende in considerazione aspetti come l'utilizzo delle app, la durata della batteria, indipendentemente dal fatto che l'altro dispositivo sia attualmente in uso, ecc. Una volta che il sistema ha trasferito le informazioni, l'applicazione sull'altro dispositivo eseguirà un metodo di richiamata delegato la prossima volta è lanciato.
Ora è il momento per noi di implementare il lato ricevente su Apple Watch. Aperto ExtensionDelegate.swift e aggiungere il seguente metodo al ExtensionDelegate classe:
Accentsconagua
func session (session: WCSession, didReceiveUserInfo userInfo: [String: AnyObject]) dispatch_async (dispatch_get_main_queue ()) () -> Void in if let items = NSUserDefaults.standardUserDefaults (). objectForKey ("items") as? [NSDictionary] var newItems = items newItems.append (userInfo) NSUserDefaults.standardUserDefaults (). SetObject (newItems as AnyObject, forKey: "items") else NSUserDefaults.standardUserDefaults (). SetObject ([userInfo] come AnyObject, forKey : "elementi") Questo metodo verrà chiamato non appena eseguiremo l'applicazione Apple Watch e una volta che le informazioni sono state trasferite correttamente.
Si noti che mentre questo tutorial mostra solo un esempio di trasferimento di informazioni da iOS a watchOS, il WCSession e WCSessionDelegate i metodi si comportano esattamente allo stesso modo su entrambe le piattaforme per i trasferimenti in background.
Con questo codice implementato, esegui l'app Apple Watch nel simulatore. Successivamente, esegui nuovamente l'app per iPhone e premi il pulsante per creare un nuovo elemento.
Ora torna al simulatore di Apple Watch e premi Comando-Maiuscole-H due volte per tornare all'app più recente. Vedrai che l'oggetto appena creato compare su Apple Watch.
Si noti che, mentre il trasferimento delle informazioni avviene immediatamente tra i simulatori, in una situazione reale con dispositivi fisici questo non sarà sempre il caso.
Con la tua app iOS ancora in esecuzione, esci dal simulatore Apple Watch dalla barra dei menu o premendo Comando-Q. Dopo averlo fatto, premi il pulsante nella tua app per iOS per creare altri oggetti come mostrato di seguito.
Ogni volta che si tenta di trasferire informazioni utilizzando il framework Watch Connectivity, questo viene aggiunto a una coda che viene gradualmente cancellata man mano che le informazioni vengono trasferite. È possibile accedere a questa coda e accedere ai trasferimenti in coda.
Questo è utile, perché puoi vedere quanti elementi sono ancora in sospeso e puoi persino annullare i trasferimenti specifici se necessario. Gli elementi appena creati sono attualmente trattenuti nella coda delle informazioni utente perché l'Apple Watch è attualmente disconnesso dal dispositivo principale, rendendo impossibile il trasferimento.
Aperto AppDelegate.swift e aggiungi il seguente codice alla fine di applicazione (_: didFinishLaunchingWithOptions :):
let transfers = session.outstandingUserInfoTransfers if transfers.count> 0 let transfer = transfers.first! transfer.cancel ()
Con questo codice, accediamo ai trasferimenti di informazioni utente in sospeso e, se ce n'è almeno uno, annulla il primo trasferimento. Il WCSessionUserInfoTransfer oggetti restituiti dal outstandingUserInfoTransfers la proprietà ha anche due proprietà di sola lettura a cui è possibile accedere:
userInfo: Questa proprietà memorizza il dizionario che si sta trasferendo.trasferimento: Questa proprietà memorizza un valore booleano e indica se le informazioni dell'utente sono attualmente trasferite.Non c'è una grande quantità di funzionalità disponibili con trasferimenti di informazioni eccezionali nel framework Watch Connectivity, ma a seconda dell'applicazione, alcune di queste funzionalità potrebbero essere molto utili.
In questo tutorial, abbiamo coperto solo i trasferimenti in background di informazioni utente, ma ci sono altri modi per trasferire dati tra dispositivi. Ognuno di questi metodi è progettato per uno scopo specifico quando si comunica tra un iPhone e un Apple Watch.
Qui è dove è necessario trasferire le informazioni tra dispositivi in cui sono rilevanti solo le informazioni più recenti. Si trasferisce un singolo dizionario chiamando il updateApplicationContext (_: errore :) metodo. Il errore parametro in questo metodo è un puntatore a un NSError oggetto, che verrà riempito con informazioni se si verifica un problema con il trasferimento.
Dal lato ricevente è possibile implementare il sessione (_: didReceiveApplicationContext :) metodo o, in alternativa, accedere al contesto dell'applicazione tramite l'impostazione predefinita WCSession oggetto di receivedApplicationContext proprietà.
Qui è dove devi trasferire un singolo dizionario di informazioni utente specifico per la complicazione personalizzata della tua app. Puoi solo inviare informazioni dal lato iOS e questo è fatto con transferCurrentComplicationUserInfo (_ :) metodo.
La differenza fondamentale tra questo e il transferUserInfo (_ :) il metodo utilizzato in precedenza in questo tutorial è che, quando si aggiorna una complicazione, il sistema tenterà sempre di trasferire immediatamente le informazioni.
Tieni presente che il trasferimento non è garantito poiché i dispositivi possono essere scollegati o la tua complicazione potrebbe aver superato il budget di esecuzione in background. Se un trasferimento di informazioni di complicanza non può essere completato, viene aggiunto al outstandingUserInfoTransfers fare la fila dove può essere visualizzato e cancellato se necessario.
Si noti inoltre che, se un trasferimento di informazioni di complicanze è in coda e si chiama il transferCurrentComplicationUserInfo (_ :) di nuovo, il trasferimento esistente nella coda verrà annullato e annullato.
È anche possibile utilizzare il framework Watch Connectivity per trasferire file tra dispositivi. Questo viene fatto tramite il transferFile (_: metaData :) metodo in cui il primo parametro è locale NSURL al file e il secondo è un dizionario opzionale, contenente eventuali dati aggiuntivi associati a quel file.
Come ci si aspetterebbe, la ricezione di questo file è gestita da un metodo di WCSessionDelegate protocollo, il sessione (_: didReceiveFile :) metodo per essere precisi. In questo metodo, ti viene dato un singolo WCSessionFile oggetto che contiene un nuovo URL locale per il file effettivo e anche i metadati trasferiti.
Come con i trasferimenti di informazioni dell'utente, è anche possibile visualizzare i trasferimenti in sospeso o in corso in corso tramite l'impostazione predefinita WCSession oggetto di outstandingFileTransfers proprietà.
Nel complesso, il framework Watch Connectivity fornisce un'interfaccia molto semplice e facile da usare per trasferire i dati tra un iPhone collegato e un Apple Watch. Il framework consente il trasferimento di informazioni utente, contesto applicativo e dizionari di informazioni sulle complicazioni nonché i file.
Ora dovresti essere a tuo agio sia con l'invio e la ricezione di informazioni utilizzando la struttura di Watch Connectivity, sia con il modo in cui puoi interagire con qualsiasi trasferimento eccezionale.
Come sempre, si prega di essere sicuri di lasciare i vostri commenti e feedback nei commenti qui sotto.
