Merge pull request #1709 from CapSoftware/sentry-bugs

Misc sentry bugs, performance stuff etc

Author: richiemcilroy

Cargo.lock

@@ -150,3 +150,6 @@ winreg = "0.55"
 
 [target.'cfg(unix)'.dependencies]
 nix = { version = "0.29.0", features = ["fs"] }
+
+[dev-dependencies]
+tauri = { workspace = true, features = ["test"] }

apps/desktop/src-tauri/Cargo.toml

@@ -67,6 +67,20 @@ fn clamp_size(size: f32) -> f32 {
     size.clamp(MIN_CAMERA_SIZE, MAX_CAMERA_SIZE)
 }
 
+fn preferred_alpha_mode(alpha_modes: &[CompositeAlphaMode]) -> CompositeAlphaMode {
+    [
+        CompositeAlphaMode::PreMultiplied,
+        CompositeAlphaMode::PostMultiplied,
+        CompositeAlphaMode::Opaque,
+        CompositeAlphaMode::Auto,
+        CompositeAlphaMode::Inherit,
+    ]
+    .into_iter()
+    .find(|mode| alpha_modes.contains(mode))
+    .or_else(|| alpha_modes.first().copied())
+    .unwrap_or(CompositeAlphaMode::Opaque)
+}
+
 pub struct CameraPreviewManager {
     store: Result<Arc<tauri_plugin_store::Store<tauri::Wry>>, String>,
     preview: Option<InitializedCameraPreview>,
@@ -483,19 +497,7 @@ impl InitializedCameraPreview {
         });
 
         let surface_capabilities = surface.get_capabilities(&adapter);
