Skip to content

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

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

import type {ScreenshareResolution, StreamingMode} from '@app/features/voice/state/VoiceSettings';
import {
	canRestartDisplayShareWithoutPreselectedSource,
	type DisplayShareEnvironment,
	prestartAudioToggleIsPickerOwned,
} from '@app/features/voice/utils/ScreenShareEnvironment';
import {
	normaliseResolutionForContext,
	normaliseStreamingModeForContext,
	resolveScreenShareQualityPick,
	type ScreenShareContext,
	type ScreenShareQualityInput,
	type ScreenShareQualityPatch,
	type ScreenShareQualityPick,
	type ScreenShareTarget,
	SUPPORTED_SCREEN_SHARE_FRAME_RATES,
	type SupportedScreenShareFrameRate,
} from '@app/features/voice/utils/ScreenShareOptions';
import {
	canSelectManualAudioSources,
	canSelectWindowsDesktopAudioSource,
	manualAudioSourcesGovernShare,
	resolveWindowShareAudioScope,
	type ScreenShareAudioSourceMode,
	type StreamSettingsShareContext,
	selectAppShareAudioRoute,
	type WindowShareAudioScope,
} from '@app/features/voice/utils/StreamSettingsUpdatePolicy';
import type {NativeAudioAvailability} from '@app/types/electron.d';
import {msg} from '@lingui/core/macro';
import {initialTransition, setup, transition} from 'xstate';

export const CAPTURE_DEVICES_USE_THE_GAMING_PRESET_DESCRIPTOR = msg({
	message: 'Capture devices use the Gaming preset.',
	comment:
		'Note shown beside the stored Screen share preset in the stream settings menu and the video settings tab of a capture device share, explaining why that preset is not used.',
});

type StreamSettingsAudioControlStateValue =
	| 'hidden'
	| 'unsupported'
	| 'prestartNativePickerOwned'
	| 'restartRequired'
	| 'toggle';
type StreamSettingsAudioControlLabelKey =
	| 'captureAppAudio'
	| 'captureDesktopAudio'
	| 'captureDeviceAudio'
	| 'captureSystemAudio';
type StreamSettingsNativeAudioUnsupportedScope = 'process' | 'system';

interface StreamSettingsNativeAudioSignals {
	shareContext: StreamSettingsShareContext;
	platform?: string | null;
	nativeAudioAvailability: NativeAudioAvailability | null;
}

export interface StreamSettingsAudioControlSignals extends StreamSettingsNativeAudioSignals {
	applyToLiveStream: boolean;
	displayShareEnvironment: DisplayShareEnvironment;
	supportsStreamAudio: boolean;
	captureAudioEnabled: boolean;
	hasLiveScreenShareAudioPublication: boolean;
	audioSourceMode?: ScreenShareAudioSourceMode;
	selectedAudioSourceCount?: number;
	windowAudioScope?: WindowShareAudioScope;
}

interface StreamSettingsAudioControlViewState {
	value: StreamSettingsAudioControlStateValue;
	checked: boolean;
	labelKey: StreamSettingsAudioControlLabelKey;
}

export interface StreamSettingsAudioMenuViewState {
	control: StreamSettingsAudioControlViewState;
	showManualAudioSources: boolean;
	showWindowsAudioSourceMenu: boolean;
	showDeviceAudioMenu: boolean;
}

type StreamSettingsAudioControlEvent = {
	type: 'audio.evaluate';
	signals: StreamSettingsAudioControlSignals;
};

function selectStreamSettingsNativeAudioUnsupportedScope(
	shareContext: StreamSettingsShareContext,
): StreamSettingsNativeAudioUnsupportedScope | null {
	if (shareContext === 'app') return 'process';
	if (shareContext === 'display') return 'system';
	return null;
}

function selectStreamSettingsNativeAudioUnsupportedOnThisOs(signals: StreamSettingsNativeAudioSignals): boolean {
	const scope = selectStreamSettingsNativeAudioUnsupportedScope(signals.shareContext);
	return (
		scope != null &&
		(signals.platform === 'win32' || signals.platform === 'darwin') &&
		signals.nativeAudioAvailability != null &&
		(signals.nativeAudioAvailability.capabilities?.[scope] === false ||
			(!signals.nativeAudioAvailability.available && signals.nativeAudioAvailability.reason === 'os-version-too-old'))
	);
}

function shouldRestartToEnableDisplayAudio(signals: StreamSettingsAudioControlSignals): boolean {
	return (
		signals.applyToLiveStream &&
		signals.shareContext === 'display' &&
		!signals.captureAudioEnabled &&
		!signals.hasLiveScreenShareAudioPublication &&
		!canRestartDisplayShareWithoutPreselectedSource(signals.displayShareEnvironment) &&
		!canEnableNativeDisplayAudioWithoutRestart(signals)
	);
}

