There isn’t a single recommended approach by Apple, so all these methods are legit. However, NSUserDefaults is more appropriate for user preferences, rather than real data, and files may not be a good solution for all data scenarios. Therefore, if we have to choose, we will bet on Core Data, and today I am going to show you how you can send your Telerik Chart for iOS to the Apple Watch in the form of an image and a string stored in Core Data.

Creating the WatchKit app     

Creating the data proxy library     

1. With your iPhone app project opened in Xcode, go to File >> Target >> iOS >> Framework & Library >> Cocoa Touch Framework and click Next.
2. Name the library WatchCoreDataProxy and select Swift from the Language drop-down. Click Finish.
3. Right-click the WatchCoreDataProxy folder from the project structure panel and select New File >> iOS >> Core Data >> Data Model.
4. Name the model WatchModel and click Create. This will create your model file and will open the Model editor for you.
5. Create a new entity called ChartDataEntity and add two fields to the entity:           
   • imageBinaryData of type Binary Data
   • stringData of type String
      
      

Now it’s time to implement the code needed to talk to the SQLite db behind the Core Data. The core logic of this implementation is the boilerplate code that you get in the AppDelegate.swift file when you create a project clicking the Use Core Data checkbox. Basically, this core logic consists of the applicationDocumentsDirectory, managedObjectModel, persistentStoreCoordinator and managedObjectContext properties and the saveContext method.

So, let’s add these to the WatchCoreDataProxy.swift the following way:

1. Right-click the WatchCoreDataProxy folder >>New File >> iOS >> Source >> Swift File to create a new Swift file and name the file WatchCoreDataProxy.
2. Add the following code: 
   

   import CoreData
   
   public class WatchCoreDataProxy: NSObject {
       public var sharedAppGroup: NSString = ""
   
       // MARK: - Core Data stack
   
       lazy var applicationDocumentsDirectory: NSURL = {
   
           let urls = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)
           return urls[urls.count-1] as NSURL
           }()
   
       lazy var managedObjectModel: NSManagedObjectModel = {
   
           let proxyBundle = NSBundle(identifier: "com.telerik.WatchCoreDataProxy")
           let modelURL = proxyBundle?.URLForResource("WatchModel", withExtension: "momd")!
   
           return NSManagedObjectModel(contentsOfURL: modelURL!)!
           }()
   
       lazy var persistentStoreCoordinator: NSPersistentStoreCoordinator? = {
   
           let containerPath = NSFileManager.defaultManager().containerURLForSecurityApplicationGroupIdentifier(self.sharedAppGroup)?.path
           let sqlitePath = NSString(format: "%@/%@", containerPath!, "WatchModel")
           let url = NSURL(fileURLWithPath: sqlitePath);
   
           let  model = self.managedObjectModel;
   
           var coordinator: NSPersistentStoreCoordinator? = NSPersistentStoreCoordinator(managedObjectModel: model)
           var error: NSError? = nil
   
           var failureReason = "There was an error creating or loading the application's saved data."
           if coordinator!.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: url, options: nil, error: &error) == nil {
               coordinator = nil
               // 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
               error = NSError(domain: "YOUR_ERROR_DOMAIN", code: 9999, userInfo: dict)
   
               NSLog("Unresolved error \(error), \(error!.userInfo)")
               abort()
           }
   
           return coordinator
           }()
   
       lazy var managedObjectContext: NSManagedObjectContext? = {
   
           let coordinator = self.persistentStoreCoordinator
           if coordinator == nil {
               return nil
           }
           var managedObjectContext = NSManagedObjectContext()
           managedObjectContext.persistentStoreCoordinator = coordinator
           return managedObjectContext
           }()
   
       func saveContext () {
           if let moc = self.managedObjectContext {
               var error: NSError? = nil
               if moc.hasChanges && !moc.save(&error) {
                   NSLog("Unresolved error \(error), \(error!.userInfo)")
                   abort()
               }
           }
       }
   }

