chore: move single-instance plugin

plugins/single-instance/src/platform_impl/linux.rs

@@ -0,0 +1,96 @@
+#![cfg(target_os = "linux")]
+
+use std::sync::Arc;
+
+use crate::SingleInstanceCallback;
+use tauri::{
+    plugin::{self, TauriPlugin},
+    AppHandle, Config, Manager, RunEvent, Runtime,
+};
+use zbus::{
+    blocking::{Connection, ConnectionBuilder},
+    dbus_interface,
+};
+
+struct ConnectionHandle(Connection);
+
+struct SingleInstanceDBus<R: Runtime> {
+    callback: Box<SingleInstanceCallback<R>>,
+    app_handle: AppHandle<R>,
+}
+
+#[dbus_interface(name = "org.SingleInstance.DBus")]
+impl<R: Runtime> SingleInstanceDBus<R> {
+    fn execute_callback(&mut self, argv: Vec<String>, cwd: String) {
+        (self.callback)(&self.app_handle, argv, cwd);
+    }
+}
+
+fn dbus_id(config: Arc<Config>) -> String {
+    config
+        .tauri
+        .bundle
+        .identifier
+        .replace('.', "_")
+        .replace('-', "_")
+}
+
+pub fn init<R: Runtime>(f: Box<SingleInstanceCallback<R>>) -> TauriPlugin<R> {
+    plugin::Builder::new("single-instance")
+        .setup(|app| {
+            let id = dbus_id(app.config());
+            let single_instance_dbus = SingleInstanceDBus {
+                callback: f,
+                app_handle: app.clone(),
+            };
+            let dbus_name = format!("org.{}.SingleInstance", id);
+            let dbus_path = format!("/org/{}/SingleInstance", id);
+
+            match ConnectionBuilder::session()
+                .unwrap()
+                .name(dbus_name.as_str())
+                .unwrap()
+                .serve_at(dbus_path.as_str(), single_instance_dbus)
+                .unwrap()
+                .build()
+            {
+                Ok(connection) => {
+                    app.manage(ConnectionHandle(connection));
+                }
+                Err(zbus::Error::NameTaken) => {
+                    if let Ok(connection) = Connection::session() {
+                        let _ = connection.call_method(
+                            Some(dbus_name.as_str()),
+                            dbus_path.as_str(),
+                            Some("org.SingleInstance.DBus"),
+                            "ExecuteCallback",
+                            &(
+                                std::env::args().collect::<Vec<String>>(),
+                                std::env::current_dir()
+                                    .unwrap_or_default()
+                                    .to_str()
+                                    .unwrap_or_default(),
+                            ),
+                        );
+                    }
+                    std::process::exit(0)
+                }
+                _ => {}
+            }
+
+            Ok(())
+        })
+        .on_event(|app, event| {
+            if let RunEvent::Exit = event {
+                destroy(app);
+            }
+        })
+        .build()
+}
+
+pub fn destroy<R: Runtime, M: Manager<R>>(manager: &M) {
+    if let Some(connection) = manager.try_state::<ConnectionHandle>() {
+        let dbus_name = format!("org.{}.SingleInstance", dbus_id(manager.config()));
+        let _ = connection.0.release_name(dbus_name);
+    }
+}

plugins/single-instance/src/platform_impl/macos.rs

@@ -0,0 +1,12 @@
+#![cfg(target_os = "macos")]
+
+use crate::SingleInstanceCallback;
+use tauri::{
+    plugin::{self, TauriPlugin},
+    Manager, Runtime,
+};
+pub fn init<R: Runtime>(f: Box<SingleInstanceCallback<R>>) -> TauriPlugin<R> {
+    plugin::Builder::new("single-instance").build()
+}
+
+pub fn destroy<R: Runtime, M: Manager<R>>(_manager: &M) {}

plugins/single-instance/src/platform_impl/windows.rs

