Mantenere sincronizzati i dati delle applicazioni tra i dispositivi è un compito complesso e scoraggiante. Fortunatamente, questo è esattamente il motivo per cui Apple ha creato iCloud. In questa serie di Tuts + Premium, imparerai come funziona iCloud e come le tue applicazioni possono condividere i dati in modo trasparente su più dispositivi.
Disponibile anche in questa serie:
Lavorare con iCloud: Introduzione
Lavorare con iCloud: Key-Value Storage
Lavorare con iCloud: Archiviazione documenti
Lavorare con iCloud: Core Data Integration
Nella prima puntata di questa serie, ho dato un'introduzione a iCloud e in particolare a iCloud Storage. Due tipi di archiviazione iCloud sono disponibili per gli sviluppatori, Stoccaggio valore-chiave e Archiviazione di documenti. Il Key-Value Storage sarà al centro di questo tutorial.
Inizieremo questo tutorial dando uno sguardo più da vicino al processo di configurazione di un'applicazione da utilizzare con iCloud. Con la nostra applicazione opportunamente configurata, faremo uso di Key-Value Storage di iCloud per mantenere i dati della nostra applicazione sincronizzati su più dispositivi.
Prima di iniziare
Non possiamo testare la sincronizzazione dei dati con un solo dispositivo. Per completare questo tutorial, è necessario disporre di almeno due dispositivi iOS con iOS 5 o versioni successive. Sfortunatamente, iOS Simulator non può essere utilizzato per testare iCloud Storage.
L'applicazione che stiamo per costruire sarà una semplice applicazione iOS, il che significa che sarai in grado di eseguirlo su qualsiasi iPhone, iPod Touch o iPad con iOS 5 o versioni successive. La lettura di questo tutorial sarà comunque utile anche se non si dispone di due dispositivi iOS separati da utilizzare per il test. Ti insegnerà come è configurato iCloud e come puoi utilizzare lo Storage a valore chiave di iCloud per migliorare le tue applicazioni.
Passaggio 1: Impostazione del progetto
Inizierò guidandoti nel processo di configurazione della nostra applicazione per utilizzare iCloud Storage. Tuttavia, per prima cosa dobbiamo impostare il nostro progetto Xcode.
Crea un nuovo progetto in Xcode selezionando il Applicazione vista singola modello. Dai un nome alla tua domanda Nuvoloso, entrare in un identificatore della società, impostato i phone per la famiglia di dispositivi e controllare Utilizzare il conteggio di riferimento automatico. Le restanti caselle di controllo dovrebbero essere deselezionate. Dillo a Xcode dove vuoi salvare il tuo progetto e colpire Creare.
È fondamentale che tu scelga attentamente il nome del prodotto e identificatore della società per questo progetto. La combinazione di questi due elementi forma il identificatore del gruppo (insieme all'identificativo del seme bundle) della tua applicazione, che iCloud userà per identificare in modo univoco la tua applicazione. Controllare attentamente l'ortografia, poiché l'identificatore del gruppo è sensibile al maiuscolo e al minuscolo.
Passaggio 2: configurazione di iCloud
Come accennato nel primo articolo di questa serie Tuts + Premium, la configurazione di un'applicazione per l'utilizzo di iCloud è semplice e richiede solo due passaggi. Lascia che ti guidi attraverso il processo passo-passo.
Passaggio 2A: portale di provisioning
Apri il tuo browser preferito e vai al Dev Center iOS di Apple. Accedi al tuo account sviluppatore iOS e fai clic su iOS Provisioning Portal link a destra.
Innanzitutto, dobbiamo creare un ID app per la nostra applicazione. Apri il ID app scheda a sinistra e fare clic su Nuovo ID app pulsante in alto a destra. Assegna al tuo ID app un nome descrittivo per identificarlo facilmente in un secondo momento. Successivamente, inserisci l'identificatore del gruppo di cui ho parlato pochi istanti fa. L'identificatore del bundle è la combinazione dell'identificativo della tua azienda, com.mobiletuts nel nostro esempio e il nome del prodotto, Nuvoloso nel nostro esempio. È possibile lasciare impostato l'identificatore seme bundle Usa l'ID del team, che va bene per la nostra applicazione.
Verifica che il tuo identificatore di bundle sia stato digitato correttamente. Come accennato in precedenza, l'identificatore del bunder è case sensitive. Fai clic sul pulsante di invio per creare il tuo ID app.
L'ID app appena creato dovrebbe essere ora presente nell'elenco degli ID app. Noterai che iCloud è disabilitato per impostazione predefinita per ogni ID app appena creato. Cambiamo questo. A destra del tuo ID app, fai clic su Configurazione pulsante. Nella parte inferiore della pagina, dovresti vedere una casella di controllo che dice Abilita per iCloud. Seleziona la casella di controllo e fai clic Fatto. Il nostro ID app è ora configurato per funzionare con iCloud. C'è un'altra cosa di cui dobbiamo occuparci mentre siamo nel Portale di provisioning.
Per garantire che la nostra applicazione possa essere eseguita sui nostri dispositivi, dobbiamo creare un profilo di provisioning. Sempre nel portale di provisioning iOS, apri il Approvvigionamento scheda a sinistra e selezionare il Sviluppo scheda in alto. Clicca il Nuovo profilo in alto a destra e inserisci un nome descrittivo per il tuo nuovo profilo. Quindi, selezionare il certificato di sviluppo con cui si desidera associare il profilo e scegliere l'ID app corretto dall'elenco a discesa. Infine, seleziona i dispositivi che utilizzerai per il test dall'elenco nella parte inferiore della pagina.
Dopo aver fatto clic sul pulsante di invio in basso a destra, si noterà che il profilo di provisioning ha uno stato di in attesa di. Dopo aver ricaricato la pagina, lo stato del profilo dovrebbe essere aggiornato a Attivo. Fare clic sul pulsante di download accanto al profilo di provisioning e fare doppio clic sul profilo. Xcode installerà automaticamente il profilo per te.
Passaggio 2B: Diritti
Molti sviluppatori si lamentano quando sentono la parola diritti. I diritti non hanno nulla di cui aver paura quando capisci a cosa servono. I diritti concedono capacità specifiche o permessi di sicurezza a un'applicazione. Questo è tutto ciò che c'è da fare. Si tratta di un semplice elenco di coppie chiave-valore che indicano al sistema operativo ciò che l'applicazione può o non può fare e quali applicazioni hanno accesso ai dati dell'applicazione. Quest'ultimo è particolarmente importante quando si lavora con iCloud.
Nel nostro esempio, le autorizzazioni iCloud consentono di abilitare l'archiviazione iCloud per la nostra applicazione. Per configurare le autorizzazioni della nostra applicazione, ci dirigiamo verso l'editor di destinazione di Xcode.
Fai clic sul nostro progetto nel Project Navigator e seleziona il nostro obiettivo dalla lista dei bersagli. Con il Sommario scheda selezionata, dovresti vedere una sezione chiamata I diritti in basso. Seleziona la prima casella di controllo per abilitare le autorizzazioni per la nostra applicazione. Questa opzione creerà un file di autorizzazione per la nostra applicazione. Il campo di testo sotto la casella di controllo deve essere precompilato per te. Ora abbiamo la possibilità di abilitare iCloud Key-Value Storage e iCloud Document Storage.
In questo tutorial parlerò solo di iCloud Key-Value Storage, quindi seleziona la casella accanto a iCloud Key-Value Store. Ancora una volta, Xcode preleva il campo di testo accanto alla casella di controllo con l'identificativo del pacchetto dell'applicazione (senza l'identificatore del seme del pacchetto). Verifica che questo identificatore di gruppo corrisponda a quello che hai inserito nel portale di fornitura quando hai creato l'ID app. Parlerò di iCloud Containers nel prossimo tutorial in cui si riferiscono a iCloud Document Storage.
Nella parte inferiore della sezione delle autorizzazioni, vedi Gruppi di accesso portachiavi. Questo elenco specifica quali applicazioni hanno accesso agli elementi del portachiavi delle applicazioni. Puoi lasciare intatta quella sezione per ora.
Prima di sporcarci le mani con le API di iCloud, dobbiamo configurare le nostre impostazioni di compilazione. Sempre nell'editor di destinazione di Xcode, seleziona il Costruisci le impostazioni scheda e scorrere fino a Firma del codice sezione. Impostare l'identità per la firma del codice per mettere a punto e pubblicazione configurazioni per abbinare il profilo che abbiamo appena creato nel iOS Provisioning Portal.
Passaggio 3: Interfaccia utente
Questo tutorial è un po 'avanzato e presumo quindi che tu abbia familiarità con i concetti di base dello sviluppo di iOS. Ciò significa che mi muoverò un po 'più veloce di quanto faccia di solito visto che abbiamo molto terreno da coprire.
L'applicazione che stiamo per costruire sarà un semplice gestore di segnalibri. Possiamo aggiungere ed eliminare segnalibri ei nostri segnalibri verranno sincronizzati tra i nostri dispositivi. Quant'è fico? Iniziamo.
Aprire il file di intestazione del controller della vista e creare una variabile di istanza (ivar) di tipo NSMutableArray con un nome di segnalibri. L'ivar memorizzerà i nostri segnalibri. I segnalibri verranno visualizzati in una vista tabella. Crea una presa per la vista tabella nel file di intestazione del nostro controller di visualizzazione e assicurati di conformare il nostro controller di visualizzazione all'origine dati della vista tabella e ai protocolli di delega. Inoltre, non dimenticare di sintetizzare gli accessor per entrambe le proprietà nel file di implementazione del nostro controller di visualizzazione. Successivamente, aggiungi due azioni a ViewController.h, editBookmarks: e Aggiungi segnalibro:. Pronto? Dirigetevi verso il ViewController.xib file per collegare tutto.
Inizia trascinando una barra di navigazione sulla vista del nostro controller di visualizzazione e posizionala in alto. Trascina un'istanza di UIBarButtonItem a sinistra della barra di navigazione e imposta il suo identificatore nel Ispettore degli attributi a modificare. Controllo trascinamento dal pulsante di modifica sul nostro Proprietario del file e selezionare il editBookmarks: metodo. Trascina una seconda barra di pulsanti a destra della barra di navigazione e assegnagli un identificativo di Inserisci. Controllo trascinamento dal pulsante Aggiungi al nostro Proprietario del file e selezionare il Aggiungi segnalibro: metodo. Infine, trascina un'istanza di UITableView per vedere la vista del controller e collegare la sua fonte di dati e delegare i punti vendita al Proprietario del file oggetto. Fatto.
L'implementazione dei protocolli di origine dati e delegati della nostra vista tabella è semplice e diretta. Nel numberOfSectionsInTableView: metodo, verifichiamo se la nostra fonte di dati, ovvero i nostri segnalibri, non è nulla. Se è nullo, restituiamo 1. Se non lo è, restituiamo 0. Il tableView: numberOfRowsInSection: il metodo è quasi identico. Invece, se la nostra fonte di dati non è nulla, restituiamo il numero di elementi che contiene. Se la nostra fonte di dati è nulla, restituiamo 0.
Nel tableView: cellForRowAtIndexPath: metodo, iniziamo dichiarando un identificatore di cella statico ai fini del riutilizzo delle celle e poi chiediamo alla tabella di visualizzazione una cella riutilizzabile con l'identificatore di cella che abbiamo appena dichiarato. Se non è stata restituita una cella riutilizzabile, inizializziamo una nuova cella con uno stile di UITableViewCellStyleSubtitle e passiamo il nostro identificatore di cella per il riutilizzo delle celle. Successivamente, recuperiamo il segnalibro corretto dall'origine dati. Ogni segnalibro sarà un dizionario con due coppie di valori-chiave, a nome e a URL. Configuriamo la cella impostando l'etichetta e l'etichetta di dettaglio rispettivamente con il nome e l'URL del segnalibro.
L'utente ha anche la possibilità di modificare i propri segnalibri. Nel tableView: canEditRowAtIndexPath: metodo torniamo SÌ. Il tableView: commitEditingStyle: forRowAtIndexPath: è leggermente più complesso. Iniziamo verificando che lo stile di modifica della cella sia uguale a UITableViewCellEditingStyleDelete, cioè, un segnalibro è stato cancellato. Innanzitutto, aggiorniamo la nostra fonte di dati eliminando il segnalibro dall'array dei segnalibri. Quindi salviamo l'origine dati inviando il nostro controller di visualizzazione a saveBookmarks messaggio e aggiorniamo infine la vista tabella per riflettere le modifiche apportate all'origine dati.
Diamo un'occhiata alle nostre azioni ora. Il editBookmarks: il metodo non potrebbe essere più facile. Commutiamo lo stato di modifica della vista tabella in modo animato.
Il Aggiungi segnalibro: il metodo richiede un po 'più di lavoro. Inizializziamo una nuova istanza di AddBookmarkViewController, un controller di visualizzazione che creeremo a breve, e abbiamo impostato la proprietà del controller di visualizzazione su se stesso. Presentiamo quindi il controller di visualizzazione appena creato modally. Come suggerisce il nome, AddBookmarkViewController è responsabile della creazione di nuovi segnalibri. Diamo un'occhiata più da vicino AddBookmarkViewController.
L'implementazione di AddBookmarkViewController è molto semplice quindi non entrerò troppo nei dettagli. Il controller della vista ha un debole riferimento al nostro controller di visualizzazione principale. Ciò gli consente di notificare il nostro controller di visualizzazione principale quando è stato creato un nuovo segnalibro. Ha anche due uscite di tipo UITextField, che consente all'utente di inserire un nome e un URL per ciascun segnalibro.
Il file XIB contiene una barra di navigazione in alto con a Annulla e a salvare pulsante. La vista stessa contiene il nome e i campi di testo url che ho appena menzionato. I pulsanti Annulla e Salva sono collegati a a Annulla: e a salvare: azione, rispettivamente. Il Annulla: l'azione semplicemente respinge il nostro controller di visualizzazione modale. Il salvare: l'azione è altrettanto semplice. Creiamo un nuovo segnalibro (ad esempio un'istanza di NSDictionary) con i dati che l'utente ha inserito nei campi di testo e comunica al nostro controller di vista principale il nuovo segnalibro. È importante notare che questa non è la soluzione migliore per far sapere al nostro controller di visualizzazione principale quando un nuovo segnalibro è stato creato dal nostro AddBookmarkViewController. Questo approccio introduce un accoppiamento stretto, che dovrebbe essere evitato il più possibile. Un approccio migliore sarebbe adottare il modello di delega.
Siamo quasi pronti, ma dobbiamo ancora implementarlo saveBookmark: metodo nel nostro controller di visualizzazione principale. Inizia dichiarando questo metodo nel file di intestazione del nostro controller di visualizzazione e quindi dirigiti al suo file di implementazione. L'implementazione è minima. Aggiungiamo il segnalibro appena creato alla nostra origine dati, salviamo l'origine dati e quindi ricarichiamo la vista tabella per mostrare il segnalibro che abbiamo appena aggiunto.
La nostra applicazione non è molto utile se i segnalibri dell'utente non vengono salvati su disco. L'utente perderebbe i propri segnalibri ogni volta che l'applicazione si chiuderà. Cattiva esperienza utente Risolviamo questo.
Nel nostro viewDidLoad: metodo, inviamo il nostro controller di visualizzazione a loadBookmarks Messaggio. Diamo un'occhiata al loadBookmarks metodo. Memorizzeremo i segnalibri dell'utente in database di default dell'utente. Per prima cosa controlliamo se esiste già una voce nel database dei default dell'utente con la chiave segnalibri. In tal caso, inizializziamo i segnalibri con i contenuti dell'oggetto memorizzato. Non è questo il caso, inizializziamo i nostri segnalibri con una matrice mutabile vuota e archiviamo quella matrice nel database dei valori predefiniti dell'utente. Semplice. Destra?
Salvare i segnalibri è ancora più semplice. Archiviamo il nostro oggetto segnalibri nel database dei default dell'utente usando la chiave segnalibri. Questo è tutto ciò che c'è da fare.
È stato un bel po 'di lavoro. Ora puoi creare ed eseguire la tua applicazione. Dovresti essere in grado di aggiungere segnalibri ed eliminare segnalibri. I segnalibri vengono salvati su disco in modo da non perdere dati quando si esce dall'applicazione.
Passaggio 6: sincronizzazione dei segnalibri
Per far brillare la nostra applicazione, utilizzeremo iCloud per mantenere sincronizzati i nostri segnalibri tra i nostri dispositivi. Ti sorprenderà quanto sia facile. Come ho accennato nel precedente tutorial di questa serie, il Key-Value Storage di iCloud funziona molto simile NSUserDefaults, vale a dire memorizza le coppie chiave-valore. Nella terminologia iCloud il negozio è chiamato NSUbiquitousKeyValueStore. Iniziamo salvando i nostri segnalibri non solo a livello locale, ma anche su iCloud.
Vai al nostro saveBookmarks: metodo e modificare il nostro metodo per assomigliare a quello qui sotto. Iniziamo recuperando un riferimento allo store predefinito chiamando defaultStore sul NSUbiquitousKeyValueStore classe. Ancora una volta, questo è molto simile a NSUserDefaults. Se il nostro riferimento al negozio non è zero, archiviamo il nostro oggetto segnalibri nel negozio con la stessa chiave che abbiamo usato per memorizzare i nostri segnalibri nel database dei valori predefiniti dell'utente. Infine, sincronizziamo il negozio.
chiamata sincronizzare sull'istanza del negozio sincronizza le chiavi ei valori in memoria con quelli salvati sul disco. Potresti pensare che questo metodo costringa qualsiasi nuova coppia chiave-valore ad essere inviata ad iCloud, ma non è questo il caso. Salvando le chiavi in memoria sul disco, iCloud riceve notifica della disponibilità di nuove coppie chiave-valore da sincronizzare. Tuttavia, è il sistema operativo che alla fine decide quando è opportuno sincronizzare le coppie chiave-valore appena aggiunte con iCloud. Questo è importante da tenere a mente e questo è anche il motivo per cui le modifiche apportate su un dispositivo non saranno immediatamente visibili su un altro dispositivo.
Inoltre, anche se abbiamo chiamato il sincronizzato metodo sull'istanza del negozio, questo non è necessario nella maggior parte delle situazioni. Il sistema operativo fa questo per te nei momenti appropriati. Lo sapevi NSUserDefaults ha un sincronizzare metodo che funziona quasi in modo identico?
Ci si potrebbe chiedere come la nostra applicazione sappia quando un altro dispositivo ha aggiornato il Key-Value Store in iCloud e come può apportare tali modifiche. Questa è un'ottima domanda e questo è l'ultimo tassello del puzzle.
Ogni volta che l'archivio valori-chiave è stato modificato, viene inviata una notifica e la nostra applicazione può registrarsi come un obesante per queste notifiche. È importante che ti registri per tali notifiche il prima possibile nel ciclo di vita della tua applicazione.
Vediamo come funziona. Nel nostro viewDidLoad metodo facciamo quattro cose. Innanzitutto, otteniamo un riferimento al Key-Value Store. In secondo luogo, aggiungiamo il nostro controller di visualizzazione come osservatore per qualsiasi notifica con un nome di NSUbiquitousKeyValueStoreDidChangeExternallyNotification inviato dal Key-Value Store. Quando riceviamo tale notifica gestiremo questa notifica nel nostro updateKeyValuePairs: metodo (che scriveremo in un momento). Successivamente, inviamo al negozio un messaggio di sincronizzare. Finalmente, carichiamo i segnalibri come facevamo prima.
Tutto ciò che resta da fare è implementare il updateKeyValuePairs: metodo. Facciamolo adesso. La notifica userInfo dizionario contiene due importanti coppie chiave-valore, (1) il ragionare perché la notifica è stata inviata e (2) il chiavi nel Key-Value Store i cui valori sono stati modificati. Iniziamo dando uno sguardo più da vicino al motivo della notifica. Prima assicuriamo che sia stato specificato un motivo e restituisca se non è stato specificato alcun motivo. Se una ragione è stata effettivamente specificata, procediamo solo se il motivo era o una modifica sul server (NSUbiquitousKeyValueStoreServerChange) o le modifiche locali sono state scartate a causa di una sincronizzazione iniziale con il server (NSUbiquitousKeyValueStoreInitialSyncChange). Se uno di questi criteri viene soddisfatto, estraiamo la serie di chiavi che sono state modificate e iteriamo sulle chiavi per vedere se la chiave dei segnalibri è tra queste. In tal caso, prendiamo il valore associato alla chiave e aggiorniamo la nostra origine dati e il database dei valori predefiniti dell'utente con questo valore. Infine, ricarichiamo la vista tabella per riflettere le modifiche.
- (void) updateKeyValuePairs: notifica (NSNotification *) NSDictionary * userInfo = [notifica userInfo]; NSNumber * changeReason = [userInfo objectForKey: NSUbiquitousKeyValueStoreChangeReasonKey]; Motivo NSInteger = -1; // è un motivo specificato? se (! changeReason) return; else reason = [changeReason integerValue]; // Procedi se il motivo era (1) Modifiche al server o (2) Sincronizzazione iniziale if ((motivo == NSUbiquitousKeyValueStoreServerChange) || (motivo == NSUbiquitousKeyValueSitoneInitialSyncChange)) NSArray * changedKeys = [userInfo objectForKey: NSUbiquitousKeyValueStoreChangedKeysKey]; NSUbiquitousKeyValueStore * store = [NSUbiquitousKeyValueStore defaultStore]; // Cerca chiavi per "segnalibri" Chiave per (chiave NSString * in chiavi modificate) if ([chiave isEqualToString: @ "segnalibri"]) // Aggiorna origine dati self.bookmarks = [NSMutableArray arrayWithArray: [store objectForKey: key] ]; // Salva copia locale NSUserDefaults * ud = [NSUserDefaults standardUserDefaults]; [ud setObject: self.bookmarks forKey: @ "segnalibri"]; // Reload Table View [self.tableView reloadData];
Ci sono due punti che richiedono un'attenzione speciale. Innanzitutto, come abbiamo visto nella realizzazione di updateKeyValuePairs:, riceviamo un array contenente tutte le chiavi nel Key-Value Store con i valori che sono stati modificati. Si tratta di un'opzione per impedire a iCloud di inviare una notifica per ogni coppia di valori-chiave modificata. In secondo luogo, si consiglia vivamente di archiviare tutti i dati dal Key-Value Store localmente. Il database predefinito dell'utente è adatto per questo scopo, ma sei libero di scegliere qualsiasi soluzione adatta alle tue esigenze. La ragione per archiviare una copia locale è di non fare affidamento su iCloud per l'archiviazione dei dati. Non tutti gli utenti avranno un account iCloud o avranno abilitato iCloud sul proprio dispositivo.
Con questo ultimo pezzo di codice, la nostra applicazione è ora abilitata per iCloud. Crea ed esegui la tua applicazione su due dispositivi e testala tu stesso. Si noti che le modifiche non sono istantanee. Le modifiche devono essere sincronizzate con i server iCloud e successivamente inviate ai dispositivi appropriati che richiedono l'aggiornamento.
Anche se questo tutorial è lungo, l'implementazione di iCloud Key-Value Storage non richiede molto codice aggiuntivo. Come ho scritto nel tutorial precedente, l'adozione di Key-Value Storage è semplice, intuitiva e richiede un piccolo overhead da parte dell'utente.
Conclusione
Prima di concludere questo tutorial, desidero ribadire i pro e i contro di iCloud Key-Value Storage poiché sono importanti da tenere a mente. Ormai i professionisti sono ovvi, è facile da adottare, veloce da implementare e somiglia molto a come NSUserDefaults lavori. Tuttavia, è anche importante tenere a mente gli aspetti negativi. Le coppie valore-chiave sono quelle che sono. Cioè, coppie semplici senza alcuna forma di gestione dei conflitti a meno che non si implementi la propria logica di gestione dei conflitti. Quest'ultimo non è raccomandato in quanto il Key-Value Storage non è stato creato pensando a questo. Document Storage fornisce un supporto integrato per i conflitti ed è quindi un'opzione molto migliore se si richiede la gestione dei conflitti. Infine, non dimenticare che lo Storage valore-chiave può contenere solo 1 MB di dati con un massimo di 1024 coppie chiave-valore. Anche se abbiamo adottato Key-Value Storage in questa applicazione a scopo illustrativo, non possiamo garantire che non ci sarà mai un utente con un elenco di segnalibri che supera il limite di 1 MB.
Voglio anche sottolineare che lo scopo della nostra applicazione è mostrarti come adottare Key-Value Storage e come funziona dietro le quinte. Questa non è in alcun modo un'applicazione pronta per il rilascio in qu
Share
Accentsconagua
