Switch windows implementation to use tauri-single-instance v2 methods

Author: jf908

Cargo.toml

@@ -1,7 +1,11 @@
 [package]
 name = "cargo-deep-link"
 version = "0.1.0"
-authors = ["FabianLars <[email protected]>", "jf908"]
+authors = [
+    "jf908",
+    "Tauri Programme within The Commons Conservancy",
+    "FabianLars <[email protected]>",
+]
 description = "A library for deep linking support"
 repository = "https://github.com/jf908/cargo-deep-link"
 edition = "2021"
@@ -15,13 +19,17 @@ dirs = "5"
 log = "0.4"
 
 [target.'cfg(windows)'.dependencies]
-interprocess = { version = "1.2", default-features = false }
-windows-sys = { version = "0.52.0", features = [
+windows-sys = { version = "0.59.0", features = [
+    "Win32_System_Threading",
+    "Win32_System_DataExchange",
     "Win32_Foundation",
-    "Win32_UI_Input_KeyboardAndMouse",
     "Win32_UI_WindowsAndMessaging",
+    "Win32_Security",
+    "Win32_System_LibraryLoader",
+    "Win32_Graphics_Gdi",
 ] }
-winreg = "0.55.0"
+dunce = "1"
+windows-registry = "0.4"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 objc2 = "0.4.1"

LICENSE_MIT

@@ -1,6 +1,8 @@
 MIT License
 
+Copyright (c) 2025 - Present jf908
 Copyright (c) 2022 - Present FabianLars
+Copyright (c) 2017 - Present Tauri Apps Contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

examples/main.rs

@@ -1,7 +1,11 @@
 // Disable Windows console on release builds
-// #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-use eframe::egui;
+use std::sync::{
+    Arc, Mutex,
+};
+
+use eframe::egui::{self, ViewportCommand};
 
 fn main() {
     // prepare() checks if it's a single instance and tries to send the args otherwise.
@@ -10,30 +14,45 @@ fn main() {
 
     env_logger::init();
 
-    cargo_deep_link::listen(|str| {
-        println!("{:?}", str);
-    })
-    .unwrap();
-
     eframe::run_native(
         "egui App",
         eframe::NativeOptions {
             viewport: egui::ViewportBuilder::default().with_inner_size([320.0, 240.0]),
             ..Default::default()
         },
-        Box::new(|_| Ok(Box::<App>::default())),
+        Box::new(move |cc| {
+            let frame = cc.egui_ctx.clone();
+            let last_call = Arc::new(Mutex::new(None));
+
+            {
+                let last_call = last_call.clone();
+
+                cargo_deep_link::listen(move |str| {
+                    last_call.lock().unwrap().replace(str);
+                    frame.send_viewport_cmd(ViewportCommand::Focus);
+                })
+                .unwrap();
+            }
+
+            Ok(Box::new(App {
+                last_call,
+                ..Default::default()
+            }))
+        }),
     )
     .unwrap();
 }
 
 struct App {
     args: String,
+    last_call: Arc<Mutex<Option<String>>>,
 }
 
 impl Default for App {
     fn default() -> Self {
         Self {
             args: std::env::args().collect::<Vec<_>>().join(" "),
+            last_call: Arc::new(Mutex::new(None)),
         }
     }
 }
@@ -43,23 +62,26 @@ impl eframe::App for App {
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.heading("egui Application");
 
-            ui.label(self.args.clone());
+            ui.horizontal(|ui| {
+                if ui.add(egui::Button::new("Register")).clicked() {
+                    // If you need macOS support this must be called in .setup() !
+                    // Otherwise this could be called right after prepare() but then you don't have access to tauri APIs
+                    cargo_deep_link::register("test-scheme").unwrap(/* If listening to the scheme is optional for your app, you don't want to unwrap here. */);
+                }
 
-            if ui.add(egui::Button::new("Register")).clicked() {
-                // If you need macOS support this must be called in .setup() !
-                // Otherwise this could be called right after prepare() but then you don't have access to tauri APIs
-                cargo_deep_link::register(
-                    "test-scheme",
-                    |request| {
-                       println!("{:?}", &request);
-                    },
-                )
-                .unwrap(/* If listening to the scheme is optional for your app, you don't want to unwrap here. */);
-            }
+                if ui.add(egui::Button::new("Unregister")).clicked() {
+                    cargo_deep_link::unregister("test-scheme").unwrap();
+                }
+            });
 
-            if ui.add(egui::Button::new("Unregister")).clicked() {
-                cargo_deep_link::unregister("test-scheme").unwrap();
-            }
+            ui.separator();
+            
+            ui.label("Args:");
+
+            ui.text_edit_singleline(&mut self.args.clone());
+            
+            ui.label("Last link:");
+            ui.text_edit_singleline(&mut self.last_call.lock().unwrap().as_ref().cloned().unwrap_or_default());
         });
     }
 }

