Verwenden von iCloud mit Xamarin.iOS

Artikel
01/10/2024

Die iCloud-Speicher-API in iOS 5 ermöglicht Anwendungen das Speichern von Benutzerdokumenten und anwendungsspezifischen Daten an einem zentralen Speicherort und den Zugriff auf diese Elemente von allen Geräten des Benutzers.

Es stehen vier Speichertypen zur Verfügung:

Key-Value-Speicher – um kleine Datenmengen für Ihre Anwendung auf den anderen Geräten eines Benutzers freizugeben.
UIDocument-Speicher – zum Speichern von Dokumenten und anderen Daten im iCloud-Konto des Benutzers mithilfe einer Unterklasse von UIDocument.
CoreData - SQLite-Datenbankspeicher.
Einzelne Dateien und Verzeichnisse – zum Verwalten von vielen verschiedenen Dateien direkt im Dateisystem.

In diesem Dokument werden die ersten beiden Typen – Key-Value-Paare und UIDocument-Unterklassen – und die Verwendung dieser Features in Xamarin.iOS erläutert.

Wichtig

Apple stellt Tools zur Verfügung, die Entwickler dabei unterstützen, die Datenschutz-Grundverordnung (DSGVO) der Europäischen Union umzusetzen.

Anforderungen

Die neueste stabile Version von Xamarin.iOS
Xcode 10
Visual Studio für Mac oder Visual Studio 2019.

Vorbereiten der iCloud-Entwicklung

Anwendungen müssen für die Verwendung von iCloud sowohl im Apple Provisioning Portal als auch im Projekt selbst konfiguriert werden. Führen Sie vor der Entwicklung für iCloud (oder testen Sie die Beispiele) die folgenden Schritte aus.

So konfigurieren Sie eine Anwendung ordnungsgemäß für den Zugriff auf iCloud:

Suchen Sie Ihre TeamID – melden Sie sich bei developer.apple.com an, und besuchen Sie die Zusammenfassung Ihres Kontoentwicklerkontos im Member Center >>, um Ihre Team-ID (oder einzelne ID für einzelne Entwickler) zu erhalten. Es handelt sich um eine 10-Zeichen-Zeichenfolge ( z. B. A93A5CM278 ) – dies ist Teil des "Containerbezeichners".
Erstellen Sie eine neue App-ID – Führen Sie zum Erstellen einer App-ID die schritte aus, die im Abschnitt "Bereitstellung für Store-Technologien" des Leitfadens für die Gerätebereitstellung beschrieben sind, und überprüfen Sie unbedingt iCloud als zulässigen Dienst:

Erstellen Sie ein neues Bereitstellungsprofil : Führen Sie zum Erstellen eines Bereitstellungsprofils die schritte aus, die im Leitfaden zur Gerätebereitstellung beschrieben sind.
Fügen Sie den Containerbezeichner zu "Entitlements.plist " hinzu. Das Containerbezeichnerformat lautet TeamID.BundleID. Weitere Informationen finden Sie im Leitfaden zum Arbeiten mit Berechtigungen .
Konfigurieren der Projekteigenschaften – Stellen Sie in der Datei "Info.plist" sicher, dass der Bündelbezeichner der Paket-ID entspricht, die beim Erstellen einer App-ID festgelegt wurde. Die iOS-Bündelsignierung verwendet ein Bereitstellungsprofil, das eine App-ID mit dem iCloud-App-Dienst und die ausgewählte Datei "Benutzerdefinierte Berechtigungen" enthält. Dies kann alles in Visual Studio im Bereich "Projekteigenschaften" erfolgen.
Aktivieren Sie iCloud auf Ihrem Gerät – wechseln Sie zu Einstellungen > iCloud, und stellen Sie sicher, dass das Gerät angemeldet ist. Wählen Sie die Option "Dokumente und Daten " aus, und aktivieren Sie sie.
Sie müssen ein Gerät verwenden, um iCloud zu testen - es funktioniert nicht auf dem Simulator. Tatsächlich benötigen Sie wirklich zwei oder mehr Geräte, die alle mit derselben Apple-ID angemeldet sind, um iCloud in Aktion zu sehen.

Schlüsselwertspeicher

Schlüsselwertspeicher ist für kleine Datenmengen vorgesehen, die ein Benutzer auf allen Geräten speichern mag – z. B. die letzte Seite, die er in einem Buch oder Magazin angezeigt hat. Schlüsselwertspeicher sollte nicht zum Sichern von Daten verwendet werden.

