Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
A notification center for Darwin Notifications. MIT License applies.
//
// DarwinNotificationCenter.swift
//
// Copyright © 2017 WeTransfer. All rights reserved.
//
import Foundation
/// A Darwin notification payload. It does not contain any userInfo, a Darwin notification is purely event handling.
public struct DarwinNotification {
/// The Darwin notification name
public struct Name: Equatable {
/// The CFNotificationName's value
fileprivate var rawValue: CFString
}
/// The Darwin notification name
var name: Name
/// Initializes the notification based on the name.
fileprivate init(_ name: Name) {
self.name = name
}
}
// MARK: -
extension DarwinNotification.Name {
/// Initializes a new Notification Name, based on a custom string. This string should be identifying for not only this notification, but for the full system. Therefore, you should include a bundle identifier to the string.
public init(_ rawValue: String) {
self.rawValue = rawValue as CFString
}
/// Initialize a new Notification Name, based on a CFNotificationName.
init(_ cfNotificationName: CFNotificationName) {
rawValue = cfNotificationName.rawValue
}
public static func == (lhs: DarwinNotification.Name, rhs: DarwinNotification.Name) -> Bool {
return (lhs.rawValue as String) == (rhs.rawValue as String)
}
}
// MARK: -
/// A system-wide notification center. This means that all notifications will be delivered to all interested observers, regardless of the process owner. Darwin notifications don't support userInfo payloads to the notifications. This wrapper is thread-safe.
public final class DarwinNotificationCenter {
/// An active observation by an observer.
fileprivate final class Observation {
/// The handler to be executed when the notification is received.
let handler: NotificationHandler
/// The notification name where the observer is interested in.
let name: DarwinNotification.Name
/// The interested object
weak var observer: AnyObject?
init(observer: AnyObject, name: DarwinNotification.Name, handler: @escaping NotificationHandler) {
self.observer = observer
self.name = name
self.handler = handler
observe()
}
}
/// The handler type to be executed when the notification is received.
public typealias NotificationHandler = ((DarwinNotification) -> Void)
/// The shared DarwinNotificationCenter, it will always return the same instance.
public static var shared = DarwinNotificationCenter()
/// The underlying CFNotificationCenter.
private let center = CFNotificationCenterGetDarwinNotifyCenter()
/// All observation info. This frequently needs some cleanup, as done by the cleanupObservers() method.
private var observations = [Observation]()
/// A serial queue to sync all observation changes onto, to make the wrapper thread-safe.
private let queue = DispatchQueue(label: "com.wetransfer.darwin-notificationcenter", qos: .default, attributes: [], autoreleaseFrequency: .workItem)
private init() {}
// MARK: -
/// Cleanup all deallocated observers
private func cleanupObservers() {
queue.async {
self.observations = self.observations.filter { (observation) -> Bool in
let stillAlive = observation.observer != nil
if !stillAlive {
observation.unobserve()
}
return stillAlive
}
}
}
/// Adds a given observer, to watch for the given Darwin notification, using a given handler.
///
/// - Parameters:
/// - observer: The observer that is interested in the notification. Whenever the observer gets deallocated, the handler won't be guaranteed to be called anymore.
/// - name: The notification name of interest.
/// - handler: The handler to be executed when the notification is received. This will always be executed on a dedicated userinteractive queue, so NOT the main queue. If you want, you can dispatch to the main queue yourself.
public func addObserver(_ observer: AnyObject, for name: DarwinNotification.Name, using handler: @escaping NotificationHandler) {
cleanupObservers()
queue.async {
let observation = Observation(observer: observer, name: name, handler: handler)
if !self.observations.contains(observation) {
self.observations.append(observation)
}
}
}
/// Remove a given observer. By default, all notifications for the given observer will be removed, but it's also possible to pass a specific notification name.
///
/// - Parameters:
/// - observer: The observer that needs to be removed.
/// - name: The notification name that is not interesting anymore. This is nil by default, meaning that all notifications will be removed for the given observer.
public func removeObserver(_ observer: AnyObject, for name: DarwinNotification.Name? = nil) {
cleanupObservers()
queue.async {
self.observations = self.observations.filter { (observation) -> Bool in
let shouldRetain = observer !== observation.observer || (name != nil && observation.name != name)
if !shouldRetain {
observation.unobserve()
}
return shouldRetain
}
}
}
/// Checks whether the given object is an observer for the given notification name.
///
/// - Parameters:
/// - observer: The observer to check.
/// - name: The name to check.
/// - Returns: Whether the object is an observer.
public func isObserver(_ observer: AnyObject, for name: DarwinNotification.Name? = nil) -> Bool {
cleanupObservers()
return queue.sync(execute: { () -> Bool in
return observations.contains(where: { (observation) -> Bool in
return observer === observation.observer && (name == nil || observation.name == name)
})
})
}
/// Posts the given Notification name to the system.
///
/// - Parameter name: The notification name to post.
public func postNotification(_ name: DarwinNotification.Name) {
// Before posting a notification, cleanup all observers that are deallocated.
cleanupObservers()
guard let cfNotificationCenter = self.center else {
fatalError("Invalid CFNotificationCenter")
}
CFNotificationCenterPostNotification(cfNotificationCenter, CFNotificationName(rawValue: name.rawValue), nil, nil, false)
}
/// Execute the observation handler for all observers that observe the given notification name.
private func signalNotification(_ name: DarwinNotification.Name) {
cleanupObservers()
queue.async {
let affectedObservations = self.observations.filter({ (observation) -> Bool in
return observation.name == name
})
let notification = DarwinNotification(name)
for observation in affectedObservations {
observation.handler(notification)
}
}
}
}
// MARK: -
extension DarwinNotificationCenter.Observation: Equatable {
/// Start observing the notification.
fileprivate func observe() {
guard let cfCenter = DarwinNotificationCenter.shared.center else {
fatalError("Invalid Darwin observation info.")
}
// A notification callback. Since this is a C function pointer, it can not have any ownership context.
let callback: CFNotificationCallback = { (center, observer, name, object, userInfo) in
guard let cfName = name else {
return
}
let notificationName = DarwinNotification.Name(cfName)
DarwinNotificationCenter.shared.signalNotification(notificationName)
}
let observer = Unmanaged.passUnretained(self).toOpaque()
CFNotificationCenterAddObserver(cfCenter, observer, callback, name.rawValue, nil, .coalesce)
}
/// Stop observing the notification. This should be done whenever the observation is going to be removed.
fileprivate func unobserve() {
guard let cfCenter = DarwinNotificationCenter.shared.center else {
fatalError("Invalid Darwin observation info.")
}
let notificationName = CFNotificationName(rawValue: name.rawValue)
var observer = self
CFNotificationCenterRemoveObserver(cfCenter, &observer, notificationName, nil)
}
static func == (lhs: DarwinNotificationCenter.Observation, rhs: DarwinNotificationCenter.Observation) -> Bool {
return lhs.observer === rhs.observer && lhs.name == rhs.name
}
}
@patka817

