WatchConnectivity: Sharing All Data via User Info

Posted on October 21st, 2015

Check out previous blog posts on WatchOS 2 if you haven’t already:

Background data transfers via User Info should be done when you need to make sure that all your data is transferred (not just the latest like with Application Context). User Info data is queued up for delivery in a FIFO (first-in-first-out) order, so nothing is overwritten.

One examples for when you might want to use this is in a text messaging app – when the last message is just as important as the first to see the full conversation and context. Or if the user updated a few pieces of their profile information and all the changes need to be synced to the Watch profile.

For this tutorial, I’m going to walk through building a food emoji communication app because food and emoji! I LOVE 🍦!

Also, this could potentially be an Apple Watch based grocery list app – you select the food you plan to buy from the list of emojis on the phone, and it goes to the app, which you can then glance at as you shop at the grocery store!

emoji grocery store

Disclamer

Note that for this app, I’m going to write more of an abstract data updating layer meant for larger applications with multiple places in the UI that need to have the updated data source, so it’ll be over-engineered for the app I’m demoing.

I’m also experimenting with different architectures, especially in Swift, so if you have feedback on how to make the abstract data layer better in Swift, let me know in the comments!

The Setup

For this tutorial, I’m assuming you know how to create a Single View Application in Xcode, and create a simple Table View with a list of Food Emojis. If you’re having problems replicating it, take a look at my FoodSelectionViewController here.

I’m also assuming you know how to create a Watch App and do the basic styling in Interface.storyboard of your Watch Application. If you need help settings this up, make sure to read my WatchOS 2: Hello, World tutorial and the WatchKit: Let’s Create a Table tutorial.

Finally, you should be able to set up the basic singleton to wrap around WCSession and activate it in application:didFinishLaunchingWithOptions in the AppDelegate and applicationDidFinishLaunching in the ExtensionDelegate in your Watch Extension. If not, take a look at my WatchConnectivity: Say Hello to WCSession tutorial.

You should have something that looks like this in your iOS app:

// in your iOS app
import WatchConnectivity

class WatchSessionManager: NSObject, WCSessionDelegate {
    
    static let sharedManager = WatchSessionManager()
    private override init() {
        super.init()
    }
    
    private let session: WCSession? = WCSession.isSupported() ? WCSession.defaultSession() : nil
    
    private var validSession: WCSession? {
        
        // paired - the user has to have their device paired to the watch
        // watchAppInstalled - the user must have your watch app installed
        
        // Note: if the device is paired, but your watch app is not installed
        // consider prompting the user to install it for a better experience
        
        if let session = session where session.paired && session.watchAppInstalled {
            return session
        }
        return nil
    }
    
    func startSession() {
        session?.delegate = self
        session?.activateSession()
    }
}

// in your iOS app

import WatchConnectivity

class WatchSessionManager: NSObject, WCSessionDelegate {

static let sharedManager = WatchSessionManager()

private override init() {

super.init()

}

private let session: WCSession? = WCSession.isSupported() ? WCSession.defaultSession() : nil

private var validSession: WCSession? {

// paired - the user has to have their device paired to the watch

// watchAppInstalled - the user must have your watch app installed

// Note: if the device is paired, but your watch app is not installed

// consider prompting the user to install it for a better experience

if let session = session where session.paired && session.watchAppInstalled {

return session

}

return nil

}

func startSession() {

session?.delegate = self

session?.activateSession()

}

And something like this in your Watch App:

// in your WatchKit Extension

import WatchConnectivity

class WatchSessionManager: NSObject, WCSessionDelegate {
    
    static let sharedManager = WatchSessionManager()
    private override init() {
        super.init()
    }
    
    private let session: WCSession = WCSession.defaultSession()
    
    func startSession() {
        session.delegate = self
        session.activateSession()
    }
}

// in your WatchKit Extension

import WatchConnectivity

class WatchSessionManager: NSObject, WCSessionDelegate {

static let sharedManager = WatchSessionManager()

private override init() {

super.init()

}

private let session: WCSession = WCSession.defaultSession()

func startSession() {

session.delegate = self

session.activateSession()

}

And of course, you can always refer to the source code for this tutorial if you ever need extra clarification.

Now, on to the fun stuff 🚀.

Sending Data

In my application, every time the user selects a food item, it needs to be transferred in the background to my Watch App. That means the iOS app is the sender. This is super simple to do.

Just extend the WatchSessionManager singleton in your iOS app to transfer user info:

// in your iOS app

// MARK: User Info
// use when your app needs all the data
// FIFO queue
extension WatchSessionManager {
    
