Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
#![recursion_limit = "256"]
mod api;
mod audio;
mod audio_library;
mod audio_meter;
mod auth;
mod automation;
mod camera;
mod camera_legacy;
#[cfg(target_os = "macos")]
mod camera_native;
mod captions;
mod clean_capture;
mod cli;
mod clip_thumbnails;
mod crash_sentinel;
mod deeplink_actions;
mod diagnostics;
mod editor_preparing;
mod editor_recording;
mod editor_window;
mod exit_shutdown;
mod export;
mod fake_window;
mod flags;
pub mod frame_ws;
mod general_settings;
mod gpui_app;
mod hotkeys;
mod http_client;
mod import;
pub mod linux_instant_camera;
mod logging;
#[cfg(target_os = "macos")]
mod macos_save_panel;
mod main_window_geometry;
mod notifications;
mod panel_manager;
mod permissions;
#[cfg(debug_assertions)]
mod picker_benchmark;
mod platform;
mod power_observer;
mod preparing_finalization;
mod presets;
mod recording;
mod recording_settings;
mod recording_telemetry;
mod recordings_locations;
mod recovery;
mod render_frame_event;
mod screenshot_editor;
mod startup;
#[cfg(debug_assertions)]
mod stop_editor_benchmark;
mod target_select_overlay;
mod telemetry;
mod thumbnails;
mod tray;
mod update_project_names;
mod updates;
mod upload;
pub mod web_api;
mod window_exclusion;
mod window_position_persistence;
mod windows;
use audio::AppSounds;
use auth::{AuthStore, Plan};
use camera::{CameraPreviewManager, CameraPreviewSender, CameraPreviewState};
use cap_editor::{EditorInstance, EditorState};
use cap_project::{
InstantRecordingMeta, ProjectConfiguration, RecordingMeta, RecordingMetaInner, SharingMeta,
StudioRecordingMeta, StudioRecordingStatus, UploadMeta, VideoUploadInfo, XY, ZoomSegment,
};
use cap_recording::{
RecordingMode,
feeds::{
self,
camera::{CameraFeed, DeviceOrModelID},
microphone::{self, MicrophoneFeed},
},
sources::screen_capture::ScreenCaptureTarget,
};
use cap_rendering::ProjectRecordingsMeta;
use clipboard_rs::Clipboard;
#[cfg(not(target_os = "linux"))]
use clipboard_rs::ClipboardContext;
#[cfg(target_os = "linux")]
use clipboard_rs::ClipboardContext as PlatformClipboardContext;
use clipboard_rs::common::RustImage;
use cpal::StreamError;
use editor_window::{EditorInstances, PendingEditorInstances, WindowEditorInstance};
use ffmpeg::ffi::AV_TIME_BASE;
use general_settings::GeneralSettingsStore;
use kameo::{Actor, actor::ActorRef};
use notifications::NotificationType;
use recording::{InProgressRecording, RecordingEvent, RecordingInputKind};
use scap_targets::{Display, DisplayId, WindowId, bounds::LogicalBounds};
use screenshot_editor::{
PendingScreenshotEditorInstances, ScreenshotEditorInstances, WindowScreenshotEditorInstance,
create_screenshot_editor_instance, prewarm_screenshot_background, recognize_screenshot_text,
render_screenshot_for_export, render_screenshot_png, render_screenshot_project_for_export,
update_screenshot_config,
};
mod gpu_context;
mod gpu_device_health;
pub use gpu_context::{PendingScreenshot, PendingScreenshots};
use serde::{Deserialize, Serialize};
use serde_json::json;
use specta::Type;
use std::{
collections::{BTreeMap, HashSet},
future::Future,
marker::PhantomData,
path::{Path, PathBuf},
process::Command,
str::FromStr,
sync::{
Arc,
atomic::{AtomicBool, AtomicU64, Ordering},
},
time::{Duration, Instant, SystemTime, UNIX_EPOCH},
};
use tauri::Listener;
use tauri::{AppHandle, Emitter, Manager, State, Window, WindowEvent, ipc::Channel};
#[cfg(target_os = "linux")]
use tauri_plugin_clipboard_manager::ClipboardExt;
use tauri_plugin_deep_link::DeepLinkExt;
use tauri_plugin_dialog::DialogExt;
use tauri_plugin_global_shortcut::GlobalShortcutExt;
use tauri_plugin_notification::{NotificationExt, PermissionState};
use tauri_plugin_opener::OpenerExt;
use tauri_plugin_shell::ShellExt;
use tauri_specta::Event;
use tokio::sync::{Mutex, RwLock, oneshot, watch};
use tracing::*;
use upload::{create_or_get_video, upload_screenshot_bytes, upload_screenshot_file, upload_video};
use web_api::AuthedApiError;
use web_api::ManagerExt as WebManagerExt;
#[cfg(target_os = "macos")]
use windows::hide_overlay;
use windows::{
CapWindowId, EditorRecordingTarget, EditorWindowIds, ScreenshotEditorWindowIds, ShowCapWindow,
set_window_transparent, show_overlay,
};
use crate::recording_settings::{RecordingSettingsStore, RecordingTargetMode};
use crate::{recording::start_recording, upload::build_video_meta};
use exit_shutdown::{
AppExitAction, ExitBlocked, ExitRequestDecision, app_exit_action, collect_device_inventory,
handle_exit_requested, prepare_then_begin_exit, recording_start_allowed, run_while_active,
with_idle_recording_state,
};
use futures::FutureExt;
use std::panic::AssertUnwindSafe;
#[cfg(target_os = "macos")]
use tauri::menu::{
AboutMetadata, HELP_SUBMENU_ID, Menu, MenuItem, PredefinedMenuItem, Submenu, WINDOW_SUBMENU_ID,
};
type FinalizationResult = Option<Result<(), String>>;
const MAX_SETTLED_FINALIZATIONS: usize = 32;
#[derive(Default)]
struct FinalizingRecordingsMap {
attempts: std::collections::HashMap<ProjectObjectId, Arc<FinalizationAttempt>>,
settled: std::collections::VecDeque<(ProjectObjectId, String)>,
last_preparing_generation: u64,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum FinalizationOrigin {
Recording,
Recovery,
}
struct FinalizationAttempt {
id: String,
origin: FinalizationOrigin,
project: Arc<FinalizationProject>,
result: watch::Sender<FinalizationResult>,
preparing_generation: Option<u64>,
preparing_presentation:
watch::Sender<Option<Result<Arc<cap_project::ProjectConfiguration>, String>>>,
preparing: watch::Sender<preparing_finalization::PreparingFinalizationState>,
}
pub(crate) struct FinalizationToken {
recordings: Arc<std::sync::Mutex<FinalizingRecordingsMap>>,
attempt: Arc<FinalizationAttempt>,
}
enum FinalizationRequest {
Started(FinalizationToken),
Existing(watch::Receiver<FinalizationResult>),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum ProjectObjectId {
#[cfg(unix)]
Unix { device: u64, inode: u64 },
#[cfg(windows)]
Windows { volume: u64, file: [u8; 16] },
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum FinalizationAccess {
Observe,
Write,
}
pub(crate) struct FinalizationProject {
display_path: PathBuf,
work_path: PathBuf,
identity: ProjectObjectId,
access: FinalizationAccess,
_directory: std::fs::File,
}
fn open_finalization_directory(path: &Path) -> std::io::Result<std::fs::File> {
fn validate(metadata: &std::fs::Metadata) -> std::io::Result<()> {
#[cfg(windows)]
{
use std::os::windows::fs::MetadataExt;
if metadata.file_attributes() & 0x400 != 0 {
return Err(std::io::Error::other(
"Recording directory is a reparse point",
));
}
}
if metadata.file_type().is_symlink() || !metadata.is_dir() {
return Err(std::io::Error::other(
"Recording path is not an ordinary directory",
));
}
Ok(())
}
validate(&path.symlink_metadata()?)?;
let mut options = std::fs::OpenOptions::new();
options.read(true);
#[cfg(unix)]
{
use std::os::unix::fs::OpenOptionsExt;
options.custom_flags(nix::libc::O_DIRECTORY | nix::libc::O_NOFOLLOW | nix::libc::O_CLOEXEC);
}
#[cfg(windows)]
{
use std::os::windows::fs::OpenOptionsExt;
options
.custom_flags(0x0200_0000 | 0x0020_0000)
.share_mode(0x1 | 0x2 | 0x4);
}
let directory = options.open(path)?;
validate(&directory.metadata()?)?;
Ok(directory)
}
fn finalization_directory_identity(directory: &std::fs::File) -> std::io::Result<ProjectObjectId> {
#[cfg(unix)]
{
use std::os::unix::fs::MetadataExt;
let metadata = directory.metadata()?;
Ok(ProjectObjectId::Unix {
device: metadata.dev(),
inode: metadata.ino(),
})
}
#[cfg(windows)]
{
use ::windows::Win32::{
Foundation::HANDLE,
Storage::FileSystem::{FILE_ID_INFO, FileIdInfo, GetFileInformationByHandleEx},
};
use std::os::windows::io::AsRawHandle;
let mut information = FILE_ID_INFO::default();
unsafe {
GetFileInformationByHandleEx(
HANDLE(directory.as_raw_handle()),
FileIdInfo,
(&mut information as *mut FILE_ID_INFO).cast(),
std::mem::size_of::<FILE_ID_INFO>() as u32,
)
}
.map_err(|error| std::io::Error::other(error.to_string()))?;
Ok(ProjectObjectId::Windows {
volume: information.VolumeSerialNumber,
file: information.FileId.Identifier,
})
}
}
impl FinalizationProject {
fn capture(display_path: PathBuf, access: FinalizationAccess) -> Result<Arc<Self>, String> {
let capture = || -> std::io::Result<Self> {
let directory = match access {
FinalizationAccess::Observe => {
open_finalization_directory(&display_path.canonicalize()?)?
}
FinalizationAccess::Write => open_finalization_directory(&display_path)?,
};
let identity = finalization_directory_identity(&directory)?;
let work_path = display_path.canonicalize()?;
let project = Self {
display_path: display_path.clone(),
work_path,
identity,
access,
_directory: directory,
};
project.validate_identity()?;
Ok(project)
};
capture()
.map(Arc::new)
.map_err(|error| Self::identity_error(&display_path, error))
}
pub(crate) async fn admit(display_path: PathBuf) -> Result<Arc<Self>, String> {
Self::capture_async(display_path, FinalizationAccess::Write).await
}
pub(crate) async fn observe(display_path: PathBuf) -> Result<Arc<Self>, String> {
Self::capture_async(display_path, FinalizationAccess::Observe).await
}
async fn capture_async(
display_path: PathBuf,
access: FinalizationAccess,
) -> Result<Arc<Self>, String> {
let error_path = display_path.clone();
tokio::task::spawn_blocking(move || Self::capture(display_path, access))
.await
.map_err(|error| Self::identity_error(&error_path, error))?
}
fn identity_error(path: &Path, error: impl std::fmt::Display) -> String {
recoverable_finalization_error(
path,
format!("Could not verify the recording directory: {error}"),
)
}
fn validate_identity(&self) -> std::io::Result<()> {
let observed_path = match self.access {
FinalizationAccess::Observe => self.display_path.canonicalize()?,
FinalizationAccess::Write => self.display_path.clone(),
};
for path in [&observed_path, &self.work_path] {
let directory = open_finalization_directory(path)?;
if finalization_directory_identity(&directory)? != self.identity {
return Err(std::io::Error::other(format!(
"Recording directory changed at {}",
path.display()
)));
}
}
Ok(())
}
pub(crate) fn validate(&self) -> Result<(), String> {
self.validate_identity()
.map_err(|error| Self::identity_error(&self.display_path, error))
}
pub(crate) async fn validate_async(self: &Arc<Self>) -> Result<(), String> {
let project = self.clone();
tokio::task::spawn_blocking(move || project.validate())
.await
.map_err(|error| Self::identity_error(&self.display_path, error))?
}
pub(crate) fn work_path(&self) -> &Path {
&self.work_path
}
pub(crate) fn display_path(&self) -> &Path {
&self.display_path
}
}
const EDITOR_PREVIEW_FPS: u32 = 60;
const EDITOR_OUTPUT_SIZE: XY<u32> = XY::new(1920, 1080);
const DEFAULT_EDITOR_PREVIEW_SCALE_NUMERATOR: u32 = 65;
const DEFAULT_EDITOR_PREVIEW_SCALE_DENOMINATOR: u32 = 100;
fn default_editor_preview_resolution() -> XY<u32> {
scaled_editor_preview_resolution(
EDITOR_OUTPUT_SIZE,
DEFAULT_EDITOR_PREVIEW_SCALE_NUMERATOR,
DEFAULT_EDITOR_PREVIEW_SCALE_DENOMINATOR,
)
}
fn scaled_editor_preview_resolution(
output_size: XY<u32>,
numerator: u32,
denominator: u32,
) -> XY<u32> {
XY::new(
scaled_editor_preview_dimension(output_size.x, numerator, denominator, 4, 4),
scaled_editor_preview_dimension(output_size.y, numerator, denominator, 2, 2),
)
}
fn scaled_editor_preview_dimension(
value: u32,
numerator: u32,
denominator: u32,
minimum: u32,
alignment: u32,
) -> u32 {
let denominator = denominator.max(1);
let alignment = alignment.max(1);
let scaled = ((u64::from(value) * u64::from(numerator)) + (u64::from(denominator) / 2))
/ u64::from(denominator);
let rounded = u32::try_from(scaled).unwrap_or(u32::MAX).max(minimum);
let aligned = u64::from(rounded).div_ceil(u64::from(alignment)) * u64::from(alignment);
u32::try_from(aligned).unwrap_or(u32::MAX)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn tauri_event_loop_runs_once_on_its_calling_thread() {
let thread = std::thread::current().id();
let calls = std::cell::Cell::new(0);
let result = run_tauri_event_loop(|| {
assert_eq!(std::thread::current().id(), thread);
calls.set(calls.get() + 1);
42
});
assert_eq!(calls.get(), 1);
assert_eq!(result, 42);
}
#[cfg(target_os = "linux")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn linux_tauri_event_loop_allows_blocking_plugin_setup_and_shutdown() {
let thread = std::thread::current().id();
run_tauri_event_loop(|| {
assert_eq!(std::thread::current().id(), thread);
let plugin_runtime = tokio::runtime::Builder::new_multi_thread()
.worker_threads(1)
.enable_all()
.build()
.unwrap();
assert_eq!(plugin_runtime.block_on(async { 1 }), 1);
let callback = tokio::spawn(async { 2 });
assert_eq!(plugin_runtime.block_on(callback).unwrap(), 2);
assert_eq!(plugin_runtime.block_on(async { 3 }), 3);
});
assert_eq!(tokio::spawn(async { 4 }).await.unwrap(), 4);
}
#[test]
fn default_editor_preview_resolution_matches_frontend_defaults() {
assert_eq!(default_editor_preview_resolution(), XY::new(1248, 702));
}
#[test]
fn scaled_editor_preview_resolution_rounds_like_frontend() {
assert_eq!(
scaled_editor_preview_resolution(XY::new(1919, 1079), 65, 100),
XY::new(1248, 702)
);
}
#[cfg(target_os = "linux")]
#[test]
fn wayland_clipboard_fallback_requires_wayland_without_x11() {
use std::ffi::OsStr;
assert!(uses_wayland_clipboard_fallback(
Some(OsStr::new("wayland-1")),
None
));
assert!(!uses_wayland_clipboard_fallback(
Some(OsStr::new("wayland-1")),
Some(OsStr::new(":0"))
));
assert!(!uses_wayland_clipboard_fallback(None, None));
}
#[test]
fn graphics_recovery_only_engages_for_gpu_init_deaths() {
use crash_sentinel::UnexpectedTermination;
// Clean previous exit: never engage.
assert!(!should_engage_graphics_recovery(None));
// Died outside GPU init (force-quit, power loss, OS kill): a healthy GPU
// machine must keep hardware rendering.
assert!(!should_engage_graphics_recovery(Some(
UnexpectedTermination {
during_gpu_init: false,
in_graphics_recovery: false,
blur_active: false,
}
)));
// Died during GPU bring-up on hardware: engage software recovery.
assert!(should_engage_graphics_recovery(Some(
UnexpectedTermination {
during_gpu_init: true,
in_graphics_recovery: false,
blur_active: false,
}
)));
// A recovery-mode session that also died must not chain into recovery
// forever; retry hardware.
assert!(!should_engage_graphics_recovery(Some(
UnexpectedTermination {
during_gpu_init: true,
in_graphics_recovery: true,
blur_active: false,
}
)));
assert!(!should_engage_graphics_recovery(Some(
UnexpectedTermination {
during_gpu_init: false,
in_graphics_recovery: true,
blur_active: false,
}
)));
}
#[test]
fn camera_blur_crash_recovery_disables_and_heals_on_update() {
use crash_sentinel::UnexpectedTermination;
let died_with_blur = Some(UnexpectedTermination {
during_gpu_init: false,
in_graphics_recovery: false,
blur_active: true,
});
let died_without_blur = Some(UnexpectedTermination {
during_gpu_init: false,
in_graphics_recovery: false,
blur_active: false,
});
// Clean exit, blur never disabled: stays enabled.
assert_eq!(next_camera_blur_disabled_version(None, None, "1.0"), None);
// Deaths unrelated to blur must not disable it.
assert_eq!(
next_camera_blur_disabled_version(None, died_without_blur, "1.0"),
None
);
// A death with blur active disables it at the current version.
assert_eq!(
next_camera_blur_disabled_version(None, died_with_blur, "1.0"),
Some("1.0".into())
);
// The disable persists across clean launches of the same version.
assert_eq!(
next_camera_blur_disabled_version(Some("1.0"), None, "1.0"),
Some("1.0".into())
);
// An app update heals: the new stack gets one retry.
assert_eq!(
next_camera_blur_disabled_version(Some("1.0"), None, "1.1"),
None
);
// But a fresh blur-attributed death beats version optimism.
assert_eq!(
next_camera_blur_disabled_version(Some("1.0"), died_with_blur, "1.1"),
Some("1.1".into())
);
}
}
#[derive(Default)]
pub struct FinalizingRecordings {
recordings: Arc<std::sync::Mutex<FinalizingRecordingsMap>>,
}
pub struct CameraWindowCloseGate(AtomicBool);
impl Default for CameraWindowCloseGate {
fn default() -> Self {
Self(AtomicBool::new(false))
}
}
impl CameraWindowCloseGate {
pub fn allow_close(&self) -> bool {
self.0.load(Ordering::Acquire)
}
pub fn set_allow_close(&self, value: bool) {
self.0.store(value, Ordering::Release);
}
}
pub struct AppExitState {
exiting: AtomicBool,
restarting: AtomicBool,
title_flush_pending: AtomicBool,
admission: std::sync::Mutex<()>,
}
impl Default for AppExitState {
fn default() -> Self {
Self {
exiting: AtomicBool::new(false),
restarting: AtomicBool::new(false),
title_flush_pending: AtomicBool::new(false),
admission: std::sync::Mutex::new(()),
}
}
}
impl AppExitState {
fn begin_title_flush(&self) -> Option<PendingTitleExit<'_>> {
self.title_flush_pending
.compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
.ok()
.map(|_| PendingTitleExit(self))
}
fn exit_pending(&self) -> bool {
self.is_exiting() || self.title_flush_pending.load(Ordering::Acquire)
}
pub fn begin(&self) -> bool {
self.exiting
.compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
.is_ok()
}
pub fn begin_restart(&self) {
self.restarting.store(true, Ordering::Release);
self.exiting.store(true, Ordering::Release);
}
pub fn is_exiting(&self) -> bool {
self.exiting.load(Ordering::Acquire)
}
pub fn is_restarting(&self) -> bool {
self.restarting.load(Ordering::Acquire)
}
}
struct PendingTitleExit<'a>(&'a AppExitState);
impl Drop for PendingTitleExit<'_> {
fn drop(&mut self) {
self.0.title_flush_pending.store(false, Ordering::Release);
}
}
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);
const APP_EXIT_FORCE_TIMEOUT: Duration = Duration::from_secs(8);
#[cfg(target_os = "macos")]
const APP_MENU_QUIT_ID: &str = "app_quit";
#[cfg(target_os = "macos")]
static MACOS_NATIVE_TERMINATE_APP: std::sync::OnceLock<AppHandle> = std::sync::OnceLock::new();
async fn await_exit_step<T, E, F>(name: &'static str, timeout: Duration, fut: F) -> Option<T>
where
E: std::fmt::Display,
F: Future<Output = Result<T, E>>,
{
let started = Instant::now();
match tokio::time::timeout(timeout, fut).await {
Ok(Ok(value)) => {
info!(
step = name,
elapsed_ms = started.elapsed().as_millis(),
"Exit cleanup step completed"
);
Some(value)
}
Ok(Err(err)) => {
warn!(
step = name,
elapsed_ms = started.elapsed().as_millis(),
error = %err,
"Exit cleanup step failed"
);
None
}
Err(_) => {
warn!(
step = name,
timeout_ms = timeout.as_millis(),
elapsed_ms = started.elapsed().as_millis(),
"Exit cleanup step timed out"
);
None
}
}
}
fn log_process_memory_snapshot(stage: &'static str) {
let Ok(pid) = sysinfo::get_current_pid() else {
return;
};
let mut system = sysinfo::System::new();
system.refresh_processes(sysinfo::ProcessesToUpdate::Some(&[pid]), true);
if let Some(process) = system.process(pid) {
info!(
stage = stage,
rss_mb = process.memory() / 1_048_576,
virtual_mb = process.virtual_memory() / 1_048_576,
"Process memory snapshot"
);
}
}
fn spawn_process_memory_sampler(app: AppHandle) {
tokio::spawn(async move {
let mut interval = tokio::time::interval(Duration::from_secs(60));
loop {
interval.tick().await;
if app_is_exiting(&app) {
break;
}
log_process_memory_snapshot("periodic");
}
});
}
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"
);
force_exit(0);
});
}
pub(crate) fn app_is_exiting(app: &AppHandle) -> bool {
match app.try_state::<AppExitState>() {
Some(state) => state.is_exiting(),
None => false,
}
}
fn should_show_onboarding(app: &AppHandle) -> bool {
let settings = GeneralSettingsStore::get(app).ok().flatten();
let startup_completed = settings
.as_ref()
.map(|s| s.has_completed_startup)
.unwrap_or(false);
let onboarding_completed = settings
.as_ref()
.map(|s| s.has_completed_onboarding)
.unwrap_or(false);
!startup_completed
|| !onboarding_completed
|| !permissions::do_permissions_check(false).necessary_granted()
}
#[cfg(target_os = "macos")]
fn build_macos_app_menu(app_handle: &AppHandle) -> tauri::Result<Menu<tauri::Wry>> {
let pkg_info = app_handle.package_info();
let config = app_handle.config();
let about_metadata = AboutMetadata {
name: Some(pkg_info.name.clone()),
version: Some(pkg_info.version.to_string()),
copyright: config.bundle.copyright.clone(),
authors: config
.bundle
.publisher
.clone()
.map(|publisher| vec![publisher]),
..Default::default()
};
let quit_label = config
.product_name
.as_ref()
.map(|name| format!("Quit {name}"))
.unwrap_or_else(|| "Quit Cap".to_string());
let window_menu = Submenu::with_id_and_items(
app_handle,
WINDOW_SUBMENU_ID,
"Window",
true,
&[
&PredefinedMenuItem::minimize(app_handle, None)?,
&PredefinedMenuItem::maximize(app_handle, None)?,
&PredefinedMenuItem::separator(app_handle)?,
&PredefinedMenuItem::close_window(app_handle, None)?,
],
)?;
let help_menu = Submenu::with_id_and_items(app_handle, HELP_SUBMENU_ID, "Help", true, &[])?;
Menu::with_items(
app_handle,
&[
&Submenu::with_items(
app_handle,
pkg_info.name.clone(),
true,
&[
&PredefinedMenuItem::about(app_handle, None, Some(about_metadata))?,
&PredefinedMenuItem::separator(app_handle)?,
&PredefinedMenuItem::services(app_handle, None)?,
&PredefinedMenuItem::separator(app_handle)?,
&PredefinedMenuItem::hide(app_handle, None)?,
&PredefinedMenuItem::hide_others(app_handle, None)?,
&PredefinedMenuItem::separator(app_handle)?,
&MenuItem::with_id(
app_handle,
APP_MENU_QUIT_ID,
quit_label,
true,
Some("Cmd+Q"),
)?,
],
)?,
&Submenu::with_items(
app_handle,
"File",
true,
&[&PredefinedMenuItem::close_window(app_handle, None)?],
)?,
&Submenu::with_items(
app_handle,
"Edit",
true,
&[
&PredefinedMenuItem::undo(app_handle, None)?,
&PredefinedMenuItem::redo(app_handle, None)?,
&PredefinedMenuItem::separator(app_handle)?,
&PredefinedMenuItem::cut(app_handle, None)?,
&PredefinedMenuItem::copy(app_handle, None)?,
&PredefinedMenuItem::paste(app_handle, None)?,
&PredefinedMenuItem::select_all(app_handle, None)?,
],
)?,
&Submenu::with_items(
app_handle,
"View",
true,
&[&PredefinedMenuItem::fullscreen(app_handle, None)?],
)?,
&window_menu,
&help_menu,
],
)
}
#[cfg(target_os = "macos")]
unsafe extern "C" fn macos_application_should_terminate(
_: &objc::runtime::Object,
_: objc::runtime::Sel,
_: cocoa::base::id,
) -> isize {
if let Some(app) = MACOS_NATIVE_TERMINATE_APP.get() {
let app = app.clone();
tokio::spawn(async move {
request_app_exit(app).await;
});
} else {
warn!("macOS native termination requested before app exit handler was installed");
}
0
}
#[cfg(target_os = "macos")]
fn install_macos_native_terminate_handler(app: &AppHandle) {
use cocoa::base::{id, nil};
use objc::{class, msg_send, sel, sel_impl};
let _ = MACOS_NATIVE_TERMINATE_APP.set(app.clone());
unsafe {
let ns_app: id = msg_send![class!(NSApplication), sharedApplication];
let delegate: id = msg_send![ns_app, delegate];
if delegate == nil {
warn!("Unable to install macOS native termination handler without app delegate");
return;
}
let delegate_class = (*delegate).class() as *const _ as *mut objc::runtime::Class;
let imp = std::mem::transmute::<
unsafe extern "C" fn(&objc::runtime::Object, objc::runtime::Sel, id) -> isize,
objc::runtime::Imp,
>(macos_application_should_terminate);
let added = objc::runtime::class_addMethod(
delegate_class,
sel!(applicationShouldTerminate:),
imp,
c"q@:@".as_ptr(),
);
if added == objc::runtime::YES {
info!("Installed macOS native termination handler");
} else {
warn!("macOS native termination handler was already installed");
}
}
}
fn now_millis() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_millis() as u64)
.unwrap_or(0)
}
#[derive(Debug)]
pub struct CameraWindowPositionGuard {
ignore_until_ms: AtomicU64,
}
impl Default for CameraWindowPositionGuard {
fn default() -> Self {
Self {
ignore_until_ms: AtomicU64::new(0),
}
}
}
impl CameraWindowPositionGuard {
pub fn ignore_for(&self, duration_ms: u64) {
let now = now_millis();
let until = now.saturating_add(duration_ms);
self.ignore_until_ms.store(until, Ordering::Release);
}
pub fn should_ignore(&self) -> bool {
let now = now_millis();
now < self.ignore_until_ms.load(Ordering::Acquire)
}
}
pub type CameraWindowOperationLock = Mutex<()>;
impl FinalizingRecordings {
fn request(
&self,
project: Arc<FinalizationProject>,
retry_failed: bool,
origin: FinalizationOrigin,
preparing_requested: bool,
) -> Result<FinalizationRequest, String> {
if project.access != FinalizationAccess::Write {
return Err("Recording directory was not admitted for recovery.".into());
}
let mut recordings = self
.recordings
.lock()
.expect("FinalizingRecordings mutex poisoned");
if let Some(attempt) = recordings.attempts.get(&project.identity)
&& attempt
.result
.borrow()
.as_ref()
.is_none_or(|result| !retry_failed && result.is_err())
{
return Ok(FinalizationRequest::Existing(attempt.result.subscribe()));
}
let preparing_generation = if preparing_requested
&& origin == FinalizationOrigin::Recording
&& let Some(generation) = recordings.last_preparing_generation.checked_add(1)
{
recordings.last_preparing_generation = generation;
Some(generation)
} else {
None
};
let attempt = Arc::new(FinalizationAttempt {
id: uuid::Uuid::new_v4().to_string(),
origin,
project,
result: watch::channel(None).0,
preparing_generation,
preparing_presentation: watch::channel(None).0,
preparing: watch::channel(Default::default()).0,
});
recordings
.settled
.retain(|(identity, _)| *identity != attempt.project.identity);
let _ = recordings
.attempts
.insert(attempt.project.identity, attempt.clone());
Ok(FinalizationRequest::Started(FinalizationToken {
recordings: self.recordings.clone(),
attempt,
}))
}
fn start_with_origin(
&self,
project: Arc<FinalizationProject>,
origin: FinalizationOrigin,
preparing_requested: bool,
) -> Result<FinalizationToken, String> {
match self.request(project, true, origin, preparing_requested)? {
FinalizationRequest::Started(token) => Ok(token),
FinalizationRequest::Existing(_) => Err(
"This recording is already being prepared. Please wait for it to finish.".into(),
),
}
}
pub(crate) fn start_finalizing(
&self,
project: Arc<FinalizationProject>,
) -> Result<FinalizationToken, String> {
self.start_with_origin(project, FinalizationOrigin::Recording, true)
}
pub(crate) fn start_recovering(
&self,
project: Arc<FinalizationProject>,
) -> Result<FinalizationToken, String> {
self.start_with_origin(project, FinalizationOrigin::Recovery, false)
}
pub(crate) async fn recovery_success(&self, path: &Path) -> Result<Option<String>, String> {
let project = FinalizationProject::observe(path.to_path_buf()).await?;
self.recovery_success_for_project(&project).await
}
pub(crate) async fn recovery_success_for_project(
&self,
project: &Arc<FinalizationProject>,
) -> Result<Option<String>, String> {
project.validate_async().await?;
let attempt = {
let recordings = self.recordings.lock().unwrap();
let Some(attempt) = recordings.attempts.get(&project.identity) else {
return Ok(None);
};
if attempt.origin != FinalizationOrigin::Recovery {
return Ok(None);
}
attempt.clone()
};
if await_finalization_result(attempt.result.subscribe())
.await
.is_err()
{
return Ok(None);
}
project.validate_async().await?;
let recordings = self.recordings.lock().unwrap();
Ok(recordings
.attempts
.get(&project.identity)
.filter(|current| Arc::ptr_eq(current, &attempt))
.map(|_| attempt.id.clone()))
}
fn is_finalizing(
&self,
project: &FinalizationProject,
) -> Option<watch::Receiver<FinalizationResult>> {
let recordings = self.recordings.lock().unwrap();
recordings
.attempts
.get(&project.identity)
.filter(|attempt| !matches!(attempt.result.borrow().as_ref(), Some(Ok(()))))
.map(|attempt| attempt.result.subscribe())
}
}
fn recoverable_finalization_error(path: &Path, error: String) -> String {
if error.starts_with("Not enough space to finish this recording.")
|| error
.to_ascii_lowercase()
.contains("may need to be recovered")
{
return error;
}
format!(
"This recording may need to be recovered. {error} Your recording files have been kept at {}. Try recovery again.",
path.display()
)
}
fn has_pending_finalizations(recordings: &FinalizingRecordingsMap) -> bool {
recordings
.attempts
.values()
.any(|attempt| attempt.result.borrow().is_none())
}
impl FinalizationToken {
fn publish(&self, result: Result<(), String>) -> bool {
let mut recordings = self.recordings.lock().unwrap();
if recordings
.attempts
.get(&self.attempt.project.identity)
.is_none_or(|current| !Arc::ptr_eq(current, &self.attempt))
{
return false;
}
let result = result.map_err(|error| {
recoverable_finalization_error(self.attempt.project.display_path(), error)
});
let succeeded = result.is_ok();
let published = self.attempt.result.send_if_modified(|current| {
if current.is_some() {
return false;
}
*current = Some(result);
true
});
if published {
if succeeded && self.attempt.origin == FinalizationOrigin::Recording {
let _ = recordings.attempts.remove(&self.attempt.project.identity);
} else {
recordings
.settled
.push_back((self.attempt.project.identity, self.attempt.id.clone()));
while recordings.settled.len() > MAX_SETTLED_FINALIZATIONS {
if let Some((identity, id)) = recordings.settled.pop_front()
&& recordings.attempts.get(&identity).is_some_and(|attempt| {
attempt.id == id && attempt.result.borrow().is_some()
})
{
let _ = recordings.attempts.remove(&identity);
}
}
}
}
published
}
pub(crate) fn finish(self, result: Result<(), String>) {
self.publish(result);
}
}
impl Drop for FinalizationToken {
fn drop(&mut self) {
self.publish(Err("Preparing this recording was interrupted.".into()));
}
}
async fn await_finalization_result(
mut result: watch::Receiver<FinalizationResult>,
) -> Result<(), String> {
loop {
if let Some(result) = result.borrow_and_update().clone() {
return result;
}
result
.changed()
.await
.map_err(|_| "Recording finalization ended without a result.".to_string())?;
}
}
pub(crate) async fn run_finalization_worker<T: Send + 'static>(
token: FinalizationToken,
work: impl FnOnce(&FinalizationProject) -> Result<T, String> + Send + 'static,
) -> Result<T, String> {
let path = token.attempt.project.display_path().to_path_buf();
tokio::task::spawn_blocking(move || {
let project = &token.attempt.project;
let result = project
.validate()
.and_then(|()| work(project))
.and_then(|value| project.validate().map(|()| value))
.map_err(|error| recoverable_finalization_error(project.display_path(), error));
token.finish(result.as_ref().map(|_| ()).map_err(Clone::clone));
result
})
.await
.map_err(|error| {
recoverable_finalization_error(
&path,
format!("Recording finalization task failed: {error}"),
)
})?
}
#[allow(clippy::large_enum_variant)]
pub enum RecordingState {
None,
Pending {
mode: RecordingMode,
target: ScreenCaptureTarget,
},
Active(InProgressRecording),
}
#[derive(Clone)]
pub(crate) struct RequestedInput<T> {
value: Option<T>,
revision: u64,
pending: bool,
error: Option<String>,
configuration: Option<serde_json::Value>,
}
impl<T: Clone> RequestedInput<T> {
fn new(value: Option<T>) -> Self {
Self {
value,
revision: 0,
pending: false,
error: None,
configuration: None,
}
}
fn begin(&mut self, value: Option<T>) -> u64 {
self.value = value;
self.revision = self.revision.wrapping_add(1);
self.pending = true;
self.error = None;
self.configuration = None;
self.revision
}
fn begin_or_join(
&mut self,
value: Option<T>,
configuration: serde_json::Value,
recording_starting: bool,
) -> (u64, bool)
where
T: PartialEq,
{
if (self.pending || (recording_starting && self.error.is_none()))
&& self.value == value
&& self.configuration.as_ref() == Some(&configuration)
{
return (self.revision, true);
}
let revision = self.begin(value);
self.configuration = Some(configuration);
(revision, false)
}
fn finish(&mut self, revision: u64, result: &Result<(), String>) {
if self.revision == revision {
self.pending = false;
self.error = result.as_ref().err().cloned();
}
}
fn prepare_restore(&mut self, revision: u64) -> bool {
if self.revision != revision || self.pending {
return false;
}
self.pending = true;
self.error = None;
true
}
fn validate(&self, kind: &str) -> Result<(), String> {
if self.pending {
return Err(format!(
"The requested {kind} is still being configured. Wait before recording."
));
}
if let Some(error) = &self.error {
return Err(format!(
"The requested {kind} could not be configured: {error}. Select it again or choose another input before recording."
));
}
Ok(())
}
}
async fn wait_for_existing_input<T: Clone>(
revision: u64,
kind: &str,
read: impl Fn() -> RequestedInput<T>,
) -> Result<(), String> {
tokio::time::timeout(Duration::from_secs(30), async {
loop {
let input = read();
if input.revision != revision {
return Err(format!(
"{kind} selection was superseded by a newer request"
));
}
if !input.pending {
return input.error.map_or(Ok(()), Err);
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.map_err(|_| format!("Timed out waiting for the selected {kind}"))?
}
#[derive(Clone)]
pub(crate) struct RequestedInputs {
microphone: RequestedInput<String>,
camera: RequestedInput<DeviceOrModelID>,
}
pub(crate) struct RequestedInputsState {
inner: Arc<std::sync::Mutex<RequestedInputs>>,
operation: Mutex<()>,
}
impl RequestedInputsState {
fn new(microphone: Option<String>, camera: Option<DeviceOrModelID>) -> Self {
Self {
inner: Arc::new(std::sync::Mutex::new(RequestedInputs {
microphone: RequestedInput::new(microphone),
camera: RequestedInput::new(camera),
})),
operation: Mutex::new(()),
}
}
pub(crate) fn snapshot(&self) -> RequestedInputs {
self.inner.lock().unwrap().clone()
}
pub(crate) fn ready_snapshot(&self) -> Result<RequestedInputs, String> {
let snapshot = self.snapshot();
snapshot.microphone.validate("microphone")?;
snapshot.camera.validate("camera")?;
Ok(snapshot)
}
pub(crate) fn ensure_ready_for_resume(&self) -> Result<(), String> {
self.ready_snapshot().map(|_| ()).map_err(|error| {
format!("Cannot resume recording: {error} Finish configuring or reselect the requested inputs before resuming.")
})
}
pub(crate) fn try_resume_guard(&self) -> Result<tokio::sync::MutexGuard<'_, ()>, String> {
let guard = self.operation.try_lock().map_err(|_| {
"Input change in progress. Finish configuring or reselect the requested inputs before resuming.".to_string()
})?;
self.ensure_ready_for_resume()?;
Ok(guard)
}
pub(crate) fn is_current(&self, snapshot: &RequestedInputs) -> bool {
let current = self.inner.lock().unwrap();
current.microphone.revision == snapshot.microphone.revision
&& current.camera.revision == snapshot.camera.revision
}
fn mic_is_current(&self, revision: u64) -> bool {
self.inner.lock().unwrap().microphone.revision == revision
}
fn camera_is_current(&self, revision: u64) -> bool {
self.inner.lock().unwrap().camera.revision == revision
}
fn publish_mic_if_current(&self, revision: u64, publish: impl FnOnce()) -> bool {
let current = self.inner.lock().unwrap();
if current.microphone.revision != revision {
return false;
}
publish();
true
}
pub(crate) fn publish_camera_if_current(&self, revision: u64, publish: impl FnOnce()) -> bool {
let current = self.inner.lock().unwrap();
if current.camera.revision != revision {
return false;
}
publish();
true
}
pub(crate) fn publish_if_current(
&self,
snapshot: &RequestedInputs,
publish: impl FnOnce(),
) -> bool {
let current = self.inner.lock().unwrap();
if current.microphone.revision != snapshot.microphone.revision
|| current.camera.revision != snapshot.camera.revision
{
return false;
}
publish();
true
}
}
#[derive(Default)]
struct AppliedMicrophoneInput {
valid: bool,
generation: u64,
settings: Option<microphone::MicrophoneDeviceSettings>,
}
impl AppliedMicrophoneInput {
fn prepare_change(
&mut self,
active: bool,
requested: Option<&str>,
selected: Option<&str>,
) -> bool {
if active && self.valid && requested.is_some() && requested == selected {
return false;
}
self.invalidate();
true
}
fn invalidate(&mut self) {
self.valid = false;
self.generation = self.generation.wrapping_add(1);
}
fn confirm_if_current(&mut self, generation: u64) -> bool {
if self.generation != generation {
return false;
}
self.confirm();
true
}
fn confirm(&mut self) {
self.valid = true;
}
}
pub struct App {
#[deprecated = "can be removed when native camera preview is ready"]
camera_ws_port: u16,
#[deprecated = "can be removed when native camera preview is ready"]
camera_ws_sender: flume::Sender<cap_recording::FFmpegVideoFrame>,
#[cfg(target_os = "linux")]
pub camera_processing: linux_instant_camera::ProcessingFactory,
camera_preview: CameraPreviewManager,
camera_preview_state_tx: tokio::sync::watch::Sender<CameraPreviewState>,
handle: AppHandle,
recording_state: RecordingState,
recording_logging_handle: LoggingHandle,
mic_feed: ActorRef<feeds::microphone::MicrophoneFeed>,
mic_meter_sender: flume::Sender<microphone::MicrophoneSamples>,
selected_mic_label: Option<String>,
applied_mic_input: AppliedMicrophoneInput,
selected_camera_id: Option<DeviceOrModelID>,
camera_in_use: bool,
camera_cleanup_done: bool,
camera_feed: ActorRef<feeds::camera::CameraFeed>,
server_url: String,
logs_dir: Option<PathBuf>,
disconnected_inputs: HashSet<RecordingInputKind>,
was_camera_only_recording: bool,
}
#[derive(specta::Type, Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub enum VideoType {
Screen,
Output,
Camera,
}
#[derive(Serialize, Deserialize, specta::Type, Debug)]
pub enum UploadResult {
Success(String),
NotAuthenticated,
PlanCheckFailed,
UpgradeRequired,
}
#[derive(Serialize, Deserialize, specta::Type, Debug)]
pub struct VideoRecordingMetadata {
pub duration: f64,
pub size: f64,
}
const CAMERA_PREVIEW_ERROR_EVENT: &str = "camera-preview-error";
const CAMERA_PREVIEW_CLEAR_EVENT: &str = "camera-preview-clear";
#[derive(Clone, Serialize)]
#[serde(rename_all = "camelCase")]
struct CameraPreviewErrorPayload {
title: String,
message: String,
}
fn camera_preview_error_message(err: &str) -> String {
if err.contains("DeviceNotFound") {
return "This camera is no longer available. Check that it is connected and allowed by system permissions.".to_string();
}
if err.contains("CameraTimeout") {
return "No frames were received from this camera. It may be closed, disconnected, covered, or in use by another app.".to_string();
}
if err.contains("StartCapturing") {
return "The system could not start this camera. It may be unavailable or in use by another app.".to_string();
}
if err.contains("InvalidFormat") {
return "This camera did not report a usable capture format.".to_string();
}
"The selected camera could not be started. Choose another camera or reconnect this one."
.to_string()
}
fn emit_camera_preview_error(app_handle: &AppHandle, message: String) {
let _ = app_handle.emit(
CAMERA_PREVIEW_ERROR_EVENT,
CameraPreviewErrorPayload {
title: "Camera unavailable".to_string(),
message,
},
);
}
fn emit_camera_preview_clear(app_handle: &AppHandle) {
let _ = app_handle.emit(CAMERA_PREVIEW_CLEAR_EVENT, ());
}
async fn add_camera_preview_ws_sender(
camera_feed: &ActorRef<CameraFeed>,
sender: flume::Sender<cap_recording::FFmpegVideoFrame>,
) {
add_camera_preview_sender(camera_feed, sender, "WebSocket").await;
}
async fn add_camera_preview_sender(
camera_feed: &ActorRef<CameraFeed>,
sender: flume::Sender<cap_recording::FFmpegVideoFrame>,
label: &str,
) {
let result = camera_feed.ask(feeds::camera::AddSender(sender)).await;
if let Err(err) = result {
warn!(error = %err, "Failed to add {label} camera sender");
}
}
async fn remove_camera_preview_sender(
camera_feed: &ActorRef<CameraFeed>,
sender: flume::Sender<cap_recording::FFmpegVideoFrame>,
label: &str,
) {
let result = camera_feed.ask(feeds::camera::RemoveSender(sender)).await;
if let Err(err) = result {
warn!(error = %err, "Failed to remove {label} camera sender");
}
}
async fn sync_camera_preview_sender(
camera_feed: &ActorRef<CameraFeed>,
camera_ws_sender: flume::Sender<cap_recording::FFmpegVideoFrame>,
camera_preview_sender: Option<CameraPreviewSender>,
use_ws_preview: bool,
) {
if use_ws_preview {
if let Some(sender) = camera_preview_sender
&& let Err(err) = sender.detach(camera_feed).await
{
warn!(error = %err, "Failed to remove native preview camera sender");
}
add_camera_preview_ws_sender(camera_feed, camera_ws_sender).await;
} else if let Some(sender) = camera_preview_sender {
if let Err(err) = sender.attach(camera_feed).await {
warn!(error = %err, "Failed to add native preview camera sender");
}
remove_camera_preview_sender(camera_feed, camera_ws_sender, "WebSocket").await;
} else {
add_camera_preview_ws_sender(camera_feed, camera_ws_sender).await;
}
}
impl App {
pub fn set_pending_recording(
&mut self,
mode: RecordingMode,
target: ScreenCaptureTarget,
) -> Result<(), String> {
recording_start_allowed(
self.handle
.try_state::<AppExitState>()
.is_some_and(|state| state.exit_pending()),
updates::recording_start_blocked(&self.handle),
)?;
#[cfg(target_os = "linux")]
if mode != RecordingMode::Instant
&& recording::linux_instant::current(&self.handle).is_some()
{
return Err("Finish the pending Instant cleanup before recording".into());
}
if !matches!(self.recording_state, RecordingState::None) {
return Err("Recording already in progress".to_string());
}
self.recording_state = RecordingState::Pending { mode, target };
CurrentRecordingChanged.emit(&self.handle).ok();
Ok(())
}
pub fn set_current_recording(&mut self, actor: InProgressRecording) {
self.recording_state = RecordingState::Active(actor);
CurrentRecordingChanged.emit(&self.handle).ok();
}
pub fn clear_pending_recording(&mut self) -> bool {
#[cfg(target_os = "linux")]
if recording::linux_instant::blocks_cleanup(&self.handle) {
return false;
}
if !matches!(self.recording_state, RecordingState::Pending { .. }) {
return false;
}
self.recording_state = RecordingState::None;
self.was_camera_only_recording = false;
self.close_occluder_windows();
crate::windows::apply_content_protection(&self.handle, false);
if let Some(camera) = CapWindowId::Camera.get(&self.handle) {
let _ = camera.set_content_protected(false);
}
CurrentRecordingChanged.emit(&self.handle).ok();
true
}
pub fn clear_current_recording(&mut self) -> Option<InProgressRecording> {
#[cfg(target_os = "linux")]
if recording::linux_instant::blocks_cleanup(&self.handle) {
return None;
}
let previous = std::mem::replace(&mut self.recording_state, RecordingState::None);
match previous {
RecordingState::Active(recording) => {
self.close_occluder_windows();
crate::windows::apply_content_protection(&self.handle, false);
Some(recording)
}
state => {
self.recording_state = state;
None
}
}
}
pub fn clear_recording_state(&mut self) -> Option<InProgressRecording> {
#[cfg(target_os = "linux")]
if recording::linux_instant::blocks_cleanup(&self.handle) {
return None;
}
let previous = std::mem::replace(&mut self.recording_state, RecordingState::None);
self.close_occluder_windows();
crate::windows::apply_content_protection(&self.handle, false);
match previous {
RecordingState::Active(recording) => Some(recording),
_ => None,
}
}
fn close_occluder_windows(&self) {
for window in self.handle.webview_windows() {
if window.0.starts_with("window-capture-occluder-") {
let _ = window.1.close();
}
}
}
fn microphone_settings_for_label(
&self,
label: &str,
) -> Option<microphone::MicrophoneDeviceSettings> {
recording_settings::RecordingSettingsStore::microphone_settings_for(&self.handle, label)
}
fn camera_settings_for_id(
&self,
id: &DeviceOrModelID,
) -> Option<feeds::camera::CameraDeviceSettings> {
recording_settings::RecordingSettingsStore::camera_settings_for(&self.handle, id)
}
async fn restart_mic_feed(&mut self) -> Result<(), String> {
self.applied_mic_input.invalidate();
info!("Restarting microphone feed after actor shutdown");
let (error_tx, error_rx) = flume::bounded(1);
let mic_feed = MicrophoneFeed::spawn(MicrophoneFeed::new(error_tx));
spawn_mic_error_handler(self.handle.clone(), error_rx);
mic_feed
.ask(microphone::AddSender(self.mic_meter_sender.clone()))
.await
.map_err(|e| e.to_string())?;
if let Some(label) = self.selected_mic_label.clone()
&& permissions::check_microphone_access().is_ok()
{
let settings = self.microphone_settings_for_label(&label);
match mic_feed.ask(microphone::SetInput { label, settings }).await {
Ok(ready) => {
if let Err(err) = ready.await {
if matches!(err, microphone::SetInputError::DeviceNotFound) {
warn!("Selected microphone not available while restarting feed");
} else {
return Err(err.to_string());
}
}
}
Err(kameo::error::SendError::HandlerError(
microphone::SetInputError::DeviceNotFound,
)) => {
warn!("Selected microphone not available while restarting feed");
}
Err(err) => return Err(err.to_string()),
}
}
self.mic_feed = mic_feed;
Ok(())
}
async fn ensure_mic_feed_alive(&mut self) -> Result<(), String> {
if self.mic_feed.is_alive() {
return Ok(());
}
self.restart_mic_feed().await
}
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(())
}
pub fn current_recording(&self) -> Option<&InProgressRecording> {
match &self.recording_state {
RecordingState::Active(recording) => Some(recording),
_ => None,
}
}
pub fn current_recording_mut(&mut self) -> Option<&mut InProgressRecording> {
match &mut self.recording_state {
RecordingState::Active(recording) => Some(recording),
_ => None,
}
}
pub fn is_recording_active_or_pending(&self) -> bool {
!matches!(self.recording_state, RecordingState::None)
|| clean_capture::blocks_idle_cleanup(&self.handle)
}
async fn handle_input_disconnect(&mut self, kind: RecordingInputKind) -> Result<(), String> {
if matches!(kind, RecordingInputKind::Microphone) {
self.applied_mic_input.invalidate();
}
if !self.disconnected_inputs.insert(kind) {
return Ok(());
}
let (title, body) = match kind {
RecordingInputKind::Microphone => (
"Microphone disconnected",
"Recording continues. Silence will be used until the microphone reconnects.",
),
RecordingInputKind::Camera => (
"Camera disconnected",
"Recording continues without camera. Camera overlay will resume when the device reconnects.",
),
};
let _ = NewNotification {
title: title.to_string(),
body: body.to_string(),
is_error: false,
}
.emit(&self.handle);
let _ = RecordingEvent::InputLost { input: kind }.emit(&self.handle);
Ok(())
}
async fn handle_input_restored(&mut self, kind: RecordingInputKind) -> Result<(), String> {
let app_handle = self.handle.clone();
let requested = app_handle.state::<RequestedInputsState>();
let camera_snapshot = requested.snapshot().camera;
if matches!(kind, RecordingInputKind::Camera)
&& (self.selected_camera_id.is_none()
|| camera_snapshot.pending
|| camera_snapshot.value != self.selected_camera_id)
{
return Ok(());
}
let camera_revision = camera_snapshot.revision;
let pending = match kind {
RecordingInputKind::Microphone => self.disconnected_inputs.remove(&kind),
RecordingInputKind::Camera => self.disconnected_inputs.contains(&kind),
};
if !pending {
return Ok(());
}
match kind {
RecordingInputKind::Microphone => {
if let Err(error) = self.ensure_selected_mic_ready().await {
warn!(%error, "Failed to restore microphone; will retry when access and the device are available");
self.disconnected_inputs
.insert(RecordingInputKind::Microphone);
return Ok(());
}
}
RecordingInputKind::Camera => match self.ensure_selected_camera_ready().await {
Ok(()) => {
if !requested.publish_camera_if_current(camera_revision, || {
self.disconnected_inputs.remove(&RecordingInputKind::Camera);
info!("Camera reconnected and reinitialized successfully");
let _ = NewNotification {
title: "Camera reconnected".to_string(),
body: "Camera overlay has been restored.".to_string(),
is_error: false,
}
.emit(&self.handle);
}) {
return Ok(());
}
}
Err(e) => {
warn!(error = %e, "Failed to reinitialize camera after reconnect, will retry on next poll");
return Ok(());
}
},
}
if matches!(kind, RecordingInputKind::Camera) {
requested.publish_camera_if_current(camera_revision, || {
let _ = RecordingEvent::InputRestored { input: kind }.emit(&self.handle);
});
} else {
let _ = RecordingEvent::InputRestored { input: kind }.emit(&self.handle);
}
Ok(())
}
async fn ensure_selected_mic_ready(&mut self) -> Result<(), String> {
check_requested_microphone_permission(
self.selected_mic_label.as_deref(),
permissions::check_microphone_access,
)?;
self.applied_mic_input.invalidate();
self.ensure_mic_feed_alive().await?;
if let Some(label) = self.selected_mic_label.clone() {
let settings = self.microphone_settings_for_label(&label);
let ready = self
.mic_feed
.ask(feeds::microphone::SetInput { label, settings })
.await
.map_err(|e| e.to_string())?;
ready.await.map_err(|e| e.to_string())?;
}
Ok(())
}
async fn ensure_selected_camera_ready(&mut self) -> Result<(), String> {
let app_handle = self.handle.clone();
let requested = app_handle.state::<RequestedInputsState>();
let snapshot = requested.snapshot();
if snapshot.camera.pending || snapshot.camera.value != self.selected_camera_id {
return Err("Camera selection was superseded by a newer request".into());
}
check_requested_camera_permission(
self.selected_camera_id.as_ref(),
permissions::check_camera_access,
)?;
if let Some(id) = self.selected_camera_id.clone() {
let settings = self.camera_settings_for_id(&id);
let ready = self
.camera_feed
.ask(feeds::camera::SetInput {
id: id.clone(),
settings,
})
.await
.map_err(|e| e.to_string())?;
await_current_camera_request(async { ready.await.map_err(|e| e.to_string()) }, || {
requested.camera_is_current(snapshot.camera.revision)
})
.await??;
}
Ok(())
}
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app_handle, state))]
async fn set_mic_input(
app_handle: AppHandle,
state: MutableState<'_, App>,
label: Option<String>,
) -> Result<(), String> {
let requested = app_handle.state::<RequestedInputsState>();
let settings = label.as_ref().and_then(|label| {
recording_settings::RecordingSettingsStore::microphone_settings_for(&app_handle, label)
});
let (revision, joined) = {
let state = state.read().await;
requested.inner.lock().unwrap().microphone.begin_or_join(
label.clone(),
serde_json::json!(settings),
matches!(state.recording_state, RecordingState::Pending { .. }),
)
};
if joined {
return wait_for_existing_input(revision, "Microphone", || {
requested.inner.lock().unwrap().microphone.clone()
})
.await;
}
let result = async {
check_requested_microphone_permission(
label.as_deref(),
permissions::check_microphone_access,
)?;
let _operation = requested.operation.lock().await;
if !requested.mic_is_current(revision) {
return Err("Microphone selection was superseded by a newer request".into());
}
apply_mic_input(&app_handle, state, label, revision).await
}
.await;
requested
.inner
.lock()
.unwrap()
.microphone
.finish(revision, &result);
result
}
fn check_requested_microphone_permission(
label: Option<&str>,
check: impl FnOnce() -> Result<(), String>,
) -> Result<(), String> {
if label.is_some() {
check()?;
}
Ok(())
}
async fn finish_microphone_input_change(
change: impl std::future::Future<Output = Result<(), String>>,
is_current: impl FnOnce() -> bool,
attach: impl std::future::Future<Output = Result<(), String>>,
) -> Result<(), String> {
change.await?;
if !is_current() {
return Err("Microphone selection was superseded by a newer request".into());
}
attach.await
}
const MICROPHONE_UNLOCK_TIMEOUT: Duration = Duration::from_millis(500);
const MICROPHONE_UNLOCK_RETRY: Duration = Duration::from_millis(50);
const MICROPHONE_CHANGE_TIMEOUT: Duration =
microphone::SETUP_TIMEOUT.saturating_add(Duration::from_secs(1));
async fn wait_for_microphone_setup(
setup: impl std::future::Future<Output = Result<(), String>>,
) -> Result<(), String> {
tokio::time::timeout(MICROPHONE_CHANGE_TIMEOUT, setup)
.await
.map_err(|_| {
"Timed out configuring the requested microphone. Select it again before recording."
.to_string()
})?
}
enum MicrophoneRemovalError {
Locked,
Failed(String),
}
async fn wait_for_microphone_removal<F>(mut remove: impl FnMut() -> F) -> Result<(), String>
where
F: std::future::Future<Output = Result<(), MicrophoneRemovalError>>,
{
let deadline = tokio::time::Instant::now() + MICROPHONE_UNLOCK_TIMEOUT;
loop {
if tokio::time::Instant::now() >= deadline {
return Err("The microphone is still in use. Stop recording and try again.".into());
}
match tokio::time::timeout_at(deadline, remove()).await {
Ok(Ok(())) => return Ok(()),
Ok(Err(MicrophoneRemovalError::Failed(error))) => return Err(error),
Ok(Err(MicrophoneRemovalError::Locked)) => {}
Err(_) => {
return Err(
"Timed out waiting for the microphone to close. Stop recording and try again."
.into(),
);
}
}
let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
if remaining.is_zero() {
return Err("The microphone is still in use. Stop recording and try again.".into());
}
tokio::time::sleep(remaining.min(MICROPHONE_UNLOCK_RETRY)).await;
}
}
async fn remove_microphone_input(feed: &ActorRef<MicrophoneFeed>) -> Result<(), String> {
wait_for_microphone_removal(|| async {
match feed.ask(microphone::RemoveInput).await {
Ok(()) => Ok(()),
Err(kameo::error::SendError::HandlerError(microphone::FeedLockedError)) => {
Err(MicrophoneRemovalError::Locked)
}
Err(error) => Err(MicrophoneRemovalError::Failed(error.to_string())),
}
})
.await
}
async fn acknowledge_studio_microphone(
acknowledgement: impl std::future::Future<Output = Result<(), String>>,
update_ownership: impl std::future::Future<Output = Result<(), String>>,
action: &str,
) -> Result<(), String> {
tokio::time::timeout(MICROPHONE_UNLOCK_TIMEOUT, acknowledgement)
.await
.map_err(|_| {
format!("Timed out {action} the Studio microphone. Stop recording and try again.")
})??;
update_ownership.await
}
fn replace_owned_microphone<T>(
owner: &std::path::Path,
current: Option<(&std::path::Path, &mut Option<T>)>,
replacement: Option<T>,
) -> Result<(), String> {
let Some((current_owner, slot)) = current else {
return Err("The Studio recording stopped while changing microphone input.".into());
};
if current_owner != owner {
return Err("The Studio recording changed while changing microphone input.".into());
}
*slot = replacement;
Ok(())
}
fn studio_microphone_owner_matches(app: &App, owner: &std::path::Path) -> bool {
matches!(app.current_recording(), Some(InProgressRecording::Studio { common, .. })
if common.recording_dir == owner)
}
fn replace_studio_microphone(
app: &mut App,
owner: &std::path::Path,
replacement: Option<Arc<microphone::MicrophoneFeedLock>>,
) -> Result<(), String> {
let current = match app.current_recording_mut() {
Some(InProgressRecording::Studio {
common, mic_feed, ..
}) => Some((common.recording_dir.as_path(), mic_feed)),
_ => None,
};
replace_owned_microphone(owner, current, replacement)
}
async fn apply_mic_input(
app_handle: &AppHandle,
state: MutableState<'_, App>,
desired_label: Option<String>,
revision: u64,
) -> Result<(), String> {
let requested = app_handle.state::<RequestedInputsState>();
check_requested_microphone_permission(
desired_label.as_deref(),
permissions::check_microphone_access,
)?;
let settings = desired_label.as_ref().and_then(|label| {
recording_settings::RecordingSettingsStore::microphone_settings_for(app_handle, label)
});
let reusable = {
let app = state.read().await;
(!matches!(app.recording_state, RecordingState::Active(_))
&& app.applied_mic_input.valid
&& app.applied_mic_input.settings == settings
&& app.selected_mic_label == desired_label)
.then(|| (app.mic_feed.clone(), app.applied_mic_input.generation))
};
if let Some((feed, generation)) = reusable
&& let Some(label) = &desired_label
&& MicrophoneFeed::list_names().contains(label)
&& feed
.ask(microphone::CheckInput(label.clone()))
.await
.unwrap_or(false)
{
let app = state.read().await;
if requested.mic_is_current(revision)
&& app.applied_mic_input.valid
&& app.applied_mic_input.generation == generation
{
return Ok(());
}
}
let (mic_feed, studio_handle, applied_generation) = {
let mut app = state.write().await;
if !requested.mic_is_current(revision) {
return Err("Microphone selection was superseded by a newer request".into());
}
app.ensure_mic_feed_alive().await?;
let selected_label = app.selected_mic_label.clone();
let active = matches!(app.recording_state, RecordingState::Active(_));
let needs_change = app.applied_mic_input.prepare_change(
active,
desired_label.as_deref(),
selected_label.as_deref(),
);
if let Some(label) = desired_label.as_ref()
&& !MicrophoneFeed::list_names().contains(label)
{
app.applied_mic_input.invalidate();
return Err(format!(
"Selected microphone '{label}' is no longer available. Reconnect it or choose another microphone."
));
}
if !needs_change {
return Ok(());
}
let handle = match app.current_recording() {
Some(InProgressRecording::Studio { handle, common, .. }) => {
Some((handle.clone(), common.recording_dir.clone()))
}
_ => None,
};
(
app.mic_feed.clone(),
handle,
app.applied_mic_input.generation,
)
};
let change = async {
if let Some((handle, owner)) = &studio_handle {
acknowledge_studio_microphone(
async {
handle
.set_mic_feed(None)
.await
.map_err(|error| error.to_string())
},
async {
let mut app = state.write().await;
replace_studio_microphone(&mut app, owner, None)
},
"detaching",
)
.await?;
remove_microphone_input(&mic_feed).await?;
}
match desired_label.as_ref() {
None if studio_handle.is_none() => remove_microphone_input(&mic_feed).await?,
None => {}
Some(label) => {
if let Some((_, owner)) = &studio_handle
&& !studio_microphone_owner_matches(&*state.read().await, owner)
{
return Err(
"The Studio recording stopped while changing microphone input.".into(),
);
}
wait_for_microphone_setup(async {
mic_feed
.ask(feeds::microphone::SetInput {
label: label.clone(),
settings,
})
.await
.map_err(|error| error.to_string())?
.await
.map(drop)
.map_err(|error| error.to_string())
})
.await?;
}
}
Ok(())
};
let attach = async {
if let Some((handle, owner)) = &studio_handle
&& let Some(label) = desired_label.as_ref()
{
let mic_lock =
tokio::time::timeout(MICROPHONE_UNLOCK_TIMEOUT, mic_feed.ask(microphone::Lock))
.await
.map_err(|_| "Timed out locking the requested microphone.".to_string())?
.map_err(|error| error.to_string())?;
if mic_lock.device_name() != label {
return Err(
"Microphone input changed before Studio could attach it. Select it again."
.into(),
);
}
let mic_lock = Arc::new(mic_lock);
acknowledge_studio_microphone(
async {
handle
.set_mic_feed(Some(mic_lock.clone()))
.await
.map_err(|error| error.to_string())
},
async {
let mut app = state.write().await;
replace_studio_microphone(&mut app, owner, Some(mic_lock.clone()))
},
"attaching",
)
.await?;
}
Ok(())
};
let apply_result =
finish_microphone_input_change(change, || requested.mic_is_current(revision), attach).await;
if let Some((_, owner)) = &studio_handle
&& !studio_microphone_owner_matches(&*state.read().await, owner)
{
remove_microphone_input(&mic_feed).await?;
return Err("The Studio recording stopped while changing microphone input.".into());
}
match apply_result {
Ok(()) => {
let mut app = state.write().await;
if let Some((_, owner)) = &studio_handle
&& !studio_microphone_owner_matches(&app, owner)
{
drop(app);
remove_microphone_input(&mic_feed).await?;
return Err("The Studio recording stopped while changing microphone input.".into());
}
let mut cleared = false;
let mut confirmed = false;
if !requested.publish_mic_if_current(revision, || {
if !app.applied_mic_input.confirm_if_current(applied_generation) {
return;
}
confirmed = true;
app.applied_mic_input.settings = settings;
app.selected_mic_label = desired_label;
cleared = app
.disconnected_inputs
.remove(&RecordingInputKind::Microphone);
}) {
return Err("Microphone selection was superseded by a newer request".into());
}
if !confirmed {
return Err("Microphone changed or disconnected during setup. Select it again before recording.".into());
}
if cleared {
let _ = RecordingEvent::InputRestored {
input: RecordingInputKind::Microphone,
}
.emit(&app.handle);
}
Ok(())
}
Err(err) => Err(err),
}
}
#[tauri::command]
#[specta::specta]
async fn upload_logs(app_handle: AppHandle) -> Result<(), String> {
logging::upload_log_file(&app_handle).await
}
#[tauri::command]
#[specta::specta]
fn get_system_diagnostics() -> cap_recording::diagnostics::SystemDiagnostics {
cap_recording::diagnostics::collect_diagnostics()
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app_handle, state))]
#[allow(unused_mut)]
async fn set_camera_input(
app_handle: AppHandle,
state: MutableState<'_, App>,
id: Option<DeviceOrModelID>,
skip_camera_window: Option<bool>,
) -> Result<(), String> {
let requested = app_handle.state::<RequestedInputsState>();
let settings = id.as_ref().and_then(|id| {
recording_settings::RecordingSettingsStore::camera_settings_for(&app_handle, id)
});
let (revision, joined) = {
let state = state.read().await;
requested.inner.lock().unwrap().camera.begin_or_join(
id.clone(),
serde_json::json!((settings, skip_camera_window.unwrap_or(false))),
matches!(state.recording_state, RecordingState::Pending { .. }),
)
};
if joined {
return wait_for_existing_input(revision, "Camera", || {
requested.inner.lock().unwrap().camera.clone()
})
.await;
}
let result = async {
check_requested_camera_permission(id.as_ref(), permissions::check_camera_access)?;
let _operation = requested.operation.lock().await;
if !requested.camera_is_current(revision) {
return Err("Camera selection was superseded by a newer request".into());
}
apply_camera_input(&app_handle, state, id, skip_camera_window, revision).await
}
.await;
requested
.inner
.lock()
.unwrap()
.camera
.finish(revision, &result);
result
}
fn check_requested_camera_permission(
id: Option<&DeviceOrModelID>,
check: impl FnOnce() -> Result<(), String>,
) -> Result<(), String> {
if id.is_some() {
check()?;
}
Ok(())
}
async fn await_current_camera_request<T>(
request: impl std::future::Future<Output = T>,
is_current: impl FnOnce() -> bool,
) -> Result<T, String> {
let result = request.await;
if !is_current() {
return Err("Camera selection was superseded by a newer request".into());
}
Ok(result)
}
async fn apply_camera_input(
app_handle: &AppHandle,
state: MutableState<'_, App>,
id: Option<DeviceOrModelID>,
skip_camera_window: Option<bool>,
revision: u64,
) -> Result<(), String> {
check_requested_camera_permission(id.as_ref(), permissions::check_camera_access)?;
let requested = app_handle.state::<RequestedInputsState>();
let operation_lock = app_handle.state::<CameraWindowOperationLock>();
let _operation_guard = operation_lock.lock().await;
if !requested.camera_is_current(revision) {
return Err("Camera selection was superseded by a newer request".into());
}
let app = state.read().await;
let camera_feed = app.camera_feed.clone();
let studio_handle = match app.current_recording() {
Some(InProgressRecording::Studio { handle, .. }) => Some(handle.clone()),
_ => None,
};
let current_id = app.selected_camera_id.clone();
let camera_in_use = app.camera_in_use;
let recording_active = matches!(app.recording_state, RecordingState::Active(_));
drop(app);
if !requested.camera_is_current(revision) {
return Err("Camera selection was superseded by a newer request".into());
}
let skip_camera_window = skip_camera_window.unwrap_or(false);
let camera_window_is_visible = CapWindowId::Camera
.get(app_handle)
.and_then(|window| window.is_visible().ok())
.unwrap_or(false);
if id == current_id && camera_in_use && recording_active && !skip_camera_window {
let show_result = if camera_window_is_visible {
Ok(())
} else {
show_requested_camera_window(app_handle, revision).await
};
show_result
.map_err(|err| error!("Failed to show camera preview window: {err}"))
.ok();
return Ok(());
}
if let Some(id) = &id
&& !is_camera_available(id)
{
return Err(format!(
"Selected camera '{}' is no longer available. Reconnect it or choose another camera.",
recording::camera_id_label(id)
));
}
let settings = id.as_ref().and_then(|id| {
recording_settings::RecordingSettingsStore::camera_settings_for(app_handle, id)
});
if !recording_active
&& !skip_camera_window
&& camera_in_use
&& id == current_id
&& let Some(id) = &id
&& camera_feed
.ask(feeds::camera::CheckInput {
id: id.clone(),
settings,
})
.await
.unwrap_or(false)
{
if !requested.camera_is_current(revision) {
return Err("Camera selection was superseded by a newer request".into());
}
if !camera_window_is_visible {
show_requested_camera_window(app_handle, revision).await?;
}
return Ok(());
}
if let Some(handle) = &studio_handle {
handle
.set_camera_feed(None)
.await
.map_err(|e| e.to_string())?;
}
match &id {
None => {
let shutdown_rx = {
let app = &mut *state.write().await;
let mut shutdown_rx = None;
if !requested.publish_camera_if_current(revision, || {
app.camera_in_use = false;
app.camera_cleanup_done = true;
if skip_camera_window {
shutdown_rx = app.camera_preview.begin_shutdown();
} else {
app.camera_preview.pause();
}
}) {
return Err("Camera selection was superseded by a newer request".into());
}
shutdown_rx
};
camera_feed
.ask(feeds::camera::RemoveInput)
.await
.map_err(|e| e.to_string())?;
if let Some(rx) = shutdown_rx {
let _ = tokio::time::timeout(Duration::from_millis(500), rx).await;
}
if !skip_camera_window && let Some(window) = CapWindowId::Camera.get(app_handle) {
let _ = window.hide();
}
}
Some(id) => {
if !requested.publish_camera_if_current(revision, || {
emit_camera_preview_clear(app_handle);
}) {
return Err("Camera selection was superseded by a newer request".into());
}
let (camera_ws_sender, camera_preview_sender, use_ws_preview) = {
let app = &mut *state.write().await;
let use_ws_preview = !(camera_window_is_visible
&& app.camera_preview.is_initialized()
&& !app.camera_preview.is_paused());
if !requested.publish_camera_if_current(revision, || {
app.camera_in_use = true;
app.camera_cleanup_done = false;
}) {
return Err("Camera selection was superseded by a newer request".into());
}
#[allow(deprecated)]
(
app.camera_ws_sender.clone(),
app.camera_preview.sender(),
use_ws_preview,
)
};
sync_camera_preview_sender(
&camera_feed,
camera_ws_sender,
camera_preview_sender,
use_ws_preview,
)
.await;
let mut showed_camera_window = skip_camera_window;
let mut attempts = 0;
let init_result: Result<(), String> = loop {
if !requested.camera_is_current(revision) {
return Err("Camera selection was superseded by a newer request".into());
}
attempts += 1;
let request = camera_feed
.ask(feeds::camera::SetInput {
id: id.clone(),
settings,
})
.await
.map_err(|e| e.to_string());
if !requested.camera_is_current(revision) {
return Err("Camera selection was superseded by a newer request".into());
}
if !showed_camera_window {
showed_camera_window = true;
let show_result = show_requested_camera_window(app_handle, revision).await;
show_result
.map_err(|err| error!("Failed to show camera preview window: {err}"))
.ok();
}
let result = await_current_camera_request(
async {
match request {
Ok(future) => future.await.map_err(|e| e.to_string()),
Err(e) => Err(e),
}
},
|| requested.camera_is_current(revision),
)
.await?;
match result {
Ok(_) => {
if !requested.publish_camera_if_current(revision, || {
emit_camera_preview_clear(app_handle);
}) {
return Err("Camera selection was superseded by a newer request".into());
}
break Ok(());
}
Err(e) => {
if attempts == 1
&& !skip_camera_window
&& !requested.publish_camera_if_current(revision, || {
emit_camera_preview_error(
app_handle,
camera_preview_error_message(&e),
);
})
{
return Err("Camera selection was superseded by a newer request".into());
}
if attempts >= 3 {
break Err(format!(
"Failed to initialize camera after {attempts} attempts: {e}"
));
}
debug!(
"Failed to set camera input (attempt {}): {}. Retrying...",
attempts, e
);
await_current_camera_request(
tokio::time::sleep(Duration::from_millis(500)),
|| requested.camera_is_current(revision),
)
.await?;
}
}
};
if !requested.camera_is_current(revision) {
return Err("Camera selection was superseded by a newer request".into());
}
if let Err(e) = init_result {
let message = camera_preview_error_message(&e);
let _ = camera_feed.ask(feeds::camera::RemoveInput).await;
let app = &mut *state.write().await;
if !requested.publish_camera_if_current(revision, || {
app.camera_in_use = false;
if app.disconnected_inputs.insert(RecordingInputKind::Camera) {
let _ = RecordingEvent::InputLost {
input: RecordingInputKind::Camera,
}
.emit(app_handle);
}
emit_camera_preview_error(app_handle, message.clone());
let _ = NewNotification {
title: "Camera unavailable".to_string(),
body: message,
is_error: true,
}
.emit(app_handle);
}) {
return Err("Camera selection was superseded by a newer request".into());
}
return Err(e);
}
}
}
if !requested.camera_is_current(revision) {
return Err("Camera selection was superseded by a newer request".into());
}
if let Some(handle) = studio_handle
&& id.is_some()
{
let camera_lock = camera_feed
.ask(feeds::camera::Lock)
.await
.map_err(|e| e.to_string())?;
handle
.set_camera_feed(Some(Arc::new(camera_lock)))
.await
.map_err(|e| e.to_string())?;
}
{
let app = &mut *state.write().await;
let mut cleared = false;
if !requested.publish_camera_if_current(revision, || {
app.selected_camera_id = id;
app.camera_in_use = app.selected_camera_id.is_some();
app.camera_cleanup_done = !app.camera_in_use;
cleared = app.disconnected_inputs.remove(&RecordingInputKind::Camera);
}) {
return Err("Camera selection was superseded by a newer request".into());
}
if cleared {
let _ = RecordingEvent::InputRestored {
input: RecordingInputKind::Camera,
}
.emit(&app.handle);
}
}
Ok(())
}
async fn show_requested_camera_window(app: &AppHandle, revision: u64) -> Result<(), String> {
let requested = app.state::<RequestedInputsState>();
if !requested.camera_is_current(revision) {
return Err("Camera selection was superseded by a newer request".into());
}
let result = ShowCapWindow::Camera { centered: false }.show(app).await;
if !requested.camera_is_current(revision) {
if let Some(window) = CapWindowId::Camera.get(app) {
let _ = window.hide();
}
return Err("Camera selection was superseded by a newer request".into());
}
result.map(|_| ()).map_err(|error| error.to_string())
}
pub(crate) async fn restore_requested_inputs(app_handle: &AppHandle) {
let requested = app_handle.state::<RequestedInputsState>();
let snapshot = requested.snapshot();
if snapshot.microphone.pending || snapshot.camera.pending {
return;
}
let microphone_permission = check_requested_microphone_permission(
snapshot.microphone.value.as_deref(),
permissions::check_microphone_access,
);
let camera_permission = check_requested_camera_permission(
snapshot.camera.value.as_ref(),
permissions::check_camera_access,
);
let _operation = requested.operation.lock().await;
let state = app_handle.state::<ArcLock<App>>();
if !requested.is_current(&snapshot) || state.read().await.is_recording_active_or_pending() {
return;
}
if !requested
.inner
.lock()
.unwrap()
.microphone
.prepare_restore(snapshot.microphone.revision)
{
return;
}
let mic_result = match microphone_permission {
Ok(()) => {
apply_mic_input(
app_handle,
state.clone(),
snapshot.microphone.value.clone(),
snapshot.microphone.revision,
)
.await
}
Err(error) => Err(error),
};
requested
.inner
.lock()
.unwrap()
.microphone
.finish(snapshot.microphone.revision, &mic_result);
if let Err(error) = mic_result {
warn!(%error, "Failed to restore requested microphone");
}
let restore_camera = {
let state = state.read().await;
requested.is_current(&snapshot)
&& !state.is_recording_active_or_pending()
&& !state.camera_cleanup_done
&& !state.camera_in_use
&& snapshot.camera.value.is_some()
};
if !restore_camera {
return;
}
if !requested
.inner
.lock()
.unwrap()
.camera
.prepare_restore(snapshot.camera.revision)
{
return;
}
let camera_result = match camera_permission {
Ok(()) => {
apply_camera_input(
app_handle,
state,
snapshot.camera.value,
Some(false),
snapshot.camera.revision,
)
.await
}
Err(error) => Err(error),
};
requested
.inner
.lock()
.unwrap()
.camera
.finish(snapshot.camera.revision, &camera_result);
if let Err(error) = camera_result {
warn!(%error, "Failed to restore requested camera");
}
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app_handle, state))]
async fn set_native_camera_preview_enabled(
app_handle: AppHandle,
state: MutableState<'_, App>,
enabled: bool,
) -> Result<(), String> {
if enabled && cfg!(not(target_os = "macos")) {
return Err("Native camera preview is only available on macOS".to_string());
}
let operation_lock = app_handle.state::<CameraWindowOperationLock>();
let _operation_guard = operation_lock.lock().await;
GeneralSettingsStore::update(&app_handle, |settings| {
settings.enable_native_camera_preview = enabled;
})?;
let window = CapWindowId::Camera.get(&app_handle);
if enabled {
let Some(window) = window else {
return Ok(());
};
let is_visible = window.is_visible().unwrap_or(false);
if !is_visible {
return Ok(());
}
let init_result = {
let mut app = state.write().await;
windows::ensure_camera_input_active(&mut app).await;
if app.selected_camera_id.is_none() || !app.camera_in_use {
None
} else {
let camera_feed = app.camera_feed.clone();
Some(app.camera_preview.init_window(window, camera_feed).await)
}
};
let Some(init_result) = init_result else {
return Ok(());
};
if let Err(err) = init_result {
GeneralSettingsStore::update(&app_handle, |settings| {
settings.enable_native_camera_preview = false;
})?;
return Err(format!("Failed to enable native camera preview: {err}"));
}
let (camera_feed, camera_ws_sender) = {
let app = state.read().await;
#[allow(deprecated)]
(app.camera_feed.clone(), app.camera_ws_sender.clone())
};
#[allow(deprecated)]
let result = camera_feed
.ask(feeds::camera::RemoveSender(camera_ws_sender))
.await;
if let Err(err) = result {
warn!(error = %err, "Failed to remove camera WebSocket sender");
}
return Ok(());
}
let (shutdown_rx, camera_feed, camera_ws_sender, should_restore_ws_sender) = {
let mut app = state.write().await;
#[allow(deprecated)]
(
app.camera_preview.begin_shutdown(),
app.camera_feed.clone(),
app.camera_ws_sender.clone(),
app.selected_camera_id.is_some() && app.camera_in_use,
)
};
if let Some(rx) = shutdown_rx {
let _ = tokio::time::timeout(Duration::from_secs(2), rx).await;
}
if should_restore_ws_sender {
#[allow(deprecated)]
let result = camera_feed
.ask(feeds::camera::AddSender(camera_ws_sender))
.await;
if let Err(err) = result {
warn!(error = %err, "Failed to restore camera WebSocket sender");
}
}
Ok(())
}
fn display_for_position(pos_x: f64, pos_y: f64) -> Option<Display> {
Display::list().into_iter().find_map(|display| {
let bounds = display.raw_handle().logical_bounds()?;
let x = bounds.position().x();
let y = bounds.position().y();
let width = bounds.size().width();
let height = bounds.size().height();
if pos_x >= x && pos_x < x + width && pos_y >= y && pos_y < y + height {
Some(display)
} else {
None
}
})
}
// On Windows the per-monitor logical rects overlap in mixed-DPI layouts, so a
// window's display must be resolved from its physical position; logical
// containment (display_for_position) can match the wrong monitor there.
#[cfg(windows)]
fn display_for_physical_position(pos_x: f64, pos_y: f64) -> Option<Display> {
Display::list().into_iter().find(|display| {
display
.raw_handle()
.physical_bounds()
.is_some_and(|bounds| {
pos_x >= bounds.position().x()
&& pos_x < bounds.position().x() + bounds.size().width()
&& pos_y >= bounds.position().y()
&& pos_y < bounds.position().y() + bounds.size().height()
})
})
}
pub(crate) fn update_camera_window_position_settings(
settings: &mut GeneralSettingsStore,
x: f64,
y: f64,
display_id: Option<DisplayId>,
) {
let display = display_id
.and_then(|id| Display::from_id(&id))
.or_else(|| display_for_position(x, y));
let display_id = display.as_ref().map(|display| display.id());
let monitor_name = display
.as_ref()
.and_then(|display| display.name())
.filter(|name| !name.trim().is_empty());
let position = general_settings::WindowPosition { x, y, display_id };
settings.camera_window_position = Some(position.clone());
if let Some(monitor_name) = monitor_name {
settings
.camera_window_positions_by_monitor_name
.insert(monitor_name, position);
}
}
fn spawn_mic_error_handler(app_handle: AppHandle, error_rx: flume::Receiver<StreamError>) {
tokio::spawn(async move {
let state = app_handle.state::<ArcLock<App>>();
let state = state.inner().clone();
let error_rx = error_rx;
while let Ok(err) = error_rx.recv_async().await {
if app_is_exiting(&app_handle) {
break;
}
error!("Mic feed actor error: {err}");
{
let mut app = state.write().await;
if let Err(handle_err) = app
.handle_input_disconnect(RecordingInputKind::Microphone)
.await
{
warn!("Failed to handle mic disconnect event: {handle_err}");
}
}
tokio::time::sleep(Duration::from_millis(500)).await;
if app_is_exiting(&app_handle) {
break;
}
let mut app = state.write().await;
if app_is_exiting(&app_handle) {
break;
}
match app.ensure_selected_mic_ready().await {
Ok(()) => {
info!("Microphone stream recovered after error");
if let Err(restored_err) = app
.handle_input_restored(RecordingInputKind::Microphone)
.await
{
warn!("Failed to handle mic restoration: {restored_err}");
}
}
Err(restart_err) => {
warn!("Failed to restart microphone input after error: {restart_err}");
}
}
}
});
}
fn spawn_device_watchers(app_handle: AppHandle) {
spawn_microphone_watcher(app_handle.clone());
spawn_camera_watcher(app_handle);
}
#[derive(Serialize, Type, tauri_specta::Event, Debug, Clone)]
pub struct DevicesUpdated {
cameras: Vec<cap_camera::CameraInfo>,
microphones: Vec<String>,
permissions: permissions::OSPermissionsCheck,
}
#[tauri::command]
#[specta::specta]
async fn get_devices_snapshot() -> DevicesUpdated {
let permissions = permissions::do_permissions_check(false);
let cameras = if permissions.camera.permitted() {
cap_camera::list_cameras().collect()
} else {
Vec::new()
};
let microphones = if permissions.microphone.permitted() {
MicrophoneFeed::list_names()
} else {
Vec::new()
};
DevicesUpdated {
cameras,
microphones,
permissions,
}
}
fn any_webview_window_visible(app: &AppHandle) -> bool {
app.webview_windows()
.values()
.any(|window| window.is_visible().unwrap_or(false))
}
fn spawn_devices_snapshot_emitter(app_handle: AppHandle) {
tokio::spawn(async move {
let mut last_perm_tuple: (u8, u8, u8, u8) = (255, 255, 255, 255);
let mut last_camera_ids: Vec<String> = Vec::new();
let mut last_mics: Vec<String> = Vec::new();
let mut fast_loops = 0u32;
loop {
if app_is_exiting(&app_handle) {
break;
}
if power_observer::is_system_asleep() {
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
continue;
}
if !any_webview_window_visible(&app_handle) {
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
continue;
}
let permissions = permissions::do_permissions_check(false);
let Some((cameras, microphones)) = collect_device_inventory(
|| app_is_exiting(&app_handle),
permissions.camera.permitted(),
permissions.microphone.permitted(),
|| cap_camera::list_cameras().collect::<Vec<_>>(),
MicrophoneFeed::list_names,
) else {
break;
};
let perm_tuple = (
match permissions.screen_recording {
permissions::OSPermissionStatus::NotNeeded => 0,
permissions::OSPermissionStatus::Empty => 1,
permissions::OSPermissionStatus::Granted => 2,
permissions::OSPermissionStatus::Denied => 3,
},
match permissions.microphone {
permissions::OSPermissionStatus::NotNeeded => 0,
permissions::OSPermissionStatus::Empty => 1,
permissions::OSPermissionStatus::Granted => 2,
permissions::OSPermissionStatus::Denied => 3,
},
match permissions.camera {
permissions::OSPermissionStatus::NotNeeded => 0,
permissions::OSPermissionStatus::Empty => 1,
permissions::OSPermissionStatus::Granted => 2,
permissions::OSPermissionStatus::Denied => 3,
},
match permissions.accessibility {
permissions::OSPermissionStatus::NotNeeded => 0,
permissions::OSPermissionStatus::Empty => 1,
permissions::OSPermissionStatus::Granted => 2,
permissions::OSPermissionStatus::Denied => 3,
},
);
let camera_ids: Vec<String> =
cameras.iter().map(|c| c.device_id().to_string()).collect();
let mut changed = perm_tuple != last_perm_tuple;
if !changed {
changed = camera_ids != last_camera_ids || microphones != last_mics;
}
if changed && !app_is_exiting(&app_handle) {
DevicesUpdated {
cameras: cameras.clone(),
microphones: microphones.clone(),
permissions: permissions.clone(),
}
.emit(&app_handle)
.ok();
last_perm_tuple = perm_tuple;
last_camera_ids = camera_ids;
last_mics = microphones;
}
let dur = if fast_loops < 10 {
std::time::Duration::from_millis(500)
} else {
std::time::Duration::from_secs(5)
};
fast_loops = fast_loops.saturating_add(1);
tokio::time::sleep(dur).await;
if app_is_exiting(&app_handle) {
break;
}
}
});
}
fn spawn_system_resume_detector(app_handle: AppHandle) {
const TICK: Duration = Duration::from_secs(5);
const WAKE_THRESHOLD: Duration = Duration::from_secs(20);
tokio::spawn(async move {
let mut last_instant = std::time::Instant::now();
let mut last_system_time = std::time::SystemTime::now();
loop {
if app_is_exiting(&app_handle) {
break;
}
tokio::time::sleep(TICK).await;
if app_is_exiting(&app_handle) {
break;
}
let now_instant = std::time::Instant::now();
let now_system = std::time::SystemTime::now();
let monotonic_delta = now_instant.saturating_duration_since(last_instant);
let wall_delta = now_system
.duration_since(last_system_time)
.unwrap_or_default();
last_instant = now_instant;
last_system_time = now_system;
let drift = wall_delta.saturating_sub(monotonic_delta);
let slept = drift >= WAKE_THRESHOLD || monotonic_delta >= TICK + WAKE_THRESHOLD;
if slept {
tracing::warn!(
monotonic_ms = monotonic_delta.as_millis(),
wall_ms = wall_delta.as_millis(),
"System resume drift detected; scheduling resume recovery"
);
schedule_resume_recovery(app_handle.clone());
}
}
});
}
pub(crate) fn schedule_resume_recovery(app_handle: AppHandle) {
tauri::async_runtime::spawn(async move {
if app_is_exiting(&app_handle) {
return;
}
tokio::time::sleep(Duration::from_millis(500)).await;
if app_is_exiting(&app_handle) {
return;
}
#[cfg(target_os = "macos")]
{
if let Some(prewarmer) =
app_handle.try_state::<crate::platform::ScreenCapturePrewarmer>()
{
prewarmer.request(true).await;
} else {
warn!("ScreenCapturePrewarmer state unavailable during resume recovery");
}
}
if !app_is_exiting(&app_handle) {
emit_app_event_safely(&app_handle, RequestScreenCapturePrewarm { force: true });
}
if !app_is_exiting(&app_handle) {
let snapshot = get_devices_snapshot().await;
emit_app_event_safely(&app_handle, snapshot);
}
});
}
async fn cleanup_camera_window(app: AppHandle, session_id: u64) {
if app_is_exiting(&app) {
return;
}
let state = app.state::<ArcLock<App>>();
let camera_feed = {
let mut app_state = state.write().await;
if app_is_exiting(&app) {
return;
}
let current_session_id = app_state
.camera_preview
.session_id_handle()
.load(Ordering::Acquire);
if current_session_id != session_id {
tracing::info!(
"Camera cleanup aborted: session mismatch (cleanup session {} vs current {})",
session_id,
current_session_id
);
return;
}
if app_state.camera_cleanup_done {
return;
}
app_state.camera_cleanup_done = true;
app_state.camera_preview.pause();
if app_state.is_recording_active_or_pending() {
return;
}
let has_visible_target_overlay = app.webview_windows().iter().any(|(label, window)| {
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 && main_window_visible {
tracing::info!("Camera cleanup: preserving camera feed for camera-only mode");
return;
}
if has_visible_target_overlay {
return;
}
app_state.camera_feed.clone()
};
let _ = tokio::time::timeout(
APP_EXIT_STEP_TIMEOUT,
camera_feed.ask(feeds::camera::RemoveInput),
)
.await;
let mut app_state = state.write().await;
app_state.camera_in_use = false;
}
async fn cleanup_camera_after_overlay_close(app: AppHandle, captured_session_id: u64) {
if app_is_exiting(&app) {
return;
}
let state = app.state::<ArcLock<App>>();
let camera_feed = {
let mut app_state = state.write().await;
if app_is_exiting(&app) {
return;
}
let current_session_id = app_state
.camera_preview
.session_id_handle()
.load(Ordering::Acquire);
if current_session_id != captured_session_id {
tracing::info!(
"Camera cleanup after overlay aborted: session mismatch ({} vs {})",
captured_session_id,
current_session_id
);
return;
}
if app_state.camera_cleanup_done {
return;
}
if app_state.is_recording_active_or_pending() {
return;
}
let has_camera_window = CapWindowId::Camera.get(&app).is_some();
if has_camera_window {
return;
}
let has_visible_target_overlay = app.webview_windows().iter().any(|(label, window)| {
label.starts_with("target-select-overlay-") && window.is_visible().unwrap_or(false)
});
if has_visible_target_overlay {
return;
}
app_state.camera_cleanup_done = true;
if !app_state.camera_in_use {
return;
}
app_state.camera_feed.clone()
};
let _ = camera_feed.ask(feeds::camera::RemoveInput).await;
let mut app_state = state.write().await;
app_state.camera_in_use = false;
}
async fn cleanup_app_resources_for_exit(app: &AppHandle) {
let started = Instant::now();
log_process_memory_snapshot("exit_cleanup_begin");
// Reverse the macOS Liquid Glass private SPI (remove the NSGlassEffectView, restore
// window/WKWebView occlusion detection) BEFORE anything else, so a slow camera/ML
// shutdown can never starve it. Leaving an occlusion-suppressed private glass view
// attached when the process hard-exits can wedge WindowServer on macOS 26 and soft-
// restart the user's login session. Bounded so a stuck main thread can't block exit.
#[cfg(target_os = "macos")]
{
let _ = await_exit_step(
"teardown_liquid_glass",
APP_EXIT_STEP_TIMEOUT,
crate::platform::teardown_all_liquid_glass(app),
)
.await;
}
export::cancel_all_exports();
upload::lifecycle::shutdown().await;
power_observer::uninstall(app);
fake_window::cancel_all_fake_window_listeners(app);
close_target_select_overlays(app);
let preparing = app
.state::<editor_preparing::PreparingConsumers>()
.inner()
.clone();
let _ = await_exit_step(
"dispose_preparing_editor_frames",
APP_EXIT_STEP_TIMEOUT,
preparing.dispose_all(),
)
.await;
let app_for_pending_editors = app.clone();
let _ = await_exit_step(
"dispose_pending_editor_instances",
APP_EXIT_STEP_TIMEOUT,
async move {
PendingEditorInstances::dispose_all(&app_for_pending_editors).await;
Ok::<(), String>(())
},
)
.await;
let app_for_editors = app.clone();
let _ = await_exit_step(
"dispose_editor_instances",
APP_EXIT_STEP_TIMEOUT,
async move {
EditorInstances::dispose_all(&app_for_editors).await;
Ok::<(), String>(())
},
)
.await;
let app_for_pending_screenshot_editors = app.clone();
let _ = await_exit_step(
"dispose_pending_screenshot_editor_instances",
APP_EXIT_STEP_TIMEOUT,
async move {
PendingScreenshotEditorInstances::dispose_all(&app_for_pending_screenshot_editors)
.await;
Ok::<(), String>(())
},
)
.await;
let app_for_screenshot_editors = app.clone();
let _ = await_exit_step(
"dispose_screenshot_editor_instances",
APP_EXIT_STEP_TIMEOUT,
async move {
ScreenshotEditorInstances::dispose_all(&app_for_screenshot_editors).await;
Ok::<(), String>(())
},
)
.await;
log_process_memory_snapshot("exit_after_editor_dispose");
let (mic_feed, camera_feed, camera_shutdown) = {
let Some(state) = app.try_state::<ArcLock<App>>() else {
warn!("App state unavailable during exit cleanup");
return;
};
let mut app_state = state.write().await;
let camera_shutdown = app_state.camera_preview.begin_shutdown();
app_state.applied_mic_input.invalidate();
app_state.camera_in_use = false;
app_state.selected_camera_id = None;
(
app_state.mic_feed.clone(),
app_state.camera_feed.clone(),
camera_shutdown,
)
};
let _ = await_exit_step(
"remove_microphone_input",
APP_EXIT_STEP_TIMEOUT,
async move { mic_feed.ask(microphone::RemoveInput).await },
)
.await;
let _ = await_exit_step("remove_camera_input", APP_EXIT_STEP_TIMEOUT, async move {
camera_feed.ask(feeds::camera::RemoveInput).await
})
.await;
if let Some(rx) = camera_shutdown {
let _ = await_exit_step(
"camera_preview_shutdown",
APP_EXIT_CAMERA_SHUTDOWN_TIMEOUT,
rx,
)
.await;
}
captions::release_ml_models().await;
log_process_memory_snapshot("exit_cleanup_end");
info!(
elapsed_ms = started.elapsed().as_millis(),
"Exit cleanup completed"
);
}
#[cfg(target_os = "macos")]
fn finalize_app_exit(app: &AppHandle, exit_code: i32) -> ! {
let _ = app;
sentry::Hub::with(|hub| {
if let Some(client) = hub.client() {
let _ = client.flush(Some(Duration::from_millis(250)));
}
});
match app_exit_action(exit_code) {
AppExitAction::Process(code) => force_exit(code),
}
}
#[cfg(not(target_os = "macos"))]
fn finalize_app_exit(app: &AppHandle, exit_code: i32) {
match app_exit_action(exit_code) {
AppExitAction::Runtime(code) => app.exit(code),
}
}
pub(crate) fn with_idle_app<T>(
app: &AppHandle,
include_exports: bool,
begin: impl FnOnce() -> T,
) -> Result<T, ExitBlocked> {
with_idle_app_for_title_flush(app, include_exports, false, begin)
}
fn with_idle_app_for_title_flush<T>(
app: &AppHandle,
include_exports: bool,
owns_title_flush: bool,
begin: impl FnOnce() -> T,
) -> Result<T, ExitBlocked> {
let exit_state = app
.try_state::<AppExitState>()
.ok_or(ExitBlocked::StateUnavailable)?;
let _admission = exit_state
.admission
.try_lock()
.map_err(|_| ExitBlocked::StateUnavailable)?;
if exit_state.is_exiting()
|| (!owns_title_flush && exit_state.title_flush_pending.load(Ordering::Acquire))
{
return Err(ExitBlocked::AlreadyExiting);
}
let state = app
.try_state::<ArcLock<App>>()
.ok_or(ExitBlocked::StateUnavailable)?;
let finalizing = app
.try_state::<FinalizingRecordings>()
.ok_or(ExitBlocked::StateUnavailable)?;
let _clean_capture = app
.try_state::<clean_capture::State>()
.ok_or(ExitBlocked::StateUnavailable)?;
let updates = app
.try_state::<updates::UpdatesState>()
.ok_or(ExitBlocked::StateUnavailable)?;
if updates.is_installing() {
return Err(ExitBlocked::UpdateInstalling);
}
with_idle_recording_state(
&state,
|state| {
if state.is_recording_active_or_pending() || clean_capture::phase(app).is_some() {
return Err(ExitBlocked::RecordingActive);
}
let recordings = finalizing
.recordings
.try_lock()
.map_err(|_| ExitBlocked::StateUnavailable)?;
if has_pending_finalizations(&recordings) {
return Err(ExitBlocked::FinalizationActive);
}
if include_exports {
if export::export_session_active() {
return Err(ExitBlocked::ExportActive);
}
if upload::upload_session_active() {
return Err(ExitBlocked::UploadActive);
}
}
Ok(())
},
begin,
)
}
fn begin_app_exit_if_idle(app: &AppHandle, restarting: bool) -> Result<bool, ExitBlocked> {
let exit_state = app
.try_state::<AppExitState>()
.ok_or(ExitBlocked::StateUnavailable)?;
with_idle_app(app, restarting, || {
if !exit_state.begin() {
return false;
}
if restarting {
exit_state.begin_restart();
}
true
})
}
pub(crate) fn prepare_app_exit(
app: &AppHandle,
prepare: impl FnOnce() -> Result<(), String>,
) -> Result<(), String> {
let exit_state = app
.try_state::<AppExitState>()
.ok_or(ExitBlocked::StateUnavailable.message())?;
with_idle_app(app, true, || {
prepare_then_begin_exit(prepare, || exit_state.begin())
})
.map_err(|reason| reason.message().to_string())?
}
fn show_exit_blocked(app: &AppHandle, reason: ExitBlocked) {
warn!(
?reason,
"Refusing app exit while recording safety is unconfirmed"
);
app.dialog()
.message(reason.message())
.title("Cap is still busy")
.kind(tauri_plugin_dialog::MessageDialogKind::Warning)
.show(|_| {});
}
#[derive(Clone, Serialize)]
#[serde(rename_all = "camelCase")]
struct EditorTitleSaveRequest {
request_id: String,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct EditorTitleSaveResponse {
request_id: String,
window_label: String,
error: Option<String>,
}
async fn wait_for_editor_title_saves(
request_id: &str,
mut pending: HashSet<String>,
mut responses: tokio::sync::mpsc::UnboundedReceiver<EditorTitleSaveResponse>,
timeout: Duration,
) -> Result<(), String> {
tokio::time::timeout(timeout, async {
while !pending.is_empty() {
let response = responses
.recv()
.await
.ok_or("The editor title save connection closed before saving finished.")?;
if response.request_id != request_id || !pending.remove(&response.window_label) {
continue;
}
if let Some(error) = response.error {
return Err(format!("Could not save the recording title: {error}"));
}
}
Ok(())
})
.await
.map_err(|_| {
"Could not confirm that all recording titles were saved. Try Quit again.".to_string()
})?
}
async fn flush_editor_titles_for_exit(
app: &AppHandle,
) -> Result<Option<EditorTitleSaveRequest>, String> {
let labels: HashSet<_> = app
.webview_windows()
.into_keys()
.filter(|label| matches!(CapWindowId::from_str(label), Ok(CapWindowId::Editor { .. })))
.collect();
if labels.is_empty() {
return Ok(None);
}
let request = EditorTitleSaveRequest {
request_id: uuid::Uuid::new_v4().to_string(),
};
let (sender, responses) = tokio::sync::mpsc::unbounded_channel();
let listener = app.listen_any("editor-title-save-finished", move |event| {
if let Ok(response) = serde_json::from_str(event.payload()) {
let _ = sender.send(response);
}
});
let result = async {
for label in &labels {
app.emit_to(label, "editor-title-save-request", &request)
.map_err(|error| format!("Could not request an editor title save: {error}"))?;
}
wait_for_editor_title_saves(
&request.request_id,
labels.clone(),
responses,
Duration::from_secs(5),
)
.await?;
if app.webview_windows().keys().any(|label| {
!labels.contains(label)
&& matches!(CapWindowId::from_str(label), Ok(CapWindowId::Editor { .. }))
}) {
return Err("Another editor opened while preparing to quit. Try Quit again.".into());
}
Ok(())
}
.await;
app.unlisten(listener);
if result.is_err() {
let _ = app.emit("editor-title-save-cancelled", &request);
}
result.map(|()| Some(request))
}
#[tauri::command]
#[specta::specta]
fn restart_app(app: AppHandle) -> Result<(), String> {
match begin_app_exit_if_idle(&app, true) {
Ok(true) => {
app.request_restart();
Ok(())
}
Ok(false) => Err("Cap is already shutting down.".into()),
Err(reason) => Err(reason.message().into()),
}
}
pub async fn request_app_exit(app: AppHandle) {
let Some(exit_state) = app.try_state::<AppExitState>() else {
show_exit_blocked(&app, ExitBlocked::StateUnavailable);
return;
};
let pending = match with_idle_app(&app, false, || exit_state.begin_title_flush()) {
Ok(Some(pending)) => pending,
Ok(None) => return,
Err(ExitBlocked::AlreadyExiting) => return,
Err(reason) => {
show_exit_blocked(&app, reason);
return;
}
};
let request = match flush_editor_titles_for_exit(&app).await {
Ok(request) => request,
Err(error) => {
drop(pending);
warn!(%error, "Quit canceled because an editor title could not be saved");
app.dialog()
.message(format!(
"{error}\n\nCap is still open. Your title is still in the editor."
))
.title("Title not saved")
.kind(tauri_plugin_dialog::MessageDialogKind::Warning)
.show(|_| {});
return;
}
};
let admission = with_idle_app_for_title_flush(&app, true, true, || exit_state.begin());
drop(pending);
match admission {
Ok(true) => {}
result => {
if let Some(request) = request {
let _ = app.emit("editor-title-save-cancelled", request);
}
if let Err(reason) = result {
show_exit_blocked(&app, reason);
}
return;
}
}
complete_admitted_app_exit(app).await;
}
pub(crate) async fn complete_admitted_app_exit(app: AppHandle) {
#[cfg(target_os = "macos")]
cancel_macos_startup_opens(&app);
spawn_exit_watchdog();
export::cancel_all_exports();
if tokio::time::timeout(APP_EXIT_TOTAL_TIMEOUT, cleanup_app_resources_for_exit(&app))
.await
.is_err()
{
error!(
timeout_ms = APP_EXIT_TOTAL_TIMEOUT.as_millis(),
"Timed out while cleaning up app resources for exit"
);
} else {
// Cleanup finished within budget — disarm the sentinel so this graceful exit
// is not reported as an unexpected termination on next launch. A timed-out
// (hung) shutdown deliberately leaves it armed.
crash_sentinel::mark_clean_exit();
}
finalize_app_exit(&app, 0);
}
pub(crate) fn find_mic_by_label(devices: &[String], selected_label: &str) -> Option<String> {
if devices.iter().any(|name| name == selected_label) {
return Some(selected_label.to_string());
}
None
}
fn spawn_microphone_watcher(app_handle: AppHandle) {
tokio::spawn(async move {
let state = app_handle.state::<ArcLock<App>>();
let state = state.inner().clone();
loop {
if app_is_exiting(&app_handle) {
break;
}
if power_observer::is_system_asleep() {
tokio::time::sleep(Duration::from_secs(1)).await;
continue;
}
let (should_check, label, is_marked) = {
let guard = state.read().await;
(
matches!(guard.recording_state, RecordingState::Active(_)),
guard.selected_mic_label.clone(),
guard
.disconnected_inputs
.contains(&RecordingInputKind::Microphone),
)
};
if should_check && let Some(selected_label) = label {
let Some(devices) = run_while_active(
|| app_is_exiting(&app_handle),
microphone::MicrophoneFeed::list_names,
) else {
break;
};
let matched = find_mic_by_label(&devices, &selected_label);
if matched.is_none() && !is_marked {
let mut app = state.write().await;
if let Err(err) = app
.handle_input_disconnect(RecordingInputKind::Microphone)
.await
{
warn!("Failed to handle mic disconnect: {err}");
}
} else if matched.is_some() && is_marked {
let mut app = state.write().await;
if let Err(err) = app
.handle_input_restored(RecordingInputKind::Microphone)
.await
{
warn!("Failed to handle mic reconnection: {err}");
}
}
}
tokio::time::sleep(Duration::from_secs(1)).await;
}
});
}
fn spawn_camera_watcher(app_handle: AppHandle) {
tokio::spawn(async move {
let state = app_handle.state::<ArcLock<App>>();
let state = state.inner().clone();
loop {
if app_is_exiting(&app_handle) {
break;
}
if power_observer::is_system_asleep() {
tokio::time::sleep(Duration::from_secs(1)).await;
continue;
}
let (should_check, camera_id, is_marked) = {
let guard = state.read().await;
(
matches!(guard.recording_state, RecordingState::Active(_))
&& guard.camera_in_use,
guard.selected_camera_id.clone(),
guard
.disconnected_inputs
.contains(&RecordingInputKind::Camera),
)
};
if should_check && let Some(ref selected_id) = camera_id {
let Some(available) = run_while_active(
|| app_is_exiting(&app_handle),
|| is_camera_available(selected_id),
) else {
break;
};
debug!(
"Camera watcher: checking availability for {:?}, available={}, is_marked={}",
selected_id, available, is_marked
);
if !available && !is_marked {
warn!(
"Camera watcher: camera {:?} detected as unavailable, continuing recording without camera",
selected_id
);
let mut app = state.write().await;
if let Err(err) = app
.handle_input_disconnect(RecordingInputKind::Camera)
.await
{
warn!("Failed to handle camera disconnect: {err}");
}
} else if available && is_marked {
let mut app = state.write().await;
if let Err(err) = app.handle_input_restored(RecordingInputKind::Camera).await {
warn!("Failed to handle camera reconnection: {err}");
}
}
}
tokio::time::sleep(Duration::from_secs(1)).await;
}
});
}
pub(crate) fn is_camera_available(id: &DeviceOrModelID) -> bool {
let cameras: Vec<_> = cap_camera::list_cameras().collect();
debug!(
"is_camera_available: looking for {:?} in {} cameras",
id,
cameras.len()
);
for camera in &cameras {
debug!(
" - device_id={}, model_id={:?}, name={}",
camera.device_id(),
camera.model_id(),
camera.display_name()
);
}
cameras.iter().any(|info| match id {
DeviceOrModelID::DeviceID(device_id) => info.device_id() == device_id,
DeviceOrModelID::ModelID(model_id) => {
info.model_id().is_some_and(|existing| existing == model_id)
}
})
}
#[derive(specta::Type, Serialize, tauri_specta::Event, Clone)]
pub struct RecordingOptionsChanged;
#[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
pub struct NewStudioRecordingAdded {
path: PathBuf,
}
#[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
pub struct EditorRecordingAdded {
pub editor_path: PathBuf,
pub recording_path: PathBuf,
}
#[derive(Deserialize, specta::Type, tauri_specta::Event, Debug, Clone, Serialize)]
pub struct RecordingDeleted {
path: PathBuf,
}
#[derive(specta::Type, tauri_specta::Event, Serialize)]
pub struct SetCaptureAreaPending(bool);
#[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
pub struct NewScreenshotAdded {
path: PathBuf,
}
#[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
pub struct RecordingStarted;
#[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
pub struct RecordingStopped;
#[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
pub struct RequestStartRecording {
pub mode: RecordingMode,
}
#[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
pub struct RequestOpenRecordingPicker {
pub target_mode: Option<RecordingTargetMode>,
}
#[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
pub struct RequestSetTargetMode {
pub target_mode: Option<RecordingTargetMode>,
pub display_id: Option<String>,
}
#[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
pub struct RequestOpenSettings {
page: String,
}
#[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
pub struct RequestScrollToSettingsSection {
pub section: String,
}
#[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
pub struct RequestScreenCapturePrewarm {
#[serde(default)]
pub force: bool,
}
#[derive(Deserialize, specta::Type, Serialize, tauri_specta::Event, Debug, Clone)]
pub struct NewNotification {
title: String,
body: String,
is_error: bool,
}
type ArcLock<T> = Arc<RwLock<T>>;
pub type MutableState<'a, T> = State<'a, Arc<RwLock<T>>>;
#[cfg(target_os = "linux")]
pub enum ClipboardContext {
Platform(PlatformClipboardContext),
Wayland(AppHandle),
}
#[cfg(target_os = "linux")]
fn uses_wayland_clipboard_fallback(
wayland_display: Option<&std::ffi::OsStr>,
x11_display: Option<&std::ffi::OsStr>,
) -> bool {
wayland_display.is_some() && x11_display.is_none()
}
#[cfg(target_os = "linux")]
impl ClipboardContext {
fn new(app: &AppHandle) -> clipboard_rs::common::Result<Self> {
match PlatformClipboardContext::new() {
Ok(context) => Ok(Self::Platform(context)),
Err(error)
if uses_wayland_clipboard_fallback(
std::env::var_os("WAYLAND_DISPLAY").as_deref(),
std::env::var_os("DISPLAY").as_deref(),
) =>
{
info!(%error, "Using native Wayland clipboard");
Ok(Self::Wayland(app.clone()))
}
Err(error) => Err(error),
}
}
fn set_text(&self, text: String) -> clipboard_rs::common::Result<()> {
match self {
Self::Platform(context) => context.set_text(text),
Self::Wayland(app) => app.clipboard().write_text(text).map_err(Into::into),
}
}
fn set_image(&self, image: clipboard_rs::RustImageData) -> clipboard_rs::common::Result<()> {
match self {
Self::Platform(context) => context.set_image(image),
Self::Wayland(app) => {
let rgba = image.to_rgba8()?;
let width = rgba.width();
let height = rgba.height();
let image = tauri::image::Image::new_owned(rgba.into_raw(), width, height);
app.clipboard().write_image(&image).map_err(Into::into)
}
}
}
fn set_files(&self, files: Vec<String>) -> clipboard_rs::common::Result<()> {
match self {
Self::Platform(context) => context.set_files(files),
Self::Wayland(app) => {
let urls = files
.into_iter()
.map(|path| {
tauri::Url::from_file_path(&path)
.map(|url| url.to_string())
.map_err(|()| format!("Invalid clipboard file path: {path}"))
})
.collect::<Result<Vec<_>, _>>()?;
if urls.is_empty() {
return Err("No files supplied for clipboard".into());
}
app.clipboard()
.write_text(urls.join("\r\n"))
.map_err(Into::into)
}
}
}
}
type SingleTuple<T> = (T,);
#[derive(Serialize, Type)]
struct JsonValue<T>(
#[serde(skip)] PhantomData<T>,
#[specta(type = SingleTuple<T>)] serde_json::Value,
);
impl<T> Clone for JsonValue<T> {
fn clone(&self) -> Self {
Self(PhantomData, self.1.clone())
}
}
impl<T: Serialize> JsonValue<T> {
fn new(value: &T) -> Self {
Self(PhantomData, json!(value))
}
}
#[derive(Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RecordingInfo {
capture_target: ScreenCaptureTarget,
}
#[derive(Serialize, Type)]
#[serde(rename_all = "camelCase")]
enum CurrentRecordingTarget {
Window {
id: WindowId,
bounds: Option<LogicalBounds>,
},
Screen {
id: DisplayId,
},
Area {
screen: DisplayId,
bounds: LogicalBounds,
},
Camera,
}
#[derive(Serialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum RecordingStatus {
Pending,
Recording,
}
#[derive(Serialize, Type)]
#[serde(rename_all = "camelCase")]
struct CurrentRecording {
target: CurrentRecordingTarget,
mode: RecordingMode,
status: RecordingStatus,
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(state))]
async fn get_current_recording(
state: MutableState<'_, App>,
) -> Result<JsonValue<Option<CurrentRecording>>, ()> {
let state = state.read().await;
let (mode, capture_target, status) = match &state.recording_state {
RecordingState::None => {
return Ok(JsonValue::new(&None));
}
RecordingState::Pending { mode, target } => (*mode, target, RecordingStatus::Pending),
RecordingState::Active(inner) => (
inner.mode(),
inner.capture_target(),
RecordingStatus::Recording,
),
};
let target = match capture_target {
ScreenCaptureTarget::Display { id } => CurrentRecordingTarget::Screen { id: id.clone() },
ScreenCaptureTarget::Window { id } => {
let bounds =
scap_targets::Window::from_id(id).and_then(|w| w.display_relative_logical_bounds());
CurrentRecordingTarget::Window {
id: id.clone(),
bounds,
}
}
ScreenCaptureTarget::Area { screen, bounds } => CurrentRecordingTarget::Area {
screen: screen.clone(),
bounds: *bounds,
},
ScreenCaptureTarget::CameraOnly => CurrentRecordingTarget::Camera,
};
Ok(JsonValue::new(&Some(CurrentRecording {
target,
mode,
status,
})))
}
#[derive(Serialize, Type, tauri_specta::Event, Clone)]
pub struct CurrentRecordingChanged;
pub(crate) async fn create_screenshot(
input: PathBuf,
output: PathBuf,
size: Option<(u32, u32)>,
) -> Result<(), String> {
let result: Result<(), String> = tokio::task::spawn_blocking(move || -> Result<(), String> {
let mut ictx = ffmpeg::format::input(&input).map_err(|e| e.to_string())?;
let input_stream = ictx
.streams()
.best(ffmpeg::media::Type::Video)
.ok_or("No video stream found")?;
let video_stream_index = input_stream.index();
let mut decoder =
ffmpeg::codec::context::Context::from_parameters(input_stream.parameters())
.map_err(|e| e.to_string())?
.decoder()
.video()
.map_err(|e| e.to_string())?;
let mut scaler = ffmpeg::software::scaling::context::Context::get(
decoder.format(),
decoder.width(),
decoder.height(),
ffmpeg::format::Pixel::RGB24,
size.map_or(decoder.width(), |s| s.0),
size.map_or(decoder.height(), |s| s.1),
ffmpeg::software::scaling::flag::Flags::BILINEAR,
)
.map_err(|e| e.to_string())?;
let mut frame = ffmpeg::frame::Video::empty();
for (stream, packet) in ictx.packets() {
if stream.index() == video_stream_index {
decoder.send_packet(&packet).map_err(|e| e.to_string())?;
if decoder.receive_frame(&mut frame).is_ok() {
let mut rgb_frame = ffmpeg::frame::Video::empty();
scaler
.run(&frame, &mut rgb_frame)
.map_err(|e| e.to_string())?;
let width = rgb_frame.width() as usize;
let height = rgb_frame.height() as usize;
let bytes_per_pixel = 3;
let src_stride = rgb_frame.stride(0);
let dst_stride = width * bytes_per_pixel;
let mut img_buffer = vec![0u8; height * dst_stride];
for y in 0..height {
let src_slice =
&rgb_frame.data(0)[y * src_stride..y * src_stride + dst_stride];
let dst_slice = &mut img_buffer[y * dst_stride..(y + 1) * dst_stride];
dst_slice.copy_from_slice(src_slice);
}
let img = image::RgbImage::from_raw(width as u32, height as u32, img_buffer)
.ok_or("Failed to create image from frame data")?;
img.save_with_format(&output, image::ImageFormat::Jpeg)
.map_err(|e| e.to_string())?;
return Ok(());
}
}
}
Err("Failed to create screenshot".to_string())
})
.await
.map_err(|e| format!("Task join error: {e}"))?;
result
}
pub(crate) async fn create_screenshot_source_from_segments(
segments_dir: &std::path::Path,
) -> Result<PathBuf, String> {
let init_path = segments_dir.join("init.mp4");
if !init_path.exists() {
return Err(format!("init.mp4 not found in {}", segments_dir.display()));
}
let first_segment = find_first_segment(segments_dir)
.ok_or_else(|| format!("No .m4s segments found in {}", segments_dir.display()))?;
let temp_path = segments_dir.join(".screenshot_source.mp4");
let mut out = tokio::fs::File::create(&temp_path)
.await
.map_err(|e| format!("Failed to create screenshot source: {e}"))?;
let mut init_file = tokio::fs::File::open(&init_path)
.await
.map_err(|e| format!("Failed to open init.mp4: {e}"))?;
tokio::io::copy(&mut init_file, &mut out)
.await
.map_err(|e| format!("Failed to copy init.mp4: {e}"))?;
let mut seg_file = tokio::fs::File::open(&first_segment)
.await
.map_err(|e| format!("Failed to open {}: {e}", first_segment.display()))?;
tokio::io::copy(&mut seg_file, &mut out)
.await
.map_err(|e| format!("Failed to copy segment: {e}"))?;
Ok(temp_path)
}
fn find_first_segment(dir: &std::path::Path) -> Option<PathBuf> {
let mut segments: Vec<PathBuf> = std::fs::read_dir(dir)
.ok()?
.filter_map(|e| {
let path = e.ok()?.path();
if path.extension().is_some_and(|ext| ext == "m4s") {
Some(path)
} else {
None
}
})
.collect();
segments.sort();
segments.into_iter().next()
}
// async fn create_thumbnail(input: PathBuf, output: PathBuf, size: (u32, u32)) -> Result<(), String> {
// println!("Creating thumbnail: input={input:?}, output={output:?}, size={size:?}");
// tokio::task::spawn_blocking(move || -> Result<(), String> {
// let img = image::open(&input).map_err(|e| {
// eprintln!("Failed to open image: {e}");
// e.to_string()
// })?;
// let width = img.width() as usize;
// let height = img.height() as usize;
// let bytes_per_pixel = 3;
// let src_stride = width * bytes_per_pixel;
// let rgb_img = img.to_rgb8();
// let img_buffer = rgb_img.as_raw();
// let mut corrected_buffer = vec![0u8; height * src_stride];
// for y in 0..height {
// let src_slice = &img_buffer[y * src_stride..(y + 1) * src_stride];
// let dst_slice = &mut corrected_buffer[y * src_stride..(y + 1) * src_stride];
// dst_slice.copy_from_slice(src_slice);
// }
// let corrected_img =
// image::RgbImage::from_raw(width as u32, height as u32, corrected_buffer)
// .ok_or("Failed to create corrected image")?;
// let thumbnail = image::imageops::resize(
// &corrected_img,
// size.0,
// size.1,
// image::imageops::FilterType::Lanczos3,
// );
// thumbnail
// .save_with_format(&output, image::ImageFormat::Png)
// .map_err(|e| {
// eprintln!("Failed to save thumbnail: {e}");
// e.to_string()
// })?;
// println!("Thumbnail created successfully");
// Ok(())
// })
// .await
// .map_err(|e| format!("Task join error: {e}"))?
// }
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn copy_file_to_path(app: AppHandle, src: String, dst: String) -> Result<(), String> {
run_command_safely("copy_file_to_path", copy_file_to_path_inner(app, src, dst)).await
}
async fn copy_file_to_path_inner(app: AppHandle, src: String, dst: String) -> Result<(), String> {
info!(%src, %dst, "Attempting to copy file");
let is_screenshot = src.contains("screenshots/");
let is_gif = src.ends_with(".gif") || dst.ends_with(".gif");
let src_path = std::path::Path::new(&src);
if !src_path.exists() {
return Err(format!("Source file {src} does not exist"));
}
if !is_screenshot && !is_gif && !is_valid_video(src_path) {
let mut attempts = 0;
while attempts < 10 {
// Replaced `std::thread::sleep` with `tokio::time::sleep` — the previous version
// blocked the tokio worker for up to 10 seconds, which on release builds with
// smaller worker pools could starve the runtime and cause unrelated tasks to time
// out (including window/IPC events).
tokio::time::sleep(std::time::Duration::from_secs(1)).await;
if is_valid_video(src_path) {
break;
}
attempts += 1;
}
if attempts == 10 {
return Err("Source video file is not a valid MP4".to_string());
}
}
if let Some(parent) = std::path::Path::new(&dst).parent() {
tokio::fs::create_dir_all(parent)
.await
.map_err(|e| format!("Failed to create target directory: {e}"))?;
}
let mut attempts = 0;
const MAX_ATTEMPTS: u32 = 3;
let mut last_error = None;
while attempts < MAX_ATTEMPTS {
match tokio::fs::copy(&src, &dst).await {
Ok(bytes) => {
let src_size = match tokio::fs::metadata(&src).await {
Ok(metadata) => metadata.len(),
Err(e) => {
last_error = Some(format!("Failed to get source file metadata: {e}"));
attempts += 1;
tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
continue;
}
};
if bytes != src_size {
last_error = Some(format!(
"File copy verification failed: copied {bytes} bytes but source is {src_size} bytes"
));
let _ = tokio::fs::remove_file(&dst).await;
attempts += 1;
tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
continue;
}
if !is_screenshot && !is_gif && !is_valid_video(std::path::Path::new(&dst)) {
last_error = Some("Destination file is not a valid".to_string());
let _ = tokio::fs::remove_file(&dst).await;
attempts += 1;
tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
continue;
}
info!(bytes, %src, %dst, "Successfully copied file");
notifications::send_notification(
&app,
if is_screenshot {
notifications::NotificationType::ScreenshotSaved
} else {
notifications::NotificationType::VideoSaved
},
);
return Ok(());
}
Err(e) => {
last_error = Some(e.to_string());
attempts += 1;
if attempts < MAX_ATTEMPTS {
tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
continue;
}
}
}
}
let last_error_message = last_error
.as_deref()
.unwrap_or("Maximum retry attempts exceeded");
error!(
%src,
%dst,
attempts = MAX_ATTEMPTS,
error = %last_error_message,
"Failed to copy file after retries"
);
notifications::send_notification(
&app,
if is_screenshot {
notifications::NotificationType::ScreenshotSaveFailed
} else {
notifications::NotificationType::VideoSaveFailed
},
);
Err(last_error.unwrap_or_else(|| "Maximum retry attempts exceeded".to_string()))
}
pub fn is_valid_video(path: &std::path::Path) -> bool {
match ffmpeg::format::input(path) {
Ok(input_context) => {
// Check if we have at least one video stream
input_context
.streams()
.any(|stream| stream.parameters().medium() == ffmpeg::media::Type::Video)
}
Err(_) => false,
}
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(clipboard))]
async fn copy_screenshot_to_clipboard(
clipboard: MutableState<'_, ClipboardContext>,
path: String,
) -> Result<(), String> {
println!("Copying screenshot to clipboard: {path:?}");
let img_data = clipboard_rs::RustImageData::from_path(&path)
.map_err(|e| format!("Failed to copy screenshot to clipboard: {e}"))?;
clipboard
.write()
.await
.set_image(img_data)
.map_err(|err| format!("Failed to copy screenshot to clipboard: {err}"))?;
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(clipboard, data))]
async fn copy_image_to_clipboard(
clipboard: MutableState<'_, ClipboardContext>,
data: Vec<u8>,
) -> Result<(), String> {
println!("Copying image to clipboard ({} bytes)", data.len());
let img_data = clipboard_rs::RustImageData::from_bytes(&data)
.map_err(|e| format!("Failed to create image data from bytes: {e}"))?;
clipboard
.write()
.await
.set_image(img_data)
.map_err(|err| format!("Failed to copy image to clipboard: {err}"))?;
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(clipboard, instance))]
async fn copy_rendered_screenshot_to_clipboard(
clipboard: MutableState<'_, ClipboardContext>,
instance: WindowScreenshotEditorInstance,
) -> Result<(), String> {
let data = render_screenshot_png(&instance).await?;
let img_data = clipboard_rs::RustImageData::from_bytes(&data)
.map_err(|e| format!("Failed to create image data from bytes: {e}"))?;
clipboard
.write()
.await
.set_image(img_data)
.map_err(|err| format!("Failed to copy image to clipboard: {err}"))?;
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(_app))]
async fn open_file_path(_app: AppHandle, path: PathBuf) -> Result<(), String> {
let path_str = path.to_str().ok_or("Invalid path")?;
let is_dir = path.is_dir();
#[cfg(target_os = "windows")]
{
if is_dir {
Command::new("explorer")
.arg(path_str)
.spawn()
.map_err(|e| format!("Failed to open folder: {e}"))?;
} else {
Command::new("explorer")
.args(["/select,", path_str])
.spawn()
.map_err(|e| format!("Failed to open folder: {e}"))?;
}
}
#[cfg(target_os = "macos")]
{
if is_dir {
Command::new("open")
.arg(path_str)
.spawn()
.map_err(|e| format!("Failed to open folder: {e}"))?;
} else {
Command::new("open")
.arg("-R")
.arg(path_str)
.spawn()
.map_err(|e| format!("Failed to open folder: {e}"))?;
}
}
#[cfg(target_os = "linux")]
{
if is_dir {
Command::new("xdg-open")
.arg(path_str)
.spawn()
.map_err(|e| format!("Failed to open folder: {e}"))?;
} else {
Command::new("xdg-open")
.arg(
path.parent()
.ok_or("Invalid path")?
.to_str()
.ok_or("Invalid path")?,
)
.spawn()
.map_err(|e| format!("Failed to open folder: {e}"))?;
}
}
Ok(())
}
/// The opener's Linux backend makes blocking zbus calls, which panic inside an async task.
pub(crate) async fn reveal_in_dir(app: AppHandle, path: PathBuf) -> Result<(), String> {
cap_utils::run_on_dedicated_thread("reveal-item-in-dir", move || {
app.opener().reveal_item_in_dir(path)
})
.await
.map_err(|e| e.to_string())?
.map_err(|e| e.to_string())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn reveal_item_in_dir(app: AppHandle, path: PathBuf) -> Result<(), String> {
reveal_in_dir(app, path)
.await
.map_err(|e| format!("Failed to reveal item: {e}"))
}
#[derive(Deserialize, specta::Type, tauri_specta::Event, Debug, Clone)]
struct RenderFrameEvent {
frame_number: u32,
fps: u32,
resolution_base: XY<u32>,
}
#[derive(Serialize, specta::Type, tauri_specta::Event, Debug, Clone)]
struct EditorStateChanged {
playhead_position: u32,
}
/// Rendered display/camera placement of the latest preview frame, in
/// output-frame pixels — consumed by the editor's on-canvas layout overlay.
#[derive(Serialize, specta::Type, tauri_specta::Event, Debug, Clone, PartialEq)]
pub(crate) struct FrameLayoutEvent {
display: [f32; 4],
camera: Option<[f32; 4]>,
output_width: u32,
output_height: u32,
}
impl From<cap_editor::FrameLayout> for FrameLayoutEvent {
fn from(layout: cap_editor::FrameLayout) -> Self {
Self {
display: layout.display,
camera: layout.camera,
output_width: layout.output_size[0],
output_height: layout.output_size[1],
}
}
}
impl EditorStateChanged {
fn new(s: &EditorState) -> Self {
Self {
playhead_position: s.playhead_position,
}
}
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(editor_instance))]
async fn start_playback(
editor_instance: WindowEditorInstance,
fps: u32,
resolution_base: XY<u32>,
) -> Result<(), String> {
editor_instance.start_playback(fps, resolution_base).await;
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(editor_instance))]
async fn stop_playback(editor_instance: WindowEditorInstance) -> Result<(), String> {
let mut state = editor_instance.state.lock().await;
if let Some(handle) = state.playback_task.take() {
handle.stop();
}
Ok(())
}
#[tauri::command]
#[specta::specta]
async fn commit_editor_preparing_frame(
editor_instance: WindowEditorInstance,
instance_id: String,
frame_number: u32,
fps: u32,
) -> Result<bool, String> {
editor_instance.commit_preparing_frame(&instance_id, frame_number, fps)
}
#[tauri::command]
#[specta::specta]
async fn start_editor_handoff_playback(
editor_instance: WindowEditorInstance,
instance_id: String,
frame_number: u32,
fps: u32,
resolution_base: XY<u32>,
) -> Result<String, String> {
editor_instance
.start_handoff_playback(&instance_id, frame_number, fps, resolution_base)
.await
}
#[tauri::command]
#[specta::specta]
async fn stop_editor_handoff_playback(
editor_instance: WindowEditorInstance,
instance_id: String,
playback_id: String,
) -> Result<(), String> {
editor_instance
.stop_handoff_playback(&instance_id, &playback_id)
.await
}
#[derive(Serialize, Type, Debug)]
#[serde(rename_all = "camelCase")]
struct SerializedEditorInstance {
instance_id: String,
preparing_playback: bool,
frames_socket_url: String,
preparing_snapshot: Option<editor_preparing::PreparingEditorChanged>,
recording_duration: f64,
saved_project_config: ProjectConfiguration,
recordings: Arc<ProjectRecordingsMeta>,
path: PathBuf,
/// Notch geometry the overlay uses when the project sets no manual
/// placement: this recording's own measurements where the recorder took
/// them, else a stock MacBook notch for the editor to start from.
notch_base: cap_project::DisplayNotch,
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(window))]
async fn create_editor_instance(window: Window) -> Result<SerializedEditorInstance, String> {
let CapWindowId::Editor { id } =
CapWindowId::from_str(window.label()).map_err(|e| e.to_string())?
else {
return Err("Invalid window".to_string());
};
let path = {
let window_ids = EditorWindowIds::get(window.app_handle());
let window_ids = window_ids.ids.lock().unwrap();
let Some((path, _)) = window_ids.iter().find(|(_, _id)| *_id == id) else {
return Err("Editor instance not found".to_string());
};
path.clone()
};
let editor_instance = EditorInstances::get_or_create(&window, path).await?;
Ok(SerializedEditorInstance {
instance_id: editor_instance.instance_id.to_string(),
preparing_playback: editor_instance.preparing_adoption().is_some(),
preparing_snapshot: window
.state::<editor_preparing::PreparingConsumers>()
.snapshot_for_window(id),
frames_socket_url: format!("ws://localhost:{}", editor_instance.ws_port),
recording_duration: editor_instance.recordings.duration(),
saved_project_config: {
let project_config = editor_instance.project_config.1.borrow();
project_config.clone()
},
recordings: editor_instance.recordings.clone(),
path: editor_instance.project_path.clone(),
notch_base: editor_instance
.render_constants
.meta
.display_notch()
.unwrap_or(cap_project::DEFAULT_MACBOOK_NOTCH),
})
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(window))]
async fn get_editor_project_path(window: Window) -> Result<PathBuf, String> {
let CapWindowId::Editor { id } =
CapWindowId::from_str(window.label()).map_err(|e| e.to_string())?
else {
return Err("Invalid window".to_string());
};
let window_ids = EditorWindowIds::get(window.app_handle());
let window_ids = window_ids.ids.lock().unwrap();
let Some((path, _)) = window_ids.iter().find(|(_, _id)| *_id == id) else {
return Err("Editor instance not found".to_string());
};
Ok(path.clone())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(editor))]
async fn get_editor_meta(editor: WindowEditorInstance) -> Result<RecordingMeta, String> {
let path = editor.project_path.clone();
RecordingMeta::load_for_project(&path).map_err(|e| e.to_string())
}
#[tauri::command]
#[specta::specta]
async fn get_recording_meta_by_path(project_path: PathBuf) -> Result<RecordingMeta, String> {
RecordingMeta::load_for_project(&project_path).map_err(|e| e.to_string())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(editor))]
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]
#[instrument(skip(app, clipboard))]
async fn copy_video_to_clipboard(
app: AppHandle,
clipboard: MutableState<'_, ClipboardContext>,
path: String,
) -> Result<(), String> {
println!("copying");
let _ = clipboard.write().await.set_files(vec![path]);
notifications::send_notification(
&app,
notifications::NotificationType::VideoCopiedToClipboard,
);
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument]
async fn get_video_metadata(path: PathBuf) -> Result<VideoRecordingMetadata, String> {
let recording_meta = RecordingMeta::load_for_project(&path).map_err(|v| v.to_string())?;
fn get_duration_for_path(path: PathBuf) -> Result<f64, String> {
let input =
ffmpeg::format::input(&path).map_err(|e| format!("Failed to open video file: {e}"))?;
let raw_duration = input.duration();
if raw_duration <= 0 {
return Err(format!(
"Unknown or invalid duration for video file: {path:?}"
));
}
let duration = raw_duration as f64 / AV_TIME_BASE as f64;
Ok(duration)
}
let display_paths = match &recording_meta.inner {
RecordingMetaInner::Instant(_) => {
vec![path.join("content/output.mp4")]
}
RecordingMetaInner::Studio(meta) => {
let status = meta.status();
if let StudioRecordingStatus::Failed { .. } = status {
return Err("Unable to get metadata on failed recording".to_string());
} else if let StudioRecordingStatus::InProgress = status {
return Err("Unable to get metadata on in-progress recording".to_string());
}
match &**meta {
StudioRecordingMeta::SingleSegment { segment } => {
vec![recording_meta.path(&segment.display.path)]
}
StudioRecordingMeta::MultipleSegments { inner } => inner
.segments
.iter()
.map(|s| recording_meta.path(&s.display.path))
.collect(),
}
}
};
let duration = display_paths
.into_iter()
.map(get_duration_for_path)
.try_fold(0f64, |acc, item| -> Result<f64, String> {
let d = item?;
Ok(acc + d)
})?;
let (width, height) = (1920, 1080);
let fps = 30;
let base_bitrate = if width <= 1280 && height <= 720 {
4_000_000.0
} else if width <= 1920 && height <= 1080 {
8_000_000.0
} else if width <= 2560 && height <= 1440 {
14_000_000.0
} else {
20_000_000.0
};
let fps_factor = (fps as f64) / 30.0;
let video_bitrate = base_bitrate * fps_factor;
let audio_bitrate = 192_000.0;
let total_bitrate = video_bitrate + audio_bitrate;
let estimated_size_mb = (total_bitrate * duration) / (8.0 * 1024.0 * 1024.0);
Ok(VideoRecordingMetadata {
size: estimated_size_mb,
duration,
})
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
fn close_recordings_overlay_window(app: AppHandle) {
#[cfg(target_os = "macos")]
{
let app_for_close = app.clone();
app.run_on_main_thread(move || {
use tauri_nspanel::ManagerExt;
if let Ok(panel) =
app_for_close.get_webview_panel(&CapWindowId::RecordingsOverlay.label())
{
panel.released_when_closed(false);
panel.close();
}
})
.ok();
}
if !cfg!(target_os = "macos")
&& let Some(window) = CapWindowId::RecordingsOverlay.get(&app)
{
let _ = window.close();
}
}
#[tauri::command(async)]
#[specta::specta]
#[instrument(skip(_app))]
fn focus_captures_panel(_app: AppHandle) {
#[cfg(target_os = "macos")]
{
let app_for_focus = _app.clone();
_app.run_on_main_thread(move || {
use tauri_nspanel::ManagerExt;
if let Ok(panel) =
app_for_focus.get_webview_panel(&CapWindowId::RecordingsOverlay.label())
{
panel.make_key_window();
}
})
.ok();
}
}
#[derive(Serialize, Deserialize, specta::Type, Clone)]
#[serde(tag = "type", rename_all = "camelCase")]
pub struct FramesRendered {
rendered_count: u32,
total_frames: u32,
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(editor_instance))]
async fn set_playhead_position(
editor_instance: WindowEditorInstance,
frame_number: u32,
) -> Result<(), String> {
editor_instance
.modify_and_emit_state(|state| {
state.playhead_position = frame_number;
})
.await;
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(editor_instance))]
async fn set_project_config(
editor_instance: WindowEditorInstance,
config: ProjectConfiguration,
) -> Result<(), String> {
editor_instance.project_config.0.send(config.clone()).ok();
config
.write(&editor_instance.project_path)
.map_err(|error| format!("Failed to write project config: {error}"))?;
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(editor_instance))]
async fn update_project_config_in_memory(
editor_instance: WindowEditorInstance,
config: ProjectConfiguration,
frame_number: Option<u32>,
fps: Option<u32>,
resolution_base: Option<XY<u32>>,
) -> Result<(), String> {
editor_instance.project_config.0.send(config).ok();
if let (Some(frame), Some(f), Some(res)) = (frame_number, fps, resolution_base) {
editor_instance.preview_tx.send_modify(|v| {
*v = Some((frame, f, res));
});
}
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app, editor_instance))]
async fn generate_zoom_segments_from_clicks(
app: AppHandle,
editor_instance: WindowEditorInstance,
) -> Result<Vec<ZoomSegment>, String> {
let meta = editor_instance.meta();
let recordings = &editor_instance.recordings;
let zoom_amount = GeneralSettingsStore::get(&app)
.ok()
.flatten()
.and_then(|settings| settings.default_zoom_amount)
.unwrap_or(recording::DEFAULT_AUTO_ZOOM_AMOUNT);
let zoom_segments =
recording::generate_zoom_segments_for_project(meta, recordings, zoom_amount);
Ok(zoom_segments)
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(editor_instance))]
async fn generate_keyboard_segments(
editor_instance: WindowEditorInstance,
grouping_threshold_ms: f64,
linger_duration_ms: f64,
show_modifiers: bool,
show_special_keys: bool,
) -> Result<Vec<cap_project::KeyboardTrackSegment>, String> {
let project = editor_instance.project_config.1.borrow().clone();
let Some(timeline) = project.timeline else {
return Ok(Vec::new());
};
let settings = cap_project::KeyboardSettings {
grouping_threshold_ms,
linger_duration: (linger_duration_ms / 1000.0) as f32,
show_modifiers,
show_special_keys,
..Default::default()
};
let meta = editor_instance.meta().clone();
tokio::task::spawn_blocking(move || {
cap_project::generate_project_keyboard_segments(&meta, &timeline, &settings)
})
.await
.map_err(|error| format!("Keyboard generation failed: {error}"))?
}
#[tauri::command]
#[specta::specta]
#[instrument]
async fn list_audio_devices() -> Result<Vec<String>, ()> {
if !permissions::do_permissions_check(false)
.microphone
.permitted()
{
return Ok(vec![]);
}
Ok(MicrophoneFeed::list_names())
}
#[tauri::command]
#[specta::specta]
#[instrument]
async fn list_system_fonts() -> Vec<String> {
tokio::task::spawn_blocking(cap_rendering::system_font_families)
.await
.unwrap_or_default()
}
#[derive(Serialize, Type, Debug, Clone)]
pub struct UploadProgress {
progress: f64,
}
#[derive(Debug, Deserialize, Type)]
pub enum UploadMode {
Initial {
pre_created_video: Option<VideoUploadInfo>,
},
Reupload,
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app, channel))]
async fn upload_exported_video(
app: AppHandle,
path: PathBuf,
mode: UploadMode,
channel: Channel<UploadProgress>,
organization_id: Option<String>,
) -> Result<UploadResult, String> {
let Ok(Some(auth)) = AuthStore::get(&app) else {
AuthStore::set(&app, None).map_err(|e| e.to_string())?;
return Ok(UploadResult::NotAuthenticated);
};
let mut meta = RecordingMeta::load_for_project(&path).map_err(|v| v.to_string())?;
if matches!(meta.inner, RecordingMetaInner::Instant(_)) {
match upload::lifecycle::retry_existing(app.clone(), &path).await {
Ok(Some(link)) => return Ok(UploadResult::Success(link)),
Ok(None) => {}
Err(AuthedApiError::InvalidAuthentication) => {
return Ok(UploadResult::NotAuthenticated);
}
Err(error) => return Err(error.to_string()),
}
}
let file_path = meta.output_path();
if !file_path.exists() {
notifications::send_notification(&app, notifications::NotificationType::UploadFailed);
return Err("Failed to upload video: Rendered video not found".to_string());
}
let metadata = build_video_meta(&file_path)
.map_err(|err| format!("Error getting output video meta: {err}"))?;
if !auth.is_upgraded() && metadata.duration_in_secs > 300.0 {
return Ok(UploadResult::UpgradeRequired);
}
channel.send(UploadProgress { progress: 0.0 }).ok();
let existing_video_id = upload::reusable_video_id(meta.sharing.as_ref(), meta.upload.as_ref());
let s3_config = match async {
let video_id = match mode {
UploadMode::Initial { pre_created_video } => {
if let Some(video_id) = existing_video_id.clone() {
Some(video_id)
} else if let Some(pre_created) = pre_created_video {
return Ok(pre_created.config);
} else {
None
}
}
UploadMode::Reupload => {
let Some(sharing) = meta.sharing.clone() else {
return Err("No sharing metadata found".into());
};
Some(sharing.id)
}
};
create_or_get_video(
&app,
false,
video_id,
Some(meta.pretty_name.clone()),
Some(metadata.clone()),
organization_id,
)
.await
}
.await
{
Ok(data) => data,
Err(AuthedApiError::InvalidAuthentication) => return Ok(UploadResult::NotAuthenticated),
Err(AuthedApiError::UpgradeRequired) => return Ok(UploadResult::UpgradeRequired),
Err(err) => return Err(err.to_string()),
};
if existing_video_id
.as_ref()
.is_some_and(|video_id| *video_id != s3_config.id)
{
return Err("Server did not preserve the existing share link".into());
}
let screenshot_path = meta.project_path.join("screenshots/display.jpg");
meta.upload = Some(UploadMeta::SinglePartUpload {
video_id: s3_config.id.clone(),
file_path: file_path.clone(),
screenshot_path: screenshot_path.clone(),
recording_dir: path.clone(),
});
meta.save_for_project()
.map_err(|error| format!("Failed to persist upload state: {error}"))?;
match upload_video(
&app,
s3_config.id.clone(),
file_path,
screenshot_path,
meta.sharing.is_some(),
Some(channel.clone()),
)
.await
{
Ok(uploaded_video) => {
channel.send(UploadProgress { progress: 1.0 }).ok();
let link = meta
.sharing
.as_ref()
.map(|sharing| sharing.link.clone())
.unwrap_or(uploaded_video.link);
meta.upload = Some(UploadMeta::Complete);
meta.sharing = Some(SharingMeta {
link: link.clone(),
id: uploaded_video.id.clone(),
content_hash: None,
});
meta.save_for_project()
.map_err(|error| format!("Failed to persist sharing state: {error}"))?;
let _ = app
.state::<ArcLock<ClipboardContext>>()
.write()
.await
.set_text(link.clone());
NotificationType::ShareableLinkCopied.send(&app);
Ok(UploadResult::Success(link))
}
Err(AuthedApiError::UpgradeRequired) => Ok(UploadResult::UpgradeRequired),
Err(e) => {
error!("Failed to upload video: {e}");
NotificationType::UploadFailed.send(&app);
meta.upload = Some(UploadMeta::Failed {
error: e.to_string(),
});
meta.save_for_project()
.map_err(|e| error!("Failed to save recording meta: {e}"))
.ok();
Err(e.to_string())
}
}
}
fn screenshot_project_path_from_path(path: &std::path::Path) -> Option<PathBuf> {
path.ancestors()
.find(|ancestor| ancestor.extension().and_then(|s| s.to_str()) == Some("cap"))
.map(std::path::Path::to_path_buf)
}
fn load_screenshot_project_meta(
path: &std::path::Path,
) -> Result<(PathBuf, RecordingMeta), String> {
let project_path = screenshot_project_path_from_path(path)
.ok_or_else(|| format!("Could not find screenshot project for {}", path.display()))?;
let meta = RecordingMeta::load_for_project(&project_path)
.map_err(|err| format!("Failed to load screenshot metadata: {err}"))?;
Ok((project_path, meta))
}
fn save_screenshot_sharing(
project_path: &std::path::Path,
mut meta: RecordingMeta,
uploaded: &upload::UploadedItem,
content_hash: Option<String>,
) -> Result<(), String> {
meta.sharing = Some(SharingMeta {
link: uploaded.link.clone(),
id: uploaded.id.clone(),
content_hash,
});
meta.save_for_project()
.map_err(|err| format!("Error saving project {}: {err}", project_path.display()))
}
#[derive(Serialize, Type, Debug)]
#[serde(rename_all = "camelCase")]
struct ScreenshotSharingState {
link: String,
content_hash: Option<String>,
}
#[derive(Serialize, Type, Debug)]
#[serde(rename_all = "camelCase")]
struct ScreenshotProjectShareState {
config: ProjectConfiguration,
sharing: Option<ScreenshotSharingState>,
}
async fn copy_screenshot_share_link(
clipboard: &MutableState<'_, ClipboardContext>,
link: String,
app: &AppHandle,
) -> Result<(), String> {
let _ = clipboard.write().await.set_text(link);
notifications::send_notification(app, notifications::NotificationType::ShareableLinkCopied);
Ok(())
}
fn screenshot_share_link_for_hash(
sharing: Option<&SharingMeta>,
content_hash: &str,
) -> Option<String> {
let sharing = sharing?;
if sharing.content_hash.as_deref() == Some(content_hash) {
return Some(sharing.link.clone());
}
None
}
async fn upgrade_required_result(app: &AppHandle) -> UploadResult {
if let Err(error) = open_pricing_page(app).await {
warn!(%error, "Failed to open pricing page");
}
UploadResult::UpgradeRequired
}
#[tauri::command]
#[specta::specta]
fn get_screenshot_project_share_state(
path: PathBuf,
) -> Result<ScreenshotProjectShareState, String> {
let (project_path, meta) = load_screenshot_project_meta(&path)?;
let config = ProjectConfiguration::load(&project_path)
.map_err(|err| format!("Failed to load screenshot config: {err}"))?;
let sharing = meta.sharing.map(|sharing| ScreenshotSharingState {
link: sharing.link,
content_hash: sharing.content_hash,
});
Ok(ScreenshotProjectShareState { config, sharing })
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app, clipboard))]
async fn copy_current_screenshot_share_link(
app: AppHandle,
clipboard: MutableState<'_, ClipboardContext>,
project_path: PathBuf,
content_hash: String,
) -> Result<Option<UploadResult>, String> {
let (_, meta) = load_screenshot_project_meta(&project_path)?;
let Some(link) = screenshot_share_link_for_hash(meta.sharing.as_ref(), &content_hash) else {
return Ok(None);
};
copy_screenshot_share_link(&clipboard, link.clone(), &app).await?;
Ok(Some(UploadResult::Success(link)))
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app, clipboard))]
async fn upload_screenshot(
app: AppHandle,
clipboard: MutableState<'_, ClipboardContext>,
screenshot_path: PathBuf,
) -> Result<UploadResult, String> {
let Ok(Some(auth)) = AuthStore::get(&app) else {
AuthStore::set(&app, None).map_err(|e| e.to_string())?;
return Ok(UploadResult::NotAuthenticated);
};
if !auth.is_upgraded() {
return Ok(upgrade_required_result(&app).await);
}
println!("Uploading screenshot: {screenshot_path:?}");
let (project_path, meta) = load_screenshot_project_meta(&screenshot_path)?;
if let Some(sharing) = meta.sharing.as_ref() {
copy_screenshot_share_link(&clipboard, sharing.link.clone(), &app).await?;
return Ok(UploadResult::Success(sharing.link.clone()));
}
let uploaded = match upload_screenshot_file(&app, screenshot_path.clone(), None, None).await {
Ok(uploaded) => uploaded,
Err(AuthedApiError::InvalidAuthentication) => return Ok(UploadResult::NotAuthenticated),
Err(AuthedApiError::UpgradeRequired) => return Ok(upgrade_required_result(&app).await),
Err(e) => return Err(e.to_string()),
};
save_screenshot_sharing(&project_path, meta, &uploaded, None)?;
println!("Copying to clipboard: {:?}", uploaded.link);
copy_screenshot_share_link(&clipboard, uploaded.link.clone(), &app).await?;
Ok(UploadResult::Success(uploaded.link))
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app, clipboard, image_bytes))]
async fn upload_rendered_screenshot(
app: AppHandle,
clipboard: MutableState<'_, ClipboardContext>,
image_bytes: Vec<u8>,
content_type: String,
project_path: PathBuf,
content_hash: Option<String>,
) -> Result<UploadResult, String> {
let Ok(Some(auth)) = AuthStore::get(&app) else {
AuthStore::set(&app, None).map_err(|e| e.to_string())?;
return Ok(UploadResult::NotAuthenticated);
};
if !auth.is_upgraded() {
return Ok(upgrade_required_result(&app).await);
}
let (project_path, meta) = load_screenshot_project_meta(&project_path)?;
let existing_video_id = meta.sharing.as_ref().map(|sharing| sharing.id.clone());
let uploaded =
match upload_screenshot_bytes(&app, image_bytes, &content_type, existing_video_id, None)
.await
{
Ok(uploaded) => uploaded,
Err(AuthedApiError::InvalidAuthentication) => {
return Ok(UploadResult::NotAuthenticated);
}
Err(AuthedApiError::UpgradeRequired) => return Ok(upgrade_required_result(&app).await),
Err(e) => return Err(e.to_string()),
};
save_screenshot_sharing(&project_path, meta, &uploaded, content_hash)?;
copy_screenshot_share_link(&clipboard, uploaded.link.clone(), &app).await?;
Ok(UploadResult::Success(uploaded.link))
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(window))]
async fn save_file_dialog(
window: tauri::Window,
file_name: String,
file_type: String,
) -> Result<Option<String>, String> {
run_command_safely(
"save_file_dialog",
save_file_dialog_inner(window, file_name, file_type),
)
.await
}
async fn save_file_dialog_inner(
window: tauri::Window,
file_name: String,
file_type: String,
) -> Result<Option<String>, String> {
info!(file_name, file_type, "Save file dialog requested");
let file_name = file_name
.strip_suffix(".cap")
.unwrap_or(&file_name)
.to_string();
let (name, extension) = match file_type.as_str() {
"recording" | "mp4" => ("MP4 Video", "mp4"),
"gif" => ("GIF Image", "gif"),
"mov" => ("MOV Video", "mov"),
"screenshot" | "png" => ("PNG Image", "png"),
"srt" => ("SubRip Subtitle", "srt"),
"vtt" => ("WebVTT", "vtt"),
_ => {
warn!(file_type, "Invalid save file dialog type");
return Err("Invalid file type".to_string());
}
};
info!(file_name, name, extension, "Showing save file dialog");
#[cfg(target_os = "linux")]
let path = export::show_linux_save_dialog(
window.clone(),
tokio_util::sync::CancellationToken::new(),
file_name,
name,
extension,
)
.await?;
#[cfg(target_os = "macos")]
let path = export::show_macos_save_dialog(window.app_handle(), file_name, extension).await?;
#[cfg(not(any(target_os = "linux", target_os = "macos")))]
let path = {
use tauri_plugin_dialog::DialogExt;
let app = window.app_handle().clone();
// Use `tokio::sync::oneshot` so the async runtime worker yields while the native dialog
// is open instead of being parked by a synchronous `std::sync::mpsc` receive. The
// previous version blocked a runtime worker for the lifetime of the dialog which, in
// release builds with fewer/active workers, could starve other tasks and let an unrelated
// exit event slip through before the export session guard incremented.
let (tx, rx) = tokio::sync::oneshot::channel();
app.dialog()
.file()
.set_title("Save File")
.set_file_name(file_name)
.add_filter(name, &[extension])
.save_file(move |path| {
let _ = tx.send(
path.as_ref()
.and_then(|p| p.as_path())
.map(std::path::PathBuf::from),
);
});
match rx.await {
Ok(result) => {
info!(path = ?result, "Save file dialog completed");
result
}
Err(e) => {
warn!(error = %e, "Save file dialog failed");
notifications::send_notification(
&app,
notifications::NotificationType::VideoSaveFailed,
);
return Err(e.to_string());
}
}
};
if let Some(path) = &path {
use tauri_plugin_fs::FsExt;
if let Some(scope) = window.try_fs_scope() {
scope.allow_file(path).map_err(|error| error.to_string())?;
}
window
.state::<tauri::scope::Scopes>()
.allow_file(path)
.map_err(|error| error.to_string())?;
}
Ok(path.map(|path| path.to_string_lossy().into_owned()))
}
#[derive(Serialize, specta::Type)]
pub struct RecordingMetaWithMetadata {
#[serde(flatten)]
pub inner: RecordingMeta,
// Easier accessors for within webview
// THESE MUST COME AFTER `inner` to override flattened fields with the same name
pub mode: RecordingMode,
pub status: StudioRecordingStatus,
// Number of recorded takes (segments) the recording is made up of.
pub clip_count: u32,
pub sort_time_millis: f64,
}
impl RecordingMetaWithMetadata {
fn new(inner: RecordingMeta, sort_time_millis: f64) -> Self {
Self {
mode: match &inner.inner {
RecordingMetaInner::Studio(_) => RecordingMode::Studio,
RecordingMetaInner::Instant(_) => RecordingMode::Instant,
},
clip_count: match &inner.inner {
RecordingMetaInner::Studio(meta) => match &**meta {
StudioRecordingMeta::MultipleSegments { inner } => inner.segments.len() as u32,
StudioRecordingMeta::SingleSegment { .. } => 1,
},
RecordingMetaInner::Instant(_) => 1,
},
status: match &inner.inner {
RecordingMetaInner::Studio(meta) => match &**meta {
StudioRecordingMeta::MultipleSegments { inner } => inner
.status
.clone()
.unwrap_or(StudioRecordingStatus::Complete),
StudioRecordingMeta::SingleSegment { .. } => StudioRecordingStatus::Complete,
},
RecordingMetaInner::Instant(InstantRecordingMeta::InProgress { .. }) => {
StudioRecordingStatus::InProgress
}
RecordingMetaInner::Instant(InstantRecordingMeta::Failed { error }) => {
StudioRecordingStatus::Failed {
error: error.clone(),
}
}
RecordingMetaInner::Instant(InstantRecordingMeta::Complete { .. }) => {
StudioRecordingStatus::Complete
}
},
sort_time_millis,
inner,
}
}
}
#[derive(Serialize, specta::Type)]
pub struct ScreenshotMetaWithMetadata {
#[serde(flatten)]
pub inner: RecordingMeta,
pub sort_time_millis: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize, Type, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum FileType {
Recording,
Screenshot,
}
#[tauri::command(async)]
#[specta::specta]
#[instrument]
fn get_recording_meta(
path: PathBuf,
_file_type: FileType,
) -> Result<RecordingMetaWithMetadata, String> {
let sort_time_millis = media_sort_time_millis(&path);
RecordingMeta::load_for_project(&path)
.map(|meta| RecordingMetaWithMetadata::new(meta, sort_time_millis))
.map_err(|e| format!("Failed to load recording meta: {e}"))
}
fn media_sort_time(path: &Path) -> SystemTime {
let Ok(metadata) = path.metadata() else {
return UNIX_EPOCH;
};
metadata
.created()
.or_else(|_| metadata.modified())
.unwrap_or(UNIX_EPOCH)
}
fn media_sort_time_millis(path: &Path) -> f64 {
media_sort_time(path)
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_secs_f64()
* 1000.0
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn list_recordings(
app: AppHandle,
) -> Result<Vec<(PathBuf, RecordingMetaWithMetadata)>, String> {
tokio::task::spawn_blocking(move || list_recordings_inner(&app, usize::MAX))
.await
.map_err(|error| error.to_string())
}
#[tauri::command]
#[specta::specta]
async fn list_recent_recordings(
app: AppHandle,
) -> Result<Vec<(PathBuf, RecordingMetaWithMetadata)>, String> {
tokio::task::spawn_blocking(move || list_recordings_inner(&app, 9))
.await
.map_err(|error| error.to_string())
}
fn newest_valid_media<T, U>(
mut candidates: Vec<(T, f64)>,
limit: usize,
mut load: impl FnMut(T, f64) -> Option<U>,
) -> Vec<U> {
candidates.sort_by(|(_, a), (_, b)| b.total_cmp(a));
candidates
.into_iter()
.filter_map(|(candidate, timestamp)| load(candidate, timestamp))
.take(limit)
.collect()
}
fn list_recordings_inner(
app: &AppHandle,
limit: usize,
) -> Vec<(PathBuf, RecordingMetaWithMetadata)> {
// Recordings can live in multiple folders (the active one, the default
// one, and any previously used custom folders) — scan them all so
// switching the storage folder never hides existing recordings.
let mut result = Vec::new();
for recordings_dir in recordings_locations::known_recordings_dirs(app) {
let Ok(entries) = std::fs::read_dir(&recordings_dir) else {
continue;
};
for entry in entries.flatten() {
let path = entry.path();
if !path.is_dir() {
continue;
}
let timestamp = media_sort_time_millis(&path);
result.push((path, timestamp));
}
}
newest_valid_media(result, limit, |path, timestamp| {
let meta = RecordingMeta::load_for_project(&path).ok()?;
Some((path, RecordingMetaWithMetadata::new(meta, timestamp)))
})
}
fn acquire_recording_delete_lock(
path: &std::path::Path,
) -> Result<cap_recording::upload_resume::UploadLock, String> {
cap_recording::upload_resume::UploadLock::acquire(path).map_err(|error| error.to_string())
}
fn recording_delete_target(
recordings_dirs: &[PathBuf],
path: &Path,
) -> Result<Option<PathBuf>, String> {
if path
.components()
.any(|component| matches!(component, std::path::Component::ParentDir))
{
return Err("Invalid path".to_string());
}
let canonical_dirs: Vec<_> = recordings_dirs
.iter()
.filter_map(|dir| dir.canonicalize().ok())
.collect();
if recordings_dirs
.iter()
.chain(&canonical_dirs)
.any(|dir| path == dir)
{
return Err("Path is not inside a recordings directory".to_string());
}
if path
.try_exists()
.map_err(|error| format!("Failed to inspect recording path: {error}"))?
{
let canonical_path = path
.canonicalize()
.map_err(|error| format!("Failed to resolve recording path: {error}"))?;
if canonical_dirs.iter().any(|dir| &canonical_path == dir)
|| !canonical_dirs
.iter()
.any(|dir| canonical_path.starts_with(dir))
{
return Err("Path is not inside a recordings directory".to_string());
}
Ok(Some(canonical_path))
} else if recordings_dirs
.iter()
.chain(&canonical_dirs)
.any(|dir| path.starts_with(dir))
{
Ok(None)
} else {
Err("Path is not inside a recordings directory".to_string())
}
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn delete_recording_directory(app: AppHandle, path: PathBuf) -> Result<(), String> {
// The library lists recordings from every known storage folder, so
// deletion must accept the same set — but nothing outside it.
let recordings_dirs = recordings_locations::known_recordings_dirs(&app);
if let Some(canonical_path) = recording_delete_target(&recordings_dirs, &path)? {
upload::lifecycle::cancel(&canonical_path).await;
let ownership = acquire_recording_delete_lock(&canonical_path)?;
upload::lifecycle::mark_cancelled(&canonical_path).map_err(|error| error.to_string())?;
std::fs::remove_dir_all(&canonical_path)
.map_err(|error| format!("Failed to delete recording: {error}"))?;
drop(ownership);
}
let _ = RecordingDeleted { path }.emit(&app);
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn list_screenshots(
app: AppHandle,
) -> Result<Vec<(PathBuf, ScreenshotMetaWithMetadata)>, String> {
tokio::task::spawn_blocking(move || list_screenshots_inner(&app, usize::MAX))
.await
.map_err(|error| error.to_string())?
}
#[tauri::command]
#[specta::specta]
async fn list_recent_screenshots(
app: AppHandle,
) -> Result<Vec<(PathBuf, ScreenshotMetaWithMetadata)>, String> {
tokio::task::spawn_blocking(move || list_screenshots_inner(&app, 9))
.await
.map_err(|error| error.to_string())?
}
fn list_screenshots_inner(
app: &AppHandle,
limit: usize,
) -> Result<Vec<(PathBuf, ScreenshotMetaWithMetadata)>, String> {
let screenshots_dir = screenshots_path(app);
let result = std::fs::read_dir(&screenshots_dir)
.map_err(|e| format!("Failed to read screenshots directory: {e}"))?
.filter_map(|entry| {
let entry = entry.ok()?;
let path = entry.path();
if path.is_dir() && path.extension().and_then(|s| s.to_str()) == Some("cap") {
let png_path = std::fs::read_dir(&path)
.ok()?
.filter_map(|e| e.ok())
.find(|e| e.path().extension().and_then(|s| s.to_str()) == Some("png"))
.map(|e| e.path())?;
let sort_time_millis = media_sort_time_millis(&png_path);
Some(((path, png_path), sort_time_millis))
} else {
None
}
})
.collect::<Vec<_>>();
Ok(newest_valid_media(
result,
limit,
|(path, png_path), sort_time_millis| {
let inner = RecordingMeta::load_for_project(&path).ok()?;
Some((
png_path,
ScreenshotMetaWithMetadata {
inner,
sort_time_millis,
},
))
},
))
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn check_upgraded_and_update(app: AppHandle) -> Result<bool, String> {
println!("Checking upgraded status and updating...");
if let Ok(Some(settings)) = GeneralSettingsStore::get(&app)
&& settings.commercial_license.is_some()
{
return Ok(true);
}
let Ok(Some(auth)) = AuthStore::get(&app) else {
return Ok(false);
};
if let Some(ref plan) = auth.plan
&& plan.manual
{
return Ok(true);
}
println!("Fetching plan");
let response = app
.authed_api_request("/api/desktop/plan", |client, url| client.get(url))
.await
.map_err(|e| {
println!("Failed to fetch plan: {e}");
e.to_string()
})?;
println!("Plan fetch response status: {}", response.status());
let plan_data = response.json::<serde_json::Value>().await.map_err(|e| {
println!("Failed to parse plan response: {e}");
format!("Failed to parse plan response: {e}")
})?;
let is_pro = plan_data
.get("upgraded")
.and_then(|v| v.as_bool())
.unwrap_or(false);
println!("Pro status: {is_pro}");
let updated_auth = AuthStore {
secret: auth.secret,
user_id: auth.user_id,
plan: Some(Plan {
upgraded: is_pro,
manual: auth.plan.map(|p| p.manual).unwrap_or(false),
last_checked: chrono::Utc::now().timestamp() as i32,
}),
organizations: auth.organizations,
organizations_updated_at: auth.organizations_updated_at,
};
println!("Updating auth store with new pro status");
AuthStore::set(&app, Some(updated_auth)).map_err(|e| e.to_string())?;
Ok(is_pro)
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
fn open_external_link(app: tauri::AppHandle, url: String) -> Result<(), String> {
if let Ok(Some(settings)) = GeneralSettingsStore::get(&app)
&& settings.disable_auto_open_links
{
return Ok(());
}
app.shell()
.open(&url, None)
.map_err(|e| format!("Failed to open URL: {e}"))?;
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(_app))]
async fn reset_camera_permissions(_app: AppHandle) -> Result<(), String> {
#[cfg(target_os = "macos")]
{
let bundle_id = _app.config().identifier.clone();
Command::new("tccutil")
.arg("reset")
.arg("Camera")
.arg(bundle_id)
.output()
.map_err(|_| "Failed to reset camera permissions".to_string())?;
}
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(_app))]
async fn reset_microphone_permissions(_app: AppHandle) -> Result<(), String> {
#[cfg(target_os = "macos")]
{
let bundle_id = _app.config().identifier.clone();
Command::new("tccutil")
.arg("reset")
.arg("Microphone")
.arg(bundle_id)
.output()
.map_err(|_| "Failed to reset microphone permissions".to_string())?;
}
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn clear_presets(app: AppHandle) -> Result<(), String> {
presets::PresetsStore::clear(&app)
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn is_camera_window_open(app: AppHandle) -> bool {
CapWindowId::Camera
.get(&app)
.map(|w| w.is_visible().unwrap_or(false))
.unwrap_or(false)
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(editor_instance))]
async fn seek_to(editor_instance: WindowEditorInstance, frame_number: u32) -> Result<(), String> {
editor_instance
.modify_and_emit_state(|state| {
state.playhead_position = frame_number;
})
.await;
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(editor_instance))]
async fn get_display_frame_for_cropping(
editor_instance: WindowEditorInstance,
fps: u32,
) -> Result<Vec<u8>, String> {
use cap_project::ClipOffsets;
use cap_rendering::{PixelFormat, cpu_yuv};
use image::{ImageEncoder, codecs::jpeg::JpegEncoder};
use std::io::Cursor;
use std::time::Instant;
let total_started_at = Instant::now();
let frame_number = editor_instance.state.lock().await.playhead_position;
let time_secs = frame_number as f64 / fps as f64;
let project = editor_instance.project_config.1.borrow().clone();
let lookup_started_at = Instant::now();
let (segment_time, segment) = project
.get_segment_time(time_secs)
.ok_or_else(|| "No segment found for current time".to_string())?;
let segment_medias = editor_instance
.segment_medias
.get(segment.recording_clip as usize)
.ok_or_else(|| "Segment media not found".to_string())?;
let clip_offsets = project
.clips
.iter()
.find(|v| v.index == segment.recording_clip)
.map(|v| v.offsets)
.unwrap_or(ClipOffsets::default());
let lookup_elapsed_ms = lookup_started_at.elapsed().as_secs_f64() * 1000.0;
let decode_started_at = Instant::now();
let segment_frames = segment_medias
.decoders
.get_frames(segment_time as f32, false, true, clip_offsets)
.await
.ok_or_else(|| "Failed to get frame".to_string())?;
let decode_elapsed_ms = decode_started_at.elapsed().as_secs_f64() * 1000.0;
let screen_frame = segment_frames
.screen_frame
.ok_or_else(|| "Failed to get screen frame".to_string())?;
let width = screen_frame.width();
let height = screen_frame.height();
let convert_started_at = Instant::now();
let rgba_data = match screen_frame.format() {
PixelFormat::Rgba => screen_frame.data().to_vec(),
PixelFormat::Nv12 => {
let y_plane = screen_frame.y_plane().ok_or("Missing Y plane")?;
let uv_plane = screen_frame.uv_plane().ok_or("Missing UV plane")?;
let mut rgba = vec![0u8; (width * height * 4) as usize];
cpu_yuv::nv12_to_rgba(
y_plane,
uv_plane,
width,
height,
screen_frame.y_stride(),
screen_frame.uv_stride(),
&mut rgba,
);
rgba
}
PixelFormat::Yuv420p => {
let y_plane = screen_frame.y_plane().ok_or("Missing Y plane")?;
let u_plane = screen_frame.u_plane().ok_or("Missing U plane")?;
let v_plane = screen_frame.v_plane().ok_or("Missing V plane")?;
let mut rgba = vec![0u8; (width * height * 4) as usize];
cpu_yuv::yuv420p_to_rgba(
y_plane,
u_plane,
v_plane,
width,
height,
screen_frame.y_stride(),
screen_frame.uv_stride(),
&mut rgba,
);
rgba
}
};
let convert_elapsed_ms = convert_started_at.elapsed().as_secs_f64() * 1000.0;
let encode_started_at = Instant::now();
// The cropper maps interactions back to full display dimensions, so the
// reference image only needs to be sharp enough to position the crop. A
// downscaled JPEG keeps decode + IPC transfer near-instant even when the
// playhead is deep into a long recording.
const MAX_PREVIEW_DIM: u32 = 1440;
let rgba_image = image::RgbaImage::from_raw(width, height, rgba_data)
.ok_or_else(|| "Failed to build image buffer from frame".to_string())?;
let longest_side = width.max(height);
let resized = if longest_side > MAX_PREVIEW_DIM {
let scale = MAX_PREVIEW_DIM as f32 / longest_side as f32;
let target_w = ((width as f32 * scale).round() as u32).max(1);
let target_h = ((height as f32 * scale).round() as u32).max(1);
image::imageops::resize(
&rgba_image,
target_w,
target_h,
image::imageops::FilterType::Triangle,
)
} else {
rgba_image
};
let rgb_image = image::DynamicImage::ImageRgba8(resized).into_rgb8();
let out_width = rgb_image.width();
let out_height = rgb_image.height();
let mut jpeg_data = Cursor::new(Vec::new());
JpegEncoder::new_with_quality(&mut jpeg_data, 82)
.write_image(
rgb_image.as_raw(),
out_width,
out_height,
image::ExtendedColorType::Rgb8,
)
.map_err(|e| format!("Failed to encode JPEG: {e}"))?;
let encode_elapsed_ms = encode_started_at.elapsed().as_secs_f64() * 1000.0;
let total_elapsed_ms = total_started_at.elapsed().as_secs_f64() * 1000.0;
debug!(
target: "cap_crop_profile",
frame_number = frame_number,
time_secs = time_secs,
segment_time = segment_time,
width = width,
height = height,
out_width = out_width,
out_height = out_height,
lookup_ms = lookup_elapsed_ms,
decode_ms = decode_elapsed_ms,
convert_ms = convert_elapsed_ms,
encode_ms = encode_elapsed_ms,
total_ms = total_elapsed_ms,
"crop frame profile"
);
Ok(jpeg_data.into_inner())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(editor_instance))]
async fn get_mic_waveforms(editor_instance: WindowEditorInstance) -> Result<Vec<Vec<f32>>, String> {
let mut out = Vec::new();
for segment in editor_instance.segment_medias.iter() {
// Waits for the background decode; a failed track just renders as an
// empty waveform (playback/export surface the actual error).
match segment.audio.get().await {
Ok(Some(audio)) => out.push(audio::align_waveform_to_playback(
audio::get_waveform(&audio),
segment.audio_timing_repair.mic_offset_secs,
)),
Ok(None) => out.push(Vec::new()),
Err(error) => {
warn!(%error, "Mic audio failed to load; returning empty waveform");
out.push(Vec::new());
}
}
}
Ok(out)
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(editor_instance))]
async fn get_system_audio_waveforms(
editor_instance: WindowEditorInstance,
) -> Result<Vec<Vec<f32>>, String> {
let mut out = Vec::new();
for segment in editor_instance.segment_medias.iter() {
match segment.system_audio.get().await {
Ok(Some(audio)) => out.push(audio::align_waveform_to_playback(
audio::get_waveform(&audio),
segment.audio_timing_repair.system_audio_offset_secs,
)),
Ok(None) => out.push(Vec::new()),
Err(error) => {
warn!(%error, "System audio failed to load; returning empty waveform");
out.push(Vec::new());
}
}
}
Ok(out)
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app, editor_instance, window))]
async fn editor_delete_project(
app: tauri::AppHandle,
editor_instance: WindowEditorInstance,
window: tauri::Window,
) -> Result<(), String> {
let _ = window.close();
tokio::time::sleep(std::time::Duration::from_millis(20)).await;
let path = editor_instance.0.project_path.clone();
drop(editor_instance);
let _ = tokio::fs::remove_dir_all(&path).await;
RecordingDeleted { path }.emit(&app).ok();
Ok(())
}
async fn open_pricing_page(app: &AppHandle) -> Result<(), String> {
app.shell()
.open("https://cap.so/pricing?ref=desktop", None)
.map_err(|e| e.to_string())
}
// keep this async otherwise opening windows may hang on windows
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn show_window(app: AppHandle, window: ShowCapWindow) -> Result<(), String> {
if matches!(window, ShowCapWindow::Upgrade) {
return open_pricing_page(&app).await;
}
if matches!(window, ShowCapWindow::Camera { .. }) {
let operation_lock = app.state::<CameraWindowOperationLock>();
let _operation_guard = operation_lock.lock().await;
window.show(&app).await.map_err(|e| e.to_string())?;
return Ok(());
}
window.show(&app).await.map_err(|e| e.to_string())?;
Ok(())
}
#[tauri::command(async)]
#[specta::specta]
#[instrument]
fn list_fails() -> Result<BTreeMap<String, bool>, ()> {
Ok(cap_fail::get_state())
}
#[tauri::command(async)]
#[specta::specta]
#[instrument]
fn set_fail(name: String, value: bool) {
cap_fail::set_fail(&name, value)
}
async fn check_notification_permissions(app: AppHandle) {
let Ok(Some(settings)) = GeneralSettingsStore::get(&app) else {
return;
};
if !settings.enable_notifications {
return;
}
match app.notification().permission_state() {
Ok(state) if state != PermissionState::Granted => {
info!("Requesting notification permission");
match app.notification().request_permission() {
Ok(PermissionState::Granted) => {
info!("Notification permission granted");
}
Ok(_) | Err(_) => {
GeneralSettingsStore::update(&app, |s| {
s.enable_notifications = false;
})
.ok();
}
}
}
Ok(_) => {
debug!("Notification permission already granted");
}
Err(e) => {
error!("Error checking notification permission state: {e}");
}
}
}
// fn configure_logging(folder: &PathBuf) -> tracing_appender::non_blocking::WorkerGuard {
// let file_appender = tracing_appender::rolling::daily(folder, "cap-logs.log");
// let (non_blocking, _guard) = tracing_appender::non_blocking(file_appender);
// let filter = || tracing_subscriber::filter::EnvFilter::builder().parse_lossy("cap-*=TRACE");
// tracing_subscriber::registry()
// .with(
// tracing_subscriber::fmt::layer()
// .with_ansi(false)
// .with_target(false)
// .with_writer(non_blocking)
// .with_filter(filter()),
// )
// .with(
// tracing_subscriber::fmt::layer()
// .with_ansi(true)
// .with_target(false)
// .with_filter(filter()),
// )
// .init();
// _guard
// }
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn set_server_url(app: MutableState<'_, App>, server_url: String) -> Result<(), ()> {
let mut app = app.write().await;
telemetry::set_server_url(&server_url);
app.server_url = server_url;
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn pick_recordings_folder(app: AppHandle) -> Result<Option<String>, String> {
use tauri_plugin_dialog::DialogExt;
let (tx, rx) = tokio::sync::oneshot::channel();
app.dialog()
.file()
.set_title("Choose Recordings Folder")
.pick_folder(move |path| {
let _ = tx.send(
path.as_ref()
.and_then(|p| p.as_path())
.and_then(|p| p.to_str())
.map(|s| s.to_string()),
);
});
let result = rx.await.map_err(|e| e.to_string())?;
if let Some(ref path) = result {
general_settings::GeneralSettingsStore::update(&app, |s| {
let previous = s.recordings_path.replace(path.clone());
recordings_locations::remember_previous_recordings_path(s, previous, Some(path));
})?;
}
Ok(result)
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn reset_recordings_folder(app: AppHandle) -> Result<(), String> {
general_settings::GeneralSettingsStore::update(&app, |s| {
let previous = s.recordings_path.take();
recordings_locations::remember_previous_recordings_path(s, previous, None);
})
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn set_camera_preview_state(
app: MutableState<'_, App>,
state: CameraPreviewState,
) -> Result<(), String> {
let app_guard = app.read().await;
let state_for_ws = state.clone();
app_guard
.camera_preview
.set_state(state)
.map_err(|err| format!("Error saving camera window state: {err}"))?;
let _ = app_guard.camera_preview_state_tx.send(state_for_ws);
drop(app_guard);
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
fn set_camera_window_position(app: AppHandle, x: f64, y: f64) -> Result<(), String> {
if app
.try_state::<CameraWindowPositionGuard>()
.is_some_and(|guard| guard.should_ignore())
{
return Ok(());
}
GeneralSettingsStore::update(&app, |settings| {
update_camera_window_position_settings(settings, x, y, None);
})?;
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument]
fn ignore_camera_window_position(
guard: State<'_, CameraWindowPositionGuard>,
duration_ms: u32,
) -> Result<(), String> {
guard.ignore_for(duration_ms as u64);
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(state))]
async fn refresh_camera_feed(state: MutableState<'_, App>) -> Result<(), String> {
let app = state.read().await;
let camera_feed = app.camera_feed.clone();
#[allow(deprecated)]
let camera_ws_sender = app.camera_ws_sender.clone();
let camera_preview_sender = app.camera_preview.sender();
let use_ws_preview = app.camera_preview.is_paused() || camera_preview_sender.is_none();
drop(app);
if use_ws_preview {
if let Some(sender) = camera_preview_sender {
sender
.detach(&camera_feed)
.await
.map_err(|err| format!("error removing native preview sender: {err}"))?;
}
#[allow(deprecated)]
camera_feed
.ask(feeds::camera::AddSender(camera_ws_sender))
.await
.map_err(|err| format!("error re-adding camera ws sender: {err}"))?;
} else if let Some(sender) = camera_preview_sender {
#[allow(deprecated)]
camera_feed
.ask(feeds::camera::RemoveSender(camera_ws_sender))
.await
.map_err(|err| format!("error removing camera ws sender: {err}"))?;
sender
.attach(&camera_feed)
.await
.map_err(|err| format!("error re-adding camera preview sender: {err}"))?;
} else {
#[allow(deprecated)]
camera_feed
.ask(feeds::camera::AddSender(camera_ws_sender))
.await
.map_err(|err| format!("error re-adding camera ws sender: {err}"))?;
}
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app, state))]
async fn destroy_camera_window(app: AppHandle, state: MutableState<'_, App>) -> Result<(), String> {
let shutdown_rx = {
let mut app_state = state.write().await;
app_state.camera_preview.begin_shutdown()
};
if let Some(rx) = shutdown_rx {
let _ = tokio::time::timeout(std::time::Duration::from_millis(500), rx).await;
}
windows::cleanup_camera_window(&app, None, true, true).await;
Ok(())
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn await_camera_preview_ready(app: MutableState<'_, App>) -> Result<bool, String> {
let app = app.read().await.camera_feed.clone();
let (tx, rx) = oneshot::channel();
app.tell(feeds::camera::ListenForReady(tx))
.await
.map_err(|err| format!("error registering ready listener: {err}"))?;
rx.await
.map_err(|err| format!("error receiving ready signal: {err}"))?;
Ok(true)
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
async fn update_auth_plan(app: AppHandle) {
AuthStore::update_auth_plan(&app).await.ok();
}
pub async fn open_target_picker(
app: &tauri::AppHandle,
target_mode: recording_settings::RecordingTargetMode,
) {
use tauri::Manager;
hide_main_window(app);
let state = app.state::<target_select_overlay::WindowFocusManager>();
let display_id = None;
let session = match target_select_overlay::open_target_select_overlays_for_session(
app.clone(),
state.inner(),
None,
display_id.clone(),
Some(target_mode),
)
.await
{
Ok(session) => session,
Err(error) => {
warn!(%error, "Failed to open target picker");
let _ = ShowCapWindow::Main {
init_target_mode: None,
}
.show(app)
.await;
return;
}
};
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
if !state.picker_is_current(session) {
return;
}
let _ = RequestSetTargetMode {
target_mode: Some(target_mode),
display_id,
}
.emit(app);
}
type FilteredRegistry = tracing_subscriber::layer::Layered<
tracing_subscriber::filter::FilterFn<fn(m: &tracing::Metadata) -> bool>,
tracing_subscriber::Registry,
>;
pub type DynLoggingLayer = Box<dyn tracing_subscriber::Layer<FilteredRegistry> + Send + Sync>;
type LoggingHandle = tracing_subscriber::reload::Handle<Option<DynLoggingLayer>, FilteredRegistry>;
#[cfg(debug_assertions)]
pub fn initialize_stop_editor_benchmark(
create_log_directory: impl FnOnce(&std::path::Path, &std::path::Path) -> std::io::Result<PathBuf>,
) -> Result<Option<PathBuf>, String> {
stop_editor_benchmark::initialize(create_log_directory)
}
/// Software recovery exists to break GPU-driver crash loops: a process that died
/// while wgpu adapter/device initialisation was in flight. Any other unexpected
/// termination (force-quit, power loss, OS kill, a hung shutdown) says nothing
/// about the GPU, and forcing the WARP software rasterizer would cripple editor
/// playback (seconds-per-frame renders) on perfectly healthy hardware. A previous
/// session that was *already* in software recovery and still died shows software
/// mode isn't saving the machine, so retry hardware rather than chaining recovery
/// launches forever.
#[cfg_attr(not(target_os = "windows"), allow(dead_code))]
fn should_engage_graphics_recovery(
previous_termination: Option<crash_sentinel::UnexpectedTermination>,
) -> bool {
previous_termination.is_some_and(|prev| prev.during_gpu_init && !prev.in_graphics_recovery)
}
#[cfg(target_os = "windows")]
fn configure_windows_graphics_recovery(
previous_termination: Option<crash_sentinel::UnexpectedTermination>,
) {
if should_engage_graphics_recovery(previous_termination) {
cap_rendering::set_force_software_wgpu_adapter(true);
crash_sentinel::mark_graphics_recovery();
warn!(
"Previous Cap session terminated during GPU initialisation; using Windows software graphics recovery mode for this launch"
);
} else if previous_termination.is_some() {
info!(
"Previous session terminated unexpectedly, but not during first-time GPU initialisation; keeping hardware graphics"
);
}
}
#[cfg(not(target_os = "windows"))]
fn configure_windows_graphics_recovery(
_previous_termination: Option<crash_sentinel::UnexpectedTermination>,
) {
}
/// Decides what `camera_blur_disabled_by_crash` should hold for this launch: a
/// death with the blur pipeline active disables blur at the current version
/// (fresh crash evidence beats version optimism), an existing disable carries
/// over within the same app version, and an app update clears it so the new
/// ort/wgpu/driver stack gets one retry.
fn next_camera_blur_disabled_version(
stored: Option<&str>,
previous_termination: Option<crash_sentinel::UnexpectedTermination>,
current_version: &str,
) -> Option<String> {
if previous_termination.is_some_and(|prev| prev.blur_active) {
return Some(current_version.to_string());
}
stored.filter(|v| *v == current_version).map(String::from)
}
/// Breaks the camera-background-blur crash loop: a native DirectML/driver crash
/// never reaches a panic handler, and the blur toggle is persisted frontend-side,
/// so without this the next camera open repeats the crash forever. Blur init is
/// lazy (first camera frame / editor render), so running this during setup is
/// early enough. Windows-only at runtime (matching graphics recovery) but
/// compiled everywhere so non-Windows builds keep it honest.
fn configure_camera_blur_recovery(
app: &AppHandle,
previous_termination: Option<crash_sentinel::UnexpectedTermination>,
) {
if !cfg!(target_os = "windows") {
return;
}
let current_version = env!("CARGO_PKG_VERSION");
let stored = GeneralSettingsStore::get(app)
.ok()
.flatten()
.and_then(|settings| settings.camera_blur_disabled_by_crash);
let next =
next_camera_blur_disabled_version(stored.as_deref(), previous_termination, current_version);
if next != stored {
let value = next.clone();
if let Err(error) = GeneralSettingsStore::update(app, |settings| {
settings.camera_blur_disabled_by_crash = value;
}) {
warn!(%error, "Failed to persist camera blur crash-recovery state");
}
}
if next.is_some() {
cap_camera_effects::set_blur_disabled(true);
crash_sentinel::mark_blur_recovery();
if stored.is_none() {
error!(
"Previous Cap session died with camera background blur active; disabling blur until the next app update"
);
} else {
warn!("Camera background blur remains disabled by crash recovery for this launch");
}
} else if stored.is_some() {
info!(
prev_version = stored.as_deref(),
"App version changed; re-enabling camera background blur for one retry"
);
}
}
#[tauri::command]
#[specta::specta]
fn animated_gradient_catalog() -> cap_project::AnimatedGradientCatalog {
cap_project::animated_gradient_catalog()
}
#[tauri::command]
#[specta::specta]
fn random_animated_gradient() -> cap_project::AnimatedGradientConfig {
cap_project::AnimatedGradientConfig::random()
}
#[cfg(any(debug_assertions, test))]
fn typescript_exporter() -> specta_typescript::Typescript {
specta_typescript::Typescript::default().formatter(|path| {
let source = std::fs::read_to_string(path)?;
let formatted = source
.lines()
.map(str::trim_end)
.collect::<Vec<_>>()
.join("\n");
std::fs::write(path, format!("{formatted}\n"))
})
}
fn specta_builder() -> tauri_specta::Builder {
tauri_specta::Builder::new()
.commands(tauri_specta::collect_commands![
linux_instant_camera::submit_camera_presentation,
clean_capture::get_clean_capture_state,
clean_capture::reveal_capture_window,
animated_gradient_catalog,
random_animated_gradient,
set_mic_input,
set_camera_input,
set_native_camera_preview_enabled,
gpui_app::gpui_app_available,
gpui_app::switch_to_gpui_app,
recording_settings::set_recording_mode,
upload_logs,
get_system_diagnostics,
diagnostics::run_diagnostic,
diagnostics::upload_diagnostic_report,
diagnostics::reveal_diagnostic_report,
cli::get_cli_install_status,
cli::install_cli,
cli::uninstall_cli,
recording::start_recording,
recording::stop_recording,
recording::pause_recording,
recording::get_recording_pause_state,
recording::resume_recording,
recording::toggle_pause_recording,
recording::set_mic_recording_muted,
recording::restart_recording,
recording::delete_recording,
recording::take_screenshot,
recording::import_current_desktop_background,
recording::get_default_project_config,
recording::list_cameras,
recording::get_camera_formats,
recording::get_microphone_info,
recording::list_capture_windows,
recording::list_capture_displays,
recording::list_displays_with_thumbnails,
recording::list_windows_with_thumbnails,
windows::refresh_window_content_protection,
windows::restore_main_window_geometry,
general_settings::get_default_excluded_windows,
list_audio_devices,
list_system_fonts,
close_recordings_overlay_window,
fake_window::set_fake_window_bounds,
fake_window::remove_fake_window,
focus_captures_panel,
get_current_recording,
export::begin_export_session,
export::end_export_session,
export::cancel_export,
export::cancel_current_window_exports,
export::export_video,
export::export_video_with_id,
export::export_video_to_file,
export::get_export_estimates,
export::cancel_export_estimates,
export::generate_export_preview,
export::generate_export_preview_fast,
import::start_video_import,
import::add_existing_recording_to_editor,
import::start_image_import,
import::check_import_ready,
copy_file_to_path,
copy_video_to_clipboard,
copy_screenshot_to_clipboard,
copy_image_to_clipboard,
copy_rendered_screenshot_to_clipboard,
open_file_path,
reveal_item_in_dir,
get_video_metadata,
create_editor_instance,
editor_preparing::create_preparing_editor_frame,
editor_preparing::get_preparing_editor_state,
editor_preparing::seek_preparing_editor,
editor_preparing::set_preparing_editor_playing,
editor_preparing::stop_preparing_editor_frame,
get_editor_project_path,
get_mic_waveforms,
get_system_audio_waveforms,
audio_library::list_audio_library,
audio_library::add_audio_library_track,
audio_library::import_audio_track_file,
start_playback,
stop_playback,
commit_editor_preparing_frame,
start_editor_handoff_playback,
stop_editor_handoff_playback,
set_playhead_position,
set_project_config,
update_project_config_in_memory,
generate_zoom_segments_from_clicks,
generate_keyboard_segments,
render_screenshot_for_export,
render_screenshot_project_for_export,
get_screenshot_project_share_state,
permissions::open_permission_settings,
permissions::do_permissions_check,
permissions::request_permission,
get_devices_snapshot,
upload_exported_video,
copy_current_screenshot_share_link,
upload_screenshot,
upload_rendered_screenshot,
create_screenshot_editor_instance,
update_screenshot_config,
prewarm_screenshot_background,
recognize_screenshot_text,
get_recording_meta,
save_file_dialog,
list_recordings,
list_recent_recordings,
list_screenshots,
list_recent_screenshots,
check_upgraded_and_update,
open_external_link,
hotkeys::set_hotkey,
reset_camera_permissions,
reset_microphone_permissions,
clear_presets,
is_camera_window_open,
seek_to,
get_display_frame_for_cropping,
clip_thumbnails::get_clip_thumbnail,
windows::position_traffic_lights,
windows::set_theme,
windows::set_teleprompter_window_level,
windows::set_teleprompter_window_opacity,
windows::apply_macos_liquid_glass_background,
global_message_dialog,
show_window,
write_clipboard_string,
platform::perform_haptic_feedback,
platform::is_system_audio_capture_supported,
list_fails,
set_fail,
update_auth_plan,
set_window_transparent,
get_editor_meta,
get_recording_meta_by_path,
editor_recording::open_editor_recording_main,
editor_recording::cancel_editor_recording_flow,
editor_recording::get_editor_recording_target,
delete_recording_directory,
set_pretty_name,
set_server_url,
pick_recordings_folder,
reset_recordings_folder,
recordings_locations::count_recordings_to_migrate,
recordings_locations::migrate_recordings_to_current_dir,
set_camera_preview_state,
set_camera_window_position,
ignore_camera_window_position,
await_camera_preview_ready,
destroy_camera_window,
refresh_camera_feed,
captions::create_dir,
captions::save_model_file,
captions::transcribe_audio,
captions::save_captions,
captions::load_captions,
captions::get_model_download_status,
captions::download_whisper_model,
captions::check_model_exists,
captions::delete_whisper_model,
captions::download_parakeet_model,
captions::check_parakeet_model_exists,
captions::delete_parakeet_model,
captions::export_captions_srt,
target_select_overlay::open_target_select_overlays,
target_select_overlay::close_target_select_overlays,
target_select_overlay::target_select_overlay_ready,
target_select_overlay::suspend_target_select_overlays,
target_select_overlay::update_camera_overlay_bounds,
target_select_overlay::display_information,
target_select_overlay::get_window_icon,
target_select_overlay::focus_window,
editor_delete_project,
format_project_name,
recovery::find_incomplete_recordings,
recovery::recover_recording,
recovery::discard_incomplete_recording,
automation::get_automations,
automation::set_automations,
automation::test_automation,
automation::automation_should_open_screenshot_editor,
automation::list_automation_capabilities,
updates::updates_check,
updates::updates_download_and_install,
restart_app,
updates::updates_channel_changed,
])
.events(tauri_specta::collect_events![
linux_instant_camera::CameraPresentationRequested,
RecordingOptionsChanged,
NewStudioRecordingAdded,
EditorRecordingAdded,
editor_recording::EditorRecordingFlowChanged,
NewScreenshotAdded,
RenderFrameEvent,
EditorStateChanged,
editor_preparing::PreparingEditorChanged,
FrameLayoutEvent,
CurrentRecordingChanged,
RecordingStarted,
RecordingStopped,
RequestStartRecording,
RequestOpenRecordingPicker,
RequestSetTargetMode,
RequestOpenSettings,
RequestScrollToSettingsSection,
RequestScreenCapturePrewarm,
NewNotification,
audio_meter::AudioInputLevelChange,
captions::DownloadProgress,
recording::RecordingEvent,
RecordingDeleted,
recordings_locations::RecordingsMigrationProgress,
target_select_overlay::TargetUnderCursor,
hotkeys::OnEscapePress,
upload::UploadProgressEvent,
import::VideoImportProgress,
SetCaptureAreaPending,
DevicesUpdated,
updates::UpdateDownloadProgress,
updates::UpdateReady,
diagnostics::DiagnosticProgress,
])
.error_handling(tauri_specta::ErrorHandlingMode::Throw)
.typ::<ProjectConfiguration>()
.typ::<cap_project::AnimatedGradientLibrary>()
.typ::<AuthStore>()
.typ::<presets::PresetsStore>()
.typ::<hotkeys::HotkeysStore>()
.typ::<general_settings::GeneralSettingsStore>()
.typ::<recording_settings::RecordingSettingsStore>()
.typ::<cap_flags::Flags>()
.typ::<crate::window_exclusion::WindowExclusion>()
.typ::<cap_automation::AutomationsStore>()
.typ::<cap_automation::AutomationRule>()
.typ::<cap_automation::Trigger>()
.typ::<cap_automation::Condition>()
.typ::<cap_automation::Action>()
.typ::<cap_automation::ExportProfile>()
.typ::<cap_automation::MatchMode>()
.typ::<cap_automation::CaptureTargetKind>()
.typ::<cap_automation::AutomationRecordingMode>()
.typ::<cap_automation::ClipboardSource>()
.typ::<cap_automation::ExportFormat>()
.typ::<cap_automation::AutomationExportCompression>()
.typ::<cap_automation::ExportDestination>()
}
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: Option<PathBuf>) {
let startup = startup::Startup::default();
// Arm the unexpected-termination sentinel before anything else can crash, and
// report any previous session that died without a clean shutdown.
let previous_termination = crash_sentinel::init(logs_dir.as_deref(), env!("CARGO_PKG_VERSION"));
configure_windows_graphics_recovery(previous_termination);
// Keep the sentinel's blur marker in sync with live BlurProcessor instances
// (camera preview and editor render alike), so a native blur crash is
// attributable on the next launch.
cap_camera_effects::set_blur_session_observer(|active| {
if active {
crash_sentinel::enter_blur_session();
} else {
crash_sentinel::exit_blur_session();
}
});
ffmpeg::init()
.map_err(|e| {
error!("Failed to initialize ffmpeg: {e}");
})
.ok();
// Detect the camera-preview quality profile once from total RAM. On low-RAM
// machines (<= 8GB) this opts the preview into a cheaper profile (smaller
// textures, 30fps, no background blur); higher-spec machines keep the exact
// current behaviour. Only the preview is affected — recording is untouched.
{
let mut system = sysinfo::System::new();
system.refresh_memory();
camera::init_preview_profile(system.total_memory());
}
telemetry::init();
let tauri_context = tauri::generate_context!();
let specta_builder = specta_builder();
#[cfg(debug_assertions)]
{
let bindings_path = std::path::Path::new("../src/utils/tauri.ts");
if bindings_path.parent().is_some_and(|parent| parent.exists()) {
if let Err(err) = specta_builder.export(typescript_exporter(), bindings_path) {
warn!(error = %err, "Failed to export TypeScript bindings");
}
} else {
debug!("Skipping TypeScript bindings export outside source checkout");
}
}
let (camera_preview_state_tx, camera_preview_state_rx) =
tokio::sync::watch::channel(CameraPreviewState::default());
let camera_preview_ws = camera_legacy::create_camera_preview_ws(camera_preview_state_rx).await;
let camera_tx = camera_preview_ws.sender;
let camera_ws_port = camera_preview_ws.port;
let _shutdown = camera_preview_ws.shutdown;
#[cfg(target_os = "linux")]
let camera_processing = camera_preview_ws.processing;
let camera_ws_sender = camera_tx.clone();
let (mic_samples_tx, mic_samples_rx) = flume::bounded(8);
let mic_meter_sender = mic_samples_tx.clone();
let camera_feed = CameraFeed::spawn(CameraFeed::default());
let _ = camera_feed.ask(feeds::camera::AddSender(camera_tx)).await;
let (mic_error_tx, mic_error_rx) = flume::bounded(1);
let mic_feed = {
let mic_feed = MicrophoneFeed::spawn(MicrophoneFeed::new(mic_error_tx));
if let Err(err) = mic_feed
.ask(feeds::microphone::AddSender(mic_samples_tx))
.await
{
error!("Failed to attach audio meter sender: {err}");
}
mic_feed
};
tauri::async_runtime::set(tokio::runtime::Handle::current());
let builder =
tauri::Builder::default().plugin(tauri_plugin_single_instance::init(|app, args, _cwd| {
#[cfg(target_os = "linux")]
{
let handle = app.clone();
if let Err(error) = app.run_on_main_thread(move || {
handle_single_instance(&handle, args);
}) {
warn!(%error, "Could not queue Cap activation");
}
}
#[cfg(not(target_os = "linux"))]
handle_single_instance(app, args);
}));
#[cfg(target_os = "macos")]
let builder = builder
.manage(StartupOpenGate::default())
.menu(build_macos_app_menu)
.on_menu_event(|app, event| {
if event.id() == APP_MENU_QUIT_ID {
let app = app.clone();
tokio::spawn(async move {
request_app_exit(app).await;
});
}
})
.plugin(tauri_nspanel::init());
let builder = builder
.manage(startup)
.on_page_load(|webview, payload| {
if webview.label() == "onboarding"
&& matches!(payload.event(), tauri::webview::PageLoadEvent::Finished)
{
webview.app_handle().state::<startup::Startup>().mark_ready();
}
})
.plugin(tauri_plugin_shell::init())
.plugin(tauri_plugin_dialog::init())
.plugin(tauri_plugin_store::Builder::new().build())
.plugin(tauri_plugin_os::init())
.plugin(tauri_plugin_process::init())
.plugin(tauri_plugin_oauth::init())
.plugin(tauri_plugin_http::init())
.plugin(tauri_plugin_updater::Builder::new().build())
.plugin(tauri_plugin_notification::init())
.plugin(flags::plugin::init())
.plugin(tauri_plugin_deep_link::init())
.plugin(tauri_plugin_clipboard_manager::init())
.plugin(tauri_plugin_fs::init())
.plugin(tauri_plugin_opener::init())
.plugin(
tauri_plugin_window_state::Builder::new()
.with_state_flags({
use tauri_plugin_window_state::StateFlags;
let mut flags = StateFlags::all();
flags.remove(StateFlags::VISIBLE);
flags
})
.with_denylist(&[
CapWindowId::Onboarding.label().as_str(),
CapWindowId::Main.label().as_str(),
CapWindowId::Settings.label().as_str(),
"window-capture-occluder",
"target-select-overlay",
CapWindowId::CaptureArea.label().as_str(),
CapWindowId::Camera.label().as_str(),
CapWindowId::RecordingsOverlay.label().as_str(),
CapWindowId::RecordingControls.label().as_str(),
CapWindowId::Upgrade.label().as_str(),
"editor",
"screenshot-editor",
])
.map_label(|label| match label {
label if label.starts_with("camera-") => "camera",
label if label.starts_with("editor-") => "editor",
label if label.starts_with("screenshot-editor-") => "screenshot-editor",
label if label.starts_with("window-capture-occluder-") => {
"window-capture-occluder"
}
label if label.starts_with("target-select-overlay") => "target-select-overlay",
_ => label,
})
.build(),
)
.invoke_handler({
let public_commands = specta_builder.invoke_handler();
let recovery_commands: fn(tauri::ipc::Invoke<tauri::Wry>) -> bool = tauri::generate_handler![recovery::get_recording_recovery_success];
move |invoke| {
if invoke.message.command() == "get_recording_recovery_success" {
recovery_commands(invoke)
} else {
public_commands(invoke)
}
}
})
.setup(move |app| {
let app = app.handle().clone();
#[cfg(debug_assertions)]
stop_editor_benchmark::validate_app_identifier(&app.config().identifier)?;
#[cfg(target_os = "macos")]
let _startup_open_guard = app
.try_state::<StartupOpenGate>()
.map(|state| StartupOpenGuard((*state).clone()));
if let Err(err) = update_project_names::migrate_if_needed(&app) {
tracing::error!("Failed to migrate project file names: {}", err);
}
specta_builder.mount_events(&app);
general_settings::init(&app);
// Before anything shows a window or initialises further state: when
// the native app owns the session, this one only exists to start it.
if gpui_app::redirect_at_startup_if_enabled(&app)? {
// Nothing is managed yet, so `ExitRequested` would otherwise
// spawn a cleanup with no `AppExitState` to guard it. Marking
// the exit as already begun takes the plain runtime-exit path.
let exit_state = AppExitState::default();
exit_state.begin();
app.manage(exit_state);
crash_sentinel::mark_clean_exit();
#[cfg(target_os = "macos")]
{
if app.try_state::<gpui_app::StartupRedirectState>().is_none() {
app.manage(gpui_app::StartupRedirectState::default());
}
finish_macos_startup_opens(&app, StartupOpenDestination::Gpui);
gpui_app::retire_foreground_parent_for_handoff(&app);
let app = app.clone();
tokio::spawn(async move {
tokio::time::sleep(Duration::from_millis(750)).await;
let Some(reopen_pid) = app
.try_state::<gpui_app::StartupRedirectState>()
.and_then(|state| state.exit_if_pending())
else {
return;
};
if let Some(pid) = reopen_pid
{
match tokio::task::spawn_blocking(move || gpui_app::request_gpui_reopen(pid)).await {
Ok(Ok(())) => info!(pid, "Queued a request to reopen Cap GPUI"),
Ok(Err(error)) => warn!(pid, %error, "Could not confirm Cap GPUI reopening; the existing instance remains unchanged"),
Err(error) => warn!(pid, %error, "Cap GPUI reopen forwarding did not finish"),
}
}
app.exit(0);
});
}
#[cfg(not(target_os = "macos"))]
app.exit(0);
return Ok(());
}
app.manage(clean_capture::State::default());
hotkeys::init(&app);
configure_camera_blur_recovery(&app, previous_termination);
fake_window::init(&app);
app.manage(target_select_overlay::WindowFocusManager::default());
app.manage(EditorWindowIds::default());
app.manage(ScreenshotEditorWindowIds::default());
app.manage(EditorRecordingTarget::default());
app.manage(editor_recording::EditorRecordingFlowState::default());
#[cfg(target_os = "macos")]
app.manage(crate::platform::ScreenCapturePrewarmer::default());
#[cfg(target_os = "macos")]
app.manage(panel_manager::PanelManager::new());
app.manage(http_client::HttpClient::default());
app.manage(http_client::RetryableHttpClient::default());
app.manage(PendingScreenshots::default());
app.manage(FinalizingRecordings::default());
app.manage(editor_preparing::PreparingConsumers::default());
app.manage(updates::UpdatesState::default());
updates::spawn_background_loop(app.clone());
#[cfg(unix)]
{
let app_for_signal = app.clone();
tokio::spawn(async move {
use tokio::signal::unix::{SignalKind, signal};
let Ok(mut term) = signal(SignalKind::terminate()) else {
tracing::warn!("Failed to register SIGTERM handler");
return;
};
let Ok(mut hup) = signal(SignalKind::hangup()) else {
tracing::warn!("Failed to register SIGHUP handler");
return;
};
loop {
tokio::select! {
signal = term.recv() => {
if signal.is_none() {
return;
}
tracing::info!("Received SIGTERM; requesting graceful shutdown");
}
signal = hup.recv() => {
if signal.is_none() {
return;
}
tracing::info!("Received SIGHUP; requesting graceful shutdown");
}
}
request_app_exit(app_for_signal.clone()).await;
if app_is_exiting(&app_for_signal) {
return;
}
}
});
}
tokio::spawn({
let camera_feed = camera_feed.clone();
let app = app.clone();
async move {
camera_feed
.tell(feeds::camera::OnFeedDisconnect(Box::new({
move || {
if app_is_exiting(&app) {
return;
}
if let Some(win) = CapWindowId::Camera.get(&app) {
win.hide().ok();
}
}
})))
.send()
.await
.map_err(|err| error!("Error registering on camera feed disconnect: {err}"))
.ok();
}
});
if let Ok(Some(auth)) = AuthStore::load(&app) {
sentry::configure_scope(|scope| {
scope.set_user(auth.user_id.map(|id| sentry::User {
id: Some(id),
..Default::default()
}));
});
}
{
let (server_url, should_update) = if cfg!(debug_assertions)
&& let Ok(url) = std::env::var("VITE_SERVER_URL")
{
(url, true)
} else if let Some(url) = GeneralSettingsStore::get(&app)
.ok()
.flatten()
.map(|v| v.server_url.clone())
{
(url, false)
} else {
(
option_env!("VITE_SERVER_URL")
.unwrap_or("https://cap.so")
.to_string(),
true,
)
};
// This ensures settings reflects the correct value if it's set at startup
if should_update {
GeneralSettingsStore::update(&app, |s| {
s.server_url = server_url.clone();
})
.map_err(|err| warn!("Error updating server URL into settings store: {err}"))
.ok();
}
telemetry::set_server_url(&server_url);
let camera_preview = CameraPreviewManager::new(&app);
let camera_session_id_handle = camera_preview.session_id_handle();
let requested_settings = match RecordingSettingsStore::get(&app) {
Ok(settings) => settings.unwrap_or_default(),
Err(error) => {
warn!(%error, "Failed to load recording settings during startup");
RecordingSettingsStore::default()
}
};
app.manage(linux_instant_camera::PresentationBroker::default());
app.manage(RequestedInputsState::new(
requested_settings.mic_name,
requested_settings.camera_id,
));
app.manage(Arc::new(RwLock::new(App {
camera_ws_port,
camera_ws_sender,
#[cfg(target_os = "linux")]
camera_processing,
handle: app.clone(),
camera_preview,
camera_preview_state_tx,
recording_state: RecordingState::None,
recording_logging_handle,
mic_feed,
mic_meter_sender,
selected_mic_label: None,
applied_mic_input: AppliedMicrophoneInput::default(),
selected_camera_id: None,
camera_in_use: false,
camera_cleanup_done: false,
camera_feed,
server_url,
logs_dir: logs_dir.clone(),
disconnected_inputs: HashSet::new(),
was_camera_only_recording: false,
})));
app.manage(camera_session_id_handle);
app.manage(CameraWindowCloseGate::default());
app.manage(CameraWindowPositionGuard::default());
app.manage(CameraWindowOperationLock::default());
app.manage(AppExitState::default());
app.manage(MainWindowReadyState::default());
app.manage(deeplink_actions::DeepLinkActionExecutor::new(&app));
#[cfg(target_os = "macos")]
install_macos_native_terminate_handler(&app);
spawn_process_memory_sampler(app.clone());
#[cfg(target_os = "linux")]
let clipboard = ClipboardContext::new(&app)
.expect("Failed to create clipboard context");
#[cfg(not(target_os = "linux"))]
let clipboard = ClipboardContext::new()
.expect("Failed to create clipboard context");
app.manage(Arc::new(RwLock::new(clipboard)));
}
app.listen_any("main-window-ready", {
let app = app.clone();
move |_| {
app.state::<MainWindowReadyState>().set_ready(true);
tracing::info!("Main window frontend ready");
app.state::<startup::Startup>().mark_ready();
#[cfg(debug_assertions)]
stop_editor_benchmark::run(app.clone());
#[cfg(debug_assertions)]
picker_benchmark::run(app.clone());
gpu_context::prewarm_gpu();
tokio::task::spawn_blocking(cap_rendering::prewarm_fonts);
tokio::spawn(screenshot_editor::prewarm_screenshot_renderer());
#[cfg(target_os = "macos")]
{
let app = app.clone();
tokio::spawn(async move {
if let Some(prewarmer) =
app.try_state::<crate::platform::ScreenCapturePrewarmer>()
{
prewarmer.request(false).await;
} else {
warn!("ScreenCapturePrewarmer state unavailable after main window ready");
}
});
}
}
});
upload::lifecycle::init(app.clone());
spawn_mic_error_handler(app.clone(), mic_error_rx);
spawn_device_watchers(app.clone());
spawn_devices_snapshot_emitter(app.clone());
spawn_system_resume_detector(app.clone());
power_observer::install(&app);
window_position_persistence::install(&app);
tokio::spawn(check_notification_permissions(app.clone()));
tokio::spawn({
let app = app.clone();
async move {
let startup_window = if should_show_onboarding(&app) {
ShowCapWindow::Onboarding
} else {
ShowCapWindow::Main {
init_target_mode: None,
}
};
match startup_window.show(&app).await {
Ok(window) => {
tracing::info!(label = window.label(), "Startup window created");
}
Err(error) => {
tracing::error!(%error, "Failed to open startup window");
}
}
}
});
audio_meter::spawn_event_emitter(app.clone(), mic_samples_rx);
if let Err(err) = tray::create_tray(&app) {
error!("Failed to create tray: {err}");
}
RequestStartRecording::listen_any_spawn(&app, async |event, app| {
let settings = RecordingSettingsStore::get(&app)
.ok()
.flatten()
.unwrap_or_default();
let _ = start_recording(app.clone(), app.state(), {
recording::StartRecordingInputs {
capture_target: settings.target.unwrap_or_else(|| {
ScreenCaptureTarget::Display {
id: Display::primary().id(),
}
}),
mode: event.mode,
capture_system_audio: settings.system_audio,
organization_id: settings.organization_id,
}
})
.await;
});
RequestOpenRecordingPicker::listen_any_spawn(&app, async |event, app| {
if let Some(target_mode) = event.target_mode {
open_target_picker(&app, target_mode).await;
} else {
let _ = ShowCapWindow::Main {
init_target_mode: None,
}
.show(&app)
.await;
}
});
RequestOpenSettings::listen_any_spawn(&app, async |payload, app| {
let _ = ShowCapWindow::Settings {
page: Some(payload.page),
}
.show(&app)
.await;
});
#[cfg(target_os = "macos")]
RequestScreenCapturePrewarm::listen_any_spawn(&app, async |event, app| {
if let Some(prewarmer) = app.try_state::<crate::platform::ScreenCapturePrewarmer>()
{
prewarmer.request(event.force).await;
} else {
warn!("ScreenCapturePrewarmer state unavailable during prewarm request");
}
});
RecordingStarted::listen_any_spawn(&app, async |_event, app| {
crate::automation::run_recording_started_automations(app);
});
RecordingDeleted::listen_any_spawn(&app, async |event, app| {
crate::automation::run_recording_deleted_automations(app, event.path);
});
import::VideoImportProgress::listen_any_spawn(&app, async |event, app| {
if matches!(event.stage, import::ImportStage::Complete) {
crate::automation::run_video_imported_automations(
app,
std::path::PathBuf::from(event.project_path),
);
}
});
let app_handle = app.clone();
app.deep_link().on_open_url(move |event| {
deeplink_actions::handle(&app_handle, event.urls());
});
#[cfg(target_os = "macos")]
finish_macos_startup_opens(&app, StartupOpenDestination::Desktop);
Ok(())
})
.on_window_event(|window, event| {
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let label = window.label();
let app = window.app_handle();
if matches!(
event,
WindowEvent::CloseRequested { .. }
| WindowEvent::Moved(_)
| WindowEvent::Focused(_)
) && app_is_exiting(app)
{
return;
}
match event {
WindowEvent::CloseRequested { api, .. } => {
let window_id = CapWindowId::from_str(label).ok();
if !matches!(
window_id,
Some(CapWindowId::Editor { .. })
| Some(CapWindowId::ScreenshotEditor { .. })
) && export::export_session_active()
{
api.prevent_close();
warn!(
window = label,
"Preventing window close request during active export"
);
return;
}
if let Some(window_id) = window_id {
match window_id {
CapWindowId::Camera => {
if app
.try_state::<CameraWindowCloseGate>()
.is_some_and(|close_gate| close_gate.allow_close())
{
return;
}
api.prevent_close();
let _ = window.hide();
tracing::warn!("Camera window CloseRequested event received!");
let session_id = app
.try_state::<Arc<AtomicU64>>()
.map(|state| state.load(Ordering::Acquire))
.unwrap_or(0);
let app = app.clone();
spawn_on_runtime(async move {
cleanup_camera_window(app, session_id).await;
});
}
CapWindowId::Main => {
api.prevent_close();
dismiss_main_window(app);
}
_ => {}
}
}
}
WindowEvent::Destroyed => {
fake_window::cancel_fake_window_listener(app, label);
let window_id = CapWindowId::from_str(label).ok();
if let Some(window_id) = &window_id {
retire_project_window(window, window_id);
}
if app_is_exiting(app) {
return;
}
if export::export_session_active() {
warn!(
window = label,
"Skipping window restoration during active export"
);
return;
}
if let Some(window_id) = window_id {
if matches!(window_id, CapWindowId::Camera) {
tracing::warn!("Camera window Destroyed event received!");
}
match window_id {
CapWindowId::Main => {
let app = app.clone();
close_target_select_overlays(&app);
if let Some(camera) = CapWindowId::Camera.get(&app) {
let _ = camera.hide();
}
spawn_on_runtime(async move {
let Some(state) = app.try_state::<ArcLock<App>>() else {
warn!("App state unavailable during main window destroyed cleanup");
return;
};
let feeds = {
let mut app_state = state.write().await;
if app_state.is_recording_active_or_pending() {
None
} else {
app_state.applied_mic_input.invalidate();
Some((
app_state.mic_feed.clone(),
app_state.camera_feed.clone(),
))
}
};
if let Some((mic_feed, camera_feed)) = feeds {
let _ = tokio::time::timeout(
APP_EXIT_STEP_TIMEOUT,
mic_feed.ask(microphone::RemoveInput),
)
.await;
let _ = tokio::time::timeout(
APP_EXIT_STEP_TIMEOUT,
camera_feed.ask(feeds::camera::RemoveInput),
)
.await;
let mut app_state = state.write().await;
if !app_state.is_recording_active_or_pending() {
app_state.selected_mic_label = None;
app_state.selected_camera_id = None;
app_state.camera_in_use = false;
}
}
});
}
CapWindowId::Editor { .. } | CapWindowId::ScreenshotEditor { .. } => {
editor_recording::abort_if_editor_gone(app);
restore_main_windows_if_no_editors(app);
}
CapWindowId::Settings => {
restore_main_and_target_select_windows(app);
restore_camera_window(app);
#[cfg(target_os = "windows")]
if !has_open_editor_window(app) {
reopen_main_window(app);
}
#[cfg(target_os = "macos")]
return;
}
CapWindowId::Upgrade | CapWindowId::ModeSelect => {
restore_main_and_target_select_windows(app);
restore_camera_window(app);
#[cfg(target_os = "macos")]
return;
}
CapWindowId::TargetSelectOverlay { display_id } => {
if let Some(focus_manager) =
app.try_state::<target_select_overlay::WindowFocusManager>()
{
focus_manager.destroy(&display_id, app.global_shortcut());
}
let session_id = app
.try_state::<Arc<AtomicU64>>()
.map(|state| state.load(Ordering::Acquire))
.unwrap_or(0);
spawn_on_runtime(cleanup_camera_after_overlay_close(
app.clone(),
session_id,
));
}
CapWindowId::Camera => {
tracing::info!(
"Camera window Destroyed event - resetting panel state"
);
let session_id = app
.try_state::<Arc<AtomicU64>>()
.map(|state| state.load(Ordering::Acquire))
.unwrap_or(0);
let app = app.clone();
spawn_on_runtime(async move {
#[cfg(target_os = "macos")]
{
if let Some(panel_manager) =
app.try_state::<panel_manager::PanelManager>()
{
panel_manager
.force_reset(panel_manager::PanelWindowType::Camera)
.await;
}
}
cleanup_camera_window(app, session_id).await;
});
}
_ => {}
};
}
#[cfg(target_os = "macos")]
crate::permissions::sync_macos_dock_visibility(app);
}
#[cfg(target_os = "macos")]
WindowEvent::Focused(focused) => {
let window_id = CapWindowId::from_str(label);
if matches!(window_id, Ok(CapWindowId::Upgrade)) {
for (label, window) in app.webview_windows() {
if let Ok(id) = CapWindowId::from_str(&label)
&& matches!(id, CapWindowId::TargetSelectOverlay { .. })
{
hide_overlay(&window);
}
}
}
if *focused
&& let Ok(window_id) = window_id
&& window_id.activates_dock()
{
crate::permissions::sync_macos_dock_visibility(app);
}
}
WindowEvent::DragDrop(tauri::DragDropEvent::Drop { paths, .. }) => {
let window_id = CapWindowId::from_str(label).ok();
for path in paths {
let result = if matches!(window_id, Some(CapWindowId::Main)) {
open_importable_from_path(path, app.clone())
} else {
open_project_from_path(path, app.clone())
};
if let Err(err) = result {
warn!(path = %path.display(), error = %err, "Failed to open dropped path");
}
}
}
WindowEvent::Moved(position) => {
let window_id = CapWindowId::from_str(label);
#[cfg(target_os = "macos")]
if matches!(&window_id, Ok(CapWindowId::Main))
&& let Some(constrained_position) =
platform::constrain_main_window_to_visible_top(window, *position)
{
match window.set_position(constrained_position) {
Ok(()) => {
let scale_factor = window
.current_monitor()
.ok()
.flatten()
.map(|monitor| monitor.scale_factor())
.unwrap_or_else(|| window.scale_factor().unwrap_or(1.0));
let logical_pos =
constrained_position.to_logical::<f64>(scale_factor);
let display_id = display_for_position(logical_pos.x, logical_pos.y)
.map(|display| display.id());
window_position_persistence::queue_main_position(
app,
general_settings::WindowPosition {
x: logical_pos.x,
y: logical_pos.y,
display_id,
},
);
return;
}
Err(error) => warn!(
%error,
"Failed to constrain main window to the visible screen area"
),
}
}
if let Ok(window_id) = window_id {
let scale_factor = window.scale_factor().unwrap_or(1.0);
let logical_pos = position.to_logical::<f64>(scale_factor);
// Resolve which display the window landed on. On Windows this
// must use the physical position: mixed-DPI logical rects
// overlap, so logical containment can pick the wrong display.
#[cfg(windows)]
let moved_display =
display_for_physical_position(position.x as f64, position.y as f64);
#[cfg(not(windows))]
let moved_display = display_for_position(logical_pos.x, logical_pos.y);
match window_id {
CapWindowId::Main => {
let display_id =
moved_display.as_ref().map(|display| display.id());
window_position_persistence::queue_main_position(
app,
general_settings::WindowPosition {
x: logical_pos.x,
y: logical_pos.y,
display_id,
},
);
}
CapWindowId::Camera => {
if app
.try_state::<CameraWindowPositionGuard>()
.is_some_and(|guard| guard.should_ignore())
{
return;
}
window_position_persistence::queue_camera_position(
app,
logical_pos.x,
logical_pos.y,
moved_display.map(|display| display.id()),
);
}
_ => {}
}
}
}
WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
if let Some(webview_window) = app.get_webview_window(label) {
windows::update_window_rasterization_scale(
&webview_window,
*scale_factor,
);
}
}
_ => {}
}
}));
if let Err(panic) = result {
let message = panic_payload_message(&panic);
tracing::error!(panic = %message, "Suppressed panic in Tauri WindowEvent handler");
sentry::capture_message(
&format!("Tauri WindowEvent panic suppressed: {message}"),
sentry::Level::Error,
);
}
});
run_tauri_event_loop(move || {
builder
.build(tauri_context)
.expect("error while running tauri application")
.run(move |handle, event| {
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
handle_run_event(handle, event);
}));
if let Err(panic) = result {
let message = panic_payload_message(&panic);
tracing::error!(panic = %message, "Suppressed panic in Tauri RunEvent handler");
sentry::capture_message(
&format!("Tauri RunEvent panic suppressed: {message}"),
sentry::Level::Error,
);
}
});
});
}
fn run_tauri_event_loop<R>(run: impl FnOnce() -> R) -> R {
#[cfg(target_os = "linux")]
{
// zbus blocks on its own runtime during plugin setup and shutdown; keep GTK on this thread.
tokio::task::block_in_place(run)
}
#[cfg(not(target_os = "linux"))]
run()
}
fn handle_single_instance(app: &AppHandle, args: Vec<String>) {
trace!(arg_count = args.len(), "Single instance invoked");
#[cfg(target_os = "linux")]
if app
.try_state::<AppExitState>()
.is_some_and(|state| state.is_exiting())
{
return;
}
if gpui_app::handle_update_handoff(app) {
return;
}
#[cfg(any(target_os = "macos", windows))]
if gpui_app::forward_deep_links_to_active_gpui(app, &args) {
return;
}
let action_urls = args
.iter()
.filter(|arg| arg.starts_with("cap-desktop://"))
.filter_map(|arg| tauri::Url::parse(arg).ok())
.collect::<Vec<_>>();
if !action_urls.is_empty() {
deeplink_actions::handle(app, action_urls);
return;
}
let Some(cap_file) = args
.iter()
.find(|arg| arg.ends_with(".cap"))
.map(PathBuf::from)
else {
let app = app.clone();
tauri::async_runtime::spawn(async move {
if let Err(error) = (ShowCapWindow::Main {
init_target_mode: None,
})
.show(&app)
.await
{
warn!(%error, "Could not show Cap recording controls");
}
});
return;
};
let _ = open_project_from_path(&cap_file, app.clone());
}
pub(crate) fn panic_payload_message(payload: &(dyn std::any::Any + Send)) -> String {
if let Some(s) = payload.downcast_ref::<&'static str>() {
(*s).to_string()
} else if let Some(s) = payload.downcast_ref::<String>() {
s.clone()
} else {
"<non-string panic payload>".to_string()
}
}
// Catches panics inside an async Tauri command body so a single bad code path can't
// unwind through the IPC dispatcher and terminate the whole desktop process. This is
// particularly important for commands that participate in the export flow because the
// sidecar architecture relies on the desktop app remaining alive to babysit the worker.
async fn run_command_safely<T, F>(command_name: &'static str, fut: F) -> Result<T, String>
where
F: std::future::Future<Output = Result<T, String>>,
{
match AssertUnwindSafe(fut).catch_unwind().await {
Ok(result) => result,
Err(panic) => {
let message = panic_payload_message(&*panic);
error!(
command = command_name,
panic = %message,
"Suppressed panic in Tauri command"
);
sentry::capture_message(
&format!("Tauri command '{command_name}' panicked: {message}"),
sentry::Level::Error,
);
Err(format!("{command_name} failed unexpectedly"))
}
}
}
fn emit_app_event_safely<E>(app: &AppHandle, event: E)
where
E: Event + Serialize + Clone,
{
let event_name = std::any::type_name::<E>();
match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| event.emit(app))) {
Ok(Ok(())) => {}
Ok(Err(error)) => warn!(event = event_name, %error, "Failed to emit app event"),
Err(panic) => {
let message = panic_payload_message(&panic);
error!(event = event_name, panic = %message, "Suppressed panic while emitting app event");
}
}
}
#[cfg(any(target_os = "macos", test))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum StartupOpenDestination {
Desktop,
Gpui,
}
#[cfg(any(target_os = "macos", test))]
struct StartupOpenDispatch {
destination: StartupOpenDestination,
urls: Vec<tauri::Url>,
}
#[cfg(any(target_os = "macos", test))]
#[derive(Default)]
struct StartupOpenQueue {
destination: Option<StartupOpenDestination>,
cancelled: bool,
urls: Vec<tauri::Url>,
gpui_forwarding: bool,
gpui_dispatched: Vec<tauri::Url>,
}
#[cfg(any(target_os = "macos", test))]
impl StartupOpenQueue {
fn request(&mut self, urls: Vec<tauri::Url>) -> Result<Option<StartupOpenDispatch>, String> {
if self.cancelled {
return Err("Cap startup stopped before the project could be opened".into());
}
if self.destination == Some(StartupOpenDestination::Desktop) {
return Ok(Some(StartupOpenDispatch {
destination: StartupOpenDestination::Desktop,
urls,
}));
}
let mut additions = Vec::new();
for url in urls {
if self.urls.contains(&url)
|| self.gpui_dispatched.contains(&url)
|| additions.contains(&url)
{
continue;
}
if self.urls.len() + self.gpui_dispatched.len() + additions.len() >= 64 {
return Err("Too many projects were requested while Cap was starting".into());
}
additions.push(url);
}
self.urls.extend(additions);
if self.destination == Some(StartupOpenDestination::Gpui) && !self.gpui_forwarding {
return Ok(self.take_queued());
}
Ok(None)
}
fn finish(&mut self, destination: StartupOpenDestination) -> Option<StartupOpenDispatch> {
if self.cancelled || self.destination.is_some() {
return None;
}
self.destination = Some(destination);
self.take_queued()
}
fn take_queued(&mut self) -> Option<StartupOpenDispatch> {
let destination = self.destination?;
if self.urls.is_empty() {
return None;
}
let urls = std::mem::take(&mut self.urls);
if destination == StartupOpenDestination::Gpui {
self.gpui_forwarding = true;
self.gpui_dispatched.extend(urls.iter().cloned());
}
Some(StartupOpenDispatch { destination, urls })
}
fn next_gpui_batch(&mut self) -> Option<StartupOpenDispatch> {
if self.cancelled
|| self.destination != Some(StartupOpenDestination::Gpui)
|| !self.gpui_forwarding
{
return None;
}
if let Some(dispatch) = self.take_queued() {
return Some(dispatch);
}
self.cancel();
None
}
fn cancel(&mut self) {
self.cancelled = true;
self.urls.clear();
self.gpui_dispatched.clear();
self.gpui_forwarding = false;
}
}
#[cfg(any(target_os = "macos", test))]
#[derive(Clone, Default)]
struct StartupOpenGate(Arc<std::sync::Mutex<StartupOpenQueue>>);
#[cfg(any(target_os = "macos", test))]
struct StartupOpenGuard(StartupOpenGate);
#[cfg(any(target_os = "macos", test))]
impl Drop for StartupOpenGuard {
fn drop(&mut self) {
if let Ok(mut queue) = self.0.0.lock()
&& queue.destination.is_none()
{
queue.cancel();
}
}
}
#[cfg(target_os = "macos")]
fn queue_macos_startup_urls(app: &AppHandle, urls: Vec<tauri::Url>) -> Result<(), String> {
let gate = app
.try_state::<StartupOpenGate>()
.ok_or_else(|| "Cap startup is not ready to receive projects".to_string())?;
let dispatch = gate
.0
.lock()
.map_err(|_| "Cap startup file-open state is unavailable".to_string())?
.request(urls)?;
if let Some(dispatch) = dispatch {
dispatch_macos_startup_urls(app, dispatch);
}
Ok(())
}
#[cfg(target_os = "macos")]
fn finish_macos_startup_opens(app: &AppHandle, destination: StartupOpenDestination) {
let Some(gate) = app.try_state::<StartupOpenGate>() else {
return;
};
let dispatch = match gate.0.lock() {
Ok(mut queue) => queue.finish(destination),
Err(error) => {
warn!(%error, "Could not release startup project requests");
return;
}
};
if let Some(dispatch) = dispatch {
dispatch_macos_startup_urls(app, dispatch);
}
}
#[cfg(target_os = "macos")]
fn cancel_macos_startup_opens(app: &AppHandle) {
if let Some(gate) = app.try_state::<StartupOpenGate>()
&& let Ok(mut queue) = gate.0.lock()
{
queue.cancel();
}
}
#[cfg(target_os = "macos")]
fn dispatch_macos_startup_urls(app: &AppHandle, dispatch: StartupOpenDispatch) {
let urls = dispatch.urls;
let arguments = urls
.iter()
.map(|url| url.as_str().to_string())
.collect::<Vec<_>>();
if dispatch.destination == StartupOpenDestination::Gpui {
let Some(redirect) = app.try_state::<gpui_app::StartupRedirectState>() else {
warn!("Cap GPUI startup forwarding state is unavailable");
return;
};
if redirect.begin_forwarding() {
let app = app.clone();
tokio::spawn(async move {
let mut arguments = arguments;
let mut forwarded_pid = None;
loop {
let forwarded = tokio::task::spawn_blocking(move || {
gpui_app::forward_deep_links_to_gpui_when_ready(&arguments)
})
.await
.ok()
.flatten();
if let Some(pid) = forwarded {
forwarded_pid = Some(pid);
} else {
warn!("Could not forward the requested project batch to Cap GPUI");
}
let next = app.try_state::<StartupOpenGate>().and_then(|gate| {
gate.0
.lock()
.ok()
.and_then(|mut queue| queue.next_gpui_batch())
});
let Some(next) = next else {
break;
};
arguments = next
.urls
.iter()
.map(|url| url.as_str().to_string())
.collect();
}
if let Some(pid) = forwarded_pid
&& let Err(error) = app.run_on_main_thread(move || {
gpui_app::activate_instance(pid);
})
{
warn!(%error, "Could not activate Cap GPUI after forwarding a project");
}
if app
.try_state::<gpui_app::StartupRedirectState>()
.is_some_and(|state| state.exit_after_forwarding())
{
app.exit(0);
}
});
} else {
cancel_macos_startup_opens(app);
warn!("Cap GPUI handoff already finished before the project could be forwarded");
}
return;
}
if gpui_app::forward_deep_links_to_active_gpui(app, &arguments) {
return;
}
for url in urls {
if url.scheme() == "file"
&& let Ok(path) = url.to_file_path()
&& let Err(error) = open_project_from_path(&path, app.clone())
{
warn!(path = %path.display(), %error, "Could not open the requested project");
}
}
}
fn handle_run_event(_handle: &AppHandle, event: tauri::RunEvent) {
match event {
#[cfg(target_os = "macos")]
tauri::RunEvent::Opened { urls } => {
if let Err(error) = queue_macos_startup_urls(_handle, urls) {
warn!(%error, "Could not receive the requested startup project");
}
}
#[cfg(target_os = "macos")]
tauri::RunEvent::Reopen { .. } => {
if _handle
.try_state::<gpui_app::StartupRedirectState>()
.is_some()
{
return;
}
if gpui_app::handle_update_handoff(_handle) {
return;
}
let should_focus_onboarding = should_show_onboarding(_handle);
if should_focus_onboarding
&& let Some(onboarding) = CapWindowId::Onboarding.get(_handle)
{
onboarding.show().ok();
onboarding.set_focus().ok();
return;
}
let has_window = _handle.webview_windows().iter().any(|(label, _)| {
label.starts_with("editor-")
|| label.starts_with("screenshot-editor-")
|| label.as_str() == "settings"
|| label.as_str() == "signin"
|| (should_focus_onboarding && label.as_str() == "onboarding")
});
if has_window {
if let Some(window) = _handle
.webview_windows()
.iter()
.find(|(label, _)| {
label.starts_with("editor-")
|| label.starts_with("screenshot-editor-")
|| label.as_str() == "settings"
|| label.as_str() == "signin"
|| (should_focus_onboarding && label.as_str() == "onboarding")
})
.map(|(_, window)| window.clone())
{
window.set_focus().ok();
}
} else {
let handle = _handle.clone();
spawn_on_runtime(async move {
let _ = ShowCapWindow::Main {
init_target_mode: None,
}
.show(&handle)
.await;
});
}
}
tauri::RunEvent::ExitRequested { code, api, .. } => {
info!(?code, "App exit requested");
match handle_exit_requested(
_handle
.try_state::<AppExitState>()
.is_some_and(|state| state.is_exiting()),
export::export_session_active() || upload::upload_session_active(),
code.is_some(),
code == Some(tauri::RESTART_EXIT_CODE),
|| api.prevent_exit(),
) {
ExitRequestDecision::StartCleanup => {
let handle = _handle.clone();
spawn_on_runtime(async move {
request_app_exit(handle).await;
});
}
ExitRequestDecision::AlreadyExiting => {}
ExitRequestDecision::ExportActive => {
warn!("Preventing app exit request during an active export or upload");
}
ExitRequestDecision::AllowRuntimeExit => {}
ExitRequestDecision::AllowRuntimeRestart => {
if let Some(state) = _handle.try_state::<AppExitState>() {
state.begin_restart();
}
crash_sentinel::mark_clean_exit();
info!("Allowing Tauri to restart the app");
}
}
}
tauri::RunEvent::Exit => {
#[cfg(target_os = "macos")]
cancel_macos_startup_opens(_handle);
#[cfg(target_os = "macos")]
{
// This arm runs on the AppKit main thread, so reverse the Liquid Glass
// SPI inline before restart or a hard _exit. This is the last-chance
// teardown for terminal paths that skip cleanup_app_resources_for_exit;
// touching the NSWindow/NSView here is safe because we are on main.
let torn_down = crate::platform::teardown_all_liquid_glass_on_main(_handle);
if _handle
.try_state::<AppExitState>()
.is_some_and(|state| state.is_restarting())
{
info!(
windows = torn_down,
"macOS runtime exit reached; allowing Tauri to restart"
);
return;
}
warn!(
windows = torn_down,
"macOS runtime exit reached; tore down liquid glass, forcing process exit"
);
force_exit(0);
}
#[cfg(not(target_os = "macos"))]
{
let already_exiting = match _handle.try_state::<AppExitState>() {
Some(state) => !state.begin(),
None => false,
};
if already_exiting {
return;
}
let handle = _handle.clone();
spawn_on_runtime(async move {
let _ = tokio::time::timeout(
Duration::from_secs(2),
cleanup_app_resources_for_exit(&handle),
)
.await;
});
}
}
_ => {}
}
}
fn spawn_on_runtime<F>(future: F)
where
F: Future<Output = ()> + Send + 'static,
{
match tokio::runtime::Handle::try_current() {
Ok(handle) => {
handle.spawn(future);
}
Err(err) => {
tracing::warn!(error = %err, "No tokio runtime available; dropping background task");
}
}
}
fn retire_project_window(window: &Window, window_id: &CapWindowId) {
let app = window.app_handle();
match window_id {
CapWindowId::Editor { id } => {
app.state::<editor_preparing::PreparingConsumers>()
.cancel_window(*id, None);
let window_ids = EditorWindowIds::get(app);
match window_ids.ids.lock() {
Ok(mut ids) => ids.retain(|(_, current_id)| current_id != id),
Err(err) => warn!(error = %err, "Editor window ids lock poisoned"),
}
export::cancel_exports_for_window(window.label());
let label = window.label().to_string();
let pending = PendingEditorInstances::get(app);
spawn_on_runtime(async move {
pending.cancel_prewarm(&label).await;
});
spawn_on_runtime(EditorInstances::remove(window.clone()));
}
CapWindowId::ScreenshotEditor { id } => {
let window_ids = ScreenshotEditorWindowIds::get(app);
match window_ids.ids.lock() {
Ok(mut ids) => ids.retain(|(_, current_id)| current_id != id),
Err(err) => warn!(error = %err, "Screenshot editor window ids lock poisoned"),
}
export::cancel_exports_for_window(window.label());
let label = window.label().to_string();
let pending = PendingScreenshotEditorInstances::get(app);
spawn_on_runtime(async move {
pending.cancel_prewarm(&label).await;
});
spawn_on_runtime(ScreenshotEditorInstances::remove(window.clone()));
}
_ => {}
}
}
#[cfg(target_os = "windows")]
fn has_open_editor_window(app: &AppHandle) -> bool {
app.webview_windows()
.keys()
.any(|label| matches!(CapWindowId::from_str(label), Ok(CapWindowId::Editor { .. })))
}
fn restore_main_windows_if_no_editors(app: &AppHandle) {
let has_other_editors = app.webview_windows().keys().any(|label| {
matches!(
CapWindowId::from_str(label),
Ok(CapWindowId::Editor { .. } | CapWindowId::ScreenshotEditor { .. })
)
});
if !has_other_editors {
if CapWindowId::Settings.get(app).is_none() {
if let Some(main) = CapWindowId::Main.get(app) {
let generation = clean_capture::generation(app);
let _ = clean_capture::reveal_now(&main, generation);
}
restore_main_window_inputs(app);
restore_camera_window(app);
}
spawn_on_runtime(captions::release_ml_models());
}
}
fn restore_main_and_target_select_windows(app: &AppHandle) {
let target_select_overlays_hidden_for_restore = app
.try_state::<target_select_overlay::WindowFocusManager>()
.map(|focus_manager| focus_manager.take_overlay_restore_labels())
.unwrap_or_default();
for (label, window) in app.webview_windows() {
if let Ok(id) = CapWindowId::from_str(&label) {
match id {
CapWindowId::TargetSelectOverlay { .. } => {
if window.is_visible().unwrap_or(false)
|| target_select_overlays_hidden_for_restore.contains(label.as_str())
{
show_overlay(&window);
}
}
CapWindowId::Main => {
let generation = clean_capture::generation(app);
let _ = clean_capture::reveal_now(&window, generation);
restore_main_window_inputs(app);
}
_ => {}
}
}
}
}
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 snapshot = app.state::<RequestedInputsState>().snapshot();
if snapshot.camera.value.is_none() || snapshot.camera.pending || snapshot.camera.error.is_some()
{
return;
}
let app = app.clone();
spawn_on_runtime(async move {
let requested = app.state::<RequestedInputsState>();
let _input_operation = requested.operation.lock().await;
let operation_lock = app.state::<CameraWindowOperationLock>();
let _operation_guard = operation_lock.lock().await;
let state = app.state::<ArcLock<App>>();
let can_restore = {
let state = state.read().await;
requested.is_current(&snapshot)
&& !state.is_recording_active_or_pending()
&& !state.camera_cleanup_done
&& state.selected_camera_id == snapshot.camera.value
};
if can_restore {
let _ = show_requested_camera_window(&app, snapshot.camera.revision).await;
}
});
}
fn close_target_select_overlays(app: &AppHandle) {
target_select_overlay::close_target_select_overlay_windows(app);
}
#[cfg(target_os = "windows")]
fn reopen_main_window(app: &AppHandle) {
#[cfg(target_os = "linux")]
if let Some(attempt) = recording::linux_instant::current(app)
&& attempt.has_capture()
&& !attempt.ui_ready()
{
let app = app.clone();
drop(tauri::async_runtime::spawn(async move {
if recording::linux_instant::control(app.clone(), attempt, false)
.await
.is_ok()
{
let _ = ShowCapWindow::Main {
init_target_mode: None,
}
.show(&app)
.await;
}
}));
return;
}
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 {
let _ = ShowCapWindow::Main {
init_target_mode: None,
}
.show(&handle)
.await;
});
}
}
fn instant_upload_may_resume(inner: &RecordingMetaInner) -> bool {
!matches!(
inner,
RecordingMetaInner::Instant(
InstantRecordingMeta::InProgress { .. } | InstantRecordingMeta::Failed { .. }
)
)
}
#[cfg(test)]
fn load_instant_resume_candidate(path: &std::path::Path) -> Result<Option<RecordingMeta>, String> {
load_upload_resume_candidate(path, true).map(|candidate| candidate.map(|(meta, _lock)| meta))
}
fn load_upload_resume_candidate(
path: &std::path::Path,
mark_crashed: bool,
) -> Result<Option<(RecordingMeta, cap_recording::upload_resume::UploadLock)>, String> {
load_upload_resume_candidate_at(path, mark_crashed, SystemTime::now())
}
fn load_upload_resume_candidate_at(
path: &std::path::Path,
mark_crashed: bool,
now: SystemTime,
) -> Result<Option<(RecordingMeta, cap_recording::upload_resume::UploadLock)>, String> {
if !mark_crashed && !upload::recovery_age::eligible(path, now) {
return Ok(None);
}
let lock = match upload::acquire_upload_lock(path) {
Ok(lock) => lock,
Err(_) => return Ok(None),
};
let mut meta = RecordingMeta::load_for_project(path).map_err(|error| error.to_string())?;
if mark_crashed {
let changed = match &mut meta.inner {
RecordingMetaInner::Instant(InstantRecordingMeta::InProgress { .. }) => {
meta.inner = RecordingMetaInner::Instant(InstantRecordingMeta::Failed {
error: "Recording crashed".into(),
});
true
}
RecordingMetaInner::Studio(studio) => {
if let StudioRecordingMeta::MultipleSegments { inner } = &mut **studio
&& matches!(inner.status, Some(StudioRecordingStatus::InProgress))
{
inner.status = Some(StudioRecordingStatus::Failed {
error: "Recording crashed".into(),
});
true
} else {
false
}
}
_ => false,
};
if changed {
meta.save_for_project().map_err(|error| error.to_string())?;
}
}
if !upload::recovery_age::eligible(path, now) {
return Ok(None);
}
upload::lifecycle::reconcile_reupload(&mut meta).map_err(|error| error.to_string())?;
Ok(instant_upload_may_resume(&meta.inner).then_some((meta, lock)))
}
async fn resume_uploads(app: AppHandle, mark_crashed: bool) -> Result<(), String> {
upload::lifecycle::reap().await;
if app_is_exiting(&app) || !upload::lifecycle::has_capacity() {
return Ok(());
}
let scan_app = app.clone();
let paths = tokio::task::spawn_blocking(move || {
let mut paths = Vec::new();
for directory in recordings_locations::known_recordings_dirs(&scan_app) {
let Ok(entries) = std::fs::read_dir(directory) else {
continue;
};
for entry in entries.flatten() {
if app_is_exiting(&scan_app) {
return paths;
}
let path = entry.path();
if path.extension().and_then(|value| value.to_str()) == Some("cap")
&& (mark_crashed || upload::recovery_age::eligible(&path, SystemTime::now()))
{
paths.push(path);
}
}
}
paths
})
.await
.map_err(|error| error.to_string())?;
for path in paths {
if app_is_exiting(&app) || !upload::lifecycle::has_capacity() {
break;
}
let candidate_path = path.clone();
let candidate_app = app.clone();
let candidate = tokio::task::spawn_blocking(move || {
let mark_crashed = mark_crashed
&& candidate_app
.state::<startup::Startup>()
.predates_launch(&candidate_path);
load_upload_resume_candidate(&candidate_path, mark_crashed)
})
.await
.map_err(|error| error.to_string())?;
let (meta, lock) = match candidate {
Ok(Some(candidate)) => candidate,
Ok(None) => continue,
Err(error) => {
warn!(%error, recording = %path.display(), "Recording upload state could not be read; files retained");
continue;
}
};
if matches!(
meta.upload,
None | Some(UploadMeta::Complete | UploadMeta::Failed { .. })
) {
continue;
}
let fallback_audio = matches!(
&meta.inner,
RecordingMetaInner::Instant(InstantRecordingMeta::Complete {
sample_rate: Some(_),
..
})
);
let required_audio =
match upload::lifecycle::resume_audio(&app, &path, fallback_audio).await {
Ok(Some(required_audio)) => required_audio,
Ok(None) => continue,
Err(error) => {
warn!(%error, "Recording upload intent could not be read; files retained");
continue;
}
};
if let Err(error) =
upload::lifecycle::resume_existing(app.clone(), meta, lock, required_audio).await
{
warn!(%error, "Upload retry remains local");
}
}
Ok(())
}
async fn create_editor_instance_impl(
app: &AppHandle,
path: PathBuf,
frame_cb: cap_editor::EditorFrameCallback,
) -> Result<(Arc<EditorInstance>, tauri::EventId), String> {
let app = app.clone();
wait_for_recording_ready(&app, &path).await?;
recording::spawn_heal_oversized_desktop_background_snapshots(path.clone());
let shared_device =
gpu_context::get_shared_gpu()
.await
.map(|shared| cap_rendering::SharedWgpuDevice {
instance: (*shared.instance).clone(),
adapter: (*shared.adapter).clone(),
device: (*shared.device).clone(),
queue: (*shared.queue).clone(),
is_software_adapter: shared.is_software_adapter,
});
#[cfg(debug_assertions)]
let frame_cb: cap_editor::EditorFrameCallback =
if stop_editor_benchmark::frame_capture_requested() {
let capture_path = path.clone();
let mut frame_cb = frame_cb;
Box::new(move |output, layout| {
stop_editor_benchmark::capture_output(
stop_editor_benchmark::CaptureKind::Ordinary,
&capture_path,
&output,
);
frame_cb(output, layout);
})
} else {
frame_cb
};
let (audio_output, startup, live_handoff) = app
.state::<editor_preparing::PreparingConsumers>()
.take_startup(&path)
.await?;
let instance = {
let app = app.clone();
EditorInstance::new_with_startup_inputs(
path,
move |state| {
let _ = EditorStateChanged::new(state).emit(&app);
},
frame_cb,
shared_device,
cap_editor::EditorFrameFormat::Rgba,
audio_output,
startup,
)
.await?
};
if let Some(handoff) = &live_handoff {
instance.install_preparing_handoff(handoff).await?;
}
let event_id = RenderFrameEvent::listen_checked(&app, {
let preview_tx = instance.preview_tx.clone();
move |e| {
preview_tx.send_modify(|v| {
*v = Some((e.frame_number, e.fps, e.resolution_base));
});
}
});
let started = match instance
.start_preparing_handoff(EDITOR_PREVIEW_FPS, default_editor_preview_resolution())
.await
{
Ok(started) => started,
Err(error) => {
app.unlisten(event_id);
let cleanup_failed = if let Some(handoff) = &live_handoff {
handoff.stop_and_wait().await.cleanup_failed
} else {
false
};
instance.dispose().await;
return Err(if cleanup_failed {
format!(
"Preparing handoff start failed: {error:?}; preparing playback cleanup failed"
)
} else {
format!("Preparing handoff start failed: {error:?}")
});
}
};
if !started {
let frame = instance
.preparing_adoption()
.and_then(|adoption| adoption.frame_number(EDITOR_PREVIEW_FPS))
.unwrap_or(0);
instance.preview_tx.send_modify(|v| {
*v = Some((
frame,
EDITOR_PREVIEW_FPS,
default_editor_preview_resolution(),
))
});
}
Ok((instance, event_id))
}
pub(crate) async fn wait_for_recording_ready(app: &AppHandle, path: &Path) -> Result<(), String> {
let result = wait_for_recording_ready_inner(app, path).await;
if result.is_err() {
let cleanup = editor_preparing::join_before_ordinary(app, path).await;
return result.and(cleanup);
}
result
}
async fn await_finalization_before_ordinary(
app: &AppHandle,
path: &Path,
result: watch::Receiver<FinalizationResult>,
) -> Result<(), String> {
let finalization = await_finalization_result(result).await;
let cleanup = editor_preparing::join_before_ordinary(app, path).await;
finalization.and(cleanup)
}
async fn wait_for_recording_ready_inner(app: &AppHandle, path: &Path) -> Result<(), String> {
let display_path = path;
let project = FinalizationProject::observe(path.to_path_buf()).await?;
let path = project.work_path();
let finalizing_state = app.state::<FinalizingRecordings>();
if let Some(result) = finalizing_state.is_finalizing(&project) {
info!("Recording is being finalized, waiting for completion...");
await_finalization_before_ordinary(app, display_path, result).await?;
project.validate_async().await?;
info!("Recording finalization completed");
let meta = RecordingMeta::load_for_project(path)
.map_err(|e| format!("Failed to reload recording meta: {e}"))?;
if let Some(studio_meta) = meta.studio_meta() {
studio_meta.ensure_ordinary_media_access(path)?;
}
return Ok(());
}
editor_preparing::join_before_ordinary(app, display_path).await?;
let meta = match RecordingMeta::load_for_project(path) {
Ok(meta) => meta,
Err(e) => {
return Err(format!("Failed to load recording meta: {e}"));
}
};
if let Some(studio_meta) = meta.studio_meta()
&& matches!(studio_meta.status(), StudioRecordingStatus::InProgress)
{
info!("Recording/import is in progress, waiting for completion...");
const POLL_INTERVAL: std::time::Duration = std::time::Duration::from_millis(250);
const MAX_WAIT: std::time::Duration = std::time::Duration::from_secs(600);
let start = std::time::Instant::now();
loop {
if start.elapsed() > MAX_WAIT {
return Err("Timed out waiting for import to complete".to_string());
}
tokio::time::sleep(POLL_INTERVAL).await;
project.validate_async().await?;
if let Some(result) = finalizing_state.is_finalizing(&project) {
await_finalization_before_ordinary(app, display_path, result).await?;
break;
}
let current_meta = match RecordingMeta::load_for_project(path) {
Ok(m) => m,
Err(_) => continue,
};
if let Some(current_studio) = current_meta.studio_meta() {
match current_studio.status() {
StudioRecordingStatus::Complete => {
info!("Recording/import completed");
break;
}
StudioRecordingStatus::Failed { error } => {
return Err(format!("Import failed: {error}"));
}
StudioRecordingStatus::InProgress => continue,
StudioRecordingStatus::NeedsRemux => break,
}
}
}
}
project.validate_async().await?;
if let Some(result) = finalizing_state.is_finalizing(&project) {
await_finalization_before_ordinary(app, display_path, result).await?;
project.validate_async().await?;
}
let meta = RecordingMeta::load_for_project(path)
.map_err(|e| format!("Failed to reload recording meta: {e}"))?;
if let Some(studio_meta) = meta.studio_meta() {
studio_meta.ensure_ordinary_media_access(path)?;
}
if let Some(studio_meta) = meta.studio_meta()
&& recording::needs_fragment_remux(path, studio_meta)
{
info!("Recording needs remux (crash recovery), starting remux...");
let work_project = FinalizationProject::admit(project.display_path().to_path_buf()).await?;
if work_project.identity != project.identity {
return Err(FinalizationProject::identity_error(
project.display_path(),
"Recording directory changed before recovery",
));
}
match finalizing_state.request(work_project, false, FinalizationOrigin::Recording, false)? {
FinalizationRequest::Started(token) => {
run_finalization_worker(token, recording::remux_fragmented_recording).await?;
}
FinalizationRequest::Existing(result) => {
await_finalization_before_ordinary(app, display_path, result).await?
}
}
project.validate_async().await?;
info!("Crash recovery remux completed");
}
if meta.studio_meta().is_some() {
// Repair video tracks that were stamped at the wrong rate by older
// recorders (slow-motion display on high-refresh Windows monitors,
// 2x-length camera). Non-fatal: the editor still opens with the
// unhealed files if this fails.
let path = path.to_path_buf();
match tokio::task::spawn_blocking(move || {
cap_recording::track_heal::heal_stretched_tracks(&path)
})
.await
{
Ok(Ok(true)) => info!("Healed stretched video track(s)"),
Ok(Ok(false)) => {}
Ok(Err(e)) => warn!("Track heal check failed: {e:#}"),
Err(e) => warn!("Track heal task panicked: {e}"),
}
}
project.validate_async().await?;
Ok(())
}
fn recordings_path(app: &AppHandle) -> PathBuf {
general_settings::GeneralSettingsStore::recordings_dir(app)
}
// fn recording_path(app: &AppHandle, recording_id: &str) -> PathBuf {
// recordings_path(app).join(format!("{recording_id}.cap"))
// }
fn screenshots_path(app: &AppHandle) -> PathBuf {
let path = app.path().app_data_dir().unwrap().join("screenshots");
std::fs::create_dir_all(&path).unwrap_or_default();
path
}
// fn screenshot_path(app: &AppHandle, screenshot_id: &str) -> PathBuf {
// screenshots_path(app).join(format!("{screenshot_id}.cap"))
// }
#[tauri::command]
#[specta::specta]
#[instrument(skip(app))]
fn global_message_dialog(app: AppHandle, message: String) {
app.dialog().message(message).show(|_| {});
}
#[tauri::command]
#[specta::specta]
#[instrument(skip(clipboard))]
async fn write_clipboard_string(
clipboard: MutableState<'_, ClipboardContext>,
text: String,
) -> Result<(), String> {
let writer = clipboard
.try_write()
.map_err(|e| format!("Failed to acquire lock on clipboard state: {e}"))?;
writer
.set_text(text)
.map_err(|e| format!("Failed to write text to clipboard: {e}"))
}
#[tauri::command(async)]
#[specta::specta]
fn format_project_name(
template: Option<String>,
target_name: String,
target_kind: String,
recording_mode: RecordingMode,
datetime: Option<chrono::DateTime<chrono::Local>>,
) -> String {
recording::format_project_name(
template.as_deref(),
target_name.as_str(),
target_kind.as_str(),
recording_mode,
datetime,
)
}
trait EventExt: tauri_specta::Event {
fn listen_any_spawn<Fut>(
app: &AppHandle,
handler: impl Fn(Self, AppHandle) -> Fut + Send + 'static + Clone,
) -> tauri::EventId
where
Fut: Future + Send,
Self: serde::de::DeserializeOwned + Send + 'static,
{
let app = app.clone();
Self::listen_any(&app.clone(), move |e| {
let app = app.clone();
let handler = handler.clone();
tokio::spawn(async move {
(handler)(e.payload, app).await;
});
})
}
}
impl<T: tauri_specta::Event> EventExt for T {}
fn show_import_error_dialog(app: &AppHandle, message: String) {
app.dialog()
.message(message)
.title("Import Error")
.kind(tauri_plugin_dialog::MessageDialogKind::Error)
.show(|_| {});
}
/// Everything a close request on the main window does -- hide it, drop the
/// preview inputs when nothing is recording, and hand the foreground back to
/// the editor that started a "Record a new clip" flow.
pub(crate) fn dismiss_main_window(app: &AppHandle) {
clean_capture::cancel_closed_preflight(app);
hide_main_window(app);
#[cfg(target_os = "macos")]
crate::permissions::schedule_macos_dock_visibility_sync(app);
let Some(state) = app.try_state::<ArcLock<App>>() else {
warn!("App state unavailable during main window close request");
return;
};
let is_recording = state
.try_read()
.map(|s| s.is_recording_active_or_pending())
.unwrap_or(true);
if !is_recording {
if let Some(camera_window) = CapWindowId::Camera.get(app) {
let _ = camera_window.hide();
}
close_target_select_overlays(app);
let app_for_cleanup = app.clone();
spawn_on_runtime(async move {
let app = app_for_cleanup;
let Some(state) = app.try_state::<ArcLock<App>>() else {
warn!("App state unavailable during main window close cleanup");
return;
};
let (mic_feed, camera_feed) = {
let mut app_state = state.write().await;
app_state.camera_preview.pause();
app_state.applied_mic_input.invalidate();
(app_state.mic_feed.clone(), app_state.camera_feed.clone())
};
let _ =
tokio::time::timeout(APP_EXIT_STEP_TIMEOUT, mic_feed.ask(microphone::RemoveInput))
.await;
let _ = tokio::time::timeout(
APP_EXIT_STEP_TIMEOUT,
camera_feed.ask(feeds::camera::RemoveInput),
)
.await;
let mut app_state = state.write().await;
app_state.selected_mic_label = None;
app_state.camera_in_use = false;
});
if let Some(editor_path) = editor_recording::abort(app) {
editor_recording::reveal_editor(app, &editor_path);
}
}
}
pub(crate) fn hide_main_window(app: &AppHandle) {
if let Some(main_window) = CapWindowId::Main.get(app)
&& main_window.hide().is_ok()
{
let _ = main_window.emit_to(CapWindowId::Main.label(), "main-window-hidden", ());
}
}
fn open_importable_from_path(path: &Path, app: AppHandle) -> Result<(), String> {
if import::is_supported_video_import_path(path) {
let source_path = path.to_path_buf();
tokio::spawn(async move {
match import::start_video_import(app.clone(), source_path).await {
Ok(project_path) => {
if let Err(err) = (ShowCapWindow::Editor { project_path }).show(&app).await {
error!("Failed to show imported video editor: {err}");
show_import_error_dialog(
&app,
format!("Failed to open imported video: {err}"),
);
return;
}
hide_main_window(&app);
}
Err(err) => {
error!("Failed to import dropped video: {err}");
show_import_error_dialog(&app, format!("Failed to import video: {err}"));
}
}
});
return Ok(());
}
if import::is_supported_image_import_path(path) {
let source_path = path.to_path_buf();
tokio::spawn(async move {
match import::start_image_import(app.clone(), source_path).await {
Ok(path) => {
if let Err(err) = (ShowCapWindow::ScreenshotEditor { path }).show(&app).await {
error!("Failed to show imported image editor: {err}");
show_import_error_dialog(
&app,
format!("Failed to open imported image: {err}"),
);
return;
}
hide_main_window(&app);
}
Err(err) => {
error!("Failed to import dropped image: {err}");
show_import_error_dialog(&app, format!("Failed to import image: {err}"));
}
}
});
return Ok(());
}
open_project_from_path(path, app)
}
fn open_project_from_path(path: &Path, app: AppHandle) -> Result<(), String> {
#[cfg(target_os = "macos")]
{
let gate = app
.try_state::<StartupOpenGate>()
.ok_or_else(|| "Cap startup is not ready to receive projects".to_string())?;
let ready = {
let queue = gate
.0
.lock()
.map_err(|_| "Cap startup file-open state is unavailable".to_string())?;
!queue.cancelled && queue.destination == Some(StartupOpenDestination::Desktop)
};
if !ready {
let path = if path.is_absolute() {
path.to_path_buf()
} else {
std::env::current_dir()
.map_err(|error| error.to_string())?
.join(path)
};
let url = tauri::Url::from_file_path(path)
.map_err(|_| "The requested project path is invalid".to_string())?;
return queue_macos_startup_urls(&app, vec![url]);
}
}
let meta = RecordingMeta::load_for_project(path).map_err(|v| v.to_string())?;
match &meta.inner {
RecordingMetaInner::Studio(meta) => {
let status = meta.status();
if let StudioRecordingStatus::Failed { .. } = status {
return Err("Unable to open failed recording".to_string());
} else if let StudioRecordingStatus::InProgress = status {
return Err("Recording in progress".to_string());
}
let project_path = path.to_path_buf();
tokio::spawn(async move {
if let Err(error) = (ShowCapWindow::Editor { project_path }).show(&app).await {
warn!(%error, "Could not show the requested project editor");
}
});
}
RecordingMetaInner::Instant(_) => {
let mp4_path = path.join("content/output.mp4");
if mp4_path.exists() && mp4_path.is_file() {
let _ = app
.opener()
.open_path(mp4_path.to_str().unwrap_or_default(), None::<String>);
hide_main_window(&app);
}
}
}
Ok(())
}
#[cfg(test)]
mod startup_project_open_tests {
use super::{StartupOpenDestination, StartupOpenGate, StartupOpenGuard, StartupOpenQueue};
fn project(name: &str) -> tauri::Url {
tauri::Url::parse(&format!("file:///recordings/{name}.cap")).unwrap()
}
#[test]
fn early_file_opens_wait_for_full_desktop_startup() {
let mut queue = StartupOpenQueue::default();
let urls = vec![project("first"), project("second")];
assert!(queue.request(urls.clone()).unwrap().is_none());
let dispatch = queue.finish(StartupOpenDestination::Desktop).unwrap();
assert_eq!(dispatch.destination, StartupOpenDestination::Desktop);
assert_eq!(dispatch.urls, urls);
assert!(queue.urls.is_empty());
assert!(queue.finish(StartupOpenDestination::Desktop).is_none());
}
#[test]
fn queued_files_follow_gpui_handoff_without_opening_classic_editors() {
let mut queue = StartupOpenQueue::default();
let url = project("handoff");
assert!(queue.request(vec![url.clone()]).unwrap().is_none());
let dispatch = queue.finish(StartupOpenDestination::Gpui).unwrap();
assert_eq!(dispatch.destination, StartupOpenDestination::Gpui);
assert_eq!(dispatch.urls, [url]);
assert!(queue.request(vec![project("later")]).unwrap().is_none());
let dispatch = queue.next_gpui_batch().unwrap();
assert_eq!(dispatch.destination, StartupOpenDestination::Gpui);
assert_eq!(dispatch.urls, [project("later")]);
}
#[test]
fn normal_post_ready_file_opens_dispatch_immediately() {
let mut queue = StartupOpenQueue::default();
assert!(queue.finish(StartupOpenDestination::Desktop).is_none());
let url = project("ready");
let dispatch = queue.request(vec![url.clone()]).unwrap().unwrap();
assert_eq!(dispatch.destination, StartupOpenDestination::Desktop);
assert_eq!(dispatch.urls, [url]);
}
#[test]
fn failed_or_cancelled_setup_discards_pending_opens() {
let gate = StartupOpenGate::default();
let guard = StartupOpenGuard(gate.clone());
assert!(
gate.0
.lock()
.unwrap()
.request(vec![project("pending")])
.unwrap()
.is_none()
);
drop(guard);
let mut queue = gate.0.lock().unwrap();
assert!(queue.urls.is_empty());
assert!(queue.request(vec![project("later")]).is_err());
assert!(queue.finish(StartupOpenDestination::Desktop).is_none());
assert!(queue.finish(StartupOpenDestination::Gpui).is_none());
}
#[test]
fn completed_setup_guard_preserves_selected_destination() {
for destination in [
StartupOpenDestination::Desktop,
StartupOpenDestination::Gpui,
] {
let gate = StartupOpenGate::default();
let guard = StartupOpenGuard(gate.clone());
assert!(gate.0.lock().unwrap().finish(destination).is_none());
drop(guard);
let dispatch = gate
.0
.lock()
.unwrap()
.request(vec![project("ready")])
.unwrap()
.unwrap();
assert_eq!(dispatch.destination, destination);
}
}
#[test]
fn pending_file_open_queue_is_bounded_and_deduplicates() {
let mut queue = StartupOpenQueue::default();
for _ in 0..100 {
assert!(queue.request(vec![project("same")]).unwrap().is_none());
}
assert_eq!(queue.urls.len(), 1);
let urls = (0..100).map(|index| project(&index.to_string())).collect();
assert!(queue.request(urls).is_err());
assert_eq!(queue.urls, [project("same")]);
let urls = (0..63).map(|index| project(&index.to_string())).collect();
assert!(queue.request(urls).unwrap().is_none());
assert_eq!(queue.urls.len(), 64);
assert!(queue.request(vec![project("overflow")]).is_err());
}
#[test]
fn gpui_handoff_drains_later_batches_without_duplicate_dispatches() {
let mut queue = StartupOpenQueue::default();
assert!(queue.finish(StartupOpenDestination::Gpui).is_none());
let first = queue.request(vec![project("first")]).unwrap().unwrap();
assert_eq!(first.urls, [project("first")]);
assert!(
queue
.request(vec![project("first"), project("second")])
.unwrap()
.is_none()
);
assert!(queue.request(vec![project("second")]).unwrap().is_none());
let second = queue.next_gpui_batch().unwrap();
assert_eq!(second.urls, [project("second")]);
assert_eq!(second.destination, StartupOpenDestination::Gpui);
assert!(queue.request(vec![project("third")]).unwrap().is_none());
assert_eq!(queue.next_gpui_batch().unwrap().urls, [project("third")]);
assert!(queue.next_gpui_batch().is_none());
assert!(queue.request(vec![project("after-exit")]).is_err());
}
#[test]
fn cancellation_stops_desktop_dispatch_and_gpui_pending_batches() {
for destination in [
StartupOpenDestination::Desktop,
StartupOpenDestination::Gpui,
] {
let mut queue = StartupOpenQueue::default();
assert!(queue.finish(destination).is_none());
assert!(queue.request(vec![project("first")]).unwrap().is_some());
let _ = queue.request(vec![project("pending")]).unwrap();
queue.cancel();
assert!(queue.request(vec![project("after-exit")]).is_err());
assert!(queue.next_gpui_batch().is_none());
assert!(queue.urls.is_empty());
assert!(queue.gpui_dispatched.is_empty());
}
}
}
#[cfg(test)]
mod editor_title_save_tests {
use super::{AppExitState, EditorTitleSaveResponse, wait_for_editor_title_saves};
use std::{collections::HashSet, time::Duration};
use tokio::sync::mpsc;
fn response(request: &str, window: &str, error: Option<&str>) -> EditorTitleSaveResponse {
EditorTitleSaveResponse {
request_id: request.into(),
window_label: window.into(),
error: error.map(str::to_string),
}
}
#[test]
fn failed_title_flush_releases_admission_without_stopping_device_watchers() {
let state = AppExitState::default();
let pending = state.begin_title_flush().unwrap();
assert!(state.exit_pending());
assert!(!state.is_exiting());
assert!(state.begin_title_flush().is_none());
drop(pending);
assert!(!state.exit_pending());
assert!(!state.is_exiting());
let pending = state.begin_title_flush().unwrap();
assert!(state.begin());
drop(pending);
assert!(state.is_exiting());
assert!(state.exit_pending());
}
#[tokio::test]
async fn quit_waits_for_every_editor_and_ignores_stale_or_duplicate_responses() {
let (sender, responses) = mpsc::unbounded_channel();
let pending = HashSet::from(["editor-1".into(), "editor-2".into()]);
sender.send(response("previous", "editor-1", None)).unwrap();
sender.send(response("current", "unknown", None)).unwrap();
sender.send(response("current", "editor-1", None)).unwrap();
sender.send(response("current", "editor-1", None)).unwrap();
let waiting =
wait_for_editor_title_saves("current", pending, responses, Duration::from_secs(1));
tokio::pin!(waiting);
assert!(futures::poll!(&mut waiting).is_pending());
sender.send(response("current", "editor-2", None)).unwrap();
assert_eq!(waiting.await, Ok(()));
}
#[tokio::test]
async fn one_editor_save_failure_prevents_quit() {
let (sender, responses) = mpsc::unbounded_channel();
sender
.send(response("current", "editor-1", Some("disk full")))
.unwrap();
let result = wait_for_editor_title_saves(
"current",
HashSet::from(["editor-1".into(), "editor-2".into()]),
responses,
Duration::from_secs(1),
)
.await;
assert!(result.unwrap_err().contains("disk full"));
}
#[tokio::test]
async fn missing_editor_acknowledgement_does_not_authorize_quit() {
let (_sender, responses) = mpsc::unbounded_channel();
let result = wait_for_editor_title_saves(
"current",
HashSet::from(["editor-1".into()]),
responses,
Duration::from_millis(1),
)
.await;
assert!(result.unwrap_err().contains("Could not confirm"));
}
#[tokio::test]
async fn closed_response_channel_does_not_authorize_quit() {
let (sender, responses) = mpsc::unbounded_channel();
drop(sender);
let result = wait_for_editor_title_saves(
"current",
HashSet::from(["editor-1".into()]),
responses,
Duration::from_secs(1),
)
.await;
assert!(result.unwrap_err().contains("connection closed"));
}
#[tokio::test]
async fn no_editor_requires_no_acknowledgement() {
let (_sender, responses) = mpsc::unbounded_channel();
assert_eq!(
wait_for_editor_title_saves(
"current",
HashSet::new(),
responses,
Duration::from_millis(1),
)
.await,
Ok(())
);
}
}
#[cfg(test)]
mod studio_microphone_ownership_tests {
use super::{
MicrophoneRemovalError, RequestedInputsState, acknowledge_studio_microphone,
replace_owned_microphone, wait_for_microphone_removal,
};
use std::{
path::{Path, PathBuf},
sync::{
Arc, Mutex,
atomic::{AtomicBool, AtomicUsize, Ordering},
},
time::Duration,
};
use tokio::sync::oneshot;
struct Lock {
drops: Arc<AtomicUsize>,
unlock: Option<oneshot::Sender<()>>,
}
impl Drop for Lock {
fn drop(&mut self) {
self.drops.fetch_add(1, Ordering::SeqCst);
if let Some(unlock) = self.unlock.take() {
let _ = unlock.send(());
}
}
}
#[tokio::test]
async fn detach_drops_app_lock_after_ack_and_waits_for_unlock_and_removal() {
let drops = Arc::new(AtomicUsize::new(0));
let (unlock_tx, unlock_rx) = oneshot::channel();
let lock = Arc::new(Lock {
drops: drops.clone(),
unlock: Some(unlock_tx),
});
let app_slot = Mutex::new(Some(lock.clone()));
let actor_slot = Mutex::new(Some(lock));
let (ack_tx, ack_rx) = oneshot::channel();
let unlocked = AtomicBool::new(false);
let removed = AtomicBool::new(false);
let attempts = AtomicUsize::new(0);
let transition = async {
acknowledge_studio_microphone(
async {
ack_rx.await.unwrap();
drop(actor_slot.lock().unwrap().take());
Ok(())
},
async {
replace_owned_microphone(
Path::new("owner"),
Some((Path::new("owner"), &mut *app_slot.lock().unwrap())),
None,
)
},
"detaching",
)
.await
.unwrap();
assert_eq!(drops.load(Ordering::SeqCst), 1);
wait_for_microphone_removal(|| async {
attempts.fetch_add(1, Ordering::SeqCst);
if unlocked.load(Ordering::SeqCst) {
removed.store(true, Ordering::SeqCst);
Ok(())
} else {
Err(MicrophoneRemovalError::Locked)
}
})
.await
.unwrap();
};
tokio::join!(
biased;
transition,
async {
assert!(app_slot.lock().unwrap().is_some());
assert_eq!(drops.load(Ordering::SeqCst), 0);
ack_tx.send(()).unwrap();
unlock_rx.await.unwrap();
assert!(!removed.load(Ordering::SeqCst));
tokio::time::sleep(Duration::from_millis(10)).await;
unlocked.store(true, Ordering::SeqCst);
}
);
assert!(removed.load(Ordering::SeqCst));
assert!(attempts.load(Ordering::SeqCst) >= 2);
}
#[tokio::test]
async fn failed_detach_keeps_app_ownership() {
let drops = Arc::new(AtomicUsize::new(0));
let mut slot = Some(Arc::new(Lock {
drops: drops.clone(),
unlock: None,
}));
let result = acknowledge_studio_microphone(
async { Err("Pause before changing input".into()) },
async {
replace_owned_microphone(
Path::new("owner"),
Some((Path::new("owner"), &mut slot)),
None,
)
},
"detaching",
)
.await;
assert!(result.is_err());
assert!(slot.is_some());
assert_eq!(drops.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn timed_out_detach_keeps_app_ownership() {
let mut slot = Some(Arc::new(1));
let result = acknowledge_studio_microphone(
std::future::pending(),
async {
replace_owned_microphone(
Path::new("owner"),
Some((Path::new("owner"), &mut slot)),
None,
)
},
"detaching",
)
.await;
assert!(result.unwrap_err().contains("Timed out"));
assert!(slot.is_some());
}
#[tokio::test]
async fn stale_successful_attachment_retains_actual_arc_for_next_request() {
let requests = RequestedInputsState::new(Some("A".into()), None);
let revision = requests
.inner
.lock()
.unwrap()
.microphone
.begin(Some("B".into()));
let lock = Arc::new(42);
let actor_slot = Mutex::new(None);
let app_slot = Mutex::new(None);
let (tx, rx) = oneshot::channel();
let (result, ()) = tokio::join!(
biased;
acknowledge_studio_microphone(
async { rx.await.unwrap(); *actor_slot.lock().unwrap() = Some(lock.clone()); Ok(()) },
async { replace_owned_microphone(Path::new("owner"), Some((Path::new("owner"), &mut *app_slot.lock().unwrap())), Some(lock.clone())) },
"attaching",
),
async {
assert!(app_slot.lock().unwrap().is_none());
let _revision = requests.inner.lock().unwrap().microphone.begin(None);
tx.send(()).unwrap();
}
);
result.unwrap();
assert!(!requests.mic_is_current(revision));
assert!(Arc::ptr_eq(
app_slot.lock().unwrap().as_ref().unwrap(),
actor_slot.lock().unwrap().as_ref().unwrap()
));
}
#[tokio::test]
async fn failed_attachment_does_not_retain_new_lock() {
let mut slot: Option<Arc<u32>> = None;
let result = acknowledge_studio_microphone(
async { Err("Studio stopped".into()) },
async {
replace_owned_microphone(
Path::new("owner"),
Some((Path::new("owner"), &mut slot)),
Some(Arc::new(42)),
)
},
"attaching",
)
.await;
assert!(result.is_err());
assert!(slot.is_none());
}
#[tokio::test]
async fn stop_or_replacement_during_ack_does_not_overwrite_another_owner() {
for next_owner in [None, Some(PathBuf::from("new-owner"))] {
let requests = RequestedInputsState::new(None, None);
let _operation = requests.operation.lock().await;
let owner = Mutex::new(Some(PathBuf::from("old-owner")));
let new_lock = Arc::new(9);
let slot = Mutex::new(Some(new_lock.clone()));
let (tx, rx) = oneshot::channel();
let (result, ()) = tokio::join!(
biased;
acknowledge_studio_microphone(
async { rx.await.unwrap(); Ok(()) },
async {
let owner = owner.lock().unwrap();
let mut slot = slot.lock().unwrap();
replace_owned_microphone(Path::new("old-owner"), owner.as_deref().map(|owner| (owner, &mut *slot)), Some(Arc::new(42)))
},
"attaching",
),
async { *owner.lock().unwrap() = next_owner; tx.send(()).unwrap(); }
);
assert!(result.is_err());
assert!(Arc::ptr_eq(
slot.lock().unwrap().as_ref().unwrap(),
&new_lock
));
}
}
#[tokio::test]
async fn locked_input_is_not_reported_removed_at_the_deadline() {
let result = tokio::time::timeout(
Duration::from_secs(2),
wait_for_microphone_removal(|| async { Err(MicrophoneRemovalError::Locked) }),
)
.await
.unwrap();
assert!(result.is_err());
}
#[tokio::test]
async fn unresponsive_remove_ask_is_bounded() {
let result = tokio::time::timeout(
Duration::from_secs(2),
wait_for_microphone_removal(std::future::pending),
)
.await
.unwrap();
assert!(result.unwrap_err().contains("Timed out"));
}
#[tokio::test]
async fn pending_microphone_change_blocks_resume() {
let requests = RequestedInputsState::new(Some("A".into()), None);
let _revision = requests
.inner
.lock()
.unwrap()
.microphone
.begin(Some("B".into()));
let error = requests.try_resume_guard().unwrap_err();
assert!(error.contains("still being configured"));
}
#[tokio::test]
async fn failed_microphone_change_blocks_resume_until_reselected() {
let requests = RequestedInputsState::new(Some("A".into()), None);
let revision = requests
.inner
.lock()
.unwrap()
.microphone
.begin(Some("B".into()));
requests
.inner
.lock()
.unwrap()
.microphone
.finish(revision, &Err("B unavailable".into()));
assert!(
requests
.try_resume_guard()
.unwrap_err()
.contains("B unavailable")
);
let none = requests.inner.lock().unwrap().microphone.begin(None);
requests
.inner
.lock()
.unwrap()
.microphone
.finish(none, &Ok(()));
assert!(requests.try_resume_guard().is_ok());
}
#[tokio::test]
async fn camera_setup_also_blocks_resume() {
let requests = RequestedInputsState::new(None, None);
let _revision = requests.inner.lock().unwrap().camera.begin(None);
assert!(requests.try_resume_guard().unwrap_err().contains("camera"));
}
#[tokio::test]
async fn resume_rejects_busy_operation_without_waiting_for_it() {
let requests = RequestedInputsState::new(None, None);
let _operation = requests.operation.lock().await;
assert!(
requests
.try_resume_guard()
.unwrap_err()
.contains("Input change in progress")
);
}
#[tokio::test]
async fn healthy_resume_holds_operation_until_actor_acknowledgement() {
let requests = RequestedInputsState::new(Some("A".into()), None);
let (tx, rx) = oneshot::channel();
tokio::join!(
biased;
async {
let _guard = requests.try_resume_guard().unwrap();
rx.await.unwrap();
},
async {
assert!(requests.operation.try_lock().is_err());
tx.send(()).unwrap();
}
);
assert!(requests.operation.try_lock().is_ok());
}
#[tokio::test]
async fn non_lock_failure_is_not_retried() {
let attempts = AtomicUsize::new(0);
let result = wait_for_microphone_removal(|| async {
attempts.fetch_add(1, Ordering::SeqCst);
Err(MicrophoneRemovalError::Failed("Actor unavailable".into()))
})
.await;
assert_eq!(result.unwrap_err(), "Actor unavailable");
assert_eq!(attempts.load(Ordering::SeqCst), 1);
}
}
#[cfg(test)]
mod applied_microphone_tests {
use super::{
AppliedMicrophoneInput, RequestedInputsState, finish_microphone_input_change,
wait_for_microphone_setup,
};
use std::sync::Mutex;
use tokio::sync::oneshot;
#[tokio::test]
async fn microphone_configuration_accepts_native_startup_longer_than_legacy_deadline() {
let result = wait_for_microphone_setup(async {
tokio::time::sleep(std::time::Duration::from_millis(1600)).await;
Ok(())
})
.await;
assert_eq!(result, Ok(()));
}
#[tokio::test]
async fn microphone_configuration_preserves_backend_failure() {
let result = wait_for_microphone_setup(async { Err("device disconnected".into()) }).await;
assert_eq!(result, Err("device disconnected".into()));
}
#[derive(Default)]
struct Feed {
applied: AppliedMicrophoneInput,
selected: Option<String>,
actual: Option<String>,
attached: Option<String>,
active: bool,
set_count: usize,
remove_count: usize,
detach_count: usize,
attach_count: usize,
}
impl Feed {
fn healthy_active() -> Self {
Self {
applied: AppliedMicrophoneInput {
valid: true,
generation: 0,
settings: None,
},
selected: Some("A".into()),
actual: Some("A".into()),
attached: Some("A".into()),
active: true,
..Default::default()
}
}
}
async fn apply(
feed: &Mutex<Feed>,
requests: &RequestedInputsState,
label: Option<&str>,
revision: u64,
ready: oneshot::Receiver<()>,
fail: bool,
) -> Result<(), String> {
let generation = {
let mut feed = feed.lock().unwrap();
let active = feed.active;
let selected = feed.selected.clone();
if !feed
.applied
.prepare_change(active, label, selected.as_deref())
{
return Ok(());
}
feed.applied.generation
};
let result = finish_microphone_input_change(
async {
{
let mut feed = feed.lock().unwrap();
if feed.active {
feed.detach_count += 1;
feed.attached = None;
}
}
ready.await.unwrap();
let mut feed = feed.lock().unwrap();
if label.is_some() {
feed.set_count += 1;
} else {
feed.remove_count += 1;
}
feed.actual = if fail {
None
} else {
label.map(str::to_string)
};
if fail {
Err("Setup failed".into())
} else {
Ok(())
}
},
|| requests.mic_is_current(revision),
async {
let mut feed = feed.lock().unwrap();
if feed.active && label.is_some() {
feed.attach_count += 1;
feed.attached = feed.actual.clone();
}
Ok(())
},
)
.await;
if result.is_ok() {
let mut confirmed = false;
requests.publish_mic_if_current(revision, || {
let mut feed = feed.lock().unwrap();
if feed.applied.confirm_if_current(generation) {
feed.selected = label.map(str::to_string);
confirmed = true;
}
});
if !confirmed {
return Err("Input changed during setup".into());
}
}
result
}
fn ready() -> oneshot::Receiver<()> {
let (tx, rx) = oneshot::channel();
tx.send(()).unwrap();
rx
}
#[tokio::test]
async fn stale_a_then_none_removes_actual_input_even_when_metadata_is_none() {
let feed = Mutex::new(Feed::default());
let requests = RequestedInputsState::new(None, None);
let a = requests
.inner
.lock()
.unwrap()
.microphone
.begin(Some("A".into()));
let (tx, rx) = oneshot::channel();
let (old, none) = tokio::join!(apply(&feed, &requests, Some("A"), a, rx, false), async {
let none = requests.inner.lock().unwrap().microphone.begin(None);
tx.send(()).unwrap();
none
});
assert!(old.is_err());
{
let feed = feed.lock().unwrap();
assert_eq!(feed.actual.as_deref(), Some("A"));
assert!(feed.selected.is_none());
assert!(!feed.applied.valid);
}
apply(&feed, &requests, None, none, ready(), false)
.await
.unwrap();
let feed = feed.lock().unwrap();
assert!(feed.actual.is_none());
assert_eq!(feed.remove_count, 1);
}
#[tokio::test]
async fn stale_b_then_a_restores_actual_feed_and_studio_attachment() {
let feed = Mutex::new(Feed::healthy_active());
let requests = RequestedInputsState::new(Some("A".into()), None);
let b = requests
.inner
.lock()
.unwrap()
.microphone
.begin(Some("B".into()));
let (tx, rx) = oneshot::channel();
let (old, a) = tokio::join!(apply(&feed, &requests, Some("B"), b, rx, false), async {
let a = requests
.inner
.lock()
.unwrap()
.microphone
.begin(Some("A".into()));
tx.send(()).unwrap();
a
});
assert!(old.is_err());
assert!(feed.lock().unwrap().attached.is_none());
apply(&feed, &requests, Some("A"), a, ready(), false)
.await
.unwrap();
let feed = feed.lock().unwrap();
assert_eq!(feed.actual.as_deref(), Some("A"));
assert_eq!(feed.attached.as_deref(), Some("A"));
assert_eq!(feed.set_count, 2);
assert_eq!(feed.detach_count, 2);
assert_eq!(feed.attach_count, 1);
}
#[tokio::test]
async fn failed_b_leaves_dirty_state_and_a_cannot_reuse_metadata() {
let feed = Mutex::new(Feed::healthy_active());
let requests = RequestedInputsState::new(Some("A".into()), None);
let b = requests
.inner
.lock()
.unwrap()
.microphone
.begin(Some("B".into()));
assert!(
apply(&feed, &requests, Some("B"), b, ready(), true)
.await
.is_err()
);
{
let feed = feed.lock().unwrap();
assert_eq!(feed.selected.as_deref(), Some("A"));
assert!(feed.actual.is_none());
assert!(feed.attached.is_none());
assert!(!feed.applied.valid);
}
let a = requests
.inner
.lock()
.unwrap()
.microphone
.begin(Some("A".into()));
apply(&feed, &requests, Some("A"), a, ready(), false)
.await
.unwrap();
let feed = feed.lock().unwrap();
assert_eq!(feed.actual.as_deref(), Some("A"));
assert_eq!(feed.attached.as_deref(), Some("A"));
assert_eq!(feed.set_count, 2);
assert_eq!(feed.attach_count, 1);
}
#[tokio::test]
async fn disconnect_during_setup_cannot_restore_validity() {
let feed = Mutex::new(Feed::healthy_active());
let requests = RequestedInputsState::new(Some("A".into()), None);
let b = requests
.inner
.lock()
.unwrap()
.microphone
.begin(Some("B".into()));
let (tx, rx) = oneshot::channel();
let (result, ()) = tokio::join!(
biased;
apply(&feed, &requests, Some("B"), b, rx, false),
async {
feed.lock().unwrap().applied.invalidate();
tx.send(()).unwrap();
}
);
assert!(result.is_err());
let feed = feed.lock().unwrap();
assert!(!feed.applied.valid);
assert_eq!(feed.selected.as_deref(), Some("A"));
}
#[tokio::test]
async fn healthy_active_same_input_has_zero_setup_or_detach() {
let feed = Mutex::new(Feed::healthy_active());
let requests = RequestedInputsState::new(Some("A".into()), None);
let a = requests
.inner
.lock()
.unwrap()
.microphone
.begin(Some("A".into()));
apply(&feed, &requests, Some("A"), a, ready(), false)
.await
.unwrap();
let feed = feed.lock().unwrap();
assert_eq!(feed.set_count, 0);
assert_eq!(feed.detach_count, 0);
assert_eq!(feed.attach_count, 0);
assert_eq!(feed.attached.as_deref(), Some("A"));
}
}
#[cfg(test)]
mod microphone_permission_tests {
use super::{RequestedInput, check_requested_microphone_permission};
#[test]
fn disabled_microphone_bypasses_permission() {
check_requested_microphone_permission(None, || {
panic!("turning the microphone off must not require permission")
})
.unwrap();
}
#[test]
fn saved_microphone_permission_failure_retains_intent_and_blocks_start() {
let mut input = RequestedInput::new(Some("Saved microphone".to_string()));
let revision = input.revision;
let result = check_requested_microphone_permission(input.value.as_deref(), || {
Err("Allow microphone access in System Settings".into())
});
assert!(input.prepare_restore(revision));
input.finish(revision, &result);
assert_eq!(input.value.as_deref(), Some("Saved microphone"));
assert!(!input.pending);
assert!(
input
.validate("microphone")
.unwrap_err()
.contains("System Settings")
);
}
#[test]
fn revoked_access_blocks_current_selection_until_reselected_after_grant() {
let mut input = RequestedInput::new(Some("Saved microphone".to_string()));
let denied = input.begin(Some("Saved microphone".into()));
let result = check_requested_microphone_permission(input.value.as_deref(), || {
Err("Microphone access is blocked".into())
});
input.finish(denied, &result);
assert!(input.validate("microphone").is_err());
let granted = input.begin(Some("Saved microphone".into()));
let result = check_requested_microphone_permission(input.value.as_deref(), || Ok(()));
input.finish(granted, &result);
assert!(input.validate("microphone").is_ok());
assert_eq!(input.value.as_deref(), Some("Saved microphone"));
}
#[test]
fn stale_permission_failure_cannot_replace_a_newer_selection() {
let mut input = RequestedInput::<String>::new(None);
let old = input.begin(Some("Old microphone".into()));
let current = input.begin(Some("New microphone".into()));
let result = check_requested_microphone_permission(Some("Old microphone"), || {
Err("Microphone access is blocked".into())
});
input.finish(old, &result);
assert!(input.pending);
assert!(input.error.is_none());
input.finish(current, &Ok(()));
assert_eq!(input.value.as_deref(), Some("New microphone"));
assert!(input.validate("microphone").is_ok());
}
#[test]
fn explicit_off_clears_permission_failure_and_ignores_old_completion() {
let mut input = RequestedInput::new(Some("Saved microphone".to_string()));
let old = input.begin(Some("Saved microphone".into()));
input.finish(old, &Err("Microphone access is blocked".into()));
let off = input.begin(None);
let result = check_requested_microphone_permission(input.value.as_deref(), || {
panic!("turning the microphone off must not require permission")
});
input.finish(off, &result);
input.finish(old, &Err("Old permission failure".into()));
assert!(input.value.is_none());
assert!(input.validate("microphone").is_ok());
}
}
#[cfg(test)]
mod requested_inputs_tests {
use super::{RequestedInput, RequestedInputsState, wait_for_existing_input};
#[test]
fn matching_pending_requests_share_setup_but_changed_configuration_supersedes_it() {
let mut input = RequestedInput::new(None::<String>);
let settings = serde_json::json!({ "sampleRate": 48_000 });
let (first, joined) = input.begin_or_join(Some("mic".into()), settings.clone(), false);
assert!(!joined);
assert_eq!(
input.begin_or_join(Some("mic".into()), settings.clone(), false),
(first, true)
);
let (second, joined) = input.begin_or_join(
Some("mic".into()),
serde_json::json!({ "sampleRate": 44_100 }),
false,
);
assert!(!joined);
assert_ne!(first, second);
input.finish(first, &Ok(()));
assert!(input.pending);
input.finish(second, &Err("disconnected".into()));
let (retry, joined) = input.begin_or_join(Some("mic".into()), settings, false);
assert!(!joined);
assert_ne!(retry, second);
}
#[tokio::test]
async fn restoring_identical_inputs_during_startup_keeps_recording_publishable() {
let state = RequestedInputsState::new(None, None);
let mic = Some("MacBook Pro Microphone".to_string());
let camera = Some(super::DeviceOrModelID::DeviceID(
"MacBook Pro Camera".into(),
));
let mic_settings = serde_json::json!(null);
let camera_settings = serde_json::json!((None::<serde_json::Value>, false));
let (mic_revision, camera_revision) = {
let mut inputs = state.inner.lock().unwrap();
let (mic_revision, _) =
inputs
.microphone
.begin_or_join(mic.clone(), mic_settings.clone(), false);
inputs.microphone.finish(mic_revision, &Ok(()));
let (camera_revision, _) =
inputs
.camera
.begin_or_join(camera.clone(), camera_settings.clone(), false);
inputs.camera.finish(camera_revision, &Ok(()));
(mic_revision, camera_revision)
};
let snapshot = state.ready_snapshot().unwrap();
let _startup = state.operation.lock().await;
{
let mut inputs = state.inner.lock().unwrap();
assert_eq!(
inputs.microphone.begin_or_join(mic, mic_settings, true),
(mic_revision, true)
);
assert_eq!(
inputs.camera.begin_or_join(camera, camera_settings, true),
(camera_revision, true)
);
}
for (revision, kind) in [(mic_revision, "Microphone"), (camera_revision, "Camera")] {
let result = tokio::time::timeout(std::time::Duration::from_millis(100), async {
if kind == "Microphone" {
wait_for_existing_input(revision, kind, || state.snapshot().microphone).await
} else {
wait_for_existing_input(revision, kind, || state.snapshot().camera).await
}
})
.await
.unwrap();
assert_eq!(result, Ok(()));
}
assert!(state.ready_snapshot().is_ok());
assert!(state.is_current(&snapshot));
let mut published = false;
assert!(state.publish_if_current(&snapshot, || published = true));
assert!(published);
}
#[test]
fn startup_still_rejects_changed_devices_settings_and_disabled_inputs() {
for (value, settings) in [
(Some("other".to_string()), serde_json::json!(48_000)),
(Some("mic".to_string()), serde_json::json!(44_100)),
(None, serde_json::json!(48_000)),
] {
let state = RequestedInputsState::new(None, None);
{
let mut inputs = state.inner.lock().unwrap();
let (revision, _) = inputs.microphone.begin_or_join(
Some("mic".into()),
serde_json::json!(48_000),
false,
);
inputs.microphone.finish(revision, &Ok(()));
}
let snapshot = state.ready_snapshot().unwrap();
let (_, joined) = state
.inner
.lock()
.unwrap()
.microphone
.begin_or_join(value, settings, true);
assert!(!joined);
assert!(!state.is_current(&snapshot));
assert!(!state.publish_if_current(&snapshot, || panic!("changed input published")));
}
}
#[test]
fn completed_requests_are_retried_when_idle_or_previously_failed() {
for (recording_starting, result) in
[(false, Ok(())), (true, Err("disconnected".to_string()))]
{
let mut input = RequestedInput::new(None::<String>);
let (first, _) =
input.begin_or_join(Some("mic".into()), serde_json::json!(null), false);
input.finish(first, &result);
let (retry, joined) = input.begin_or_join(
Some("mic".into()),
serde_json::json!(null),
recording_starting,
);
assert!(!joined);
assert_ne!(retry, first);
assert!(input.pending);
assert!(input.error.is_none());
}
}
#[tokio::test]
async fn joined_input_requests_report_completion_failure_and_supersession() {
for result in [Ok(()), Err("device unavailable".to_string())] {
let input = std::sync::Mutex::new(RequestedInput::new(None::<String>));
let revision = input.lock().unwrap().begin(Some("mic".into()));
let waiter =
wait_for_existing_input(revision, "Microphone", || input.lock().unwrap().clone());
let finish = async {
tokio::task::yield_now().await;
input.lock().unwrap().finish(revision, &result);
};
let (observed, ()) = tokio::join!(waiter, finish);
assert_eq!(observed, result);
input.lock().unwrap().begin(Some("different".into()));
assert!(
wait_for_existing_input(revision, "Microphone", || input.lock().unwrap().clone())
.await
.unwrap_err()
.contains("superseded")
);
}
}
#[test]
fn persisted_intent_is_available_before_preview_setup() {
let state = RequestedInputsState::new(Some("Missing microphone".into()), None);
let snapshot = state.ready_snapshot().unwrap();
assert_eq!(
snapshot.microphone.value.as_deref(),
Some("Missing microphone")
);
assert!(snapshot.camera.value.is_none());
}
#[test]
fn failed_change_retains_requested_device_and_blocks_start() {
let mut input = RequestedInput::new(Some("A".to_string()));
let revision = input.begin(Some("B".to_string()));
input.finish(revision, &Err("B unavailable".into()));
assert_eq!(input.value.as_deref(), Some("B"));
assert!(
input
.validate("microphone")
.unwrap_err()
.contains("B unavailable")
);
}
#[test]
fn stale_completion_cannot_finish_newer_request() {
let mut input = RequestedInput::new(None);
let old = input.begin(Some("A".to_string()));
let current = input.begin(Some("B".to_string()));
input.finish(old, &Err("A failed".into()));
assert!(input.pending);
assert!(input.error.is_none());
assert_eq!(input.value.as_deref(), Some("B"));
input.finish(current, &Ok(()));
assert!(input.validate("microphone").is_ok());
}
#[test]
fn rapid_requests_preserve_explicit_none() {
let mut input = RequestedInput::new(None);
let first = input.begin(Some("A".to_string()));
let second = input.begin(Some("B".to_string()));
let none = input.begin(None);
input.finish(none, &Ok(()));
input.finish(first, &Ok(()));
input.finish(second, &Err("B unavailable".into()));
assert!(input.value.is_none());
assert!(input.validate("microphone").is_ok());
}
#[test]
fn restore_cannot_replace_newer_or_pending_request() {
let mut input = RequestedInput::new(Some("A".to_string()));
let old = input.revision;
let current = input.begin(None);
assert!(!input.prepare_restore(old));
assert!(!input.prepare_restore(current));
input.finish(current, &Ok(()));
assert!(input.prepare_restore(current));
assert!(input.value.is_none());
}
#[test]
fn start_is_blocked_while_setup_is_pending_or_failed() {
let state = RequestedInputsState::new(None, None);
let revision = state
.inner
.lock()
.unwrap()
.microphone
.begin(Some("A".into()));
assert!(state.ready_snapshot().is_err());
state
.inner
.lock()
.unwrap()
.microphone
.finish(revision, &Err("Unavailable".into()));
assert!(state.ready_snapshot().is_err());
let none = state.inner.lock().unwrap().microphone.begin(None);
state.inner.lock().unwrap().microphone.finish(none, &Ok(()));
assert!(state.ready_snapshot().is_ok());
}
#[test]
fn changed_request_prevents_recording_publication() {
let state = RequestedInputsState::new(Some("A".into()), None);
let snapshot = state.ready_snapshot().unwrap();
let _revision = state
.inner
.lock()
.unwrap()
.microphone
.begin(Some("B".into()));
let mut published = false;
assert!(!state.publish_if_current(&snapshot, || published = true));
assert!(!published);
}
#[test]
fn stale_camera_restore_cannot_publish_runtime_state() {
let state = RequestedInputsState::new(None, None);
let revision = state.snapshot().camera.revision;
let _new_revision = state.inner.lock().unwrap().camera.begin(None);
let mut published = false;
assert!(!state.publish_camera_if_current(revision, || published = true));
assert!(!published);
}
#[test]
fn stale_microphone_completion_cannot_publish_runtime_state() {
let state = RequestedInputsState::new(None, None);
let revision = state.snapshot().microphone.revision;
let _new_revision = state.inner.lock().unwrap().microphone.begin(None);
let mut published = false;
assert!(!state.publish_mic_if_current(revision, || published = true));
assert!(!published);
}
#[test]
fn unchanged_request_can_publish_recording() {
let state = RequestedInputsState::new(None, None);
let snapshot = state.ready_snapshot().unwrap();
let mut published = false;
assert!(state.publish_if_current(&snapshot, || published = true));
assert!(published);
}
}
#[cfg(test)]
mod screenshot_share_cache_tests {
use super::*;
fn sharing(content_hash: Option<&str>) -> SharingMeta {
SharingMeta {
id: String::from("video-id"),
link: String::from("https://cap.so/s/video-id"),
content_hash: content_hash.map(str::to_string),
}
}
#[test]
fn reuses_link_when_content_hash_matches() {
let link =
screenshot_share_link_for_hash(Some(&sharing(Some("hash-a"))), "hash-a").unwrap();
assert_eq!(link, "https://cap.so/s/video-id");
}
#[test]
fn does_not_reuse_link_when_content_hash_changed() {
let link = screenshot_share_link_for_hash(Some(&sharing(Some("hash-a"))), "hash-b");
assert!(link.is_none());
}
#[test]
fn does_not_reuse_legacy_link_without_content_hash() {
let link = screenshot_share_link_for_hash(Some(&sharing(None)), "hash-a");
assert!(link.is_none());
}
}
#[cfg(test)]
mod recording_delete_path_tests {
use super::recording_delete_target;
#[test]
fn delete_target_rejects_an_allowed_root_nested_in_another_allowed_root() {
let temp = tempfile::tempdir().unwrap();
let recordings = temp.path().join("recordings");
let nested = recordings.join("nested");
let bundle = nested.join("keep-me.cap");
std::fs::create_dir_all(&bundle).unwrap();
let dirs = [recordings, nested.clone()];
for path in [&nested, &nested.canonicalize().unwrap()] {
assert_eq!(
recording_delete_target(&dirs, path),
Err("Path is not inside a recordings directory".to_string())
);
assert!(bundle.is_dir());
}
assert_eq!(
recording_delete_target(&dirs, &bundle),
Ok(Some(bundle.canonicalize().unwrap()))
);
}
#[test]
fn delete_target_accepts_only_strict_children_of_a_recordings_root() {
let temp = tempfile::tempdir().unwrap();
let recordings = temp.path().join("recordings");
let bundle = recordings.join("delete-me.cap");
let outside = temp.path().join("outside.cap");
std::fs::create_dir_all(&bundle).unwrap();
std::fs::create_dir_all(&outside).unwrap();
assert_eq!(
recording_delete_target(std::slice::from_ref(&recordings), &bundle),
Ok(Some(bundle.canonicalize().unwrap()))
);
assert_eq!(
recording_delete_target(std::slice::from_ref(&recordings), &recordings),
Err("Path is not inside a recordings directory".to_string())
);
assert_eq!(
recording_delete_target(std::slice::from_ref(&recordings), &outside),
Err("Path is not inside a recordings directory".to_string())
);
assert_eq!(
recording_delete_target(
std::slice::from_ref(&recordings),
&recordings.join("..").join("outside.cap"),
),
Err("Invalid path".to_string())
);
assert_eq!(
recording_delete_target(
std::slice::from_ref(&recordings),
&recordings.join("already-gone.cap"),
),
Ok(None)
);
}
#[cfg(unix)]
#[test]
fn delete_target_rejects_a_symlink_escape() {
let temp = tempfile::tempdir().unwrap();
let recordings = temp.path().join("recordings");
let victim = temp.path().join("victim");
let escape = recordings.join("escape.cap");
std::fs::create_dir_all(&recordings).unwrap();
std::fs::create_dir_all(&victim).unwrap();
std::fs::write(victim.join("keep.txt"), b"keep").unwrap();
std::os::unix::fs::symlink(&victim, &escape).unwrap();
assert_eq!(
recording_delete_target(&[recordings], &escape),
Err("Path is not inside a recordings directory".to_string())
);
assert!(victim.join("keep.txt").is_file());
}
#[cfg(windows)]
#[test]
fn delete_target_accepts_a_canonical_windows_project_under_a_raw_root() {
let temp = tempfile::tempdir().unwrap();
let recordings = temp.path().join("recordings");
let bundle = recordings.join("delete-me.cap");
std::fs::create_dir_all(&bundle).unwrap();
let canonical_bundle = bundle.canonicalize().unwrap();
assert_eq!(
recording_delete_target(std::slice::from_ref(&recordings), &canonical_bundle),
Ok(Some(canonical_bundle.clone()))
);
std::fs::remove_dir_all(&canonical_bundle).unwrap();
assert_eq!(
recording_delete_target(&[recordings], &canonical_bundle),
Ok(None)
);
}
}
#[cfg(test)]
mod typescript_bindings_tests {
#[test]
fn export_typescript_bindings() {
let bindings_path = std::path::Path::new("../src/utils/tauri.ts");
if bindings_path.parent().is_some_and(|parent| parent.exists()) {
super::specta_builder()
.export(super::typescript_exporter(), bindings_path)
.expect("failed to export TypeScript bindings");
}
}
}
#[cfg(test)]
mod instant_resume_safety_tests {
use super::*;
#[test]
fn old_recordings_are_reconciled_once_but_skipped_before_periodic_metadata_reads() {
let path = project("old", InstantRecordingMeta::InProgress { recording: true });
let later = path.metadata().unwrap().created().unwrap() + Duration::from_secs(25 * 60 * 60);
assert!(
load_upload_resume_candidate_at(&path, true, later)
.unwrap()
.is_none()
);
assert!(matches!(
RecordingMeta::load_for_project(&path).unwrap().inner,
RecordingMetaInner::Instant(InstantRecordingMeta::Failed { .. })
));
std::fs::write(path.join("recording-meta.json"), b"invalid").unwrap();
assert!(
load_upload_resume_candidate_at(&path, false, later)
.unwrap()
.is_none()
);
assert_eq!(
std::fs::read(path.join("recording-meta.json")).unwrap(),
b"invalid"
);
std::fs::remove_dir_all(path).unwrap();
}
fn project(tag: &str, inner: InstantRecordingMeta) -> PathBuf {
static NEXT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
let path = std::env::temp_dir().join(format!(
"cap-instant-recovery-{tag}-{}-{}",
std::process::id(),
NEXT.fetch_add(1, std::sync::atomic::Ordering::AcqRel)
));
std::fs::create_dir_all(&path).unwrap();
let meta = RecordingMeta {
platform: None,
project_path: path.clone(),
pretty_name: "Synthetic recovery".into(),
sharing: None,
inner: RecordingMetaInner::Instant(inner),
upload: Some(UploadMeta::SegmentUpload {
video_id: "synthetic".into(),
recording_dir: path.clone(),
pre_created_video: VideoUploadInfo {
id: "synthetic".into(),
link: "https://example.invalid/s/synthetic".into(),
config: cap_project::S3UploadMeta {
id: "synthetic".into(),
},
},
}),
};
meta.save_for_project().unwrap();
path
}
#[test]
fn crashed_and_failed_projects_never_become_automatic_upload_candidates() {
for inner in [
InstantRecordingMeta::InProgress { recording: true },
InstantRecordingMeta::Failed {
error: "required audio failed".into(),
},
] {
let path = project("failed", inner);
assert!(load_instant_resume_candidate(&path).unwrap().is_none());
let meta = RecordingMeta::load_for_project(&path).unwrap();
assert!(matches!(
meta.inner,
RecordingMetaInner::Instant(InstantRecordingMeta::Failed { .. })
));
assert!(matches!(
meta.upload,
Some(UploadMeta::SegmentUpload { .. })
));
assert!(path.is_dir());
std::fs::remove_dir_all(path).unwrap();
}
}
#[test]
fn positively_complete_project_remains_resumable_without_media_deletion() {
let path = project(
"complete",
InstantRecordingMeta::Complete {
fps: 30,
sample_rate: Some(48000),
},
);
assert!(load_instant_resume_candidate(&path).unwrap().is_some());
assert!(path.is_dir());
std::fs::remove_dir_all(path).unwrap();
}
#[test]
fn invalid_recovery_metadata_cannot_authorize_upload() {
let path = project(
"invalid",
InstantRecordingMeta::Complete {
fps: 30,
sample_rate: None,
},
);
std::fs::write(path.join("recording-meta.json"), b"invalid").unwrap();
assert!(load_instant_resume_candidate(&path).is_err());
assert!(path.is_dir());
std::fs::remove_dir_all(path).unwrap();
}
#[test]
fn periodic_reconciliation_does_not_mark_an_active_recording_failed() {
let path = project(
"periodic",
InstantRecordingMeta::InProgress { recording: true },
);
assert!(
load_upload_resume_candidate(&path, false)
.unwrap()
.is_none()
);
assert!(matches!(
RecordingMeta::load_for_project(&path).unwrap().inner,
RecordingMetaInner::Instant(InstantRecordingMeta::InProgress { recording: true })
));
std::fs::remove_dir_all(path).unwrap();
}
#[test]
fn another_upload_owner_prevents_startup_metadata_mutation() {
let path = project(
"owned",
InstantRecordingMeta::InProgress { recording: true },
);
let lock = cap_recording::upload_resume::UploadLock::acquire(&path).unwrap();
let before = std::fs::read(path.join("recording-meta.json")).unwrap();
assert!(load_upload_resume_candidate(&path, true).unwrap().is_none());
assert_eq!(
std::fs::read(path.join("recording-meta.json")).unwrap(),
before
);
drop(lock);
std::fs::remove_dir_all(path).unwrap();
}
#[test]
fn explicit_delete_accepts_idle_gpui_recordings_while_resume_defers_them() {
let path = project(
"gpui-delete",
InstantRecordingMeta::Complete {
fps: 30,
sample_rate: None,
},
);
std::fs::write(path.join("instant-upload.json"), b"{}").unwrap();
assert!(upload::acquire_upload_lock(&path).is_err());
let ownership = acquire_recording_delete_lock(&path).unwrap();
assert!(acquire_recording_delete_lock(&path).is_err());
std::fs::remove_dir_all(&path).unwrap();
drop(ownership);
assert!(!path.exists());
}
#[test]
fn explicit_delete_cannot_bypass_another_clients_active_upload_lock() {
let path = project(
"active-delete",
InstantRecordingMeta::Complete {
fps: 30,
sample_rate: None,
},
);
let ownership = cap_recording::upload_resume::UploadLock::acquire(&path).unwrap();
let original = std::fs::read(path.join("recording-meta.json")).unwrap();
assert!(acquire_recording_delete_lock(&path).is_err());
assert_eq!(
std::fs::read(path.join("recording-meta.json")).unwrap(),
original
);
drop(ownership);
std::fs::remove_dir_all(path).unwrap();
}
}
#[cfg(test)]
mod recent_media_tests {
use super::*;
#[test]
fn limited_history_matches_the_full_list_with_invalid_metadata_and_timestamp_ties() {
let candidates = vec![
("old", 1.0),
("first tie", 4.0),
("broken", 5.0),
("second tie", 4.0),
("middle", 2.0),
];
let load = |path, timestamp| (path != "broken").then_some((path, timestamp));
let full = newest_valid_media(candidates.clone(), usize::MAX, load);
let recent = newest_valid_media(candidates, 2, load);
assert_eq!(recent, full[..2]);
assert_eq!(recent, vec![("first tie", 4.0), ("second tie", 4.0)]);
}
#[test]
fn a_large_library_only_loads_metadata_for_the_requested_recent_items() {
let mut loads = 0;
let recent = newest_valid_media(
(0..10_000).map(|id| (id, f64::from(id))).collect(),
9,
|id, _| {
loads += 1;
Some(id)
},
);
assert_eq!(loads, 9);
assert_eq!(recent, (9991..10_000).rev().collect::<Vec<_>>());
}
}
#[cfg(test)]
mod camera_permission_tests {
use super::{
DeviceOrModelID, RequestedInput, RequestedInputsState, await_current_camera_request,
check_requested_camera_permission,
};
fn camera(name: &str) -> DeviceOrModelID {
DeviceOrModelID::DeviceID(name.into())
}
#[test]
fn disabled_camera_bypasses_permission() {
check_requested_camera_permission(None, || {
panic!("turning the camera off must not require permission")
})
.unwrap();
}
#[test]
fn saved_camera_permission_failure_preserves_intent_and_retry() {
let mut input = RequestedInput::new(Some(camera("Saved camera")));
let revision = input.revision;
assert!(input.prepare_restore(revision));
let result = check_requested_camera_permission(input.value.as_ref(), || {
Err("Allow camera access in System Settings".into())
});
input.finish(revision, &result);
assert_eq!(input.value, Some(camera("Saved camera")));
assert!(!input.pending);
assert!(
input
.validate("camera")
.unwrap_err()
.contains("System Settings")
);
assert!(input.prepare_restore(revision));
let result = check_requested_camera_permission(input.value.as_ref(), || Ok(()));
input.finish(revision, &result);
assert!(input.validate("camera").is_ok());
}
#[test]
fn revoked_camera_access_requires_successful_reselection() {
let mut input = RequestedInput::new(Some(camera("Saved camera")));
let denied = input.begin(Some(camera("Saved camera")));
let result = check_requested_camera_permission(input.value.as_ref(), || {
Err("Camera access is blocked".into())
});
input.finish(denied, &result);
assert!(input.validate("camera").is_err());
let granted = input.begin(Some(camera("Saved camera")));
let result = check_requested_camera_permission(input.value.as_ref(), || Ok(()));
input.finish(granted, &result);
input.finish(denied, &Err("Stale denial".into()));
assert!(input.validate("camera").is_ok());
assert_eq!(input.value, Some(camera("Saved camera")));
}
#[test]
fn camera_off_clears_permission_failure_without_requesting_access() {
let mut input = RequestedInput::new(Some(camera("Saved camera")));
let old = input.begin(Some(camera("Saved camera")));
input.finish(old, &Err("Camera access is blocked".into()));
let off = input.begin(None);
let result = check_requested_camera_permission(input.value.as_ref(), || {
panic!("camera off must not request permission")
});
input.finish(off, &result);
input.finish(old, &Err("Old failure".into()));
assert!(input.value.is_none());
assert!(input.validate("camera").is_ok());
}
#[tokio::test]
async fn current_camera_setup_keeps_success_and_device_failure() {
assert_eq!(
await_current_camera_request(async { Ok::<_, String>(()) }, || true).await,
Ok(Ok(()))
);
assert_eq!(
await_current_camera_request(
async { Err::<(), _>("CameraTimeout".to_string()) },
|| true
)
.await,
Ok(Err("CameraTimeout".into()))
);
}
#[tokio::test]
async fn stale_camera_ready_failure_does_not_publish_or_retry() {
let requested = RequestedInputsState::new(None, Some(camera("Saved camera")));
let revision = requested
.inner
.lock()
.unwrap()
.camera
.begin(Some(camera("Saved camera")));
let result = await_current_camera_request(
async {
let mut current = requested.inner.lock().unwrap();
let latest = current.camera.begin(Some(camera("New camera")));
current.camera.finish(latest, &Ok(()));
Err::<(), _>("CameraTimeout".to_string())
},
|| requested.camera_is_current(revision),
)
.await;
assert!(result.unwrap_err().contains("superseded"));
let mut published = false;
assert!(!requested.publish_camera_if_current(revision, || published = true));
assert!(!published);
assert!(requested.snapshot().camera.validate("camera").is_ok());
assert_eq!(
requested.snapshot().camera.value,
Some(camera("New camera"))
);
}
#[tokio::test]
async fn stale_camera_ready_success_cannot_clear_newer_failure() {
let requested = RequestedInputsState::new(None, Some(camera("Saved camera")));
let revision = requested
.inner
.lock()
.unwrap()
.camera
.begin(Some(camera("Saved camera")));
let result = await_current_camera_request(
async {
let mut current = requested.inner.lock().unwrap();
let latest = current.camera.begin(Some(camera("Saved camera")));
current
.camera
.finish(latest, &Err("New selection failed".into()));
Ok::<(), String>(())
},
|| requested.camera_is_current(revision),
)
.await;
assert!(result.unwrap_err().contains("superseded"));
assert_eq!(
requested.snapshot().camera.error.as_deref(),
Some("New selection failed")
);
}
#[tokio::test]
async fn superseded_camera_retry_wait_cannot_start_another_attempt() {
let requested = RequestedInputsState::new(None, Some(camera("Saved camera")));
let revision = requested
.inner
.lock()
.unwrap()
.camera
.begin(Some(camera("Saved camera")));
let mut attempts = 1;
let retry = await_current_camera_request(
async {
requested.inner.lock().unwrap().camera.begin(None);
},
|| requested.camera_is_current(revision),
)
.await;
if retry.is_ok() {
attempts += 1;
}
assert!(retry.unwrap_err().contains("superseded"));
assert_eq!(attempts, 1);
assert!(requested.snapshot().camera.value.is_none());
}
#[test]
fn superseded_camera_cleanup_cannot_mark_a_newer_camera_disconnected() {
let requested = RequestedInputsState::new(None, Some(camera("Old camera")));
let old = requested
.inner
.lock()
.unwrap()
.camera
.begin(Some(camera("Old camera")));
let latest = requested
.inner
.lock()
.unwrap()
.camera
.begin(Some(camera("New camera")));
requested
.inner
.lock()
.unwrap()
.camera
.finish(latest, &Ok(()));
let mut connected = true;
let mut notification = None;
assert!(!requested.publish_camera_if_current(old, || {
connected = false;
notification = Some("Camera unavailable");
}));
assert!(connected);
assert!(notification.is_none());
}
}