维护CloudKit记录的本地缓存

您可能希望将CloudKit记录的本地缓存添加到您的应用，以支持离线使用您的应用或提高性能。或者您可能已经为您的应用程序提供了数据存储，并且您希望添加对在CloudKit中持久存储该数据的支持。

一般工作流程

配置应用程序以维护本地缓存后，以下是您的应用将遵循的常规流程：

当您的应用首次在新设备上启动时，它将订阅用户私有和共享数据库中的更改。
当用户在设备A上本地修改其数据时，您的应用会将这些更改发送到CloudKit。
您的应用将在同一用户的设备B上收到推送通知，通知它已在服务器上进行了更改。
您在设备B上的应用程序将询问服务器自上次与服务器通信后发生的更改，然后使用这些更改更新其本地缓存。

初始化容器

应用程序启动时，应用程序的初始化逻辑应该会运行。无论您是否已经创建了区域和订阅，您的应用都应该在本地缓存，这样您就不会在每次启动时发出不必要的请求。

首先，代码定义了整个示例中要使用的项目。

let container = CKContainer.default()
let privateDB = container.privateCloudDatabase
let sharedDB = container.sharedCloudDatabase
 
// Use a consistent zone ID across the user's devices
// CKCurrentUserDefaultName specifies the current user's ID when creating a zone ID
let zoneID = CKRecordZoneID(zoneName: "Todos", ownerName: CKCurrentUserDefaultName)
 
// Store these to disk so that they persist across launches
var createdCustomZone = false
var subscribedToPrivateChanges = false
var subscribedToSharedChanges = false
 
let privateSubscriptionId = "private-changes"
let sharedSubscriptionId = "shared-changes"

创建自定义区域

let createZoneGroup = DispatchGroup()
 
if !self.createdCustomZone {
    createZoneGroup.enter()
    
    let customZone = CKRecordZone(zoneID: zoneID)
    
    let createZoneOperation = CKModifyRecordZonesOperation(recordZonesToSave: [customZone], recordZoneIDsToDelete: [] )
    
    createZoneOperation.modifyRecordZonesCompletionBlock = { (saved, deleted, error) in
        if (error == nil) { self.createdCustomZone = true }
        // else custom error handling
        createZoneGroup.leave()
    }
    createZoneOperation.qualityOfService = .userInitiated
    
    self.privateDB.add(createZoneOperation)
}

订阅变更通知

您的应用需要订阅其他设备所做的更改。订阅会告知CloudKit您关注哪些数据，以便在数据发生变化时向您的应用发送推送通知。

if !self.subscribedToPrivateChanges {
    let createSubscriptionOperation = self.createDatabaseSubscriptionOperation(subscriptionId: privateSubscriptionId)
    createSubscriptionOperation.modifySubscriptionsCompletionBlock = { (subscriptions, deletedIds, error) in
        if error == nil { self.subscribedToPrivateChanges = true }
        // else custom error handling
    }
    self.privateDB.add(createSubscriptionOperation)
}
 
if !self.subscribedToSharedChanges {
    let createSubscriptionOperation = self.createDatabaseSubscriptionOperation(subscriptionId: sharedSubscriptionId)
    createSubscriptionOperation.modifySubscriptionsCompletionBlock = { (subscriptions, deletedIds, error) in
        if error == nil { self.subscribedToSharedChanges = true }
        // else custom error handling
    }
    self.sharedDB.add(createSubscriptionOperation)
}
 
// Fetch any changes from the server that happened while the app wasn't running
createZoneGroup.notify(queue: DispatchQueue.global()) {
    if self.createdCustomZone {
        self.fetchChanges(in: .private) {}
        self.fetchChanges(in: .shared) {}
    }
}

这些订阅告诉CloudKit只要在您创建订阅的数据库中添加，修改或删除记录或区域，就可以在此设备上向您的应用发送推送通知。

您可能希望配置订阅以发送静默推送通知。这些通知唤醒您的应用，以便它可以获取更改，但应用程序不会向用户显示警报。

func createDatabaseSubscriptionOperation(subscriptionId: String) -> CKModifySubscriptionsOperation {
    let subscription = CKDatabaseSubscription.init(subscriptionID: subscriptionId)
    
    let notificationInfo = CKNotificationInfo()
    // send a silent notification
    notificationInfo.shouldSendContentAvailable = true
    subscription.notificationInfo = notificationInfo
    
    let operation = CKModifySubscriptionsOperation(subscriptionsToSave: [subscription], subscriptionIDsToDelete: [])
    operation.qualityOfService = .utility
    
    return operation
}

倾听推送通知

在配置应用程序以使用CloudKit时，您需要配置应用程序以侦听远程通知。

CKNotification(fromRemoteNotificationDictionary: dict)在userInfo字典上使用以确定您的应用程序接收的远程通知是否由a触发CKSubscription。

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
    application.registerForRemoteNotifications()
    return true
}
 
func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    print("Received notification!")
    
    let viewController = self.window?.rootViewController as? ViewController
    guard let viewController = self.window?.rootViewController as? ViewController else { return }
    
    let dict = userInfo as! [String: NSObject]
    guard let notification:CKDatabaseNotification = CKNotification(fromRemoteNotificationDictionary:dict) as? CKDatabaseNotification else { return }
    
    viewController!.fetchChanges(in: notification.databaseScope) {
        completionHandler(.newData)
    }
}

获取更改

这些操作的关键是previousServerChangeToken对象，它告诉服务器您的应用程序上次与服务器通话的时间，允许服务器仅返回自那时以来更改的项目。

