Merge pull request #1720 from CapSoftware/0.4.84-fixes

0.4.84 fixes

Author: richiemcilroy

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

@@ -624,6 +624,7 @@ impl Renderer {
         let mut is_paused = false;
 
         let mut state = default_state;
+        let mut needs_full_reconfigure = false;
 
         let pause_and_hide = || {
             window
@@ -642,6 +643,7 @@ impl Renderer {
                     match reconfigure.recv().await {
                         Ok(ReconfigureEvent::Resume) => {
                             is_paused = false;
+                            while camera_rx.try_recv().is_ok() {}
                             break;
                         }
                         Ok(ReconfigureEvent::Shutdown) => {
@@ -650,6 +652,7 @@ impl Renderer {
                         }
                         Ok(ReconfigureEvent::State(new_state)) => {
                             state = new_state;
+                            needs_full_reconfigure = true;
                         }
                         Ok(ReconfigureEvent::WindowResized { width, height }) => {
                             self.reconfigure_gpu_surface(width, height);
@@ -662,14 +665,35 @@ impl Renderer {
                 }
             }
 
-            let event = loop {
-                let timeout_remaining = if received_first_frame {
-                    Duration::MAX
-                } else {
-                    startup_timeout.saturating_sub(start_time.elapsed())
-                };
+            if needs_full_reconfigure {
+                needs_full_reconfigure = false;
+                self.update_state_uniforms(&state);
+                let aspect_ratio = self.aspect_ratio.get_latest_key().copied().unwrap_or(
+                    if state.shape == CameraPreviewShape::Full {
+                        16.0 / 9.0
+                    } else {
+                        1.0
+                    },
+                );
+                self.aspect_ratio = Cached::default();
+                if let Ok((width, height)) = resize_window(&window, &state, aspect_ratio, false)
+                    .await
+                    .map_err(|err| {
+                        error!("Error resizing camera preview window after resume: {err}")
+                    })
+                {
+                    self.reconfigure_gpu_surface(width, height);
+                }
+            }
+
+            let frame_timeout = if received_first_frame {
+                Duration::from_secs(5)
+            } else {
+                startup_timeout.saturating_sub(start_time.elapsed())
+            };
 
-                if timeout_remaining.is_zero() {
+            let event = loop {
+                if frame_timeout.is_zero() {
                     warn!(
                         "Camera preview timed out waiting for first frame, entering paused state"
                     );
@@ -696,8 +720,8 @@ impl Renderer {
                             continue;
                         }
                     },
-                    _ = tokio::time::sleep(timeout_remaining) => {
-                        warn!("Camera preview timed out waiting for first frame, entering paused state");
+                    _ = tokio::time::sleep(frame_timeout) => {
+                        warn!("Camera preview: no frames received within timeout, entering paused state");
                         is_paused = true;
                         pause_and_hide();
                         continue 'main_loop;
@@ -808,8 +832,7 @@ impl Renderer {
                         .ok();
                 }
                 Err(ReconfigureEvent::Resume) => {
-                    // On resume, we just need to present a frame to wake up the surface.
-                    // The actual window.show() happens in windows.rs ShowCapWindow::Camera.
+                    while camera_rx.try_recv().is_ok() {}
                     if let Some(surface) = &self.surface
                         && let Ok(texture) = surface.get_current_texture()
                     {

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

@@ -1,9 +1,12 @@
-use scap_targets::{Display, DisplayId, bounds::LogicalBounds};
+use cap_recording::sources::screen_capture::ScreenCaptureTarget;
+use scap_targets::{Display, DisplayId, Window as ScapWindow, bounds::LogicalBounds};
 use std::{collections::HashMap, sync::Arc, time::Duration};
 use tauri::{AppHandle, Manager, WebviewWindow};
 use tokio::{sync::RwLock, time::sleep};
 use tracing::instrument;
 
+use crate::{App, ArcLock, RecordingState};
+
 const RECORDING_CONTROLS_LABEL: &str = "in-progress-recording";
 const RECORDING_CONTROLS_WIDTH: f64 = 320.0;
 const RECORDING_CONTROLS_HEIGHT: f64 = 150.0;
@@ -70,6 +73,37 @@ fn calculate_bottom_center_position(display: &Display) -> Option<(f64, f64)> {
     Some((pos_x, pos_y))
 }
 
+const TARGET_CONTROLS_OFFSET_Y: f64 = 48.0;
+
+pub fn calculate_recording_controls_position_for_target(
+    capture_target: &ScreenCaptureTarget,
+) -> Option<(f64, f64)> {
+    match capture_target {
+        ScreenCaptureTarget::Window { id } => {
+            let window = ScapWindow::from_id(id)?;
+            let bounds = window.raw_handle().logical_bounds()?;
+            let pos_x =
+                bounds.position().x() + (bounds.size().width() - RECORDING_CONTROLS_WIDTH) / 2.0;
+            let pos_y = bounds.position().y() + bounds.size().height()
+                - RECORDING_CONTROLS_HEIGHT
+                - TARGET_CONTROLS_OFFSET_Y;
+            Some((pos_x, pos_y))
+        }
+        ScreenCaptureTarget::Area { screen, bounds } => {
+            let display = Display::from_id(screen)?;
+            let display_bounds = display.raw_handle().logical_bounds()?;
+            let abs_x = display_bounds.position().x() + bounds.position().x();
+            let abs_y = display_bounds.position().y() + bounds.position().y();
+            let pos_x = abs_x + (bounds.size().width() - RECORDING_CONTROLS_WIDTH) / 2.0;
+            let pos_y = abs_y + bounds.size().height()
+                - RECORDING_CONTROLS_HEIGHT
+                - TARGET_CONTROLS_OFFSET_Y;
+            Some((pos_x, pos_y))
+        }
+        _ => None,
+    }
+}
+
 pub fn spawn_fake_window_listener(app: AppHandle, window: WebviewWindow) {
     window.set_ignore_cursor_events(true).ok();
 
@@ -78,19 +112,59 @@ pub fn spawn_fake_window_listener(app: AppHandle, window: WebviewWindow) {
     tokio::spawn(async move {
         let state = app.state::<FakeWindowBounds>();
         let mut current_display_id: Option<DisplayId> = get_display_id_for_cursor();
+        let mut last_target_pos: Option<(f64, f64)> = None;
 
         loop {
             sleep(Duration::from_millis(1000 / 20)).await;
 
-            if is_recording_controls && let Some(cursor_display_id) = get_display_id_for_cursor() {
-                let display_changed = current_display_id.as_ref() != Some(&cursor_display_id);
+            if is_recording_controls {
+                let capture_target = app.state::<ArcLock<App>>().try_read().ok().and_then(|s| {
+                    match &s.recording_state {
+                        RecordingState::Pending { target, .. } => Some(target.clone()),
+                        RecordingState::Active(inner) => Some(inner.capture_target().clone()),
+                        RecordingState::None => None,
+                    }
+                });
+
+                let mut handled = false;
+
+                if let Some(ref target) = capture_target {
+                    match target {
+                        ScreenCaptureTarget::Window { .. } => {
+                            if let Some((px, py)) =
+                                calculate_recording_controls_position_for_target(target)
+                            {
+                                let changed = match last_target_pos {
+                                    Some((lx, ly)) => {
+                                        (px - lx).abs() > 0.5 || (py - ly).abs() > 0.5
+                                    }
+                                    None => true,
+                                };
+                                if changed {
+                                    let _ =
+                                        window.set_position(tauri::LogicalPosition::new(px, py));
+                                    last_target_pos = Some((px, py));
+                                }
+                                handled = true;
+                            }
+                        }
+                        ScreenCaptureTarget::Area { .. } => {
+                            handled = true;
+                        }
+                        _ => {}
+                    }
+                }
+
+                if !handled && let Some(cursor_display_id) = get_display_id_for_cursor() {
+                    let display_changed = current_display_id.as_ref() != Some(&cursor_display_id);
 
-                if display_changed
-                    && let Some(display) = get_display_by_id(&cursor_display_id)
-                    && let Some((pos_x, pos_y)) = calculate_bottom_center_position(&display)
-                {
-                    let _ = window.set_position(tauri::LogicalPosition::new(pos_x, pos_y));
-                    current_display_id = Some(cursor_display_id);
+                    if display_changed
+                        && let Some(display) = get_display_by_id(&cursor_display_id)
+                        && let Some((pos_x, pos_y)) = calculate_bottom_center_position(&display)
+                    {
+                        let _ = window.set_position(tauri::LogicalPosition::new(pos_x, pos_y));
+                        current_display_id = Some(cursor_display_id);
+                    }
                 }
             }
 

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

@@ -206,14 +206,21 @@ where
     }
 }
 
+fn force_exit(code: i32) -> ! {
+    unsafe extern "C" {
+        fn _exit(code: i32) -> !;
+    }
+    unsafe { _exit(code) }
+}
+
 fn spawn_exit_watchdog() {
     std::thread::spawn(move || {
         std::thread::sleep(APP_EXIT_FORCE_TIMEOUT);
         error!(
             timeout_ms = APP_EXIT_FORCE_TIMEOUT.as_millis(),
             "Forcing process exit after shutdown deadline"
         );
-        std::process::exit(0);
+        force_exit(0);
     });
 }
 
@@ -1074,13 +1081,18 @@ async fn cleanup_camera_window(app: AppHandle, session_id: u64) {
             label.starts_with("target-select-overlay-") && window.is_visible().unwrap_or(false)
         });
 
+        let main_window_visible = CapWindowId::Main
+            .get(&app)
+            .and_then(|w| w.is_visible().ok())
+            .unwrap_or(false);
+
         let is_camera_only_mode = recording_settings::RecordingSettingsStore::get(&app)
             .ok()
             .flatten()
             .and_then(|s| s.target)
             .is_some_and(|t| matches!(t, ScreenCaptureTarget::CameraOnly));
 
-        if is_camera_only_mode {
+        if is_camera_only_mode && main_window_visible {
             tracing::info!("Camera cleanup: preserving camera feed for camera-only mode");
             return;
         }
@@ -1202,7 +1214,7 @@ fn finalize_app_exit(app: &AppHandle, exit_code: i32) -> ! {
         }
     });
     match app_exit_action(exit_code) {
-        AppExitAction::Process(code) => std::process::exit(code),
+        AppExitAction::Process(code) => force_exit(code),
     }
 }
 
@@ -4206,7 +4218,7 @@ fn restore_camera_window(app: &AppHandle) {
     let should_restore_camera = app
         .state::<ArcLock<App>>()
         .try_read()
-        .map(|state| state.selected_camera_id.is_some())
+        .map(|state| state.selected_camera_id.is_some() && !state.camera_cleanup_done)
         .unwrap_or(false);
 
     if should_restore_camera {

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

@@ -655,15 +655,21 @@ pub async fn start_recording(
         RecordingMode::Instant => {
             match AuthStore::get(&app).ok().flatten() {
                 Some(_) => {
-                    // Pre-create the video and get the shareable link
+                    let upload_mode =
+                        if matches!(inputs.capture_target, ScreenCaptureTarget::CameraOnly) {
+                            "desktopMP4"
+                        } else {
+                            "desktopSegments"
+                        };
+
                     let s3_config = match crate::upload::create_or_get_video_with_mode(
                         &app,
                         false,
                         None,
                         Some(project_name.clone()),
                         None,
                         inputs.organization_id.clone(),
-                        "desktopSegments",
+                        upload_mode,
                     )
                     .await
                     {
@@ -764,9 +770,12 @@ pub async fn start_recording(
             win.hide().ok();
         }
     }
-    let _ = ShowCapWindow::InProgressRecording { countdown }
-        .show(&app)
-        .await;
+    let _ = ShowCapWindow::InProgressRecording {
+        countdown,
+        capture_target: Some(inputs.capture_target.clone()),
+    }
+    .show(&app)
+    .await;
 
     if let Some(window) = CapWindowId::Main.get(&app) {
         let _ = general_settings
@@ -1845,27 +1854,36 @@ async fn handle_recording_finish(
             }
 
             let app = app.clone();
-            let segments_dir = recording_dir.join("content/display");
+            let is_camera_only =
+                matches!(recording.display_source, ScreenCaptureTarget::CameraOnly);
 
             let display_screenshot = screenshots_dir.join("display.jpg");
-            let screenshot_task = tokio::spawn({
-                let segments_dir = segments_dir.clone();
-                let display_screenshot = display_screenshot.clone();
-                async move {
-                    let screenshot_source: Result<PathBuf, String> =
-                        create_screenshot_source_from_segments(&segments_dir).await;
-                    match screenshot_source {
-                        Ok(temp_path) => {
-                            let result =
-                                create_screenshot(temp_path.clone(), display_screenshot, None)
-                                    .await;
-                            let _ = tokio::fs::remove_file(&temp_path).await;
-                            result
+            let screenshot_task = if is_camera_only {
+                let output_mp4 = recording_dir.join("content/output.mp4");
+                tokio::spawn({
+                    let display_screenshot = display_screenshot.clone();
+                    async move { create_screenshot(output_mp4, display_screenshot, None).await }
+                })
+            } else {
+                let segments_dir = recording_dir.join("content/display");
+                tokio::spawn({
+                    let display_screenshot = display_screenshot.clone();
+                    async move {
+                        let screenshot_source: Result<PathBuf, String> =
+                            create_screenshot_source_from_segments(&segments_dir).await;
+                        match screenshot_source {
+                            Ok(temp_path) => {
+                                let result =
+                                    create_screenshot(temp_path.clone(), display_screenshot, None)
+                                        .await;
+                                let _ = tokio::fs::remove_file(&temp_path).await;
+                                result
+                            }
+                            Err(e) => Err(format!("Failed to create screenshot source: {e}")),
                         }
-                        Err(e) => Err(format!("Failed to create screenshot source: {e}")),
                     }
-                }
-            });
+                })
+            };
 
             let _ = open_external_link(app.clone(), video_upload_info.link.clone());
 

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

@@ -2684,7 +2684,7 @@ mod tests {
             }
 
             use futures::StreamExt;
-            while let Some(_) = in_flight.next().await {}
+            while in_flight.next().await.is_some() {}
         }
         let old_duration = old_start.elapsed();
 
@@ -2712,7 +2712,7 @@ mod tests {
             }
 
             use futures::StreamExt;
-            while let Some(_) = in_flight.next().await {}
+            while in_flight.next().await.is_some() {}
         }
         let new_duration = new_start.elapsed();