[Download Xcode 9 project with full Swift 4 source from GitHub.]
The topic today is how to communicate between objects within an app, specifically using iOS’s NSNotificationCenter. In the last post, “Tutorial: delegates and delegation in Swift 4,” I used delegation to communicate between two objects. In the code I wrote for the last article, the app’s main (and only) view controller waited to display an image. The image was not included in the app bundle, rather downloaded from a NASA website. I created a class that downloaded the image file. The view controller was informed that the image was finished downloading and ready to display using a technique called “delegation.” Here, we’ll modify the delegation tutorial code to work with NSNotificationCenter instead. The image downloading class will notify the view controller that the image has finished downloading by sending a notification (message).
I will show you: 1) a one-post-to-one-observer notification; and, 2) a broadcast, where one post is received by many observers. Download the project and follow along in Xcode. Here’s the app we’ll build:
Background
In the parlance of an object-oriented programming language like Objective-C, a phrase like “calling an object method” is synonymous with the phrase “sending a message to an object instance.” This is not the kind of messages we’re talking about today.
We’re going to talk about NSNotificationCenter, which is a much more freewheeling approach to communication between aspects (objects) of an application.
A good metaphor for NSNotificationCenter is a radio station with a bunch of people tuned in and listening. The radio station applies for and gets a specific frequency, say, 104.4 FM, from the FCC. It broadcasts music and talk shows — content that people want to hear. That content is a form of message. If people out there in the radio station’s listening area want to listen to 104.4 FM, they have to tune their radios to match the FM frequency of 104.4. They’ve subscribed to 104.4. There’s one radio station in the area with frequency 104.4 FM and there are a bunch of people listening to 104.4 FM. People don’t have to listen to 104.4 FM, but they can if they want. Listeners don’t have to know any details about the radio station (like its office address, annual revenues, etc.). The radio station doesn’t have to know the blood type and refrigerator make of each listener (though with today’s aggressive marketing approaches, they’d probably like to know).
A developer can use NSNotificationCenter to post (send) message(s) with a unique ID and a bit of some optional extra data. These messages (NSNotifications) are sent out — broadcast — into the cosmos, and there’s no guarantee that anyone is listening. If there are listeners (observers) who have subscribed to that message with that unique ID (NSNotification.Name), those listeners will receive the message.
Yes, there can be one notifier and one observer, but here’s the kicker: there can be one notifier and many observers, just like in my radio station metaphor.
NSNotificationCenter is an example of loose coupling. The players don’t have a whole lot of interdependencies. I started this article mentioning Objective-C and one object calling a method of another object. Even with Objective-C’s late/dynamic binding, objects need to know some things about other objects when calling each other’s methods (if you want the methods to work; if they’re optional, who cares?). All’s I’m saying is that method calls are more tightly coupled than sending messages via NSNotificationCenter.
Whenever messaging technologies like NSNotificationCenter are brought up, the inevitable comparison to delegation is brought up. Developers need to know when objects should communicate via NSNotificationCenter or delegation (see my detailed tutorial here).
Here is Apple’s take on calling object methods and the differences between notifications and delegation:
The standard way to pass information between objects is message passing–in which one object invokes the method of another object. However, message passing requires that the object sending the message know who the receiver is and what messages it responds to. This requirement is true of delegation messages as well as other types of messages. At times, this tight coupling of two objects is undesirable–most notably because it would join together what might be two otherwise independent subsystems. And it is impractical because it would require hard-coded connections between many disparate objects in an application.
For cases where standard message passing just won’t do, Cocoa offers the broadcast model of notification. By using the notification mechanism, one object can keep other objects informed of what it is doing. In this sense, it is similar to delegation, but the differences are important. The key distinction between delegation and notification is that the former is a one-to-one communication path (between the delegating object and its delegate). But notification is a potentially one-to-many form of communication–it is a broadcast. An object can have only one delegate, but it can have many observers, as the recipients of notification are known. And the object doesn’t have to know what those observers are. Any object can observe an event indirectly via notification and adjust its own appearance, behavior, and state in response to the event. Notification is a powerful mechanism for attaining coordination and cohesion in a program.
You already use NSNotificationCenter
Just so you know, you’re already using notifications in your apps (the following quote applies to macOS, but the same type of thing is happening in iOS):
The delegate of most Cocoa framework classes is automatically registered as an observer of notifications posted by the delegating object. The delegate need only implement a notification method declared by the framework class to receive a particular notification message. Following the example above, a window object posts an NSWindowWillCloseNotification to observers but sends a windowShouldClose: message to its delegate.
How notifications work
Generally, from Apple’s documentation:
How the notification mechanism works is conceptually straightforward. A process has an object called a notification center, which acts as a clearing house and broadcast center for notifications. Objects that need to know about an event elsewhere in the application register with the notification center to let it know they want to be notified when that event happens. An example of this is a controller object that needs to know when a pop-up menu choice is made so it can reflect this change in the user interface. When the event does happen, the object that is handling the event posts a notification to the notification center, which then dispatches the notification to all of its observers.
Specifically, from Apple’s documentation:
Objects register with a notification center to receive notifications (NSNotification objects) using the addObserver(_:selector:name:object:) or addObserver(forName:object:queue:using:) methods. When an object adds itself as an observer, it specifies which notifications it should receive. An object may therefore call this method several times in order to register itself as an observer for several different notifications.
Each running app has a default notification center, and you can create new notification centers to organize communications in particular contexts.
… and from related documentation …
Posts a given notification to the notification center…
Posting Notifications …
|
1 |
func post(name: NSNotification.Name, object: Any?) |
Creates a notification with a given name and sender and posts it to the notification center.
Notification setup workflow
This is the order in which I set up messaging using NSNotificationCenter:
1) define global and unique notification identifiers for each notification to be sent/broadcast and received;
2) decide where I am going to listen/observe for notifications and what, in general, to do when I receive those notifications;
3) decide where I am going to send/post/broadcast notifications;
4) define what specifically I’ll do when I receive notifications; and,
5) stop listening for notifications — remove the observers — when I know I am done with notifications.
I know my steps may seem a little odd, but you’re probably starting to realize that I design — at least outline — my overall solution before implementing it.
The code
Think about what you just read, compare to my previous post, then read the code and inline commentary below. Download the sample code, build, and run the app. Note my comments in the code where I’ve materialized my notification setup workflow steps for messaging using NSNotificationCenter (STEP 1, STEP 2.1, STEP 2.2, STEP 3.1, STEP 3.2, STEP 4.1, STEP 4.2, and STEP 5).
LogoDownloader.swift
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 |
import Foundation import UIKit // STEP 1: Define unique strings to identify the purpose of // all this app's notifications. I've defined these as global // constants because messages are often sent to various locations // throughout an app. I use my reverse domain name because // I know it will be unique and won't clash with any // iOS-based notifications. let logoDownloadNotificationID = "com.iosbrain.logoDownloadCompletedNotificationID" let welcomeReadyNotificationID = "com.iosbrain.welcomeReadyNotificationID" class LogoDownloader { var logoURL:String var image:UIImage? init(logoURL:String) { self.logoURL = logoURL } func downloadLogo() -> Void { // Start the image download task asynchronously by submitting // it to the default background queue; this task is submitted // and DispatchQueue.global returns immediately. DispatchQueue.global(qos: DispatchQoS.QoSClass.default).async { // I'm PURPOSEFULLY downloading the image using a synchronous call // (NSData), but I'm doing so in the BACKGROUND. let imageURL = URL(string: self.logoURL) let imageData = NSData(contentsOf: imageURL!) self.image = UIImage(data: imageData! as Data) print("image downloaded") // Once the image finishes downloading, I jump onto the MAIN // THREAD TO UPDATE THE UI. DispatchQueue.main.async { // Tell somebody listening that the image // has downloaded so the listener can // display the image. self.didDownloadImage() } } // end DispatchQueue.global } // STEP 3.1: When the image finishes downloading, this method is // called and it "posts" (sends) a "notification" // (message) to anyone who's "observing" (listening). Note below // that this class ("object: self") is posting the notification. func didDownloadImage() { NotificationCenter.default.post(name: Notification.Name(rawValue: logoDownloadNotificationID), object: self) } } // end class LogoDownloader |
ViewController.swift
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 |
import UIKit // NOTE: I set auto layout constraints for the view controller // in the storyboard corresponding to this ViewController // for "View as: iPhone SE." class ViewController: UIViewController { @IBOutlet weak var loadingLabel: UILabel! @IBOutlet weak var loginView: UIView! @IBOutlet weak var imageView: UIImageView! @IBOutlet weak var leftSquareView: UIView! @IBOutlet weak var welcomeLabel: UILabel! @IBOutlet weak var rightSquareView: UIView! var logoDownloader:LogoDownloader? override func viewDidLoad() { super.viewDidLoad() // Do any additional setup after loading the view, typically from a nib. // // This is ONE-TO-ONE: one sender (post) and one listener // (observer). // // STEP 2.1: Start "observing" (listening) for ONE "notification" // (message) labelled "com.iosbrain.logoDownloadCompletedNotificationID"; // when we receive this message, we call the didFinishDownloading method to // display the login interface. The observer is this class, // ViewController. NotificationCenter.default.addObserver(self, selector: #selector(didFinishDownloading), name: Notification.Name(rawValue: logoDownloadNotificationID), object: nil) // // STEP 2.2: // // This is ONE-TO-MANY: one sender (post) and MANY listeners // (observers). This of my radio station analogy. // // Start "observing" (listening) for THREE "notifications" // (messages) ALL labelled "com.iosbrain.welcomeReadyNotificationID"; // when we receive these messages, we call the showLeftSquare, // showWelcomeLabel, and showRightSquare methods to // display the welcome interface. The observer is this class, // ViewController. NotificationCenter.default.addObserver(self, selector: #selector(showLeftSquare), name: Notification.Name(rawValue: welcomeReadyNotificationID), object: nil) NotificationCenter.default.addObserver(self, selector: #selector(showWelcomeLabel), name: Notification.Name(rawValue: welcomeReadyNotificationID), object: nil) NotificationCenter.default.addObserver(self, selector: #selector(showRightSquare), name: Notification.Name(rawValue: welcomeReadyNotificationID), object: nil) // Initially, the "Welcome" label and two green views are hidden -- being // saved for that juicy login. leftSquareView.alpha = 0.0 welcomeLabel.alpha = 0.0 rightSquareView.alpha = 0.0 // Initially, the image view is hidden so we can fade it in with animation. imageView.alpha = 0.0 // Initially, the login area, with username, password, and // login button are hidden until the logo image downloads; // then we fade it in. loginView.alpha = 0.0 // NASA images used pursuant to https://www.nasa.gov/multimedia/guidelines/index.html let imageURL: String = "https://cdn.spacetelescope.org/archives/images/publicationjpg/heic1509a.jpg" // Construct a LogoDownloader to download the NASA file. logoDownloader = LogoDownloader(logoURL: imageURL) // Start the logo image download and get informed when it // finishes downloading -- that'll be when // didFinishDownloading() is called. logoDownloader?.downloadLogo() } // end func viewDidLoad() override func didReceiveMemoryWarning() { super.didReceiveMemoryWarning() // Dispose of any resources that can be recreated. } // STEP 5: It's good practice to remember to STOP // listening (observing) for notifications (messages) // once listening won't do us any good. In a more complex // and dynamic scenario, you'd see why you'd want to be // tiddy. deinit { NotificationCenter.default.removeObserver(self, name: Notification.Name(rawValue: logoDownloadNotificationID), object: nil) NotificationCenter.default.removeObserver(self, name: Notification.Name(rawValue: welcomeReadyNotificationID), object: nil) } // STEP 4.2: When welcomeReadyNotificationID is // received, THESE THREE methods are executed. // These methods are called when we receive a notification // that "Login" button was clicked. // NOTE the "@objc" definition (homework). @objc func showLeftSquare() { UIView.animate(withDuration: 1.0) { self.leftSquareView.alpha = 1.0 } } @objc func showWelcomeLabel() { UIView.animate(withDuration: 1.0) { self.welcomeLabel.alpha = 1.0 } } @objc func showRightSquare() { UIView.animate(withDuration: 1.0) { self.rightSquareView.alpha = 1.0 } } // ------------------------------- // STEP 4.1: When logoDownloadNotificationID is // received, this is the method that's executed. // This method is called when we receive a notification // that the logo image finished downloading. // NOTE the "@objc" definition (homework). @objc func didFinishDownloading() { imageView.image = logoDownloader?.image // Animate the appearance of this ViewController's // user interface. UIView.animate(withDuration: 2.0, delay: 0.5, options: UIViewAnimationOptions.curveEaseIn, animations: { self.loadingLabel.alpha = 0.0 self.imageView.alpha = 1.0 }) { (completed:Bool) in if (completed) { UIView.animate(withDuration: 2.0) { self.loginView.alpha = 1.0 } } } } // end func didFinishDownloading // STEP 3.2: When we can click the "Login" button, and do so, // this method is called and it BROADCASTS -- "posts" (sends) -- // a "notification" (message) to anyone who's "observing" (listening). // Note below that this class ("object: self") is posting the notification. @IBAction func loginButtonTapped(_ sender: Any) { NotificationCenter.default.post(name: Notification.Name(rawValue: welcomeReadyNotificationID), object: self) } } // end class ViewController |
What did you think?
Do you understand NSNotificationCenter and messaging in iOS and Swift? Notifications are easier to wrap your brain around than delegates, but be warned, do not fall into the trap of over-using notifications. You’ll end up with the biggest tangle of spaghetti imaginable.
As always, listen to your grandfather! Practice, pratice, practice, get experience, work hard — but please play and enjoy your lives, too!
