DogCoffee DogCoffee - 1 month ago 8
Swift Question

Swift Ensembles Set Up & ubiquityContainerIdentifier

The book states,


“An ensemble identifier is used to match stores across devices. It is
important that this be the same for each store in the ensemble.”


let ensembleFileSystem = CDEICloudFileSystem(ubiquityContainerIdentifier: "???")


Does this need to be unique for all users ? or just for my application?

If anyone has a Swift version of how the set up Ensembles that would be great.

What I have so far, is this all that is needed?

func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {

let ensembleFileSystem = CDEICloudFileSystem(ubiquityContainerIdentifier: "???")

let modelURL = NSBundle.mainBundle().URLForResource("DataModel", withExtension: "momd")!
let url = applicationDocumentsDirectory.URLByAppendingPathComponent("SingleViewCoreData.sqlite")

let ensemble = CDEPersistentStoreEnsemble(ensembleIdentifier: "mainstore", persistentStoreURL: url, managedObjectModelURL: modelURL, cloudFileSystem: ensembleFileSystem!)


if !ensemble.leeched {
ensemble.leechPersistentStoreWithCompletion { (error) -> Void in
if error != nil {
print("cannot leech")
print(error!.localizedDescription)
}
}
}

NSNotificationCenter.defaultCenter().addObserver(self, selector: "syncWithCompletion:", name: CDEMonitoredManagedObjectContextDidSaveNotification, object: nil)
NSNotificationCenter.defaultCenter().addObserver(self, selector: "syncWithCompletion:", name: CDEICloudFileSystemDidDownloadFilesNotification, object: nil)

return true
}

func syncWithCompletion(notification:NSNotification) {
print("synced \(notification)")
managedObjectContext.mergeChangesFromContextDidSaveNotification(notification)
}


Something is missing Im getting this error log

User is not logged into iCloud


Despite being logged in as evident

print(NSFileManager.defaultManager().ubiquityIdentityToken)


Not being nil

Answer

Got it to work in the end - found example apps in 1.0 Git

I belive I was leeching to fast - not giving enough time for the set up process to complete.

Support this framework - buy ensembles 2, if you like ver 1.

Update .. easier way

I just use the normal core data stack apple provides.

Here is the extras to get ensembles working.

var ensemble:CDEPersistentStoreEnsemble!

func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {

    let file = CDEICloudFileSystem(ubiquityContainerIdentifier: nil)
    let modelURL = NSBundle.mainBundle().URLForResource("DataModel", withExtension: "momd")!
    let storeurl = self.applicationDocumentsDirectory.URLByAppendingPathComponent("store.sqlite")
    ensemble = CDEPersistentStoreEnsemble(ensembleIdentifier: "MyStoreName", persistentStoreURL: storeurl, managedObjectModelURL: modelURL, cloudFileSystem: file)
    ensemble.delegate = self

    NSNotificationCenter.defaultCenter().addObserver(self, selector: "localSaveOccurred:", name: CDEMonitoredManagedObjectContextDidSaveNotification, object: nil)
    NSNotificationCenter.defaultCenter().addObserver(self, selector: "cloudDataDidDownload:", name: CDEICloudFileSystemDidDownloadFilesNotification, object: nil)

    syncWithCompletion { completed in
        if completed {
            print("SUCCESSS")
        }
        else {
            print("FAIL")
        }
    }

    return true
}

// MARK: - Sync

func applicationDidEnterBackground(application: UIApplication) {
    print("Did Enter Background Save from App Delegate")

    let identifier = UIApplication.sharedApplication().beginBackgroundTaskWithExpirationHandler(nil)
    saveContext()

    syncWithCompletion { (completed) -> Void in
        if completed {
            UIApplication.sharedApplication().endBackgroundTask(identifier)
        }
    }
}

func applicationWillEnterForeground(application: UIApplication) {
    syncWithCompletion { (completed) -> Void in

    }
}

func localSaveOccurred(note:NSNotification) {
    syncWithCompletion { (completed) -> Void in

    }
}

func cloudDataDidDownload(note:NSNotification) {
    syncWithCompletion { (completed) -> Void in
        print("items from iCloud arrived")
    }
}

func syncWithCompletion(completion:(completed:Bool) -> Void) {

    UIApplication.sharedApplication().networkActivityIndicatorVisible = true

    if !ensemble.leeched {
        ensemble.leechPersistentStoreWithCompletion(nil)
    }
    else {
        ensemble.mergeWithCompletion{ error in
            if error != nil {
                print("cannot merge \(error!.localizedDescription)")
                UIApplication.sharedApplication().networkActivityIndicatorVisible = false
                completion(completed: false)
            }
            else {
                print("merged")
                UIApplication.sharedApplication().networkActivityIndicatorVisible = false
                completion(completed: true)
            }
        }
    }
}

// MARK: - Ensemble Delegate Methods

func persistentStoreEnsemble(ensemble: CDEPersistentStoreEnsemble!, didSaveMergeChangesWithNotification notification: NSNotification!) {

    managedObjectContext.performBlockAndWait { () -> Void in
        self.managedObjectContext.mergeChangesFromContextDidSaveNotification(notification)
    }
}

func persistentStoreEnsemble(ensemble: CDEPersistentStoreEnsemble!, globalIdentifiersForManagedObjects objects: [AnyObject]!) -> [AnyObject]! {
    return (objects as NSArray).valueForKeyPath("uniqueIdentifier") as! [AnyObject]
}

My First Way

Here it is in Swift, with a few extras

