Deep-Link commands

apps/desktop/package.json

@@ -34,7 +34,6 @@
     "@solidjs/start": "^1.0.6",
     "@tanstack/solid-query": "^5.51.21",
     "@tauri-apps/api": "^2.1.1",
-    "@tauri-apps/plugin-deep-link": "^2.2.0",
     "@tauri-apps/plugin-dialog": "2.0.1",
     "@tauri-apps/plugin-fs": "2.0.3",
     "@tauri-apps/plugin-http": "^2.0.1",

apps/desktop/src-tauri/capabilities/default.json

@@ -31,7 +31,6 @@
     "oauth:allow-start",
     "updater:default",
     "notification:default",
-    "deep-link:default",
     {
       "identifier": "http:default",
       "allow": [

apps/desktop/src-tauri/src/auth.rs

@@ -1,22 +1,30 @@
+use std::sync::Arc;
+
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use specta::Type;
 use tauri::{AppHandle, Runtime};
 use tauri_plugin_store::StoreExt;
 
+use tauri_specta::Event;
 use web_api::ManagerExt;
 
 use crate::web_api;
 
 #[derive(Serialize, Deserialize, Type, Debug)]
+pub enum AuthState {
+    Listening,
+}
+
+#[derive(Serialize, Deserialize, Type, Clone, Debug)]
 pub struct AuthStore {
     pub token: String,
     pub user_id: Option<String>,
     pub expires: i32,
     pub plan: Option<Plan>,
 }
 
-#[derive(Serialize, Deserialize, Type, Debug)]
+#[derive(Serialize, Deserialize, Type, Clone, Debug)]
 pub struct Plan {
     pub upgraded: bool,
     pub manual: bool,
@@ -112,9 +120,18 @@ impl AuthStore {
         });
 
         store.set("auth", json!(value));
+        if let Some(auth) = value {
+            if let Err(e) = Authenticated::emit(&Authenticated(auth), app) {
+                eprintln!("Error while emitting Authenticated: {}", e.to_string());
+            };
+        }
+
         store.save().map_err(|e| e.to_string())
     }
 }
 
 #[derive(specta::Type, serde::Serialize, tauri_specta::Event, Debug, Clone, serde::Deserialize)]
 pub struct AuthenticationInvalid;
+
+#[derive(specta::Type, serde::Serialize, tauri_specta::Event, Debug, Clone, serde::Deserialize)]
+pub struct Authenticated(AuthStore);

apps/desktop/src-tauri/src/deeplink_actions.rs