Es gibt einige Einschränkungen, die Sie bei der Verwendung von Schlüsselwertspeicher beachten müssen:

Maximale Schlüsselgröße – Schlüsselnamen dürfen nicht länger als 64 Byte sein.
Maximale Wertgröße – Sie können nicht mehr als 64 KB in einem einzelnen Wert speichern.
Maximale Größe des Schlüsselwertspeichers für eine App – Anwendungen können maximal 64 KB Schlüsselwertdaten insgesamt speichern. Versuche, Schlüssel über diesen Grenzwert hinaus festzulegen, schlagen fehl, und der vorherige Wert wird beibehalten.
Datentypen – Nur grundlegende Typen wie Zeichenfolgen, Zahlen und Booleane können gespeichert werden.

Das iCloudKeyValue-Beispiel veranschaulicht, wie es funktioniert. Der Beispielcode erstellt einen Für jedes Gerät benannten Schlüssel: Sie können diesen Schlüssel auf einem Gerät festlegen und sehen, wie der Wert an andere weitergegeben wird. Außerdem wird ein Schlüssel namens "Freigegeben" erstellt, der auf jedem Gerät bearbeitet werden kann – wenn Sie auf vielen Geräten gleichzeitig bearbeiten, entscheidet iCloud, welcher Wert "gewinnt" (mithilfe eines Zeitstempels für die Änderung) und wird verteilt.

Dieser Screenshot zeigt das verwendete Beispiel. Wenn Änderungsbenachrichtigungen von iCloud empfangen werden, werden sie in der Bildlauftextansicht unten auf dem Bildschirm gedruckt und in den Eingabefeldern aktualisiert.

Festlegen und Abrufen von Daten

Dieser Code zeigt, wie ein Zeichenfolgenwert festgelegt wird.

var store = NSUbiquitousKeyValueStore.DefaultStore;
store.SetString("testkey", "VALUE IN THE CLOUD");  // key and value
store.Synchronize();

Durch Das Aufrufen von Synchronize wird sichergestellt, dass der Wert nur auf dem lokalen Datenträgerspeicher beibehalten wird. Die Synchronisierung mit iCloud erfolgt im Hintergrund und kann nicht durch Anwendungscode "erzwungen" werden. Bei guter Netzwerkkonnektivität erfolgt die Synchronisierung häufig innerhalb von 5 Sekunden, wenn das Netzwerk jedoch schlecht (oder getrennt) ist, kann ein Update viel länger dauern.

Sie können einen Wert mit diesem Code abrufen:

var store = NSUbiquitousKeyValueStore.DefaultStore;
display.Text = store.GetString("testkey");

Der Wert wird aus dem lokalen Datenspeicher abgerufen – diese Methode versucht nicht, iCloud-Server zu kontaktieren, um den "neuesten" Wert abzurufen. iCloud aktualisiert den lokalen Datenspeicher entsprechend seinem eigenen Zeitplan.

Löschen von Daten

Um ein Schlüssel-Wert-Paar vollständig zu entfernen, verwenden Sie die Remove-Methode wie folgt:

var store = NSUbiquitousKeyValueStore.DefaultStore;
store.Remove("testkey");
store.Synchronize();

Beobachten von Änderungen

Eine Anwendung kann auch Benachrichtigungen empfangen, wenn Werte von iCloud geändert werden, indem sie einen Beobachter zur NSNotificationCenter.DefaultCenter. Der folgende Code aus der KeyValueViewController.cs-MethodeViewWillAppear zeigt, wie Sie auf diese Benachrichtigungen lauschen und eine Liste erstellen, welche Schlüssel geändert wurden:

keyValueNotification =
NSNotificationCenter.DefaultCenter.AddObserver (
    NSUbiquitousKeyValueStore.DidChangeExternallyNotification, notification => {
    Console.WriteLine ("Cloud notification received");
    NSDictionary userInfo = notification.UserInfo;

    var reasonNumber = (NSNumber)userInfo.ObjectForKey (NSUbiquitousKeyValueStore.ChangeReasonKey);
    nint reason = reasonNumber.NIntValue;

    var changedKeys = (NSArray)userInfo.ObjectForKey (NSUbiquitousKeyValueStore.ChangedKeysKey);
    var changedKeysList = new List<string> ();
    for (uint i = 0; i < changedKeys.Count; i++) {
        var key = changedKeys.GetItem<NSString> (i); // resolve key to a string
        changedKeysList.Add (key);
    }
    // now do something with the list...
});