-        let alpha_mode = if surface_capabilities
-            .alpha_modes
-            .contains(&CompositeAlphaMode::PreMultiplied)
-        {
-            CompositeAlphaMode::PreMultiplied
-        } else if surface_capabilities
-            .alpha_modes
-            .contains(&CompositeAlphaMode::PostMultiplied)
-        {
-            CompositeAlphaMode::PostMultiplied
-        } else {
-            CompositeAlphaMode::Inherit
-        };
+        let alpha_mode = preferred_alpha_mode(&surface_capabilities.alpha_modes);
 
         let surface_config = wgpu::SurfaceConfiguration {
             usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
@@ -1021,6 +1023,51 @@ async fn resize_window(
         .map_err(anyhow::Error::new)
 }
 
+#[cfg(test)]
+mod tests {
+    use super::preferred_alpha_mode;
+    use wgpu::CompositeAlphaMode;
+
+    #[test]
+    fn preferred_alpha_mode_avoids_unsupported_inherit_fallback() {
+        assert_eq!(
+            preferred_alpha_mode(&[CompositeAlphaMode::Opaque]),
+            CompositeAlphaMode::Opaque
+        );
+    }
+
+    #[test]
+    fn preferred_alpha_mode_keeps_transparent_modes_when_supported() {
+        assert_eq!(
+            preferred_alpha_mode(&[
+                CompositeAlphaMode::Opaque,
+                CompositeAlphaMode::PreMultiplied,
+            ]),
+            CompositeAlphaMode::PreMultiplied
+        );
+        assert_eq!(
+            preferred_alpha_mode(&[
+                CompositeAlphaMode::Opaque,
+                CompositeAlphaMode::PostMultiplied,
+            ]),
+            CompositeAlphaMode::PostMultiplied
+        );
+    }
+
+    #[test]
+    fn preferred_alpha_mode_uses_other_supported_fallbacks() {
+        assert_eq!(
+            preferred_alpha_mode(&[CompositeAlphaMode::Auto]),
+            CompositeAlphaMode::Auto
+        );
+        assert_eq!(
+            preferred_alpha_mode(&[CompositeAlphaMode::Inherit]),
+            CompositeAlphaMode::Inherit
+        );
+        assert_eq!(preferred_alpha_mode(&[]), CompositeAlphaMode::Opaque);
+    }
+}
+
 fn render_solid_frame(color: [u8; 4], width: u32, height: u32) -> (Vec<u8>, u32) {
     let pixel_count = (height * width) as usize;
     let buffer: Vec<u8> = color

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

@@ -1,5 +1,4 @@
 use crate::editor_window::{OptionalWindowEditorInstance, WindowEditorInstance};
-use crate::recording::should_force_ffmpeg_for_recovered_project;
 use crate::{FramesRendered, get_video_metadata};
 use cap_export::{ExporterBase, make_cursor_only_project};
 use cap_project::{RecordingMeta, XY};
@@ -145,7 +144,8 @@ fn is_frame_decode_error(error: &str) -> bool {
 }
 
 fn should_force_ffmpeg_export(project_path: &Path, settings: &ExportSettings) -> bool {
-    settings.force_ffmpeg_decoder() || should_force_ffmpeg_for_recovered_project(project_path)
+    let _ = project_path;
+    settings.force_ffmpeg_decoder()
 }
 
 #[tauri::command]
@@ -541,7 +541,7 @@ mod tests {
     }
 
     #[test]
-    fn recovered_projects_force_ffmpeg_for_gif_exports() {
+    fn recovered_projects_do_not_force_ffmpeg_without_explicit_setting() {
         let dir = tempdir().unwrap();
         std::fs::write(
             dir.path()
@@ -556,7 +556,7 @@ mod tests {
             quality: None,
         });
 
-        assert!(should_force_ffmpeg_export(dir.path(), &gif_settings));
+        assert!(!should_force_ffmpeg_export(dir.path(), &gif_settings));
     }
 }
 

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

@@ -268,7 +268,12 @@ impl GeneralSettingsStore {
         let mut settings = Self::get(app)?.unwrap_or_default();
         update(&mut settings);
         store.set("general_settings", json!(settings));
-        store.save().map_err(|e| e.to_string())
+        store.save().map_err(|e| e.to_string())?;
+
+        #[cfg(target_os = "macos")]
+        crate::permissions::sync_macos_dock_visibility(app);
+
+        Ok(())
     }
 
     fn save(&self, app: &AppHandle) -> Result<(), String> {
@@ -297,6 +302,9 @@ pub fn init(app: &AppHandle) {
         error!("Failed to save general settings: {}", e);
     }
 
+    #[cfg(target_os = "macos")]
+    crate::permissions::sync_macos_dock_visibility(app);
+
     println!("GeneralSettingsState managed");
 }
 

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

@@ -33,7 +33,7 @@ mod thumbnails;
 mod tray;
 mod update_project_names;
 mod upload;
-mod web_api;
+pub mod web_api;
 mod window_exclusion;
 mod windows;
 
@@ -89,6 +89,7 @@ use std::{
     },
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
+use tauri::Listener;
 use tauri::{AppHandle, Manager, State, Window, WindowEvent, ipc::Channel};
 use tauri_plugin_deep_link::DeepLinkExt;
 use tauri_plugin_dialog::DialogExt;
@@ -158,6 +159,24 @@ impl AppExitState {
     }
 }
 
+pub struct MainWindowReadyState(AtomicBool);
+
+impl Default for MainWindowReadyState {
+    fn default() -> Self {
+        Self(AtomicBool::new(false))
+    }
+}
+
+impl MainWindowReadyState {
+    pub fn is_ready(&self) -> bool {
+        self.0.load(Ordering::Acquire)
+    }
+
+    pub fn set_ready(&self, value: bool) {
+        self.0.store(value, Ordering::Release);
+    }
+}
+
 const APP_EXIT_STEP_TIMEOUT: Duration = Duration::from_millis(750);
 const APP_EXIT_CAMERA_SHUTDOWN_TIMEOUT: Duration = Duration::from_millis(1200);
 const APP_EXIT_TOTAL_TIMEOUT: Duration = Duration::from_secs(3);
@@ -1113,14 +1132,6 @@ async fn cleanup_app_resources_for_exit(app: &AppHandle) {
     })
     .await;
 
-    #[cfg(target_os = "macos")]
-    {
-        app.state::<CameraWindowCloseGate>().set_allow_close(true);
-        if let Some(camera_window) = CapWindowId::Camera.get(app) {
-            let _ = camera_window.close();
-        }
-    }
-
     if let Some(rx) = camera_shutdown {
         let _ = await_exit_step(
             "camera_preview_shutdown",
@@ -3501,16 +3512,6 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
                 });
             }
 
-            tokio::spawn({
-                let app = app.clone();
-                async move {
-                    resume_uploads(app)
-                        .await
-                        .map_err(|err| warn!("Error resuming uploads: {err}"))
-                        .ok();
-                }
-            });
-
             {
                 let (server_url, should_update) = if cfg!(debug_assertions)
                     && let Ok(url) = std::env::var("VITE_SERVER_URL")
@@ -3570,12 +3571,30 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
                 app.manage(CameraWindowPositionGuard::default());
                 app.manage(CameraWindowOperationLock::default());
                 app.manage(AppExitState::default());
+                app.manage(MainWindowReadyState::default());
 
                 app.manage(Arc::new(RwLock::new(
                     ClipboardContext::new().expect("Failed to create clipboard context"),
                 )));
             }
 
