tauri-plugin-single-window 1.1.1

use std::sync::Arc;
#[cfg(desktop)]
use tauri::Manager;
use tauri::{
    plugin::{Builder, TauriPlugin},
    AppHandle, Runtime,
};

mod config;
pub use config::Config;
mod models;
pub use models::ActivationPayload;

#[cfg(desktop)]
mod desktop;

mod error;

pub use error::{Error, Result};

type ActivationCallback<R> = Arc<dyn Fn(AppHandle<R>, ActivationPayload) + Send + Sync>;

/// Initializes the plugin.
pub fn init<R: Runtime>() -> TauriPlugin<R> {
    init_with(Config::default())
}

/// Initializes the plugin with configuration.
pub fn init_with<R: Runtime>(config: Config) -> TauriPlugin<R> {
    let callback = config
        .activation_callback
        .as_ref()
        .and_then(|callback| callback.downcast_ref::<ActivationCallback<R>>())
        .cloned();

    let builder = Builder::new("single-window").setup(move |app, api| {
        #[cfg(desktop)]
        {
            let single_instance = desktop::init(app, api, &config, callback.clone())?;
            app.manage(single_instance);
        }

        #[cfg(mobile)]
        {
            let _ = (app, api, &config, &callback);
        }

        Ok(())
    });

    #[cfg(target_os = "linux")]
    let builder = {
        let mut ready_seen = false;

        builder.on_event(move |app, event| {
            if matches!(event, tauri::RunEvent::Ready) {
                if ready_seen {
                    if let Some(single_instance) = app.try_state::<desktop::SingleInstance<R>>() {
                        single_instance.handle_remote_activation();
                    }
                } else {
                    ready_seen = true;
                }
            }
        })
    };

    builder.build()
}