Ios15

Example/IceCream_Example/AppDelegate.swift

@@ -19,11 +19,16 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
 
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
 
-        syncEngine = SyncEngine(objects: [
-            SyncObject(type: Dog.self),
-            SyncObject(type: Cat.self),
-            SyncObject(type: Person.self, uListElementType: Cat.self)
-            ])
+        syncEngine = SyncEngine(
+            objects: [
+                SyncObject(type: Dog.self),
+                SyncObject(type: Cat.self),
+                SyncObject(type: Person.self, uListElementType: Cat.self)
+            ],
+            callback: { syncEngine in
+                syncEngine.pull(completionHandler: nil)
+                syncEngine.startObservingLocalAndRemoteChanges()
+            })
 
         /// If you wanna test public Database, comment the above syncEngine code and uncomment the following one
         /// Besides, uncomment Line 26 to 28 in Person.swift file

IceCream/Classes/DatabaseManagerProtocol.swift

@@ -34,9 +34,12 @@ protocol DatabaseManager: class {
 
     func createCustomZonesIfAllowed()
     func startObservingRemoteChanges()
+    func stopObservingRemoteChanges()
     func startObservingTermination()
+    func stopObservingTermination()
     func createDatabaseSubscriptionIfHaveNot()
     func registerLocalDatabase()
+    func unregisterLocalDatabase()
 
     func cleanUp()
 }
@@ -59,10 +62,27 @@ extension DatabaseManager {
                 self.container.fetchLongLivedOperation(withID: id, completionHandler: { [weak self](ope, error) in
                     guard let self = self, error == nil else { return }
                     if let modifyOp = ope as? CKModifyRecordsOperation {
-                        modifyOp.modifyRecordsCompletionBlock = { (_,_,_) in
-                            print("Resume modify records success!")
+                        if #available(iOS 15, *) {
+                            modifyOp.modifyRecordsResultBlock = { result in
+                                print("🍦 modify result: \(result)")
+                            }
+                        } else {
+                            modifyOp.modifyRecordsCompletionBlock = { (_,_,_) in
+                                print("🍦 Resume modify records success!")
+                            }
+                        }
+
+                        if let isFinished = ope?.isFinished, !isFinished {
+                            print("🍦 Cancel operation")
+                            ope?.cancel()
+                        }
+
+                        if #available(iOS 15, *) {
+                            print("🍦 Add fetched long-lived operation")
+                            self.database.add(modifyOp)
+                        } else {
+                            self.container.add(modifyOp)
                         }
-                        self.container.add(modifyOp)
                     }
                 })
             }
@@ -77,6 +97,10 @@ extension DatabaseManager {
             }
         })
     }
+
+    func stopObservingRemoteChanges() {
+        NotificationCenter.default.removeObserver(self, name: Notifications.cloudKitDataDidChangeRemotely.name, object: nil)
+    }
 
     /// Sync local data to CloudKit
     /// For more about the savePolicy: https://developer.apple.com/documentation/cloudkit/ckrecordsavepolicy
@@ -109,25 +133,30 @@ extension DatabaseManager {
 
             switch ErrorHandler.shared.resultType(with: error) {
             case .success:
+                print("🍦 Modify record completed")
                 DispatchQueue.main.async {
                     completion?(nil)
                 }
             case .retry(let timeToWait, _):
+                print("🍦 Modify record needs retry")
                 ErrorHandler.shared.retryOperationIfPossible(retryAfter: timeToWait) {
                     self.syncRecordsToCloudKit(recordsToStore: recordsToStore, recordIDsToDelete: recordIDsToDelete, completion: completion)
                 }
             case .chunk:
+                print("🍦 Modify record needs chunk")
                 /// CloudKit says maximum number of items in a single request is 400.
                 /// So I think 300 should be fine by them.
                 let chunkedRecords = recordsToStore.chunkItUp(by: 300)
                 for chunk in chunkedRecords {
                     self.syncRecordsToCloudKit(recordsToStore: chunk, recordIDsToDelete: recordIDsToDelete, completion: completion)
                 }
             default:
+                print("🍦 Modify record unhandled completion: \(error.debugDescription)")
                 return
             }
         }