    // Sender
    func transferUserInfo(userInfo: [String : AnyObject]) -> WCSessionUserInfoTransfer? {
        return validSession?.transferUserInfo(userInfo)
    }
}

// in your iOS app

// MARK: User Info

// use when your app needs all the data

// FIFO queue

extension WatchSessionManager {

// Sender

func transferUserInfo(userInfo: [String : AnyObject]) -> WCSessionUserInfoTransfer? {

return validSession?.transferUserInfo(userInfo)

}

So now, when the user selects a food item cell, you simply call the above method:

// FoodSelectionViewController.swift

class FoodSelectionViewController: UITableViewController {

    private let food = ["🍦", "🍮", "🍤","🍉", "🍨", "🍏", "🍌", "🍰", "🍚", "🍓", "🍪", "🍕"]

    // Table Data Source methods truncated
    
    // MARK: Table view delegate
    
    override func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
        
        let foodItem = food[indexPath.row]
        WatchSessionManager.sharedManager.transferUserInfo(["foodItem" : foodItem])
    }

}

// FoodSelectionViewController.swift

class FoodSelectionViewController: UITableViewController {

private let food = ["🍦", "🍮", "🍤","🍉", "🍨", "🍏", "🍌", "🍰", "🍚", "🍓", "🍪", "🍕"]

// Table Data Source methods truncated

// MARK: Table view delegate

override func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {

let foodItem = food[indexPath.row]

WatchSessionManager.sharedManager.transferUserInfo(["foodItem" : foodItem])

}

That’s it! The selected food item is now in a FIFO queue and will be send over to your Watch App!

Receiving Data

Your Watch App now has to receive the data. This is pretty simple to start with. Just implement the session:didReceiveUserInfo: WCSessionDelegate method.

// in your WatchKit Extension

// MARK: User Info
// use when your app needs all the data
// FIFO queue
extension WatchSessionManager {
    
    // Receiver
    func session(session: WCSession, didReceiveUserInfo userInfo: [String : AnyObject]) {
        // handle receiving user info
        // this will be filled in in the Updating Data section below
    }
    
}

// in your WatchKit Extension

// MARK: User Info

// use when your app needs all the data

// FIFO queue

extension WatchSessionManager {

// Receiver

func session(session: WCSession, didReceiveUserInfo userInfo: [String : AnyObject]) {

// handle receiving user info

// this will be filled in in the Updating Data section below

}

Updating Data

Now that you received the data, this is the tricky part. Trying to let your Watch Extension’s InterfaceController and other views or data sources that your data has been updated. One way to do this is through NSNotificationCenter, but I’m going to try out a different approach. This is the part that can be done in multiple ways and is a bit over-engineered for this app, so keep this in mind.

Since we’re in Swift, my goal is to change to a value-type model as soon as I can. Unfortunately, as I mentioned in my blog post on WCSession, the WCSessionDelegate can only be implemented on an NSObject. So to mitigate that, I created a DataSource value that can take the userInfo data, and convert it into something immutable and usable by multiple InterfaceControllers. Since user info is received in a FIFO queue order, the DataSource should also keep track of the data in the order received.

// in your WatchKit Extension

struct DataSource {
    
    let items: [Item]
    
    enum Item {
        case Food(String)
        case Unknown
    }
    
    init(items: [Item] = [Item]()) {
        self.items = items
    }
    
