Avoid - [NSNotification removeObserver:]

Recently, I found myself implementing a UIViewController which required me to shift the associated view up and down as the keyboard appeared or disappeared. Since it was only necessary to catch these events when the view was actually visible, I decided to listen to keyboard notifications when the view was visible only:

// YoYoViewController.m

@implementation YoYoViewController

#pragma mark View lifecycle events

- (void)viewDidAppear:(BOOL)animated
{
    [super viewDidAppear:animated];

    [[NSNotificationCenter defaultCenter] addObserver:self 
                                             selector:@selector(keyboardWillShow:) 
                                                 name:UIKeyboardWillShowNotification 
                                               object:nil];
    [[NSNotificationCenter defaultCenter] addObserver:self 
                                             selector:@selector(keyboardWillHide:) 
                                                 name:UIKeyboardWillHideNotification 
                                               object:nil];
}

- (void)viewDidDisappear:(BOOL)animated
{
    [super viewDidDisappear:animated];

    [[NSNotificationCenter defaultCenter] removeObserver:self];
}

- (void)viewDidUnload
{
    [super viewDidUnload];

    // Release associated views here
}

#pragma mark Keboard notification events

- (void)keyboardWillShow:(NSNotification *)notification
{
    // Shift the view up
}

- (void)keyboardWillHide:(NSNotification *)notification
{
    // Shift the view down
}

// ...

@end

I can be quite lazy sometimes, and since I was not registering for any other notifications, I decided to save myself some typing by simply using - [NSNotification removeObserver:] to stop listening to keyboard notification events when the view disappeared.

Soon afterwards, I was testing my application, and I found it surprisingly robust when simulating memory warnings in the iOS simulator. I even congratulated my fellow colleagues about the nice work we had done taking all necessary measures so that the application behaved nicely when running out of memory. Well, at least this is what I was thinking.

God I was wrong.

I usually try to be lazy when this can save me some unnecessary work, but laziness is bad when it comes to testing your application. The morning after, I decided to check my viewDidUnload method implementation, so I fired up gdb and added a breakpoint on it. I was surprised to discover it was never called.

The reason is simple when you think about it, but is easy to overlook: By calling - [NSNotification removeObserver:] in my viewDidDisappear method, I not only stopped listening to keyboard event notifications, I also got rid of all previous registrations which UIViewController made under the hoods! This includes memory warning notifications, of course, but also device orientation notifications. Had the application I was working on supported more than one orientation (which was not the case), I would also have discovered that my YoYoViewController would not have been able to rotate anymore once it had disappeared.

The solution to this problem is straightforward: Don't be lazy when unregistering from the notification center, always specify the notifications you stop listening to:

- (void)viewDidDisappear:(BOOL)animated
{
    [super viewDidDisappear:animated];

    [[NSNotificationCenter defaultCenter] removeObserver:self
                                                    name:UIKeyboardWillShowNotification
                                                  object:nil]; 
    [[NSNotificationCenter defaultCenter] removeObserver:self
                                                    name:UIKeyboardWillHideNotification
                                                  object:nil];
}

Moral of the story

Never ever use - [NSNotification removeObserver:] to unregister from notification events, except from a dealloc method. This might cancel registrations made by a parent class, and you cannot know how a parent class is implemented (at least you shouldn't care). Stick to this rule even if your parent class is NSObject: Your class hierarchy might change in the future, and you do not want to run into problems when you don't have to, do you?

This article discusses - [NSNotification removeObserver:] specifically, but any unregistration / cleanup method being too greedy suffers from the same issues (e.g. - [NSObject cancelPreviousPerformRequestsWithTarget:]). Be careful.