Improve deep link for debug build on macOS

Author: powell-newin

plugins/single-instance/src/lib.rs

@@ -35,6 +35,16 @@ pub fn init<R: Runtime, F: FnMut(&AppHandle<R>, Vec<String>, String) + Send + Sy
         #[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());
+            #[cfg(all(target_os = "macos", debug_assertions))]
+            {
+                let mut args = args.iter();
+                args.next();
+                let arg = args.next();
+                use tauri::Emitter;
+                if let Some(url) = arg {
+                    let _ = app.emit("deep-link://new-url", vec![url]);
+                }
+            }
         }
         f(app, args, cwd)
     }))

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

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: MIT
 
 use std::{
-    io::{BufWriter, Error, ErrorKind, Read, Write},
+    io::{BufWriter, ErrorKind, Read, Write},
     os::unix::net::{UnixListener, UnixStream},
     path::PathBuf,
 };
@@ -16,17 +16,25 @@ use tauri::{
     AppHandle, Config, Manager, RunEvent, Runtime,
 };
 
+#[cfg(debug_assertions)]
+static IS_PRIMARY_APP: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+
 pub fn init<R: Runtime>(cb: Box<SingleInstanceCallback<R>>) -> TauriPlugin<R> {
     plugin::Builder::new("single-instance")
         .setup(|app, _api| {
             let socket = socket_path(app.config(), app.package_info());
 
             // Notify the singleton which may or may not exist.
-            match notify_singleton(&socket) {
+            match notify_singleton(&socket, &std::env::args().collect::<Vec<_>>()) {
                 Ok(_) => {
+                    #[cfg(debug_assertions)]
+                    IS_PRIMARY_APP.set(false).unwrap();
+                    #[cfg(not(debug_assertions))]
                     std::process::exit(0);
                 }
                 Err(e) => {
+                    #[cfg(debug_assertions)]
+                    IS_PRIMARY_APP.set(true).unwrap();
                     match e.kind() {
                         ErrorKind::NotFound | ErrorKind::ConnectionRefused => {
                             // This process claims itself as singleton as likely none exists
@@ -44,10 +52,32 @@ pub fn init<R: Runtime>(cb: Box<SingleInstanceCallback<R>>) -> TauriPlugin<R> {
             }
             Ok(())
         })
-        .on_event(|app, event| {
-            if let RunEvent::Exit = event {
+        .on_event(|app, event| match event {
+            RunEvent::Exit => {
                 destroy(app);
             }
+            #[cfg(debug_assertions)]
+            RunEvent::Opened { urls } => {
+                if let Some(true) = IS_PRIMARY_APP.get() {
+                    return;
+                }
+                let socket = socket_path(app.config(), app.package_info());
+                match notify_singleton(
+                    &socket,
+                    &std::env::args()
+                        .take(1)
+                        .chain(urls.iter().map(|url| url.to_string()))
+                        .collect::<Vec<String>>(),
+                ) {
+                    Ok(_) => {
+                        std::process::exit(0);
+                    }
+                    Err(e) => {
+                        tracing::error!(?e);
+                    }
+                }
+            }
+            _ => {}
         })
         .build()
 }
@@ -74,10 +104,10 @@ fn socket_cleanup(socket: &PathBuf) {
     let _ = std::fs::remove_file(socket);
 }
 
-fn notify_singleton(socket: &PathBuf) -> Result<(), Error> {
+fn notify_singleton(socket: &PathBuf, args: &[String]) -> Result<(), std::io::Error> {
     let stream = UnixStream::connect(socket)?;
     let mut bf = BufWriter::new(&stream);
-    let args_joined = std::env::args().collect::<Vec<String>>().join("\0");
+    let args_joined = args.join("\0");
     bf.write_all(args_joined.as_bytes())?;
     bf.flush()?;
     drop(bf);