Ihr Code kann dann eine Aktion mit der Liste der geänderten Schlüssel ausführen, z. B. eine lokale Kopie davon aktualisieren oder die Benutzeroberfläche mit den neuen Werten aktualisieren.

Mögliche Änderungsgründe sind: ServerChange (0), InitialSyncChange (1) oder QuotaViolationChange (2). Sie können auf den Grund zugreifen und bei Bedarf eine andere Verarbeitung durchführen (z. B. müssen Sie möglicherweise einige Schlüssel als Ergebnis eines QuotaViolationChange entfernen).

Dokumentspeicher

iCloud Document Storage ist für die Verwaltung von Daten konzipiert, die für Ihre App (und für den Benutzer) wichtig sind. Es kann verwendet werden, um Dateien und andere Daten zu verwalten, die Ihre App ausführen muss, während gleichzeitig iCloud-basierte Sicherungs- und Freigabefunktionen auf allen Geräten des Benutzers bereitgestellt werden.

Dieses Diagramm zeigt, wie alles zusammenpasst. Jedes Gerät verfügt über Daten, die im lokalen Speicher (UbiquityContainer) gespeichert sind, und der iCloud-Daemon des Betriebssystems kümmert sich um das Senden und Empfangen von Daten in der Cloud. Der gesamte Dateizugriff auf den UbiquityContainer muss über FilePresenter/FileCoordinator erfolgen, um gleichzeitigen Zugriff zu verhindern. Die UIDocument Klasse implementiert diese für Sie. In diesem Beispiel wird gezeigt, wie UIDocument verwendet wird.

Im iCloudUIDoc-Beispiel wird eine einfache UIDocument Unterklasse implementiert, die ein einzelnes Textfeld enthält. Der Text wird in einer UITextView Datei gerendert, und Die Bearbeitungen werden von iCloud auf andere Geräte weitergegeben, wobei eine Benachrichtigung rot angezeigt wird. Der Beispielcode behandelt nicht komplexere iCloud-Features wie konfliktbehebung.

Dieser Screenshot zeigt die Beispielanwendung – nach dem Ändern des Texts und Drücken von UpdateChangeCount wird das Dokument über iCloud mit anderen Geräten synchronisiert.

Es gibt fünf Teile des iCloudUIDoc-Beispiels:

Zugriff auf den UbiquityContainer – ermitteln Sie, ob iCloud aktiviert ist, und wenn dies der Pfad zum iCloud-Speicherbereich Ihrer Anwendung ist.
Erstellen einer UIDocument-Unterklasse – Erstellen Sie eine Klasse zwischen dem iCloud-Speicher und den Modellobjekten.
Suchen und Öffnen von iCloud-Dokumenten – Verwenden NSFileManager und NSPredicate suchen Sie iCloud-Dokumente, und öffnen Sie sie.
Anzeigen von iCloud-Dokumenten – Verfügbarmachen von Eigenschaften, UIDocument sodass Sie mit UI-Steuerelementen interagieren können.
Speichern von iCloud-Dokumenten – Stellen Sie sicher, dass änderungen, die auf der Benutzeroberfläche vorgenommen wurden, auf Datenträger und iCloud gespeichert werden.

Alle iCloud-Vorgänge werden asynchron ausgeführt (oder sollten ausgeführt werden), sodass sie nicht blockiert werden, während sie darauf warten, dass etwas passiert. Im Beispiel werden drei verschiedene Möglichkeiten zum Ausführen dieser Vorgehensweise angezeigt:

Threads – im anfänglichen Aufruf GetUrlForUbiquityContainer erfolgt in AppDelegate.FinishedLaunching einem anderen Thread, um zu verhindern, dass der Standard Thread blockiert wird.

NotificationCenter – Registrierung für Benachrichtigungen bei asynchronen Vorgängen wie NSMetadataQuery.StartQuery "Abgeschlossen".

Vervollständigungshandler – Übergeben von Methoden, die beim Abschluss asynchroner Vorgänge ausgeführt werden sollen, z UIDocument.Open. B. .

Zugreifen auf den UbiquityContainer

Der erste Schritt bei der Verwendung des iCloud-Dokumentspeichers besteht darin, zu bestimmen, ob iCloud aktiviert ist und ob dies der Speicherort des "ubiquity-Containers" ist (das Verzeichnis, in dem iCloud-fähige Dateien auf dem Gerät gespeichert werden).