首先，您的应用将使用a CKFetchDatabaseChangesOperation来找出哪些区域已更改，并且：

收集新区域和更新区域的ID。
清除已删除区域中的本地数据。

以下是一些获取数据库更改的示例代码：

func fetchChanges(in databaseScope: CKDatabaseScope, completion: @escaping () -> Void) {
    switch databaseScope {
    case .private:
        fetchDatabaseChanges(database: self.privateDB, databaseTokenKey: "private", completion: completion)
    case .shared:
        fetchDatabaseChanges(database: self.sharedDB, databaseTokenKey: "shared", completion: completion)
    case .public:
        fatalError()
    }
}
 
func fetchDatabaseChanges(database: CKDatabase, databaseTokenKey: String, completion: @escaping () -> Void) {
    var changedZoneIDs: [CKRecordZoneID] = []
    
    let changeToken = … // Read change token from disk
    let operation = CKFetchDatabaseChangesOperation(previousServerChangeToken: changeToken)
    
    operation.recordZoneWithIDChangedBlock = { (zoneID) in
        changedZoneIDs.append(zoneID)
    }
    
    operation.recordZoneWithIDWasDeletedBlock = { (zoneID) in
        // Write this zone deletion to memory
    }
    
    operation.changeTokenUpdatedBlock = { (token) in
        // Flush zone deletions for this database to disk
        // Write this new database change token to memory
    }
    
    operation.fetchDatabaseChangesCompletionBlock = { (token, moreComing, error) in
        if let error = error {
            print("Error during fetch shared database changes operation", error)
            completion()
            return
        }
        // Flush zone deletions for this database to disk
        // Write this new database change token to memory
        
        self.fetchZoneChanges(database: database, databaseTokenKey: databaseTokenKey, zoneIDs: changedZoneIDs) {
            // Flush in-memory database change token to disk
            completion()
        }
    }
    operation.qualityOfService = .userInitiated
    
    database.add(operation)
}

创建和更新任何已更改的记录
删除不再存在的任何记录
更新区域更改令牌

以下是一些获取区域更改的示例代码：

func fetchZoneChanges(database: CKDatabase, databaseTokenKey: String, zoneIDs: [CKRecordZoneID], completion: @escaping () -> Void) {
    
    // Look up the previous change token for each zone
    var optionsByRecordZoneID = [CKRecordZoneID: CKFetchRecordZoneChangesOptions]()
    for zoneID in zoneIDs {
        let options = CKFetchRecordZoneChangesOptions()
        options.previousServerChangeToken = … // Read change token from disk
            optionsByRecordZoneID[zoneID] = options
    }
    let operation = CKFetchRecordZoneChangesOperation(recordZoneIDs: zoneIDs, optionsByRecordZoneID: optionsByRecordZoneID)
    
    operation.recordChangedBlock = { (record) in
        print("Record changed:", record)
        // Write this record change to memory
    }
    
    operation.recordWithIDWasDeletedBlock = { (recordId) in
        print("Record deleted:", recordId)
        // Write this record deletion to memory
    }
    
    operation.recordZoneChangeTokensUpdatedBlock = { (zoneId, token, data) in
        // Flush record changes and deletions for this zone to disk
        // Write this new zone change token to disk
    }
    
    operation.recordZoneFetchCompletionBlock = { (zoneId, changeToken, _, _, error) in
        if let error = error {
            print("Error fetching zone changes for \(databaseTokenKey) database:", error)
            return
        }
        // Flush record changes and deletions for this zone to disk
        // Write this new zone change token to disk
    }
    
    operation.fetchRecordZoneChangesCompletionBlock = { (error) in
        if let error = error {
            print("Error fetching zone changes for \(databaseTokenKey) database:", error)
        }
        completion()
    }
    
    database.add(operation)
}

上面的代码有几条关于将更改写入内存然后将这些更改刷新到磁盘的注释。一般流程如下。

对于数据库：

当被告知区域删除时，将其写入内存。
当被告知数据库的新变更令牌时，将该令牌写入内存，然后：
- 将所有内存中区域更改保留到磁盘（删除已删除的区域，并记录需要更改的区域列表），或
- 将区域删除保留到磁盘，并获取所有已修改记录区域的更改。
注意： 在获取数据库更改时，需要在获取数据库更改令牌之前保留所有收到的每个区域回调。
最后，将更新的数据库更改标记刷新到磁盘

同样，对于区域：

当被告知区域中的记录更改时，请将其写入内存。
当被告知区域的新变更令牌时，将该区域中的所有内存中记录更改以及该区域的更新变更令牌提交到磁盘。

存储记录元数据

以下是您的应用如何读取元数据以便在本地存储它的示例：

// obtain the metadata from the CKRecord
let data = NSMutableData()
let coder = NSKeyedArchiver.init(forWritingWith: data)
coder.requiresSecureCoding = true
record.encodeSystemFields(with: coder)
coder.finishEncoding()
 
// store this metadata on your local object
yourLocalObject.encodedSystemFields = data

根据您的本地数据向CloudKit发送更改时，您可以将本地缓存读回CloudKit对象并操作它们以便在CloudKit中存储：

// set up the CKRecord with its metadata
let coder = NSKeyedUnarchiver(forReadingWith: yourLocalObject.encodedSystemFields!)
coder.requiresSecureCoding = true
let record = CKRecord(coder: coder)
coder.finishDecoding()
// write your custom fields...

高级本地缓存

监视网络可访问性，并在网络再次可用时重试该操作。

也可以看看

Previous部署架构 Next文档修订历史

Last updated 5 years ago

Was this helpful?