+            app.listen_any("main-window-ready", {
+                let app = app.clone();
+                move |_| {
+                    app.state::<MainWindowReadyState>().set_ready(true);
+                }
+            });
+
+            tokio::spawn({
+                let app = app.clone();
+                async move {
+                    resume_uploads(app)
+                        .await
+                        .map_err(|err| warn!("Error resuming uploads: {err}"))
+                        .ok();
+                }
+            });
+
             spawn_mic_error_handler(app.clone(), mic_error_rx);
             spawn_device_watchers(app.clone());
             spawn_devices_snapshot_emitter(app.clone());
@@ -3825,6 +3844,7 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
                                     reopen_main_window(app);
                                 }
 
+                                #[cfg(target_os = "macos")]
                                 return;
                             }
                             CapWindowId::Upgrade | CapWindowId::ModeSelect => {
@@ -3840,6 +3860,7 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
                                     }
                                 }
                                 restore_camera_window(app);
+                                #[cfg(target_os = "macos")]
                                 return;
                             }
                             CapWindowId::TargetSelectOverlay { display_id } => {
@@ -3875,18 +3896,8 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
                         };
                     }
 
-                    if let Some(settings) = GeneralSettingsStore::get(app).unwrap_or(None)
-                        && settings.hide_dock_icon
-                        && app.webview_windows().keys().all(|label| {
-                            CapWindowId::from_str(label)
-                                .map(|id| !id.activates_dock())
-                                .unwrap_or(false)
-                        })
-                    {
-                        #[cfg(target_os = "macos")]
-                        app.set_activation_policy(tauri::ActivationPolicy::Accessory)
-                            .ok();
-                    }
+                    #[cfg(target_os = "macos")]
+                    crate::permissions::sync_macos_dock_visibility(app);
                 }
                 #[cfg(target_os = "macos")]
                 WindowEvent::Focused(focused) => {
@@ -3906,8 +3917,7 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
                         && let Ok(window_id) = window_id
                         && window_id.activates_dock()
                     {
-                        app.set_activation_policy(tauri::ActivationPolicy::Regular)
-                            .ok();
+                        crate::permissions::sync_macos_dock_visibility(app);
                     }
                 }
                 WindowEvent::DragDrop(tauri::DragDropEvent::Drop { paths, .. }) => {

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

@@ -100,6 +100,10 @@ fn macos_focus_permission_window(app: &tauri::AppHandle) {
 
 #[cfg(target_os = "macos")]
 fn macos_activate_permission_request(app: &tauri::AppHandle) {
+    if let Err(err) = app.set_dock_visibility(true) {
+        tracing::warn!("Failed to show dock icon for permission request: {err}");
+    }
+
     if let Err(err) = app.set_activation_policy(tauri::ActivationPolicy::Regular) {
         tracing::warn!("Failed to set activation policy to Regular: {err}");
     }
@@ -117,21 +121,21 @@ fn macos_activate_permission_request(app: &tauri::AppHandle) {
 }
 
 #[cfg(target_os = "macos")]
-fn macos_restore_activation_policy(app: &tauri::AppHandle) {
+pub(crate) fn sync_macos_dock_visibility(app: &tauri::AppHandle) {
     let should_hide_dock = GeneralSettingsStore::get(app)
         .ok()
         .flatten()
         .is_some_and(|settings| settings.hide_dock_icon);
 
-    if should_hide_dock
-        && app.webview_windows().keys().all(|label| {
+    let should_show_dock = !should_hide_dock
+        || app.webview_windows().keys().any(|label| {
             CapWindowId::from_str(label)
-                .map(|window_id| !window_id.activates_dock())
+                .map(|window_id| window_id.activates_dock())
                 .unwrap_or(false)
-        })
-        && let Err(err) = app.set_activation_policy(tauri::ActivationPolicy::Accessory)
-    {
-        tracing::warn!("Failed to restore activation policy to Accessory: {err}");
+        });
+
+    if let Err(err) = app.set_dock_visibility(should_show_dock) {
+        tracing::warn!("Failed to update dock visibility: {err}");
     }
 }
 
@@ -262,12 +266,12 @@ fn macos_open_permission_settings(app: &tauri::AppHandle, permission: &OSPermiss
                     _ => {}
                 }
                 crate::tray::refresh_tray_menu_for_app(&app);
-                macos_restore_activation_policy(&app);
+                sync_macos_dock_visibility(&app);
             });
         }
         Err(err) => {
             tracing::error!("Failed to open permission settings: {err}");
-            macos_restore_activation_policy(app);
+            sync_macos_dock_visibility(app);
         }
     }
 }
@@ -312,7 +316,7 @@ pub async fn request_permission(_app: tauri::AppHandle, _permission: OSPermissio
         if macos_permission_needs_settings_fallback(&_permission) && !granted {
             macos_open_permission_settings(&_app, &_permission);
         } else {
-            macos_restore_activation_policy(&_app);
+            sync_macos_dock_visibility(&_app);
         }
     }