Dieser Code befindet sich in der AppDelegate.FinishedLaunching Methode des Beispiels.

// GetUrlForUbiquityContainer is blocking, Apple recommends background thread or your UI will freeze
ThreadPool.QueueUserWorkItem (_ => {
    CheckingForiCloud = true;
    Console.WriteLine ("Checking for iCloud");
    var uburl = NSFileManager.DefaultManager.GetUrlForUbiquityContainer (null);
    // OR instead of null you can specify "TEAMID.com.your-company.ApplicationName"

    if (uburl == null) {
        HasiCloud = false;
        Console.WriteLine ("Can't find iCloud container, check your provisioning profile and entitlements");

        InvokeOnMainThread (() => {
            var alertController = UIAlertController.Create ("No \uE049 available",
            "Check your Entitlements.plist, BundleId, TeamId and Provisioning Profile!", UIAlertControllerStyle.Alert);
            alertController.AddAction (UIAlertAction.Create ("OK", UIAlertActionStyle.Destructive, null));
            viewController.PresentViewController (alertController, false, null);
        });
    } else { // iCloud enabled, store the NSURL for later use
        HasiCloud = true;
        iCloudUrl = uburl;
        Console.WriteLine ("yyy Yes iCloud! {0}", uburl.AbsoluteUrl);
    }
    CheckingForiCloud = false;
});

Obwohl das Beispiel dies nicht tut, empfiehlt Apple, GetUrlForUbiquityContainer aufzurufen, wenn eine App in den Vordergrund kommt.

Erstellen einer UIDocument-Unterklasse

Alle iCloud-Dateien und Verzeichnisse (d. h. alle im UbiquityContainer-Verzeichnis gespeicherten) müssen mit NSFileManager-Methoden verwaltet werden, das NSFilePresenter-Protokoll implementieren und über ein NSFileCoordinator schreiben. Die einfachste Möglichkeit, das alles zu tun, ist nicht, sie selbst zu schreiben, sondern unterklassen-UIDocument, das alles für Sie erledigt.

Es gibt nur zwei Methoden, die Sie in einer UIDocument-Unterklasse implementieren müssen, um mit iCloud zu arbeiten:

LoadFromContents – übergibt die NSData des Dateiinhalts, damit Sie die Entpackung in Die Modellklasse/es entpacken können.
ContentsForType – Fordern Sie an, die NSData-Darstellung Ihrer Modellklasse/n anzugeben, die auf dem Datenträger (und in der Cloud) gespeichert werden soll.

Dieser Beispielcode aus iCloudUIDoc\MonkeyDocument.cs zeigt, wie UIDocument implementiert wird.

public class MonkeyDocument : UIDocument
{
    // the 'model', just a chunk of text in this case; must easily convert to NSData
    NSString dataModel;
    // model is wrapped in a nice .NET-friendly property
    public string DocumentString {
        get {
            return dataModel.ToString ();
        }
        set {
            dataModel = new NSString (value);
        }
    }
    public MonkeyDocument (NSUrl url) : base (url)
    {
        DocumentString = "(default text)";
    }
    // contents supplied by iCloud to display, update local model and display (via notification)
    public override bool LoadFromContents (NSObject contents, string typeName, out NSError outError)
    {
        outError = null;

        Console.WriteLine ("LoadFromContents({0})", typeName);

        if (contents != null)
            dataModel = NSString.FromData ((NSData)contents, NSStringEncoding.UTF8);

        // LoadFromContents called when an update occurs
        NSNotificationCenter.DefaultCenter.PostNotificationName ("monkeyDocumentModified", this);
        return true;
    }
    // return contents for iCloud to save (from the local model)
    public override NSObject ContentsForType (string typeName, out NSError outError)
    {
        outError = null;

        Console.WriteLine ("ContentsForType({0})", typeName);
        Console.WriteLine ("DocumentText:{0}",dataModel);

        NSData docData = dataModel.Encode (NSStringEncoding.UTF8);
        return docData;
    }
}

Das Datenmodell in diesem Fall ist sehr einfach - ein einzelnes Textfeld. Ihr Datenmodell kann beliebig komplex sein, z. B. ein XML-Dokument oder Binärdaten. Die primäre Rolle der UIDocument-Implementierung besteht darin, zwischen Ihren Modellklassen und einer NSData-Darstellung zu übersetzen, die auf dem Datenträger gespeichert/geladen werden kann.

