Restore main window inputs; refactor device locking

Author: richiemcilroy

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

@@ -4722,6 +4722,7 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
                                             }
                                             CapWindowId::Main => {
                                                 let _ = window.show();
+                                                restore_main_window_inputs(app);
                                             }
                                             _ => {}
                                         }
@@ -4747,6 +4748,7 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
                                             }
                                             CapWindowId::Main => {
                                                 let _ = window.show();
+                                                restore_main_window_inputs(app);
                                             }
                                             _ => {}
                                         }
@@ -5087,13 +5089,21 @@ fn restore_main_windows_if_no_editors(app: &AppHandle) {
                 let _ = main.show();
             }
 
+            restore_main_window_inputs(app);
             restore_camera_window(app);
         }
 
         spawn_on_runtime(captions::release_ml_models());
     }
 }
 
+fn restore_main_window_inputs(app: &AppHandle) {
+    let handle = app.clone();
+    spawn_on_runtime(async move {
+        windows::restore_main_window_inputs(&handle).await;
+    });
+}
+
 fn restore_camera_window(app: &AppHandle) {
     let should_restore_camera = app
         .try_state::<ArcLock<App>>()
@@ -5142,6 +5152,7 @@ fn reopen_main_window(app: &AppHandle) {
     if let Some(main) = CapWindowId::Main.get(app) {
         let _ = main.show();
         let _ = main.set_focus();
+        restore_main_window_inputs(app);
     } else {
         let handle = app.clone();
         tokio::spawn(async move {

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

@@ -557,10 +557,7 @@ fn camera_id_label(id: &camera::DeviceOrModelID) -> String {
     }
 }
 
-fn camera_lock_matches_id(
-    lock: &CameraFeedLock,
-    selected_id: &camera::DeviceOrModelID,
-) -> bool {
+fn camera_lock_matches_id(lock: &CameraFeedLock, selected_id: &camera::DeviceOrModelID) -> bool {
     let camera_info = lock.camera_info();
     match selected_id {
         camera::DeviceOrModelID::DeviceID(device_id) => camera_info.device_id() == device_id,
@@ -582,7 +579,7 @@ async fn initialize_selected_camera(
         .await
         .map_err(|err| anyhow!("Failed to initialize selected camera '{label}': {err}"))?;
 
-    ready.await.map_err(|err| match err {
+    ready.await.map(|_| ()).map_err(|err| match err {
         camera::SetInputError::DeviceNotFound => {
             anyhow!("Selected camera '{label}' is no longer available")
         }
@@ -597,9 +594,7 @@ async fn lock_initialized_camera(
     let label = camera_id_label(id);
     match camera_feed.ask(camera::Lock).await {
         Ok(lock) => Ok(lock),
-        Err(kameo::error::SendError::HandlerError(
-            camera::LockFeedError::NoInput,
-        )) => Err(anyhow!(
+        Err(kameo::error::SendError::HandlerError(camera::LockFeedError::NoInput)) => Err(anyhow!(
             "Selected camera '{label}' did not become ready after initialization"
         )),
         Err(err) => Err(anyhow!("Failed to lock selected camera '{label}': {err}")),
@@ -655,9 +650,7 @@ async fn lock_selected_camera(
             tokio::time::sleep(Duration::from_millis(50)).await;
             None
         }
-        Err(kameo::error::SendError::HandlerError(
-            camera::LockFeedError::NoInput,
-        )) => None,
+        Err(kameo::error::SendError::HandlerError(camera::LockFeedError::NoInput)) => None,
         Err(err) => {
             return Err(anyhow!(
                 "Failed to lock selected camera '{}': {err}",
@@ -690,7 +683,7 @@ async fn initialize_selected_microphone(
         .await
         .map_err(|err| anyhow!("Failed to initialize selected microphone '{label}': {err}"))?;
 
-    ready.await.map_err(|err| match err {
+    ready.await.map(|_| ()).map_err(|err| match err {
         microphone::SetInputError::DeviceNotFound => {
             anyhow!("Selected microphone '{label}' is no longer available")
         }
@@ -704,12 +697,12 @@ async fn lock_initialized_microphone(
 ) -> anyhow::Result<microphone::MicrophoneFeedLock> {
     match mic_feed.ask(microphone::Lock).await {
         Ok(lock) => Ok(lock),
-        Err(kameo::error::SendError::HandlerError(
-            microphone::LockFeedError::NoInput,
-        )) => Err(anyhow!(
-            "Selected microphone '{label}' did not become ready after initialization"
+        Err(kameo::error::SendError::HandlerError(microphone::LockFeedError::NoInput)) => Err(
+            anyhow!("Selected microphone '{label}' did not become ready after initialization"),
+        ),
+        Err(err) => Err(anyhow!(
+            "Failed to lock selected microphone '{label}': {err}"
         )),
-        Err(err) => Err(anyhow!("Failed to lock selected microphone '{label}': {err}")),
     }
 }
 
@@ -1102,9 +1095,7 @@ pub async fn start_recording(
         let inputs = inputs.clone();
         async move {
             fail!("recording::spawn_actor");
-            use kameo::error::SendError;
 
-            // Initialize camera if selected but not active
             let (camera_feed_actor, selected_camera_id, selected_camera_settings) = {
                 let state = state_mtx.read().await;
                 let selected_camera_settings = state.selected_camera_id.as_ref().and_then(|id| {
@@ -1120,52 +1111,16 @@ pub async fn start_recording(
                 )
             };
 
-            let camera_lock_result = camera_feed_actor.ask(camera::Lock).await;
-
-            let camera_feed_lock = match camera_lock_result {
-                Ok(lock) => Some(lock),
-                Err(SendError::HandlerError(camera::LockFeedError::NoInput)) => {
-                    if let Some(id) = selected_camera_id {
-                        info!(
-                            "Camera selected but not initialized, initializing: {:?}",
-                            id
-                        );
-                        match camera_feed_actor
-                            .ask(camera::SetInput {
-                                id: id.clone(),
-                                settings: selected_camera_settings,
-                            })
-                            .await
-                        {
-                            Ok(fut) => match fut.await {
-                                Ok(_) => match camera_feed_actor.ask(camera::Lock).await {
-                                    Ok(lock) => Some(lock),
-                                    Err(e) => {
-                                        warn!("Failed to lock camera after initialization: {}", e);
-                                        None
-                                    }
-                                },
-                                Err(e) => {
-                                    warn!("Failed to initialize camera: {}", e);
-                                    None
-                                }
-                            },
-                            Err(e) => {
-                                warn!("Failed to ask SetInput: {}", e);
-                                None
-                            }
-                        }
-                    } else {
-                        None
-                    }
-                }
-                Err(e) => return Err(anyhow!(e.to_string())),
-            };
+            let camera_feed = lock_selected_camera(
+                &camera_feed_actor,
+                selected_camera_id,
+                selected_camera_settings,
+                &inputs.capture_target,
+            )
+            .await?;
 
             let mut state = state_mtx.write().await;
 
-            let camera_feed = camera_feed_lock.map(Arc::new);
-
             state.camera_in_use = camera_feed.is_some();
 
             #[cfg(target_os = "macos")]
@@ -1801,34 +1756,30 @@ async fn lock_selected_microphone(
         return Ok(None);
     };
 
-    match mic_feed.ask(microphone::Lock).await {
-        Ok(lock) => return Ok(Some(Arc::new(lock))),
-        Err(kameo::error::SendError::HandlerError(microphone::LockFeedError::NoInput)) => {}
-        Err(err) => return Err(anyhow!(err.to_string())),
-    }
-
-    let ready = mic_feed
-        .ask(microphone::SetInput {
-            label: label.clone(),
-            settings: selected_settings,
-        })
-        .await
-        .map_err(|err| anyhow!(err.to_string()))?;
-
-    ready.await.map_err(|err| match err {
-        microphone::SetInputError::DeviceNotFound => {
-            anyhow!("Selected microphone '{label}' is no longer available")
+    let existing_lock = match mic_feed.ask(microphone::Lock).await {
+        Ok(lock) if lock.device_name() == label => Some(lock),
+        Ok(lock) => {
+            drop(lock);
+            tokio::time::sleep(Duration::from_millis(50)).await;
+            None
         }
-        err => anyhow!("Failed to initialize selected microphone '{label}': {err}"),
-    })?;
+        Err(kameo::error::SendError::HandlerError(microphone::LockFeedError::NoInput)) => None,
+        Err(err) => {
+            return Err(anyhow!(
+                "Failed to lock selected microphone '{label}': {err}"
+            ));
+        }
+    };
 
-    match mic_feed.ask(microphone::Lock).await {
-        Ok(lock) => Ok(Some(Arc::new(lock))),
-        Err(kameo::error::SendError::HandlerError(microphone::LockFeedError::NoInput)) => Err(
-            anyhow!("Selected microphone '{label}' did not become ready after initialization"),
-        ),
-        Err(err) => Err(anyhow!(err.to_string())),
-    }
+    let lock = if let Some(lock) = existing_lock {
+        lock
+    } else {
+        initialize_selected_microphone(mic_feed, &label, selected_settings).await?;
+        lock_initialized_microphone(mic_feed, &label).await?
+    };
+
+    validate_microphone_receiving(&lock, &label).await?;
+    Ok(Some(Arc::new(lock)))
 }
 
 fn mic_actor_not_running(err: &anyhow::Error) -> bool {
@@ -1866,6 +1817,92 @@ where
     }
 }
 
+async fn cancel_discarded_recording(
+    app: &AppHandle,
+    recording: InProgressRecording,
+) -> Option<String> {
+    match recording {
+        InProgressRecording::Instant {
+            handle,
+            segment_upload,
+            video_upload_info,
+            ..
+        } => {
+            let video_id = video_upload_info.id;
+            segment_upload.handle.abort();
+
+            if let Err(err) = handle.cancel().await {
+                warn!("Failed to cancel instant recording while discarding: {err:#}");
+            }
+
+            match segment_upload.handle.await {
+                Ok(Ok(())) => {}
+                Ok(Err(err)) => warn!("Instant upload ended while discarding recording: {err}"),
+                Err(err) if err.is_cancelled() => {}
+                Err(err) => {
+                    warn!("Failed to join instant upload while discarding recording: {err}")
+                }
+            }
+
+            crate::upload::emit_upload_complete(app, &video_id);
+            Some(video_id)
+        }
+        InProgressRecording::Studio { handle, .. } => {
+            if let Err(err) = handle.cancel().await {
+                warn!("Failed to cancel studio recording while discarding: {err:#}");
+            }
+
+            None
+        }
+    }
+}
+
+async fn remove_recording_dir(recording_dir: &Path) -> Result<(), String> {
+    match tokio::fs::remove_dir_all(recording_dir).await {
+        Ok(()) => Ok(()),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(()),
+        Err(err) => Err(format!("Failed to delete recording files: {err}")),
+    }
+}
+
+async fn delete_remote_instant_video(app: &AppHandle, video_id: &str) -> Result<(), String> {
+    let response = app
+        .authed_api_request(
+            format!("/api/desktop/video/delete?videoId={video_id}"),
+            |client, url| client.delete(url),
+        )
+        .await
+        .map_err(|err| format!("Failed to delete instant recording: {err}"))?;
+
+    let status = response.status();
+    if status.is_success() || status == reqwest::StatusCode::NOT_FOUND {
+        return Ok(());
+    }
+
+    let body = response
+        .text()
+        .await
+        .unwrap_or_else(|err| format!("Failed to read response body: {err}"));
+
+    Err(format!(
+        "Failed to delete instant recording {video_id}: {status}: {body}"
+    ))
+}
+
+async fn discard_recording(app: &AppHandle, recording: InProgressRecording) -> Result<(), String> {
+    let recording_dir = recording.recording_dir().clone();
+    let video_id = cancel_discarded_recording(app, recording).await;
+    let local_delete = remove_recording_dir(&recording_dir).await;
+    let remote_delete = if let Some(video_id) = video_id {
+        delete_remote_instant_video(app, &video_id).await
+    } else {
+        Ok(())
+    };
+
+    remote_delete?;
+    local_delete
+}
+
 #[tauri::command]
 #[specta::specta]
 #[instrument(skip(app, state))]
@@ -1910,7 +1947,7 @@ pub async fn restart_recording(
 
     let inputs = recording.inputs().clone();
 
-    let _ = recording.cancel().await;
+    discard_recording(&app, recording).await?;
 
     tokio::time::sleep(Duration::from_millis(1000)).await;
 
@@ -1927,41 +1964,11 @@ pub async fn delete_recording(app: AppHandle, state: MutableState<'_, App>) -> R
     };
 
     if let Some(recording) = recording_data {
-        let recording_dir = recording.recording_dir().clone();
         CurrentRecordingChanged.emit(&app).ok();
         RecordingStopped {}.emit(&app).ok();
 
-        let video_id = match &recording {
-            InProgressRecording::Instant {
-                video_upload_info,
-                segment_upload,
-                ..
-            } => {
-                debug!(
-                    "User deleted recording. Aborting multipart upload for {:?}",
-                    video_upload_info.id
-                );
-                segment_upload.handle.abort();
-
-                Some(video_upload_info.id.clone())
-            }
-            _ => None,
-        };
-
-        let _ = recording.cancel().await;
+        let delete_result = discard_recording(&app, recording).await;
 
-        std::fs::remove_dir_all(&recording_dir).ok();
-
-        if let Some(id) = video_id {
-            let _ = app
-                .authed_api_request(
-                    format!("/api/desktop/video/delete?videoId={id}"),
-                    |c, url| c.delete(url),
-                )
-                .await;
-        }
-
-        // Check user's post-deletion behavior setting
         let settings = GeneralSettingsStore::get(&app)
             .ok()
             .flatten()
@@ -1981,6 +1988,8 @@ pub async fn delete_recording(app: AppHandle, state: MutableState<'_, App>) -> R
                 .await;
             }
         }
+
+        delete_result?;
     }
 
     Ok(())