Merge branch 'main' into main

Author: NalinDalal

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

@@ -5,23 +5,35 @@ use tauri::{AppHandle, Wry};
 use tauri_plugin_store::StoreExt;
 use uuid::Uuid;
 
-#[derive(Default, Serialize, Deserialize, Type, Debug)]
+#[derive(Default, Serialize, Deserialize, Type, Debug, Clone, Copy)]
 #[serde(rename_all = "camelCase")]
 pub enum PostStudioRecordingBehaviour {
     #[default]
     OpenEditor,
     ShowOverlay,
 }
 
-#[derive(Default, Serialize, Deserialize, Type, Debug)]
+#[derive(Default, Serialize, Deserialize, Type, Debug, Clone, Copy)]
 #[serde(rename_all = "camelCase")]
 pub enum MainWindowRecordingStartBehaviour {
     #[default]
     Close,
     Minimise,
 }
 
-#[derive(Serialize, Deserialize, Type, Debug)]
+impl MainWindowRecordingStartBehaviour {
+    pub fn perform(&self, window: &tauri::WebviewWindow) -> tauri::Result<()> {
+        match self {
+            Self::Close => window.close(),
+            Self::Minimise => window.minimize(),
+        }
+    }
+}
+
+// When adding fields here, #[serde(default)] defines the value to use for existing configurations,
+// and `Default::default` defines the value to use for new configurations.
+// Things that affect the user experience should only be enabled by default for new configurations.
+#[derive(Serialize, Deserialize, Type, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct GeneralSettingsStore {
     #[serde(default = "uuid::Uuid::new_v4")]
@@ -57,6 +69,8 @@ pub struct GeneralSettingsStore {
     pub custom_cursor_capture: bool,
     #[serde(default = "default_server_url")]
     pub server_url: String,
+    #[serde(default)]
+    pub recording_countdown: Option<u32>,
     #[serde(default, alias = "open_editor_after_recording")]
     #[deprecated]
     _open_editor_after_recording: bool,
@@ -68,7 +82,7 @@ fn default_server_url() -> String {
         .to_string()
 }
 
-#[derive(Serialize, Deserialize, Type, Debug)]
+#[derive(Serialize, Deserialize, Type, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct CommercialLicense {
     license_key: String,
@@ -96,6 +110,7 @@ impl Default for GeneralSettingsStore {
             main_window_recording_start_behaviour: MainWindowRecordingStartBehaviour::Close,
             custom_cursor_capture: false,
             server_url: default_server_url(),
+            recording_countdown: Some(3),
             _open_editor_after_recording: false,
         }
     }

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

@@ -151,6 +151,22 @@ impl App {
             }
         }
     }
+
+    async fn add_recording_logging_handle(&mut self, path: &PathBuf) -> Result<(), String> {
+        let logfile =
+            std::fs::File::create(path).map_err(|e| format!("Failed to create logfile: {e}"))?;
+
+        self.recording_logging_handle
+            .reload(Some(Box::new(
+                tracing_subscriber::fmt::layer()
+                    .with_ansi(false)
+                    .with_target(true)
+                    .with_writer(logfile),
+            ) as DynLoggingLayer))
+            .map_err(|e| format!("Failed to reload logging layer: {e}"))?;
+
+        Ok(())
+    }
 }
 
 #[tauri::command]
@@ -820,6 +836,13 @@ async fn get_editor_meta(editor: WindowEditorInstance) -> Result<RecordingMeta,
     let path = editor.project_path.clone();
     RecordingMeta::load_for_project(&path).map_err(|e| e.to_string())
 }
+#[tauri::command]
+#[specta::specta]
+async fn set_pretty_name(editor: WindowEditorInstance, pretty_name: String) -> Result<(), String> {
+    let mut meta = editor.meta().clone();
+    meta.pretty_name = pretty_name;
+    meta.save_for_project().map_err(|e| e.to_string())
+}
 
 #[tauri::command]
 #[specta::specta]
@@ -1852,6 +1875,7 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
             update_auth_plan,
             set_window_transparent,
             get_editor_meta,
+            set_pretty_name,
             set_server_url,
             set_camera_preview_state,
             await_camera_preview_ready,
@@ -1882,6 +1906,7 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
             audio_meter::AudioInputLevelChange,
             UploadProgress,
             captions::DownloadProgress,
+            recording::RecordingEvent
         ])
         .error_handling(tauri_specta::ErrorHandlingMode::Throw)
         .typ::<ProjectConfiguration>()

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