function canEnableNativeDisplayAudioWithoutRestart(signals: StreamSettingsAudioControlSignals): boolean {
	if (signals.displayShareEnvironment !== 'desktop-custom') return false;
	if (signals.platform === 'linux') return true;
	if (signals.platform !== 'darwin' && signals.platform !== 'win32') return false;
	if (!signals.nativeAudioAvailability) return true;
	return signals.nativeAudioAvailability.available && signals.nativeAudioAvailability.capabilities?.system !== false;
}

function shouldDisablePrestartNativeAudioToggle(signals: StreamSettingsAudioControlSignals): boolean {
	return (
		!signals.applyToLiveStream &&
		signals.shareContext === 'display' &&
		prestartAudioToggleIsPickerOwned(signals.displayShareEnvironment)
	);
}

const streamSettingsAudioControlStateMachine = setup({
	types: {} as {
		events: StreamSettingsAudioControlEvent;
	},
	guards: {
		isHidden: ({event}) => !event.signals.supportsStreamAudio,
		isUnsupported: ({event}) => selectStreamSettingsNativeAudioUnsupportedOnThisOs(event.signals),
		isPrestartNativePickerOwned: ({event}) => shouldDisablePrestartNativeAudioToggle(event.signals),
		isRestartRequired: ({event}) => shouldRestartToEnableDisplayAudio(event.signals),
	},
}).createMachine({
	id: 'streamSettingsAudioControl',
	initial: 'hidden',
	on: {
		'audio.evaluate': [
			{target: '.hidden', guard: 'isHidden'},
			{target: '.unsupported', guard: 'isUnsupported'},
			{target: '.prestartNativePickerOwned', guard: 'isPrestartNativePickerOwned'},
			{target: '.restartRequired', guard: 'isRestartRequired'},
			{target: '.toggle'},
		],
	},
	states: {
		hidden: {},
		unsupported: {},
		prestartNativePickerOwned: {},
		restartRequired: {},
		toggle: {},
	},
});

function selectStreamSettingsAudioControlState(
	signals: StreamSettingsAudioControlSignals,
): StreamSettingsAudioControlStateValue {
	const [snapshot] = transition(
		streamSettingsAudioControlStateMachine,
		initialTransition(streamSettingsAudioControlStateMachine)[0],
		{
			type: 'audio.evaluate',
			signals,
		},
	);
	return typeof snapshot.value === 'string' ? (snapshot.value as StreamSettingsAudioControlStateValue) : 'hidden';
}

function selectAudioControlLabelKey(signals: StreamSettingsAudioControlSignals): StreamSettingsAudioControlLabelKey {
	if (signals.shareContext === 'device') return 'captureDeviceAudio';
	if (signals.shareContext !== 'app') return 'captureDesktopAudio';
	const route = selectAppShareAudioRoute({
		audioSourceMode: signals.audioSourceMode,
		selectedSourceCount: signals.selectedAudioSourceCount,
		windowAudioScope: resolveWindowShareAudioScope(signals),
	});
	return route === 'system' ? 'captureSystemAudio' : 'captureAppAudio';
}

export function selectStreamSettingsAudioMenuState(
	signals: StreamSettingsAudioControlSignals,
): StreamSettingsAudioMenuViewState {
	const value = selectStreamSettingsAudioControlState(signals);
	return {
		control: {
			value,
			checked: signals.captureAudioEnabled,
			labelKey: selectAudioControlLabelKey(signals),
		},
		showManualAudioSources:
			signals.supportsStreamAudio &&
			signals.captureAudioEnabled &&
			manualAudioSourcesGovernShare(signals) &&
			canSelectManualAudioSources({
				platform: signals.platform,
				nativeAudioAvailability: signals.nativeAudioAvailability,
			}),
		showWindowsAudioSourceMenu:
			signals.supportsStreamAudio &&
			signals.captureAudioEnabled &&
			canSelectWindowsDesktopAudioSource({
				platform: signals.platform,
				shareContext: signals.shareContext,
				nativeAudioAvailability: signals.nativeAudioAvailability,
			}),
		showDeviceAudioMenu: signals.shareContext === 'device' && signals.captureAudioEnabled,
	};
}

export type StreamSettingsQualityWrite =
	| {kind: 'none'}
	| {kind: 'premium'}
	| {kind: 'write'; patch: ScreenShareQualityPatch};

interface StreamSettingsQualitySignals {
	quality: ScreenShareQualityInput;
	pick: ScreenShareQualityPick;
	premiumOption: boolean;
	showPremiumFeatures: boolean;
}

