mirror of
https://github.com/SableClient/Sable.git
synced 2026-11-20 09:01:17 -08:00
fix(call): stabilize LiveKit controller lifetime
This commit is contained in:
4 files changed
+450
-64
No files matched your search
@@ -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>
|
||||
);
|
||||
}
|
||||
@@ -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,
|
||||
]
|
||||
);
|
||||
|
||||
|
||||
Reference in new issue
Block a user