3. Next are the methods you have to implement in the WatchCoreDataProxy class to send data (image and text) from the iPhone app to the SQLite DB through Core Data, and the methods to fetch the saved data and expose it to the WatchKit app:  
   

    public class var sharedInstance : WatchCoreDataProxy {
           struct Static {
               static var onceToken : dispatch_once_t = 0
               static var instance : WatchCoreDataProxy? = nil
           }
           dispatch_once(&Static.onceToken) {
               Static.instance = WatchCoreDataProxy()
           }
   
           return Static.instance!
       }
   
       public func sendImageToWatch(image:UIImage){
           let imageData: NSData  = UIImagePNGRepresentation(image);
   
           let context = self.managedObjectContext
           let entity = NSEntityDescription.entityForName("ChartDataEntity", inManagedObjectContext: self.managedObjectContext!)
   
   
           var request = NSFetchRequest()
           request.entity = entity
           var error: NSError? = nil
           let results = self.managedObjectContext?.executeFetchRequest(request, error: &error)
           if(results?.count==0){
               let newManagedObject = NSEntityDescription.insertNewObjectForEntityForName("ChartDataEntity", inManagedObjectContext: context!) as NSManagedObject
   
               newManagedObject.setValue(imageData, forKey: "imageBinaryData")
   
           }else{
               let existingObject: NSManagedObject = results![0] as NSManagedObject
               existingObject.setValue(imageData, forKey: "imageBinaryData")
           }
   
           if !(context?.save(&error) != nil) {
               println("Unresolved error \(error), \(error?.userInfo)")
               abort()
           }
       }
   
       public func receiveImage()-> UIImage? {
   
           var request = NSFetchRequest()
           var entity = NSEntityDescription.entityForName("ChartDataEntity", inManagedObjectContext: self.managedObjectContext!)
           request.entity = entity
   
           var error: NSError? = nil
           let results = self.managedObjectContext?.executeFetchRequest(request, error: &error)
   
           var image: UIImage?
           if results != nil && results?.count > 0 {
               let managedObject: NSManagedObject = results![0] as NSManagedObject
               let myData: NSData? = managedObject.valueForKey("imageBinaryData") as? NSData
               image = UIImage(data: myData!)
           }
   
           return image
       }
       public func sendStringToWatch(stringData:NSString){
   
           let context = self.managedObjectContext
           let entity = NSEntityDescription.entityForName("ChartDataEntity", inManagedObjectContext: self.managedObjectContext!)
   
   
           var request = NSFetchRequest()
           request.entity = entity
           var error: NSError? = nil
           let results = self.managedObjectContext?.executeFetchRequest(request, error: &error)
           if(results?.count==0){
               let newManagedObject = NSEntityDescription.insertNewObjectForEntityForName("ChartDataEntity", inManagedObjectContext: context!) as NSManagedObject
   
               newManagedObject.setValue(stringData, forKey: "stringData")
   
           }else{
               let existingObject: NSManagedObject = results![0] as NSManagedObject
               existingObject.setValue(stringData, forKey: "stringData")
           }
   
           if !(context?.save(&error) != nil) {
               println("Unresolved error \(error), \(error?.userInfo)")
               abort()
           }
       }
   
       public func receiveString()-> NSString? {
   
           var request = NSFetchRequest()
           var entity = NSEntityDescription.entityForName("ChartDataEntity", inManagedObjectContext: self.managedObjectContext!)
           request.entity = entity
   
           var error: NSError? = nil
           let results = self.managedObjectContext?.executeFetchRequest(request, error: &error)
   
           var stringData: NSString?
           if results != nil && results?.count > 0 {
               let managedObject: NSManagedObject = results![0] as NSManagedObject
               stringData = managedObject.valueForKey("stringData") as? NSString
           }
   
           return stringData
       }

App Groups

Now that we have the iPhone app, the proxy library and the WatchKit app, it’s time to make sure that the iPhone app and the WatchKit app can actually share data. The thing that enables sharing data in whatever form between applications (Files, NSUserDefaults, CoreData) is called App Groups; both applications should be part of the same App Group. To enable the App Groups feature for both apps:     

1. Select the AppleWatchWithTelerikChart project from the project structure panel. 
2. Select the AppleWatchWithTelerikChart app target.
3. Go to Capabilities >> App Groups and turn that feature ON. You will be asked to select your Development Team/Account.
4. Check the group.watch.sample group. Of course, you can create your own group name, but for our demo purposes, we will use the default one. 
      
   
5. Select the AppleWatchWithTelerikChart WatchKit Extension target.
6. Go to Capabilities >> App Groups and turn that feature ON.
7. Check the group.watch.sample group. It is important for the name of that group to be the same as the name of the AppleWatchWithTelerikChart’s App Group. 
      

Sending and Getting the Data Using the Proxy Library