-
+
+        print("🍦 Add operation: syncRecordsToCloudKit store \(recordsToStore.count) \(recordsToStore.first?.recordType ?? "unknown") objects, delete \(recordIDsToDelete.count) objects")
         database.add(modifyOpe)
     }
 

IceCream/Classes/PrivateDatabaseManager.swift

@@ -31,6 +31,7 @@ final class PrivateDatabaseManager: DatabaseManager {
 
         /// Only update the changeToken when fetch process completes
         changesOperation.changeTokenUpdatedBlock = { [weak self] newToken in
+            print("🍦 Database change token updated")
             self?.databaseChangeToken = newToken
         }
 
@@ -40,27 +41,33 @@ final class PrivateDatabaseManager: DatabaseManager {
             guard let self = self else { return }
             switch ErrorHandler.shared.resultType(with: error) {
             case .success:
+                print("🍦 Database fetch completed, token updated")
                 self.databaseChangeToken = newToken
                 // Fetch the changes in zone level
                 self.fetchChangesInZones(callback)
             case .retry(let timeToWait, _):
+                print("🍦 Database fetch needs retry")
                 ErrorHandler.shared.retryOperationIfPossible(retryAfter: timeToWait, block: {
                     self.fetchChangesInDatabase(callback)
                 })
             case .recoverableError(let reason, _):
                 switch reason {
                 case .changeTokenExpired:
+                    print("🍦 Database fetch token expired")
                     /// The previousServerChangeToken value is too old and the client must re-sync from scratch
                     self.databaseChangeToken = nil
                     self.fetchChangesInDatabase(callback)
                 default:
+                    print("🍦 Database fetch unhandled recoverable error: \(reason)")
                     return
                 }
             default:
+                print("🍦 Database unhandled completion: \(error.debugDescription)")
                 return
             }
         }
-
+
+        print("🍦 Add operation: fetchChangesInDatabase")
         database.add(changesOperation)
     }
 
@@ -90,7 +97,8 @@ final class PrivateDatabaseManager: DatabaseManager {
                 return
             }
         }
-
+
+        print("🍦 Add operation: createCustomZonesIfAllowed")
         database.add(modifyOp)
     }
 
@@ -110,6 +118,7 @@ final class PrivateDatabaseManager: DatabaseManager {
             self.subscriptionIsLocallyCached = true
         }
         createOp.qualityOfService = .utility
+        print("🍦 Add operation: createDatabaseSubscriptionIfHaveNot")
         database.add(createOp)
         #endif
     }
@@ -125,6 +134,18 @@ final class PrivateDatabaseManager: DatabaseManager {
 
         #endif
     }
+
+    func stopObservingTermination() {
+        #if os(iOS) || os(tvOS)
+
+        NotificationCenter.default.removeObserver(self, name: UIApplication.willTerminateNotification, object: nil)
+
+        #elseif os(macOS)
+
+        NotificationCenter.default.removeObserver(self, name: NSApplication.willTerminateNotification, object: nil)
+
+        #endif
+    }
 
     func registerLocalDatabase() {
         self.syncObjects.forEach { object in
@@ -133,12 +154,21 @@ final class PrivateDatabaseManager: DatabaseManager {
             }
         }
     }