function selectStreamSettingsQualityWrite(signals: StreamSettingsQualitySignals): StreamSettingsQualityWrite {
	if (signals.premiumOption && !signals.quality.entitled) {
		return signals.showPremiumFeatures ? {kind: 'premium'} : {kind: 'none'};
	}
	const patch = resolveScreenShareQualityPick(signals.quality, signals.pick);
	return patch === null ? {kind: 'none'} : {kind: 'write', patch};
}

export const OFFERED_SCREEN_SHARE_RESOLUTIONS = [
	'low_480p',
	'medium',
	'high',
	'ultra',
	'source',
] as const satisfies ReadonlyArray<ScreenshareResolution>;

export type OfferedScreenShareResolution = (typeof OFFERED_SCREEN_SHARE_RESOLUTIONS)[number];

export function offeredScreenShareResolution(resolution: ScreenshareResolution): OfferedScreenShareResolution {
	return resolution === 'low_240p' ? 'low_480p' : resolution;
}

const STREAM_SETTINGS_FREE_RESOLUTIONS: ReadonlyArray<OfferedScreenShareResolution> = ['low_480p', 'medium'];
const STREAM_SETTINGS_PREMIUM_RESOLUTIONS: ReadonlyArray<OfferedScreenShareResolution> = ['high', 'ultra', 'source'];
const STREAM_SETTINGS_FREE_FRAME_RATES: ReadonlyArray<SupportedScreenShareFrameRate> = [15, 30];
const STREAM_SETTINGS_PREMIUM_FRAME_RATES: ReadonlyArray<SupportedScreenShareFrameRate> = [60];

interface StreamSettingsQualityOption<T> {
	value: T;
	premium: boolean;
	selected: boolean;
	write: StreamSettingsQualityWrite;
}

export interface StreamSettingsQualityMenuViewState {
	resolutions: Array<StreamSettingsQualityOption<OfferedScreenShareResolution>>;
	frameRates: Array<StreamSettingsQualityOption<SupportedScreenShareFrameRate>>;
}

export interface StreamSettingsQualityMenuSignals {
	quality: ScreenShareQualityInput;
	target: ScreenShareTarget;
	showPremiumFeatures: boolean;
}

export function contextAllowsScreenShareResolution(
	resolution: OfferedScreenShareResolution,
	context: ScreenShareContext,
): boolean {
	return normaliseResolutionForContext(resolution, context, true) === resolution;
}

export function selectStreamSettingsQualityMenuState(
	signals: StreamSettingsQualityMenuSignals,
): StreamSettingsQualityMenuViewState {
	const offersPremium = signals.quality.entitled || signals.showPremiumFeatures;
	const selectedResolution = offeredScreenShareResolution(signals.target.resolution);
	const buildOption = <T>(
		value: T,
		premium: boolean,
		selected: boolean,
		pick: ScreenShareQualityPick,
	): StreamSettingsQualityOption<T> => ({
		value,
		premium,
		selected,
		write: selectStreamSettingsQualityWrite({
			quality: signals.quality,
			pick,
			premiumOption: premium,
			showPremiumFeatures: signals.showPremiumFeatures,
		}),
	});
	return {
		resolutions: OFFERED_SCREEN_SHARE_RESOLUTIONS.filter(
			(value) =>
				value === selectedResolution ||
				STREAM_SETTINGS_FREE_RESOLUTIONS.includes(value) ||
				(offersPremium &&
					STREAM_SETTINGS_PREMIUM_RESOLUTIONS.includes(value) &&
					contextAllowsScreenShareResolution(value, signals.quality.context)),
		).map((value) =>
			buildOption(value, STREAM_SETTINGS_PREMIUM_RESOLUTIONS.includes(value), value === selectedResolution, {
				axis: 'resolution',
				resolution: value,
			}),
		),
		frameRates: SUPPORTED_SCREEN_SHARE_FRAME_RATES.filter(
			(value) =>
				value === signals.target.frameRate ||
				STREAM_SETTINGS_FREE_FRAME_RATES.includes(value) ||
				(offersPremium && STREAM_SETTINGS_PREMIUM_FRAME_RATES.includes(value)),
		).map((value) =>
			buildOption(value, !STREAM_SETTINGS_FREE_FRAME_RATES.includes(value), value === signals.target.frameRate, {
				axis: 'frameRate',
				frameRate: value,
			}),
		),
	};
}

export function selectStreamSettingsPresetOverriddenByContext(
	mode: StreamingMode,
	context: ScreenShareContext,
): boolean {
	return normaliseStreamingModeForContext(mode, context) !== mode;
}