Inconsistent behaviour with WatchKit app - Swift

Question

I'm trying to make iOS app to communicate with watch, but i get inconsistent behaviour all the time - either the communication is too slow, or none of the data gets transferred at all.

Besides, i don't see any "Phone disabled" screen when the watchKit runs (which causes a crash, because i need to get data from the phone first).

This is what i have in regards to establishing the WCSession in the iPhone app

App Delegate

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

       if NSClassFromString("WCSession") != nil {
            if #available(iOS 9.0, *) {
                if(WCSession.isSupported()){
                    self.session = WCSession.defaultSession()
                    self.session.delegate = self
                    self.session.activateSession()
                    if session.paired {
                        print("Watch connected")
                    } else {
                        print("No watch")
                    }
                }
            } else {
            }}

        if NSClassFromString("WCSession") != nil {
            if(WCSession.isSupported()){
                session.sendMessage(["b":"delegateSaysHi"], replyHandler: nil, errorHandler: nil)
            }}
}

MainViewController (viewDidLoad)

if NSClassFromString("WCSession") != nil {
        if(WCSession.isSupported()){
            self.session = WCSession.defaultSession()
            self.session.delegate = self
            self.session.activateSession()
            if session.paired {
                print("Watch connected")
            } else {
                print("No watch")
            }
    }}

MainViewController (Method for transferring bunch of data from iOS app to watchKit app)

    func transferData(){
    do {
        let dataArray = ["somedata": array2d1]
        try WCSession.defaultSession().updateApplicationContext(dataArray)
        let dataArray1 = ["somedata1": array2d2]
        try WCSession.defaultSession().updateApplicationContext(dataArray1)
        let dataArray2 = ["somedata2": array2d3]
        try WCSession.defaultSession().updateApplicationContext(dataArray2)
            let dataArray3 = ["somedata3": array2d4]
        try WCSession.defaultSession().updateApplicationContext(dataArray3)

// and up to 12
        }

    catch {
        print("Something wrong happened")
    }
    }

And this is for watchKit app

App Delegate

func applicationDidFinishLaunching() {
    if(WCSession.isSupported()){
        self.session = WCSession.defaultSession()
        self.session.delegate = self
        self.session.activateSession()
    }
}

func applicationDidBecomeActive() {
    if(WCSession.isSupported()){
        self.session.sendMessage(["b":"peek"], replyHandler: nil, errorHandler: nil)
    }

InterfaceController (awakeWithContext)

if(WCSession.defaultSession().reachable){
    self.session.sendMessage(["b":"peek"], replyHandler: nil, errorHandler: nil)
}

Method for receiving ApplicationContext data

func session(session: WCSession, didReceiveApplicationContext applicationContext: [String : AnyObject]) {

    dispatch_async(dispatch_get_main_queue()) { () -> Void in

        if let retrievedArray1 = applicationContext["somedata"] as? [[String]] {
                self.watchAppArray = retrievedArray1

        }
        if let retrievedArray2 = applicationContext["somedata2"] as? [[String]] {

             self.watchAppArray = retrievedArray1

// and so on for 12 arrays sent from phone

        }

        }
    }}

Any advices on clearing out the situation are very welcome!

Thank you.

Answer 1

Multiple delegates/activations:

You're repeatedly setting up, delegating, and activating sessions in different parts of your app. You keep changing your delegate, so code in one part of the app will no longer be used after you delegated handling to a different part of your app.

You should use a single session/delegate throughout your app. One solution is to setup a WCSession singleton which would be available app-wide. Here's a guide which walks you through that process.

Only the most recent application context would get sent:

By trying to queue up multiple application context requests, the earlier ones would no longer be in the queue when the system gets around to transmitting it, as the system would have already replaced the preceding context with the later one. So only the last (dataArray3) would ever get transmitted.

Use the updateApplicationContext:error: method to communicate recent state information to the counterpart. When the counterpart wakes, it can use this information to update its own state. ... This method overwrites the previous data dictionary, so use this method when your app needs only the most recent data values.

If all of the arrays represent the recent state of your application, you want to transmit them together in a single dictionary.

var dataArray = [String: AnyObject]()
dataArray["somedata"] = array2d1
dataArray["somedata1"] = array2d2
dataArray["somedata2"] = array2d3
dataArray["somedata3"] = array2d4

do {
    try session.updateApplicationContext(dataArray)
}
catch {
    print(error)
}

It may also help to add some error handling to your sendMessage code, as the paired device may not always be reachable.

Slow communication:

As for the communication being too slow, there are two issues at hand.

• Transfers may not happen immediately.

  When only one session is active, the active session may still send updates and transfer files, but those transfers happen opportunistically in the background.

  Remember that background transfers are not be delivered immediately. The system sends data as quickly as possible but transfers are not instantaneous, and the system may delay transfers slightly to improve power usage. Also, sending a large data file requires a commensurate amount of time to transmit the data to the other device and process it on the receiving side.

• The more data you send, the longer it takes to transmit/receive it all.

  When sending messages, send only the data that your app needs. All transfers involve sending data wireless to the counterpart app, which consumes power. Rather than sending all of your data every time, send only the items that have changed.

You can control how much data you send, as well as whether the data is sent interactively or in the background. If the watch is reachable, you could use sendMessage for immediate communication. If it's not reachable, you could fall back on a background method.