fix(call): stabilize LiveKit controller lifetime

This commit is contained in:
Erwan Leboucher committed 2026-07-30 14:10:58 +02:00
1 parent 5de9a1450e
commit 2cc6e4a033
4 files changed
+450 -64

No files matched your search

+5 -2
View File
@@ -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) {
<IncomingCallModal />
{callEmbed && <CallUtils embed={callEmbed} />}
<CallEmbedRefContextProvider value={callEmbedRef}>
<AutoJoinManager />
{children}
<LivekitJsCallManagerProvider>
<AutoJoinManager />
{children}
</LivekitJsCallManagerProvider>
</CallEmbedRefContextProvider>
<div
@@ -0,0 +1,318 @@
import type { ReactNode } from 'react';
import { useEffect } from 'react';
import { act, render, waitFor } from '@testing-library/react';
import { createStore, Provider as JotaiProvider } from 'jotai';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import type { MatrixClient, Room } from '$types/matrix-sdk';
import { MatrixClientProvider } from '$hooks/useMatrixClient';
import { AutoDiscoveryInfoProvider } from '$hooks/useAutoDiscoveryInfo';
import { CallEmbedRefContextProvider } from '$hooks/useCallEmbed';
import { getSettings, settingsAtom } from '$state/settings';
import { livekitJsCallAtom } from '$state/livekitJsCall';
import {
type LivekitJsCallManager,
LivekitJsCallManagerProvider,
useLivekitJsCallManager,
} from './livekitJsCallManager';
import type { LivekitJsControllerState } from './livekitJsController';
vi.mock('$hooks/useTheme', () => ({
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<LivekitJsControllerState>) => void;
type FakeController = {
connect: ReturnType<typeof vi.fn>;
disconnect: ReturnType<typeof vi.fn>;
subscribe: (listener: ControllerListener) => () => void;
getState: () => LivekitJsControllerState;
emit: (state: Partial<LivekitJsControllerState>) => void;
listenerCount: () => number;
};
const makeFakeController = (): FakeController => {
const listeners = new Set<ControllerListener>();
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<void>>(async () => undefined),
disconnect: vi.fn<() => Promise<void>>(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<typeof createStore>;
controllers: FakeController[];
wrapper: ({ children }: { children?: ReactNode }) => ReactNode;
managers: Array<LivekitJsCallManager | undefined>;
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<LivekitJsCallManager | undefined> = [];
const Consumer = (): null => {
managers.push(useLivekitJsCallManager());
return null;
};
const embedRef = { current: null };
const wrapper = ({ children }: { children?: ReactNode }) => (
<JotaiProvider store={store}>
<MatrixClientProvider value={mx}>
<AutoDiscoveryInfoProvider value={{ 'org.matrix.msc4143.rtc_foci': [] } as never}>
<CallEmbedRefContextProvider value={embedRef}>
<LivekitJsCallManagerProvider>{children}</LivekitJsCallManagerProvider>
</CallEmbedRefContextProvider>
</AutoDiscoveryInfoProvider>
</MatrixClientProvider>
</JotaiProvider>
);
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(
<harness.wrapper>
<harness.Consumer />
</harness.wrapper>
);
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(<harness.wrapper>{undefined}</harness.wrapper>);
expect(controller.disconnect).not.toHaveBeenCalled();
expect(controller.listenerCount()).toBe(1);
// A replacement consumer mounts and still sees the same controller/manager.
view.rerender(
<harness.wrapper>
<harness.Consumer />
</harness.wrapper>
);
expect(controller.disconnect).not.toHaveBeenCalled();
});
it('explicit end via session hangup disconnects exactly once', async () => {
const harness = createHarness();
render(
<harness.wrapper>
<harness.Consumer />
</harness.wrapper>
);
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(
<harness.wrapper>
<AutoJoinChild />
</harness.wrapper>
);
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<void>>(
() =>
new Promise<void>((resolve) => {
resolveOldDisconnect = resolve;
})
),
};
harness.controllers.push(controller);
return controller;
});
const view = render(
<harness.wrapper>
<harness.Consumer />
</harness.wrapper>
);
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(<harness.wrapper>{undefined}</harness.wrapper>);
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(<harness.wrapper>{undefined}</harness.wrapper>);
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(
<harness.wrapper>
<harness.Consumer />
<harness.Consumer />
<harness.Consumer />
</harness.wrapper>
);
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);
});
});
@@ -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<LivekitJsCallManager | undefined>(undefined);
export const useLivekitJsCallManager = (): LivekitJsCallManager | undefined =>
useContext(LivekitJsCallManagerContext);
type LivekitJsController = ReturnType<typeof createLivekitJsController>;
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<string | undefined>(undefined);
const controllerRef = useRef<LivekitJsController | undefined>(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<LivekitJsCallManager>(() => ({ start }), [start]);
return (
<LivekitJsCallManagerContext.Provider value={manager}>
{children}
</LivekitJsCallManagerContext.Provider>
);
}
+8 -62
View File
@@ -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<string | undefined>(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,
]
);