    func insertItemFromData(data: [String : AnyObject]) -> DataSource {
        
        let updatedItems: [Item]

        if let foodItem = data["foodItem"] as? String {
            updatedItems = [.Food(foodItem)] + items
        } else {
            updatedItems = [.Unknown] + items
        }
        
        return DataSource(items: updatedItems)
    }
}

// in your WatchKit Extension

struct DataSource {

let items: [Item]

enum Item {

case Food(String)

case Unknown

}

init(items: [Item] = [Item]()) {

self.items = items

}

func insertItemFromData(data: [String : AnyObject]) -> DataSource {

let updatedItems: [Item]

if let foodItem = data["foodItem"] as? String {

updatedItems = [.Food(foodItem)] + items

} else {

updatedItems = [.Unknown] + items

}

return DataSource(items: updatedItems)

}

I can now set up a protocol that will update all parties that need to know about the data change with the most updated data source:

// in your WatchKit Extension
//  WatchSessionManager.swift

protocol DataSourceChangedDelegate {
    func dataSourceDidUpdate(dataSource: DataSource)
}

// in your WatchKit Extension

// WatchSessionManager.swift

protocol DataSourceChangedDelegate {

func dataSourceDidUpdate(dataSource: DataSource)

}

So now onto the interesting part! Your WatchSessionManager will need to somehow keep track of all the dataSourceChangedDelegates. This could be done through an array, and methods that will add and remove delegates from the array. The WatchSessionManager also needs to keep track of the latest copy of the DataSource, so it can use the data from that DataSource to create a new DataSource with the newest data:

// in your WatchKit Extension
//  WatchSessionManager.swift

class WatchSessionManager: NSObject, WCSessionDelegate {
    
    static let sharedManager = WatchSessionManager()
    private override init() {
        super.init()
    }
    
    private let session: WCSession = WCSession.defaultSession()
    
    private var dataSource = DataSource()
    private var dataSourceChangedDelegates = [DataSourceChangedDelegate]()
    
    func startSession() {
        session.delegate = self
        session.activateSession()
    }
    
    func addDataSourceChangedDelegate(delegate: T) {
        dataSourceChangedDelegates.append(delegate)
    }
    