Suchen und Öffnen von iCloud-Dokumenten

Die Beispiel-App behandelt nur eine einzelne Datei - test.txt - so erstellt der Code in AppDelegate.cs eine NSPredicate und NSMetadataQuery sucht speziell nach diesem Dateinamen. Die NSMetadataQuery Ausführung erfolgt asynchron und sendet nach Abschluss einer Benachrichtigung eine Benachrichtigung. DidFinishGathering wird vom Benachrichtigungsbeobachter aufgerufen, stoppt die Abfrage und ruft LoadDocument auf, die die UIDocument.Open Methode mit einem Abschlusshandler verwendet, um zu versuchen, die Datei zu laden und in einer MonkeyDocumentViewControlleranzuzeigen.

string monkeyDocFilename = "test.txt";
void FindDocument ()
{
    Console.WriteLine ("FindDocument");
    query = new NSMetadataQuery {
        SearchScopes = new NSObject [] { NSMetadataQuery.UbiquitousDocumentsScope }
    };

    var pred = NSPredicate.FromFormat ("%K == %@", new NSObject[] {
        NSMetadataQuery.ItemFSNameKey, new NSString (MonkeyDocFilename)
    });

    Console.WriteLine ("Predicate:{0}", pred.PredicateFormat);
    query.Predicate = pred;

    NSNotificationCenter.DefaultCenter.AddObserver (
        this,
        new Selector ("queryDidFinishGathering:"),
        NSMetadataQuery.DidFinishGatheringNotification,
        query
    );

    query.StartQuery ();
}

[Export ("queryDidFinishGathering:")]
void DidFinishGathering (NSNotification notification)
{
    Console.WriteLine ("DidFinishGathering");
    var metadataQuery = (NSMetadataQuery)notification.Object;
    metadataQuery.DisableUpdates ();
    metadataQuery.StopQuery ();

    NSNotificationCenter.DefaultCenter.RemoveObserver (this, NSMetadataQuery.DidFinishGatheringNotification, metadataQuery);
    LoadDocument (metadataQuery);
}

void LoadDocument (NSMetadataQuery metadataQuery)
{
    Console.WriteLine ("LoadDocument");

    if (metadataQuery.ResultCount == 1) {
        var item = (NSMetadataItem)metadataQuery.ResultAtIndex (0);
        var url = (NSUrl)item.ValueForAttribute (NSMetadataQuery.ItemURLKey);
        doc = new MonkeyDocument (url);

        doc.Open (success => {
            if (success) {
                Console.WriteLine ("iCloud document opened");
                Console.WriteLine (" -- {0}", doc.DocumentString);
                viewController.DisplayDocument (doc);
            } else {
                Console.WriteLine ("failed to open iCloud document");
            }
        });
    } // TODO: if no document, we need to create one
}

Anzeigen von iCloud-Dokumenten

Das Anzeigen eines UIDocument sollte sich nicht von einer anderen Modellklasse unterscheiden – Eigenschaften werden in UI-Steuerelementen angezeigt, möglicherweise vom Benutzer bearbeitet und dann wieder in das Modell geschrieben.

Im Beispiel "iCloudUIDoc\MonkeyDocumentViewController.cs " wird der MonkeyDocument-Text in einem UITextView. ViewDidLoad lauscht auf die in der MonkeyDocument.LoadFromContents Methode gesendete Benachrichtigung. LoadFromContents wird aufgerufen, wenn iCloud neue Daten für die Datei enthält, sodass die Benachrichtigung angibt, dass das Dokument aktualisiert wurde.

NSNotificationCenter.DefaultCenter.AddObserver (this,
    new Selector ("dataReloaded:"),
    new NSString ("monkeyDocumentModified"),
    null
);

Der Beispielcodebenachrichtigungshandler ruft eine Methode auf, um die Benutzeroberfläche zu aktualisieren – in diesem Fall ohne Konflikterkennung oder -auflösung.

[Export ("dataReloaded:")]
void DataReloaded (NSNotification notification)
{
    doc = (MonkeyDocument)notification.Object;
    // we just overwrite whatever was being typed, no conflict resolution for now
    docText.Text = doc.DocumentString;
}

Speichern von iCloud-Dokumenten

