Invalidation token returned from Notification Center is not Send/Sync

[pronebird]

let handle = win.ns_window().unwrap() as *mut objc2_app_kit::NSWindow;
                let handle = objc2::rc::Retained::retain(handle).unwrap();

let nc = NSNotificationCenter::defaultCenter();
let invalidationToken = nc.addObserverForName_object_queue_usingBlock(
    Some(NSWindowDidBecomeKeyNotification),
    Some(handle.deref()),
    None,
    &RcBlock::new(|notification| {
        // Handle window becoming key
        tracing::info!("Window became key");
    }),
);

Basically it's impossible to store invalidationToken anywhere

[madsmtm]

Yeah, the API isn't marked NS_SWIFT_SENDABLE in the headers - and I'm pretty sure you'd get the same problem with Swift? See also a bit of discussion on thread-safety of notifications in https://developer.apple.com/documentation/foundation/notification-center-messages.

Why do you need it to be Send/Sync? In Winit, I create notifications and store them on a non-Send/Sync object, see https://github.com/rust-windowing/winit/blob/b8f28efd04a6a1d5cce47779228a16d574d0ea62/winit-uikit/src/event_loop.rs#L123-L239.

[pronebird]

Yeah, the API isn't marked NS_SWIFT_SENDABLE in the headers - and I'm pretty sure you'd get the same problem with Swift? See also a bit of discussion on thread-safety of notifications in https://developer.apple.com/documentation/foundation/notification-center-messages.

Why do you need it to be Send/Sync? In Winit, I create notifications and store them on a non-Send/Sync object, see https://github.com/rust-windowing/winit/blob/b8f28efd04a6a1d5cce47779228a16d574d0ea62/winit-uikit/src/event_loop.rs#L123-L239.

Using them in Tauri. I am holding the invalidation token in a state behind Mutex. Either way I go about it, State in tauri has to be send/sync I believe.

[madsmtm]

Hmm. We can just change addObserverForName_object_queue_usingBlock to return Retained<ProtocolObject<dyn NSObjectProtocol + Send + Sync>>, that works, but I'm not perfectly convinced that it'd be safe to do?

NSNotificationCenter itself is Send + Sync, but maybe you could imagine it being implemented using thread-locals, which would mean that any de-registration would have to happen on the same thread as registration? Or possibly it's UB if you share the opaque to several different threads, and try to to deregister it on multiple threads at the same time? Unsure, maybe that's just me being overly cautious.

---

Anyhow, in the meantime, there are two options for you:

You could use dispatch::MainThreadBound:

type InvalidationToken = MainThreadBound<Retained<ProtocolObject<dyn NSObjectProtocol>>>;

let mtm = MainThreadMarker::new().expect("must be on the main thread");
let invalidationToken = MainThreadBound::new(invalidationToken, mtm);

Though that requires that you're registering from the main thread, and it requires that the event loop to be running while, so if it's not Dropped by Tauri on the main thread, it might block on shutdown.

Alternatively, unsafely cast it to ProtocolObject<dyn NSObjectProtocol + Send + Sync>:

let invalidationToken = unsafe { Retained::cast_unchecked::<ProtocolObject<dyn NSObjectProtocol + Send + Sync>>(invalidationToken) };

[pronebird]

Thanks for suggested alternatives. I will go with unchecked cast and perhaps ensure to call the code on main thread.

Perhaps being cautious is good.