Let’s say you have somewhat bigger app and need to update its after user changes settings. Maybe they selected new ordering for list items, changed language or what not. Or maybe you need to display notifications badge on multiple screens.
Some of these challenges could be solved with delegates or closures. But you would need to properly connect all these parts and the result would be tightly coupled. Your list controller would need to know about settings controller and vice versa to be notified about changes.
Fortunately iOS provides pretty neat solution called NotificationCenter
. This has nothing to do with push notifications or any other kind of notifications the user might see. Instead it is a way to propagate changes and send data across your application.
When you need to originate change you will use NotificationCenter
to post a notification and that is the first part done. The second part is to set observers for specific notifications when you need to know about something happening.
Basic NotificationCenter
usage
Imagine we want to change list (or rather TableView) ordering on multiple screens after user changes preference in settings screen.
In the settings controller, we would have method like this:
func saveOrderingPreference(new preference: String) {
UserDefaults.standard.set(preference, forKey: "orderingPreference")
NotificationCenter.default.post(Notification(name: Notification.Name(rawValue: "orderingPreferenceChanged")))
}
In real code we would have enum
for preferences and constant for UserDefaults
key but this is an example :-)
The second line will use default NotificationCenter
to post notification. It does not care whether anyone is listening.
Extension for notification constants
You may spot the issue with the Notification
object construction which is not that pretty. Fortunately we can create extension
to provide constants for notifications:
extension Notification.Name {
static let orderingPreferenceChanged = Notification.Name("orderingPreferenceChanged")
}
I recommend using fairly long and descriptive names for notifications so they don’t have chance to clash.
Now the post
method call looks much better:
NotificationCenter.default.post(name: .orderingPreferenceChanged, object: nil)
Another advantage is that with constant we don’t have to worry about misspelling the name.
Now let’s subscribe to our new notification:
NotificationCenter.default.addObserver(self, selector: #selector(onOrderingPreferenceChanged), name: .orderingPreferenceChanged, object: nil)
This is typically done in viewDidLoad
in case of a view controller. You have the name
of the notification and #selector
to mark method to execute when notification is received.
@objc func onOrderingPreferenceChanged() {
// reload data
}
And this is basic example finished. However there are few things you should know about NotificationCenter
.
Few things to note
The method selected in observer may not be executed on the main thread which will mean problems for UI related stuff like tableView.reloadData()
. It is best to always use DispatchQueue.main.async
when manipulating UI like so:
@objc func onOrderingPreferenceChanged() {
DispatchQueue.main.async {
// reload data
}
}
Correctly handling incoming notification should be the receiver’s responsibility so posting notifications with DispatchQueue
is not a solution.
Also NotificationCenter
work synchronously, meaning all observers have to finish work for you code after post
call to continue.
You don’t have to use NotificationCenter.default
, you can create your own. This can be useful during testing or when you want to have absolute certainty that no other code (not even OS) is sending and receiving notifications.
How to send data with NotificationCenter
Notification center uses the userInfo
design pattern which you can leverage to send simple data with your notification. This could be id of item to act upon or any other primitive type.
We would add userInfo
to post
like this:
NotificationCenter.default.post(name: .orderingPreferenceChanged, object: nil, userInfo: ["preference”: new])
And then modify our method signature to have Notification
parameter:
@objc func onOrderingPreferenceChanged(notification: Notification) {
}
Don’t forget to change the addObserver
:
NotificationCenter.default.addObserver(self, selector: #selector(onOrderingPreferenceChanged(notification:)), name: .orderingPreferenceChanged, object: nil)
And access the sent data:
@objc func onOrderingPreferenceChanged(notification: Notification) {
if let userInfo = notification.userInfo, let preference = userInfo[“preference”] as? String {
}
}
Thanks for reading!
Is anything not clear? Do you want more information? Ask in the comments and I will do my best to help you. Thanks for reading!
Top comments (0)