@@ -0,0 +1,215 @@
+#![cfg(target_os = "windows")]
+
+use crate::SingleInstanceCallback;
+use std::ffi::CStr;
+use tauri::{
+    plugin::{self, TauriPlugin},
+    AppHandle, Manager, RunEvent, Runtime,
+};
+use windows_sys::Win32::{
+    Foundation::{CloseHandle, GetLastError, ERROR_ALREADY_EXISTS, HWND, LPARAM, LRESULT, WPARAM},
+    System::{
+        DataExchange::COPYDATASTRUCT,
+        LibraryLoader::GetModuleHandleW,
+        Threading::{CreateMutexW, ReleaseMutex},
+    },
+    UI::WindowsAndMessaging::{
+        self as w32wm, CreateWindowExW, DefWindowProcW, DestroyWindow, FindWindowW,
+        RegisterClassExW, SendMessageW, GWL_STYLE, GWL_USERDATA, WINDOW_LONG_PTR_INDEX,
+        WM_COPYDATA, WM_DESTROY, WNDCLASSEXW, WS_EX_LAYERED, WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW,
+        WS_EX_TRANSPARENT, WS_OVERLAPPED, WS_POPUP, WS_VISIBLE,
+    },
+};
+
+struct MutexHandle(isize);
+struct TargetWindowHandle(isize);
+
+const WMCOPYDATA_SINGLE_INSTANCE_DATA: usize = 1542;
+
+pub fn init<R: Runtime>(f: Box<SingleInstanceCallback<R>>) -> TauriPlugin<R> {
+    plugin::Builder::new("single-instance")
+        .setup(|app| {
+            let id = &app.config().tauri.bundle.identifier;
+
+            let class_name = encode_wide(format!("{}-sic", id));
+            let window_name = encode_wide(format!("{}-siw", id));
+            let mutex_name = encode_wide(format!("{}-sim", id));
+
+            let hmutex =
+                unsafe { CreateMutexW(std::ptr::null(), true.into(), mutex_name.as_ptr()) };
+
+            if unsafe { GetLastError() } == ERROR_ALREADY_EXISTS {
+                unsafe {
+                    let hwnd = FindWindowW(class_name.as_ptr(), window_name.as_ptr());
+
+                    if hwnd != 0 {
+                        let data = format!(
+                            "{}|{}\0",
+                            std::env::current_dir()
+                                .unwrap_or_default()
+                                .to_str()
+                                .unwrap_or_default(),
+                            std::env::args().collect::<Vec<String>>().join("|")
+                        );
+                        let bytes = data.as_bytes();
+                        let cds = COPYDATASTRUCT {
+                            dwData: WMCOPYDATA_SINGLE_INSTANCE_DATA,
+                            cbData: bytes.len() as _,
+                            lpData: bytes.as_ptr() as _,
+                        };
+                        SendMessageW(hwnd, WM_COPYDATA, 0, &cds as *const _ as _);
+                        app.exit(0);
+                    }
+                }
+            } else {
+                app.manage(MutexHandle(hmutex));
+
+                let hwnd = create_event_target_window::<R>(&class_name, &window_name);
+                unsafe {
+                    SetWindowLongPtrW(
+                        hwnd,
+                        GWL_USERDATA,
+                        Box::into_raw(Box::new((app.clone(), f))) as _,
+                    )
+                };
+
+                app.manage(TargetWindowHandle(hwnd));
+            }
+
+            Ok(())
+        })
+        .on_event(|app, event| {
+            if let RunEvent::Exit = event {
+                destroy(app);
+            }
+        })
+        .build()
+}
+
+pub fn destroy<R: Runtime, M: Manager<R>>(manager: &M) {
+    if let Some(hmutex) = manager.try_state::<MutexHandle>() {
+        unsafe {
+            ReleaseMutex(hmutex.0);
+            CloseHandle(hmutex.0);
+        }
+    }
+    if let Some(hwnd) = manager.try_state::<TargetWindowHandle>() {
+        unsafe { DestroyWindow(hwnd.0) };
+    }
+}
+
+unsafe extern "system" fn single_instance_window_proc<R: Runtime>(
+    hwnd: HWND,
+    msg: u32,
+    wparam: WPARAM,
+    lparam: LPARAM,
+) -> LRESULT {
+    let data_ptr = GetWindowLongPtrW(hwnd, GWL_USERDATA)
+        as *mut (AppHandle<R>, Box<SingleInstanceCallback<R>>);
+    let (app_handle, callback) = &mut *data_ptr;
+
+    match msg {
+        WM_COPYDATA => {
+            let cds_ptr = lparam as *const COPYDATASTRUCT;
+            if (*cds_ptr).dwData == WMCOPYDATA_SINGLE_INSTANCE_DATA {
+                let data = CStr::from_ptr((*cds_ptr).lpData as _).to_string_lossy();
+                let mut s = data.split("|");
+                let cwd = s.next().unwrap();
+                let args = s.into_iter().map(|s| s.to_string()).collect();
+                callback(&app_handle, args, cwd.to_string());
+            }
+            1
+        }
+
+        WM_DESTROY => {
+            let _ = Box::from_raw(data_ptr);
+            0
+        }
+        _ => DefWindowProcW(hwnd, msg, wparam, lparam),
+    }
+}
+
+fn create_event_target_window<R: Runtime>(class_name: &[u16], window_name: &[u16]) -> HWND {
+    unsafe {
+        let class = WNDCLASSEXW {
+            cbSize: std::mem::size_of::<WNDCLASSEXW>() as u32,
+            style: 0,
+            lpfnWndProc: Some(single_instance_window_proc::<R>),
+            cbClsExtra: 0,
+            cbWndExtra: 0,
+            hInstance: GetModuleHandleW(std::ptr::null()),
+            hIcon: 0,
+            hCursor: 0,
+            hbrBackground: 0,
+            lpszMenuName: std::ptr::null(),
+            lpszClassName: class_name.as_ptr(),
+            hIconSm: 0,
+        };
+
+        RegisterClassExW(&class);
+
+        let hwnd = CreateWindowExW(
+            WS_EX_NOACTIVATE
+            | WS_EX_TRANSPARENT
+            | WS_EX_LAYERED
+            // WS_EX_TOOLWINDOW prevents this window from ever showing up in the taskbar, which
+            // we want to avoid. If you remove this style, this window won't show up in the
+            // taskbar *initially*, but it can show up at some later point. This can sometimes
+            // happen on its own after several hours have passed, although this has proven
+            // difficult to reproduce. Alternatively, it can be manually triggered by killing
+            // `explorer.exe` and then starting the process back up.
+            // It is unclear why the bug is triggered by waiting for several hours.
+            | WS_EX_TOOLWINDOW,
+            class_name.as_ptr(),
+            window_name.as_ptr(),
+            WS_OVERLAPPED,
+            0,
+            0,
+            0,
+            0,
+            0,
+            0,
+            GetModuleHandleW(std::ptr::null()),
+            std::ptr::null(),
+        );
+        SetWindowLongPtrW(
+            hwnd,
+            GWL_STYLE,
+            // The window technically has to be visible to receive WM_PAINT messages (which are used
+            // for delivering events during resizes), but it isn't displayed to the user because of
+            // the LAYERED style.
+            (WS_VISIBLE | WS_POPUP) as isize,
+        );
+        hwnd
+    }
+}
+
+pub fn encode_wide(string: impl AsRef<std::ffi::OsStr>) -> Vec<u16> {
+    std::os::windows::prelude::OsStrExt::encode_wide(string.as_ref())
+        .chain(std::iter::once(0))
+        .collect()
+}
+
+#[cfg(target_pointer_width = "32")]
+#[allow(non_snake_case)]
+unsafe fn SetWindowLongPtrW(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX, value: isize) -> isize {
+    w32wm::SetWindowLongW(hwnd, index, value as _) as _
+}
+
+#[cfg(target_pointer_width = "64")]
+#[allow(non_snake_case)]
+unsafe fn SetWindowLongPtrW(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX, value: isize) -> isize {
+    w32wm::SetWindowLongPtrW(hwnd, index, value)
+}
+
+#[cfg(target_pointer_width = "32")]
+#[allow(non_snake_case)]
+unsafe fn GetWindowLongPtrW(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX) -> isize {
+    w32wm::GetWindowLongW(hwnd, index) as _
+}
+
+#[cfg(target_pointer_width = "64")]
+#[allow(non_snake_case)]
+unsafe fn GetWindowLongPtrW(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX) -> isize {
+    w32wm::GetWindowLongPtrW(hwnd, index)
+}