Long running application: Close to tray icon

[jdheeter]

Many applications need to be able to operate in the background without a visible window. A good example of this would be an app like https://justgetflux.com

Currently we have implemented a tray icon, but on windows when the main windows is closed (clicking the window X) the application is killed. On MacOS, when the main window is closed the application will continue to be run (can be closed using the tray icon menu). There is an event you can listen to inside Tauri called CloseRequested, but I don't see any way to disable the logic that closes the entire Tauri application when the window is closed.

Is there any good reference/example for a Tauri application that closes to the tray?

[amrbashir]

Check this

tauri/examples/api/src-tauri/src/main.rs

Line 233 in 51dd08a

Event::ExitRequested { api, .. } => {

[amrbashir]

@joepio RunEvent::ExitRequested stilll exists, RunEvent::ClosRequested has been moved to RunEvent::WindowEvent::CloseRequested.
You can find all the events here https://docs.rs/tauri/1.0.0-rc.6/tauri/enum.RunEvent.html

[pacholoamit]

As of tauri v1.1. Here's what I came up with

tauri::Builder::default().on_window_event(|event| match event.event() {
            tauri::WindowEvent::CloseRequested { api, .. } => {
                event.window().hide().unwrap();
                api.prevent_close();
            }
            _ => {}
        }) //additional code for tauri

[rizaldirnm]

How do we listen when user want to show again? @pacholoamit

[yuhr]

@rizaldirnm This article may help. Here's a slightly modified version (not to use tauri-plugin-positioner) of the example code from the section:

		.on_system_tray_event(|app, event| match event {
			SystemTrayEvent::LeftClick { position: _, size: _, .. } => {
				let window = app.get_window("main").unwrap();
				if window.is_visible().unwrap() {
					window.hide().unwrap();
				} else {
					window.show().unwrap();
					window.set_focus().unwrap();
				}
			}
		})

[benediktms]

Is it possible to handle intercepting the event when a user quits the application via OS shortcuts (Cmd+Q/Alt+F4)? My assumption is that this gets handled by the OS so I'd have to hook into those APIs myself, is that correct? Or does Tauri provide a way to do this?

[dQw4w9WgXcQ]

app.set_activation_policy(ActivationPolicy::Accessory);

[davidklein147]

I also faced this problem when I migrated my app from v1 to v2

I found that when the "X" of the window is clicked then "tauri::RunEvent::ExitRequested with code = None" triggered, so when I click exit on the tray icon I give it code 0, then I handle closing the app according to the code, when the window closed anyway

Here is my solution:

fn tray_event_handler(app: &AppHandle, event: MenuEvent, url: Arc<Url>) {
    match event.id.as_ref() {
        "open" => {
            let window = app.get_webview_window("main");
            match window {
                Some(w) => {
                    let win_is_open = w.is_visible().unwrap();
                    match win_is_open {
                        false => {
                            info!("show window");
                            w.show().unwrap();
                        }
                        true => {}
                    }
                }
                None => {
                    let _ = build_main_window(app, url);
                    ()
                }
            }
        }
        "quit" => {
            let app = app.app_handle();
            app.exit(0)
        }
        _ => (),
    }
}

fn run_event_handler(_app_handle: &AppHandle, event: tauri::RunEvent) {
    match event {
        tauri::RunEvent::ExitRequested { code, api, .. } =>
            match code {
                Some(c) => {
                    info!("Exit Request with code: {}", c);
                }
                _ => {
                    info!("Exit Request with code: {:?} - prevented exit", code);
                    api.prevent_exit();
                }
            }
        _ => (),
    }
}