#nsnotification

Getting the code right in Swift to retrieve data from the NSNotification userInfo dictionary was not straightforward, mainly due to compilation errors from type casting the dictionary and its values. The following two key points helped find the correct solution:

userInfo is an optional dictionary, so it requires unwrapping.

The mapped value in the dictionary needs to be type casted to NSValue.

Furthermore, if the mapped value is an enumeration, you can use its fromRaw method to get back the enumeration member. The code snippet below shows an example with AVAudioSessionInterruptionNotification. In this case the userInfo dictionary maps key AVAudioSessionInterruptionTypeKey to a member of AVAudioSessionInterruptionType. After retrieving the int value of the enumeration from the dictionary, you can get the enumeration member and go through a switch statement.

  https://gist.github.com/jchernan/de6c30b40fb69d03fb63

I think everyone would agree the notification pattern within objective-c is a great way to decouple views from services.

Swift implementation

Posting a notification in swift is similar to the objective-c implement just with the new syntax.

NSNotificationCenter.defaultCenter.postNotification(name: “notificationName”, object: nil)

When adding an observer to the Notification Center in swift. The class that is being set as the observer must be an objective-c type (Derive from NSObject). When the class isn’t an objective-c type, when the notification selector fires and exception is thrown crashing the app.

NSNotificationCenter.defaultCenter.addObserver(selector: “methodToInvoke:”, name: “notificationName”)