+
+    func unregisterLocalDatabase() {
+        self.syncObjects.forEach { object in
+            DispatchQueue.main.async {
+                object.unregisterLocalDatabase()
+            }
+        }
+    }
 
     private func fetchChangesInZones(_ callback: ((Error?) -> Void)? = nil) {
         let changesOp = CKFetchRecordZoneChangesOperation(recordZoneIDs: zoneIds, optionsByRecordZoneID: zoneIdOptions)
         changesOp.fetchAllChanges = true
 
         changesOp.recordZoneChangeTokensUpdatedBlock = { [weak self] zoneId, token, _ in
+            print("🍦 Record zone \(zoneId) change token updated")
             guard let self = self else { return }
             guard let syncObject = self.syncObjects.first(where: { $0.zoneID == zoneId }) else { return }
             syncObject.zoneChangesToken = token
@@ -147,12 +177,14 @@ final class PrivateDatabaseManager: DatabaseManager {
         changesOp.recordChangedBlock = { [weak self] record in
             /// The Cloud will return the modified record since the last zoneChangesToken, we need to do local cache here.
             /// Handle the record:
+            print("🍦 Record zone \(record.recordID) changed")
             guard let self = self else { return }
             guard let syncObject = self.syncObjects.first(where: { $0.recordType == record.recordType }) else { return }
             syncObject.add(record: record)
         }
 
         changesOp.recordWithIDWasDeletedBlock = { [weak self] recordId, _ in
+            print("🍦 Record \(recordId) deleted")
             guard let self = self else { return }
             guard let syncObject = self.syncObjects.first(where: { $0.zoneID == recordId.zoneID }) else { return }
             syncObject.delete(recordID: recordId)
@@ -162,23 +194,28 @@ final class PrivateDatabaseManager: DatabaseManager {
             guard let self = self else { return }
             switch ErrorHandler.shared.resultType(with: error) {
             case .success:
+                print("🍦 Record zone \(zoneId) fetch completed, token updated")
                 guard let syncObject = self.syncObjects.first(where: { $0.zoneID == zoneId }) else { return }
                 syncObject.zoneChangesToken = token
             case .retry(let timeToWait, _):
+                print("🍦 Record zone \(zoneId) fetch needs retry")
                 ErrorHandler.shared.retryOperationIfPossible(retryAfter: timeToWait, block: {
                     self.fetchChangesInZones(callback)
                 })
             case .recoverableError(let reason, _):
                 switch reason {
                 case .changeTokenExpired:
+                    print("🍦 Record zone \(zoneId) token expired")
                     /// The previousServerChangeToken value is too old and the client must re-sync from scratch
                     guard let syncObject = self.syncObjects.first(where: { $0.zoneID == zoneId }) else { return }
                     syncObject.zoneChangesToken = nil
                     self.fetchChangesInZones(callback)
                 default:
+                    print("🍦 Record zone \(zoneId) unhandled recoverable error: \(reason)")
                     return
                 }
             default:
+                print("🍦 Record zone \(zoneId) unhandled completion: \(error.debugDescription)")
                 return
             }
         }
@@ -190,7 +227,8 @@ final class PrivateDatabaseManager: DatabaseManager {
             }
             callback?(error)
         }
-
+
+        print("🍦 Add operation: fetchChangesInZones")
         database.add(changesOp)
     }
 }

IceCream/Classes/PublicDatabaseManager.swift

@@ -54,6 +54,18 @@ final class PublicDatabaseManager: DatabaseManager {
 
         #endif
     }
+
+    func stopObservingTermination() {
+        #if os(iOS) || os(tvOS)
+
+        NotificationCenter.default.removeObserver(self, name: UIApplication.willTerminateNotification, object: nil)
+
+        #elseif os(macOS)
+
+        NotificationCenter.default.removeObserver(self, name: NSApplication.willTerminateNotification, object: nil)
+
+        #endif
+    }
 
     func registerLocalDatabase() {
         syncObjects.forEach { object in
@@ -62,6 +74,14 @@ final class PublicDatabaseManager: DatabaseManager {
             }
         }
     }
+
+    func unregisterLocalDatabase() {
+        self.syncObjects.forEach { object in
+            DispatchQueue.main.async {
+                object.unregisterLocalDatabase()
+            }
+        }
+    }
 
     // MARK: - Private Methods
     private func excuteQueryOperation(queryOperation: CKQueryOperation,on syncObject: Syncable, callback: ((Error?) -> Void)? = nil) {
@@ -89,7 +109,8 @@ final class PublicDatabaseManager: DatabaseManager {
                 break
             }
         }
-
+
+        print("🍦 Add operation: excuteQueryOperation")
         database.add(queryOperation)
     }
 
@@ -108,6 +129,7 @@ final class PublicDatabaseManager: DatabaseManager {
 
         }
         createOp.qualityOfService = .utility
+        print("🍦 Add operation: createSubscriptionInPublicDatabase")
         database.add(createOp)
         #endif
     }