    func removeDataSourceChangedDelegate(delegate: T) {
        for (index, dataSourceDelegate) in dataSourceChangedDelegates.enumerate() {
            if let dataSourceDelegate = dataSourceDelegate as? T where dataSourceDelegate == delegate {
                dataSourceChangedDelegates.removeAtIndex(index)
                break
            }
        }
    }
}

// in your WatchKit Extension

// WatchSessionManager.swift

class WatchSessionManager: NSObject, WCSessionDelegate {

static let sharedManager = WatchSessionManager()

private override init() {

super.init()

}

private let session: WCSession = WCSession.defaultSession()

private var dataSource = DataSource()

private var dataSourceChangedDelegates = [DataSourceChangedDelegate]()

func startSession() {

session.delegate = self

session.activateSession()

}

func addDataSourceChangedDelegate(delegate: T) {

dataSourceChangedDelegates.append(delegate)

}

func removeDataSourceChangedDelegate(delegate: T) {

for (index, dataSourceDelegate) in dataSourceChangedDelegates.enumerate() {

if let dataSourceDelegate = dataSourceDelegate as? T where dataSourceDelegate == delegate {

dataSourceChangedDelegates.removeAtIndex(index)

break

}

We can now add the implementation for when the user info is received:

// in your WatchKit Extension
//  WatchSessionManager.swift

// MARK: User Info
// use when your app needs all the data
// FIFO queue
extension WatchSessionManager {
    
    // Receiver
    func session(session: WCSession, didReceiveUserInfo userInfo: [String : AnyObject]) {
        // handle receiving user info
        dispatch_async(dispatch_get_main_queue()) { [weak self] in
            
            if let dataSource = self?.dataSource.insertItemFromData(userInfo) {
                self?.dataSource = dataSource
                self?.dataSourceChangedDelegates.forEach {
                    $0.dataSourceDidUpdate(dataSource)
                }
            }
        }
    }   
}

// in your WatchKit Extension

// WatchSessionManager.swift

// MARK: User Info

// use when your app needs all the data

// FIFO queue

extension WatchSessionManager {

// Receiver

func session(session: WCSession, didReceiveUserInfo userInfo: [String : AnyObject]) {

// handle receiving user info

dispatch_async(dispatch_get_main_queue()) { [weak self] in

if let dataSource = self?.dataSource.insertItemFromData(userInfo) {

self?.dataSource = dataSource

self?.dataSourceChangedDelegates.forEach {

$0.dataSourceDidUpdate(dataSource)

}

Now, we just need to make sure our InterfaceController is DataSourceChangedDelegate, and is kept track of by the WatchSessionManager.

// in your WatchKit Extension
//  InterfaceController.swift

class InterfaceController: WKInterfaceController, DataSourceChangedDelegate {
    
    @IBOutlet var foodTable: WKInterfaceTable!
    
    override func awakeWithContext(context: AnyObject?) {
        super.awakeWithContext(context)

        WatchSessionManager.sharedManager.addDataSourceChangedDelegate(self)
        loadTableData(DataSource())
    }
    
    override func didDeactivate() {
        
        // remove InterfaceController as a dataSourceChangedDelegate
        // to prevent memory leaks
        WatchSessionManager.sharedManager.removeDataSourceChangedDelegate(self)
        super.didDeactivate()
    }
    
    // MARK: DataSourceUpdatedDelegate
    // update the table once the data is changed!
    func dataSourceDidUpdate(dataSource: DataSource) {
        loadTableData(dataSource)
    }

}

private extension InterfaceController {
    
    private func loadTableData(dataSource: DataSource) {
        
        foodTable.setNumberOfRows(dataSource.items.count, withRowType: "FoodTableRowController")
        
        for (index, item) in dataSource.items.enumerate() {
            if let row = foodTable.rowControllerAtIndex(index) as? FoodTableRowController {
                switch item {
                case .Food(let foodItem):
                    row.foodLabel.setText(foodItem)
                case .Unknown:
                    row.foodLabel.setText("¯\\_(ツ)_/¯")
                }
                
            }
        }
        
    }

}

// in your WatchKit Extension

// InterfaceController.swift

class InterfaceController: WKInterfaceController, DataSourceChangedDelegate {

@IBOutlet var foodTable: WKInterfaceTable!

override func awakeWithContext(context: AnyObject?) {

super.awakeWithContext(context)

WatchSessionManager.sharedManager.addDataSourceChangedDelegate(self)

loadTableData(DataSource())

}

override func didDeactivate() {

// remove InterfaceController as a dataSourceChangedDelegate

// to prevent memory leaks

WatchSessionManager.sharedManager.removeDataSourceChangedDelegate(self)

super.didDeactivate()

}

// MARK: DataSourceUpdatedDelegate

// update the table once the data is changed!

func dataSourceDidUpdate(dataSource: DataSource) {

loadTableData(dataSource)

}

private extension InterfaceController {

private func loadTableData(dataSource: DataSource) {

foodTable.setNumberOfRows(dataSource.items.count, withRowType: "FoodTableRowController")

for (index, item) in dataSource.items.enumerate() {

if let row = foodTable.rowControllerAtIndex(index) as? FoodTableRowController {

switch item {

case .Food(let foodItem):

row.foodLabel.setText(foodItem)

case .Unknown:

row.foodLabel.setText("¯\\_(ツ)_/¯")

}

And that’s it!

You can view the full source code on Github here.

Sabes™

How do your datasource delegates perform on your devices Natasha? Mine are really hit or miss…especially my Glance, which works on the simulator but not on device. I am calling transferUserInfo and updateApplicationContext in my app delegate methods (didFinishLaunching and didEnterBackground) not sure if that makes a difference?
Guled

Thank you for this wonderful tutorial Natasha! I have a quick question. I recall that you created a tutorial, when WatchOS1 was being used at the time, to make the Apple Watch share data, from Core Data, with the iPhone. Now that we have WatchOS2, do you recommend, since both devices now have their own data stores, that developers send their Core Data objects to the Apple Watch (and back), using dictionaries, constantly when something changes? What would you recommend?
Adriana Pineda

Hi Natasha! Thanks for the blog post. Im doing a watch app and after watchOS 2.2 Im having trouble transferring user info and updating the application context. Sometimes I see that the session is not valid (but it is, I mean the watch is paired and has the app installed) and some other times the event simply are not received. I thought I was doing something wrong, but it turns out that many people are having this issues; I tried to run your project and same problem with my watchOS 2.2
Have you had this issue before?