listen_global can't be shared between threads safely

[fcoury]

I am writing my app's setup method to listen to a global event, where I am basically using the same approach described here:

https://tauri.app/v1/guides/features/events#global-events-1

But I am getting a specific error about thread safety (full error below):

error[E0277]: `Rc<tao::event_loop::EventLoopWindowTarget<tauri_runtime_wry::Message<EventLoopMessage>>>` cannot be shared between threads safely
   --> src/main.rs:25:26
    |
25  |             let id = app.listen_global("update-battery", |event| {
    |                          ^^^^^^^^^^^^^ `Rc<tao::event_loop::EventLoopWindowTarget<tauri_runtime_wry::Message<EventLoopMessage>>>` cannot be shared between threads safely

Here's the relevant part of my code:

    #[allow(unused_mut)]
    let mut app = tauri::Builder::default()
        .setup(|app| {
            let id = app.listen_global("update-battery", |event| {
                app.tray_handle().get_item("battery").set_title("New title");
            });
            app.unlisten(id);
            Ok(())
        })
        .system_tray(SystemTray::new().with_menu(items))

Can you help me understand the difference between my implementation and the documentation mentioned above?

For reference, here's the full main.rs:

use razermacos::{devices::USB_DEVICE_ID_RAZER_VIPER_ULTIMATE_WIRELESS, RazerDevices};
use tauri::{CustomMenuItem, Manager, RunEvent, SystemTray, SystemTrayEvent, SystemTrayMenu};

#[derive(Clone, serde::Serialize)]
struct BatteryStatus {
    pub percentage: u8,
    pub charging: bool,
}

fn main() {
    let item = if let Some(status) = get_status(USB_DEVICE_ID_RAZER_VIPER_ULTIMATE_WIRELESS) {
        let ch_str = if status.charging { " ⚡️" } else { "" };
        CustomMenuItem::new(
            "battery",
            format!("Battery: 🔋{}%{}", status.percentage, ch_str),
        )
    } else {
        CustomMenuItem::new("battery", "No devices found.")
    };
    let items = SystemTrayMenu::new().add_item(item);

    #[allow(unused_mut)]
    let mut app = tauri::Builder::default()
        .setup(|app| {
            let id = app.listen_global("update-battery", |event| {
                app.tray_handle().get_item("battery").set_title("New title");
            });
            app.unlisten(id);
            Ok(())
        })
        .system_tray(SystemTray::new().with_menu(items))
        .on_system_tray_event(|app, event| match event {
            SystemTrayEvent::RightClick {
                position: _,
                size: _,
                ..
            } => {
                let window = app.get_window("main").unwrap();
                window.show().unwrap();
                window.set_focus().unwrap();
            }
            SystemTrayEvent::MenuItemClick { id, .. } => {
                let _item_handle = app.tray_handle().get_item(&id);
                match id.as_str() {
                    "battery" => {
                        if let Some(status) =
                            get_status(USB_DEVICE_ID_RAZER_VIPER_ULTIMATE_WIRELESS)
                        {
                            app.emit_all("update-battery", status);
                        }
                    }
                    "no_devices" => {
                        eprintln!("No devices clicked");
                    }
                    "quit" => {
                        app.exit(0);
                    }
                    _ => {}
                }
            }
            _ => {}
        })
        .build(tauri::generate_context!())
        .expect("error while building tauri application");

    app.run(move |_app_handle, e| {
        if let RunEvent::ExitRequested { api, .. } = &e {
            api.prevent_exit();
        }
        // if let Some(on_event) = &mut on_event {
        //     (on_event)(app_handle, e);
        // }
    });
}

fn get_status(device_id: u32) -> Option<BatteryStatus> {
    let mut devices = RazerDevices::all();
    let device = devices.find(device_id as u16);

    if let Some(device) = device {
        return Some(BatteryStatus {
            percentage: device.battery(),
            charging: device.is_charging(),
        });
    }

    None
}

And full backtrace:

   Compiling app v0.1.0 (/Users/fcoury/code/razermon/src-tauri)
error[E0277]: `Rc<tao::event_loop::EventLoopWindowTarget<tauri_runtime_wry::Message<EventLoopMessage>>>` cannot be shared between threads safely
   --> src/main.rs:25:26
    |
25  |             let id = app.listen_global("update-battery", |event| {
    |                          ^^^^^^^^^^^^^ `Rc<tao::event_loop::EventLoopWindowTarget<tauri_runtime_wry::Message<EventLoopMessage>>>` cannot be shared between threads safely
    |
    = help: within `tauri::App`, the trait `Sync` is not implemented for `Rc<tao::event_loop::EventLoopWindowTarget<tauri_runtime_wry::Message<EventLoopMessage>>>`
    = note: required because it appears within the type `tao::platform_impl::platform::event_loop::EventLoop<tauri_runtime_wry::Message<EventLoopMessage>>`
    = note: required because it appears within the type `tao::event_loop::EventLoop<tauri_runtime_wry::Message<EventLoopMessage>>`
    = note: required because it appears within the type `tauri_runtime_wry::Wry<EventLoopMessage>`
    = note: required because it appears within the type `std::option::Option<tauri_runtime_wry::Wry<EventLoopMessage>>`
    = note: required because it appears within the type `tauri::App`
    = note: required because of the requirements on the impl of `Send` for `&tauri::App`
note: required because it's used within this closure
   --> src/main.rs:25:58
    |
25  |             let id = app.listen_global("update-battery", |event| {
    |                                                          ^^^^^^^
note: required by a bound in `listen_global`
   --> /Users/fcoury/.cargo/registry/src/github.com-1ecc6299db9ec823/tauri-1.1.1/src/lib.rs:605:20
    |
605 |     F: Fn(Event) + Send + 'static,
    |                    ^^^^ required by this bound in `listen_global`

error[E0277]: `Rc<tao::platform_impl::platform::event_loop::PanicInfo>` cannot be shared between threads safely
   --> src/main.rs:25:26
    |
25  |             let id = app.listen_global("update-battery", |event| {
    |                          ^^^^^^^^^^^^^ `Rc<tao::platform_impl::platform::event_loop::PanicInfo>` cannot be shared between threads safely
    |
    = help: within `tauri::App`, the trait `Sync` is not implemented for `Rc<tao::platform_impl::platform::event_loop::PanicInfo>`
    = note: required because it appears within the type `tao::platform_impl::platform::event_loop::EventLoop<tauri_runtime_wry::Message<EventLoopMessage>>`
    = note: required because it appears within the type `tao::event_loop::EventLoop<tauri_runtime_wry::Message<EventLoopMessage>>`
    = note: required because it appears within the type `tauri_runtime_wry::Wry<EventLoopMessage>`
    = note: required because it appears within the type `std::option::Option<tauri_runtime_wry::Wry<EventLoopMessage>>`
    = note: required because it appears within the type `tauri::App`
    = note: required because of the requirements on the impl of `Send` for `&tauri::App`
note: required because it's used within this closure
   --> src/main.rs:25:58
    |
25  |             let id = app.listen_global("update-battery", |event| {
    |                                                          ^^^^^^^
note: required by a bound in `listen_global`
   --> /Users/fcoury/.cargo/registry/src/github.com-1ecc6299db9ec823/tauri-1.1.1/src/lib.rs:605:20
    |
605 |     F: Fn(Event) + Send + 'static,
    |                    ^^^^ required by this bound in `listen_global`

error[E0277]: `*mut ()` cannot be shared between threads safely
   --> src/main.rs:25:26
    |
25  |             let id = app.listen_global("update-battery", |event| {
    |                          ^^^^^^^^^^^^^ `*mut ()` cannot be shared between threads safely
    |
    = help: within `tauri::App`, the trait `Sync` is not implemented for `*mut ()`
    = note: required because it appears within the type `PhantomData<*mut ()>`
    = note: required because it appears within the type `tao::event_loop::EventLoop<tauri_runtime_wry::Message<EventLoopMessage>>`
    = note: required because it appears within the type `tauri_runtime_wry::Wry<EventLoopMessage>`
    = note: required because it appears within the type `std::option::Option<tauri_runtime_wry::Wry<EventLoopMessage>>`
    = note: required because it appears within the type `tauri::App`
    = note: required because of the requirements on the impl of `Send` for `&tauri::App`
note: required because it's used within this closure
   --> src/main.rs:25:58
    |
25  |             let id = app.listen_global("update-battery", |event| {
    |                                                          ^^^^^^^
note: required by a bound in `listen_global`
   --> /Users/fcoury/.cargo/registry/src/github.com-1ecc6299db9ec823/tauri-1.1.1/src/lib.rs:605:20
    |
605 |     F: Fn(Event) + Send + 'static,
    |                    ^^^^ required by this bound in `listen_global`

error[E0277]: `*mut objc::runtime::Object` cannot be shared between threads safely
   --> src/main.rs:25:26
    |
25  |             let id = app.listen_global("update-battery", |event| {
    |                          ^^^^^^^^^^^^^ `*mut objc::runtime::Object` cannot be shared between threads safely
    |
    = help: within `tauri::App`, the trait `Sync` is not implemented for `*mut objc::runtime::Object`
    = note: required because it appears within the type `tao::platform_impl::platform::util::IdRef`
    = note: required because it appears within the type `tao::platform_impl::platform::event_loop::EventLoop<tauri_runtime_wry::Message<EventLoopMessage>>`
    = note: required because it appears within the type `tao::event_loop::EventLoop<tauri_runtime_wry::Message<EventLoopMessage>>`
    = note: required because it appears within the type `tauri_runtime_wry::Wry<EventLoopMessage>`
    = note: required because it appears within the type `std::option::Option<tauri_runtime_wry::Wry<EventLoopMessage>>`
    = note: required because it appears within the type `tauri::App`
    = note: required because of the requirements on the impl of `Send` for `&tauri::App`
note: required because it's used within this closure
   --> src/main.rs:25:58
    |
25  |             let id = app.listen_global("update-battery", |event| {
    |                                                          ^^^^^^^
note: required by a bound in `listen_global`
   --> /Users/fcoury/.cargo/registry/src/github.com-1ecc6299db9ec823/tauri-1.1.1/src/lib.rs:605:20
    |
605 |     F: Fn(Event) + Send + 'static,
    |                    ^^^^ required by this bound in `listen_global`

error[E0277]: `Rc<RefCell<(dyn for<'r, 's, 't0> FnMut(tao::event::Event<'r, tauri_runtime_wry::Message<EventLoopMessage>>, &'s tao::event_loop::EventLoopWindowTarget<tauri_runtime_wry::Message<EventLoopMessage>>, &'t0 mut tao::event_loop::ControlFlow) + 'static)>>` cannot be shared between threads safely
   --> src/main.rs:25:26
    |
25  |             let id = app.listen_global("update-battery", |event| {
    |                          ^^^^^^^^^^^^^ `Rc<RefCell<(dyn for<'r, 's, 't0> FnMut(tao::event::Event<'r, tauri_runtime_wry::Message<EventLoopMessage>>, &'s tao::event_loop::EventLoopWindowTarget<tauri_runtime_wry::Message<EventLoopMessage>>, &'t0 mut tao::event_loop::ControlFlow) + 'static)>>` cannot be shared between threads safely
    |
    = help: within `tauri::App`, the trait `Sync` is not implemented for `Rc<RefCell<(dyn for<'r, 's, 't0> FnMut(tao::event::Event<'r, tauri_runtime_wry::Message<EventLoopMessage>>, &'s tao::event_loop::EventLoopWindowTarget<tauri_runtime_wry::Message<EventLoopMessage>>, &'t0 mut tao::event_loop::ControlFlow) + 'static)>>`
    = note: required because it appears within the type `std::option::Option<Rc<RefCell<(dyn for<'r, 's, 't0> FnMut(tao::event::Event<'r, tauri_runtime_wry::Message<EventLoopMessage>>, &'s tao::event_loop::EventLoopWindowTarget<tauri_runtime_wry::Message<EventLoopMessage>>, &'t0 mut tao::event_loop::ControlFlow) + 'static)>>>`
    = note: required because it appears within the type `tao::platform_impl::platform::event_loop::EventLoop<tauri_runtime_wry::Message<EventLoopMessage>>`
    = note: required because it appears within the type `tao::event_loop::EventLoop<tauri_runtime_wry::Message<EventLoopMessage>>`
    = note: required because it appears within the type `tauri_runtime_wry::Wry<EventLoopMessage>`
    = note: required because it appears within the type `std::option::Option<tauri_runtime_wry::Wry<EventLoopMessage>>`
    = note: required because it appears within the type `tauri::App`
    = note: required because of the requirements on the impl of `Send` for `&tauri::App`
note: required because it's used within this closure
   --> src/main.rs:25:58
    |
25  |             let id = app.listen_global("update-battery", |event| {
    |                                                          ^^^^^^^
note: required by a bound in `listen_global`
   --> /Users/fcoury/.cargo/registry/src/github.com-1ecc6299db9ec823/tauri-1.1.1/src/lib.rs:605:20
    |
605 |     F: Fn(Event) + Send + 'static,
    |                    ^^^^ required by this bound in `listen_global`

error[E0277]: `(dyn tauri_runtime_wry::Plugin<EventLoopMessage> + 'static)` cannot be shared between threads safely
   --> src/main.rs:25:26
    |
25  |             let id = app.listen_global("update-battery", |event| {
    |                          ^^^^^^^^^^^^^ `(dyn tauri_runtime_wry::Plugin<EventLoopMessage> + 'static)` cannot be shared between threads safely
    |
    = help: the trait `Sync` is not implemented for `(dyn tauri_runtime_wry::Plugin<EventLoopMessage> + 'static)`
    = note: required because of the requirements on the impl of `Sync` for `Unique<(dyn tauri_runtime_wry::Plugin<EventLoopMessage> + 'static)>`
    = note: required because it appears within the type `Box<(dyn tauri_runtime_wry::Plugin<EventLoopMessage> + 'static)>`
    = note: required because of the requirements on the impl of `Sync` for `Unique<Box<(dyn tauri_runtime_wry::Plugin<EventLoopMessage> + 'static)>>`
    = note: required because it appears within the type `alloc::raw_vec::RawVec<Box<(dyn tauri_runtime_wry::Plugin<EventLoopMessage> + 'static)>>`
    = note: required because it appears within the type `Vec<Box<(dyn tauri_runtime_wry::Plugin<EventLoopMessage> + 'static)>>`
    = note: required because it appears within the type `tauri_runtime_wry::Wry<EventLoopMessage>`
    = note: required because it appears within the type `std::option::Option<tauri_runtime_wry::Wry<EventLoopMessage>>`
    = note: required because it appears within the type `tauri::App`
    = note: required because of the requirements on the impl of `Send` for `&tauri::App`
note: required because it's used within this closure
   --> src/main.rs:25:58
    |
25  |             let id = app.listen_global("update-battery", |event| {
    |                                                          ^^^^^^^
note: required by a bound in `listen_global`
   --> /Users/fcoury/.cargo/registry/src/github.com-1ecc6299db9ec823/tauri-1.1.1/src/lib.rs:605:20
    |
605 |     F: Fn(Event) + Send + 'static,
    |                    ^^^^ required by this bound in `listen_global`

For more information about this error, try `rustc --explain E02

[FabianLars]

App (the input argument for .setup) is !Send meaning you can't send it across threads or move it into the event handlers. You'll need to get an AppHandle via app.handle() and use that inside listen_global:

        .setup(|app| {
            let handle = app.handle();
            let id = app.listen_global("update-battery", move |event| { // i think that this needs the move keyword, not sure right now
                handle.tray_handle().get_item("battery").set_title("New title");
            });
            // app.unlisten(id); Don't unlisten here as it would make the listen_global call above useless (immediately unregistered)
            Ok(())
        })

[fcoury]

Works flawlessly, thank you!