Using WCSession with more than one ViewController

Question

I found many questions and many answers but no final example for the request:

Can anyone give a final example in Objective C what is best practice to use WCSession with an IOS app and a Watch app (WatchOS2) with more than one ViewController.

What I noticed so far are the following facts:

1.) Activate the WCSession in the parent (IOS) app at the AppDelegate:

- (BOOL)application:(UIApplication *)application
didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    //Any other code you might have

    if ([WCSession isSupported]) {
        self.session = [WCSession defaultSession];
        self.session.delegate = self;
        [self.session activateSession];
    }
}

2.) On the WatchOS2 side use <WCSessionDelegate>. But the rest is totally unclear for me! Some answers are talking from specifying keys in the passing Dictionary like:

[session updateApplicationContext:@{@"viewController1": @"item1"} error:&error];
[session updateApplicationContext:@{@"viewController2": @"item2"} error:&error];

Others are talking about retrieving the default session

WCSession* session = [WCSession defaultSession];
[session updateApplicationContext:applicationDict error:nil];

Others are talking about different queues? "It is the client's responsibility to dispatch to another queue if necessary. Dispatch back to the main."

I am totally confused. So please give an example how to use WCSession with an IOS app and a WatchOS2 App with more than one ViewController.

I need it for the following case (simplified): In my parent app I am measuring heart rate, workout time and calories. At the Watch app 1. ViewController I will show the heart rate and the workout time at the 2. ViewController I will show the heart rate, too and the calories burned.

Answer 1

As far as I understand the task you just need synchronisation in a Phone -> Watch direction so in a nutshell a minimum configuration for you:

Phone:

I believe the application:didFinishLaunchingWithOptions: handler is the best place for the WCSession initialisation therefore place the following code there:

if ([WCSession isSupported]) {
    // You even don't need to set a delegate because you don't need to receive messages from Watch.
    // Everything that you need is just activate a session.
    [[WCSession defaultSession] activateSession];
}

Then somewhere in your code that measures a heart rate for example:

NSError *updateContextError;
BOOL isContextUpdated = [[WCSession defaultSession] updateApplicationContext:@{@"heartRate": @"90"} error:&updateContextError]

if (!isContextUpdated) {
    NSLog(@"Update failed with error: %@", updateContextError);
}

update:

Watch:

ExtensionDelegate.h:

@import WatchConnectivity;
#import <WatchKit/WatchKit.h>

@interface ExtensionDelegate : NSObject <WKExtensionDelegate, WCSessionDelegate>
@end

ExtensionDelegate.m:

#import "ExtensionDelegate.h"

@implementation ExtensionDelegate

- (void)applicationDidFinishLaunching {
    // Session objects are always available on Apple Watch thus there is no use in calling +WCSession.isSupported method.
    [WCSession defaultSession].delegate = self;
    [[WCSession defaultSession] activateSession];
}

- (void)session:(nonnull WCSession *)session didReceiveApplicationContext:(nonnull NSDictionary<NSString *,id> *)applicationContext {
     NSString *heartRate = [applicationContext objectForKey:@"heartRate"];

    // Compose a userInfo to pass it using postNotificationName method.
    NSDictionary *userInfo = [NSDictionary dictionaryWithObject:heartRate forKey:@"heartRate"];

    // Broadcast data outside.
    [[NSNotificationCenter defaultCenter] postNotificationName: @"heartRateDidUpdate" object:nil userInfo:userInfo];
}

@end

Somewhere in your Controller, let's name it XYZController1.

XYZController1:

#import "XYZController1.h"

@implementation XYZController1

- (void)awakeWithContext:(id)context {
    [super awakeWithContext:context];

    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleUpdatedHeartRate:) name:@"heartRateDidUpdate" object:nil];
}

-(void)handleUpdatedHeartRate:(NSNotification *)notification {
        NSDictionary* userInfo = notification.userInfo;
        NSString* heartRate = userInfo[@"heartRate"];
        NSLog (@"Successfully received heartRate notification!");
}

@end

Code hasn't been tested I just wrote it as is so there can be some typos.

I think the main idea now is quite clear and a transfer of remaining types of data is not that tough task.

My current WatchConnectivity architecture much more complicated but nevertheless it is based on this logic.

If you still have any questions we might move a further discussion to the chat.

Answer 2

Well, this is simplified version of my solution as requested by Greg Robertson. Sorry it's not in Objective-C anymore; I'm just copy-pasting from existing AppStore-approved project to make sure there will be no mistakes.

Essentially, any WatchDataProviderDelegate can hook to data provider class as that provides array holder for delegates (instead of one weak var). Incoming WCSessionData are forwarded to all delegates using the notifyDelegates() method.

// MARK: - Data Provider Class

class WatchDataProvider: WCSessionDelegate {

    // This class is singleton
    static let sharedInstance = WatchDataProvider()

    // Sub-Delegates we'll forward to
    var delegates = [AnyObject]()

    init() {
        if WCSession.isSupported() {
            WCSession.defaultSession().delegate = self
            WCSession.defaultSession().activateSession()
            WatchDataProvider.activated = true;
        }
    }

    // MARK: - WCSessionDelegate                

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

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

