fix(windows): stop camera enumeration leaking device resources and pause idle polling in the tray (#2143)

* fix: stop Media Foundation camera enumeration leaking device resources

* fix: pause device polling while Cap idles hidden in the tray

* fix: stop DirectShow camera enumeration instantiating capture filters

* fix: fall back to DirectShow when a Media Foundation device is unusable

* fix: cover remaining main-window hide paths and restore native visibility detection

* fix: release unusable MF sources and harden DirectShow fallback pairing

* fix: pause queries when the main window hides itself from the frontend

* fix: shut down unusable MF-only devices before returning empty formats

* fix: pause queries explicitly on frontend main-window hides

* fix: harden main-window hide coverage and pause ordering

Author: Hona

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

@@ -92,7 +92,10 @@ impl MainWindowRecordingStartBehaviour {
                 #[cfg(windows)]
                 return window.minimize();
                 #[cfg(not(windows))]
-                window.hide()
+                {
+                    crate::hide_main_window(window.app_handle());
+                    Ok(())
+                }
             }
             Self::Minimise => window.minimize(),
         }

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

@@ -1752,6 +1752,12 @@ async fn get_devices_snapshot() -> DevicesUpdated {
     }
 }
 
+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);
@@ -1768,6 +1774,14 @@ fn spawn_devices_snapshot_emitter(app_handle: AppHandle) {
                 continue;
             }
 
+            // Device snapshots only feed UI pickers via DevicesUpdated, so
+            // polling while every window sits hidden in the tray probes the
+            // OS device stack and burns CPU for nobody (#2132).
+            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),
@@ -4741,9 +4755,7 @@ pub async fn open_target_picker(
 ) {
     use tauri::Manager;
 
-    if let Some(window) = CapWindowId::Main.get(app) {
-        window.hide().ok();
-    }
+    hide_main_window(app);
 
     let state = app.state::<target_select_overlay::WindowFocusManager>();
     let display_id = None;
@@ -5665,7 +5677,7 @@ pub async fn run(recording_logging_handle: LoggingHandle, logs_dir: PathBuf) {
                                 }
                                 CapWindowId::Main => {
                                 api.prevent_close();
-                                let _ = window.hide();
+                                hide_main_window(app);
 
                                 #[cfg(target_os = "macos")]
                                 crate::permissions::schedule_macos_dock_visibility_sync(app);
@@ -6819,9 +6831,15 @@ fn show_import_error_dialog(app: &AppHandle, message: String) {
         .show(|_| {});
 }
 
-fn hide_main_window(app: &AppHandle) {
-    if let Some(main_window) = CapWindowId::Main.get(app) {
-        let _ = main_window.hide();
+// Hidden webviews on Windows never see document.visibilityState change
+// (tauri-apps/tauri#9524), so the frontend cannot detect hide-to-tray on its
+// own; this event lets it pause polling, and only fires when the hide
+// actually happened so a failed hide never pauses a visible window (#2132).
+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", ());
     }
 }
 
@@ -6901,9 +6919,7 @@ fn open_project_from_path(path: &Path, app: AppHandle) -> Result<(), String> {
                 let _ = app
                     .opener()
                     .open_path(mp4_path.to_str().unwrap_or_default(), None::<String>);
-                if let Some(main_window) = CapWindowId::Main.get(&app) {
-                    main_window.hide().ok();
-                }
+                hide_main_window(&app);
             }
         }
     }

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

@@ -163,6 +163,8 @@ fn hide_recording_windows(app: &AppHandle, restore_target_select_overlays: bool)
                     focus_manager.remember_overlay_for_restore(label);
                 }
                 hide_overlay(&window);
+            } else if matches!(id, CapWindowId::Main) {
+                crate::hide_main_window(app);
             } else {
                 let _ = window.hide();
             }
