You might want to add a local cache of CloudKit records to your app to support offline use of your app or to improve performance. Or you may already have a data store for your app and you'd like to add support for persisting that data in CloudKit as well.

The General Workflow

Clear cache on Mac manually. All the caches created by your apps by default are stored in the system Library or user Library folders. Thus, to clear cache on Mac, you should delete the contents of the following directories in Finder. Some Mac customers may need to temporary and cache files from Mac OS. Stores and fleeting archives can consolidate things like browser cache and history, messages cache, specific app temporary and cache files, incomplete downloads, and more. While most applications will easily manage cache and junk files, and Mac OS will manage some other cache.

After you configure your app to maintain a local cache, here is the general flow your app will follow:

When your app launches for the first time on a new device it will subscribe to changes in the user's private and shared databases.
When a user modifies their data locally on Device A your app will send those changes to CloudKit.
Your app will receive a push notification on the same user's Device B notifying it that there was a change made on the server.
Your app on Device B will ask the server for the changes that occurred since the last time it spoke with the server and then update its local cache with those changes.

Initializating the Container

Your app's initialization logic should run whenever your app launches. Your app should cache locally regardless of whether you've already created your zone(s) and subscriptions so that you aren't issuing unnecessary requests upon every launch.

First the code defines items to be used throughout this example.

Creating Custom Zone(s)

To use the change tracking functionality of CloudKit, you need to store your app data in a custom zone in the user's private database. You can create a custom zone by instantiating a CKModifyRecordZonesOperation object as shown below.

Subscribing to Change Notifications

Your app needs to subscribe to changes made from other devices. Subscriptions tell CloudKit which data you care about so that it can send push notifications to your app when that data changes.

Your app will need to create two subscriptions to database changes (CKDatabaseSubscription objects), one for the private database and one for the shared database.

These subscriptions tell CloudKit to send a push notification to your app on this device any time a record or zone is added, modified, or deleted within the database you created the subscription in.

You likely want to configure your subscriptions to send silent push notifications. These notifications wake your app so that it can fetch changes, but the app will not present an alert to the user.

Listening for Push Notifications

As part of configuring your app to use CloudKit, you will need to configure your app to listen for remote notifications.

Use CKNotification(fromRemoteNotificationDictionary: dict) on the userInfo dictionary to determine whether the remote notification your app receives was triggered by a CKSubscription.

Fetching Changes

After app launch or the receipt of a push, your app uses CKFetchDatabaseChangesOperation and then CKFetchRecordZoneChangesOperation to ask the server for only the changes since the last time it updated.

The key to these operations is the previousServerChangeToken object, which tells the server when your app last spoke to the server, allowing the server to return only the items that were changed since that time.

On Mac Can I Remove Library Caches Cloudkit

First your app will use a CKFetchDatabaseChangesOperation to find out which zones have changed and:

On mac can i remove library caches cloudkit software

Collect the IDs for the new and updated zones.
Clean up local data from zones that were deleted.

Here is some example code to fetch the database changes:

Next your app uses a CKFetchRecordZoneChangesOperation object with the set of zone IDs you just collected to do the following:

Create and update any changed records
Delete any records that no longer exist
Update the zone change tokens

Here is some example code to fetch the zone changes:

The code above has several comments about writing changes to memory and then later flushing those changes to disk. The general flow is as follows.

For databases:

When told about a zone deletion, write that into memory.
When told about a new change token for a database, write that token into memory, then either:
- persist all in-memory zone changes to disk (deleting deleted zones, and recording a list of zones that need changes fetched), or
- persist zone deletions to disk, and fetch changes for all modified record zones.
Note: When you are fetching database changes, you need to persist all of the per-zone callbacks you received before getting the database change token.
Finally, flush the updated database change token to disk

Similarly, for zones:

On Mac Can I Remove Library Caches Cloudkit Free

When told about a record change in a zone, write that into memory.
When told about a new change token for a zone, commit all in-memory record changes in that zone as well as the updated change token for that zone to disk.

Storing Record Metadata

To relate records in your local data store to records on the server, you will likely need to store the metadata for your records (record name, zone ID, change tag, creation date, and so on). There is a handy method on CKRecord, encodeSystemFieldsWithCoder, that helps you do this for system fields. You will still have to handle your own custom fields separately.

Here is an example of how your app can read the metadata in order to store it locally:

When sending changes to CloudKit based on your local data, you can read the local cache back into CloudKit objects and manipulate them for storage in CloudKit:

Advanced Local Caching

On Mac Can I Remove Library Caches Cloudkit Software

A user can delete your app's data on the CloudKit servers through iCloud Settings->Manage Storage. Your app needs to handle this gracefully and re-create the zone and subscriptions on the server again if they don't exist. The specific error returned in this case is userDeletedZone.

The operation dependency system outlined in the Advanced NSOperations talk from WWDC2015 is a great way to manage your CloudKit operations so that account and network statuses are checked and zones and subscriptions are created at the right time.

Mac Caches Delete

The network connection may disappear at any time, so make sure to properly handle networkUnavailable errors from any operation.

Watch for network reachability, and retry the operation when the network becomes available again.