src/lib.rs

@@ -4,6 +4,8 @@ use std::{
     sync::OnceLock,
 };
 
+pub(crate) type SingleInstanceCallback = dyn FnMut(Vec<String>, String) + Send + Sync + 'static;
+
 #[cfg(target_os = "windows")]
 #[path = "windows.rs"]
 mod platform_impl;
@@ -16,6 +18,16 @@ mod platform_impl;
 
 static ID: OnceLock<String> = OnceLock::new();
 
+// pub fn init<F: FnMut(Vec<String>, String) + Send + Sync + 'static>(mut f: F) {
+//     platform_impl::init(Box::new(move |args, cwd| {
+//         #[cfg(feature = "deep-link")]
+//         if let Some(deep_link) = app.try_state::<tauri_plugin_deep_link::DeepLink<R>>() {
+//             deep_link.handle_cli_arguments(args.iter());
+//         }
+//         f(args, cwd)
+//     }))
+// }
+
 /// This function is meant for use-cases where the default [`prepare()`] function can't be used.
 ///
 /// # Errors
@@ -32,16 +44,16 @@ pub fn set_identifier(identifier: &str) -> Result<()> {
 /// ## Platform-specific:
 ///
 /// - **macOS**: On macOS schemes must be defined in an Info.plist file, therefore this function only calls [`listen()`] without registering the scheme. This function can only be called once on macOS.
-pub fn register<F: FnMut(String) + Send + 'static>(scheme: &str, handler: F) -> Result<()> {
-    platform_impl::register(scheme, handler)
+pub fn register(scheme: &str) -> Result<()> {
+    platform_impl::register(scheme)
 }
 
 /// Starts the event listener without registering any schemes.
 ///
 /// ## Platform-specific:
 ///
 /// - **macOS**: This function can only be called once on macOS.
-pub fn listen<F: FnMut(String) + Send + 'static>(handler: F) -> Result<()> {
+pub fn listen<F: FnMut(String) + Send + Sync + 'static>(handler: F) -> Result<()> {
     platform_impl::listen(handler)
 }
 

src/linux.rs

@@ -9,9 +9,7 @@ use dirs::data_dir;
 
 use crate::ID;
 
