A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// 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';