Skip to content

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

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

import {Logger} from '@app/features/platform/utils/AppLogger';
import {ExponentialBackoff} from '@app/features/platform/utils/RetryScheduler';
import type {DesktopModuleAPI} from '@fluxer/desktop_ipc/src/ModuleContract';
import {DesktopModuleEnsureStatus} from '@fluxer/desktop_ipc/src/ModuleContract';

const DESKTOP_MODULE_BACKOFF_MIN_MS = 1_000;
const DESKTOP_MODULE_BACKOFF_MAX_MS = 30_000;

type DesktopModuleState = 'idle' | 'loading' | 'ready' | 'failed';

export interface DesktopModuleRequest {
	readonly ensure: () => Promise<DesktopModuleEnsureStatus | null>;
	readonly isSettled: () => boolean;
	readonly isUnavailable: () => boolean;
	readonly subscribe: (listener: () => void) => () => void;
	readonly reset: () => void;
}

function getDesktopModules(): DesktopModuleAPI | null {
	return globalThis.window?.electron?.desktopModules ?? null;
}

export function createDesktopModuleRequest(moduleName: string): DesktopModuleRequest {
	const logger = new Logger(`DesktopModuleRequest:${moduleName}`);
	const listeners = new Set<() => void>();
	const backoff = new ExponentialBackoff({
		minDelay: DESKTOP_MODULE_BACKOFF_MIN_MS,
		maxDelay: DESKTOP_MODULE_BACKOFF_MAX_MS,
		jitterFactor: 0.2,
	});
	let state: DesktopModuleState = 'idle';
	let unavailable = false;
	let pending: Promise<DesktopModuleEnsureStatus | null> | null = null;
	let retryTimer: ReturnType<typeof setTimeout> | null = null;
	let generation = 0;

	const notify = (): void => {
		for (const listener of listeners) {
			try {
				listener();
			} catch (error) {
				logger.error('A desktop module listener threw', error);
			}
		}
	};

	const scheduleRetry = (loadGeneration: number): void => {
		if (retryTimer !== null) {
			clearTimeout(retryTimer);
		}
		retryTimer = setTimeout(() => {
			if (loadGeneration !== generation) {
				return;
			}
			retryTimer = null;
			void load();
		}, backoff.next());
	};

	const load = (): Promise<DesktopModuleEnsureStatus | null> => {
		const loadGeneration = ++generation;
		const desktopModules = getDesktopModules();
		if (!desktopModules) {
			state = 'ready';
			notify();
			return Promise.resolve(null);
		}
		state = 'loading';
		const request = desktopModules
			.ensure(moduleName)
			.then((result) => {
				if (loadGeneration !== generation) {
					return result.status;
				}
				if (result.status === DesktopModuleEnsureStatus.UNAVAILABLE) {
					state = 'failed';
					unavailable = true;
					logger.warn('The desktop shell reports this module is unavailable; not retrying until the next launch');
					notify();
					return result.status;
				}
				state = 'ready';
				backoff.reset();
				notify();
				return result.status;
			})
			.catch((error: unknown) => {
				if (loadGeneration !== generation) {
					return null;
				}
				logger.warn('Failed to request the module from the desktop shell', error);
				state = 'failed';
				notify();
				scheduleRetry(loadGeneration);
				return null;
			})
			.finally(() => {
				if (loadGeneration === generation) {
					pending = null;
				}
			});
		pending = request;
		notify();
		return request;
	};

	const ensure = (): Promise<DesktopModuleEnsureStatus | null> => {
		if (state === 'ready') {
			return Promise.resolve(null);
		}
		if (unavailable) {
			return Promise.resolve(DesktopModuleEnsureStatus.UNAVAILABLE);
		}
		if (pending) {
			return pending;
		}
		if (state === 'failed') {
			return Promise.resolve(null);
		}
		return load();
	};

	return {
		ensure,
		isSettled: () => state === 'ready',
		isUnavailable: () => unavailable,
		subscribe: (listener) => {
			listeners.add(listener);
			return () => {
				listeners.delete(listener);
			};
		},
		reset: () => {
			pending = null;
			if (retryTimer !== null) {
				clearTimeout(retryTimer);
				retryTimer = null;
			}
			backoff.reset();
			state = 'idle';
			unavailable = false;
			generation++;
			listeners.clear();
		},
	};
}