var ensemble:CDEPersistentStoreEnsemble!
var cloudFileSystem:CDEICloudFileSystem!
var managedObjectContext: NSManagedObjectContext!

func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
    // Override point for customization after application launch.

    setUpCoreData()

    let modelURL = NSBundle.mainBundle().URLForResource("YourDataModel", withExtension: "momd")!
    cloudFileSystem = CDEICloudFileSystem(ubiquityContainerIdentifier:"USE_YOUR_APPS_REVERSE DOMAIN NAME HERE")

From the developer: RE ubiquityContainerIdentifier

This is not part of Ensembles per se. It is from iCloud. Every app using iCloud has to have a ubiquity container id. You can find it in your app settings when you enable iCloud. It is unique per app, and we only use it if you are choosing for iCloud (eg not Dropbox).

    ensemble = CDEPersistentStoreEnsemble(ensembleIdentifier: "store", persistentStoreURL: storeURL(), managedObjectModelURL: modelURL, cloudFileSystem: cloudFileSystem!)
    ensemble.delegate = self

    NSNotificationCenter.defaultCenter().addObserver(self, selector: "localSaveOccurred:", name: CDEMonitoredManagedObjectContextDidSaveNotification, object: nil)
    NSNotificationCenter.defaultCenter().addObserver(self, selector: "cloudDataDidDownload:", name: CDEICloudFileSystemDidDownloadFilesNotification, object: nil)

    syncWithCompletion { completed in
        if completed {
            print("SUCCESSS")
        }
        else {
            print("FAIL")
        }
    }

    return true
}

// MARK: - Core Data Stack

func setUpCoreData() {

    let modelURL = NSBundle.mainBundle().URLForResource("DataModel", withExtension: "momd")!
    guard let model = NSManagedObjectModel(contentsOfURL: modelURL) else { fatalError("cannot use model") }

    do {
        try NSFileManager.defaultManager().createDirectoryAtURL(storeDirectoryURL(), withIntermediateDirectories: true, attributes: nil)
    }
    catch {
        fatalError("cannot create dir")
    }

    let coordinator = NSPersistentStoreCoordinator(managedObjectModel: model)
    //NSDictionary *options = @{NSMigratePersistentStoresAutomaticallyOption: @YES, NSInferMappingModelAutomaticallyOption: @YES};

    let failureReason = "There was an error creating or loading the application's saved data."

    do {
        try coordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: storeURL(), options: nil)

        managedObjectContext = NSManagedObjectContext.init(concurrencyType: .MainQueueConcurrencyType)
        managedObjectContext.persistentStoreCoordinator = coordinator
        managedObjectContext.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy

    } catch {
        // Report any error we got.
        var dict = [String: AnyObject]()
        dict[NSLocalizedDescriptionKey] = "Failed to initialize the application's saved data"
        dict[NSLocalizedFailureReasonErrorKey] = failureReason

        dict[NSUnderlyingErrorKey] = error as NSError
        let wrappedError = NSError(domain: "YOUR_ERROR_DOMAIN", code: 9999, userInfo: dict)
        // Replace this with code to handle the error appropriately.
        // abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
        NSLog("Unresolved error \(wrappedError), \(wrappedError.userInfo)")
        abort()
    }
}

func storeDirectoryURL() -> NSURL {

    let directoryURL = try! NSFileManager.defaultManager().URLForDirectory(.DocumentDirectory, inDomain: .UserDomainMask, appropriateForURL: nil, create: true)
    return directoryURL
}

func storeURL() -> NSURL {
    let url = storeDirectoryURL().URLByAppendingPathComponent("store.sqlite")
    return url
}


// MARK: - Sync

func applicationDidEnterBackground(application: UIApplication) {
    print("Did Enter Background Save from App Delegate")

    let identifier = UIApplication.sharedApplication().beginBackgroundTaskWithExpirationHandler(nil)
    saveContext()

    syncWithCompletion { (completed) -> Void in
        if completed {
            UIApplication.sharedApplication().endBackgroundTask(identifier)
        }
    }
}

func applicationWillEnterForeground(application: UIApplication) {
    syncWithCompletion { (completed) -> Void in

    }
}

func localSaveOccurred(note:NSNotification) {
    syncWithCompletion { (completed) -> Void in

    }
}

func cloudDataDidDownload(note:NSNotification) {
    syncWithCompletion { (completed) -> Void in

    }
}

func syncWithCompletion(completion:(completed:Bool) -> Void) {

    if !ensemble.leeched {
        ensemble.leechPersistentStoreWithCompletion { error in
            if error != nil {
                print("cannot leech \(error!.localizedDescription)")
                completion(completed: false)
            }
            else {
                print("leached!!")
                completion(completed: true)
            }
        }
    }
    else {
        ensemble.mergeWithCompletion{ error in
            if error != nil {
                print("cannot merge \(error!.localizedDescription)")
                completion(completed: false)
            }
            else {
                print("merged!!")
                completion(completed: true)
            }
        }
    }
}

// MARK: - Ensemble Delegate Methods

func persistentStoreEnsemble(ensemble: CDEPersistentStoreEnsemble!, didSaveMergeChangesWithNotification notification: NSNotification!) {

    print("did merge changes with note")


    managedObjectContext.mergeChangesFromContextDidSaveNotification(notification)
}

func persistentStoreEnsemble(ensemble: CDEPersistentStoreEnsemble!, globalIdentifiersForManagedObjects objects: [AnyObject]!) -> [AnyObject]! {
    return (objects as NSArray).valueForKeyPath("uniqueIdentifier") as! [AnyObject]
}
Comments