寻求支持删除与订阅功能的Core Data与CloudKit公共数据库双向同步可用实现方案及问题排查

Hey there, let’s work through your CloudKit + Core Data sync headaches—this stuff can be notoriously finicky, especially with public databases. I’ve wrestled with similar flakiness before, so here’s a breakdown of fixes and checks tailored to your situation:

1. Fix Subscription Instability #

Your current code creates the subscription during persistent container initialization, which can run into timing issues (the container might not be fully ready to interact with CloudKit yet). Let’s adjust that and add safeguards to avoid duplicate subscriptions:

Key Changes: #

• Move subscription setup after the persistent store finishes loading
• Check for existing subscriptions before creating/updating (prevents duplicates that can cause silent failures)
• Add basic retry logic for subscription saves

Here’s revised code for your container and subscription setup:

lazy var persistentContainer: NSPersistentCloudKitContainer = {
    let container = NSPersistentCloudKitContainer(name: "PublicDB")
    guard let store = container.persistentStoreDescriptions.first else {
        fatalError("No persistent store description found")
    }
    let storesURL = store.url!.deletingLastPathComponent()
    store.url = storesURL.appendingPathComponent("public.sqlite")
    store.setOption(true as NSNumber, forKey: NSPersistentHistoryTrackingKey)
    store.setOption(true as NSNumber, forKey: NSPersistentStoreRemoteChangeNotificationPostOptionKey)
    store.cloudKitContainerOptions?.databaseScope = .public
    container.viewContext.automaticallyMergesChangesFromParent = true
    container.viewContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
    
    // Load stores first, then set up subscriptions
    container.loadPersistentStores(completionHandler: { (storeDescription, error) in
        guard let error = error as NSError? else {
            self.setupCloudKitPublicSubscription()
            return
        }
        fatalError("###\(#function): Failed to load persistent stores:\(error)")
    })
    
    return container
}()

private func setupCloudKitPublicSubscription() {
    let database = CKContainer(identifier: "iCloud.com.xxxxxx.DemoApp").publicCloudDatabase
    let subscriptionID = "PublicDB_MyEntity_Subscription"
    
    // Check if subscription already exists
    database.fetch(withSubscriptionID: subscriptionID) { [weak self] subscription, error in
        guard let self = self else { return }
        if let error = error {
            // Create subscription if it doesn't exist
            if (error as NSError).code == CKError.notFound.rawValue {
                self.createPublicSubscription(in: database, withID: subscriptionID)
            } else {
                print("Failed to fetch subscription: \(error.localizedDescription)")
                // Add retry logic here (e.g., DispatchQueue.main.asyncAfter)
            }
        } else if let existingSub = subscription as? CKQuerySubscription {
            // Update if existing subscription has outdated settings
            let needsUpdate = existingSub.options != [.firesOnRecordCreation, .firesOnRecordDeletion, .firesOnRecordUpdate] ||
                              existingSub.notificationInfo?.shouldSendContentAvailable != true
            if needsUpdate {
                self.updatePublicSubscription(existingSub, in: database)
            }
        }
    }
}

private func createPublicSubscription(in database: CKDatabase, withID subscriptionID: String) {
    let subscription = CKQuerySubscription(
        recordType: "CD_My_Entity",
        predicate: NSPredicate(value: true),
        subscriptionID: subscriptionID,
        options: [.firesOnRecordCreation, .firesOnRecordDeletion, .firesOnRecordUpdate]
    )
    let notification = CKSubscription.NotificationInfo()
    notification.shouldSendContentAvailable = true
    notification.alertBody = "There's a new change in the db."
    notification.soundName = "default"
    subscription.notificationInfo = notification
    
    database.save(subscription) { _, error in
        if let error = error {
            print("<<<<<<<<<<")
            print("Failed to save subscription: \(error.localizedDescription)")
            print(">>>>>>>>>>")
            // Retry after a short delay if needed
            DispatchQueue.main.asyncAfter(deadline: .now() + 5) {
                self.createPublicSubscription(in: database, withID: subscriptionID)
            }
        } else {
            print("Public subscription created successfully")
        }
    }
}

private func updatePublicSubscription(_ subscription: CKQuerySubscription, in database: CKDatabase) {
    subscription.options = [.firesOnRecordCreation, .firesOnRecordDeletion, .firesOnRecordUpdate]
    let notification = CKSubscription.NotificationInfo()
    notification.shouldSendContentAvailable = true
    notification.alertBody = "There's a new change in the db."
    notification.soundName = "default"
    subscription.notificationInfo = notification
    
    database.save(subscription) { _, error in
        if let error = error {
            print("Failed to update subscription: \(error.localizedDescription)")
        } else {
            print("Public subscription updated successfully")
        }
    }
}

2. Fix Sync & Deletion Issues #

Core Data + CloudKit sync relies on proper handling of remote change notifications. Make sure your AppDelegate is set up to listen for and merge these changes:

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    // Register for remote notifications
    UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound]) { granted, _ in
        if granted {
            DispatchQueue.main.async {
                application.registerForRemoteNotifications()
            }
        }
    }
    
    // Listen for Core Data remote changes
    NotificationCenter.default.addObserver(
        self,
        selector: #selector(handleRemoteStoreChange(_:)),
        name: .NSPersistentStoreRemoteChange,
        object: persistentContainer.persistentStoreCoordinator
    )
    
    return true
}

@objc private func handleRemoteStoreChange(_ notification: Notification) {
    // Merge remote changes into the view context
    persistentContainer.viewContext.perform {
        do {
            try self.persistentContainer.viewContext.save()
        } catch {
            print("Failed to merge remote changes: \(error.localizedDescription)")
        }
    }
}

func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    // Let CloudKit process the notification trigger
    if CKNotification(fromRemoteNotificationDictionary: userInfo) != nil {
        persistentContainer.persistentStoreCoordinator.performAndWait {
            completionHandler(.newData)
        }
    } else {
        completionHandler(.noData)
    }
}

Additional Checks for Deletion Sync: #

• Ensure your Core Data entities have CloudKit record types correctly mapped (check the Data Model inspector for your entity)
• Verify that your CloudKit public database permissions allow deletions (check the Apple Developer Portal > CloudKit Dashboard > Your Container > Security)

3. Address Simulator vs. Real Device Inconsistencies #

Simulators are great for development but have limitations with iCloud:

• Always log into iCloud on the simulator (Settings > Apple ID)
• Enable background app refresh for your App on the simulator
• Restart the simulator after changing notification or iCloud settings—they often don’t pick up changes immediately
• For reliable sync testing, prioritize real devices

4. Your iCloud Environment Hypothesis is Likely Correct #

Flaky sync that works randomly without code changes is almost always tied to Apple’s iCloud development infrastructure. Here’s how to debug:

• Check the CloudKit Dashboard (Apple Developer Portal) for logs—look for subscription failures, sync errors, or throttling warnings
• Try resetting your CloudKit development container (warning: this deletes all test data) to clear any stuck state
• Note that iCloud sync can have delays (especially in development) — give it 5-10 minutes before assuming it’s broken

内容的提问来源于stack exchange，提问作者zeeshan