    func processIncomingMessage(dictionary: [String:AnyObject] ) {
        // do something with incoming data<
        notifyDelegates()
    }

    // MARK: - QLWatchDataProviderDelegate     

   public func addDelegate(delegate: AnyObject) {
       if !(delegates as NSArray).containsObject(delegate) {
           delegates.append(delegate)
       }
   }

   public func removeDelegate(delegate: AnyObject) {
       if (delegates as NSArray).containsObject(delegate) {
           delegates.removeAtIndex((delegates as NSArray).indexOfObject(delegate))
       }
   }

   func notifyDelegates()
   {
       for delegate in delegates {
           if delegate.respondsToSelector("watchDataDidUpdate") {
               let validDelegate = delegate as! WatchDataProviderDelegate
               validDelegate.watchDataDidUpdate()
           }
       }
   }    
}


// MARK: - Watch Glance (or any view controller) listening for changes

class GlanceController: WKInterfaceController, WatchDataProviderDelegate {

    // A var in Swift is strong by default
    var dataProvider = WatchDataProvider.sharedInstance()
    // Obj-C would be: @property (nonatomic, string) WatchDataProvider *dataProvider

    override func awakeWithContext(context: AnyObject?) {
        super.awakeWithContext(context)
        dataProvider.addDelegate(self)
    }

    // WatchDataProviderDelegate
    func watchDataDidUpdate() {
        dispatch_async(dispatch_get_main_queue(), {
            // update UI on main thread
        })
    }}
}

class AnyOtherClass: UIViewController, WatchDataProviderDelegate {

    func viewDidLoad() {
        WatchDataProvider.sharedInstance().addDelegate(self)
    }

    // WatchDataProviderDelegate
    func watchDataDidUpdate() {
        dispatch_async(dispatch_get_main_queue(), {
            // update UI on main thread
        })
    }}
}

Answer 3

Doing the session management (however WCSession is singleton) in a View-Controller smells like MVC violation (and I've seen too many Watch blog posts wrong this way already).

I made an umbrella singleton class over the WCSession, that is first strongly referenced from Watch Extension Delegate to make sure it will load soon and do not get deallocated in the middle of work (e.g. when a View-Controller disappears while transferUserInfo or transferCurrentComplicationUserInfo happens in another watch thread).

Only this class then handles/holds the WCSession and decouples the session data (Model) from all the View-Controller(s) in watch app, exposing data mostly though public static class variables providing at least basic level of thread-safety.

Then this class is used both from complication controller, glance controller and other view controllers. Updates run in the background (or in backgroundFetchHandler), none of the apps (iOS/WatchOS) is required to be in foreground at all (as in case of updateApplicationContext) and the session does not necessarily have to be currently reachable.

I don't say this is ideal solution, but finally it started working once I did it this way. I'd love to hear that this is completely wrong, but since I had lots of issues before going with this approach, I'll stick to it now.

I do not give code example intentionally, as it is pretty long and I don't want anyone to blindly copy-paste it.

Answer 4

I found, with "try and error", a solution. It is working, but I don't know exactly why! If I send a request from the Watch to the IOS app, the delegate of that ViewController of the Watch app gets all the data from the main queue from the IOS app. I added the following code in the - (void)awakeWithContext:(id)context and the - (void)willActivate of all ViewControllers of the Watch app:

By example 0 ViewController:

[self packageAndSendMessage:@{@"request":@"Yes",@"counter":[NSString stringWithFormat:@"%i",0]}];

By example 1 ViewController1:

[self packageAndSendMessage:@{@"request":@"Yes",@"counter":[NSString stringWithFormat:@"%i",1]}];

/*
     Helper function - accept Dictionary of values to send them to its phone - using sendMessage - including replay from phone
 */
-(void)packageAndSendMessage:(NSDictionary*)request
{
    if(WCSession.isSupported){


        WCSession* session = WCSession.defaultSession;
        session.delegate = self;
        [session activateSession];

        if(session.reachable)
        {

            [session sendMessage:request
                    replyHandler:
             ^(NSDictionary<NSString *,id> * __nonnull replyMessage) {


                 dispatch_async(dispatch_get_main_queue(), ^{
                     NSLog(@".....replyHandler called --- %@",replyMessage);

                     NSDictionary* message = replyMessage;

                     NSString* response = message[@"response"];

                     [[WKInterfaceDevice currentDevice] playHaptic:WKHapticTypeSuccess];

                     if(response)
                         NSLog(@"WK InterfaceController - (void)packageAndSendMessage = %@", response);
                     else
                         NSLog(@"WK InterfaceController - (void)packageAndSendMessage = %@", response);


                 });
             }

                    errorHandler:^(NSError * __nonnull error) {

                        dispatch_async(dispatch_get_main_queue(), ^{
                            NSLog(@"WK InterfaceController - (void)packageAndSendMessage = %@", error.localizedDescription);
                        });

                    }


             ];
        }
        else
        {
            NSLog(@"WK InterfaceController - (void)packageAndSendMessage = %@", @"Session Not reachable");
        }

    }
    else
    {
        NSLog(@"WK InterfaceController - (void)packageAndSendMessage = %@", @"Session Not Supported");
    }

}