CODEWITHSUNDEEP
iosobjective-ccallbacknotificationsbluetooth-lowenergy
BlackHatSamurai
BlackHatSamurai

Reputation: 23503

Problems using notifications as a callback?

I am trying to update a view when something happens in another class, and after some looking, it appeared that the most common way to do this was to use either delegates or blocks to create a callback. However, I was able to accomplish this task using notifications. What I want to know is: Is there a problem using notifications to trigger methods calls? Are there any risks I'm not aware of? Is there a reason I'd want to use blocks/delegates over notifications?

I'm new to Objective-C, so I'm not sure if the approach I'm taking is correct.

As an example, I'm trying to set the battery level of a BLE device on the ViewController. I have a BluetoothLEManager, which discovers the peripheral, its services/characteristics, etc. But to do this, I need to initiate the "connection" in the detailViewController, then update the battery level once I find it.

Here is some example code of what I'm doing:

DetailViewController.m

- (void)viewDidLoad {
    [super viewDidLoad];

    // Do any additional setup after loading the view.
    NSLog(@"Selected tag UUID: %@", [selectedTag.tagUUID UUIDString]);
    tagName.text = selectedTag.mtagName;
    if(selectedTag.batteryLevel != nil){
         batteryLife.text = selectedTag.batteryLevel;
    }

    uuidLabel.text = [selectedTag.tagUUID UUIDString];

    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(setBatteryLevel:) name:@"SetBatteryLevel" object:nil];
}
...
-(void)setBatteryLevel:(NSNotification*)notif{
    NSMutableString* batLevel = [[NSMutableString alloc]initWithString:[NSString stringWithFormat:@"%@", selectedTag.batteryLevel]];
    [batLevel appendString:@" %"];
    selectedTag.batteryLevel = batLevel; 
    batteryLife.text = selectedTag.batteryLevel;
}

BluetoothLEManager.m:

...
-(void) getBatteryLevel:(CBCharacteristic *)characteristic error:(NSError *)error fetchTag:(FetchTag *)fetchTag
{
    NSLog(@"Getting battery Level...");
    NSData* data = characteristic.value;
    const uint8_t* reportData = [data bytes];
    uint16_t batteryLevel = reportData[0];
    selectedTag.batteryLevel = [NSString stringWithFormat:@"%i", batteryLevel];
    NSLog(@"Battery Level is %@", [NSString stringWithFormat:@"%i", batteryLevel]);
    [[NSNotificationCenter defaultCenter] postNotificationName:@"SetBatteryLevel" object:nil]; 


}
...

Let me know if you need any other code, but this is the basics of it all.

Upvotes: 0

Views: 93

Answers (1)

Duncan C
Duncan C

Reputation: 131511

Each approach has different strengths and weaknesses.

Delegates and protocols require a defined interface between the object and it's delegate, a one-to-one relationship, and that the object have specific knowledge of the delegate object it's going to call.

Methods with completion blocks involve a similar one-to-one relationship between an object and the object that invokes the method. However since blocks inherit the scope in which they're defined, you have more flexibility as to the context that's available in the completion block. Blocks also allow the caller to define the completion code in same place that the call takes place, making you code more self-documenting.

In both cases, the object that is notifying the delegate or invoking the completion block has to know who it's talking to, or what code is being executed.

A delegate call is like an auto shop calling you back to let you know your car is done. The service manager has to have your phone number and know that you want a call.

A block is more like a recipe you give to a chef. Give the chef a different recipe and he/she performs a different task for you.

Notifications are much less tightly coupled. It's like a town crier, yelling announcements in a crowded public square. The crier doesn't need to know who's listening, or how many people are listening.

Likewise, when you send a notification, you don't know who, if anybody, is listening, or how many listeners there are. You don't need to know. If 10 objects care about the message you are broadcasting, they can all listen for it, and they'll all be notified. The message sender doesn't have to know or care who's listening.

Sometimes you want tighter coupling, and sometimes you want looser coupling. It depends on the problem you're trying to solve.

Upvotes: 2

Related Questions