Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
12.8 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import {Logger} from '@app/features/platform/utils/AppLogger';
import {CheckboxItem, MenuGroupLabel, SubMenu as MenuItemSubmenu} from '@app/features/ui/action_menu/ContextMenu';
import {MenuGroup} from '@app/features/ui/action_menu/MenuGroup';
import {MenuItem} from '@app/features/ui/action_menu/MenuItem';
import {MenuItemRadio} from '@app/features/ui/action_menu/MenuItemRadio';
import {getElectronAPI} from '@app/features/ui/utils/NativeUtils';
import * as VoiceSettingsCommands from '@app/features/voice/commands/VoiceSettingsCommands';
import MediaEngine from '@app/features/voice/engine/MediaEngineFacade';
import {useMediaDevices} from '@app/features/voice/hooks/useMediaDevices';
import VoiceSettings from '@app/features/voice/state/VoiceSettings';
import {
	type LinuxAudioSourceFilterOptions,
	type LinuxAudioSourceItem,
	linuxAudioSourceItemKey,
	linuxAudioSourcePatternsEqual,
	mapLinuxAudioNodeToItems,
	uniqueLinuxAudioSourceItems,
	withSelectedLinuxAudioSources,
} from '@app/features/voice/utils/LinuxAudioSourceRules';
import {
	formatScreenShareAudioSummary,
	MICROPHONE_WITH_DEVICE_DESCRIPTOR,
	resolveDeviceShareAudioPairing,
} from '@app/features/voice/utils/ScreenShareAudioSummary';
import type {DisplayShareEnvironment} from '@app/features/voice/utils/ScreenShareEnvironment';
import {
	resolveWindowShareAudioScope,
	type StreamSettingsShareContext,
	supportsWindowShareAudioScope,
	type WindowShareAudioScope,
} from '@app/features/voice/utils/StreamSettingsUpdatePolicy';
import {MICROPHONE_DESCRIPTOR} from '@app/features/voice/utils/VoiceSharedMessageDescriptors';
import type {VirtmicNode} from '@app/types/electron.d';
import {msg} from '@lingui/core/macro';
import {Trans, useLingui} from '@lingui/react/macro';
import {observer} from 'mobx-react-lite';
import {useCallback, useEffect, useState} from 'react';

const SHARED_WINDOW_AUDIO_DESCRIPTOR = msg({
	message: 'Shared window audio',
	comment:
		'Capture option in the Linux audio source picker on a window share. Captures only the audio of the window being shared.',
});
const AUDIO_SOURCES_DESCRIPTOR = msg({
	message: 'Audio sources: {summaryLabel}',
	comment:
		'Toggle / summary row label in the Linux audio source picker. {summaryLabel} is one of the audio-source summary labels.',
});
const CAPTURE_DESCRIPTOR = msg({
	message: 'Capture',
	comment:
		'Section header in the Linux audio source picker. Lists capture-target options (entire system / specific apps).',
});
const INCLUDE_APPS_DESCRIPTOR = msg({
	message: 'Include apps',
	comment: 'Section header in the Linux audio source picker for the per-app inclusion list.',
});
const EXCLUDE_FROM_SYSTEM_DESCRIPTOR = msg({
	message: 'Exclude from system',
	comment: 'Section header in the Linux audio source picker for apps excluded from the system mix.',
});
const logger = new Logger('AudioSourcePickerLinux');

interface AudioSourceSnapshot {
	available: boolean;
	loading: boolean;
	items: Array<LinuxAudioSourceItem>;
	hasPipewire: boolean;
	error: string | null;
}

const EMPTY_SNAPSHOT: AudioSourceSnapshot = {
	available: false,
	loading: true,
	items: [],
	hasPipewire: true,
	error: null,
};

function isItemSelected(value: VirtmicNode, sources: Array<VirtmicNode>): boolean {
	return sources.some((source) => linuxAudioSourcePatternsEqual(source, value));
}

async function fetchAudioSources(options: LinuxAudioSourceFilterOptions): Promise<AudioSourceSnapshot> {
	const electronApi = getElectronAPI();
	if (!electronApi?.virtmic) {
		return {available: false, loading: false, items: [], hasPipewire: false, error: 'electron-unavailable'};
	}
	try {
		const availability = await electronApi.virtmic.getAvailability();
		if (!availability.available) {
			return {
				available: false,
				loading: false,
				items: [],
				hasPipewire: availability.reason !== 'no-pipewire',
				error: availability.reason ?? null,
			};
		}
		const result = await electronApi.virtmic.listTargets({granular: options.granular});
		if (!result.ok || !result.targets) {
			return {available: true, loading: false, items: [], hasPipewire: true, error: 'list-failed'};
		}
		const items = uniqueLinuxAudioSourceItems(
			result.targets.flatMap((node) => mapLinuxAudioNodeToItems(node, options)),
		);
		return {available: true, loading: false, items, hasPipewire: true, error: null};
	} catch (error) {
		logger.warn('Failed to fetch audio-bridge sources', error);
		return {available: false, loading: false, items: [], hasPipewire: true, error: 'exception'};
	}
}