This comment has been minimized.

Copy link

@patka817 patka817 commented Jan 22, 2020

Nicely done, just one thing: won't this post the same notification multiple times if you have multiple observers for the same notification name? Since every observation (one per observer) will get the callback for the given name which in turn will call the shared DarwinNotificationCenter which in turn will call all observers for that notification name.. 🤔

@AvdLee

This comment has been minimized.

Copy link
Owner Author

@AvdLee AvdLee commented Jan 22, 2020

It shouldn't as we check whether an observation is already registered. Could you point me more precisely where you think that is caused?

@patka817

This comment has been minimized.

Copy link

@patka817 patka817 commented Jan 22, 2020

If you add two observers (different instances, lets say a view and a class for caching data) for the same notificationname, then the generated observations will hold two different observers and the equality-check will yield false -> you have two observations on the same name -> two callbacks each time CFNotificationCenter notifies for that name. If im reasoning correctly that is..

Sorry for the wall of text, answering from the phone :)

@AvdLee

This comment has been minimized.

Copy link
Owner Author

@AvdLee AvdLee commented Jan 23, 2020

No worries, it made me understand it! We shouldn't add another observer here: https://gist.github.com/AvdLee/07de0b0fe7dbc351541ab817b9eb6c1c#file-darwinnotificationcenter-swift-L207 if it's already observing a certain name.