-pub fn register<F: FnMut(String) + Send + 'static>(scheme: &str, handler: F) -> Result<()> {
-    listen(handler)?;
-
+pub fn register(scheme: &str) -> Result<()> {
     let mut target = data_dir()
         .ok_or_else(|| Error::new(ErrorKind::NotFound, "data directory not found."))?
         .join("applications");

src/macos.rs

@@ -20,9 +20,7 @@ type THandler = OnceLock<Mutex<Box<dyn FnMut(String) + Send + 'static>>>;
 // If the Mutex turns out to be a problem, or FnMut turns out to be useless, we can remove the Mutex and turn FnMut into Fn
 static HANDLER: THandler = OnceLock::new();
 
-pub fn register<F: FnMut(String) + Send + 'static>(_scheme: &str, handler: F) -> Result<()> {
-    listen(handler)?;
-
+pub fn register(_scheme: &str) -> Result<()> {
     Ok(())
 }
 

src/windows.rs

@@ -1,145 +1,53 @@
-use std::{
-    io::{BufRead, BufReader, Result, Write},
-    path::Path,
-};
+use std::io::Result;
 
-use interprocess::local_socket::{LocalSocketListener, LocalSocketStream};
-use windows_sys::Win32::UI::{
-    Input::KeyboardAndMouse::{SendInput, INPUT, INPUT_0, INPUT_KEYBOARD, KEYBDINPUT},
-    WindowsAndMessaging::{AllowSetForegroundWindow, ASFW_ANY},
-};
-use winreg::{enums::HKEY_CURRENT_USER, RegKey};
+use windows_registry::CURRENT_USER;
 
 use crate::ID;
 
-pub fn register<F: FnMut(String) + Send + 'static>(scheme: &str, handler: F) -> Result<()> {
-    listen(handler)?;
+mod windows_single;
 
-    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
-    let base = Path::new("Software").join("Classes").join(scheme);
+pub fn register(scheme: &str) -> Result<()> {
+    let key_base = format!("Software\\Classes\\{}", scheme);
 
-    let exe = crate::current_exe()?
+    let exe = dunce::simplified(&crate::current_exe()?)
         .display()
-        .to_string()
-        .replace("\\\\?\\", "");
+        .to_string();
 
-    let (key, _) = hkcu.create_subkey(&base)?;
-    key.set_value(
+    let key_reg = CURRENT_USER.create(&key_base)?;
+    key_reg.set_string(
         "",
         &format!(
-            "URL:{}",
+            "URL:{} protocol",
             ID.get().expect("register() called before prepare()")
         ),
     )?;
-    key.set_value("URL Protocol", &"")?;
+    key_reg.set_string("URL Protocol", "")?;
 
-    let (icon, _) = hkcu.create_subkey(base.join("DefaultIcon"))?;
-    icon.set_value("", &format!("{},0", &exe))?;
+    let icon_reg = CURRENT_USER.create(format!("{key_base}\\DefaultIcon"))?;
+    icon_reg.set_string("", &format!("{exe},0"))?;
 
-    let (cmd, _) = hkcu.create_subkey(base.join("shell").join("open").join("command"))?;
+    let cmd_reg = CURRENT_USER.create(format!("{key_base}\\shell\\open\\command"))?;
 
-    cmd.set_value("", &format!("{} \"%1\"", &exe))?;
+    cmd_reg.set_string("", &format!("\"{exe}\" \"%1\""))?;
 
     Ok(())
 }
 
 pub fn unregister(scheme: &str) -> Result<()> {
-    let hkcu = RegKey::predef(HKEY_CURRENT_USER);
-    let base = Path::new("Software").join("Classes").join(scheme);
-
-    hkcu.delete_subkey_all(base)?;
+    CURRENT_USER.remove_tree(format!("Software\\Classes\\{}", scheme))?;
 
     Ok(())
 }
 
-pub fn listen<F: FnMut(String) + Send + 'static>(mut handler: F) -> Result<()> {
-    std::thread::spawn(move || {
-        let listener =
-            LocalSocketListener::bind(ID.get().expect("listen() called before prepare()").as_str())
-                .expect("Can't create listener");
-
-        for conn in listener.incoming().filter_map(|c| {
-            c.map_err(|error| log::error!("Incoming connection failed: {}", error))
-                .ok()
-        }) {
-            // Listen for the launch arguments
-            let mut conn = BufReader::new(conn);
-            let mut buffer = String::new();
-            if let Err(io_err) = conn.read_line(&mut buffer) {
-                log::error!("Error reading incoming connection: {}", io_err.to_string());
-            };
-            buffer.pop();
-
-            handler(buffer);
-        }
-    });
+pub fn listen<F: FnMut(String) + Sync + Send + 'static>(mut handler: F) -> Result<()> {
+    windows_single::init(Box::new(move |args, _| {
+        handler(args.join(" "));
+    }));
 
     Ok(())
 }
 
 pub fn prepare(identifier: &str) {
-    if let Ok(mut conn) = LocalSocketStream::connect(identifier) {
-        // We are the secondary instance.
-        // Prep to activate primary instance by allowing another process to take focus.
-
-        // A workaround to allow AllowSetForegroundWindow to succeed - press a key.
-        // This was originally used by Chromium: https://bugs.chromium.org/p/chromium/issues/detail?id=837796
-        dummy_keypress();
-
-        let primary_instance_pid = conn.peer_pid().unwrap_or(ASFW_ANY);
-        unsafe {
-            let success = AllowSetForegroundWindow(primary_instance_pid) != 0;
-            if !success {
-                log::warn!("AllowSetForegroundWindow failed.");
-            }
-        }
-
-        if let Err(io_err) = conn.write_all(std::env::args().nth(1).unwrap_or_default().as_bytes())
-        {
-            log::error!(
-                "Error sending message to primary instance: {}",
-                io_err.to_string()
-            );
-        };
-        let _ = conn.write_all(b"\n");
-        std::process::exit(0);
-    };
     ID.set(identifier.to_string())
         .expect("prepare() called more than once with different identifiers.");
 }
-
-/// Send a dummy keypress event so AllowSetForegroundWindow can succeed
-fn dummy_keypress() {
-    let keyboard_input_down = KEYBDINPUT {
-        wVk: 0, // This doesn't correspond to any actual keyboard key, but should still function for the workaround.
-        dwExtraInfo: 0,
-        wScan: 0,
-        time: 0,
-        dwFlags: 0,
-    };
-
-    let mut keyboard_input_up = keyboard_input_down;
-    keyboard_input_up.dwFlags = 0x0002; // KEYUP flag
-
-    let input_down_u = INPUT_0 {
-        ki: keyboard_input_down,
-    };
-    let input_up_u = INPUT_0 {
-        ki: keyboard_input_up,
-    };
-
-    let input_down = INPUT {
-        r#type: INPUT_KEYBOARD,
-        Anonymous: input_down_u,
-    };
-
-    let input_up = INPUT {
-        r#type: INPUT_KEYBOARD,
-        Anonymous: input_up_u,
-    };
-
-    let ipsize = std::mem::size_of::<INPUT>() as i32;
-    unsafe {
-        SendInput(2, [input_down, input_up].as_ptr(), ipsize);
-    };
-}