diff --git a/src/app/components/CallEmbedProvider.tsx b/src/app/components/CallEmbedProvider.tsx
index 78b2b5ee0..b5bbc05ba 100644
--- a/src/app/components/CallEmbedProvider.tsx
+++ b/src/app/components/CallEmbedProvider.tsx
@@ -17,6 +17,7 @@ import { useSelectedRoom } from '$hooks/router/useSelectedRoom';
import { ScreenSize, useScreenSizeContext } from '$hooks/useScreenSize';
import { IncomingCallModal } from '$features/call/IncomingCallModal';
import { toCallEmbedStartError } from '$plugins/call/callEmbedError';
+import { LivekitJsCallManagerProvider } from '$features/call/livekitJsCallManager';
function CallUtils({ embed }: { embed: CallEmbed }) {
const setCallEmbed = useSetAtom(callEmbedAtom);
@@ -80,8 +81,10 @@ export function CallEmbedProvider({ children }: CallEmbedProviderProps) {
{callEmbed && }
-
- {children}
+
+
+ {children}
+
({
+ ThemeKind: { Light: 'light', Dark: 'dark' },
+ useTheme: () => ({ kind: 'light' }),
+}));
+
+vi.mock('$hooks/useClientConfig', () => ({
+ useClientConfig: () => ({ elementCallUrl: undefined }),
+}));
+
+const { createControllerMock } = vi.hoisted(() => ({
+ createControllerMock: vi.fn<(...args: unknown[]) => unknown>(),
+}));
+
+vi.mock('./livekitJsController', () => ({
+ createLivekitJsController: createControllerMock,
+}));
+
+type ControllerListener = (state: Readonly
) => void;
+
+type FakeController = {
+ connect: ReturnType;
+ disconnect: ReturnType;
+ subscribe: (listener: ControllerListener) => () => void;
+ getState: () => LivekitJsControllerState;
+ emit: (state: Partial) => void;
+ listenerCount: () => number;
+};
+
+const makeFakeController = (): FakeController => {
+ const listeners = new Set();
+ let state: LivekitJsControllerState = {
+ lifecycle: 'idle',
+ failure: null,
+ mediaFailure: null,
+ e2ee: { ready: false, localOutboundIdentity: null, keyIndex: null, lastImportFailure: null },
+ };
+ const snapshot = (): LivekitJsControllerState => ({ ...state, e2ee: { ...state.e2ee } });
+ return {
+ connect: vi.fn<(...args: unknown[]) => Promise>(async () => undefined),
+ disconnect: vi.fn<() => Promise>(async () => undefined),
+ getState: () => snapshot(),
+ subscribe: (listener) => {
+ listeners.add(listener);
+ listener(snapshot());
+ return () => {
+ listeners.delete(listener);
+ };
+ },
+ emit: (next) => {
+ state = { ...state, ...next };
+ listeners.forEach((listener) => listener(snapshot()));
+ },
+ listenerCount: () => listeners.size,
+ };
+};
+
+const room = { roomId: '!room:example.org' } as Room;
+
+const memberships: string[] = [];
+const mx = {
+ matrixRTC: {
+ getRoomSession: vi.fn<() => unknown>(() => ({ memberships })),
+ },
+} as unknown as MatrixClient;
+
+type Harness = {
+ store: ReturnType;
+ controllers: FakeController[];
+ wrapper: ({ children }: { children?: ReactNode }) => ReactNode;
+ managers: Array;
+ Consumer: () => null;
+};
+
+const createHarness = (
+ settingsOverrides: { livekitJsCallsEnabled?: boolean; livekitJsMediaTestEnabled?: boolean } = {}
+): Harness => {
+ const store = createStore();
+ store.set(settingsAtom, { ...getSettings(), ...settingsOverrides });
+ const controllers: FakeController[] = [];
+ createControllerMock.mockImplementation(() => {
+ const controller = makeFakeController();
+ controllers.push(controller);
+ return controller;
+ });
+ const managers: Array = [];
+ const Consumer = (): null => {
+ managers.push(useLivekitJsCallManager());
+ return null;
+ };
+ const embedRef = { current: null };
+ const wrapper = ({ children }: { children?: ReactNode }) => (
+
+
+
+
+ {children}
+
+
+
+
+ );
+ return { store, controllers, wrapper, managers, Consumer };
+};
+
+const currentManager = (harness: Harness): LivekitJsCallManager => {
+ const manager = harness.managers[harness.managers.length - 1];
+ expect(manager).toBeDefined();
+ return manager!;
+};
+
+describe('LivekitJsCallManagerProvider', () => {
+ beforeEach(() => {
+ createControllerMock.mockReset();
+ });
+
+ it('start then consumer unmount/replacement does not disconnect the controller', () => {
+ const harness = createHarness();
+ const view = render(
+
+
+
+ );
+ const controller = harness.controllers[0]!;
+ act(() => {
+ currentManager(harness).start({ room, video: true });
+ });
+ expect(controller.connect).toHaveBeenCalledTimes(1);
+ expect(controller.connect.mock.calls[0]![0]).toMatchObject({ room, callIntent: 'video' });
+
+ // Consumer unmounts (prescreen replaced by call view) while provider persists.
+ view.rerender({undefined});
+
+ expect(controller.disconnect).not.toHaveBeenCalled();
+ expect(controller.listenerCount()).toBe(1);
+
+ // A replacement consumer mounts and still sees the same controller/manager.
+ view.rerender(
+
+
+
+ );
+ expect(controller.disconnect).not.toHaveBeenCalled();
+ });
+
+ it('explicit end via session hangup disconnects exactly once', async () => {
+ const harness = createHarness();
+ render(
+
+
+
+ );
+ const controller = harness.controllers[0]!;
+ act(() => {
+ currentManager(harness).start({ room, video: false });
+ });
+ act(() => {
+ controller.emit({ lifecycle: 'active', room: {} as never });
+ });
+ const session = harness.store.get(livekitJsCallAtom);
+ expect(session?.roomId).toBe(room.roomId);
+ expect(session?.lifecycle).toBe('active');
+
+ await act(async () => {
+ await session!.hangup();
+ });
+
+ expect(controller.disconnect).toHaveBeenCalledTimes(1);
+ });
+
+ it('child passive effect (auto-join) can start on initial mount', () => {
+ const harness = createHarness({ livekitJsCallsEnabled: true });
+ const AutoJoinChild = (): null => {
+ const manager = useLivekitJsCallManager();
+ useEffect(() => {
+ manager?.start({ room, video: false });
+ }, [manager]);
+ return null;
+ };
+
+ render(
+
+
+
+ );
+
+ const controller = harness.controllers[0]!;
+ expect(controller.connect).toHaveBeenCalledTimes(1);
+ expect(controller.connect.mock.calls[0]![0]).toMatchObject({ room, callIntent: 'audio' });
+ });
+
+ it('stale disconnect completion does not clear a replacement session', async () => {
+ const harness = createHarness({ livekitJsMediaTestEnabled: false });
+ let resolveOldDisconnect: (() => void) | undefined;
+ createControllerMock.mockImplementationOnce(() => {
+ const controller = {
+ ...makeFakeController(),
+ disconnect: vi.fn<() => Promise>(
+ () =>
+ new Promise((resolve) => {
+ resolveOldDisconnect = resolve;
+ })
+ ),
+ };
+ harness.controllers.push(controller);
+ return controller;
+ });
+ const view = render(
+
+
+
+ );
+ const oldController = harness.controllers[0]!;
+ act(() => {
+ currentManager(harness).start({ room, video: false });
+ });
+
+ // Deliberate replacement via manual media toggle while old disconnect pends.
+ act(() => {
+ harness.store.set(settingsAtom, { ...getSettings(), livekitJsMediaTestEnabled: true });
+ });
+ const newController = harness.controllers[1]!;
+ expect(newController).toBeDefined();
+ expect(oldController.disconnect).toHaveBeenCalledTimes(1);
+
+ // New controller starts and publishes before the old disconnect resolves.
+ act(() => {
+ currentManager(harness).start({ room, video: false });
+ newController.emit({ lifecycle: 'active', room: {} as never });
+ });
+ expect(harness.store.get(livekitJsCallAtom)?.lifecycle).toBe('active');
+
+ await act(async () => {
+ resolveOldDisconnect!();
+ await Promise.resolve();
+ });
+
+ expect(harness.store.get(livekitJsCallAtom)?.lifecycle).toBe('active');
+ expect(harness.store.get(livekitJsCallAtom)?.roomId).toBe(room.roomId);
+ view.unmount();
+ });
+
+ it('provider unmount disconnects exactly once', async () => {
+ const harness = createHarness();
+ const view = render({undefined});
+ const controller = harness.controllers[0]!;
+
+ view.unmount();
+
+ await waitFor(() => {
+ expect(controller.disconnect).toHaveBeenCalledTimes(1);
+ });
+ expect(controller.listenerCount()).toBe(0);
+ expect(harness.store.get(livekitJsCallAtom)).toBeUndefined();
+ });
+
+ it('manual media setting change deliberately replaces the controller', async () => {
+ const harness = createHarness({ livekitJsMediaTestEnabled: false });
+ render({undefined});
+ expect(harness.controllers).toHaveLength(1);
+ const first = harness.controllers[0]!;
+ expect(createControllerMock.mock.calls[0]![1]).toEqual({ manualMediaTest: false });
+
+ act(() => {
+ harness.store.set(settingsAtom, { ...getSettings(), livekitJsMediaTestEnabled: true });
+ });
+
+ await waitFor(() => {
+ expect(first.disconnect).toHaveBeenCalledTimes(1);
+ expect(harness.controllers).toHaveLength(2);
+ });
+ expect(createControllerMock.mock.calls[1]![1]).toEqual({ manualMediaTest: true });
+ });
+
+ it('multiple consumers share one controller for one call', () => {
+ const harness = createHarness({ livekitJsCallsEnabled: true });
+ render(
+
+
+
+
+
+ );
+ const controller = harness.controllers[0]!;
+
+ // Prescreen starts the call.
+ act(() => {
+ harness.managers[0]!.start({ room, video: false });
+ });
+ act(() => {
+ controller.emit({ lifecycle: 'joining-matrix' });
+ });
+ // Room header and auto-join attempt the same call while one is active.
+ act(() => {
+ harness.managers[1]!.start({ room, video: false });
+ harness.managers[2]!.start({ room, video: false });
+ });
+
+ expect(controller.connect).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/src/app/features/call/livekitJsCallManager.tsx b/src/app/features/call/livekitJsCallManager.tsx
new file mode 100644
index 000000000..04747f641
--- /dev/null
+++ b/src/app/features/call/livekitJsCallManager.tsx
@@ -0,0 +1,119 @@
+import type { ReactNode } from 'react';
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef } from 'react';
+import { useStore } from 'jotai';
+import type { Room } from '$types/matrix-sdk';
+import { createLivekitJsController } from './livekitJsController';
+import { isLivekitJsCallActive, livekitJsCallAtom } from '$state/livekitJsCall';
+import { callEmbedAtom } from '$state/callEmbed';
+import { settingsAtom } from '$state/settings';
+import { useSetting } from '$state/hooks/settings';
+import { useMatrixClient } from '$hooks/useMatrixClient';
+import { useAutoDiscoveryInfo } from '$hooks/useAutoDiscoveryInfo';
+
+export type LivekitJsCallStartOptions = {
+ room: Room;
+ dm?: boolean;
+ video?: boolean;
+};
+
+export type LivekitJsCallManager = {
+ start: (options: LivekitJsCallStartOptions) => void;
+};
+
+const LivekitJsCallManagerContext = createContext(undefined);
+
+export const useLivekitJsCallManager = (): LivekitJsCallManager | undefined =>
+ useContext(LivekitJsCallManagerContext);
+
+type LivekitJsController = ReturnType;
+
+type LivekitJsCallManagerProviderProps = {
+ children?: ReactNode;
+};
+
+/**
+ * Provider-level owner of the single LiveKit JS call controller. Mounted with
+ * CallEmbedProvider so transient consumers (prescreen, room header, auto-join)
+ * never own or disconnect the controller themselves. Owns: creation,
+ * subscription -> livekitJsCallAtom, settings-driven deliberate replacement
+ * (manual media test toggle), and provider-unmount disconnect.
+ */
+export function LivekitJsCallManagerProvider({ children }: LivekitJsCallManagerProviderProps) {
+ const mx = useMatrixClient();
+ const discovery = useAutoDiscoveryInfo();
+ const store = useStore();
+ const [manualMediaTest] = useSetting(settingsAtom, 'livekitJsMediaTestEnabled');
+ const roomIdRef = useRef(undefined);
+ const controllerRef = useRef(undefined);
+ const generationRef = useRef(0);
+
+ // Create and expose the controller synchronously during render so child
+ // passive effects (e.g. AutoJoinManager calling start()) always see the
+ // current controller before the provider's own subscription effect runs.
+ const controller = useMemo(() => {
+ generationRef.current += 1;
+ return createLivekitJsController(undefined, { manualMediaTest });
+ }, [manualMediaTest]);
+ const generation = generationRef.current;
+ if (controllerRef.current !== controller) controllerRef.current = controller;
+
+ useEffect(() => {
+ controllerRef.current = controller;
+ const unsubscribe = controller.subscribe((controllerState) => {
+ const roomId = roomIdRef.current;
+ if (!roomId) return;
+ if (controllerState.lifecycle === 'idle') {
+ store.set(livekitJsCallAtom, undefined);
+ return;
+ }
+ store.set(livekitJsCallAtom, {
+ roomId,
+ lifecycle: controllerState.lifecycle,
+ failure: controllerState.failure,
+ room: controllerState.lifecycle === 'active' ? controllerState.room : undefined,
+ media: controllerState.lifecycle === 'active' ? controllerState.media : undefined,
+ hangup: () => controller.disconnect(),
+ });
+ });
+ return () => {
+ unsubscribe();
+ roomIdRef.current = undefined;
+ if (controllerRef.current === controller) controllerRef.current = undefined;
+ void controller.disconnect().finally(() => {
+ // A stale disconnect completing after a deliberate replacement must
+ // not clear the newer controller's session from the atom.
+ if (generationRef.current === generation) {
+ store.set(livekitJsCallAtom, undefined);
+ }
+ });
+ };
+ }, [controller, generation, store]);
+
+ const start = useCallback(
+ ({ room, dm, video }: LivekitJsCallStartOptions) => {
+ if (store.get(callEmbedAtom) || isLivekitJsCallActive(store.get(livekitJsCallAtom))) return;
+ const activeController = controllerRef.current;
+ if (!activeController) return;
+ roomIdRef.current = room.roomId;
+ void activeController
+ .connect({
+ mx,
+ room,
+ discovery,
+ callIntent: video ? 'video' : 'audio',
+ dm,
+ ongoing: mx.matrixRTC.getRoomSession(room).memberships.length > 0,
+ })
+ .catch(() => undefined);
+ },
+ [mx, discovery, store]
+ );
+
+ const manager = useMemo(() => ({ start }), [start]);
+
+ return (
+
+ {children}
+
+ );
+}
diff --git a/src/app/hooks/useCallEmbed.ts b/src/app/hooks/useCallEmbed.ts
index 562aa2d9c..04d0fbbb3 100644
--- a/src/app/hooks/useCallEmbed.ts
+++ b/src/app/hooks/useCallEmbed.ts
@@ -1,13 +1,5 @@
import type { RefObject } from 'react';
-import {
- createContext,
- useCallback,
- useContext,
- useEffect,
- useMemo,
- useRef,
- useState,
-} from 'react';
+import { createContext, useCallback, useContext, useEffect, useState } from 'react';
import type { MatrixClient, Room } from '$types/matrix-sdk';
import { useSetAtom } from 'jotai';
import * as Sentry from '@sentry/react';
@@ -23,15 +15,12 @@ import type { CallPreferences } from '../state/callPreferences';
import { createDebugLogger } from '../utils/debugLogger';
import { useClientConfig } from './useClientConfig';
import { callEmbedStartErrorAtom } from '$state/callEmbed';
-import { useAutoDiscoveryInfo } from './useAutoDiscoveryInfo';
-import { useStore } from 'jotai';
import { settingsAtom } from '$state/settings';
import { useSetting } from '$state/hooks/settings';
-import { livekitJsCallAtom, isLivekitJsCallActive } from '$state/livekitJsCall';
import { acquireCallOwner } from '$state/callOwner';
-import { createLivekitJsController } from '$features/call/livekitJsController';
import { isLivekitJsCallProbeEnabled } from '$features/call/livekitJsCallProbe';
import { selectCallStartOwner } from '$features/call/callStartSelection';
+import { useLivekitJsCallManager } from '$features/call/livekitJsCallManager';
const debugLog = createDebugLogger('useCallEmbed');
@@ -83,41 +72,8 @@ export const useCallStart = (dm = false) => {
const setCallEmbed = useSetAtom(callEmbedAtom);
const setCallEmbedStartError = useSetAtom(callEmbedStartErrorAtom);
const callEmbedRef = useCallEmbedRef();
- const store = useStore();
const [livekitJsCallsEnabled] = useSetting(settingsAtom, 'livekitJsCallsEnabled');
- const [livekitJsMediaTestEnabled] = useSetting(settingsAtom, 'livekitJsMediaTestEnabled');
- const discovery = useAutoDiscoveryInfo();
- const livekitJsRoomIdRef = useRef(undefined);
- const livekitJsController = useMemo(
- () => createLivekitJsController(undefined, { manualMediaTest: livekitJsMediaTestEnabled }),
- [livekitJsMediaTestEnabled]
- );
-
- useEffect(() => {
- const unsubscribe = livekitJsController.subscribe((controllerState) => {
- const roomId = livekitJsRoomIdRef.current;
- if (!roomId) return;
- if (controllerState.lifecycle === 'idle') {
- store.set(livekitJsCallAtom, undefined);
- return;
- }
- store.set(livekitJsCallAtom, {
- roomId,
- lifecycle: controllerState.lifecycle,
- failure: controllerState.failure,
- room: controllerState.lifecycle === 'active' ? controllerState.room : undefined,
- media: controllerState.lifecycle === 'active' ? controllerState.media : undefined,
- hangup: () => livekitJsController.disconnect(),
- });
- });
- return () => {
- unsubscribe();
- livekitJsRoomIdRef.current = undefined;
- void livekitJsController.disconnect().finally(() => {
- store.set(livekitJsCallAtom, undefined);
- });
- };
- }, [livekitJsController, store]);
+ const livekitJsCallManager = useLivekitJsCallManager();
const startCall = useCallback(
(room: Room, pref?: CallPreferences) => {
@@ -125,18 +81,10 @@ export const useCallStart = (dm = false) => {
livekitJsProbeEnabled: isLivekitJsCallProbeEnabled(livekitJsCallsEnabled),
});
if (startOwner === 'livekit-js') {
- if (store.get(callEmbedAtom) || isLivekitJsCallActive(store.get(livekitJsCallAtom))) return;
- livekitJsRoomIdRef.current = room.roomId;
- void livekitJsController
- .connect({
- mx,
- room,
- discovery,
- callIntent: pref?.video ? 'video' : 'audio',
- dm,
- ongoing: mx.matrixRTC.getRoomSession(room).memberships.length > 0,
- })
- .catch(() => undefined);
+ if (!livekitJsCallManager) {
+ throw new Error('LiveKit JS call manager is not provided!');
+ }
+ livekitJsCallManager.start({ room, dm, video: pref?.video });
return;
}
const ownerLease = acquireCallOwner('element', room.roomId);
@@ -188,10 +136,8 @@ export const useCallStart = (dm = false) => {
callEmbedRef,
clientConfig.elementCallUrl,
setCallEmbedStartError,
- store,
- discovery,
livekitJsCallsEnabled,
- livekitJsController,
+ livekitJsCallManager,
]
);