I don't have the time to solve it right now but feel free to go ahead and let me know what's needed to change it!

@patka817

This comment has been minimized.

Copy link

@patka817 patka817 commented Jan 23, 2020

Yup, correct. I would probably change the Observation class itself, make it hold an array of tuple's which binds observers and their callbacks together. E.g. observers = [(WeakObserver, NotificationHandler)]. Where WeakObserver would be a class that holds an AnyObject weakly. Then you would have to change a bit on isObserver, addObserver, removeObserver, cleanObservers and signalNotification. Then you would only have one Observation per DarwinNotification.

There is a variant where one can wrap the notificationhandler closure and before calling it, checking if the observer is nil and autoremove itself. It's quite nice imo (but depends on how often one wants to remove observers):

func add(observer: AnyObject, handler: Handler) {
    let id = ObjectIdentifier(observer)
    let callback = { [weak observer, weak self] (name) in
        if (observer == nil) {
             self?.callbacks[id] = nil
             return
         }
       handler(name)
    } 

    callbacks[id] = callback
}

Using a dictionary in this case, which makes it easier to remove them with the ObjectIdentifier.

There is probably more ways to achieve this, maybe some which requires less rewrites..

@OleksandStepanov

This comment has been minimized.

Copy link

@OleksandStepanov OleksandStepanov commented Jan 1, 2021

Hello @AvdLee,

Do you know, does Darwin notifications mechanism is still viable approach for communication between the container app and extension on iOS? I've seen some controversial information on web, particularly there are some unresolved issues on MMWormhole project, which is used the same approach. There are reports that starting from iOS 13 this mechanism had been stopped working for container app <-> extension.
Any information would be much appreciated.

With regards.

@AvdLee

This comment has been minimized.

Copy link
Owner Author

@AvdLee AvdLee commented Jan 4, 2021

@OleksandStepanov we're no longer using it and replaced it with Persistent History Tracking.

@patka817

This comment has been minimized.

Copy link

@patka817 patka817 commented Jan 4, 2021

@OleksandStepanov it is possible to use an appgroup and a userdefaults in the appgroup which makes it possible to key-value observe entries. I have made an extension which defines computed properties on userdefault that are @objc marked which enables the use of combine on those computed properties. E.g. making it possible to react to changes on value changed. For pure notification it is possible to have a bool that is toggled to propagate changes (a bit hacky but works).

@OleksandStepanov

This comment has been minimized.

Copy link

@OleksandStepanov OleksandStepanov commented Jan 4, 2021

@AvdLee,
Thanks, I got you.

@patka817,
Yes, I'm aware about the possibility to share data via app group container, but for some types of extensions, it is not available.
I'm just wondering, is Darwin notifications mechanism is still available in this case, or not. Looks like the only way is to try it.

@patka817

This comment has been minimized.

Copy link

@patka817 patka817 commented Jan 4, 2021

@OleksandStepanov Did a quick test, seems to work. Not sure about that MMWormHole. Tested on iPhone 8 with iOS 14.2, although only debug build.

@OleksandStepanov

This comment has been minimized.

Copy link

@OleksandStepanov OleksandStepanov commented Jan 5, 2021

@patka817,
Cool, thank you very much! We will give it a try in our project too.

@florentmorin

This comment has been minimized.

Copy link

@florentmorin florentmorin commented Apr 17, 2021

@AvdLee : Thank you for this awesome work.

I just made a fork integrating Combine support.
Not sure it's the best implementation (it's my first custom publisher), but it works™.

Usage:

let center = DarwinNotificationCenter.shared
let name = DarwinNotification.Name("MarvelIsAnAwesomeDog")
        
let cancellable = center.publisher(for: name)
    .sink { notification in
        print("Notification received: ", notification)
    }

// later...        
cancellable.cancel()

https://gist.github.com/florentmorin/35b15837cd4fb2a2a0630dbdf41d09aa

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment