From 2cc6e4a033673cd8300f820d7c670ebf0193449d Mon Sep 17 00:00:00 2001 From: Erwan Leboucher Date: Wed, 29 Jul 2026 17:41:59 +0200 Subject: [PATCH] fix(call): stabilize LiveKit controller lifetime --- src/app/components/CallEmbedProvider.tsx | 7 +- .../call/livekitJsCallManager.test.tsx | 318 ++++++++++++++++++ .../features/call/livekitJsCallManager.tsx | 119 +++++++ src/app/hooks/useCallEmbed.ts | 70 +--- 4 files changed, 450 insertions(+), 64 deletions(-) create mode 100644 src/app/features/call/livekitJsCallManager.test.tsx create mode 100644 src/app/features/call/livekitJsCallManager.tsx 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, ] );