A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
fix(voice): stop asking for camera and mic access on page load (#2657)
Hampus35d73eae7618
diff --git a/fluxer_app/src/app/App.tsx b/fluxer_app/src/app/App.tsxindex 4d959da4a..86845a99a 100644--- a/fluxer_app/src/app/App.tsx+++ b/fluxer_app/src/app/App.tsx@@ -55,7 +55,6 @@ import {VoiceLiveKitRoot} from '@app/features/voice/components/VoiceLiveKitRoot'import MediaEngine from '@app/features/voice/engine/MediaEngineFacade';import {useElectronScreenSharePicker} from '@app/features/voice/hooks/useElectronScreenSharePicker';import {startScreenSharePiPController} from '@app/features/voice/state/ScreenSharePiPController';-import {startMediaDeviceStartupPreload} from '@app/features/voice/utils/MediaDeviceStartupPreload';import {useNativeTitleBar} from '@app/features/window/hooks/useNativeTitleBar';import {useStopFlashFrameOnFocus} from '@app/features/window/hooks/useStopFlashFrameOnFocus';import {useWindowEventListeners} from '@app/features/window/hooks/useWindowEventListeners';@@ -149,7 +148,6 @@ export const AppWrapper = observer(({children}: AppWrapperProps) => {};}, []);useEffect(() => startScreenSharePiPController(), []);- useEffect(() => startMediaDeviceStartupPreload(), []);useServiceWorkerBadge();useKeybindManager(i18n);useDesktopElectronBridges();diff --git a/fluxer_app/src/features/app/components/layout/AppLayout.tsx b/fluxer_app/src/features/app/components/layout/AppLayout.tsxindex 8e7011bc6..96a7ca1e5 100644--- a/fluxer_app/src/features/app/components/layout/AppLayout.tsx+++ b/fluxer_app/src/features/app/components/layout/AppLayout.tsx@@ -8,6 +8,7 @@ import * as AuthenticationCommands from '@app/features/auth/commands/Authenticatimport AccountManager from '@app/features/auth/state/AccountManager';import Authentication from '@app/features/auth/state/Authentication';import GatewayConnection from '@app/features/gateway/transport/GatewayConnection';+import {MediaDeviceStartupPreloadManager} from '@app/features/voice/components/MediaDeviceStartupPreloadManager';import {NewDeviceMonitoringManager} from '@app/features/voice/components/NewDeviceMonitoringManager';import {VoiceReconnectionManager} from '@app/features/voice/components/VoiceReconnectionManager';import {clsx} from 'clsx';@@ -35,6 +36,9 @@ export const AppLayout = observer(({children}: {children: React.ReactNode}) => {return (<>{isAuthenticated && socket && <VoiceReconnectionManager data-flx="app.app-layout.voice-reconnection-manager" />}+ {isAuthenticated && (+ <MediaDeviceStartupPreloadManager data-flx="app.app-layout.media-device-startup-preload-manager" />+ )}{isAuthenticated && <NewDeviceMonitoringManager data-flx="app.app-layout.new-device-monitoring-manager" />}{isAuthenticated && <RequiredActionGate data-flx="app.app-layout.required-action-gate" />}<divdiff --git a/fluxer_app/src/features/voice/components/MediaDeviceStartupPreloadManager.test.tsx b/fluxer_app/src/features/voice/components/MediaDeviceStartupPreloadManager.test.tsxnew file mode 100644index 000000000..927e9a8c6--- /dev/null+++ b/fluxer_app/src/features/voice/components/MediaDeviceStartupPreloadManager.test.tsx@@ -0,0 +1,61 @@+// @vitest-environment happy-dom+// SPDX-License-Identifier: AGPL-3.0-or-later++import {act, createElement} from 'react';+import {createRoot, type Root} from 'react-dom/client';+import {beforeEach, describe, expect, test, vi} from 'vitest';++const preload = vi.hoisted(() => ({+ start: vi.fn(),+ stop: vi.fn(),+}));++vi.mock('@app/features/voice/utils/MediaDeviceStartupPreload', () => ({+ startMediaDeviceStartupPreload: () => {+ preload.start();+ return preload.stop;+ },+}));++const {MediaDeviceStartupPreloadManager} = await import(+ '@app/features/voice/components/MediaDeviceStartupPreloadManager'+);++(globalThis as {IS_REACT_ACT_ENVIRONMENT?: boolean}).IS_REACT_ACT_ENVIRONMENT = true;++let root: Root;++beforeEach(() => {+ vi.clearAllMocks();+ document.body.replaceChildren();+ const host = document.createElement('div');+ document.body.append(host);+ root = createRoot(host);+});++describe('MediaDeviceStartupPreloadManager', () => {+ test('starts the preload once loaded and stops it on unmount', async () => {+ act(() => {+ root.render(createElement(MediaDeviceStartupPreloadManager));+ });+ await vi.waitFor(() => expect(preload.start).toHaveBeenCalledTimes(1));+ expect(preload.stop).not.toHaveBeenCalled();+ act(() => {+ root.unmount();+ });+ expect(preload.stop).toHaveBeenCalledTimes(1);+ });++ test('never starts the preload when unmounted before it finishes loading', async () => {+ act(() => {+ root.render(createElement(MediaDeviceStartupPreloadManager));+ });+ act(() => {+ root.unmount();+ });+ await import('@app/features/voice/utils/MediaDeviceStartupPreload');+ await new Promise((resolve) => setTimeout(resolve, 0));+ expect(preload.start).not.toHaveBeenCalled();+ expect(preload.stop).not.toHaveBeenCalled();+ });+});diff --git a/fluxer_app/src/features/voice/components/MediaDeviceStartupPreloadManager.ts b/fluxer_app/src/features/voice/components/MediaDeviceStartupPreloadManager.tsnew file mode 100644index 000000000..f79523416--- /dev/null+++ b/fluxer_app/src/features/voice/components/MediaDeviceStartupPreloadManager.ts@@ -0,0 +1,27 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import {Logger} from '@app/features/platform/utils/AppLogger';+import {loadLazyModule} from '@app/features/platform/utils/LazyModuleLoader';+import {useEffect} from 'react';++const logger = new Logger('MediaDeviceStartupPreloadManager');++export const MediaDeviceStartupPreloadManager: React.FC = () => {+ useEffect(() => {+ let disposed = false;+ let stopPreload: (() => void) | null = null;+ void loadLazyModule(() => import('@app/features/voice/utils/MediaDeviceStartupPreload'))+ .then(({startMediaDeviceStartupPreload}) => {+ if (disposed) return;+ stopPreload = startMediaDeviceStartupPreload();+ })+ .catch((error) => {+ logger.warn('Failed to load media device startup preload', {error});+ });+ return () => {+ disposed = true;+ stopPreload?.();+ };+ }, []);+ return null;+};diff --git a/fluxer_app/src/features/voice/utils/MediaDeviceStartupPreload.test.ts b/fluxer_app/src/features/voice/utils/MediaDeviceStartupPreload.test.tsnew file mode 100644index 000000000..3da25537c--- /dev/null+++ b/fluxer_app/src/features/voice/utils/MediaDeviceStartupPreload.test.ts@@ -0,0 +1,98 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import {afterEach, beforeEach, describe, expect, test, vi} from 'vitest';++const mediaPermission = vi.hoisted(() => ({+ isInitialized: () => true,+ isMicrophoneGranted: () => true,+ isCameraGranted: () => true,+ getMicrophonePermissionState: (): PermissionState => 'granted',+ getCameraPermissionState: (): PermissionState => 'granted',+ addChangeListener: (listener: () => void): (() => void) => {+ listener();+ return () => {};+ },+}));++vi.mock('@app/features/permissions/system/state/MediaPermission', () => ({default: mediaPermission}));++const makeDevice = (kind: MediaDeviceKind, deviceId: string, label: string): MediaDeviceInfo =>+ ({+ deviceId,+ groupId: `${deviceId}-group`,+ kind,+ label,+ toJSON: () => ({deviceId, kind, label}),+ }) as MediaDeviceInfo;++const getUserMediaCalls: Array<MediaStreamConstraints> = [];+let browserExposesLabels = false;++const fakeMediaDevices = {+ enumerateDevices: async (): Promise<Array<MediaDeviceInfo>> => [+ makeDevice('audioinput', 'mic-1', browserExposesLabels ? 'Studio Mic' : ''),+ makeDevice('videoinput', 'cam-1', browserExposesLabels ? 'Studio Camera' : ''),+ ],+ getUserMedia: async (constraints: MediaStreamConstraints): Promise<MediaStream> => {+ getUserMediaCalls.push(constraints);+ return {getTracks: () => []} as unknown as MediaStream;+ },+ addEventListener: () => {},+ removeEventListener: () => {},+};++let originalNavigator: PropertyDescriptor | undefined;+let originalWindow: PropertyDescriptor | undefined;++beforeEach(() => {+ getUserMediaCalls.length = 0;+ browserExposesLabels = false;+ originalNavigator = Object.getOwnPropertyDescriptor(globalThis, 'navigator');+ originalWindow = Object.getOwnPropertyDescriptor(globalThis, 'window');+ Object.defineProperty(globalThis, 'navigator', {+ configurable: true,+ value: {userAgent: 'node', mediaDevices: fakeMediaDevices},+ });+ Object.defineProperty(globalThis, 'window', {+ configurable: true,+ value: {matchMedia: () => ({matches: false})},+ });+ vi.resetModules();+});++afterEach(() => {+ if (originalNavigator) {+ Object.defineProperty(globalThis, 'navigator', originalNavigator);+ } else {+ Reflect.deleteProperty(globalThis, 'navigator');+ }+ if (originalWindow) {+ Object.defineProperty(globalThis, 'window', originalWindow);+ } else {+ Reflect.deleteProperty(globalThis, 'window');+ }+});++const runStartupPreload = async () => {+ const {startMediaDeviceStartupPreload} = await import('@app/features/voice/utils/MediaDeviceStartupPreload');+ const {default: VoiceDevicePermissionState} = await import('@app/features/voice/engine/VoiceDevicePermissionState');+ const stopPreload = startMediaDeviceStartupPreload();+ const state = await VoiceDevicePermissionState.ensureDevices();+ stopPreload();+ return state;+};++describe('startMediaDeviceStartupPreload', () => {+ test('never opens capture for a granted microphone and camera when the browser hides device labels', async () => {+ const state = await runStartupPreload();+ expect(getUserMediaCalls).toEqual([]);+ expect(state.permissionStatus).toEqual({audio: 'idle', video: 'idle'});+ });++ test('confirms a granted microphone and camera from exposed device labels without opening capture', async () => {+ browserExposesLabels = true;+ const state = await runStartupPreload();+ expect(getUserMediaCalls).toEqual([]);+ expect(state.permissionStatus).toEqual({audio: 'granted', video: 'granted'});+ });+});diff --git a/fluxer_app/src/features/voice/utils/MediaDeviceStartupPreload.ts b/fluxer_app/src/features/voice/utils/MediaDeviceStartupPreload.tsindex 92a1d6f4a..442467cf8 100644--- a/fluxer_app/src/features/voice/utils/MediaDeviceStartupPreload.ts+++ b/fluxer_app/src/features/voice/utils/MediaDeviceStartupPreload.ts@@ -12,9 +12,9 @@ export function startMediaDeviceStartupPreload(): () => void {let lastPermissionStateKey: string | null = null;const preloadDevices = () => {if (stopped) return;- const requestPermissionTypes: Array<VoiceMediaPermissionType> = [];- if (MediaPermission.isMicrophoneGranted()) requestPermissionTypes.push('audio');- if (MediaPermission.isCameraGranted()) requestPermissionTypes.push('video');+ const grantedPermissionTypes: Array<VoiceMediaPermissionType> = [];+ if (MediaPermission.isMicrophoneGranted()) grantedPermissionTypes.push('audio');+ if (MediaPermission.isCameraGranted()) grantedPermissionTypes.push('video');const permissionStateKey = [MediaPermission.isInitialized() ? 'initialized' : 'pending',MediaPermission.getMicrophonePermissionState() ?? 'unknown',@@ -22,16 +22,18 @@ export function startMediaDeviceStartupPreload(): () => void {].join(':');const deviceState = VoiceDevicePermissionState.getState();const forceRefresh = lastPermissionStateKey !== null && lastPermissionStateKey !== permissionStateKey;- const requestedPermissionStatesSettled = requestPermissionTypes.every(+ const grantedPermissionStatesSettled = grantedPermissionTypes.every((type) => deviceState.permissionStatus[type] !== 'idle',);- if (!forceRefresh && lastPermissionStateKey === permissionStateKey && requestedPermissionStatesSettled) {+ if (!forceRefresh && lastPermissionStateKey === permissionStateKey && grantedPermissionStatesSettled) {return;}lastPermissionStateKey = permissionStateKey;- void VoiceDevicePermissionState.ensureDevices({forceRefresh, requestPermissionTypes}).catch((error) => {- logger.debug('Failed to preload media devices', {error});- });+ void VoiceDevicePermissionState.ensureDevices({forceRefresh, confirmPermissionTypes: grantedPermissionTypes}).catch(+ (error) => {+ logger.debug('Failed to preload media devices', {error});+ },+ );};const disposePermissionListener = MediaPermission.addChangeListener(preloadDevices);return () => {diff --git a/fluxer_app/src/features/voice/utils/VoiceDeviceManager.ts b/fluxer_app/src/features/voice/utils/VoiceDeviceManager.tsindex 4e7fd6ffb..59d7bd3ea 100644--- a/fluxer_app/src/features/voice/utils/VoiceDeviceManager.ts+++ b/fluxer_app/src/features/voice/utils/VoiceDeviceManager.ts@@ -28,12 +28,16 @@ export function hasDeviceLabels(devices: ReadonlyArray<MediaDeviceInfo>): booleaexport type VoiceMediaPermissionType = 'audio' | 'video';export type VoiceMediaPermissionStatus = 'idle' | 'loading' | 'granted' | 'denied';+type VoiceMediaPermissionIntent = 'confirm' | 'request';-const MAX_ENUMERATION_CHAIN_PASSES = 3;+const VOICE_MEDIA_PERMISSION_TYPES: ReadonlyArray<VoiceMediaPermissionType> = ['audio', 'video'];+const VOICE_MEDIA_PERMISSION_INTENTS: ReadonlyArray<VoiceMediaPermissionIntent> = ['confirm', 'request'];+const MAX_ENUMERATION_CHAIN_PASSES = 1 + VOICE_MEDIA_PERMISSION_TYPES.length * VOICE_MEDIA_PERMISSION_INTENTS.length;export interface EnsureVoiceDevicesOptions {requestPermissions?: boolean;requestPermissionTypes?: ReadonlyArray<VoiceMediaPermissionType>;+ confirmPermissionTypes?: ReadonlyArray<VoiceMediaPermissionType>;forceRefresh?: boolean;}@@ -393,8 +397,8 @@ class VoiceDeviceManager {};private listeners = new Set<Listener>();private enumerationChainPromise: Promise<VoiceDeviceState> | null = null;- private scheduledEnumerationPermissionTypes = new Set<VoiceMediaPermissionType>();- private enumerationChainPermissionTypes = new Set<VoiceMediaPermissionType>();+ private scheduledEnumerationPermissionIntents = new Map<VoiceMediaPermissionType, VoiceMediaPermissionIntent>();+ private enumerationChainPermissionIntents = new Map<VoiceMediaPermissionType, VoiceMediaPermissionIntent>();private hasEnumeratedDevices = false;constructor() {@@ -416,11 +420,10 @@ class VoiceDeviceManager {}public async ensureDevices(options: EnsureVoiceDevicesOptions = {}): Promise<VoiceDeviceState> {- const requestPermissionTypes = this.resolveRequestedPermissionTypes(options);- const requestPermissions = requestPermissionTypes.length > 0;+ const permissionIntents = this.resolvePermissionIntents(options);const forceRefresh = options.forceRefresh ?? false;logger.debug('ensureDevices called', {- requestPermissionTypes,+ permissionIntents: Object.fromEntries(permissionIntents),forceRefresh,hasEnumeratingPromise: !!this.enumerationChainPromise,currentState: {@@ -428,39 +431,50 @@ class VoiceDeviceManager {permissionStatus: this.state.permissionStatus,},});- if (!forceRefresh && !this.enumerationChainPromise && this.canUseCachedState(requestPermissions)) {+ if (!forceRefresh && !this.enumerationChainPromise && this.canUseCachedState(permissionIntents.size > 0)) {logger.debug('Using cached device state');return this.state;}if (this.enumerationChainPromise) {- this.scheduleMissingPermissionTypes(requestPermissionTypes);+ this.scheduleMissingPermissionIntents(permissionIntents);logger.debug('Joining existing enumeration promise');return this.enumerationChainPromise;}logger.debug('Creating new enumeration promise');- return this.startEnumerationChain(requestPermissionTypes);+ return this.startEnumerationChain(permissionIntents);}- private scheduleMissingPermissionTypes(requestPermissionTypes: ReadonlyArray<VoiceMediaPermissionType>): void {- for (const type of requestPermissionTypes) {- if (this.enumerationChainPermissionTypes.has(type)) continue;- this.enumerationChainPermissionTypes.add(type);- this.scheduledEnumerationPermissionTypes.add(type);+ private scheduleMissingPermissionIntents(+ permissionIntents: ReadonlyMap<VoiceMediaPermissionType, VoiceMediaPermissionIntent>,+ ): void {+ for (const [type, intent] of permissionIntents) {+ const chainIntent = this.enumerationChainPermissionIntents.get(type);+ if (chainIntent === 'request' || chainIntent === intent) continue;+ this.enumerationChainPermissionIntents.set(type, intent);+ this.scheduledEnumerationPermissionIntents.set(type, intent);}}- private resolveRequestedPermissionTypes(options: EnsureVoiceDevicesOptions): Array<VoiceMediaPermissionType> {- if (options.requestPermissionTypes) {- return [...new Set(options.requestPermissionTypes)];+ private resolvePermissionIntents(+ options: EnsureVoiceDevicesOptions,+ ): Map<VoiceMediaPermissionType, VoiceMediaPermissionIntent> {+ const permissionIntents = new Map<VoiceMediaPermissionType, VoiceMediaPermissionIntent>();+ for (const type of options.confirmPermissionTypes ?? []) {+ permissionIntents.set(type, 'confirm');}- return options.requestPermissions === true ? ['audio', 'video'] : [];+ const requestPermissionTypes: ReadonlyArray<VoiceMediaPermissionType> =+ options.requestPermissionTypes ?? (options.requestPermissions === true ? VOICE_MEDIA_PERMISSION_TYPES : []);+ for (const type of requestPermissionTypes) {+ permissionIntents.set(type, 'request');+ }+ return permissionIntents;}- private canUseCachedState(requestPermissions: boolean): boolean {+ private canUseCachedState(hasPermissionIntents: boolean): boolean {if (!this.hasEnumeratedDevices) {return false;}- return !requestPermissions;+ return !hasPermissionIntents;}private updatePermissionStatusForTypes(@@ -475,42 +489,44 @@ class VoiceDeviceManager {}private startEnumerationChain(- requestPermissionTypes: ReadonlyArray<VoiceMediaPermissionType>,+ permissionIntents: ReadonlyMap<VoiceMediaPermissionType, VoiceMediaPermissionIntent>,): Promise<VoiceDeviceState> {- this.enumerationChainPermissionTypes = new Set(requestPermissionTypes);- const pendingPromise = this.runEnumerationChain(requestPermissionTypes).finally(() => {+ this.enumerationChainPermissionIntents = new Map(permissionIntents);+ const pendingPromise = this.runEnumerationChain(permissionIntents).finally(() => {if (this.enumerationChainPromise !== pendingPromise) return;logger.debug('Enumeration promise completed');this.enumerationChainPromise = null;- this.scheduledEnumerationPermissionTypes.clear();- this.enumerationChainPermissionTypes.clear();+ this.scheduledEnumerationPermissionIntents.clear();+ this.enumerationChainPermissionIntents.clear();});this.enumerationChainPromise = pendingPromise;return pendingPromise;}private async runEnumerationChain(- initialPermissionTypes: ReadonlyArray<VoiceMediaPermissionType>,+ initialPermissionIntents: ReadonlyMap<VoiceMediaPermissionType, VoiceMediaPermissionIntent>,): Promise<VoiceDeviceState> {- let requestPermissionTypes = [...initialPermissionTypes];+ let permissionIntents = initialPermissionIntents;let state = this.state;for (let pass = 0; pass < MAX_ENUMERATION_CHAIN_PASSES; pass += 1) {- state = await this.enumerateDevices(requestPermissionTypes);- if (this.scheduledEnumerationPermissionTypes.size === 0) return state;- requestPermissionTypes = [...this.scheduledEnumerationPermissionTypes];- this.scheduledEnumerationPermissionTypes.clear();+ state = await this.enumerateDevices(permissionIntents);+ if (this.scheduledEnumerationPermissionIntents.size === 0) return state;+ permissionIntents = new Map(this.scheduledEnumerationPermissionIntents);+ this.scheduledEnumerationPermissionIntents.clear();}- if (this.scheduledEnumerationPermissionTypes.size > 0) {+ if (this.scheduledEnumerationPermissionIntents.size > 0) {throw new Error(`Voice device enumeration exceeded ${MAX_ENUMERATION_CHAIN_PASSES} bounded passes`);}return state;}private async enumerateDevices(- requestPermissionTypes: ReadonlyArray<VoiceMediaPermissionType>,+ permissionIntents: ReadonlyMap<VoiceMediaPermissionType, VoiceMediaPermissionIntent>,): Promise<VoiceDeviceState> {+ const permissionTypes = [...permissionIntents.keys()];+ const requestPermissionTypes = permissionTypes.filter((type) => permissionIntents.get(type) === 'request');const requestPermissions = requestPermissionTypes.length > 0;- logger.debug('enumerateDevices started', {requestPermissionTypes});+ logger.debug('enumerateDevices started', {permissionIntents: Object.fromEntries(permissionIntents)});if (!navigator.mediaDevices?.enumerateDevices) {logger.debug('Navigator or mediaDevices API not available');return this.state;@@ -535,20 +551,20 @@ class VoiceDeviceManager {hasLabel: !!d.label,})),});- const permissionTypesWithLabels = requestPermissionTypes.filter((type) => {+ const permissionTypesWithLabels = permissionTypes.filter((type) => {const requiredKind = type === 'audio' ? 'audioinput' : 'videoinput';return devices.some((device) => device.kind === requiredKind && device.label !== '');});for (const type of permissionTypesWithLabels) {permissionStatus[type] = 'granted';}- if (requestPermissions && permissionTypesWithLabels.length === requestPermissionTypes.length) {+ const unresolvedRequestTypes = requestPermissionTypes.filter((type) => permissionStatus[type] !== 'granted');+ if (requestPermissions && unresolvedRequestTypes.length === 0) {logger.debug('Devices have labels, permissions already granted');- } else if (requestPermissions && isDesktop()) {+ } else if (unresolvedRequestTypes.length > 0 && isDesktop()) {logger.debug('No labels detected; attempting native permission flow');- const unresolvedNativeTypes = requestPermissionTypes.filter((type) => permissionStatus[type] !== 'granted');const nativeResults = await Promise.all(- unresolvedNativeTypes.map(async (type) => {+ unresolvedRequestTypes.map(async (type) => {try {return {type,diff --git a/fluxer_app/src/features/voice/utils/VoiceDevicePermissionTypes.test.ts b/fluxer_app/src/features/voice/utils/VoiceDevicePermissionTypes.test.tsindex 493efe03b..79903932e 100644--- a/fluxer_app/src/features/voice/utils/VoiceDevicePermissionTypes.test.ts+++ b/fluxer_app/src/features/voice/utils/VoiceDevicePermissionTypes.test.ts@@ -24,13 +24,17 @@ const makeStream = (kinds: Array<'audio' | 'video'>): MediaStream => {};const getUserMediaCalls: Array<MediaStreamConstraints> = [];+const enumerationHooks: Array<() => void> = [];let labelledDevices = false;const fakeMediaDevices: FakeMediaDevices = {- enumerateDevices: async () =>- labelledDevices+ enumerateDevices: async () => {+ await Promise.resolve();+ enumerationHooks.shift()?.();+ return labelledDevices? [makeDevice('audioinput', 'mic-1', 'Studio Mic'), makeDevice('videoinput', 'cam-1', 'Studio Camera')]- : [makeDevice('audioinput', 'mic-1', ''), makeDevice('videoinput', 'cam-1', '')],+ : [makeDevice('audioinput', 'mic-1', ''), makeDevice('videoinput', 'cam-1', '')];+ },getUserMedia: async (constraints) => {getUserMediaCalls.push(constraints);labelledDevices = true;@@ -43,12 +47,21 @@ const fakeMediaDevices: FakeMediaDevices = {removeEventListener: () => {},};+const fakeElectron = {+ platform: 'darwin',+ checkMediaAccess: vi.fn(async () => 'granted'),+ requestMediaAccess: vi.fn(async () => true),+};+let originalNavigator: PropertyDescriptor | undefined;let originalWindow: PropertyDescriptor | undefined;beforeEach(() => {getUserMediaCalls.length = 0;+ enumerationHooks.length = 0;labelledDevices = false;+ fakeElectron.checkMediaAccess.mockClear();+ fakeElectron.requestMediaAccess.mockClear();originalNavigator = Object.getOwnPropertyDescriptor(globalThis, 'navigator');originalWindow = Object.getOwnPropertyDescriptor(globalThis, 'window');Object.defineProperty(globalThis, 'navigator', {@@ -80,6 +93,13 @@ const loadManager = async () => {return module.voiceDeviceManager;};+const runAsDesktop = () => {+ Object.defineProperty(globalThis, 'window', {+ configurable: true,+ value: {matchMedia: () => ({matches: false}), electron: fakeElectron},+ });+};+describe('voiceDeviceManager permission types', () => {test('an audio-only request never asks the browser for video', async () => {const manager = await loadManager();@@ -111,4 +131,63 @@ describe('voiceDeviceManager permission types', () => {expect(state.permissionStatus).toEqual({audio: 'idle', video: 'idle'});expect(state.inputDevices.length).toBeGreaterThan(0);});++ test('a confirmation never asks the browser for access when device labels are hidden', async () => {+ const manager = await loadManager();+ const state = await manager.ensureDevices({confirmPermissionTypes: ['audio', 'video'], forceRefresh: true});+ expect(getUserMediaCalls).toEqual([]);+ expect(state.permissionStatus).toEqual({audio: 'idle', video: 'idle'});+ });++ test('a confirmation marks only the confirmed type granted from exposed device labels', async () => {+ labelledDevices = true;+ const manager = await loadManager();+ const state = await manager.ensureDevices({confirmPermissionTypes: ['audio'], forceRefresh: true});+ expect(getUserMediaCalls).toEqual([]);+ expect(state.permissionStatus).toEqual({audio: 'granted', video: 'idle'});+ });++ test('a request that joins an in-flight confirmation of the same type still asks the browser', async () => {+ const manager = await loadManager();+ const confirmation = manager.ensureDevices({confirmPermissionTypes: ['audio'], forceRefresh: true});+ const request = manager.ensureDevices({requestPermissionTypes: ['audio']});+ const [, state] = await Promise.all([confirmation, request]);+ expect(getUserMediaCalls).toEqual([{audio: true, video: false}]);+ expect(state.permissionStatus.audio).toBe('granted');+ });++ test('confirmations escalated into requests for every type finish within the enumeration pass bound', async () => {+ const manager = await loadManager();+ const joins: Array<Promise<unknown>> = [];+ enumerationHooks.push(+ () => joins.push(manager.ensureDevices({confirmPermissionTypes: ['audio']})),+ () => joins.push(manager.ensureDevices({requestPermissionTypes: ['audio']})),+ () => joins.push(manager.ensureDevices({confirmPermissionTypes: ['video']})),+ () => {},+ () => joins.push(manager.ensureDevices({requestPermissionTypes: ['video']})),+ );+ const state = await manager.ensureDevices({forceRefresh: true});+ await Promise.all(joins);+ expect(getUserMediaCalls).toEqual([{audio: true, video: false}]);+ expect(state.permissionStatus).toEqual({audio: 'granted', video: 'granted'});+ });++ test('a confirmation never runs the native permission flow on desktop', async () => {+ runAsDesktop();+ const manager = await loadManager();+ const state = await manager.ensureDevices({confirmPermissionTypes: ['audio'], forceRefresh: true});+ expect(fakeElectron.checkMediaAccess).not.toHaveBeenCalled();+ expect(fakeElectron.requestMediaAccess).not.toHaveBeenCalled();+ expect(getUserMediaCalls).toEqual([]);+ expect(state.permissionStatus.audio).toBe('idle');+ });++ test('a request runs the native permission flow on desktop', async () => {+ runAsDesktop();+ const manager = await loadManager();+ const state = await manager.ensureDevices({requestPermissionTypes: ['audio'], forceRefresh: true});+ expect(fakeElectron.checkMediaAccess).toHaveBeenCalledWith('microphone');+ expect(getUserMediaCalls).toEqual([]);+ expect(state.permissionStatus.audio).toBe('granted');+ });});