Um ein UIDocument zu iCloud hinzuzufügen, können Sie direkt (nur für neue Dokumente) aufrufen UIDocument.Save oder eine vorhandene Datei mithilfe NSFileManager.DefaultManager.SetUbiquitiousverschieben. Der Beispielcode erstellt ein neues Dokument direkt im ubiquity-Container mit diesem Code (hier gibt es zwei Abschlusshandler, eine für den Save Vorgang und eine für das Öffnen):

var docsFolder = Path.Combine (iCloudUrl.Path, "Documents"); // NOTE: Documents folder is user-accessible in Settings
var docPath = Path.Combine (docsFolder, MonkeyDocFilename);
var ubiq = new NSUrl (docPath, false);
var monkeyDoc = new MonkeyDocument (ubiq);
monkeyDoc.Save (monkeyDoc.FileUrl, UIDocumentSaveOperation.ForCreating, saveSuccess => {
Console.WriteLine ("Save completion:" + saveSuccess);
if (saveSuccess) {
    monkeyDoc.Open (openSuccess => {
        Console.WriteLine ("Open completion:" + openSuccess);
        if (openSuccess) {
            Console.WriteLine ("new document for iCloud");
            Console.WriteLine (" == " + monkeyDoc.DocumentString);
            viewController.DisplayDocument (monkeyDoc);
        } else {
            Console.WriteLine ("couldn't open");
        }
    });
} else {
    Console.WriteLine ("couldn't save");
}

Nachfolgende Änderungen am Dokument werden nicht direkt "gespeichert", sondern weisen darauf UIDocument hin, dass es sich geändert UpdateChangeCounthat, und es plant automatisch einen Speichervorgang auf dem Datenträger:

doc.UpdateChangeCount (UIDocumentChangeKind.Done);

Verwalten von iCloud-Dokumenten

Benutzer können iCloud-Dokumente im Verzeichnis "Dokumente" des "Ubiquity-Containers" außerhalb Ihrer Anwendung über Einstellungen verwalten. Sie können die Dateiliste anzeigen und zum Löschen wischen. Der Anwendungscode sollte in der Lage sein, die Situation zu behandeln, in der Dokumente vom Benutzer gelöscht werden. Speichern Sie keine internen Anwendungsdaten im Verzeichnis "Dokumente ".

Benutzer erhalten außerdem unterschiedliche Warnungen, wenn sie versuchen, eine iCloud-fähige Anwendung von ihrem Gerät zu entfernen, um sie über den Status von iCloud-Dokumenten im Zusammenhang mit dieser Anwendung zu informieren.

iCloud-Sicherung

Während die Sicherung in iCloud kein Feature ist, auf das entwickler direkt zugreifen können, kann sich die Art und Weise, wie Sie Ihre Anwendung entwerfen, auf die Benutzererfahrung auswirken. Apple bietet iOS-Datenspeicherrichtlinien für Entwickler, die in ihren iOS-Anwendungen befolgt werden sollen.

Am wichtigsten ist, ob Ihre App große Dateien speichert, die nicht vom Benutzer generiert werden (z. B. eine Magazinleseranwendung, die hunderte plus Megabytes an Inhalten pro Problem speichert). Apple bevorzugt, dass Sie diese Art von Daten nicht speichern, wo sie in iCloud gesichert werden und das iCloud-Kontingent des Benutzers unnötig füllen.

Anwendungen, die große Datenmengen wie diese speichern, sollten sie entweder in einem der Benutzerverzeichnisse speichern, die nicht gesichert sind (z. B. Speichert oder tmp) oder verwendet NSFileManager.SetSkipBackupAttribute , um ein Flag auf diese Dateien anzuwenden, sodass iCloud sie während sicherungsvorgängen ignoriert.

Zusammenfassung

In diesem Artikel wurde das neue iCloud-Feature eingeführt, das in iOS 5 enthalten ist. Es untersuchte die Schritte, die erforderlich sind, um Ihr Projekt für die Verwendung von iCloud zu konfigurieren, und lieferte dann Beispiele für die Implementierung von iCloud-Features.

Das Beispiel für den Schlüsselwertspeicher veranschaulicht, wie iCloud verwendet werden kann, um eine kleine Menge an Daten zu speichern, die der Speicherung von NSUserPreferences ähneln. Das UIDocument-Beispiel zeigt, wie komplexere Daten über iCloud auf mehreren Geräten gespeichert und synchronisiert werden können.

Schließlich wurde eine kurze Diskussion darüber aufgenommen, wie sich das Hinzufügen von iCloud Backup auf Ihr Anwendungsdesign auswirken sollte.