Blog

The aim of this post is to show how it works Key-Value Observing mechanism (KVO). KVO is a mechanism for transparently notifying observers of changes in object properties. In other words,  this mechanism will allow us to trap when some object property value is being modified.

Implementation

We will create a class that will hold the property to be observed:

#import <Foundation/Foundation.h>

@interface NewObject : NSObject

@property int iPropertyToBeObserved;

+ (id)sharedInstance;

@end

Its implementation is the following:

#import "NewObject.h"

@implementation NewObject

+ (id)sharedInstance {
    static NewObject *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[self alloc] init];
    });
    return sharedInstance;
}

-(id) init{
    if([super init]){
        self.iPropertyToBeObserved=3;
    }
    return self;
}


@end

As you can see the property is set to 3 in the class initialiser. Now we are going to implement the KVO mechanism in the ViewController. We will add the observer in the viewDidLoad Method:

...
     [[NewObject sharedInstance] addObserver:self forKeyPath:@"iPropertyToBeObserved" options:NSKeyValueObservingOptionInitial context:nil];
...

As important as setup the observer is remove it when it is not necessary, I will add it in the dealloc method:

-(void)dealloc{
    [[NewObject sharedInstance] removeObserver:self forKeyPath:@"iPropertyToBeObserved"];
}

In the viewWillAppear method I will update property that is being observed:

-(void)viewDidAppear:(BOOL)animated{
    [super viewDidAppear:animated];
    
    NewObject  *aNewObject=[NewObject sharedInstance];
    aNewObject.iPropertyToBeObserved=5;
}

The callback that is being called every time that the property is changed is the following:

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
    if ([keyPath isEqualToString:@"iPropertyToBeObserved"]) {
        NSLog(@"New Value:%d",[[NewObject sharedInstance] iPropertyToBeObserved]);
    } else {
        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
    }
}

@end

When you will run the project you will see that the above function is called twice. Once during NewObject initialisation and the other during viewDidAppear.

And in the log screen:

2015-03-11 22:33:15.437 KVOSimplified[5865:118370] New Value:3
2015-03-11 22:37:33.297 KVOSimplified[5865:118370] New Value:5

You can download the code from here.

The aim of this post is to present Singleton design pattern in a template. I have seen some post and articles that showed the implementation key points separately, so this is why I have decided to write a mini-post showing an implementation template and its usage.

First of all, let’s define what a Singleton pattern is:

...the singleton pattern is a design pattern that restricts the instantiation of a class to one object. This is useful when exactly one object is needed to coordinate actions across the system. The concept is sometimes generalized to systems that operate more efficiently when only one object exists, or that restrict the instantiation to a certain number of objects…. (Wikipedia)

Pattern implementation

This is my singleton implementation class:

#import "MySingletonClass.h"

@implementation MySingletonClass{
    int iLocalAttribute;
}

-(id) init{
    if([super init]){
        iLocalAttribute=5;
    }
    
    return self;
}

+ (MySingletonClass*)sharedInstance
{
    static MySingletonClass *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[MySingletonClass alloc] init];
        // Do any other initialisation stuff here
    });
    return sharedInstance;
}

-(int) giveMe5{
    iLocalAttribute+=5;
    return iLocalAttribute;
}

@end

I have added a local attribute (iLocalAttribute), for showing how to handle them, at the beginning I had to create them as static and for having access to them I had also to create static methods, but in a few lines I will explain how to avoid that.

The key point is the sharedInstance method:

1. Declare a static variable to hold the instance of the class, ensuring it’s always available, but inside of  sharedInstance method context.
2.  dispatch_once_t which ensures that the initialization code executes only once.
3. Instance of MySingletonClass.
4. Finally return the instance class.

Finally I have created a simple function that updates the local attribute and returns its value. As you can see neither the attribute nor the method are static.

This is the header class:

#import <Foundation/Foundation.h>

@interface MySingletonClass : NSObject

+ (MySingletonClass*)sharedInstance;
-(int) giveMe5;

@end

Pattern usage

This is my singleton implementation class:

   NSLog(@"%d",[[MySingletonClass sharedInstance] giveMe5]);