@@ -6,9 +6,7 @@ use crate::{
     audio::AppSounds,
     auth::AuthStore,
     create_screenshot,
-    general_settings::{
-        GeneralSettingsStore, MainWindowRecordingStartBehaviour, PostStudioRecordingBehaviour,
-    },
+    general_settings::{GeneralSettingsStore, PostStudioRecordingBehaviour},
     open_external_link,
     presets::PresetsStore,
     upload::{
@@ -202,6 +200,15 @@ pub struct StartRecordingInputs {
     pub mode: RecordingMode,
 }
 
+#[derive(tauri_specta::Event, specta::Type, Clone, Debug, serde::Serialize)]
+#[serde(tag = "variant")]
+pub enum RecordingEvent {
+    Countdown { value: u32 },
+    Started,
+    Stopped,
+    Failed { error: String },
+}
+
 #[tauri::command]
 #[specta::specta]
 #[tracing::instrument(name = "recording", skip_all)]
@@ -211,6 +218,8 @@ pub async fn start_recording(
     inputs: StartRecordingInputs,
 ) -> Result<(), String> {
     let id = uuid::Uuid::new_v4().to_string();
+    let general_settings = GeneralSettingsStore::get(&app).ok().flatten();
+    let general_settings = general_settings.as_ref();
 
     let recording_dir = app
         .path()
@@ -220,20 +229,11 @@ pub async fn start_recording(
         .join(format!("{id}.cap"));
 
     ensure_dir(&recording_dir).map_err(|e| format!("Failed to create recording directory: {e}"))?;
-    let logfile = std::fs::File::create(recording_dir.join("recording-logs.log"))
-        .map_err(|e| format!("Failed to create logfile: {e}"))?;
-
     state_mtx
         .write()
         .await
-        .recording_logging_handle
-        .reload(Some(Box::new(
-            tracing_subscriber::fmt::layer()
-                .with_ansi(false)
-                .with_target(true)
-                .with_writer(logfile),
-        ) as DynLoggingLayer))
-        .map_err(|e| format!("Failed to reload logging layer: {e}"))?;
+        .add_recording_logging_handle(&recording_dir.join("recording-logs.log"))
+        .await?;
 
     let target_name = {
         let title = inputs.capture_target.get_title();
@@ -325,6 +325,28 @@ pub async fn start_recording(
         _ => {}
     }
 
+    if let Some(window) = CapWindowId::Main.get(&app) {
+        let _ = general_settings
+            .map(|v| v.main_window_recording_start_behaviour)
+            .unwrap_or_default()
+            .perform(&window);
+    }
+
+    let countdown = general_settings.and_then(|v| v.recording_countdown);
+    let _ = ShowCapWindow::InProgressRecording { countdown }
+        .show(&app)
+        .await;
+
+    if let Some(countdown) = countdown {
+        for t in 0..countdown {
+            let _ = RecordingEvent::Countdown {
+                value: countdown - t,
+            }
+            .emit(&app);
+            tokio::time::sleep(Duration::from_secs(1)).await;
+        }
+    }
+
     let (finish_upload_tx, finish_upload_rx) = flume::bounded(1);
     let progressive_upload = video_upload_info
         .as_ref()
@@ -344,7 +366,7 @@ pub async fn start_recording(
     // done in spawn to catch panics just in case
     let actor_done_rx = spawn_actor({
         let state_mtx = Arc::clone(&state_mtx);
-        let app = app.clone();
+        let general_settings = general_settings.cloned();
         async move {
             fail!("recording::spawn_actor");
             let mut state = state_mtx.write().await;
@@ -362,9 +384,7 @@ pub async fn start_recording(
                         recording_dir.clone(),
                         base_inputs,
                         state.camera_feed.clone(),
-                        GeneralSettingsStore::get(&app)
-                            .ok()
-                            .flatten()
+                        general_settings
                             .map(|s| s.custom_cursor_capture)
                             .unwrap_or_default(),
                     )
@@ -423,6 +443,8 @@ pub async fn start_recording(
     .await
     .map_err(|e| format!("Failed to spawn recording actor: {}", e))??;
 
+    let _ = RecordingEvent::Started.emit(&app);
+
     spawn_actor({
         let app = app.clone();
         let state_mtx = Arc::clone(&state_mtx);
@@ -431,11 +453,14 @@ pub async fn start_recording(
             match actor_done_rx.await {
                 Ok(Ok(_)) => {
                     let _ = finish_upload_tx.send(());
+                    let _ = RecordingEvent::Stopped.emit(&app);
                     return;
                 }
                 Ok(Err(e)) => {
                     let mut state = state_mtx.write().await;
 
+                    let _ = RecordingEvent::Failed { error: e.clone() }.emit(&app);
+
                     let mut dialog = MessageDialogBuilder::new(
                         app.dialog().clone(),
                         format!("An error occurred"),
@@ -457,30 +482,6 @@ pub async fn start_recording(
         }
     });
 
-    if let Some(window) = CapWindowId::Main.get(&app) {
-        match GeneralSettingsStore::get(&app)
-            .ok()
-            .flatten()
-            .map(|s| s.main_window_recording_start_behaviour)
-            .unwrap_or_default()
-        {
-            MainWindowRecordingStartBehaviour::Close => {
-                let _ = window.close();
-            }
-            MainWindowRecordingStartBehaviour::Minimise => {
-                let _ = window.minimize();
-            }
-        }
-    }
-
-    if let Some(window) = CapWindowId::InProgressRecording.get(&app) {
-        window.eval("window.location.reload()").ok();
-    } else {
-        let _ = ShowCapWindow::InProgressRecording { position: None }
-            .show(&app)
-            .await;
-    }
-
     AppSounds::StartRecording.play();
 
     RecordingStarted.emit(&app).ok();
@@ -594,8 +595,11 @@ async fn handle_recording_end(
     // Clear current recording, just in case :)
     app.current_recording.take();
 
-    if let Some(recording) = recording {
-        handle_recording_finish(&handle, recording).await?;
+    let res = if let Some(recording) = recording {
+        // we delay reporting errors here so that everything else happens first
+        Some(handle_recording_finish(&handle, recording).await)
+    } else {
+        None
     };
 
     let _ = RecordingStopped.emit(&handle);
@@ -618,6 +622,10 @@ async fn handle_recording_end(
 
     CurrentRecordingChanged.emit(&handle).ok();
 
+    if let Some(res) = res {
+        res?;
+    }
+
     Ok(())
 }
 

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

@@ -1,20 +1,17 @@
 #![allow(unused_mut)]
 #![allow(unused_imports)]
 
-use crate::{
-    App, ArcLock, camera::CameraPreview, fake_window, general_settings::AppTheme, permissions,
-};
+use crate::{App, ArcLock, fake_window, general_settings::AppTheme, permissions};
 use cap_flags::FLAGS;
 use cap_media::{platform::logical_monitor_bounds, sources::CaptureScreen};
-use futures::{executor::block_on, pin_mut};
+use futures::pin_mut;
 use serde::Deserialize;
 use specta::Type;
 use std::{
-    borrow::Cow,
     ops::Deref,
     path::PathBuf,
     str::FromStr,
-    sync::{Arc, Mutex, atomic::AtomicU32, mpsc},
+    sync::{Arc, Mutex, atomic::AtomicU32},
 };
 use tauri::{
     AppHandle, LogicalPosition, Manager, Monitor, PhysicalPosition, PhysicalSize, WebviewUrl,
@@ -133,14 +130,6 @@ impl CapWindowId {
         app.get_webview_window(&label)
     }
 
-    #[cfg(target_os = "windows")]
-    pub fn should_have_decorations(&self) -> bool {
-        matches!(
-            self,
-            Self::Setup | Self::Settings | Self::Editor { .. } | Self::ModeSelect
-        )
-    }
-
     #[cfg(target_os = "macos")]
     pub fn traffic_lights_position(&self) -> Option<Option<LogicalPosition<f64>>> {
         match self {
@@ -320,6 +309,8 @@ impl ShowCapWindow {
             Self::Camera => {
                 const WINDOW_SIZE: f64 = 230.0 * 2.0;
 
+                let port = app.state::<Arc<RwLock<App>>>().read().await.camera_ws_port;
+
                 let mut window_builder = self
                     .window_builder(app, "/camera")
                     .maximized(false)
@@ -335,8 +326,13 @@ impl ShowCapWindow {
                             - WINDOW_SIZE
                             - 100.0,
                     )
-                    .transparent(true)
-                    .visible(false); // We set this true in `CameraWindowState::init_window`
+                    .initialization_script(&format!(
+                        "
+			                window.__CAP__ = window.__CAP__ ?? {{}};
+			                window.__CAP__.cameraWsPort = {port};
+		                ",
+                    ))
+                    .transparent(true);
 
                 let window = window_builder.build()?;
 
@@ -439,7 +435,8 @@ impl ShowCapWindow {
             Self::InProgressRecording {
                 position: _position,
             } => {
-                let width = 244.0;
+                let mut width = 180.0 + 32.0;
+
                 let height = 40.0;
 
                 let window = self