@@ -0,0 +1,152 @@
+use std::sync::Arc;
+
+use serde::{Deserialize, Serialize};
+use tauri::{AppHandle, Manager, Url};
+use tokio::sync::RwLock;
+
+use crate::{
+    auth::{AuthState, AuthStore},
+    windows::ShowCapWindow,
+    App,
+};
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CaptureMode {
+    Screen(String),
+    Window(String),
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum DeepLinkAction {
+    SignIn(AuthStore),
+    StartRecording {
+        mode: CaptureMode,
+        camera_label: Option<String>,
+        audio_input_name: Option<String>,
+        fps: Option<u32>,
+        output_resolution: Option<cap_project::Resolution>,
+    },
+    StopRecording,
+    OpenEditor(String),
+    OpenSettings,
+}
+
+pub fn handle(app_handle: &AppHandle, urls: Vec<Url>) {
+    #[cfg(debug_assertions)]
+    println!("Handling deep actions for: {:?}", &urls);
+
+    let actions: Vec<_> = urls
+        .into_iter()
+        .filter(|url| !url.as_str().is_empty())
+        .filter_map(|url| {
+            DeepLinkAction::try_from(&url)
+                .map_err(|e| {
+                    eprintln!("Failed to parse deep link \"{}\": {}", &url, e);
+                })
+                .ok()
+        })
+        .collect();
+
+    if actions.is_empty() {
+        return;
+    }
+
+    let app_handle = app_handle.clone();
+    tauri::async_runtime::spawn(async move {
+        for action in actions {
+            if let Err(e) = action.execute(&app_handle).await {
+                eprintln!("Failed to handle deep link action: {}", e);
+            }
+        }
+    });
+}
+
+impl TryFrom<&Url> for DeepLinkAction {
+    type Error = String;
+
+    fn try_from(url: &Url) -> Result<Self, Self::Error> {
+        if !url.domain().is_some_and(|v| v == "action") {
+            return Err("Invalid format".into());
+        }
+
+        let params = url
+            .query_pairs()
+            .collect::<std::collections::HashMap<_, _>>();
+        let json_value = params.get("value").ok_or("No value")?;
+        let action: Self = serde_json::from_str(json_value).map_err(|e| {
+            format!(
+                "Failed to parse deep-link action json value: {}",
+                e.to_string()
+            )
+        })?;
+        Ok(action)
+    }
+}
+
+impl DeepLinkAction {
+    pub async fn execute(self, app: &AppHandle) -> Result<(), String> {
+        match self {
+            Self::SignIn(auth) => {
+                let app_state = app.state::<Arc<RwLock<App>>>();
+                let reader_guard = app_state.read().await;
+
+                match &reader_guard.auth_state {
+                    Some(AuthState::Listening) => Ok(AuthStore::set(app, Some(auth))?),
+                    _ => Err("Not listening for OAuth events".into()),
+                }
+            }
+            DeepLinkAction::StartRecording {
+                mode,
+                camera_label,
+                audio_input_name,
+                fps,
+                output_resolution,
+            } => {
+                use cap_media::sources::ScreenCaptureTarget;
+                let capture_target: ScreenCaptureTarget = match mode {
+                    CaptureMode::Screen(name) => cap_media::sources::list_screens()
+                        .into_iter()
+                        .find(|(s, _)| s.name == name)
+                        .map(|(s, _)| ScreenCaptureTarget::Screen(s))
+                        .ok_or(format!("No screen with name \"{}\"", &name))?,
+                    CaptureMode::Window(name) => cap_media::sources::list_windows()
+                        .into_iter()
+                        .find(|(w, _)| w.name == name)
+                        .map(|(w, _)| ScreenCaptureTarget::Window(w))
+                        .ok_or(format!("No window with name \"{}\"", &name))?,
+                };
+
+                let state = app.state::<Arc<RwLock<App>>>();
+                crate::set_recording_options(
+                    app.clone().to_owned(),
+                    state,
+                    cap_recording::RecordingOptions {
+                        capture_target,
+                        camera_label,
+                        audio_input_name,
+                        fps: fps.unwrap_or_default(),
+                        output_resolution,
+                    },
+                )
+                .await?;
+
+                crate::recording::start_recording(app.clone(), app.state()).await
+            }
+            DeepLinkAction::StopRecording => {
+                crate::recording::stop_recording(app.clone(), app.state()).await
+            }
+            DeepLinkAction::OpenEditor(id) => {
+                crate::open_editor(app.clone(), id);
+                Ok(())
+            }
+            DeepLinkAction::OpenSettings => {
+                _ = ShowCapWindow::Settings { page: None }
+                    .show(app)
+                    .map_err(|e| format!("Failed to open settings window: {}", e))?;
+                Ok(())
+            }
+        }
+    }
+}

apps/desktop/src-tauri/src/lib.rs

@@ -10,6 +10,7 @@ mod platform;
 mod recording;
 // mod resource;
 mod audio_meter;
+mod deeplink_actions;
 mod export;
 mod fake_window;
 mod tray;
@@ -18,6 +19,7 @@ mod web_api;
 mod windows;
 
 use audio::AppSounds;
+use auth::Authenticated;
 use auth::{AuthStore, AuthenticationInvalid, Plan};
 use camera::create_camera_preview_ws;
 use cap_editor::EditorInstance;
@@ -55,7 +57,7 @@ use std::{
     sync::Arc,
     time::Duration,
 };
-use tauri::{AppHandle, Emitter, Manager, Runtime, State, WindowEvent};
+use tauri::{AppHandle, Manager, Runtime, State, WindowEvent};
 use tauri_plugin_deep_link::DeepLinkExt;
 use tauri_plugin_dialog::DialogExt;
 use tauri_plugin_notification::{NotificationExt, PermissionState};
@@ -85,6 +87,8 @@ pub struct App {
     current_recording: Option<cap_recording::ActorHandle>,
     #[serde(skip)]
     pre_created_video: Option<PreCreatedVideo>,
+    #[serde(skip)]
+    auth_state: Option<auth::AuthState>,
 }
 
 #[derive(specta::Type, Serialize, Deserialize, Clone, Debug)]
@@ -1791,6 +1795,17 @@ fn open_external_link(app: tauri::AppHandle, url: String) -> Result<(), String>
     Ok(())
 }
 
+#[tauri::command]
+#[specta::specta]
+async fn set_oauth_listening_state(
+    state: MutableState<'_, App>,
+    auth_state: Option<auth::AuthState>,
+) -> Result<(), String> {
+    let mut writer_guard = state.write().await;
+    writer_guard.auth_state = auth_state;
+    Ok(())
+}
+
 #[tauri::command]
 #[specta::specta]
 async fn delete_auth_open_signin(app: AppHandle) -> Result<(), String> {
@@ -1960,6 +1975,7 @@ pub async fn run() {
             check_upgraded_and_update,
             open_external_link,
             hotkeys::set_hotkey,
+            set_oauth_listening_state,
             delete_auth_open_signin,
             reset_camera_permissions,
             reset_microphone_permissions,
@@ -1990,6 +2006,7 @@ pub async fn run() {
             RequestOpenSettings,
             NewNotification,
             AuthenticationInvalid,
+            Authenticated,
             audio_meter::AudioInputLevelChange,
             UploadProgress,
         ])
@@ -2107,6 +2124,7 @@ pub async fn run() {
                     },
                     current_recording: None,
                     pre_created_video: None,
+                    auth_state: None,
                 })));
 
                 app.manage(Arc::new(RwLock::new(
@@ -2205,6 +2223,14 @@ pub async fn run() {
                 delete_auth_open_signin(app).await.ok();
             });
 
+            // Registering deep links at runtime is not possible on macOS,
+            // so deep links can only be tested on the bundled application,
+            // which must be installed in the /Applications directory.
+            let app_handle = app.clone();
+            app.deep_link().on_open_url(move |event| {
+                deeplink_actions::handle(&app_handle, event.urls());
+            });
+
             Ok(())
         })
         .on_window_event(|window, event| {

apps/desktop/src-tauri/tauri.conf.json

@@ -32,13 +32,7 @@
     "deep-link": {
       "desktop": {
         "schemes": ["cap-desktop"]
-      },
-      "mobile": [
-        {
-          "host": "cap.so",
-          "pathPrefix": ["/signin"]
-        }
-      ]
+      }
     }
   },
   "bundle": {