fund methodToInvoke(notification: NSNotification) { //Do Stuff }

Testing NSNotificationCenter

Currently this is no native mocking framework for swift meaning the only viable way to mock object is using hand rolled mocks.

In the test target create a new swift class called: MockNSNotificationCenter. In the new class, subclass NSNotificationCenter then override the methods your test is expecting to call as described below:

class MockNSNotificationCenter: NSNotificationCenter {

    var observerCount = 0

    var postCount = 0

    var lastPostedNotificationName:String?

    override func addObserver(observer: AnyObject, selector aSelector: Selector, name aName: String?, object anObject: AnyObject?) {

        observerCount++

    }

    override func postNotificationName(aName: String?, object anObject: AnyObject?) {

        lastPostedNotificationName = aName!

        postCount++

    }

}

Then in your real class you use lazy instantiation to allow the mock notification center to be injected.

class RealClass {

    lazy var notificationCenter: NSNotificationCenter = {

        return NSNotificationCenter.defaultCenter()

  }()

    func someMethodPostNotification() {

        notificationCenter.postNotification(name: “notificationName”, object: nil)

    }

}

In your test class you can assert that a notification is posted when a method is called

class RealClassTests: XCTestCase {

    let sut = RealClass()

    let mockNotification = MockNSNotificationCenter()

    func testNotification() {

        sut.notificationCenter = mockNotification

        sut.someMethodPostNotification()

        XCTAssertEqual(mockNotification.postCount, 1, "a notification should be posted")

    }

In Square1 we get requests for a new mobile app almost every week and the requirement is always to have it supporting both Android and iPhone. Not being too keen on using cross platform frameworks we always develop our apps using native Java or Objective-c APIs. Having implemented the same requirements on both Android and iPhone several times, I have noticed how the two platforms have taken similar approaches when it comes to solving common problems. In this series of posts I am going to show how to achieve the same result on both platforms focusing on the similarities of the two SDKs.

Intents and NSNotifications

When developing an app it is a common requirement to notify an event to various components at the same time. Let's think for example of when a user logs in or logs out or when a paid feature is purchased. It is common in this case to have to update several sections of the app to reflect the new state.

The way I normally handle this scenario is by sending an Intent with the LocalBroadcastManager on Android and by sending an NSNotification with the NSNotificationCenter on iOS.

There are 4 main aspects when dealing with both Intents and NSNotifications:

Register to receive events

Create and Send the event

Receive and Handle the event

Deregister

Register

The first step is to define a string identifier for the event and register to receive notifications. Let's call this event USER_LOGGEDIN_STATE_CHANGED.

On Android the code will look like:

public class MyActivity extends Activity { public static final String USER_LOGGEDIN_STATE_CHANGED = "USER_LOGGEDIN_STATE_CHANGED"; public void register(){ LocalBroadcastManager mngr = LocalBroadcastManager.getInstance(this); mngr.registerReceiver( mMessageReceiver, new IntentFilter(USER_LOGGEDIN_STATE_CHANGED)); } }

On iOS the code will look like:

@implementation MyViewController -(void) register { center = [NSNotificationCenter defaultCenter]; [center addObserver:self selector:@selector(messageReceiver:) name:USER_LOGGEDIN_STATE_CHANGED object:nil]; } @end

Create and Send

Once the registration is completed events can be created and sent from anywhere in the application.

On Android create an Intent, add in any extra data and broadcast:

Intent intent = new Intent(USER_LOGGEDIN_STATE_CHANGED); intent.putExtra("state", "User is logged in"); LocalBroadcastManager.getInstance(this).sendBroadcast(intent);

On iOS send an NSotification with any extra data added to the userInfo dictionary:

NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@"User is logged in" forKey:@"state"]; [[NSNotificationCenter defaultCenter] postNotificationName: @"USER_LOGGEDIN_STATE_CHANGED" object:nil userInfo:userInfo];

Receive and Handle

Receiving the notification is the part that differs the most in between Android and iPhone. On Android when calling

manager = LocalBroadcastManager.getInstance(this); manager.registerReceiver(mMessageReceiver)

we have passed mMessageReceiver, an instance of a class that extends the BroadCastReceiver class. Sending a broadcast will call in the BroadCastReceiver method

onReceive(Context context, Intent intent)

passing in the Intent that was broadcasted.

On iOS when calling

[[NSNotificationCenter defaultCenter] addObserver:self

we have passed in an instance of a class that will receive the notification ( in the example is self) and a @selector for the method of that class that will be called when the Notification is sent . Sending a Notification will call in the method

[self messageReceiver:(NSNotification*)notification

Deregister

To keep your implementation clean and save resources It is good practice to deregister when there is no longer a need to receive the notifications. This is achieved in a similar way on both Android and iOS.

On Android:

manager = LocalBroadcastManager.getInstance(this); manager.unregisterReceiver(mMessageReceiver);

On iOS:

*center = [NSNotificationCenter defaultCenter]; [center removeObserver:self];

Well there is a lot more that could be said on this subject but this covers the basics on Intents and NSNotifications!

- Roberto Prato @pratorob

Steve Breen tweets:

Tracing all NSNotificationCenter traffic on iOS. Very cool! #iosdev https://t.co/hfV8zyEm1h

— Steve Breen (@steve_breen) October 16, 2013

Every app has an instance of NSNotificationCenter.

Objects can register with NSNotificationCenter as an observer.

Objects can post notifications to NSNotificatonCenter.

When NSNotificationCenter receives a notification of a matching kind, it will forward these on to the appropriate registered objects.

Notification instances are of type NSNotification.

To register a notification:

NSNotificationCenter *center = [NSNotificationCenter defaultCenter]; [center addObserver:self              selector:@selector(openDoor:)              name:@"Knock"              object:nil];

In this example, the openDoor message is sent to the current object (self) when a notification with name "Knock" is posted, by any object (signified by the last argument being nil).

The following method is triggered when the "Knock" notification arrives:

- (void)openDoor:(NSNotification *)n {     id poster = [n object];     NSString *name = [n name];     NSDictionary *extraInformation = [n userInfo]; }

userInfo is a dictionary used to pass additional information.

Example notification:

NSDictionary *info = [NSDictionary dictionaryWithObject:@"Fast" forKey:@"Speed]; NSNotification *notification = [NSNotificationnotificationWithName:@"Knock" object:self userInfo:info]; [[NSNotificationCenter defaultCenter] postNotification:notification];

Remember to unregister registered objects if no longer in use:

.......세상에 믿을 코드 하나 없다더니ㅠㅠㅠㅠ 내 실수인것을 누굴 탓하겠느냐만 부주의로 인해 몇날 며칠을 (미루다가 이제서야 삽질해서 알아낸거지만) 끙끙 앓던 문제.. 

잊지말고 글을써두자.

Unbalanced calls to begin/end appearance transitions for <ViewController>

뭔가 viewController를 불러오는 동안? 혹은 부를때 문제가 생겼다. 근데 뭐가 문제인지 도저히 모르겠다.. 구글신에게 물어보면서 하나씩 체크!

의심 1. 애니메이션 문제인가??

 애니메이션이 이루어 지고 있을때 강제로 transfer를 하게 되면 이러한 문제가 일어날수 있다. 그러므로 Animate를 NO로 하여 넘어가던지 @selector를 이용하여 delay를 준다

결과 1 : 실패.

 우선 내 경우에서는 애니메이션이 없엇음. 그리고 animate도 NO해보고 delay를 줘 봤지만 결과는 그대로 ㅠ_ㅠ

의심 2. init 대신 initWithNibName:bundle:을 사용해라

결과 2: ㄴㄴ..실패

여기까지 하다가 생각해보니..  내 경우는 NSNotification을 이용하여 notification이 post 하면 메소드를 부르고 있었다. 그래서 break를 걸어보니...... 두...두번 부르고 있었다 orz..

[self.navigationController pushViewController:VC animated:YES]; 를 연속 두번 부르게 되어 위와 같은 문제가 발생한 것이다.

그렇다면 왜 두번 부르는 걸까.

의심 3. post를 두번하나?

결과 3: ㄴㄴ...

그래도 아니라면 .... addObserver를 두번했나 하고 봤더니 viewWillAppear에서 이 화면에 들어올때마다!!마다!! addObserver를 하고 있엇음.. 

같은 name일때는 한번만 옵져버가 등록될줄알았는데... 같은이름 같은 selector라도 아주 정직하게 다 등록해주고있엇다.. 

결과.

NSNotification을 사용할때는 removeObserver 잊지말고 addObserver는 시키는데로 계속 더해주니 조심히 사용하자. 그리고 위 에러는 view transfer에서 생기므로 넘어갈때 (pushview...)와 viewWillApper, viewDidLoad 부분을 잘 살펴보자. 

// Sender is any object want to sent // Example Assume that's NSMutableArray.

// Sender is any object ;)

NSDictionary *options = [NSDictionary dictionaryWithObjectsAndKeys: Sender, @"KeyforParse", nil];

[[NSNotificationCenter defaultCenter] postNotificationName:@"NAME of Notification" object:self userInfo:options];

Credit : Stackoverflow

How to Parse? by ZhOCKeR ;)

-(void)getCompleted:(NSNotification *)notification{ NSMutableArray *tempArray = [[NSMutableArray alloc]initWithArray:[[notification userInfo] objectForKey:@"KeyforParse"]];

NSLog(@"%@", tempArray); // << It's here?

[[NSNotificationCenter defaultCenter]removeObserver:self name:@"NAME of Notification" object:nil];

}

Creating a notification center under initWithNibName / viewDidLoad

        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(receiveNotification:) name:@"favouritePressed" object:nil];

Create a method to handle all notifications

-(void)receiveNotification:(NSNotification *) notification{     if([[notification name] isEqualToString:@"favouritePressed"]) {           } }

In another view class create a notification to send.

    [[NSNotificationCenter defaultCenter] postNotificationName:@"favouritePressed" object:self userInfo:cellIndex];

*Note - userInfo must be a NSDictionary object. Should be quite self explanatory the rest. Watch this video to clarify any doubts.