interface AudioSourcePickerLinuxSubmenuProps {
	onSelectionChange?: (nextWindowAudioScope?: WindowShareAudioScope) => void;
	shareContext?: StreamSettingsShareContext;
	displayShareEnvironment?: DisplayShareEnvironment;
	windowAudioScope?: WindowShareAudioScope;
	microphoneLabel?: string;
}

export const AudioSourcePickerLinuxSubmenu = observer((props: AudioSourcePickerLinuxSubmenuProps) => {
	const {
		onSelectionChange,
		shareContext = 'display',
		displayShareEnvironment,
		windowAudioScope,
		microphoneLabel,
	} = props;
	const {i18n} = useLingui();
	const isDeviceShare = shareContext === 'device';
	const scopeInput = {shareContext, displayShareEnvironment, windowAudioScope};
	const offersWindowScope = supportsWindowShareAudioScope(scopeInput);
	const resolvedScope = resolveWindowShareAudioScope(scopeInput);
	const sourceMode = VoiceSettings.getScreenShareAudioSourceMode();
	const includeSources = VoiceSettings.getScreenShareAudioIncludeSources();
	const excludeSources = VoiceSettings.getScreenShareAudioExcludeSources();
	const usesDeviceMicrophone = VoiceSettings.getScreenShareDeviceAudioUsesMicrophone();
	const {inputDevices, videoDevices} = useMediaDevices({autoRefresh: true, requestPermissions: false});
	const granular = VoiceSettings.getLinuxAudioCaptureGranularSelect();
	const deviceSelect = VoiceSettings.getLinuxAudioCaptureDeviceSelect();
	const ignoreVirtual = VoiceSettings.getLinuxAudioCaptureIgnoreVirtual();
	const [snapshot, setSnapshot] = useState<AudioSourceSnapshot>(EMPTY_SNAPSHOT);
	const widenedScope = offersWindowScope ? ('system' as const) : undefined;
	const refresh = useCallback(() => {
		setSnapshot((prev) => ({...prev, loading: true}));
		void fetchAudioSources({granular, deviceSelect, ignoreVirtual}).then((next) => {
			if (!next.available) {
				logger.warn('Hiding the audio source picker because no audio-bridge backend is available', {
					shareContext,
					reason: next.error,
					hasPipewire: next.hasPipewire,
				});
			}
			setSnapshot(next);
		});
	}, [granular, deviceSelect, ignoreVirtual, shareContext]);
	useEffect(() => {
		refresh();
	}, [refresh]);
	const handlePickWindow = useCallback(() => {
		onSelectionChange?.('window');
	}, [onSelectionChange]);
	const handlePickSystem = useCallback(() => {
		VoiceSettingsCommands.update(
			isDeviceShare
				? {screenShareDeviceAudioUsesMicrophone: true}
				: {screenShareAudioSourceMode: 'system', screenShareAudioIncludeSources: []},
		);
		onSelectionChange?.(widenedScope);
	}, [isDeviceShare, onSelectionChange, widenedScope]);
	const handlePickNone = useCallback(() => {
		VoiceSettingsCommands.update({
			screenShareAudioSourceMode: 'none',
			screenShareAudioIncludeSources: [],
		});
		onSelectionChange?.();
	}, [onSelectionChange]);
	const handleToggleApp = useCallback(
		(item: LinuxAudioSourceItem) => {
			const isSelected = isItemSelected(item.value, includeSources);
			const nextSources = isSelected
				? includeSources.filter((source) => !linuxAudioSourcePatternsEqual(source, item.value))
				: [...includeSources, item.value];
			VoiceSettingsCommands.update({
				screenShareAudioSourceMode: nextSources.length > 0 ? 'specific' : 'system',
				screenShareAudioIncludeSources: nextSources,
				...(isDeviceShare ? {screenShareDeviceAudioUsesMicrophone: false} : {}),
			});
			onSelectionChange?.(widenedScope);
		},
		[includeSources, isDeviceShare, onSelectionChange, widenedScope],
	);
	const handleToggleExcludeApp = useCallback(
		(item: LinuxAudioSourceItem) => {
			const isSelected = isItemSelected(item.value, excludeSources);
			const nextSources = isSelected
				? excludeSources.filter((source) => !linuxAudioSourcePatternsEqual(source, item.value))
				: [...excludeSources, item.value];
			VoiceSettingsCommands.update({
				screenShareAudioExcludeSources: nextSources,
			});
			onSelectionChange?.();
		},
		[excludeSources, onSelectionChange],
	);
	const deviceSourceLabel = i18n._(MICROPHONE_WITH_DEVICE_DESCRIPTOR, {
		deviceLabel: microphoneLabel ?? i18n._(MICROPHONE_DESCRIPTOR),
	});
	const summaryLabel = formatScreenShareAudioSummary(i18n, {
		sourceMode,
		includeSources,
		shareContext,
		microphoneLabel,
		chosenAudioDeviceId: VoiceSettings.getScreenShareAudioDeviceId(),
		deviceAudioPairing: resolveDeviceShareAudioPairing(
			[...videoDevices, ...inputDevices],
			MediaEngine.getActiveScreenShareVideoDeviceId(),
		),
		displayShareEnvironment,
		windowAudioScope,
		usesDeviceMicrophone,
	});
	const showsWideSourceLists = !offersWindowScope || resolvedScope === 'system';
	const includeItems = withSelectedLinuxAudioSources(snapshot.items, includeSources);
	const excludeItems = withSelectedLinuxAudioSources(snapshot.items, excludeSources);
	const wideSourceIsSelected = isDeviceShare ? usesDeviceMicrophone : sourceMode === 'system';
	if (!snapshot.available && !snapshot.loading) {
		return null;
	}
	return (
		<MenuItemSubmenu
			label={i18n._(AUDIO_SOURCES_DESCRIPTOR, {summaryLabel})}
			render={() => (
				<>
					<MenuGroup data-flx="voice.audio-source-picker-linux.audio-source-picker-linux-submenu.menu-group">
						<MenuGroupLabel data-flx="voice.audio-source-picker-linux.audio-source-picker-linux-submenu.group-label.capture">
							{i18n._(CAPTURE_DESCRIPTOR)}
						</MenuGroupLabel>
						{offersWindowScope && (
							<MenuItemRadio
								selected={resolvedScope === 'window'}
								onSelect={handlePickWindow}
								data-flx="voice.audio-source-picker-linux.audio-source-picker-linux-submenu.menu-item-radio.pick-window"
							>
								{i18n._(SHARED_WINDOW_AUDIO_DESCRIPTOR)}
							</MenuItemRadio>
						)}
						<MenuItemRadio
							selected={showsWideSourceLists && wideSourceIsSelected}
							onSelect={handlePickSystem}
							data-flx="voice.audio-source-picker-linux.audio-source-picker-linux-submenu.menu-item-radio.pick-system"
						>
							{isDeviceShare ? deviceSourceLabel : <Trans>Entire system audio</Trans>}
						</MenuItemRadio>
						{!isDeviceShare && !offersWindowScope && (
							<MenuItemRadio
								selected={sourceMode === 'none'}
								onSelect={handlePickNone}
								data-flx="voice.audio-source-picker-linux.audio-source-picker-linux-submenu.menu-item-radio.pick-none"
							>
								<Trans>None</Trans>
							</MenuItemRadio>
						)}
					</MenuGroup>
					{showsWideSourceLists && includeItems.length > 0 && (
						<MenuGroup data-flx="voice.audio-source-picker-linux.audio-source-picker-linux-submenu.menu-group--2">
							<MenuGroupLabel data-flx="voice.audio-source-picker-linux.audio-source-picker-linux-submenu.group-label.include-apps">
								{i18n._(INCLUDE_APPS_DESCRIPTOR)}
							</MenuGroupLabel>
							{includeItems.map((item) => (
								<CheckboxItem
									key={linuxAudioSourceItemKey(item)}
									checked={isItemSelected(item.value, includeSources)}
									onCheckedChange={() => handleToggleApp(item)}
									data-flx="voice.audio-source-picker-linux.audio-source-picker-linux-submenu.checkbox-item"
								>
									{item.name}
								</CheckboxItem>
							))}
						</MenuGroup>
					)}
					{!isDeviceShare && showsWideSourceLists && sourceMode === 'system' && excludeItems.length > 0 && (
						<MenuGroup data-flx="voice.audio-source-picker-linux.audio-source-picker-linux-submenu.menu-group--3">
							<MenuGroupLabel data-flx="voice.audio-source-picker-linux.audio-source-picker-linux-submenu.group-label.exclude-from-system">
								{i18n._(EXCLUDE_FROM_SYSTEM_DESCRIPTOR)}
							</MenuGroupLabel>
							{excludeItems.map((item) => (
								<CheckboxItem
									key={`exclude-${linuxAudioSourceItemKey(item)}`}
									checked={isItemSelected(item.value, excludeSources)}
									onCheckedChange={() => handleToggleExcludeApp(item)}
									data-flx="voice.audio-source-picker-linux.audio-source-picker-linux-submenu.checkbox-item--2"
								>
									{item.name}
								</CheckboxItem>
							))}
						</MenuGroup>
					)}
					<MenuGroup data-flx="voice.audio-source-picker-linux.audio-source-picker-linux-submenu.menu-group--4">
						<MenuItem
							onClick={refresh}
							closeOnSelect={false}
							data-flx="voice.audio-source-picker-linux.audio-source-picker-linux-submenu.menu-item.refresh"
						>
							<Trans>Refresh audio sources</Trans>
						</MenuItem>
					</MenuGroup>
				</>
			)}
			data-flx="voice.audio-source-picker-linux.audio-source-picker-linux-submenu.menu-item-submenu"
		/>
	);
});

AudioSourcePickerLinuxSubmenu.displayName = 'AudioSourcePickerLinuxSubmenu';