@@ -1515,7 +1517,7 @@ impl ShowCapWindow {
                 init_target_mode: Some(target_mode),
             } = self
             {
-                window.hide().ok();
+                crate::hide_main_window(app);
                 emit_app_event(
                     app,
                     RequestSetTargetMode {
@@ -2044,9 +2046,7 @@ impl ShowCapWindow {
                 window
             }
             Self::Upgrade => {
-                if let Some(main) = CapWindowId::Main.get(app) {
-                    let _ = main.hide();
-                }
+                crate::hide_main_window(app);
 
                 let window = self
                     .window_builder(app, "/upgrade")
@@ -2080,9 +2080,7 @@ impl ShowCapWindow {
                 window
             }
             Self::ModeSelect => {
-                if let Some(main) = CapWindowId::Main.get(app) {
-                    let _ = main.hide();
-                }
+                crate::hide_main_window(app);
 
                 let window = self
                     .window_builder(app, "/mode-select")
@@ -2116,9 +2114,7 @@ impl ShowCapWindow {
                 window
             }
             Self::Onboarding => {
-                if let Some(main) = CapWindowId::Main.get(app) {
-                    let _ = main.hide();
-                }
+                crate::hide_main_window(app);
 
                 let width = (cursor_monitor.width * 0.58).clamp(860.0, 1080.0);
                 let height = (width * 0.72).clamp(690.0, 780.0);

apps/desktop/src/app.tsx

@@ -1,5 +1,9 @@
 import { Route, Router, useCurrentMatches } from "@solidjs/router";
-import { QueryClient, QueryClientProvider } from "@tanstack/solid-query";
+import {
+	focusManager,
+	QueryClient,
+	QueryClientProvider,
+} from "@tanstack/solid-query";
 import {
 	getCurrentWebviewWindow,
 	type WebviewWindow,
@@ -124,6 +128,7 @@ export default function App() {
 function Inner() {
 	const currentWindow = getCurrentWebviewWindow();
 	createThemeListener(currentWindow);
+	createHiddenWindowQueryPause(currentWindow);
 
 	onMount(() => {
 		initAnonymousUser();
@@ -288,6 +293,46 @@ function prewarmFontCaches() {
 	else setTimeout(warm, 250);
 }
 
+// Hidden Tauri windows never flip document.visibilityState on Windows
+// (tauri-apps/tauri#9524), so TanStack keeps every refetchInterval firing
+// while the app idles in the tray (#2132). Pause queries when the backend
+// hides the window; on focus, hand control back to TanStack's own
+// visibilitychange detection (setFocused(undefined)) so platforms where it
+// works, like macOS minimize, keep pausing natively.
+function createHiddenWindowQueryPause(currentWindow: WebviewWindow) {
+	if (currentWindow.label !== "main") return;
+
+	let focusGeneration = 0;
+
+	const unlisteners = [
+		currentWindow.listen("main-window-hidden", () => {
+			focusManager.setFocused(false);
+		}),
+		currentWindow.onFocusChanged((event) => {
+			focusGeneration += 1;
+			if (event.payload) {
+				focusManager.setFocused(undefined);
+				return;
+			}
+			// Safety net for hide paths that bypass hide_main_window and
+			// hideCurrentWindow: a blur with the window no longer visible
+			// means hidden, not just unfocused. Not sufficient alone — an
+			// earlier benign blur (e.g. shell.open) masks a later hide. The
+			// generation guard stops a stale visibility result from pausing a
+			// window that regained focus while the check was in flight.
+			const generation = focusGeneration;
+			void currentWindow.isVisible().then((visible) => {
+				if (visible || generation !== focusGeneration) return;
+				focusManager.setFocused(false);
+			});
+		}),
+	];
+
+	onCleanup(() => {
+		for (const unlisten of unlisteners) void unlisten.then((fn) => fn());
+	});
+}
+
 function createThemeListener(currentWindow: WebviewWindow) {
 	const [appTheme, setAppTheme] = createSignal<AppTheme | null | undefined>();
 	let disposed = false;

apps/desktop/src/routes/(window-chrome)/new-main/ChangeLogButton.tsx

@@ -1,9 +1,9 @@
 import { makePersisted } from "@solid-primitives/storage";
 import { getVersion } from "@tauri-apps/api/app";
-import { getCurrentWindow } from "@tauri-apps/api/window";
 import { createEffect, createResource } from "solid-js";
 import { createStore } from "solid-js/store";
 import Tooltip from "~/components/Tooltip";
+import { hideCurrentWindow } from "~/utils/hide-window";
 import { commands } from "~/utils/tauri";
 import { apiClient } from "~/utils/web-api";
 import IconLucideBell from "~icons/lucide/bell";
@@ -36,7 +36,7 @@ const ChangelogButton = () => {
 
 	const handleChangelogClick = () => {
 		commands.showWindow({ Settings: { page: "changelog" } });
-		getCurrentWindow().hide();
+		hideCurrentWindow();
 		const version = currentVersion();
 		if (version) {
 			setChangelogState({

apps/desktop/src/routes/(window-chrome)/new-main/index.tsx

@@ -55,6 +55,7 @@ import {
 	type MicrophoneWithDetails,
 } from "~/utils/devices";
 import { clientEnv } from "~/utils/env";
+import { hideCurrentWindow } from "~/utils/hide-window";
 import {
 	importImageFromPicker,
 	importVideoFromPicker,
@@ -2024,7 +2025,7 @@ function Page() {
 		if (pickerActive && !hasHidden && !recording) {
 			setHasHiddenMainWindowForPicker(true);
 			setShouldRevealMainWindowAfterPicker(!editorPicker);
-			void getCurrentWindow().hide();
+			void hideCurrentWindow();
 		} else if (pickerActive && hasHidden) {
 			setShouldRevealMainWindowAfterPicker(!editorPicker);
 		} else if (recording) {
@@ -2922,7 +2923,7 @@ function Page() {
 			await shell.open(link);
 		}
 
-		await getCurrentWindow().hide();
+		await hideCurrentWindow();
 	};
 
 	const openScreenshot = async (screenshot: ScreenshotWithPath) => {
@@ -3224,7 +3225,7 @@ function Page() {
 								type="button"
 								onClick={async () => {
 									await commands.showWindow({ Settings: { page: "general" } });
-									getCurrentWindow().hide();
+									hideCurrentWindow();
 								}}
 								class="flex items-center justify-center size-5 focus:outline-hidden"
 							>
@@ -3412,7 +3413,7 @@ function Page() {
 										await commands.showWindow({
 											Settings: { page: "recordings" },
 										});
-										getCurrentWindow().hide();
+										hideCurrentWindow();
 									}}
 									uploadProgress={uploadProgress}
 									reuploadingPaths={reuploadingPaths()}
@@ -3436,7 +3437,7 @@ function Page() {
 										await commands.showWindow({
 											Settings: { page: "screenshots" },
 										});
-										getCurrentWindow().hide();
+										hideCurrentWindow();
 									}}
 								/>
 							) : variant === "camera" ? (

apps/desktop/src/utils/hide-window.ts

@@ -0,0 +1,14 @@
+import { focusManager } from "@tanstack/solid-query";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+
+// Counterpart of the Rust-side hide_main_window for hides initiated by the
+// window's own frontend. An earlier blur (e.g. shell.open stealing focus)
+// leaves a later hide invisible to the focus bridge, and
+// document.visibilityState never flips on Windows (tauri-apps/tauri#9524),
+// so the polling pause must be explicit — after the hide succeeds, so a
+// failed hide never pauses a still-visible window.
+export async function hideCurrentWindow() {
+	const currentWindow = getCurrentWindow();
+	await currentWindow.hide();
+	if (currentWindow.label === "main") focusManager.setFocused(false);
+}

apps/desktop/src/utils/importMedia.ts

@@ -1,6 +1,6 @@
 import { invoke } from "@tauri-apps/api/core";
-import { getCurrentWindow } from "@tauri-apps/api/window";
 import * as dialog from "@tauri-apps/plugin-dialog";
+import { hideCurrentWindow } from "~/utils/hide-window";
 import { commands } from "~/utils/tauri";
 
 const videoExtensions = [
@@ -32,7 +32,7 @@ const selectedPath = (result: string | string[] | null) =>
 	typeof result === "string" ? result : null;
 
 const maybeHideCurrentWindow = async (options?: ImportOptions) => {
-	if (options?.hideCurrentWindow) await getCurrentWindow().hide();
+	if (options?.hideCurrentWindow) await hideCurrentWindow();
 };
 
 export const importVideoPath = async (

crates/camera-directshow/examples/cli.rs

@@ -42,7 +42,12 @@ mod windows {
 
             let device = selected.0;
 
-            let video_control = device.output_pin().cast::<IAMVideoControl>().ok();
+            let output_pin = device
+                .output_pin()
+                .expect("failed to bind capture filter for selected device")
+                .clone();
+
+            let video_control = output_pin.cast::<IAMVideoControl>().ok();
 
             let formats = device
                 .media_types()
@@ -65,7 +70,7 @@ mod windows {
 
                     if let Some(video_control) = &video_control {
                         let time_per_frame_list = video_control.time_per_frame_list(
-                            device.output_pin(),
+                            &output_pin,
                             i as i32,
                             SIZE {
                                 cx: width,