mirror of
https://github.com/vector-im/element-call.git
synced 2026-11-22 09:41:09 +08:00
Compare commits
14
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
aee75d7d72 | ||
|
|
5235fd0e65 | ||
|
|
0f5969677f | ||
|
|
d492b9d93a | ||
|
|
800e8d2a39 | ||
|
|
2a8836e44a | ||
|
|
f6b5dd0b7e | ||
|
|
3176992d5d | ||
|
|
f934cd158f | ||
|
|
ab7d2d3893 | ||
|
|
0e1badf559 | ||
|
|
c835409cd2 | ||
|
|
79c9900568 | ||
|
|
f2207ce21f |
@@ -0,0 +1,93 @@
|
||||
/*
|
||||
Copyright 2026 Element Creations Ltd.
|
||||
|
||||
SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { afterEach, beforeEach, expect, test, vi } from "vitest";
|
||||
import { render, screen } from "@testing-library/react";
|
||||
import { type MatrixClient, type Room } from "matrix-js-sdk";
|
||||
|
||||
import { mockEmitter, mockMatrixRoom } from "../src/utils/test";
|
||||
import { ElementCall } from "./index";
|
||||
|
||||
// The call itself is out of scope: what matters is what it is handed
|
||||
const callView = vi.hoisted(() => vi.fn());
|
||||
vi.mock("../src/room/CallView", () => ({
|
||||
CallView: (props: object): string => {
|
||||
callView(props);
|
||||
return "call";
|
||||
},
|
||||
}));
|
||||
|
||||
// Media devices need a browser jsdom does not have
|
||||
vi.mock("../src/state/AppViewModel", () => ({
|
||||
AppViewModel: class {
|
||||
public mediaDevices = {};
|
||||
public backgroundEffects = {};
|
||||
},
|
||||
}));
|
||||
|
||||
const roomId = "!room:example.org";
|
||||
let room: Room;
|
||||
|
||||
beforeEach(() => {
|
||||
// What the call's backend takes from the room
|
||||
room = mockMatrixRoom({
|
||||
roomId,
|
||||
getMembersWithMembership: vi.fn(),
|
||||
getLiveTimeline: vi.fn(),
|
||||
getVersion: vi.fn(),
|
||||
hasMembershipState: vi.fn(),
|
||||
_unstable_getStickyEvents: vi.fn(),
|
||||
getMxcAvatarUrl: vi.fn(),
|
||||
getJoinRule: vi.fn(),
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
callView.mockClear();
|
||||
});
|
||||
|
||||
test("calls in the room, leaving the session to the call", async () => {
|
||||
render(<ElementCall client={mockClient()} roomId={roomId} />);
|
||||
|
||||
await screen.findByText("call");
|
||||
const props = callView.mock.lastCall?.[0];
|
||||
expect(props).toMatchObject({ backend: { roomId } });
|
||||
expect(props).not.toHaveProperty("rtcSession");
|
||||
});
|
||||
|
||||
test("shows no call in a room the host's client does not know", () => {
|
||||
render(<ElementCall client={mockClient(null)} roomId={roomId} />);
|
||||
expect(screen.queryByText("call")).toBeNull();
|
||||
});
|
||||
|
||||
// No `matrixRTC`: the host's session manager is not ours to use
|
||||
function mockClient(knownRoom: Room | null = room): MatrixClient {
|
||||
return {
|
||||
...mockEmitter(),
|
||||
getRoom: (id: string) => (id === roomId ? knownRoom : null),
|
||||
// What the call view's client is made from
|
||||
baseUrl: "https://matrix.example.org",
|
||||
getUserId: () => "@alice:example.org",
|
||||
getDeviceId: () => "DEVICE",
|
||||
getAccessToken: () => "token",
|
||||
getSyncState: () => null,
|
||||
getUser: () => null,
|
||||
getCrypto: () => undefined,
|
||||
sendEvent: vi.fn(),
|
||||
sendStateEvent: vi.fn(),
|
||||
_unstable_sendStickyEvent: vi.fn(),
|
||||
_unstable_sendStickyDelayedEvent: vi.fn(),
|
||||
cancelPendingEvent: vi.fn(),
|
||||
encryptAndSendToDevice: vi.fn(),
|
||||
redactEvent: vi.fn(),
|
||||
decryptEventIfNeeded: vi.fn(),
|
||||
setDisplayName: vi.fn(),
|
||||
setAvatarUrl: vi.fn(),
|
||||
uploadContent: vi.fn(),
|
||||
doesServerSupportUnstableFeature: vi.fn(),
|
||||
} as unknown as MatrixClient;
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
/*
|
||||
Copyright 2026 Element Creations Ltd.
|
||||
|
||||
SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { afterEach, expect, test, vi } from "vitest";
|
||||
import {
|
||||
ClientEvent,
|
||||
EventType,
|
||||
type MatrixClient,
|
||||
SyncState,
|
||||
} from "matrix-js-sdk";
|
||||
|
||||
import { createComponentLocalJsClient } from "./componentLocalJsClient";
|
||||
|
||||
afterEach(() => {
|
||||
vi.unstubAllGlobals();
|
||||
});
|
||||
|
||||
test("reads the host's live state from the host's client", () => {
|
||||
const host = mockHost();
|
||||
const client = createComponentLocalJsClient(host);
|
||||
const listener = (): void => {};
|
||||
|
||||
expect(client.getSyncState()).toBe(SyncState.Syncing);
|
||||
client.on(ClientEvent.Sync, listener);
|
||||
client.off(ClientEvent.Sync, listener);
|
||||
client.getUser("@bob:example.org");
|
||||
client.getCrypto();
|
||||
|
||||
expect(host.getSyncState).toHaveBeenCalledOnce();
|
||||
expect(host.on).toHaveBeenCalledWith(ClientEvent.Sync, listener);
|
||||
expect(host.off).toHaveBeenCalledWith(ClientEvent.Sync, listener);
|
||||
expect(host.getUser).toHaveBeenCalledWith("@bob:example.org");
|
||||
expect(host.getCrypto).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
test("sends the RTC session's encrypted events with the host's crypto", async () => {
|
||||
const host = mockHost();
|
||||
const client = createComponentLocalJsClient(host);
|
||||
|
||||
await client._unstable_sendStickyEvent(
|
||||
"!room:example.org",
|
||||
1000,
|
||||
null,
|
||||
EventType.RTCMembership,
|
||||
{ slot_id: "m.call#ROOM", msc4354_sticky_key: "key" },
|
||||
);
|
||||
await client.encryptAndSendToDevice("m.room.encrypted", [], {});
|
||||
|
||||
expect(host._unstable_sendStickyEvent).toHaveBeenCalledOnce();
|
||||
expect(host.encryptAndSendToDevice).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
test("takes its credentials from the host", () => {
|
||||
const client = createComponentLocalJsClient(mockHost());
|
||||
|
||||
expect(client.getUserId()).toBe("@alice:example.org");
|
||||
expect(client.getDeviceId()).toBe("DEVICE");
|
||||
expect(client.getDomain()).toBe("example.org");
|
||||
expect(client.baseUrl).toBe("https://matrix.example.org");
|
||||
});
|
||||
|
||||
test("makes requests with whichever token the host holds now", async () => {
|
||||
const fetch = vi.fn(
|
||||
async () =>
|
||||
await Promise.resolve(
|
||||
new Response(JSON.stringify({ access_token: "openid" }), {
|
||||
headers: { "Content-Type": "application/json" },
|
||||
}),
|
||||
),
|
||||
);
|
||||
vi.stubGlobal("fetch", fetch);
|
||||
const host = mockHost();
|
||||
const client = createComponentLocalJsClient(host);
|
||||
// As if the host had refreshed its token after we were created
|
||||
host.token = "refreshed";
|
||||
|
||||
await client.getOpenIdToken();
|
||||
|
||||
expect(fetch).toHaveBeenCalledOnce();
|
||||
const [url, init] = fetch.mock.calls[0] as unknown as [URL, RequestInit];
|
||||
expect(url.toString()).toBe(
|
||||
"https://matrix.example.org/_matrix/client/v3/user/%40alice%3Aexample.org/openid/request_token",
|
||||
);
|
||||
expect(new Headers(init.headers).get("Authorization")).toBe(
|
||||
"Bearer refreshed",
|
||||
);
|
||||
});
|
||||
|
||||
function mockHost(): MatrixClient & { token: string } {
|
||||
const host = {
|
||||
token: "first",
|
||||
baseUrl: "https://matrix.example.org",
|
||||
getUserId: (): string => "@alice:example.org",
|
||||
getDeviceId: (): string => "DEVICE",
|
||||
getAccessToken: (): string => host.token,
|
||||
getSyncState: vi.fn(() => SyncState.Syncing),
|
||||
on: vi.fn(),
|
||||
off: vi.fn(),
|
||||
getUser: vi.fn(() => null),
|
||||
getCrypto: vi.fn(() => undefined),
|
||||
sendEvent: vi.fn(),
|
||||
sendStateEvent: vi.fn(),
|
||||
_unstable_sendStickyEvent: vi.fn(),
|
||||
_unstable_sendStickyDelayedEvent: vi.fn(),
|
||||
encryptAndSendToDevice: vi.fn(),
|
||||
redactEvent: vi.fn(),
|
||||
decryptEventIfNeeded: vi.fn(),
|
||||
setDisplayName: vi.fn(),
|
||||
setAvatarUrl: vi.fn(),
|
||||
uploadContent: vi.fn(),
|
||||
doesServerSupportUnstableFeature: vi.fn(),
|
||||
};
|
||||
return host as unknown as MatrixClient & { token: string };
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
/*
|
||||
Copyright 2026 Element Creations Ltd.
|
||||
|
||||
SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { createClient, type MatrixClient } from "matrix-js-sdk";
|
||||
import type { createCallMatrixBackend } from "../src/CallMatrixBackend";
|
||||
|
||||
/**
|
||||
* The client for Element Call in Component mode.
|
||||
* We do get the full host client but we dont want to use it as it
|
||||
* might use older versions of methods were we expect changes. (f.ex. getLivekitToken)
|
||||
* We really want the expected implementation to not get runtime errors.
|
||||
*
|
||||
* This creates a new client that does use the hosts token and "stable"
|
||||
* methods but uses the ElementCall Components js-sdk's client impl for anything else.
|
||||
*/
|
||||
export function createComponentLocalJsClient(
|
||||
host: MatrixClient,
|
||||
): Parameters<typeof createCallMatrixBackend>[0] {
|
||||
const own = createClient({
|
||||
baseUrl: host.baseUrl,
|
||||
userId: host.getUserId() ?? undefined,
|
||||
deviceId: host.getDeviceId() ?? undefined,
|
||||
accessToken: host.getAccessToken() ?? undefined,
|
||||
// The host refreshes its token without telling us, so each request takes
|
||||
// whichever token the host holds now
|
||||
fetchFn: async (input, init) => {
|
||||
const headers = new Headers(init?.headers);
|
||||
const token = host.getAccessToken();
|
||||
if (token !== null) headers.set("Authorization", `Bearer ${token}`);
|
||||
return globalThis.fetch(input, { ...init, headers });
|
||||
},
|
||||
});
|
||||
|
||||
return {
|
||||
// Own has no sync loop: `syncApi?.getSyncState() ?? null` is always null
|
||||
getSyncState: host.getSyncState.bind(host),
|
||||
// Only the syncing host emits `Sync`, `ToDeviceEvent` and `Decrypted`
|
||||
on: host.on.bind(host),
|
||||
// The same emitter as `on`
|
||||
off: host.off.bind(host),
|
||||
// `this.store.getUser`: own's store is empty, only the host's sync fills it
|
||||
getUser: host.getUser.bind(host),
|
||||
// Own never inits crypto, and a second one on the device would corrupt it
|
||||
getCrypto: host.getCrypto.bind(host),
|
||||
// Own has no rooms: `encryptEventIfNeeded`'s `if (!room) return` skips E2EE
|
||||
sendEvent: host.sendEvent.bind(host),
|
||||
// Not encrypted, but the local echo goes to `getRoom()`: only the host's
|
||||
redactEvent: host.redactEvent.bind(host),
|
||||
// `attemptDecryption` only runs `if (this.getCrypto())`: a no-op on own
|
||||
decryptEventIfNeeded: host.decryptEventIfNeeded.bind(host),
|
||||
// Like `sendEvent`: on own, `if (!room) return` sends it in plaintext
|
||||
_unstable_sendStickyEvent: host._unstable_sendStickyEvent.bind(host),
|
||||
// Like `sendEvent`: delayed, but still `encryptEventIfNeeded(event, room)`
|
||||
_unstable_sendStickyDelayedEvent:
|
||||
host._unstable_sendStickyDelayedEvent.bind(host),
|
||||
// `if (!this.cryptoBackend) throw`: own has no crypto
|
||||
encryptAndSendToDevice: host.encryptAndSendToDevice.bind(host),
|
||||
|
||||
// Static: own was created with the host's user id
|
||||
getUserId: own.getUserId.bind(own),
|
||||
// Static: own was created with the host's device id
|
||||
getDeviceId: own.getDeviceId.bind(own),
|
||||
// Static: derived from the user id
|
||||
getDomain: own.getDomain.bind(own),
|
||||
// Static: own was created with the host's base URL
|
||||
baseUrl: own.baseUrl,
|
||||
// MSC4143 stable or unstable prefix, picked by /versions: ours knows both
|
||||
getRTCTransports: own.getRTCTransports.bind(own),
|
||||
// Plain HTTP with the copied credentials, like the other LiveKit auth
|
||||
getOpenIdToken: own.getOpenIdToken.bind(own),
|
||||
// MSC4195 stable or `io.element.msc4195` prefix: an older host may lack it
|
||||
getLivekitToken: own.getLivekitToken.bind(own),
|
||||
// MSC4195, like `getLivekitToken`: an older host may lack it
|
||||
delegateDelayedLeave: own.delegateDelayedLeave.bind(own),
|
||||
// Plain HTTP into own's cache, which `getCachedCapabilities` reads
|
||||
fetchCapabilities: own.fetchCapabilities.bind(own),
|
||||
// Has to be the client whose cache `fetchCapabilities` filled
|
||||
getCachedCapabilities: own.getCachedCapabilities.bind(own),
|
||||
// Straight to `scheduleDelayedEvent`: no room, no crypto, plain HTTP
|
||||
_unstable_sendDelayedStateEvent:
|
||||
own._unstable_sendDelayedStateEvent.bind(own),
|
||||
// Plain POST `/delayed_events/{id}/cancel`; newer API an old host may lack
|
||||
_unstable_cancelScheduledDelayedEvent:
|
||||
own._unstable_cancelScheduledDelayedEvent.bind(own),
|
||||
// Plain POST by the server's delay id: restarts the host's sticky leave too
|
||||
_unstable_restartScheduledDelayedEvent:
|
||||
own._unstable_restartScheduledDelayedEvent.bind(own),
|
||||
// Plain POST `/delayed_events/{id}/send`; newer API an old host may lack
|
||||
_unstable_sendScheduledDelayedEvent:
|
||||
own._unstable_sendScheduledDelayedEvent.bind(own),
|
||||
|
||||
// Plain HTTP, either client works; a stable API, so the host's
|
||||
sendStateEvent: host.sendStateEvent.bind(host),
|
||||
// Updates the `User` in the host's store, which `useProfile` listens to
|
||||
setDisplayName: host.setDisplayName.bind(host),
|
||||
// Like `setDisplayName`: updates the `User` in the host's store
|
||||
setAvatarUrl: host.setAvatarUrl.bind(host),
|
||||
// Plain HTTP, either client works; a stable API, so the host's
|
||||
uploadContent: host.uploadContent.bind(host),
|
||||
// Reads the host's /versions, which it has already fetched
|
||||
doesServerSupportUnstableFeature:
|
||||
host.doesServerSupportUnstableFeature.bind(host),
|
||||
};
|
||||
}
|
||||
+13
-6
@@ -84,7 +84,9 @@ import styles from "./ElementCall.module.css";
|
||||
import { useComponentHostBridge } from "./host";
|
||||
import { CallPortalRoot } from "./CallPortalRoot";
|
||||
import { type ElementCallProps } from "./api";
|
||||
import { createComponentLocalJsClient } from "./componentLocalJsClient";
|
||||
import { supportedLanguages, translationsBackend } from "./localization";
|
||||
import { createCallMatrixBackend } from "../src/CallMatrixBackend";
|
||||
|
||||
// The languages Element Call can be shown in
|
||||
export { supportedLanguages } from "./localization";
|
||||
@@ -205,12 +207,14 @@ export const ElementCall: FC<ElementCallProps> = ({
|
||||
}, [controlledAudioDevices, callIntent]);
|
||||
|
||||
const room = client.getRoom(roomId);
|
||||
const rtcSession = useMemo(
|
||||
() => (room === null ? null : client.matrixRTC.getRoomSession(room)),
|
||||
const backend = useMemo(
|
||||
() =>
|
||||
room &&
|
||||
createCallMatrixBackend(createComponentLocalJsClient(client), room),
|
||||
[client, room],
|
||||
);
|
||||
|
||||
if (rtcSession === null)
|
||||
if (room === null)
|
||||
logger.error(
|
||||
`Element Call was asked to call in ${roomId}, which its host's client does not know about`,
|
||||
);
|
||||
@@ -220,7 +224,7 @@ export const ElementCall: FC<ElementCallProps> = ({
|
||||
// is told that Element Call has loaded, as the widget tells its client once
|
||||
// its own initialisation is over. Once per mount, however often the pieces
|
||||
// are later swapped out.
|
||||
const ready = container !== null && rtcSession !== null && vm !== null;
|
||||
const ready = container !== null && backend !== null && vm !== null;
|
||||
const announcedLoaded = useRef(false);
|
||||
useEffect(() => {
|
||||
if (!ready || announcedLoaded.current) return;
|
||||
@@ -250,14 +254,17 @@ export const ElementCall: FC<ElementCallProps> = ({
|
||||
>
|
||||
<Decoration>
|
||||
<TooltipProvider>
|
||||
{/* The host's own client: what reads it through
|
||||
the context (avatars, the encryption system,
|
||||
rageshakes, the disconnected banner) uses only its
|
||||
stable methods. */}
|
||||
<ClientProvider client={client}>
|
||||
<MediaDevicesContext value={vm.mediaDevices}>
|
||||
<BackgroundEffectsProvider
|
||||
effects={vm.backgroundEffects}
|
||||
>
|
||||
<CallView
|
||||
client={client}
|
||||
rtcSession={rtcSession}
|
||||
backend={backend}
|
||||
isPasswordlessUser={false}
|
||||
confineToRoom={params.confineToRoom}
|
||||
preload={params.preload}
|
||||
|
||||
@@ -118,8 +118,6 @@
|
||||
"livekit_connection_error": "Failed to connect to Livekit server",
|
||||
"livekit_connection_error_description": "An error occurred while connecting to the Livekit server (<1>Reason:</1> <2>{{ reason }}</2>).",
|
||||
"matrix_rtc_transport_missing": "The server is not configured to work with {{brand}} and no other call participant provides a usable transport. Please contact your server admin (Domain: {{domain}}, Error Code: {{ errorCode }}).",
|
||||
"membership_manager": "Membership Manager Error",
|
||||
"membership_manager_description": "The Membership Manager had to shut down. This is caused by many consecutive failed network requests.",
|
||||
"no_matrix_2_authorization_service": "The authorization service for your media server (SFU) is out of date.",
|
||||
"open_elsewhere": "Opened in another tab",
|
||||
"open_elsewhere_description": "{{brand}} has been opened in another tab. If that doesn't sound right, try reloading the page.",
|
||||
|
||||
@@ -20,6 +20,7 @@ import { EMPTY, filter, map, type Observable, of, switchMap, take } from "rxjs";
|
||||
import {
|
||||
type Behavior,
|
||||
createRTCSlot,
|
||||
createSdkMatrixBackend,
|
||||
E2eeType,
|
||||
type LocalRTCMember,
|
||||
ObservableScope,
|
||||
@@ -36,7 +37,6 @@ import {
|
||||
import {
|
||||
captureSettings,
|
||||
rtcParticipationOptions,
|
||||
rtcSlotOptions,
|
||||
} from "../src/room/InCallView";
|
||||
import { createWidgetHostBridge } from "../src/HostBridge";
|
||||
import { MediaDevices } from "../src/state/MediaDevices";
|
||||
@@ -94,10 +94,9 @@ export async function createMatrixRTCSdk(
|
||||
);
|
||||
const encryptionSystem = { kind: E2eeType.PER_PARTICIPANT } as const;
|
||||
const capture = captureSettings();
|
||||
const slot = createRTCSlot(scope, client, room, {
|
||||
...rtcSlotOptions(encryptionSystem),
|
||||
application,
|
||||
id,
|
||||
const slot = createRTCSlot(scope, createSdkMatrixBackend(client, room), {
|
||||
encryptionSystem,
|
||||
slotDescription: { application, id },
|
||||
});
|
||||
let vm: CallViewModel | undefined;
|
||||
const failed =
|
||||
@@ -131,6 +130,7 @@ export async function createMatrixRTCSdk(
|
||||
{
|
||||
rtcParticipation: participation,
|
||||
matrixRoom: room,
|
||||
client,
|
||||
mediaDevices,
|
||||
muteStates,
|
||||
encryptionSystem,
|
||||
|
||||
+7
-6
@@ -19,6 +19,7 @@ nothing in Element Call's `src/`.
|
||||
```ts
|
||||
import {
|
||||
createRTCSlot,
|
||||
createSdkMatrixBackend,
|
||||
E2eeType,
|
||||
MatrixRTCMode,
|
||||
ObservableScope,
|
||||
@@ -28,15 +29,15 @@ import {
|
||||
const scope = new ObservableScope();
|
||||
const slot = createRTCSlot(
|
||||
scope,
|
||||
client, // a matrix-js-sdk MatrixClient, logged in and syncing
|
||||
room, // the matrix-js-sdk Room, from client.getRoom() once the join has synced
|
||||
{
|
||||
encryptionSystem: { kind: E2eeType.PER_PARTICIPANT },
|
||||
matrixRTCMode: MatrixRTCMode.Compatibility,
|
||||
},
|
||||
createSdkMatrixBackend(
|
||||
client, // a matrix-js-sdk MatrixClient, logged in and syncing
|
||||
room, // the matrix-js-sdk Room, from client.getRoom() once the join has synced
|
||||
),
|
||||
{ encryptionSystem: { kind: E2eeType.PER_PARTICIPANT } }, // the room's call, m.call#ROOM
|
||||
);
|
||||
const participation = slot.join({
|
||||
publish: [{ source: "microphone" }, { source: "camera" }],
|
||||
matrixRTCMode: MatrixRTCMode.Compatibility,
|
||||
});
|
||||
|
||||
// A <video> for each remote member's camera and an <audio> for its microphone.
|
||||
|
||||
+12
-12
@@ -143,18 +143,18 @@ participation split in
|
||||
[`client-into-slot-session-split-plan.md`](./client-into-slot-session-split-plan.md);
|
||||
the sections below still describe `MatrixRTCClient` until that lands.
|
||||
|
||||
| Word | Meaning here | Elsewhere |
|
||||
| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------- |
|
||||
| slot | an `RTCSlot`: the namespace in a room that memberships join into, `application` plus `id`. It exists while the room does, with nobody in it too. Holds `members$`, its open or closed `status$`, and `join()` | the js-sdk `MatrixRTCSession` is one per slot; the MSC4143 slot event |
|
||||
| participation | an `RTCParticipation`: the span between our `join()` of a slot and our `leave()`. Holds the connection and its `state$`, `localMember$`, `remoteMembers$`, the connected transports and the data channel. Made by `slot.join()`, never reused | "session" is not used here, because in the js-sdk it means the slot |
|
||||
| member | an `RTCMember`: one membership in a slot with what the SDK derives from it, `rtcBackendIdentity`, `userId`, `deviceId`, `memberId`, `displayName$`, `avatarUrl$`, `transport$` and `applicationData$`. No media. What the slot hands out in `members$` | the js-sdk `CallMembership` behind it, which never leaves the SDK; Element Call's old "matrixLivekitMember" |
|
||||
| local member, remote member | `LocalRTCMember` and `RemoteRTCMember`: an `RTCMember` plus its `MemberMedia`, which only a participation can carry. The local one's tracks carry the controls. What the participation hands out in `localMember$` and `remoteMembers$` | LiveKit `LocalParticipant` and `RemoteParticipant`, which never leave the SDK |
|
||||
| media | a `MemberMedia`: what a member sends once it has arrived on its transport, `tracks$`, null while waiting, and `encryptionError$` beside it. The media backend supplies exactly these two fields per member | Element Call's `MediaViewModel` is a view of it |
|
||||
| track | a `MediaTrack`: one publication of a member, audio or video, with `source`, `kind`, `id` and the behaviors on it. `LocalAudioMediaTrack` and `LocalVideoMediaTrack` add the controls over our own | LiveKit `TrackPublication` and `Track`, which never leave the SDK |
|
||||
| publish request | a `PublishRequest`: a source, where to capture it from and how to encode it. Given at the join in `publish`, or later to `publish` on the participation | |
|
||||
| attach, detach | handing a `<video>` or `<audio>` element to a track and taking it back. The SDK owns the stream and the observers on the element | LiveKit `Track.attach` |
|
||||
| transport | an `RTCTransport`: where media is exchanged, a LiveKit service url today. Carries the raw js-sdk `Transport` from the membership and, in `resolved$`, what the backend fetched to connect to it | MSC4143 "focus" |
|
||||
| media backend | a `MediaBackend`: what carries the media, behind `sdk/src/media-backend/api.ts`. One per participation, chosen with `backend` in the join options; LiveKit under `sdk/src/media-backend/livekit/` is the one that exists | "SFU", a LiveKit room, a peer connection |
|
||||
| Word | Meaning here | Elsewhere |
|
||||
| --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------- |
|
||||
| slot | an `RTCSlot`: the namespace in a room that memberships join into, `application` plus `id`. It exists while the room does, with nobody in it too. Holds `members$`, its open or closed `status$`, and `join()` | the js-sdk `MatrixRTCSession` is one per slot; the MSC4143 slot event |
|
||||
| participation | an `RTCParticipation`: the span between our `join()` of a slot and our `leave()`. Holds the connection and its `state$`, `localMember$`, `remoteMembers$`, the connected transports and the data channel. Made by `slot.join()`, never reused | "session" is not used here, because in the js-sdk it means the slot |
|
||||
| member | an `RTCMember`: one membership in a slot with what the SDK derives from it, `rtcBackendIdentity`, `userId`, `deviceId`, `memberId`, `matrixEventId$`, `displayName$`, `avatarUrl$`, `transport$` and `applicationData$`. No media. What the slot hands out in `members$` | the js-sdk `CallMembership` behind it, which never leaves the SDK; Element Call's old "matrixLivekitMember" |
|
||||
| local member, remote member | `LocalRTCMember` and `RemoteRTCMember`: an `RTCMember` plus its `MemberMedia`, which only a participation can carry. The local one's tracks carry the controls. What the participation hands out in `localMember$` and `remoteMembers$` | LiveKit `LocalParticipant` and `RemoteParticipant`, which never leave the SDK |
|
||||
| media | a `MemberMedia`: what a member sends once it has arrived on its transport, `tracks$`, null while waiting, and `encryptionError$` beside it. The media backend supplies exactly these two fields per member | Element Call's `MediaViewModel` is a view of it |
|
||||
| track | a `MediaTrack`: one publication of a member, audio or video, with `source`, `kind`, `id` and the behaviors on it. `LocalAudioMediaTrack` and `LocalVideoMediaTrack` add the controls over our own | LiveKit `TrackPublication` and `Track`, which never leave the SDK |
|
||||
| publish request | a `PublishRequest`: a source, where to capture it from and how to encode it. Given at the join in `publish`, or later to `publish` on the participation | |
|
||||
| attach, detach | handing a `<video>` or `<audio>` element to a track and taking it back. The SDK owns the stream and the observers on the element | LiveKit `Track.attach` |
|
||||
| transport | an `RTCTransport`: where media is exchanged, a LiveKit service url today. Carries the raw js-sdk `Transport` from the membership and, in `resolved$`, what the backend fetched to connect to it | MSC4143 "focus" |
|
||||
| media backend | a `MediaBackend`: what carries the media, behind `sdk/src/media-backend/api.ts`. One per participation, chosen with `backend` in the join options; LiveKit under `sdk/src/media-backend/livekit/` is the one that exists | "SFU", a LiveKit room, a peer connection |
|
||||
|
||||
Names use `RTC` in capitals, as the js-sdk does: `RTCSlot`, `RTCParticipation`,
|
||||
`RTCMember`, `matrixRTCMode`.
|
||||
|
||||
+3
-2
@@ -16,6 +16,7 @@ import { combineLatest, type Observable, of, switchMap } from "rxjs";
|
||||
import {
|
||||
type AudioMediaTrack,
|
||||
createRTCSlot,
|
||||
createSdkMatrixBackend,
|
||||
E2eeType,
|
||||
type LocalRTCMember,
|
||||
MatrixRTCMode,
|
||||
@@ -70,12 +71,12 @@ async function start(
|
||||
const room = await joinRoom(client, roomIdOrAlias);
|
||||
|
||||
const scope = new ObservableScope();
|
||||
const slot = createRTCSlot(scope, client, room, {
|
||||
const slot = createRTCSlot(scope, createSdkMatrixBackend(client, room), {
|
||||
encryptionSystem: { kind: E2eeType.PER_PARTICIPANT },
|
||||
matrixRTCMode: MatrixRTCMode.Compatibility,
|
||||
});
|
||||
const rtcParticipation = slot.join({
|
||||
publish: [{ source: "microphone" }, { source: "camera" }],
|
||||
matrixRTCMode: MatrixRTCMode.Compatibility,
|
||||
});
|
||||
rtcParticipation.state$.pipe(scope.bind()).subscribe((state) => {
|
||||
status.textContent =
|
||||
|
||||
@@ -57,6 +57,11 @@ export * from "./src/media-api";
|
||||
export * from "./src/media-backend/api";
|
||||
export { trackBySource$, type TrackOfSource } from "./src/utils/tracks";
|
||||
export { createRTCSlot } from "./src/RTCSlot";
|
||||
export {
|
||||
createSdkMatrixBackend,
|
||||
type SdkMatrixBackend,
|
||||
withEmitter,
|
||||
} from "./src/SdkMatrixBackend";
|
||||
export {
|
||||
createLivekitBackend,
|
||||
type LivekitBackendOptions,
|
||||
|
||||
@@ -22,7 +22,6 @@ import {
|
||||
type ParticipationState,
|
||||
type RTCMember,
|
||||
type RTCParticipationOptions,
|
||||
type RTCSlot,
|
||||
type TransportMetadata,
|
||||
} from "./api";
|
||||
import { defaultSessionTimings, MatrixRTCMode } from "./config";
|
||||
@@ -86,6 +85,7 @@ function member(
|
||||
rtcBackendIdentity: overrides.memberId,
|
||||
backendIdentities: [overrides.memberId],
|
||||
deviceId: "DEV",
|
||||
matrixEventId$: constant(`$${overrides.memberId}`),
|
||||
transport$: constant(metadata(transport)),
|
||||
applicationData$: constant({}),
|
||||
displayName$: constant(overrides.userId),
|
||||
@@ -111,7 +111,6 @@ interface FakeBackend {
|
||||
|
||||
function setup(
|
||||
options: Partial<RTCParticipationOptions> = {},
|
||||
slotOptions: { matrixRTCMode?: MatrixRTCMode } = {},
|
||||
{
|
||||
homeserverTransports = [transport],
|
||||
memberships = [],
|
||||
@@ -191,19 +190,24 @@ function setup(
|
||||
scope,
|
||||
{
|
||||
client,
|
||||
room,
|
||||
slot: {} as RTCSlot,
|
||||
jsSdkSession: mockedSession,
|
||||
members$: scope.behavior(members$),
|
||||
transports: { get: metadata, connected$: constant([]) },
|
||||
slotOptions: {
|
||||
matrixRTCMode: MatrixRTCMode.Compatibility,
|
||||
encryptionSystem: { kind: E2eeType.PER_PARTICIPANT },
|
||||
...slotOptions,
|
||||
slot: {
|
||||
roomId: room.roomId,
|
||||
application: "m.call",
|
||||
id: "ROOM",
|
||||
status$: constant(undefined),
|
||||
members$: scope.behavior(members$),
|
||||
},
|
||||
jsSdkSession: mockedSession,
|
||||
transports: { get: metadata, connected$: constant([]) },
|
||||
slotOptions: { encryptionSystem: { kind: E2eeType.PER_PARTICIPANT } },
|
||||
logger,
|
||||
},
|
||||
{ publish: [], backend: backendFactory, ...options },
|
||||
{
|
||||
publish: [],
|
||||
matrixRTCMode: MatrixRTCMode.Compatibility,
|
||||
backend: backendFactory,
|
||||
...options,
|
||||
},
|
||||
);
|
||||
const states: ParticipationState[] = [];
|
||||
participation.state$.subscribe((state) => states.push(state));
|
||||
@@ -254,7 +258,6 @@ describe("createRTCParticipation", () => {
|
||||
fociPreferred: [{ type: "livekit", url: "wss://sfu.example.org" }],
|
||||
});
|
||||
const { join, fake } = setup(
|
||||
{},
|
||||
{},
|
||||
{ homeserverTransports: [], memberships: [bobOnSfu] },
|
||||
);
|
||||
@@ -349,7 +352,7 @@ describe("createRTCParticipation", () => {
|
||||
});
|
||||
compatibility.scope.end();
|
||||
|
||||
const matrix2 = setup({}, { matrixRTCMode: MatrixRTCMode.Matrix_2_0 });
|
||||
const matrix2 = setup({ matrixRTCMode: MatrixRTCMode.Matrix_2_0 });
|
||||
const { memberId } = matrix2.fake.context.ownMembershipIdentity;
|
||||
expect(memberId).not.toBe(legacyMemberId);
|
||||
expect(memberId).toMatch(/^[0-9a-f-]{36}$/);
|
||||
|
||||
+53
-33
@@ -5,7 +5,7 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { type MatrixClient, type Room } from "matrix-js-sdk";
|
||||
import { type MatrixClient } from "matrix-js-sdk";
|
||||
import { type Logger } from "matrix-js-sdk/lib/logger";
|
||||
import {
|
||||
type MatrixRTCSession as JsSdkRTCSession,
|
||||
@@ -30,19 +30,17 @@ import {
|
||||
|
||||
import { defaultSessionTimings, MatrixRTCMode } from "./config";
|
||||
import { E2eeType } from "./encryption";
|
||||
import { type Behavior } from "./reactive/Behavior";
|
||||
import { type ObservableScope } from "./reactive/ObservableScope";
|
||||
import { generateItems } from "./reactive/observable";
|
||||
import { mapScoped } from "./utils/mapScoped";
|
||||
import {
|
||||
type ParticipationSlot,
|
||||
type DataMessage,
|
||||
type LocalRTCMember,
|
||||
type ParticipationState,
|
||||
type RemoteRTCMember,
|
||||
type RTCMember,
|
||||
type RTCParticipation,
|
||||
type RTCParticipationOptions,
|
||||
type RTCSlot,
|
||||
type RTCSlotOptions,
|
||||
} from "./api";
|
||||
import {
|
||||
@@ -67,15 +65,34 @@ import { createKeyRotationSuppressed$ } from "./matrixrtc/JsRtcSessionBehaviors"
|
||||
import { type TransportRegistry } from "./matrixrtc/Transports";
|
||||
import { participationState } from "./participationState";
|
||||
|
||||
/** What the slot lends a participation. */
|
||||
/** What is needed for our own participation. */
|
||||
export interface ParticipationDeps {
|
||||
client: MatrixClient;
|
||||
room: Room;
|
||||
slot: RTCSlot;
|
||||
client: Pick<
|
||||
MatrixClient,
|
||||
// Our own membership identity
|
||||
| "getUserId"
|
||||
| "getDeviceId"
|
||||
// Local transport discovery
|
||||
| "getDomain"
|
||||
| "getRTCTransports"
|
||||
// LiveKit auth: `getOpenIdToken` for the JWT service flow, `getLivekitToken`
|
||||
// for the client-server API flow (MSC4195), `delegateDelayedLeave` and
|
||||
// `baseUrl` for the delayed leave delegation and its probe
|
||||
| "getOpenIdToken"
|
||||
| "getLivekitToken"
|
||||
| "delegateDelayedLeave"
|
||||
| "baseUrl"
|
||||
// Homeserver connection: whether the client is syncing
|
||||
| "getSyncState"
|
||||
// `on`/`off`, to listen for:
|
||||
// - `ClientEvent.Sync` (homeserver connection)
|
||||
| "on"
|
||||
| "off"
|
||||
>;
|
||||
slot: ParticipationSlot;
|
||||
jsSdkSession: JsSdkRTCSession;
|
||||
members$: Behavior<RTCMember[]>;
|
||||
transports: TransportRegistry;
|
||||
slotOptions: Pick<RTCSlotOptions, "matrixRTCMode" | "encryptionSystem">;
|
||||
slotOptions: RTCSlotOptions;
|
||||
logger: Logger;
|
||||
}
|
||||
|
||||
@@ -94,16 +111,19 @@ export function createRTCParticipation(
|
||||
scope: ObservableScope,
|
||||
{
|
||||
client,
|
||||
room,
|
||||
slot,
|
||||
jsSdkSession,
|
||||
members$,
|
||||
transports,
|
||||
slotOptions: { matrixRTCMode, encryptionSystem },
|
||||
slotOptions: { encryptionSystem },
|
||||
logger: parentLogger,
|
||||
}: ParticipationDeps,
|
||||
options: RTCParticipationOptions,
|
||||
): ParticipationInternals {
|
||||
const { matrixRTCMode } = options;
|
||||
const { roomId, members$ } = slot;
|
||||
// The full `{application}#{id}`, which the auth service and the other
|
||||
// members key the media room on
|
||||
const slotId = jsSdkSession.slotId;
|
||||
const logger = parentLogger.getChild("[RTCParticipation]");
|
||||
const userId = client.getUserId()!;
|
||||
const deviceId = client.getDeviceId()!;
|
||||
@@ -122,8 +142,8 @@ export function createRTCParticipation(
|
||||
};
|
||||
|
||||
const backend = createBackend(scope, client, options, {
|
||||
roomId: room.roomId,
|
||||
slotId: jsSdkSession.slotId,
|
||||
roomId,
|
||||
slotId,
|
||||
ownMembershipIdentity,
|
||||
publish: options.publish,
|
||||
encryptionSystem,
|
||||
@@ -144,8 +164,8 @@ export function createRTCParticipation(
|
||||
// to come back later rather than wait in a half-working lobby
|
||||
memberships: jsSdkSession.memberships,
|
||||
ownMembershipIdentity,
|
||||
roomId: room.roomId,
|
||||
slotId: jsSdkSession.slotId,
|
||||
roomId,
|
||||
slotId,
|
||||
logger,
|
||||
})
|
||||
: null;
|
||||
@@ -175,21 +195,15 @@ export function createRTCParticipation(
|
||||
timings.syncDisconnectGracePeriodMs,
|
||||
),
|
||||
joinMatrixRTC: (transport, delayedLeave) =>
|
||||
joinJsSdkSession(
|
||||
room.roomId,
|
||||
jsSdkSession,
|
||||
ownMembershipIdentity,
|
||||
transport,
|
||||
{
|
||||
encryptMedia: encryptionSystem.kind !== E2eeType.NONE,
|
||||
matrixRTCMode,
|
||||
sendNotificationType: options.sendNotificationType,
|
||||
callIntent: options.callIntent,
|
||||
applicationData: options.applicationData,
|
||||
timings,
|
||||
delayedLeave,
|
||||
},
|
||||
),
|
||||
joinJsSdkSession(roomId, jsSdkSession, ownMembershipIdentity, transport, {
|
||||
encryptMedia: encryptionSystem.kind !== E2eeType.NONE,
|
||||
matrixRTCMode,
|
||||
sendNotificationType: options.sendNotificationType,
|
||||
callIntent: options.callIntent,
|
||||
applicationData: options.applicationData,
|
||||
timings,
|
||||
delayedLeave,
|
||||
}),
|
||||
membershipManagerError$: fromEvent(
|
||||
jsSdkSession,
|
||||
MatrixRTCSessionEvent.MembershipManagerError,
|
||||
@@ -315,7 +329,13 @@ export function createRTCParticipation(
|
||||
/** The host's backend, or LiveKit configured from the participation options. */
|
||||
function createBackend(
|
||||
scope: ObservableScope,
|
||||
client: MatrixClient,
|
||||
client: Pick<
|
||||
MatrixClient,
|
||||
// LiveKit auth: `getOpenIdToken` for the JWT service flow, `getLivekitToken`
|
||||
// for the client-server API flow (MSC4195), `delegateDelayedLeave` and
|
||||
// `baseUrl` for the delayed leave delegation and its probe
|
||||
"getOpenIdToken" | "getLivekitToken" | "delegateDelayedLeave" | "baseUrl"
|
||||
>,
|
||||
{ backend, mediaQuality }: RTCParticipationOptions,
|
||||
context: MediaBackendContext,
|
||||
): MediaBackend {
|
||||
|
||||
+132
-8
@@ -5,7 +5,7 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { describe, expect, it, vi } from "vitest";
|
||||
import { type MatrixClient, type Room } from "matrix-js-sdk";
|
||||
import { EventType } from "matrix-js-sdk/lib/@types/event";
|
||||
import { type MatrixEvent } from "matrix-js-sdk/lib/models/event";
|
||||
@@ -13,15 +13,26 @@ import {
|
||||
type RoomState,
|
||||
RoomStateEvent,
|
||||
} from "matrix-js-sdk/lib/models/room-state";
|
||||
import { RoomStickyEventsEvent } from "matrix-js-sdk/lib/models/room-sticky-events";
|
||||
|
||||
import {
|
||||
MatrixRTCSessionEvent,
|
||||
type MatrixRTCSessionEventHandlerMap,
|
||||
} from "matrix-js-sdk/lib/matrixrtc";
|
||||
|
||||
import { createRTCSlot } from "./RTCSlot";
|
||||
import { type SdkMatrixBackend } from "./SdkMatrixBackend";
|
||||
import { ObservableScope } from "./reactive/ObservableScope";
|
||||
import { type RTCSlotOptions } from "./api";
|
||||
import { MatrixRTCMode } from "./config";
|
||||
import { E2eeType } from "./encryption";
|
||||
import { mockEmitter, MockRTCSession, testScope } from "./utils/test";
|
||||
import {
|
||||
mockEmitter,
|
||||
mockRtcMembership,
|
||||
MockRTCSession,
|
||||
testScope,
|
||||
} from "./utils/test";
|
||||
|
||||
const options: RTCSlotOptions = {
|
||||
matrixRTCMode: MatrixRTCMode.Compatibility,
|
||||
encryptionSystem: { kind: E2eeType.NONE },
|
||||
};
|
||||
|
||||
@@ -34,28 +45,117 @@ function setup(): {
|
||||
...mockEmitter(),
|
||||
roomId: "!room:example.org",
|
||||
getMembersWithMembership: (): [] => [],
|
||||
// An empty room, for a session of the slot's own
|
||||
getLiveTimeline: () => ({ getState: (): undefined => undefined }),
|
||||
hasMembershipState: (): boolean => false,
|
||||
getVersion: (): string => "11",
|
||||
_unstable_getStickyEvents: (): [] => [],
|
||||
} as unknown as Room;
|
||||
const session = new MockRTCSession(room);
|
||||
const client = {
|
||||
...mockEmitter(),
|
||||
getUserId: (): string => "@alice:example.org",
|
||||
getDeviceId: (): string => "AAAA",
|
||||
matrixRTC: { getRoomSession: (): MockRTCSession => session },
|
||||
} as unknown as MatrixClient;
|
||||
return { client, room, session };
|
||||
}
|
||||
|
||||
function backendOf(client: MatrixClient, room: Room): SdkMatrixBackend {
|
||||
return {
|
||||
...client,
|
||||
...room,
|
||||
clientEmitter: client,
|
||||
roomEmitter: room,
|
||||
} as unknown as SdkMatrixBackend;
|
||||
}
|
||||
|
||||
describe("createRTCSlot", () => {
|
||||
describe("session", () => {
|
||||
it("joins the room's call slot by default", () => {
|
||||
const { client, room } = setup();
|
||||
const slot = createRTCSlot(testScope(), backendOf(client, room), options);
|
||||
expect(slot).toMatchObject({ application: "m.call", id: "ROOM" });
|
||||
});
|
||||
|
||||
it("joins the slot the options name", () => {
|
||||
const { client, room } = setup();
|
||||
const slot = createRTCSlot(testScope(), backendOf(client, room), {
|
||||
...options,
|
||||
slotDescription: { application: "io.element.example", id: "" },
|
||||
});
|
||||
expect(slot).toMatchObject({ application: "io.element.example", id: "" });
|
||||
});
|
||||
|
||||
it("stops its own session when the scope ends", async () => {
|
||||
const { client, room } = setup();
|
||||
const off = vi.spyOn(room, "off");
|
||||
const scope = new ObservableScope();
|
||||
createRTCSlot(scope, backendOf(client, room), options);
|
||||
|
||||
scope.end();
|
||||
await vi.waitFor(() =>
|
||||
expect(off).toHaveBeenCalledWith(
|
||||
RoomStickyEventsEvent.Update,
|
||||
expect.any(Function),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it("leaves a session it is given to its caller", () => {
|
||||
const { client, room, session } = setup();
|
||||
const given = session.asMockedSession();
|
||||
given.stop = vi.fn();
|
||||
const scope = new ObservableScope();
|
||||
createRTCSlot(scope, backendOf(client, room), options, given);
|
||||
|
||||
scope.end();
|
||||
expect(given.stop).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("has the session's statistics and sent call notifications", () => {
|
||||
const { client, room, session } = setup();
|
||||
const slot = createRTCSlot(
|
||||
testScope(),
|
||||
backendOf(client, room),
|
||||
options,
|
||||
session.asMockedSession(),
|
||||
);
|
||||
expect(slot.statistics).toBe(session.statistics);
|
||||
|
||||
const sent: unknown[] = [];
|
||||
slot.sentCallNotification$.subscribe((n) => sent.push(n));
|
||||
const notification = { event_id: "$notification" };
|
||||
session.emit(
|
||||
MatrixRTCSessionEvent.DidSendCallNotification,
|
||||
notification as Parameters<
|
||||
MatrixRTCSessionEventHandlerMap[MatrixRTCSessionEvent.DidSendCallNotification]
|
||||
>[0],
|
||||
);
|
||||
expect(sent).toEqual([notification]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("status$", () => {
|
||||
it("is undefined while the room has no slot event", () => {
|
||||
const { client, room } = setup();
|
||||
const slot = createRTCSlot(testScope(), client, room, options);
|
||||
const { client, room, session } = setup();
|
||||
const slot = createRTCSlot(
|
||||
testScope(),
|
||||
backendOf(client, room),
|
||||
options,
|
||||
session.asMockedSession(),
|
||||
);
|
||||
expect(slot.status$.value).toBeUndefined();
|
||||
});
|
||||
|
||||
it("follows the slot event", () => {
|
||||
const { client, room, session } = setup();
|
||||
session.rtcSlot = { status: "open" };
|
||||
const slot = createRTCSlot(testScope(), client, room, options);
|
||||
const slot = createRTCSlot(
|
||||
testScope(),
|
||||
backendOf(client, room),
|
||||
options,
|
||||
session.asMockedSession(),
|
||||
);
|
||||
expect(slot.status$.value).toBe("open");
|
||||
|
||||
session.rtcSlot = { status: "closed" };
|
||||
@@ -68,4 +168,28 @@ describe("createRTCSlot", () => {
|
||||
expect(slot.status$.value).toBe("closed");
|
||||
});
|
||||
});
|
||||
|
||||
describe("members$", () => {
|
||||
it("keeps the member when its membership is sent again, with the new event id", () => {
|
||||
const { client, room, session } = setup();
|
||||
const first = mockRtcMembership("@bob:example.org", "BOB");
|
||||
session.memberships = [first];
|
||||
const slot = createRTCSlot(
|
||||
testScope(),
|
||||
backendOf(client, room),
|
||||
options,
|
||||
session.asMockedSession(),
|
||||
);
|
||||
const [bob] = slot.members$.value;
|
||||
expect(bob.matrixEventId$.value).toBe(first.eventId);
|
||||
|
||||
const resent = mockRtcMembership("@bob:example.org", "BOB");
|
||||
session.memberships = [resent];
|
||||
session.emit(MatrixRTCSessionEvent.MembershipsChanged, [first], [resent]);
|
||||
expect(slot.members$.value).toHaveLength(1);
|
||||
expect(slot.members$.value[0]).toBe(bob);
|
||||
expect(bob.matrixEventId$.value).toBe(resent.eventId);
|
||||
expect(resent.eventId).not.toBe(first.eventId);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
+124
-74
@@ -5,12 +5,14 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { type MatrixClient, type Room } from "matrix-js-sdk";
|
||||
import { type MatrixClient } from "matrix-js-sdk";
|
||||
import { EventType } from "matrix-js-sdk/lib/@types/event";
|
||||
import { type Logger, logger as rootLogger } from "matrix-js-sdk/lib/logger";
|
||||
import { logger as rootLogger } from "matrix-js-sdk/lib/logger";
|
||||
import {
|
||||
type MatrixRTCSession as JsSdkRTCSession,
|
||||
MatrixRTCSessionManager,
|
||||
type Statistics,
|
||||
MatrixRTCSession as JsMatrixRTCSession,
|
||||
MatrixRTCSessionEvent,
|
||||
type IRTCNotificationContent,
|
||||
type SlotDescription,
|
||||
} from "matrix-js-sdk/lib/matrixrtc";
|
||||
import { type MatrixEvent } from "matrix-js-sdk/lib/models/event";
|
||||
@@ -20,6 +22,7 @@ import {
|
||||
filter,
|
||||
fromEvent,
|
||||
map,
|
||||
type Observable,
|
||||
of,
|
||||
startWith,
|
||||
switchMap,
|
||||
@@ -28,6 +31,7 @@ import {
|
||||
import { ObservableScope } from "./reactive/ObservableScope";
|
||||
import { generateItems } from "./reactive/observable";
|
||||
import {
|
||||
type ParticipationSlot,
|
||||
type RTCMember,
|
||||
type RTCParticipation,
|
||||
type RTCParticipationOptions,
|
||||
@@ -50,33 +54,64 @@ import {
|
||||
membershipKeys,
|
||||
} from "./matrixrtc/Members";
|
||||
import { createTransportRegistry } from "./matrixrtc/Transports";
|
||||
import {
|
||||
type createSdkMatrixBackend,
|
||||
type SdkMatrixBackend,
|
||||
withEmitter,
|
||||
} from "./SdkMatrixBackend";
|
||||
|
||||
const ROOM_CALL_SLOT: SlotDescription = { application: "m.call", id: "ROOM" };
|
||||
|
||||
/**
|
||||
* Takes the whole `MatrixClient` rather than a slice of it, and finds the
|
||||
* MatrixRTC session itself. The js-sdk is the MatrixRTC implementation today;
|
||||
* when the rust-rtc crate replaces it, the SDK has to bridge the crate to the
|
||||
* js-sdk client, and only the SDK knows what that bridge needs. Holding the
|
||||
* client keeps that change inside the SDK.
|
||||
* The slot runs on a matrix-js-sdk session of its own, from the SDK's copy of
|
||||
* matrix-js-sdk rather than the client's, and stops it when the scope ends.
|
||||
*/
|
||||
export function createRTCSlot(
|
||||
scope: ObservableScope,
|
||||
client: MatrixClient,
|
||||
room: Room,
|
||||
backend: SdkMatrixBackend,
|
||||
options: RTCSlotOptions,
|
||||
): RTCSlot {
|
||||
/**
|
||||
* @deprecated A session the caller owns and stops, in place of the slot's
|
||||
* own; `options.slotDescription` is then the session's. Only for the
|
||||
* standalone app, which still takes its session from its client's session
|
||||
* manager.
|
||||
*/
|
||||
externalJsSdkSession?: JsMatrixRTCSession,
|
||||
): RTCSlot & {
|
||||
// STOP GAP: This should be its own external machine. It is call
|
||||
// specific and should not live inside the sdk/rtc-slot.
|
||||
// We only put it here today, to make sure the rtcSession is fully
|
||||
// hidden inside the sdk.
|
||||
// Next step. disable sending call notificaitons in the sdk, write a new
|
||||
// notification sender in EC directly on client + room.
|
||||
sentCallNotification$: Observable<
|
||||
{
|
||||
event_id: string;
|
||||
} & IRTCNotificationContent
|
||||
>;
|
||||
// STOP GAP: the same as above. Has to live here. but should become a native
|
||||
// SDK propery independent of the rtcSession
|
||||
statistics: Statistics;
|
||||
} {
|
||||
// STOP GAP: the slot is still written against a client and a room. Both
|
||||
// are refactored along with the backend.
|
||||
const client = withEmitter(backend, backend.clientEmitter);
|
||||
const room = withEmitter(backend, backend.roomEmitter);
|
||||
const logger = rootLogger.getChild("[RTCSlot]");
|
||||
const userId = client.getUserId();
|
||||
const deviceId = client.getDeviceId();
|
||||
const roomId = room.roomId;
|
||||
if (!(userId && deviceId))
|
||||
throw new MatrixRTCError("The client has to be logged in");
|
||||
const { application = "m.call", id = "ROOM" } = options;
|
||||
|
||||
const jsSdkSession = sessionManager(
|
||||
scope,
|
||||
client,
|
||||
{ application, id },
|
||||
logger,
|
||||
).getRoomSession(room);
|
||||
const jsSdkSession =
|
||||
externalJsSdkSession ??
|
||||
createJsSdkSession(
|
||||
scope,
|
||||
client,
|
||||
room,
|
||||
options.slotDescription ?? ROOM_CALL_SLOT,
|
||||
);
|
||||
const memberships$ = createMemberships$(scope, jsSdkSession);
|
||||
|
||||
const active$ = new BehaviorSubject<ParticipationInternals | null>(null);
|
||||
@@ -126,70 +161,85 @@ export function createRTCSlot(
|
||||
),
|
||||
);
|
||||
|
||||
const slot: RTCSlot = {
|
||||
roomId: room.roomId,
|
||||
application,
|
||||
id,
|
||||
const participationSlot: ParticipationSlot = {
|
||||
roomId,
|
||||
status$,
|
||||
members$,
|
||||
...jsSdkSession.slotDescription,
|
||||
};
|
||||
|
||||
const join = (
|
||||
participationOptions: RTCParticipationOptions,
|
||||
): RTCParticipation => {
|
||||
if (active$.value !== null)
|
||||
throw new MatrixRTCError(
|
||||
"Already in this slot: leave the participation before joining again",
|
||||
);
|
||||
const participationScope = new ObservableScope();
|
||||
participationScopes.add(participationScope);
|
||||
const internals = createRTCParticipation(
|
||||
participationScope,
|
||||
{
|
||||
client,
|
||||
slot: participationSlot,
|
||||
jsSdkSession,
|
||||
transports,
|
||||
slotOptions: options,
|
||||
logger,
|
||||
},
|
||||
participationOptions,
|
||||
);
|
||||
participationScope.onEnd(() => {
|
||||
participationScopes.delete(participationScope);
|
||||
if (active$.value === internals) active$.next(null);
|
||||
});
|
||||
active$.next(internals);
|
||||
return internals.participation;
|
||||
};
|
||||
|
||||
const slot = {
|
||||
join,
|
||||
participation$: scope.behavior(
|
||||
active$.pipe(map((active) => active?.participation ?? null)),
|
||||
),
|
||||
join: (participationOptions: RTCParticipationOptions): RTCParticipation => {
|
||||
if (active$.value !== null)
|
||||
throw new MatrixRTCError(
|
||||
"Already in this slot: leave the participation before joining again",
|
||||
);
|
||||
const participationScope = new ObservableScope();
|
||||
participationScopes.add(participationScope);
|
||||
const internals = createRTCParticipation(
|
||||
participationScope,
|
||||
{
|
||||
client,
|
||||
room,
|
||||
slot,
|
||||
jsSdkSession,
|
||||
members$,
|
||||
transports,
|
||||
slotOptions: options,
|
||||
logger,
|
||||
},
|
||||
participationOptions,
|
||||
);
|
||||
participationScope.onEnd(() => {
|
||||
participationScopes.delete(participationScope);
|
||||
if (active$.value === internals) active$.next(null);
|
||||
});
|
||||
active$.next(internals);
|
||||
return internals.participation;
|
||||
},
|
||||
...participationSlot,
|
||||
};
|
||||
return slot;
|
||||
|
||||
return {
|
||||
...slot,
|
||||
sentCallNotification$: fromEvent(
|
||||
jsSdkSession,
|
||||
MatrixRTCSessionEvent.DidSendCallNotification,
|
||||
(notification: { event_id: string } & IRTCNotificationContent) =>
|
||||
notification,
|
||||
),
|
||||
statistics: jsSdkSession.statistics,
|
||||
};
|
||||
}
|
||||
|
||||
function createJsSdkSession(
|
||||
scope: ObservableScope,
|
||||
client: Pick<
|
||||
MatrixClient,
|
||||
keyof Parameters<typeof createSdkMatrixBackend>[0]
|
||||
>,
|
||||
room: ConstructorParameters<typeof JsMatrixRTCSession>[1],
|
||||
slotDescription: SlotDescription,
|
||||
): JsMatrixRTCSession {
|
||||
const session = new JsMatrixRTCSession(
|
||||
// The session's type also asks for `cancelPendingEvent`,
|
||||
// `_unstable_updateDelayedEvent` and `decryptEventIfNeeded`, which it
|
||||
// never calls
|
||||
client as ConstructorParameters<typeof JsMatrixRTCSession>[0],
|
||||
room,
|
||||
slotDescription,
|
||||
);
|
||||
scope.onEnd(() => void session.stop());
|
||||
return session;
|
||||
}
|
||||
|
||||
function slotStatus(
|
||||
session: Pick<JsSdkRTCSession, "getRtcSlot">,
|
||||
session: Pick<JsMatrixRTCSession, "getRtcSlot">,
|
||||
): "open" | "closed" | undefined {
|
||||
return session.getRtcSlot()?.status;
|
||||
}
|
||||
|
||||
/**
|
||||
* The js-sdk keeps one session manager per slot. The client comes with the
|
||||
* manager for the default slot; any other slot gets a manager of its own,
|
||||
* which lives as long as the scope.
|
||||
*/
|
||||
function sessionManager(
|
||||
scope: ObservableScope,
|
||||
client: MatrixClient,
|
||||
{ application, id }: SlotDescription,
|
||||
logger: Logger,
|
||||
): MatrixRTCSessionManager {
|
||||
if (application === "m.call" && id === "ROOM") return client.matrixRTC;
|
||||
const manager = new MatrixRTCSessionManager(logger, client, {
|
||||
application,
|
||||
id,
|
||||
});
|
||||
manager.start();
|
||||
scope.onEnd(() => manager.stop());
|
||||
return manager;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
/*
|
||||
Copyright 2026 Element Creations Ltd.
|
||||
|
||||
SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { describe, expect, it, vi } from "vitest";
|
||||
import {
|
||||
ClientEvent,
|
||||
createClient,
|
||||
type MatrixClient,
|
||||
Room,
|
||||
RoomEvent,
|
||||
SyncState,
|
||||
} from "matrix-js-sdk";
|
||||
|
||||
import { createSdkMatrixBackend, withEmitter } from "./SdkMatrixBackend";
|
||||
|
||||
describe("createSdkMatrixBackend", () => {
|
||||
it("calls each member on the client or the room it came from", () => {
|
||||
const { client, room } = setup();
|
||||
const backend = createSdkMatrixBackend(client, room);
|
||||
|
||||
expect(backend.getUserId()).toBe("@alice:example.org");
|
||||
expect(backend.roomId).toBe("!room:example.org");
|
||||
expect(backend.getVersion()).toBe(room.getVersion());
|
||||
});
|
||||
|
||||
it("keeps the client's and the room's events apart", () => {
|
||||
const { client, room } = setup();
|
||||
const backend = createSdkMatrixBackend(client, room);
|
||||
const onClient = vi.fn();
|
||||
const onRoom = vi.fn();
|
||||
backend.clientEmitter.on(ClientEvent.Sync, onClient);
|
||||
backend.roomEmitter.on(RoomEvent.Name, onRoom);
|
||||
|
||||
client.emit(ClientEvent.Sync, SyncState.Syncing, null);
|
||||
expect(onClient).toHaveBeenCalledOnce();
|
||||
expect(onRoom).not.toHaveBeenCalled();
|
||||
|
||||
room.emit(RoomEvent.Name, room);
|
||||
expect(onRoom).toHaveBeenCalledOnce();
|
||||
});
|
||||
});
|
||||
|
||||
describe("withEmitter", () => {
|
||||
it("is the backend with one side's events", () => {
|
||||
const { client, room } = setup();
|
||||
const backend = createSdkMatrixBackend(client, room);
|
||||
const asRoom = withEmitter(backend, backend.roomEmitter);
|
||||
const listener = vi.fn();
|
||||
|
||||
asRoom.on(RoomEvent.Name, listener);
|
||||
room.emit(RoomEvent.Name, room);
|
||||
|
||||
expect(listener).toHaveBeenCalledOnce();
|
||||
expect(asRoom.getUserId()).toBe("@alice:example.org");
|
||||
});
|
||||
|
||||
it("reads the backend's getters through", () => {
|
||||
const { room } = setup();
|
||||
const asRoom = withEmitter(
|
||||
{
|
||||
get name() {
|
||||
return room.name;
|
||||
},
|
||||
},
|
||||
room,
|
||||
);
|
||||
|
||||
room.name = "Renamed";
|
||||
expect(asRoom.name).toBe("Renamed");
|
||||
});
|
||||
});
|
||||
|
||||
function setup(): { client: MatrixClient; room: Room } {
|
||||
const client = createClient({
|
||||
baseUrl: "https://matrix.example.org",
|
||||
userId: "@alice:example.org",
|
||||
deviceId: "DEVICE",
|
||||
});
|
||||
const room = new Room("!room:example.org", client, "@alice:example.org");
|
||||
return { client, room };
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
/*
|
||||
Copyright 2026 Element Creations Ltd.
|
||||
|
||||
SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { type MatrixClient, type Room } from "matrix-js-sdk";
|
||||
|
||||
/** What the SDK needs of the client. */
|
||||
type SdkClientPart = Pick<
|
||||
MatrixClient,
|
||||
// Our own membership identity
|
||||
| "getUserId"
|
||||
| "getDeviceId"
|
||||
// The session: memberships, delayed leave events, sticky events, call
|
||||
// notifications, and the media keys sent to device
|
||||
| "fetchCapabilities"
|
||||
| "getCachedCapabilities"
|
||||
| "sendEvent"
|
||||
| "sendStateEvent"
|
||||
| "_unstable_sendDelayedStateEvent"
|
||||
| "_unstable_cancelScheduledDelayedEvent"
|
||||
| "_unstable_restartScheduledDelayedEvent"
|
||||
| "_unstable_sendScheduledDelayedEvent"
|
||||
| "_unstable_sendStickyEvent"
|
||||
| "_unstable_sendStickyDelayedEvent"
|
||||
| "encryptAndSendToDevice"
|
||||
// Local transport discovery
|
||||
| "getDomain"
|
||||
| "getRTCTransports"
|
||||
// LiveKit auth: `getOpenIdToken` for the JWT service flow, `getLivekitToken`
|
||||
// for the client-server API flow (MSC4195), `delegateDelayedLeave` and
|
||||
// `baseUrl` for the delayed leave delegation and its probe
|
||||
| "getOpenIdToken"
|
||||
| "getLivekitToken"
|
||||
| "delegateDelayedLeave"
|
||||
| "baseUrl"
|
||||
// Homeserver connection: whether the client is syncing
|
||||
| "getSyncState"
|
||||
>;
|
||||
|
||||
/** What the SDK needs of the room. */
|
||||
type SdkRoomPart = Pick<
|
||||
Room,
|
||||
| "roomId"
|
||||
// The members' display names and avatars
|
||||
| "getMembersWithMembership"
|
||||
// The session: memberships from the room's state, timeline and sticky events
|
||||
| "getLiveTimeline"
|
||||
| "getVersion"
|
||||
| "hasMembershipState"
|
||||
| "_unstable_getStickyEvents"
|
||||
>;
|
||||
|
||||
/**
|
||||
* STOP GAP: what the SDK needs of a Matrix client and room, on one object.
|
||||
* Only their emitters stay apart, since both have an `on` and an `off`. It is
|
||||
* to converge, along with the SDK that takes it, on whichever API fits every
|
||||
* layer best.
|
||||
*/
|
||||
export interface SdkMatrixBackend extends SdkClientPart, SdkRoomPart {
|
||||
/**
|
||||
* `ClientEvent.Sync` (homeserver connection) and `ClientEvent.ToDeviceEvent`
|
||||
* (the session's media keys)
|
||||
*/
|
||||
clientEmitter: Pick<MatrixClient, "on" | "off">;
|
||||
/** The room's state, member and sticky events */
|
||||
roomEmitter: Pick<Room, "on" | "off">;
|
||||
}
|
||||
|
||||
/** The SDK's backend from a client and a room. */
|
||||
export function createSdkMatrixBackend(
|
||||
client: SdkClientPart & Pick<MatrixClient, "on" | "off">,
|
||||
room: SdkRoomPart & Pick<Room, "on" | "off">,
|
||||
): SdkMatrixBackend {
|
||||
return {
|
||||
getUserId: client.getUserId.bind(client),
|
||||
getDeviceId: client.getDeviceId.bind(client),
|
||||
fetchCapabilities: client.fetchCapabilities.bind(client),
|
||||
getCachedCapabilities: client.getCachedCapabilities.bind(client),
|
||||
sendEvent: client.sendEvent.bind(client),
|
||||
sendStateEvent: client.sendStateEvent.bind(client),
|
||||
_unstable_sendDelayedStateEvent:
|
||||
client._unstable_sendDelayedStateEvent.bind(client),
|
||||
_unstable_cancelScheduledDelayedEvent:
|
||||
client._unstable_cancelScheduledDelayedEvent.bind(client),
|
||||
_unstable_restartScheduledDelayedEvent:
|
||||
client._unstable_restartScheduledDelayedEvent.bind(client),
|
||||
_unstable_sendScheduledDelayedEvent:
|
||||
client._unstable_sendScheduledDelayedEvent.bind(client),
|
||||
_unstable_sendStickyEvent: client._unstable_sendStickyEvent.bind(client),
|
||||
_unstable_sendStickyDelayedEvent:
|
||||
client._unstable_sendStickyDelayedEvent.bind(client),
|
||||
encryptAndSendToDevice: client.encryptAndSendToDevice.bind(client),
|
||||
getDomain: client.getDomain.bind(client),
|
||||
getRTCTransports: client.getRTCTransports.bind(client),
|
||||
getOpenIdToken: client.getOpenIdToken.bind(client),
|
||||
getLivekitToken: client.getLivekitToken.bind(client),
|
||||
delegateDelayedLeave: client.delegateDelayedLeave.bind(client),
|
||||
baseUrl: client.baseUrl,
|
||||
getSyncState: client.getSyncState.bind(client),
|
||||
roomId: room.roomId,
|
||||
getMembersWithMembership: room.getMembersWithMembership.bind(room),
|
||||
getLiveTimeline: room.getLiveTimeline.bind(room),
|
||||
getVersion: room.getVersion.bind(room),
|
||||
hasMembershipState: room.hasMembershipState.bind(room),
|
||||
_unstable_getStickyEvents: room._unstable_getStickyEvents.bind(room),
|
||||
clientEmitter: client,
|
||||
roomEmitter: room,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* STOP GAP: the backend as the client (or the room) code written against one
|
||||
* still expects, with that side's `on` and `off`.
|
||||
*/
|
||||
export function withEmitter<
|
||||
Backend extends object,
|
||||
Emitter extends {
|
||||
on: (...args: never[]) => unknown;
|
||||
off: (...args: never[]) => unknown;
|
||||
},
|
||||
>(backend: Backend, emitter: Emitter): Backend & Pick<Emitter, "on" | "off"> {
|
||||
return Object.defineProperties<object>(
|
||||
{ on: emitter.on.bind(emitter), off: emitter.off.bind(emitter) },
|
||||
Object.getOwnPropertyDescriptors(backend),
|
||||
) as Backend & Pick<Emitter, "on" | "off">;
|
||||
}
|
||||
+23
-7
@@ -14,6 +14,7 @@ Please see LICENSE in the repository root for full details.
|
||||
import {
|
||||
type RTCCallIntent,
|
||||
type RTCNotificationType,
|
||||
type SlotDescription,
|
||||
type Transport,
|
||||
} from "matrix-js-sdk/lib/matrixrtc";
|
||||
import { type Observable } from "rxjs";
|
||||
@@ -43,13 +44,9 @@ export { MatrixRTCError } from "./errors";
|
||||
// Slot
|
||||
|
||||
export interface RTCSlotOptions {
|
||||
/** The application the slot belongs to, as named in the membership. Default `m.call`. */
|
||||
application?: string;
|
||||
/** The application's slot in the room. Default `ROOM`. */
|
||||
id?: string;
|
||||
/** How memberships and keys in this slot are written. Resolved by the host. */
|
||||
matrixRTCMode: MatrixRTCMode;
|
||||
encryptionSystem: EncryptionSystem;
|
||||
/** Which slot of the room to join. Defaults to the room's call, `m.call#ROOM`. */
|
||||
slotDescription?: SlotDescription;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -81,6 +78,12 @@ export interface RTCSlot {
|
||||
join(options: RTCParticipationOptions): RTCParticipation; // Maybe MediaSession,
|
||||
}
|
||||
|
||||
/**
|
||||
* The slot as its participation sees it: members, status and identity, without
|
||||
* `join` and `participation$`, which belong to whoever joins.
|
||||
*/
|
||||
export type ParticipationSlot = Omit<RTCSlot, "join" | "participation$">;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Participation
|
||||
|
||||
@@ -95,6 +98,12 @@ export interface RTCParticipationOptions {
|
||||
* before the first connection exists.
|
||||
*/
|
||||
publish: PublishRequest[] | LocalMedia;
|
||||
/**
|
||||
* How our membership and keys are written: the member id and whether the
|
||||
* membership is a sticky event. Resolved by the host. Others' memberships
|
||||
* are read whatever their mode.
|
||||
*/
|
||||
matrixRTCMode: MatrixRTCMode;
|
||||
/**
|
||||
* LEGACY
|
||||
*
|
||||
@@ -166,7 +175,8 @@ export type ParticipationState =
|
||||
|
||||
/** The span between our `join()` of a slot and our `leave()`. */
|
||||
export interface RTCParticipation {
|
||||
readonly slot: RTCSlot;
|
||||
/** Required slot information (no `join` fn and `participation`) */
|
||||
readonly slot: ParticipationSlot;
|
||||
/** Sends the leave, tears the connections down and ends the participation. */
|
||||
leave(): void;
|
||||
state$: Behavior<ParticipationState>;
|
||||
@@ -289,6 +299,12 @@ export interface RTCMember {
|
||||
deviceId: string;
|
||||
/** The membership's own id; what the Matrix 2.0 identity is derived from. */
|
||||
memberId: string;
|
||||
/**
|
||||
* The Matrix event currently carrying the membership, which events about
|
||||
* it (reactions, raised hands) relate to. Changes when the membership is
|
||||
* sent again while the member stays the same.
|
||||
*/
|
||||
matrixEventId$: Behavior<string>;
|
||||
/** Which transport this member is on; undefined when the membership has none. */
|
||||
transport$: Behavior<TransportMetadata | undefined>;
|
||||
/** What the member's application says about itself, e.g. `intent`. */
|
||||
|
||||
@@ -8,7 +8,7 @@ Please see LICENSE in the repository root for full details.
|
||||
|
||||
import { describe, it, expect, beforeEach, afterEach } from "vitest";
|
||||
import { EventEmitter } from "events";
|
||||
import { ClientEvent, SyncState } from "matrix-js-sdk";
|
||||
import { ClientEvent, type MatrixClient, SyncState } from "matrix-js-sdk";
|
||||
import { MembershipManagerEvent, Status } from "matrix-js-sdk/lib/matrixrtc";
|
||||
|
||||
import { ObservableScope } from "../reactive/ObservableScope";
|
||||
@@ -20,7 +20,7 @@ import { testScope, withTestScheduler } from "../utils/test";
|
||||
```
|
||||
createHomeserverConnected$(
|
||||
scope: ObservableScope,
|
||||
client: NodeStyleEventEmitter & Pick<MatrixClient, "getSyncState">,
|
||||
client: Pick<MatrixClient, "getSyncState" | "on" | "off">,
|
||||
matrixRTCSession: NodeStyleEventEmitter &
|
||||
Pick<MatrixRTCSession, "membershipStatus" | "probablyLeft">,
|
||||
)
|
||||
@@ -34,12 +34,15 @@ class MockMatrixClient extends EventEmitter {
|
||||
}
|
||||
public setSyncState(state: SyncState): void {
|
||||
this.syncState = state;
|
||||
// Matrix's Sync event in createHomeserverConnected$ expects [SyncState]
|
||||
this.emit(ClientEvent.Sync, [state]);
|
||||
this.emit(ClientEvent.Sync, state);
|
||||
}
|
||||
public getSyncState(): SyncState {
|
||||
return this.syncState;
|
||||
}
|
||||
/** `MatrixClient`'s `on`/`off` return the client itself, which no mock is. */
|
||||
public get asClient(): Pick<MatrixClient, "getSyncState" | "on" | "off"> {
|
||||
return this as unknown as Pick<MatrixClient, "getSyncState" | "on" | "off">;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -47,7 +50,7 @@ class MockMatrixClient extends EventEmitter {
|
||||
```
|
||||
createHomeserverConnected$(
|
||||
scope: ObservableScope,
|
||||
client: NodeStyleEventEmitter & Pick<MatrixClient, "getSyncState">,
|
||||
client: Pick<MatrixClient, "getSyncState" | "on" | "off">,
|
||||
matrixRTCSession: NodeStyleEventEmitter &
|
||||
Pick<MatrixRTCSession, "membershipStatus" | "probablyLeft">,
|
||||
)
|
||||
@@ -99,18 +102,33 @@ describe("createHomeserverConnected$", () => {
|
||||
// easy enough to read them so I think they can stay.
|
||||
// Note: gracePeriodMs is set to 0 to avoid debouncing delays in tests
|
||||
it("reports syncing reason when sync state is not Syncing", () => {
|
||||
const hsConnected = createHomeserverConnected$(scope, client, session, 0);
|
||||
const hsConnected = createHomeserverConnected$(
|
||||
scope,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
expect(hsConnected.disconnectReason$.value).toEqual("sync");
|
||||
});
|
||||
|
||||
it("reports membership reason when sync is Syncing but membership is not Connected", () => {
|
||||
const hsConnected = createHomeserverConnected$(scope, client, session, 0);
|
||||
const hsConnected = createHomeserverConnected$(
|
||||
scope,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
client.setSyncState(SyncState.Syncing);
|
||||
expect(hsConnected.disconnectReason$.value).toEqual("membership");
|
||||
});
|
||||
|
||||
it("reports probablyLeft reason when membership transitions to Connected but ProbablyLeft is true", () => {
|
||||
const hsConnected = createHomeserverConnected$(scope, client, session, 0);
|
||||
const hsConnected = createHomeserverConnected$(
|
||||
scope,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
// Make sync loop OK
|
||||
client.setSyncState(SyncState.Syncing);
|
||||
// Indicate probable leave before connection
|
||||
@@ -120,7 +138,12 @@ describe("createHomeserverConnected$", () => {
|
||||
});
|
||||
|
||||
it("becomes null (connected) only when all three conditions are satisfied", () => {
|
||||
const hsConnected = createHomeserverConnected$(scope, client, session, 0);
|
||||
const hsConnected = createHomeserverConnected$(
|
||||
scope,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
// 1. Sync loop connected
|
||||
client.setSyncState(SyncState.Syncing);
|
||||
expect(hsConnected.disconnectReason$.value).toEqual("membership"); // not yet membership connected
|
||||
@@ -130,7 +153,12 @@ describe("createHomeserverConnected$", () => {
|
||||
});
|
||||
|
||||
it("returns syncing reason when sync loop leaves Syncing", () => {
|
||||
const hsConnected = createHomeserverConnected$(scope, client, session, 0);
|
||||
const hsConnected = createHomeserverConnected$(
|
||||
scope,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
// Reach connected state
|
||||
client.setSyncState(SyncState.Syncing);
|
||||
session.setMembershipStatus(Status.Connected);
|
||||
@@ -142,7 +170,12 @@ describe("createHomeserverConnected$", () => {
|
||||
});
|
||||
|
||||
it("returns membershipConnected reason when membership status becomes disconnected", () => {
|
||||
const hsConnected = createHomeserverConnected$(scope, client, session, 0);
|
||||
const hsConnected = createHomeserverConnected$(
|
||||
scope,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
client.setSyncState(SyncState.Syncing);
|
||||
session.setMembershipStatus(Status.Connected);
|
||||
expect(hsConnected.disconnectReason$.value).toEqual(null);
|
||||
@@ -152,7 +185,12 @@ describe("createHomeserverConnected$", () => {
|
||||
});
|
||||
|
||||
it("returns certainlyConnected reason when ProbablyLeft is emitted", () => {
|
||||
const hsConnected = createHomeserverConnected$(scope, client, session, 0);
|
||||
const hsConnected = createHomeserverConnected$(
|
||||
scope,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
client.setSyncState(SyncState.Syncing);
|
||||
session.setMembershipStatus(Status.Connected);
|
||||
expect(hsConnected.disconnectReason$.value).toEqual(null);
|
||||
@@ -162,7 +200,12 @@ describe("createHomeserverConnected$", () => {
|
||||
});
|
||||
|
||||
it("recovers to null (connected) if ProbablyLeft becomes false again while other conditions remain true", () => {
|
||||
const hsConnected = createHomeserverConnected$(scope, client, session, 0);
|
||||
const hsConnected = createHomeserverConnected$(
|
||||
scope,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
client.setSyncState(SyncState.Syncing);
|
||||
session.setMembershipStatus(Status.Connected);
|
||||
expect(hsConnected.disconnectReason$.value).toEqual(null);
|
||||
@@ -176,7 +219,12 @@ describe("createHomeserverConnected$", () => {
|
||||
});
|
||||
|
||||
it("composite sequence reflects each individual failure reason", () => {
|
||||
const hsConnected = createHomeserverConnected$(scope, client, session, 0);
|
||||
const hsConnected = createHomeserverConnected$(
|
||||
scope,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
|
||||
// Initially: sync error + membership disconnected → syncing wins (highest priority)
|
||||
expect(hsConnected.disconnectReason$.value).toEqual("sync");
|
||||
@@ -225,7 +273,7 @@ describe("createHomeserverConnected$ - disconnectReason$ reason values", () => {
|
||||
it("is null when all three conditions are satisfied", () => {
|
||||
const { disconnectReason$ } = createHomeserverConnected$(
|
||||
scope,
|
||||
client,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
@@ -237,7 +285,7 @@ describe("createHomeserverConnected$ - disconnectReason$ reason values", () => {
|
||||
it("reports syncing when sync loop is not Syncing", () => {
|
||||
const { disconnectReason$ } = createHomeserverConnected$(
|
||||
scope,
|
||||
client,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
@@ -248,7 +296,7 @@ describe("createHomeserverConnected$ - disconnectReason$ reason values", () => {
|
||||
it("reports membershipConnected when sync is fine but membership is not Connected", () => {
|
||||
const { disconnectReason$ } = createHomeserverConnected$(
|
||||
scope,
|
||||
client,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
@@ -260,7 +308,7 @@ describe("createHomeserverConnected$ - disconnectReason$ reason values", () => {
|
||||
it("reports certainlyConnected when probablyLeft is true", () => {
|
||||
const { disconnectReason$ } = createHomeserverConnected$(
|
||||
scope,
|
||||
client,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
@@ -273,7 +321,7 @@ describe("createHomeserverConnected$ - disconnectReason$ reason values", () => {
|
||||
it("prioritises syncing over membershipConnected when both fail", () => {
|
||||
const { disconnectReason$ } = createHomeserverConnected$(
|
||||
scope,
|
||||
client,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
@@ -284,7 +332,7 @@ describe("createHomeserverConnected$ - disconnectReason$ reason values", () => {
|
||||
it("updates reason as conditions change", () => {
|
||||
const { disconnectReason$ } = createHomeserverConnected$(
|
||||
scope,
|
||||
client,
|
||||
client.asClient,
|
||||
session,
|
||||
0,
|
||||
);
|
||||
@@ -329,7 +377,7 @@ describe("createHomeserverConnected$ - Grace Period", () => {
|
||||
});
|
||||
const hsConnected = createHomeserverConnected$(
|
||||
testScope(),
|
||||
client,
|
||||
client.asClient,
|
||||
session,
|
||||
GRACE_PERIOD,
|
||||
);
|
||||
|
||||
@@ -17,7 +17,6 @@ import {
|
||||
startWith,
|
||||
map,
|
||||
tap,
|
||||
type Observable,
|
||||
distinctUntilChanged,
|
||||
switchMap,
|
||||
of,
|
||||
@@ -61,7 +60,15 @@ export interface HomeserverConnected {
|
||||
*/
|
||||
export function createHomeserverConnected$(
|
||||
scope: ObservableScope,
|
||||
client: NodeStyleEventEmitter & Pick<MatrixClient, "getSyncState">,
|
||||
client: Pick<
|
||||
MatrixClient,
|
||||
// Whether the client is syncing
|
||||
| "getSyncState"
|
||||
// `on`/`off`, to listen for:
|
||||
// - `ClientEvent.Sync`
|
||||
| "on"
|
||||
| "off"
|
||||
>,
|
||||
matrixRTCSession: NodeStyleEventEmitter &
|
||||
Pick<MatrixRTCSession, "membershipStatus" | "probablyLeft">,
|
||||
gracePeriodMs?: number,
|
||||
@@ -71,11 +78,13 @@ export function createHomeserverConnected$(
|
||||
const graceMs =
|
||||
gracePeriodMs ?? defaultSessionTimings.syncDisconnectGracePeriodMs;
|
||||
|
||||
const syncing$ = (
|
||||
fromEvent(client, ClientEvent.Sync) as Observable<[SyncState]>
|
||||
const syncing$ = fromEvent(
|
||||
client,
|
||||
ClientEvent.Sync,
|
||||
(state: SyncState) => state,
|
||||
).pipe(
|
||||
startWith([client.getSyncState()]),
|
||||
map(([state]) => state === SyncState.Syncing),
|
||||
startWith(client.getSyncState()),
|
||||
map((state) => state === SyncState.Syncing),
|
||||
distinctUntilChanged(),
|
||||
switchMap((isSyncing) => {
|
||||
if (isSyncing || graceMs <= 0) {
|
||||
|
||||
@@ -23,7 +23,9 @@ export type RoomMemberMap = Map<
|
||||
string,
|
||||
Pick<RoomMember, "userId" | "getMxcAvatarUrl" | "rawDisplayName">
|
||||
>;
|
||||
export function roomToMembersMap(matrixRoom: MatrixRoom): RoomMemberMap {
|
||||
export function roomToMembersMap(
|
||||
matrixRoom: Pick<MatrixRoom, "getMembersWithMembership">,
|
||||
): RoomMemberMap {
|
||||
const members = matrixRoom
|
||||
.getMembersWithMembership(KnownMembership.Join)
|
||||
.concat(matrixRoom.getMembersWithMembership(KnownMembership.Invite));
|
||||
@@ -37,9 +39,10 @@ export function roomToMembersMap(matrixRoom: MatrixRoom): RoomMemberMap {
|
||||
}, new Map());
|
||||
}
|
||||
|
||||
/** Listens for `RoomStateEvent.Members` on the room. */
|
||||
export function createRoomMembers$(
|
||||
scope: ObservableScope,
|
||||
matrixRoom: MatrixRoom,
|
||||
matrixRoom: Pick<MatrixRoom, "getMembersWithMembership" | "on" | "off">,
|
||||
): Behavior<RoomMemberMap> {
|
||||
return scope.behavior(
|
||||
fromEvent(matrixRoom, RoomStateEvent.Members).pipe(
|
||||
|
||||
@@ -57,6 +57,12 @@ export function createRTCMember(
|
||||
userId,
|
||||
deviceId,
|
||||
memberId,
|
||||
matrixEventId$: scope.behavior(
|
||||
membership$.pipe(
|
||||
map((membership) => membership.eventId),
|
||||
distinctUntilChanged(),
|
||||
),
|
||||
),
|
||||
displayName$: scope.behavior(
|
||||
metadata
|
||||
.createDisplayNameBehavior$(scope, userId)
|
||||
|
||||
@@ -344,6 +344,7 @@ describe("createLivekitBackend", () => {
|
||||
userId: "@bob:example.org",
|
||||
deviceId: "DEV000",
|
||||
memberId: legacyId,
|
||||
matrixEventId$: constant("$bob"),
|
||||
transport$: constant({
|
||||
type: "livekit",
|
||||
id: JSON.stringify(transport),
|
||||
|
||||
@@ -276,6 +276,7 @@ export class MockRTCSession extends TypedEventEmitter<
|
||||
return this.joined;
|
||||
}
|
||||
|
||||
public slotDescription = { application: "m.call", id: "ROOM" };
|
||||
public slotId = "m.call#ROOM";
|
||||
/** The id of the delayed leave event; undefined until the manager has sent one. */
|
||||
public delayId: string | undefined = undefined;
|
||||
|
||||
@@ -0,0 +1,42 @@
|
||||
/*
|
||||
Copyright 2026 Element Creations Ltd.
|
||||
|
||||
SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { expect, test } from "vitest";
|
||||
import { createClient, Room } from "matrix-js-sdk";
|
||||
import { withEmitter } from "@element-hq/matrixrtc-sdk";
|
||||
|
||||
import { createCallMatrixBackend } from "./CallMatrixBackend";
|
||||
|
||||
test("has the SDK's part and the call's own", () => {
|
||||
const { backend, room } = setup();
|
||||
|
||||
expect(backend.getUserId()).toBe("@alice:example.org");
|
||||
expect(backend.getJoinRule()).toBe(room.getJoinRule());
|
||||
expect(backend.relations).toBe(room.relations);
|
||||
});
|
||||
|
||||
test("reads the room's name as it is now, also as a room", () => {
|
||||
const { backend, room } = setup();
|
||||
const asRoom = withEmitter(backend, backend.roomEmitter);
|
||||
|
||||
room.name = "Renamed";
|
||||
expect(backend.name).toBe("Renamed");
|
||||
expect(asRoom.name).toBe("Renamed");
|
||||
});
|
||||
|
||||
function setup(): {
|
||||
backend: ReturnType<typeof createCallMatrixBackend>;
|
||||
room: Room;
|
||||
} {
|
||||
const client = createClient({
|
||||
baseUrl: "https://matrix.example.org",
|
||||
userId: "@alice:example.org",
|
||||
deviceId: "DEVICE",
|
||||
});
|
||||
const room = new Room("!room:example.org", client, "@alice:example.org");
|
||||
return { backend: createCallMatrixBackend(client, room), room };
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
/*
|
||||
Copyright 2026 Element Creations Ltd.
|
||||
|
||||
SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { type MatrixClient, type Room } from "matrix-js-sdk";
|
||||
import {
|
||||
createSdkMatrixBackend,
|
||||
type SdkMatrixBackend,
|
||||
} from "@element-hq/matrixrtc-sdk";
|
||||
|
||||
/** What a call needs of the client beyond the SDK's part. */
|
||||
type CallClientPart = Pick<
|
||||
MatrixClient,
|
||||
// Reactions and raised hands: decrypting, and lowering a hand
|
||||
| "decryptEventIfNeeded"
|
||||
| "redactEvent"
|
||||
// Our own display name and avatar
|
||||
| "getUser"
|
||||
// Changing them, where the host lets us (`supportsProfileChanges`)
|
||||
| "setDisplayName"
|
||||
| "setAvatarUrl"
|
||||
| "uploadContent"
|
||||
// Developer settings
|
||||
| "doesServerSupportUnstableFeature"
|
||||
| "getCrypto"
|
||||
>;
|
||||
|
||||
/** What a call needs of the room beyond the SDK's part. */
|
||||
type CallRoomPart = Pick<
|
||||
Room,
|
||||
// The header and the invite link
|
||||
| "name"
|
||||
| "getMxcAvatarUrl"
|
||||
// Whether to offer the invite link
|
||||
| "getJoinRule"
|
||||
// Raised hands already in the room
|
||||
| "relations"
|
||||
>;
|
||||
|
||||
/**
|
||||
* STOP GAP: everything a call needs from Matrix on one object. Its
|
||||
* `clientEmitter` also carries `MatrixEventEvent.Decrypted` (reactions); its
|
||||
* `roomEmitter` every room event.
|
||||
*/
|
||||
export interface CallMatrixBackend
|
||||
extends SdkMatrixBackend, CallClientPart, CallRoomPart {}
|
||||
|
||||
/** A call's backend from a client and a room. */
|
||||
export function createCallMatrixBackend(
|
||||
client: Parameters<typeof createSdkMatrixBackend>[0] & CallClientPart,
|
||||
room: Parameters<typeof createSdkMatrixBackend>[1] & CallRoomPart,
|
||||
): CallMatrixBackend {
|
||||
return {
|
||||
...createSdkMatrixBackend(client, room),
|
||||
decryptEventIfNeeded: client.decryptEventIfNeeded.bind(client),
|
||||
redactEvent: client.redactEvent.bind(client),
|
||||
getUser: client.getUser.bind(client),
|
||||
setDisplayName: client.setDisplayName.bind(client),
|
||||
setAvatarUrl: client.setAvatarUrl.bind(client),
|
||||
uploadContent: client.uploadContent.bind(client),
|
||||
doesServerSupportUnstableFeature:
|
||||
client.doesServerSupportUnstableFeature.bind(client),
|
||||
getCrypto: client.getCrypto.bind(client),
|
||||
// Read through: the room is renamed while we show it
|
||||
get name() {
|
||||
return room.name;
|
||||
},
|
||||
getMxcAvatarUrl: room.getMxcAvatarUrl.bind(room),
|
||||
getJoinRule: room.getJoinRule.bind(room),
|
||||
get relations() {
|
||||
return room.relations;
|
||||
},
|
||||
};
|
||||
}
|
||||
+40
-2
@@ -142,7 +142,7 @@ interface Props {
|
||||
* itself — from the widget API, or by restoring or creating a session of its
|
||||
* own.
|
||||
*/
|
||||
client?: MatrixClient;
|
||||
client?: SuppliedClient;
|
||||
/**
|
||||
* How Element Call finds a client when none is supplied: the standalone app
|
||||
* restores or creates a session of its own. Stable, as a hook dependency.
|
||||
@@ -161,6 +161,37 @@ interface Props {
|
||||
loadClient?: ClientLoader;
|
||||
}
|
||||
|
||||
/**
|
||||
* What is read of a supplied client under a call, and by this provider and
|
||||
* analytics. Stable methods only, so a host's client, from the host's own copy
|
||||
* of matrix-js-sdk, will do.
|
||||
*/
|
||||
export type SuppliedClient = Pick<
|
||||
MatrixClient,
|
||||
// The disconnected banner, and stopping a client opened elsewhere
|
||||
| "on"
|
||||
| "removeListener"
|
||||
| "stopClient"
|
||||
// Analytics, through `window.matrixclient`
|
||||
| "getCrypto"
|
||||
| "isGuest"
|
||||
| "getAccountDataFromServer"
|
||||
| "setAccountData"
|
||||
// The room's encryption system
|
||||
| "getRoom"
|
||||
// Avatars
|
||||
| "mxcUrlToHttp"
|
||||
| "getAccessToken"
|
||||
// Rageshakes: who sends them, their crypto state, and asking others for theirs
|
||||
| "getUserId"
|
||||
| "getUser"
|
||||
| "credentials"
|
||||
| "deviceId"
|
||||
| "secretStorage"
|
||||
| "isKeyBackupKeyStored"
|
||||
| "sendEvent"
|
||||
>;
|
||||
|
||||
/**
|
||||
* Restores or creates a session of Element Call's own, kept where the given
|
||||
* functions keep it. Resolves to null when no one is signed in.
|
||||
@@ -170,7 +201,14 @@ export type ClientLoader = (
|
||||
clearSession: () => void,
|
||||
) => Promise<InitResult | null>;
|
||||
|
||||
export const ClientProvider: FC<Props> = ({ children, client, loadClient }) => {
|
||||
export const ClientProvider: FC<Props> = ({
|
||||
children,
|
||||
client: suppliedClient,
|
||||
loadClient,
|
||||
}) => {
|
||||
// STOP GAP: held as a whole client, as the standalone and widget pages need
|
||||
// one. A component host's client is only read through `SuppliedClient`.
|
||||
const client = suppliedClient as MatrixClient | undefined;
|
||||
const leaveToHome = useLeaveToHome();
|
||||
const hostBridge = useHostBridge();
|
||||
|
||||
|
||||
@@ -15,7 +15,7 @@ import {
|
||||
afterAll,
|
||||
} from "vitest";
|
||||
import { logger } from "matrix-js-sdk/lib/logger";
|
||||
import { type MatrixRTCSession } from "matrix-js-sdk/lib/matrixrtc";
|
||||
import { type Statistics } from "matrix-js-sdk/lib/matrixrtc";
|
||||
|
||||
import { PosthogAnalytics } from "./PosthogAnalytics";
|
||||
import {
|
||||
@@ -34,16 +34,14 @@ const defaultTotals = {
|
||||
roomEventEncryptionKeysReceivedTotalAge: 500,
|
||||
};
|
||||
|
||||
function createMockRtcSession(overrides?: {
|
||||
function createMockStatistics(overrides?: {
|
||||
counters?: Partial<typeof defaultCounters>;
|
||||
totals?: Partial<typeof defaultTotals>;
|
||||
}): MatrixRTCSession {
|
||||
}): Statistics {
|
||||
return {
|
||||
statistics: {
|
||||
counters: { ...defaultCounters, ...overrides?.counters },
|
||||
totals: { ...defaultTotals, ...overrides?.totals },
|
||||
},
|
||||
} as unknown as MatrixRTCSession;
|
||||
counters: { ...defaultCounters, ...overrides?.counters },
|
||||
totals: { ...defaultTotals, ...overrides?.totals },
|
||||
} as Statistics;
|
||||
}
|
||||
|
||||
describe("CallEnded", () => {
|
||||
@@ -65,9 +63,9 @@ describe("CallEnded", () => {
|
||||
it("warns if startTime is missing when track is called", () => {
|
||||
const warnSpy = vi.spyOn(logger, "warn");
|
||||
const tracker = new CallEndedTracker();
|
||||
const mockSession = createMockRtcSession();
|
||||
const statistics = createMockStatistics();
|
||||
|
||||
tracker.track("test-call-id", 2, false, mockSession);
|
||||
tracker.track("test-call-id", 2, false, statistics);
|
||||
|
||||
expect(warnSpy).toHaveBeenCalledWith(
|
||||
"[PosthogEvents] Failed to send posthog callEnded event due to missing startTime",
|
||||
@@ -77,11 +75,11 @@ describe("CallEnded", () => {
|
||||
|
||||
it("tracks event with correct properties when startTime is set", () => {
|
||||
const tracker = new CallEndedTracker();
|
||||
const mockSession = createMockRtcSession();
|
||||
const statistics = createMockStatistics();
|
||||
|
||||
tracker.cacheStartCall(new Date(Date.now() - 60000));
|
||||
tracker.cacheParticipantCountChanged(5);
|
||||
tracker.track("test-call-id", 3, true, mockSession);
|
||||
tracker.track("test-call-id", 3, true, statistics);
|
||||
|
||||
expect(PosthogAnalytics.instance.trackEvent).toHaveBeenCalledWith(
|
||||
{
|
||||
@@ -105,13 +103,13 @@ describe("CallEnded", () => {
|
||||
|
||||
it("tracks maxParticipantsCount correctly across multiple changes", () => {
|
||||
const tracker = new CallEndedTracker();
|
||||
const mockSession = createMockRtcSession();
|
||||
const statistics = createMockStatistics();
|
||||
|
||||
tracker.cacheStartCall(new Date());
|
||||
tracker.cacheParticipantCountChanged(3);
|
||||
tracker.cacheParticipantCountChanged(7);
|
||||
tracker.cacheParticipantCountChanged(2);
|
||||
tracker.track("test-call-id", 1, false, mockSession);
|
||||
tracker.track("test-call-id", 1, false, statistics);
|
||||
|
||||
expect(PosthogAnalytics.instance.trackEvent).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
@@ -123,12 +121,12 @@ describe("CallEnded", () => {
|
||||
|
||||
it("computes roomEventEncryptionKeysReceivedAverageAge as 0 when no keys received", () => {
|
||||
const tracker = new CallEndedTracker();
|
||||
const mockSession = createMockRtcSession({
|
||||
const statistics = createMockStatistics({
|
||||
counters: { roomEventEncryptionKeysReceived: 0 },
|
||||
});
|
||||
|
||||
tracker.cacheStartCall(new Date());
|
||||
tracker.track("test-call-id", 1, false, mockSession);
|
||||
tracker.track("test-call-id", 1, false, statistics);
|
||||
|
||||
expect(PosthogAnalytics.instance.trackEvent).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
@@ -140,13 +138,13 @@ describe("CallEnded", () => {
|
||||
|
||||
it("computes roomEventEncryptionKeysReceivedAverageAge correctly when keys are received", () => {
|
||||
const tracker = new CallEndedTracker();
|
||||
const mockSession = createMockRtcSession({
|
||||
const statistics = createMockStatistics({
|
||||
counters: { roomEventEncryptionKeysReceived: 4 },
|
||||
totals: { roomEventEncryptionKeysReceivedTotalAge: 200 },
|
||||
});
|
||||
|
||||
tracker.cacheStartCall(new Date());
|
||||
tracker.track("test-call-id", 1, false, mockSession);
|
||||
tracker.track("test-call-id", 1, false, statistics);
|
||||
|
||||
expect(PosthogAnalytics.instance.trackEvent).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
@@ -158,10 +156,10 @@ describe("CallEnded", () => {
|
||||
|
||||
it("passes send_instantly option correctly", () => {
|
||||
const tracker = new CallEndedTracker();
|
||||
const mockSession = createMockRtcSession();
|
||||
const statistics = createMockStatistics();
|
||||
|
||||
tracker.cacheStartCall(new Date());
|
||||
tracker.track("test-call-id", 1, false, mockSession);
|
||||
tracker.track("test-call-id", 1, false, statistics);
|
||||
|
||||
expect(PosthogAnalytics.instance.trackEvent).toHaveBeenCalledWith(
|
||||
expect.anything(),
|
||||
@@ -171,14 +169,14 @@ describe("CallEnded", () => {
|
||||
|
||||
it("includes per-reason reconnecting counts in CallEnded", () => {
|
||||
const tracker = new CallEndedTracker();
|
||||
const mockSession = createMockRtcSession();
|
||||
const statistics = createMockStatistics();
|
||||
|
||||
tracker.cacheStartCall(new Date());
|
||||
tracker.cacheReconnecting("sync");
|
||||
tracker.cacheReconnecting("sync");
|
||||
tracker.cacheReconnecting("livekit");
|
||||
tracker.cacheReconnecting("membership");
|
||||
tracker.track("test-call-id", 1, false, mockSession);
|
||||
tracker.track("test-call-id", 1, false, statistics);
|
||||
|
||||
expect(PosthogAnalytics.instance.trackEvent).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
|
||||
@@ -7,7 +7,7 @@ Please see LICENSE in the repository root for full details.
|
||||
|
||||
import { type DisconnectReason } from "livekit-client";
|
||||
import { logger } from "matrix-js-sdk/lib/logger";
|
||||
import { type MatrixRTCSession } from "matrix-js-sdk/lib/matrixrtc";
|
||||
import { type Statistics } from "matrix-js-sdk/lib/matrixrtc";
|
||||
|
||||
import {
|
||||
type IPosthogEvent,
|
||||
@@ -80,7 +80,7 @@ export class CallEndedTracker {
|
||||
callId: string,
|
||||
callParticipantsNow: number,
|
||||
sendInstantly: boolean,
|
||||
rtcSession: MatrixRTCSession,
|
||||
statistics: Statistics,
|
||||
): void {
|
||||
if (this.cache.startTime) {
|
||||
PosthogAnalytics.instance.trackEvent<CallEnded>(
|
||||
@@ -91,14 +91,13 @@ export class CallEndedTracker {
|
||||
callParticipantsOnLeave: callParticipantsNow,
|
||||
callDuration: (Date.now() - this.cache.startTime.getTime()) / 1000,
|
||||
roomEventEncryptionKeysSent:
|
||||
rtcSession.statistics.counters.roomEventEncryptionKeysSent,
|
||||
statistics.counters.roomEventEncryptionKeysSent,
|
||||
roomEventEncryptionKeysReceived:
|
||||
rtcSession.statistics.counters.roomEventEncryptionKeysReceived,
|
||||
statistics.counters.roomEventEncryptionKeysReceived,
|
||||
roomEventEncryptionKeysReceivedAverageAge:
|
||||
rtcSession.statistics.counters.roomEventEncryptionKeysReceived > 0
|
||||
? rtcSession.statistics.totals
|
||||
.roomEventEncryptionKeysReceivedTotalAge /
|
||||
rtcSession.statistics.counters.roomEventEncryptionKeysReceived
|
||||
statistics.counters.roomEventEncryptionKeysReceived > 0
|
||||
? statistics.totals.roomEventEncryptionKeysReceivedTotalAge /
|
||||
statistics.counters.roomEventEncryptionKeysReceived
|
||||
: 0,
|
||||
callReconnectingCount: this.cache.reconnectingCount,
|
||||
callReconnectingCountSync: this.cache.reconnectingCountByReason.sync,
|
||||
|
||||
@@ -10,13 +10,13 @@ import { expect, test } from "vitest";
|
||||
import { TooltipProvider } from "@vector-im/compound-web";
|
||||
import { userEvent } from "@testing-library/user-event";
|
||||
import { type ReactNode } from "react";
|
||||
import { type MatrixClient, type Room } from "matrix-js-sdk";
|
||||
|
||||
import { ReactionToggleButton } from "./ReactionToggleButton";
|
||||
import { ElementCallReactionEventType } from "../reactions";
|
||||
import { type CallViewModel } from "../state/CallViewModel/CallViewModel";
|
||||
import { getBasicCallViewModelEnvironment } from "../utils/test-viewmodel";
|
||||
import { alice, local, localRtcMember } from "../utils/test-fixtures";
|
||||
import { type MockRTCSession } from "../utils/test";
|
||||
import { ReactionsSenderProvider } from "../reactions/useReactionsSender";
|
||||
import { initializeWidget } from "../widget";
|
||||
initializeWidget();
|
||||
@@ -24,18 +24,17 @@ initializeWidget();
|
||||
const localIdent = `${localRtcMember.userId}:${localRtcMember.deviceId}`;
|
||||
|
||||
function TestComponent({
|
||||
rtcSession,
|
||||
matrixRoom,
|
||||
client,
|
||||
vm,
|
||||
}: {
|
||||
rtcSession: MockRTCSession;
|
||||
matrixRoom: Room;
|
||||
client: MatrixClient;
|
||||
vm: CallViewModel;
|
||||
}): ReactNode {
|
||||
return (
|
||||
<TooltipProvider>
|
||||
<ReactionsSenderProvider
|
||||
vm={vm}
|
||||
rtcSession={rtcSession.asMockedSession()}
|
||||
>
|
||||
<ReactionsSenderProvider vm={vm} room={matrixRoom} client={client}>
|
||||
<ReactionToggleButton
|
||||
reactionData={{
|
||||
reactions$: vm.reactions$,
|
||||
@@ -50,9 +49,9 @@ function TestComponent({
|
||||
|
||||
test("Can open menu", async () => {
|
||||
const user = userEvent.setup();
|
||||
const { vm, rtcSession } = getBasicCallViewModelEnvironment([alice]);
|
||||
const { vm, matrixRoom, client } = getBasicCallViewModelEnvironment([alice]);
|
||||
const { getByLabelText, container } = render(
|
||||
<TestComponent vm={vm} rtcSession={rtcSession} />,
|
||||
<TestComponent vm={vm} matrixRoom={matrixRoom} client={client} />,
|
||||
);
|
||||
await user.click(getByLabelText("Reactions"));
|
||||
expect(container).toMatchSnapshot();
|
||||
@@ -60,15 +59,15 @@ test("Can open menu", async () => {
|
||||
|
||||
test("Can raise hand", async () => {
|
||||
const user = userEvent.setup();
|
||||
const { vm, rtcSession, handRaisedSubject$ } =
|
||||
const { vm, matrixRoom, client, handRaisedSubject$ } =
|
||||
getBasicCallViewModelEnvironment([local, alice]);
|
||||
const { getByLabelText, container } = render(
|
||||
<TestComponent vm={vm} rtcSession={rtcSession} />,
|
||||
<TestComponent vm={vm} matrixRoom={matrixRoom} client={client} />,
|
||||
);
|
||||
await user.click(getByLabelText("Reactions"));
|
||||
await user.click(getByLabelText("Raise hand"));
|
||||
expect(rtcSession.room.client.sendEvent).toHaveBeenCalledWith(
|
||||
rtcSession.room.roomId,
|
||||
expect(client.sendEvent).toHaveBeenCalledWith(
|
||||
matrixRoom.roomId,
|
||||
"m.reaction",
|
||||
{
|
||||
"m.relates_to": {
|
||||
@@ -94,10 +93,10 @@ test("Can raise hand", async () => {
|
||||
test("Can lower hand", async () => {
|
||||
const reactionEventId = "$my-reaction-event:example.org";
|
||||
const user = userEvent.setup();
|
||||
const { vm, rtcSession, handRaisedSubject$ } =
|
||||
const { vm, matrixRoom, client, handRaisedSubject$ } =
|
||||
getBasicCallViewModelEnvironment([local, alice]);
|
||||
const { getByLabelText, container } = render(
|
||||
<TestComponent vm={vm} rtcSession={rtcSession} />,
|
||||
<TestComponent vm={vm} matrixRoom={matrixRoom} client={client} />,
|
||||
);
|
||||
await user.click(getByLabelText("Reactions"));
|
||||
await user.click(getByLabelText("Raise hand"));
|
||||
@@ -112,8 +111,8 @@ test("Can lower hand", async () => {
|
||||
});
|
||||
await user.click(getByLabelText("Reactions"));
|
||||
await user.click(getByLabelText("Lower hand"));
|
||||
expect(rtcSession.room.client.redactEvent).toHaveBeenCalledWith(
|
||||
rtcSession.room.roomId,
|
||||
expect(client.redactEvent).toHaveBeenCalledWith(
|
||||
matrixRoom.roomId,
|
||||
reactionEventId,
|
||||
);
|
||||
act(() => {
|
||||
@@ -125,14 +124,17 @@ test("Can lower hand", async () => {
|
||||
|
||||
test("Can react with emoji", async () => {
|
||||
const user = userEvent.setup();
|
||||
const { vm, rtcSession } = getBasicCallViewModelEnvironment([local, alice]);
|
||||
const { vm, matrixRoom, client } = getBasicCallViewModelEnvironment([
|
||||
local,
|
||||
alice,
|
||||
]);
|
||||
const { getByLabelText, getByText } = render(
|
||||
<TestComponent vm={vm} rtcSession={rtcSession} />,
|
||||
<TestComponent vm={vm} matrixRoom={matrixRoom} client={client} />,
|
||||
);
|
||||
await user.click(getByLabelText("Reactions"));
|
||||
await user.click(getByText("🐶"));
|
||||
expect(rtcSession.room.client.sendEvent).toHaveBeenCalledWith(
|
||||
rtcSession.room.roomId,
|
||||
expect(client.sendEvent).toHaveBeenCalledWith(
|
||||
matrixRoom.roomId,
|
||||
ElementCallReactionEventType,
|
||||
{
|
||||
"m.relates_to": {
|
||||
@@ -147,16 +149,19 @@ test("Can react with emoji", async () => {
|
||||
|
||||
test("Can fully expand emoji picker", async () => {
|
||||
const user = userEvent.setup();
|
||||
const { vm, rtcSession } = getBasicCallViewModelEnvironment([local, alice]);
|
||||
const { vm, matrixRoom, client } = getBasicCallViewModelEnvironment([
|
||||
local,
|
||||
alice,
|
||||
]);
|
||||
const { getByLabelText, container, getByText } = render(
|
||||
<TestComponent vm={vm} rtcSession={rtcSession} />,
|
||||
<TestComponent vm={vm} matrixRoom={matrixRoom} client={client} />,
|
||||
);
|
||||
await user.click(getByLabelText("Reactions"));
|
||||
await user.click(getByLabelText("Show more"));
|
||||
expect(container).toMatchSnapshot();
|
||||
await user.click(getByText("🦗"));
|
||||
expect(rtcSession.room.client.sendEvent).toHaveBeenCalledWith(
|
||||
rtcSession.room.roomId,
|
||||
expect(client.sendEvent).toHaveBeenCalledWith(
|
||||
matrixRoom.roomId,
|
||||
ElementCallReactionEventType,
|
||||
{
|
||||
"m.relates_to": {
|
||||
@@ -171,9 +176,12 @@ test("Can fully expand emoji picker", async () => {
|
||||
|
||||
test("Can close reaction dialog", async () => {
|
||||
const user = userEvent.setup();
|
||||
const { vm, rtcSession } = getBasicCallViewModelEnvironment([local, alice]);
|
||||
const { vm, matrixRoom, client } = getBasicCallViewModelEnvironment([
|
||||
local,
|
||||
alice,
|
||||
]);
|
||||
const { getByLabelText, container } = render(
|
||||
<TestComponent vm={vm} rtcSession={rtcSession} />,
|
||||
<TestComponent vm={vm} matrixRoom={matrixRoom} client={client} />,
|
||||
);
|
||||
await user.click(getByLabelText("Reactions"));
|
||||
await user.click(getByLabelText("Show more"));
|
||||
|
||||
@@ -37,7 +37,12 @@ interface UseProfile extends ProfileLoadState {
|
||||
saveProfile: ProfileSaveCallback;
|
||||
}
|
||||
|
||||
export function useProfile(client: MatrixClient | undefined): UseProfile {
|
||||
export type ProfileClientParts = Pick<
|
||||
MatrixClient,
|
||||
"getUserId" | "getUser" | "setDisplayName" | "setAvatarUrl" | "uploadContent"
|
||||
>;
|
||||
|
||||
export function useProfile(client: ProfileClientParts | undefined): UseProfile {
|
||||
const [{ success, loading, displayName, avatarUrl, error }, setState] =
|
||||
useState<ProfileLoadState>(() => {
|
||||
let user: User | undefined = undefined;
|
||||
|
||||
@@ -23,30 +23,130 @@ import {
|
||||
localRtcMember,
|
||||
} from "../utils/test-fixtures";
|
||||
import { getBasicRTCSession } from "../utils/test-viewmodel";
|
||||
import { testScope, withTestScheduler } from "../utils/test";
|
||||
import { mockRtcMembership, testScope, withTestScheduler } from "../utils/test";
|
||||
import { ElementCallReactionEventType, ReactionSet } from ".";
|
||||
|
||||
afterEach(() => {
|
||||
vitest.useRealTimers();
|
||||
});
|
||||
|
||||
test("handles a hand raised reaction", () => {
|
||||
const { rtcSession } = getBasicRTCSession([local, alice]);
|
||||
function raiseLocalHand(
|
||||
matrixRoom: ReturnType<typeof getBasicRTCSession>["matrixRoom"],
|
||||
reactionEventId: string,
|
||||
localTimestamp: Date,
|
||||
): void {
|
||||
matrixRoom.emit(
|
||||
MatrixRoomEvent.Timeline,
|
||||
new MatrixEvent({
|
||||
room_id: matrixRoom.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: localRtcMember.userId,
|
||||
type: EventType.Reaction,
|
||||
origin_server_ts: localTimestamp.getTime(),
|
||||
content: {
|
||||
"m.relates_to": { event_id: localRtcMember.eventId, key: "🖐️" },
|
||||
},
|
||||
}),
|
||||
matrixRoom,
|
||||
undefined,
|
||||
false,
|
||||
{} as IRoomTimelineData,
|
||||
);
|
||||
}
|
||||
|
||||
test("lowers the hand of a member who leaves", () => {
|
||||
const { members$, matrixRoom, client, rtcMemberships$ } = getBasicRTCSession([
|
||||
local,
|
||||
alice,
|
||||
]);
|
||||
const reactionEventId = "$my_event_id:example.org";
|
||||
const localTimestamp = new Date();
|
||||
withTestScheduler(({ schedule, expectObservable }) => {
|
||||
renderHook(() => {
|
||||
const { raisedHands$ } = new ReactionsReader(
|
||||
testScope(),
|
||||
rtcSession.asMockedSession(),
|
||||
members$,
|
||||
matrixRoom,
|
||||
client,
|
||||
);
|
||||
schedule("abc", {
|
||||
a: () => {},
|
||||
b: () => raiseLocalHand(matrixRoom, reactionEventId, localTimestamp),
|
||||
c: () => rtcMemberships$.next([aliceRtcMember]),
|
||||
});
|
||||
expectObservable(raisedHands$).toBe("abc", {
|
||||
a: {},
|
||||
b: {
|
||||
[`${localRtcMember.userId}:${localRtcMember.deviceId}`]: {
|
||||
reactionEventId,
|
||||
membershipEventId: localRtcMember.eventId,
|
||||
time: localTimestamp,
|
||||
},
|
||||
},
|
||||
c: {},
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
test("lowers the hand of a member whose membership is sent again", () => {
|
||||
const { members$, matrixRoom, client, rtcMemberships$ } = getBasicRTCSession([
|
||||
local,
|
||||
alice,
|
||||
]);
|
||||
const reactionEventId = "$my_event_id:example.org";
|
||||
const localTimestamp = new Date();
|
||||
const resent = mockRtcMembership(
|
||||
localRtcMember.userId,
|
||||
localRtcMember.deviceId,
|
||||
);
|
||||
withTestScheduler(({ schedule, expectObservable }) => {
|
||||
renderHook(() => {
|
||||
const { raisedHands$ } = new ReactionsReader(
|
||||
testScope(),
|
||||
members$,
|
||||
matrixRoom,
|
||||
client,
|
||||
);
|
||||
schedule("abc", {
|
||||
a: () => {},
|
||||
b: () => raiseLocalHand(matrixRoom, reactionEventId, localTimestamp),
|
||||
c: () => rtcMemberships$.next([resent, aliceRtcMember]),
|
||||
});
|
||||
expectObservable(raisedHands$).toBe("abc", {
|
||||
a: {},
|
||||
b: {
|
||||
[`${localRtcMember.userId}:${localRtcMember.deviceId}`]: {
|
||||
reactionEventId,
|
||||
membershipEventId: localRtcMember.eventId,
|
||||
time: localTimestamp,
|
||||
},
|
||||
},
|
||||
c: {},
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
test("handles a hand raised reaction", () => {
|
||||
const { members$, matrixRoom, client } = getBasicRTCSession([local, alice]);
|
||||
const reactionEventId = "$my_event_id:example.org";
|
||||
const localTimestamp = new Date();
|
||||
withTestScheduler(({ schedule, expectObservable }) => {
|
||||
renderHook(() => {
|
||||
const { raisedHands$ } = new ReactionsReader(
|
||||
testScope(),
|
||||
members$,
|
||||
matrixRoom,
|
||||
client,
|
||||
);
|
||||
schedule("ab", {
|
||||
a: () => {},
|
||||
b: () => {
|
||||
rtcSession.room.emit(
|
||||
matrixRoom.emit(
|
||||
MatrixRoomEvent.Timeline,
|
||||
new MatrixEvent({
|
||||
room_id: rtcSession.room.roomId,
|
||||
room_id: matrixRoom.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: localRtcMember.userId,
|
||||
type: EventType.Reaction,
|
||||
@@ -58,7 +158,7 @@ test("handles a hand raised reaction", () => {
|
||||
},
|
||||
},
|
||||
}),
|
||||
rtcSession.room,
|
||||
matrixRoom,
|
||||
undefined,
|
||||
false,
|
||||
{} as IRoomTimelineData,
|
||||
@@ -80,22 +180,24 @@ test("handles a hand raised reaction", () => {
|
||||
});
|
||||
|
||||
test("handles a redaction", () => {
|
||||
const { rtcSession } = getBasicRTCSession([local, alice]);
|
||||
const { members$, matrixRoom, client } = getBasicRTCSession([local, alice]);
|
||||
const reactionEventId = "$my_event_id:example.org";
|
||||
const localTimestamp = new Date();
|
||||
withTestScheduler(({ schedule, expectObservable }) => {
|
||||
renderHook(() => {
|
||||
const { raisedHands$ } = new ReactionsReader(
|
||||
testScope(),
|
||||
rtcSession.asMockedSession(),
|
||||
members$,
|
||||
matrixRoom,
|
||||
client,
|
||||
);
|
||||
schedule("abc", {
|
||||
a: () => {},
|
||||
b: () => {
|
||||
rtcSession.room.emit(
|
||||
matrixRoom.emit(
|
||||
MatrixRoomEvent.Timeline,
|
||||
new MatrixEvent({
|
||||
room_id: rtcSession.room.roomId,
|
||||
room_id: matrixRoom.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: localRtcMember.userId,
|
||||
type: EventType.Reaction,
|
||||
@@ -107,23 +209,23 @@ test("handles a redaction", () => {
|
||||
},
|
||||
},
|
||||
}),
|
||||
rtcSession.room,
|
||||
matrixRoom,
|
||||
undefined,
|
||||
false,
|
||||
{} as IRoomTimelineData,
|
||||
);
|
||||
},
|
||||
c: () => {
|
||||
rtcSession.room.emit(
|
||||
matrixRoom.emit(
|
||||
MatrixRoomEvent.Redaction,
|
||||
new MatrixEvent({
|
||||
room_id: rtcSession.room.roomId,
|
||||
room_id: matrixRoom.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: localRtcMember.userId,
|
||||
type: EventType.RoomRedaction,
|
||||
redacts: reactionEventId,
|
||||
}),
|
||||
rtcSession.room,
|
||||
matrixRoom,
|
||||
undefined,
|
||||
);
|
||||
},
|
||||
@@ -144,20 +246,22 @@ test("handles a redaction", () => {
|
||||
});
|
||||
|
||||
test("handles waiting for event decryption", () => {
|
||||
const { rtcSession } = getBasicRTCSession([local, alice]);
|
||||
const { members$, matrixRoom, client } = getBasicRTCSession([local, alice]);
|
||||
const reactionEventId = "$my_event_id:example.org";
|
||||
const localTimestamp = new Date();
|
||||
withTestScheduler(({ schedule, expectObservable }) => {
|
||||
renderHook(() => {
|
||||
const { raisedHands$ } = new ReactionsReader(
|
||||
testScope(),
|
||||
rtcSession.asMockedSession(),
|
||||
members$,
|
||||
matrixRoom,
|
||||
client,
|
||||
);
|
||||
schedule("abc", {
|
||||
a: () => {},
|
||||
b: () => {
|
||||
const encryptedEvent = new MatrixEvent({
|
||||
room_id: rtcSession.room.roomId,
|
||||
room_id: matrixRoom.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: localRtcMember.userId,
|
||||
type: EventType.Reaction,
|
||||
@@ -171,20 +275,20 @@ test("handles waiting for event decryption", () => {
|
||||
});
|
||||
// Should ignore encrypted events that are still encrypting
|
||||
encryptedEvent["decryptionPromise"] = Promise.resolve();
|
||||
rtcSession.room.emit(
|
||||
matrixRoom.emit(
|
||||
MatrixRoomEvent.Timeline,
|
||||
encryptedEvent,
|
||||
rtcSession.room,
|
||||
matrixRoom,
|
||||
undefined,
|
||||
false,
|
||||
{} as IRoomTimelineData,
|
||||
);
|
||||
},
|
||||
c: () => {
|
||||
rtcSession.room.client.emit(
|
||||
client.emit(
|
||||
MatrixEventEvent.Decrypted,
|
||||
new MatrixEvent({
|
||||
room_id: rtcSession.room.roomId,
|
||||
room_id: matrixRoom.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: localRtcMember.userId,
|
||||
type: EventType.Reaction,
|
||||
@@ -214,22 +318,24 @@ test("handles waiting for event decryption", () => {
|
||||
});
|
||||
|
||||
test("hands rejecting events without a proper membership", () => {
|
||||
const { rtcSession } = getBasicRTCSession([local, alice]);
|
||||
const { members$, matrixRoom, client } = getBasicRTCSession([local, alice]);
|
||||
const reactionEventId = "$my_event_id:example.org";
|
||||
const localTimestamp = new Date();
|
||||
withTestScheduler(({ schedule, expectObservable }) => {
|
||||
renderHook(() => {
|
||||
const { raisedHands$ } = new ReactionsReader(
|
||||
testScope(),
|
||||
rtcSession.asMockedSession(),
|
||||
members$,
|
||||
matrixRoom,
|
||||
client,
|
||||
);
|
||||
schedule("ab", {
|
||||
a: () => {},
|
||||
b: () => {
|
||||
rtcSession.room.emit(
|
||||
matrixRoom.emit(
|
||||
MatrixRoomEvent.Timeline,
|
||||
new MatrixEvent({
|
||||
room_id: rtcSession.room.roomId,
|
||||
room_id: matrixRoom.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: localRtcMember.userId,
|
||||
type: EventType.Reaction,
|
||||
@@ -241,7 +347,7 @@ test("hands rejecting events without a proper membership", () => {
|
||||
},
|
||||
},
|
||||
}),
|
||||
rtcSession.room,
|
||||
matrixRoom,
|
||||
undefined,
|
||||
false,
|
||||
{} as IRoomTimelineData,
|
||||
@@ -256,7 +362,7 @@ test("hands rejecting events without a proper membership", () => {
|
||||
});
|
||||
|
||||
test("handles a reaction", () => {
|
||||
const { rtcSession } = getBasicRTCSession([local, alice]);
|
||||
const { members$, matrixRoom, client } = getBasicRTCSession([local, alice]);
|
||||
const reactionEventId = "$my_event_id:example.org";
|
||||
const reaction = ReactionSet[1];
|
||||
|
||||
@@ -267,15 +373,17 @@ test("handles a reaction", () => {
|
||||
renderHook(() => {
|
||||
const { reactions$ } = new ReactionsReader(
|
||||
testScope(),
|
||||
rtcSession.asMockedSession(),
|
||||
members$,
|
||||
matrixRoom,
|
||||
client,
|
||||
);
|
||||
schedule(`abc`, {
|
||||
a: () => {},
|
||||
b: () => {
|
||||
rtcSession.room.emit(
|
||||
matrixRoom.emit(
|
||||
MatrixRoomEvent.Timeline,
|
||||
new MatrixEvent({
|
||||
room_id: rtcSession.room.roomId,
|
||||
room_id: matrixRoom.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: localRtcMember.userId,
|
||||
type: ElementCallReactionEventType,
|
||||
@@ -287,7 +395,7 @@ test("handles a reaction", () => {
|
||||
},
|
||||
},
|
||||
}),
|
||||
rtcSession.room,
|
||||
matrixRoom,
|
||||
undefined,
|
||||
false,
|
||||
{} as IRoomTimelineData,
|
||||
@@ -316,7 +424,11 @@ test("handles a reaction", () => {
|
||||
});
|
||||
|
||||
test("ignores bad reaction events", () => {
|
||||
const { rtcSession } = getBasicRTCSession([local, alice]);
|
||||
const {
|
||||
members$,
|
||||
matrixRoom: room,
|
||||
client,
|
||||
} = getBasicRTCSession([local, alice]);
|
||||
const reactionEventId = "$my_event_id:example.org";
|
||||
const reaction = ReactionSet[1];
|
||||
|
||||
@@ -326,31 +438,33 @@ test("ignores bad reaction events", () => {
|
||||
renderHook(() => {
|
||||
const { reactions$ } = new ReactionsReader(
|
||||
testScope(),
|
||||
rtcSession.asMockedSession(),
|
||||
members$,
|
||||
room,
|
||||
client,
|
||||
);
|
||||
schedule("ab", {
|
||||
a: () => {},
|
||||
b: () => {
|
||||
// Missing content
|
||||
rtcSession.room.emit(
|
||||
room.emit(
|
||||
MatrixRoomEvent.Timeline,
|
||||
new MatrixEvent({
|
||||
room_id: rtcSession.room.roomId,
|
||||
room_id: room.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: localRtcMember.userId,
|
||||
type: ElementCallReactionEventType,
|
||||
content: {},
|
||||
}),
|
||||
rtcSession.room,
|
||||
room,
|
||||
undefined,
|
||||
false,
|
||||
{} as IRoomTimelineData,
|
||||
);
|
||||
// Wrong relates event
|
||||
rtcSession.room.emit(
|
||||
room.emit(
|
||||
MatrixRoomEvent.Timeline,
|
||||
new MatrixEvent({
|
||||
room_id: rtcSession.room.roomId,
|
||||
room_id: room.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: localRtcMember.userId,
|
||||
type: ElementCallReactionEventType,
|
||||
@@ -362,16 +476,16 @@ test("ignores bad reaction events", () => {
|
||||
},
|
||||
},
|
||||
}),
|
||||
rtcSession.room,
|
||||
room,
|
||||
undefined,
|
||||
false,
|
||||
{} as IRoomTimelineData,
|
||||
);
|
||||
// Wrong rtc member event
|
||||
rtcSession.room.emit(
|
||||
room.emit(
|
||||
MatrixRoomEvent.Timeline,
|
||||
new MatrixEvent({
|
||||
room_id: rtcSession.room.roomId,
|
||||
room_id: room.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: aliceRtcMember.userId,
|
||||
type: ElementCallReactionEventType,
|
||||
@@ -383,16 +497,16 @@ test("ignores bad reaction events", () => {
|
||||
},
|
||||
},
|
||||
}),
|
||||
rtcSession.room,
|
||||
room,
|
||||
undefined,
|
||||
false,
|
||||
{} as IRoomTimelineData,
|
||||
);
|
||||
// No emoji
|
||||
rtcSession.room.emit(
|
||||
room.emit(
|
||||
MatrixRoomEvent.Timeline,
|
||||
new MatrixEvent({
|
||||
room_id: rtcSession.room.roomId,
|
||||
room_id: room.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: localRtcMember.userId,
|
||||
type: ElementCallReactionEventType,
|
||||
@@ -403,16 +517,16 @@ test("ignores bad reaction events", () => {
|
||||
},
|
||||
},
|
||||
}),
|
||||
rtcSession.room,
|
||||
room,
|
||||
undefined,
|
||||
false,
|
||||
{} as IRoomTimelineData,
|
||||
);
|
||||
// Invalid emoji
|
||||
rtcSession.room.emit(
|
||||
room.emit(
|
||||
MatrixRoomEvent.Timeline,
|
||||
new MatrixEvent({
|
||||
room_id: rtcSession.room.roomId,
|
||||
room_id: room.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: localRtcMember.userId,
|
||||
type: ElementCallReactionEventType,
|
||||
@@ -424,7 +538,7 @@ test("ignores bad reaction events", () => {
|
||||
},
|
||||
},
|
||||
}),
|
||||
rtcSession.room,
|
||||
room,
|
||||
undefined,
|
||||
false,
|
||||
{} as IRoomTimelineData,
|
||||
@@ -439,7 +553,7 @@ test("ignores bad reaction events", () => {
|
||||
});
|
||||
|
||||
test("that reactions cannot be spammed", () => {
|
||||
const { rtcSession } = getBasicRTCSession([local, alice]);
|
||||
const { members$, matrixRoom, client } = getBasicRTCSession([local, alice]);
|
||||
const reactionEventId = "$my_event_id:example.org";
|
||||
const reactionA = ReactionSet[1];
|
||||
const reactionB = ReactionSet[2];
|
||||
@@ -451,15 +565,17 @@ test("that reactions cannot be spammed", () => {
|
||||
renderHook(() => {
|
||||
const { reactions$ } = new ReactionsReader(
|
||||
testScope(),
|
||||
rtcSession.asMockedSession(),
|
||||
members$,
|
||||
matrixRoom,
|
||||
client,
|
||||
);
|
||||
schedule("abcd", {
|
||||
a: () => {},
|
||||
b: () => {
|
||||
rtcSession.room.emit(
|
||||
matrixRoom.emit(
|
||||
MatrixRoomEvent.Timeline,
|
||||
new MatrixEvent({
|
||||
room_id: rtcSession.room.roomId,
|
||||
room_id: matrixRoom.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: localRtcMember.userId,
|
||||
type: ElementCallReactionEventType,
|
||||
@@ -471,17 +587,17 @@ test("that reactions cannot be spammed", () => {
|
||||
},
|
||||
},
|
||||
}),
|
||||
rtcSession.room,
|
||||
matrixRoom,
|
||||
undefined,
|
||||
false,
|
||||
{} as IRoomTimelineData,
|
||||
);
|
||||
},
|
||||
c: () => {
|
||||
rtcSession.room.emit(
|
||||
matrixRoom.emit(
|
||||
MatrixRoomEvent.Timeline,
|
||||
new MatrixEvent({
|
||||
room_id: rtcSession.room.roomId,
|
||||
room_id: matrixRoom.roomId,
|
||||
event_id: reactionEventId,
|
||||
sender: localRtcMember.userId,
|
||||
type: ElementCallReactionEventType,
|
||||
@@ -493,7 +609,7 @@ test("that reactions cannot be spammed", () => {
|
||||
},
|
||||
},
|
||||
}),
|
||||
rtcSession.room,
|
||||
matrixRoom,
|
||||
undefined,
|
||||
false,
|
||||
{} as IRoomTimelineData,
|
||||
|
||||
@@ -5,20 +5,28 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import {
|
||||
type CallMembership,
|
||||
MatrixRTCSessionEvent,
|
||||
type MatrixRTCSession,
|
||||
} from "matrix-js-sdk/lib/matrixrtc";
|
||||
import { logger } from "matrix-js-sdk/lib/logger";
|
||||
import { type MatrixEvent, MatrixEventEvent } from "matrix-js-sdk";
|
||||
import {
|
||||
type MatrixClient,
|
||||
type MatrixEvent,
|
||||
MatrixEventEvent,
|
||||
type Room,
|
||||
} from "matrix-js-sdk";
|
||||
import { type ReactionEventContent } from "matrix-js-sdk/lib/types";
|
||||
import {
|
||||
RelationType,
|
||||
EventType,
|
||||
RoomEvent as MatrixRoomEvent,
|
||||
} from "matrix-js-sdk";
|
||||
import { BehaviorSubject, delay } from "rxjs";
|
||||
import {
|
||||
BehaviorSubject,
|
||||
combineLatest,
|
||||
delay,
|
||||
map,
|
||||
of,
|
||||
switchMap,
|
||||
} from "rxjs";
|
||||
import { type RTCMember } from "@element-hq/matrixrtc-sdk";
|
||||
|
||||
import {
|
||||
ElementCallReactionEventType,
|
||||
@@ -29,13 +37,20 @@ import {
|
||||
type ReactionInfo,
|
||||
} from ".";
|
||||
import { type ObservableScope } from "../state/ObservableScope";
|
||||
import { type Behavior } from "../state/Behavior";
|
||||
|
||||
export const REACTION_ACTIVE_TIME_MS = 3000;
|
||||
|
||||
/** A member's membership event, which its reactions relate to. */
|
||||
interface MembershipEvent {
|
||||
userId: string;
|
||||
deviceId: string;
|
||||
eventId: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* Listens for reactions from a RTCSession and populates subjects
|
||||
* for consumption by the CallViewModel.
|
||||
* @param rtcSession
|
||||
* Listens for reactions to the slot members' memberships and populates
|
||||
* subjects for consumption by the CallViewModel.
|
||||
*/
|
||||
export class ReactionsReader {
|
||||
private readonly raisedHandsSubject$ = new BehaviorSubject<
|
||||
@@ -55,9 +70,33 @@ export class ReactionsReader {
|
||||
*/
|
||||
public readonly reactions$ = this.reactionsSubject$.asObservable();
|
||||
|
||||
private memberships: MembershipEvent[] = [];
|
||||
|
||||
public constructor(
|
||||
private readonly scope: ObservableScope,
|
||||
private readonly rtcSession: MatrixRTCSession,
|
||||
members$: Behavior<RTCMember[]>,
|
||||
private readonly room: Pick<
|
||||
Room,
|
||||
// To ignore events from other rooms
|
||||
| "roomId"
|
||||
// The raised hands already in the room, as reactions to memberships
|
||||
| "relations"
|
||||
// `on`/`off`, to listen for:
|
||||
// - `RoomEvent.Timeline` (new reactions)
|
||||
// - `RoomEvent.Redaction` (lowered hands)
|
||||
// - `RoomEvent.LocalEchoUpdated` (the real id of our own reactions)
|
||||
| "on"
|
||||
| "off"
|
||||
>,
|
||||
private readonly client: Pick<
|
||||
MatrixClient,
|
||||
// Reactions that arrived encrypted
|
||||
| "decryptEventIfNeeded"
|
||||
// `on`/`off`, to listen for:
|
||||
// - `MatrixEventEvent.Decrypted` (reactions once decrypted)
|
||||
| "on"
|
||||
| "off"
|
||||
>,
|
||||
) {
|
||||
// Hide reactions after a given time.
|
||||
this.reactionsSubject$
|
||||
@@ -76,62 +115,44 @@ export class ReactionsReader {
|
||||
// TODO: Convert this class to the functional reactive style and get rid of
|
||||
// all this manual setup and teardown for event listeners
|
||||
|
||||
this.rtcSession.room.on(MatrixRoomEvent.Timeline, this.handleReactionEvent);
|
||||
this.room.on(MatrixRoomEvent.Timeline, this.handleReactionEvent);
|
||||
this.scope.onEnd(() =>
|
||||
this.rtcSession.room.off(
|
||||
MatrixRoomEvent.Timeline,
|
||||
this.handleReactionEvent,
|
||||
),
|
||||
this.room.off(MatrixRoomEvent.Timeline, this.handleReactionEvent),
|
||||
);
|
||||
|
||||
this.rtcSession.room.on(
|
||||
MatrixRoomEvent.Redaction,
|
||||
this.handleReactionEvent,
|
||||
);
|
||||
this.room.on(MatrixRoomEvent.Redaction, this.handleReactionEvent);
|
||||
this.scope.onEnd(() =>
|
||||
this.rtcSession.room.off(
|
||||
MatrixRoomEvent.Redaction,
|
||||
this.handleReactionEvent,
|
||||
),
|
||||
this.room.off(MatrixRoomEvent.Redaction, this.handleReactionEvent),
|
||||
);
|
||||
|
||||
this.rtcSession.room.client.on(
|
||||
MatrixEventEvent.Decrypted,
|
||||
this.handleReactionEvent,
|
||||
);
|
||||
this.client.on(MatrixEventEvent.Decrypted, this.handleReactionEvent);
|
||||
this.scope.onEnd(() =>
|
||||
this.rtcSession.room.client.off(
|
||||
MatrixEventEvent.Decrypted,
|
||||
this.handleReactionEvent,
|
||||
),
|
||||
this.client.off(MatrixEventEvent.Decrypted, this.handleReactionEvent),
|
||||
);
|
||||
|
||||
// We listen for a local echo to get the real event ID, as timeline events
|
||||
// may still be sending.
|
||||
this.rtcSession.room.on(
|
||||
MatrixRoomEvent.LocalEchoUpdated,
|
||||
this.handleReactionEvent,
|
||||
);
|
||||
this.room.on(MatrixRoomEvent.LocalEchoUpdated, this.handleReactionEvent);
|
||||
this.scope.onEnd(() =>
|
||||
this.rtcSession.room.off(
|
||||
MatrixRoomEvent.LocalEchoUpdated,
|
||||
this.handleReactionEvent,
|
||||
),
|
||||
this.room.off(MatrixRoomEvent.LocalEchoUpdated, this.handleReactionEvent),
|
||||
);
|
||||
|
||||
this.rtcSession.on(
|
||||
MatrixRTCSessionEvent.MembershipsChanged,
|
||||
this.onMembershipsChanged,
|
||||
);
|
||||
this.scope.onEnd(() =>
|
||||
this.rtcSession.off(
|
||||
MatrixRTCSessionEvent.MembershipsChanged,
|
||||
this.onMembershipsChanged,
|
||||
),
|
||||
);
|
||||
|
||||
// Run this once to ensure we have fetched the state from the call.
|
||||
this.onMembershipsChanged([]);
|
||||
members$
|
||||
.pipe(
|
||||
switchMap((members) =>
|
||||
members.length === 0
|
||||
? of([])
|
||||
: combineLatest(
|
||||
members.map(({ userId, deviceId, matrixEventId$ }) =>
|
||||
matrixEventId$.pipe(
|
||||
map((eventId) => ({ userId, deviceId, eventId })),
|
||||
),
|
||||
),
|
||||
),
|
||||
),
|
||||
this.scope.bind(),
|
||||
)
|
||||
.subscribe(this.onMembershipsChanged);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -145,7 +166,7 @@ export class ReactionsReader {
|
||||
membershipEventId: string,
|
||||
expectedSender: string,
|
||||
): MatrixEvent | undefined {
|
||||
const relations = this.rtcSession.room.relations.getChildEventsForEvent(
|
||||
const relations = this.room.relations.getChildEventsForEvent(
|
||||
membershipEventId,
|
||||
RelationType.Annotation,
|
||||
EventType.Reaction,
|
||||
@@ -162,22 +183,23 @@ export class ReactionsReader {
|
||||
/**
|
||||
* Will remove any hand raises by old members, and look for any
|
||||
* existing hand raises by new members.
|
||||
* @param oldMemberships Any members who have left the call.
|
||||
* @param memberships The membership events of everyone in the call now.
|
||||
*/
|
||||
private onMembershipsChanged = (oldMemberships: CallMembership[]): void => {
|
||||
private onMembershipsChanged = (memberships: MembershipEvent[]): void => {
|
||||
this.memberships = memberships;
|
||||
// Remove any raised hands for users no longer joined to the call.
|
||||
const present = new Set(
|
||||
memberships.map((m) => `${m.userId}:${m.deviceId}`),
|
||||
);
|
||||
for (const identifier of Object.keys(this.raisedHandsSubject$.value).filter(
|
||||
(rhId) => oldMemberships.find((u) => u.userId == rhId),
|
||||
(rhId) => !present.has(rhId),
|
||||
)) {
|
||||
this.removeRaisedHand(identifier);
|
||||
}
|
||||
|
||||
// For each member in the call, check to see if a reaction has
|
||||
// been raised and adjust.
|
||||
for (const m of this.rtcSession.memberships) {
|
||||
if (!m.userId || !m.eventId) {
|
||||
continue;
|
||||
}
|
||||
for (const m of memberships) {
|
||||
const identifier = `${m.userId}:${m.deviceId}`;
|
||||
if (
|
||||
this.raisedHandsSubject$.value[identifier] &&
|
||||
@@ -235,9 +257,8 @@ export class ReactionsReader {
|
||||
* @param event The incoming matrix event, which may or may not be decrypted.
|
||||
*/
|
||||
private handleReactionEvent = (event: MatrixEvent): void => {
|
||||
const room = this.rtcSession.room;
|
||||
// Decrypted events might come from a different room
|
||||
if (event.getRoomId() !== room.roomId) return;
|
||||
if (event.getRoomId() !== this.room.roomId) return;
|
||||
// Skip any events that are still sending.
|
||||
if (event.isSending()) return;
|
||||
|
||||
@@ -246,7 +267,7 @@ export class ReactionsReader {
|
||||
// Skip any event without a sender or event ID.
|
||||
if (!sender || !reactionEventId) return;
|
||||
|
||||
room.client
|
||||
this.client
|
||||
.decryptEventIfNeeded(event)
|
||||
.catch((e) => logger.warn(`Failed to decrypt ${event.getId()}`, e));
|
||||
if (event.isBeingDecrypted() || event.isDecryptionFailure()) return;
|
||||
@@ -255,7 +276,7 @@ export class ReactionsReader {
|
||||
const content: ECallReactionEventContent = event.getContent();
|
||||
|
||||
const membershipEventId = content?.["m.relates_to"]?.event_id;
|
||||
const membershipEvent = this.rtcSession.memberships.find(
|
||||
const membershipEvent = this.memberships.find(
|
||||
(e) => e.eventId === membershipEventId && e.userId === sender,
|
||||
);
|
||||
// Check to see if this reaction was made to a membership event (and the
|
||||
@@ -315,7 +336,7 @@ export class ReactionsReader {
|
||||
|
||||
// Check to see if this reaction was made to a membership event (and the
|
||||
// sender of the reaction matches the membership)
|
||||
const membershipEvent = this.rtcSession.memberships.find(
|
||||
const membershipEvent = this.memberships.find(
|
||||
(e) => e.eventId === membershipEventId && e.userId === sender,
|
||||
);
|
||||
if (!membershipEvent) {
|
||||
|
||||
@@ -5,7 +5,12 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { EventType, RelationType } from "matrix-js-sdk";
|
||||
import {
|
||||
EventType,
|
||||
type MatrixClient,
|
||||
RelationType,
|
||||
type Room,
|
||||
} from "matrix-js-sdk";
|
||||
import {
|
||||
createContext,
|
||||
use,
|
||||
@@ -14,14 +19,15 @@ import {
|
||||
useMemo,
|
||||
type JSX,
|
||||
} from "react";
|
||||
import { type MatrixRTCSession } from "matrix-js-sdk/lib/matrixrtc";
|
||||
import { logger } from "matrix-js-sdk/lib/logger";
|
||||
|
||||
import { useMatrixRTCSessionMemberships } from "../useMatrixRTCSessionMemberships";
|
||||
import { useClientState } from "../ClientContext";
|
||||
import { ElementCallReactionEventType, type ReactionOption } from ".";
|
||||
import { type CallViewModel } from "../state/CallViewModel/CallViewModel";
|
||||
import { useBehavior } from "../useBehavior";
|
||||
import { constant } from "../state/Behavior";
|
||||
|
||||
const noMembershipEvent$ = constant(undefined);
|
||||
|
||||
interface ReactionsSenderContextType {
|
||||
supportsReactions: boolean;
|
||||
@@ -46,28 +52,34 @@ export const useReactionsSender = (): ReactionsSenderContextType => {
|
||||
*/
|
||||
export const ReactionsSenderProvider = ({
|
||||
children,
|
||||
rtcSession,
|
||||
room,
|
||||
client,
|
||||
vm,
|
||||
}: {
|
||||
children: ReactNode;
|
||||
rtcSession: MatrixRTCSession;
|
||||
/** The room the reactions are sent in. */
|
||||
room: Pick<Room, "roomId">;
|
||||
client: Pick<
|
||||
MatrixClient,
|
||||
// Our own identity, which reactions and raised hands are keyed by
|
||||
| "getUserId"
|
||||
| "getDeviceId"
|
||||
// Sending reactions and raising a hand
|
||||
| "sendEvent"
|
||||
// Lowering a hand
|
||||
| "redactEvent"
|
||||
>;
|
||||
/** Our own membership, which the reactions relate to, and the current reactions. */
|
||||
vm: CallViewModel;
|
||||
}): JSX.Element => {
|
||||
const memberships = useMatrixRTCSessionMemberships(rtcSession);
|
||||
const clientState = useClientState();
|
||||
const supportsReactions =
|
||||
clientState?.state === "valid" && clientState.supportedFeatures.reactions;
|
||||
const room = rtcSession.room;
|
||||
const myUserId = room.client.getUserId();
|
||||
const myDeviceId = room.client.getDeviceId();
|
||||
const myMembershipIdentifier = `${myUserId}:${myDeviceId}`;
|
||||
const myMembershipIdentifier = `${client.getUserId()}:${client.getDeviceId()}`;
|
||||
|
||||
const myMembershipEvent = useMemo(
|
||||
() =>
|
||||
memberships.find(
|
||||
(m) => m.userId === myUserId && m.deviceId === myDeviceId,
|
||||
)?.eventId,
|
||||
[memberships, myUserId, myDeviceId],
|
||||
const localMember = useBehavior(vm.localMember$);
|
||||
const myMembershipEvent = useBehavior(
|
||||
localMember?.matrixEventId$ ?? noMembershipEvent$,
|
||||
);
|
||||
|
||||
const reactions = useBehavior(vm.reactions$);
|
||||
@@ -99,8 +111,8 @@ export const ReactionsSenderProvider = ({
|
||||
if (!myMembershipEvent) {
|
||||
throw new Error("Cannot find own membership event");
|
||||
}
|
||||
const reaction = await room.client.sendEvent(
|
||||
rtcSession.room.roomId,
|
||||
const reaction = await client.sendEvent(
|
||||
room.roomId,
|
||||
EventType.Reaction,
|
||||
{
|
||||
"m.relates_to": {
|
||||
@@ -116,20 +128,14 @@ export const ReactionsSenderProvider = ({
|
||||
}
|
||||
} else {
|
||||
try {
|
||||
await room.client.redactEvent(rtcSession.room.roomId, myReactionId);
|
||||
await client.redactEvent(room.roomId, myReactionId);
|
||||
logger.debug("Redacted raise hand event");
|
||||
} catch (ex) {
|
||||
logger.error("Failed to redact reaction event", myReactionId, ex);
|
||||
throw ex;
|
||||
}
|
||||
}
|
||||
}, [
|
||||
myMembershipEvent,
|
||||
myMembershipIdentifier,
|
||||
myRaisedHand,
|
||||
rtcSession,
|
||||
room,
|
||||
]);
|
||||
}, [myMembershipEvent, myMembershipIdentifier, myRaisedHand, client, room]);
|
||||
|
||||
const sendReaction = useCallback(
|
||||
async (reaction: ReactionOption) => {
|
||||
@@ -140,20 +146,16 @@ export const ReactionsSenderProvider = ({
|
||||
if (!myMembershipEvent) {
|
||||
throw new Error("Cannot find own membership event");
|
||||
}
|
||||
await room.client.sendEvent(
|
||||
rtcSession.room.roomId,
|
||||
ElementCallReactionEventType,
|
||||
{
|
||||
"m.relates_to": {
|
||||
rel_type: RelationType.Reference,
|
||||
event_id: myMembershipEvent,
|
||||
},
|
||||
emoji: reaction.emoji,
|
||||
name: reaction.name,
|
||||
await client.sendEvent(room.roomId, ElementCallReactionEventType, {
|
||||
"m.relates_to": {
|
||||
rel_type: RelationType.Reference,
|
||||
event_id: myMembershipEvent,
|
||||
},
|
||||
);
|
||||
emoji: reaction.emoji,
|
||||
name: reaction.name,
|
||||
});
|
||||
},
|
||||
[myMembershipEvent, myReaction, room, myMembershipIdentifier, rtcSession],
|
||||
[myMembershipEvent, myReaction, client, room, myMembershipIdentifier],
|
||||
);
|
||||
|
||||
return (
|
||||
|
||||
@@ -6,13 +6,12 @@ Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { type FC, type FormEventHandler, useCallback, useState } from "react";
|
||||
import { type MatrixClient } from "matrix-js-sdk";
|
||||
import { Trans, useTranslation } from "react-i18next";
|
||||
import { Button, Heading, Text } from "@vector-im/compound-web";
|
||||
|
||||
import styles from "./CallEndedView.module.css";
|
||||
import feedbackStyle from "../input/FeedbackInput.module.css";
|
||||
import { useProfile } from "../profile/useProfile";
|
||||
import { type ProfileClientParts, useProfile } from "../profile/useProfile";
|
||||
import { Header, HeaderLogo, LeftNav, RightNav } from "../Header";
|
||||
import { PosthogAnalytics } from "../analytics/PosthogAnalytics";
|
||||
import { FieldRow, InputField } from "../input/Input";
|
||||
@@ -22,7 +21,7 @@ import { LeaveToHomeLink } from "../button/LeaveToHomeLink";
|
||||
import { useLeaveToHome } from "../LeaveToHomeContext";
|
||||
|
||||
interface Props {
|
||||
client: MatrixClient;
|
||||
client: ProfileClientParts;
|
||||
isPasswordlessUser: boolean;
|
||||
hideHeader: boolean;
|
||||
confineToRoom: boolean;
|
||||
|
||||
+46
-80
@@ -19,16 +19,8 @@ import {
|
||||
vitest,
|
||||
} from "vitest";
|
||||
import { render, waitFor, screen, act } from "@testing-library/react";
|
||||
import {
|
||||
type MatrixClient,
|
||||
JoinRule,
|
||||
type RoomState,
|
||||
UnsupportedStickyEventsEndpointError,
|
||||
} from "matrix-js-sdk";
|
||||
import {
|
||||
MatrixRTCSessionEvent,
|
||||
type MatrixRTCSession,
|
||||
} from "matrix-js-sdk/lib/matrixrtc";
|
||||
import { type MatrixClient, JoinRule } from "matrix-js-sdk";
|
||||
import { type MatrixRTCSession } from "matrix-js-sdk/lib/matrixrtc";
|
||||
import { BrowserRouter } from "react-router-dom";
|
||||
import userEvent, {
|
||||
PointerEventsCheckLevel,
|
||||
@@ -53,7 +45,7 @@ import {
|
||||
testScope,
|
||||
} from "../utils/test";
|
||||
import { CallView } from "./CallView";
|
||||
import { GroupCallErrorBoundary } from "./GroupCallErrorBoundary";
|
||||
import { type CallMatrixBackend } from "../CallMatrixBackend";
|
||||
import {
|
||||
type HostBridge,
|
||||
HostBridgeProvider,
|
||||
@@ -61,7 +53,10 @@ import {
|
||||
nullHostBridge,
|
||||
} from "../HostBridge";
|
||||
import { type JoinCallData } from "../widget";
|
||||
import { MatrixRTCTransportMissingError } from "../utils/errors";
|
||||
import {
|
||||
ConnectionLostError,
|
||||
MatrixRTCTransportMissingError,
|
||||
} from "../utils/errors";
|
||||
import {
|
||||
BackgroundEffectsProvider,
|
||||
createAppBackgroundEffects,
|
||||
@@ -146,7 +141,6 @@ function createCallView(
|
||||
hostBridge: HostBridge,
|
||||
joined = true,
|
||||
options: {
|
||||
withErrorBoundary?: boolean;
|
||||
/** Wait for the host to say when to join, rather than joining at once. */
|
||||
preload?: boolean;
|
||||
} = {},
|
||||
@@ -155,6 +149,7 @@ function createCallView(
|
||||
getByText: ReturnType<typeof render>["getByText"];
|
||||
} {
|
||||
const client = {
|
||||
...mockEmitter(),
|
||||
getUser: () => null,
|
||||
getUserId: () => localRtcMember.userId,
|
||||
getDeviceId: () => localRtcMember.deviceId,
|
||||
@@ -170,28 +165,14 @@ function createCallView(
|
||||
client,
|
||||
roomId,
|
||||
getMember: (userId) => roomMembers.get(userId) ?? null,
|
||||
getMembersWithMembership: () => [carol],
|
||||
getMxcAvatarUrl: () => null,
|
||||
getCanonicalAlias: () => null,
|
||||
currentState: {
|
||||
...mockEmitter(),
|
||||
getJoinRule: () => JoinRule.Invite,
|
||||
} as Partial<RoomState> as RoomState,
|
||||
getJoinRule: () => JoinRule.Invite,
|
||||
});
|
||||
const rtcSession = new MockRTCSession(room, []).withMemberships(
|
||||
constant([localRtcMember]),
|
||||
);
|
||||
rtcSession.joined = joined;
|
||||
const callView = (
|
||||
<CallView
|
||||
client={client}
|
||||
isPasswordlessUser={false}
|
||||
confineToRoom={false}
|
||||
preload={options.preload ?? false}
|
||||
// Straight into the (mocked) call, past the lobby
|
||||
skipLobby
|
||||
rtcSession={rtcSession.asMockedSession()}
|
||||
/>
|
||||
);
|
||||
const { getByText } = render(
|
||||
<BrowserRouter>
|
||||
<HostBridgeProvider value={hostBridge}>
|
||||
@@ -200,13 +181,22 @@ function createCallView(
|
||||
<BackgroundEffectsProvider
|
||||
effects={createAppBackgroundEffects(testScope())}
|
||||
>
|
||||
{options.withErrorBoundary ? (
|
||||
<GroupCallErrorBoundary recoveryActionHandler={vi.fn()}>
|
||||
{callView}
|
||||
</GroupCallErrorBoundary>
|
||||
) : (
|
||||
callView
|
||||
)}
|
||||
<CallView
|
||||
backend={
|
||||
{
|
||||
...client,
|
||||
...room,
|
||||
clientEmitter: client,
|
||||
roomEmitter: room,
|
||||
} as unknown as CallMatrixBackend
|
||||
}
|
||||
isPasswordlessUser={false}
|
||||
confineToRoom={false}
|
||||
preload={options.preload ?? false}
|
||||
// Straight into the (mocked) call, past the lobby
|
||||
skipLobby
|
||||
rtcSession={rtcSession.asMockedSession()}
|
||||
/>
|
||||
</BackgroundEffectsProvider>
|
||||
</MediaDevicesContext>
|
||||
</TooltipProvider>
|
||||
@@ -371,52 +361,28 @@ test.skip("CallView shows errors that occur during joining", async () => {
|
||||
screen.getByText("Call is not supported");
|
||||
});
|
||||
|
||||
test("translates wrapped UnsupportedStickyEventsEndpointError to the StickyEventsRequiredError screen", async () => {
|
||||
// Mirror the shape the SDK emits: the MembershipManager scheduler wraps
|
||||
// the original UnsupportedStickyEventsEndpointError in a generic Error
|
||||
// but preserves the original on `.cause`.
|
||||
const stickyError = new UnsupportedStickyEventsEndpointError(
|
||||
"Server does not support the sticky events",
|
||||
"sendStickyEvent",
|
||||
test("user can reconnect after losing the connection", async () => {
|
||||
// What the call throws once the view model reports the connection lost
|
||||
(ActiveCall as MockedFunction<typeof ActiveCall>).mockImplementation(
|
||||
({ onLeft }) => {
|
||||
const [error, setError] = useState<Error | null>(null);
|
||||
if (error !== null) throw error;
|
||||
return (
|
||||
<div>
|
||||
<button onClick={() => onLeft("user")}>Leave</button>
|
||||
<button onClick={() => setError(new ConnectionLostError())}>
|
||||
LoseConnection
|
||||
</button>
|
||||
</div>
|
||||
);
|
||||
},
|
||||
);
|
||||
const wrappedError = new Error(
|
||||
"The MembershipManager shut down because of the end condition: " +
|
||||
String(stickyError),
|
||||
{ cause: stickyError },
|
||||
);
|
||||
|
||||
const { rtcSession } = createCallView(nullHostBridge, true, {
|
||||
withErrorBoundary: true,
|
||||
});
|
||||
|
||||
await act(() =>
|
||||
rtcSession.emit(MatrixRTCSessionEvent.MembershipManagerError, wrappedError),
|
||||
);
|
||||
|
||||
await screen.findByText("Homeserver does not support Matrix 2.0 calls");
|
||||
});
|
||||
|
||||
test("falls back to ConnectionLostError for unrecognised membership manager errors", async () => {
|
||||
const { rtcSession } = createCallView(nullHostBridge, true, {
|
||||
withErrorBoundary: true,
|
||||
});
|
||||
|
||||
await act(() =>
|
||||
rtcSession.emit(
|
||||
MatrixRTCSessionEvent.MembershipManagerError,
|
||||
new Error("something else broke"),
|
||||
),
|
||||
);
|
||||
|
||||
await screen.findByText("Connection lost");
|
||||
});
|
||||
|
||||
test("user can reconnect after a membership manager error", async () => {
|
||||
const user = userEvent.setup();
|
||||
const { rtcSession } = createCallView(nullHostBridge, true);
|
||||
await act(() =>
|
||||
rtcSession.emit(MatrixRTCSessionEvent.MembershipManagerError, undefined),
|
||||
);
|
||||
createCallView(nullHostBridge, true);
|
||||
await user.click(screen.getByRole("button", { name: "LoseConnection" }));
|
||||
await screen.findByText("Connection lost");
|
||||
// Never joined, so there was no call to leave
|
||||
expect(playSound).not.toHaveBeenCalled();
|
||||
// XXX: Wrapping the following click in act() shouldn't be necessary (the
|
||||
// async state update should be processed automatically by the waitFor call),
|
||||
// and yet here we are.
|
||||
|
||||
+182
-101
@@ -13,21 +13,24 @@ import {
|
||||
useMemo,
|
||||
useState,
|
||||
} from "react";
|
||||
import {
|
||||
type MatrixClient,
|
||||
JoinRule,
|
||||
type Room,
|
||||
UnsupportedStickyEventsEndpointError,
|
||||
} from "matrix-js-sdk";
|
||||
import { type MatrixClient, JoinRule, type Room } from "matrix-js-sdk";
|
||||
import {
|
||||
Room as LivekitRoom,
|
||||
isE2EESupported as isE2EESupportedBrowser,
|
||||
} from "livekit-client";
|
||||
import { logger } from "matrix-js-sdk/lib/logger";
|
||||
import {
|
||||
MatrixRTCSessionEvent,
|
||||
type MatrixRTCSession,
|
||||
type Statistics,
|
||||
} from "matrix-js-sdk/lib/matrixrtc";
|
||||
import { type Observable } from "rxjs";
|
||||
import {
|
||||
createRTCSlot,
|
||||
type EncryptionSystem,
|
||||
MembershipManagerError as RTCMembershipManagerError,
|
||||
type RTCSlot,
|
||||
withEmitter,
|
||||
} from "@element-hq/matrixrtc-sdk";
|
||||
|
||||
import { type JoinCallData } from "../widget";
|
||||
import { LobbyView } from "./LobbyView";
|
||||
@@ -39,7 +42,6 @@ import { findDeviceByName } from "../utils/media";
|
||||
import { ActiveCall } from "./InCallView";
|
||||
import { type MuteStates } from "../state/MuteStates";
|
||||
import { useMediaDevices } from "../MediaDevicesContext";
|
||||
import { useMatrixRTCSessionMemberships } from "../useMatrixRTCSessionMemberships";
|
||||
import {
|
||||
saveKeyForRoom,
|
||||
useRoomEncryptionSystem,
|
||||
@@ -57,14 +59,11 @@ import {
|
||||
} from "./CallEventAudioRenderer";
|
||||
import { useLatest } from "../useLatest";
|
||||
import {
|
||||
ConnectionLostError,
|
||||
E2EENotSupportedError,
|
||||
ElementCallError,
|
||||
StickyEventsRequiredError,
|
||||
UnknownCallError,
|
||||
} from "../utils/errors.ts";
|
||||
import { GroupCallErrorBoundary } from "./GroupCallErrorBoundary.tsx";
|
||||
import { useTypedEventEmitter } from "../useEvents";
|
||||
import { muteAllAudio$ } from "../state/MuteAllAudioModel.ts";
|
||||
import { useAppBarTitle } from "../AppBar.tsx";
|
||||
import { useBehavior } from "../useBehavior.ts";
|
||||
@@ -73,6 +72,9 @@ import { useHostBridge } from "../HostBridge.ts";
|
||||
import { useMuteStates } from "../state/useMuteStates.ts";
|
||||
import { useLeaveToHome } from "../LeaveToHomeContext.ts";
|
||||
import { useLocalMedia } from "../useLocalMedia.ts";
|
||||
import { ObservableScope } from "../state/ObservableScope.ts";
|
||||
import { type CallNotificationWrapper } from "../state/CallViewModel/CallNotificationLifecycle.ts";
|
||||
import { type CallMatrixBackend } from "../CallMatrixBackend.ts";
|
||||
|
||||
/**
|
||||
* If there already are this many participants in the call, we automatically mute
|
||||
@@ -80,17 +82,19 @@ import { useLocalMedia } from "../useLocalMedia.ts";
|
||||
*/
|
||||
export const MUTE_PARTICIPANT_COUNT = 8;
|
||||
|
||||
declare global {
|
||||
interface Window {
|
||||
rtcSession?: MatrixRTCSession;
|
||||
}
|
||||
}
|
||||
|
||||
interface Props {
|
||||
/** The client to place the call with. */
|
||||
client: MatrixClient;
|
||||
/** The call to join. */
|
||||
rtcSession: MatrixRTCSession;
|
||||
/** The client and room to place the call with and in. */
|
||||
backend: CallMatrixBackend;
|
||||
/**
|
||||
* The call to join, which the RTC slot is built on.
|
||||
* Passing undefined -> the SDK will create a inner RTCSession (or in the future a rust equivalent)
|
||||
* @deprecated: It should not get its rtcSession from here.
|
||||
* The goal is that the RTC session is fully encapsulated inside the SDK (`createRTCSlot`)
|
||||
* We keep this as a fallback for the SPA. In that mode we currently expect to manage Our
|
||||
* own rtcSession with `useLoadGroupCall`. This is an open TODO. Until then we have this
|
||||
* alternative.
|
||||
*/
|
||||
rtcSession?: MatrixRTCSession;
|
||||
/**
|
||||
* Whether the user is signed in as a guest, and so should be offered the
|
||||
* chance to create an account when the call ends.
|
||||
@@ -121,18 +125,58 @@ interface Props {
|
||||
* whatever is hosting it — the standalone app's own shell, or an application
|
||||
* embedding Element Call as a component. Both render this.
|
||||
*/
|
||||
export const CallView: FC<Props> = (props): ReactNode => {
|
||||
export const CallView: FC<Props> = ({
|
||||
backend,
|
||||
rtcSession: externalRtcSession,
|
||||
...props
|
||||
}): ReactNode => {
|
||||
// STOP GAP: what is below is still written against a client and a room.
|
||||
// Both are refactored along with the backend.
|
||||
const client = useMemo(
|
||||
() => withEmitter(backend, backend.clientEmitter),
|
||||
[backend],
|
||||
);
|
||||
const room = useMemo(
|
||||
() => withEmitter(backend, backend.roomEmitter),
|
||||
[backend],
|
||||
);
|
||||
|
||||
// Whether the user is in the call is the call's own business, not its host's.
|
||||
// Held here rather than below so that it survives the mute state being
|
||||
// rebuilt.
|
||||
const [joined, setJoined] = useState(false);
|
||||
const muteStates = useMuteStates();
|
||||
const e2eeSystem = useRoomEncryptionSystem(backend.roomId);
|
||||
|
||||
if (muteStates === null) return null;
|
||||
// One slot for every join of this call: leaving and joining again, to
|
||||
// reconnect or from the lobby, happens on the same one
|
||||
const [slot, setSlot] = useState<ReturnType<typeof createRTCSlot> | null>(
|
||||
null,
|
||||
);
|
||||
useEffect(() => {
|
||||
const scope = new ObservableScope();
|
||||
setSlot(
|
||||
createRTCSlot(
|
||||
scope,
|
||||
backend,
|
||||
{ encryptionSystem: e2eeSystem },
|
||||
externalRtcSession,
|
||||
),
|
||||
);
|
||||
return (): void => scope.end();
|
||||
}, [backend, e2eeSystem, externalRtcSession]);
|
||||
|
||||
if (muteStates === null || slot === null) return null;
|
||||
|
||||
return (
|
||||
<LoadedCallView
|
||||
{...props}
|
||||
client={client}
|
||||
room={room}
|
||||
sentCallNotification$={slot.sentCallNotification$}
|
||||
statistics={slot.statistics}
|
||||
slot={slot}
|
||||
e2eeSystem={e2eeSystem}
|
||||
joined={joined}
|
||||
setJoined={setJoined}
|
||||
muteStates={muteStates}
|
||||
@@ -140,20 +184,98 @@ export const CallView: FC<Props> = (props): ReactNode => {
|
||||
);
|
||||
};
|
||||
|
||||
interface LoadedProps extends Props {
|
||||
// Here we do not pass the rtcSession anymore. This is a huge step!!
|
||||
// We only rely on our sdk abstraction (+ client and +room but only a
|
||||
// smaller list of callbacks.)
|
||||
interface LoadedProps extends Omit<Props, "rtcSession" | "backend"> {
|
||||
// Narrower than `Props.client`: the `slot` already has what only it and its
|
||||
// session need, `getRTCTransports`, `delegateDelayedLeave`, `baseUrl`,
|
||||
// `getSyncState`, `ClientEvent.Sync`, and the session's sending
|
||||
client: Pick<
|
||||
MatrixClient,
|
||||
| "getUserId"
|
||||
| "getDeviceId"
|
||||
| "getDomain"
|
||||
| "getOpenIdToken"
|
||||
| "getLivekitToken"
|
||||
| "sendEvent"
|
||||
| "redactEvent"
|
||||
| "decryptEventIfNeeded"
|
||||
| "getUser"
|
||||
| "setDisplayName"
|
||||
| "setAvatarUrl"
|
||||
| "uploadContent"
|
||||
| "doesServerSupportUnstableFeature"
|
||||
| "getCrypto"
|
||||
// `on`/`off`, to listen for `MatrixEventEvent.Decrypted` (reactions once
|
||||
// decrypted)
|
||||
| "on"
|
||||
| "off"
|
||||
>;
|
||||
// Narrower than `Props.room`: the `slot` already follows
|
||||
// `RoomStateEvent.Events` for its status, `RoomStateEvent.Members` for its
|
||||
// own members, and the timeline its session reads the memberships from
|
||||
room: Pick<
|
||||
Room,
|
||||
| "roomId"
|
||||
| "name"
|
||||
| "getMxcAvatarUrl"
|
||||
| "getJoinRule"
|
||||
| "getMembersWithMembership"
|
||||
| "_unstable_getStickyEvents"
|
||||
| "relations"
|
||||
// `on`/`off`, to listen for:
|
||||
// - `RoomEvent.Name` (room name)
|
||||
// - `RoomStateEvent.Update` and `RoomEvent.CurrentStateUpdated` (avatar
|
||||
// and join rule hooks)
|
||||
// - `RoomStateEvent.Members` (call view model members)
|
||||
// - `RoomEvent.Timeline` and `RoomStickyEventsEvent.Update` (call notifications)
|
||||
// - `RoomEvent.Timeline`, `RoomEvent.Redaction` and
|
||||
// `RoomEvent.LocalEchoUpdated` (reactions and raised hands)
|
||||
| "on"
|
||||
| "off"
|
||||
>;
|
||||
/**
|
||||
* The call notifications the session sends with our join, so the call can
|
||||
* show it ringing: the slot's `sentCallNotification$`.
|
||||
*/
|
||||
sentCallNotification$: Observable<CallNotificationWrapper>;
|
||||
/** The session's media key statistics, reported when the call ends. */
|
||||
statistics: Statistics;
|
||||
slot: RTCSlot;
|
||||
e2eeSystem: EncryptionSystem;
|
||||
joined: boolean;
|
||||
setJoined: (value: boolean) => void;
|
||||
muteStates: MuteStates;
|
||||
}
|
||||
|
||||
/** {@link CallView}, once it has the mute state everything below needs. */
|
||||
/**
|
||||
* Whether our membership is live in the slot: seen in the room, and not taken
|
||||
* down by the membership manager stopping. Leaving the call only makes sense
|
||||
* then; an error before the join, or one that ended the membership, leaves
|
||||
* nothing to leave.
|
||||
*/
|
||||
function isInCall(slot: RTCSlot): boolean {
|
||||
const participation = slot.participation$.value;
|
||||
if (participation?.localMember$.value == null) return false;
|
||||
const state = participation.state$.value;
|
||||
return !(
|
||||
state.kind === "failed" && state.error instanceof RTCMembershipManagerError
|
||||
);
|
||||
}
|
||||
|
||||
/** {@link CallView}, once it has the slot and mute state everything below needs. */
|
||||
const LoadedCallView: FC<LoadedProps> = ({
|
||||
client,
|
||||
room,
|
||||
isPasswordlessUser,
|
||||
confineToRoom,
|
||||
preload,
|
||||
skipLobby,
|
||||
rtcSession,
|
||||
slot,
|
||||
sentCallNotification$,
|
||||
statistics,
|
||||
e2eeSystem,
|
||||
joined,
|
||||
setJoined,
|
||||
muteStates,
|
||||
@@ -162,7 +284,7 @@ const LoadedCallView: FC<LoadedProps> = ({
|
||||
const [externalError, setExternalError] = useState<ElementCallError | null>(
|
||||
null,
|
||||
);
|
||||
const memberships = useMatrixRTCSessionMemberships(rtcSession);
|
||||
const members = useBehavior(slot.members$);
|
||||
const rootElement = useRootElement();
|
||||
const hostBridge = useHostBridge();
|
||||
// A host that can close us is a host that decides when we stop existing, so
|
||||
@@ -181,7 +303,7 @@ const LoadedCallView: FC<LoadedProps> = ({
|
||||
);
|
||||
// This should use `useEffectEvent` (only available in experimental versions)
|
||||
useEffect(() => {
|
||||
if (memberships.length >= MUTE_PARTICIPANT_COUNT)
|
||||
if (members.length >= MUTE_PARTICIPANT_COUNT)
|
||||
muteStates.audio.setEnabled$.value?.(false);
|
||||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||||
}, []);
|
||||
@@ -203,48 +325,10 @@ const LoadedCallView: FC<LoadedProps> = ({
|
||||
};
|
||||
}, [rootElement]);
|
||||
|
||||
useEffect(() => {
|
||||
window.rtcSession = rtcSession;
|
||||
return (): void => {
|
||||
delete window.rtcSession;
|
||||
};
|
||||
}, [rtcSession]);
|
||||
|
||||
// TODO move this into the callViewModel LocalMembership.ts
|
||||
// We might actually not need this at all. Since we get into fatalError on those errors already?
|
||||
useTypedEventEmitter(
|
||||
rtcSession,
|
||||
MatrixRTCSessionEvent.MembershipManagerError,
|
||||
(error) => {
|
||||
// When matrix_rtc_mode=matrix_2_0 is in effect but the homeserver does
|
||||
// not advertise MSC4354 (sticky events), the SDK throws an
|
||||
// `UnsupportedStickyEventsEndpointError`. The MembershipManager
|
||||
// scheduler wraps it and exposes the original via `.cause`.
|
||||
if (
|
||||
error instanceof Error &&
|
||||
error.cause instanceof UnsupportedStickyEventsEndpointError
|
||||
) {
|
||||
setExternalError(new StickyEventsRequiredError());
|
||||
} else {
|
||||
setExternalError(new ConnectionLostError());
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
useEffect(() => {
|
||||
// Sanity check the room object
|
||||
if (client.getRoom(rtcSession.room.roomId) !== rtcSession.room)
|
||||
logger.warn(
|
||||
`We've ended up with multiple rooms for the same ID (${rtcSession.room.roomId}). This indicates a bug in the group call loading code, and may lead to incomplete room state.`,
|
||||
);
|
||||
}, [client, rtcSession.room]);
|
||||
|
||||
const room = rtcSession.room as Room;
|
||||
const { displayName, avatarUrl } = useProfile(client);
|
||||
const roomName = useRoomName(room);
|
||||
const roomAvatar = useRoomAvatar(room);
|
||||
const { returnToLobby, password: passwordFromUrl, header } = useUrlParams();
|
||||
const e2eeSystem = useRoomEncryptionSystem(room.roomId);
|
||||
|
||||
// Save the password once we start the groupCallView
|
||||
useEffect(() => {
|
||||
@@ -260,7 +344,6 @@ const LoadedCallView: FC<LoadedProps> = ({
|
||||
avatarUrl: avatarUrl!,
|
||||
roomId: room.roomId,
|
||||
roomName,
|
||||
roomAlias: room.getCanonicalAlias(),
|
||||
roomAvatar,
|
||||
e2eeSystem,
|
||||
};
|
||||
@@ -268,8 +351,8 @@ const LoadedCallView: FC<LoadedProps> = ({
|
||||
|
||||
// Count each member only once, regardless of how many devices they use
|
||||
const participantCount = useMemo(
|
||||
() => new Set<string>(memberships.map((m) => m.userId!)).size,
|
||||
[memberships],
|
||||
() => new Set<string>(members.map((m) => m.userId)).size,
|
||||
[members],
|
||||
);
|
||||
|
||||
const mediaDevices = useMediaDevices();
|
||||
@@ -277,27 +360,24 @@ const LoadedCallView: FC<LoadedProps> = ({
|
||||
// Opened by the lobby, published by the call: one capture for both
|
||||
const media = useLocalMedia();
|
||||
|
||||
const enterRTCSessionOrError = useCallback(
|
||||
async (rtcSession: MatrixRTCSession): Promise<void> => {
|
||||
try {
|
||||
setJoined(true);
|
||||
// TODO-MULTI-SFU what to do with error handling now that we don't use this function?
|
||||
// @BillCarsonFr
|
||||
} catch (e) {
|
||||
if (e instanceof ElementCallError) {
|
||||
setExternalError(e);
|
||||
} else {
|
||||
logger.error(`Unknown Error while entering RTC session`, e);
|
||||
const error = new UnknownCallError(
|
||||
e instanceof Error ? e : new Error("Unknown error", { cause: e }),
|
||||
);
|
||||
setExternalError(error);
|
||||
}
|
||||
const enterRTCSessionOrError = useCallback(async (): Promise<void> => {
|
||||
try {
|
||||
setJoined(true);
|
||||
// TODO-MULTI-SFU what to do with error handling now that we don't use this function?
|
||||
// @BillCarsonFr
|
||||
} catch (e) {
|
||||
if (e instanceof ElementCallError) {
|
||||
setExternalError(e);
|
||||
} else {
|
||||
logger.error(`Unknown Error while entering RTC session`, e);
|
||||
const error = new UnknownCallError(
|
||||
e instanceof Error ? e : new Error("Unknown error", { cause: e }),
|
||||
);
|
||||
setExternalError(error);
|
||||
}
|
||||
return Promise.resolve();
|
||||
},
|
||||
[setJoined],
|
||||
);
|
||||
}
|
||||
return Promise.resolve();
|
||||
}, [setJoined]);
|
||||
|
||||
useEffect(() => {
|
||||
const defaultDeviceSetup = async ({
|
||||
@@ -360,7 +440,6 @@ const LoadedCallView: FC<LoadedProps> = ({
|
||||
}
|
||||
}, [
|
||||
hostBridge,
|
||||
rtcSession,
|
||||
preload,
|
||||
skipLobby,
|
||||
mediaDevices,
|
||||
@@ -407,9 +486,9 @@ const LoadedCallView: FC<LoadedProps> = ({
|
||||
const sendInstantly = hostControlsLifetime;
|
||||
PosthogAnalytics.instance.eventCallEnded.track(
|
||||
room.roomId,
|
||||
rtcSession.memberships.length,
|
||||
slot.members$.value.length,
|
||||
sendInstantly,
|
||||
rtcSession,
|
||||
statistics,
|
||||
);
|
||||
// Unfortunately the PostHog library provides no way to await the
|
||||
// tracking of an event, but we don't really want it to hold up our
|
||||
@@ -455,7 +534,8 @@ const LoadedCallView: FC<LoadedProps> = ({
|
||||
hostBridge,
|
||||
hostControlsLifetime,
|
||||
room.roomId,
|
||||
rtcSession,
|
||||
slot,
|
||||
statistics,
|
||||
isPasswordlessUser,
|
||||
confineToRoom,
|
||||
returnToLobby,
|
||||
@@ -469,7 +549,7 @@ const LoadedCallView: FC<LoadedProps> = ({
|
||||
hostBridge.setAlwaysOnScreen(true).catch((e) => {
|
||||
logger.error("Error calling setAlwaysOnScreen(true)", e);
|
||||
});
|
||||
}, [hostBridge, joined, rtcSession]);
|
||||
}, [hostBridge, joined]);
|
||||
|
||||
const joinRule = useJoinRule(room);
|
||||
|
||||
@@ -530,7 +610,8 @@ const LoadedCallView: FC<LoadedProps> = ({
|
||||
<ActiveCall
|
||||
client={client}
|
||||
matrixInfo={matrixInfo}
|
||||
rtcSession={rtcSession as MatrixRTCSession}
|
||||
slot={slot}
|
||||
sentCallNotification$={sentCallNotification$}
|
||||
matrixRoom={room}
|
||||
onLeft={onLeft}
|
||||
media={media}
|
||||
@@ -553,7 +634,7 @@ const LoadedCallView: FC<LoadedProps> = ({
|
||||
if (isPasswordlessUser || PosthogAnalytics.instance.isEnabled()) {
|
||||
body = (
|
||||
<CallEndedView
|
||||
endedCallId={rtcSession.room.roomId}
|
||||
endedCallId={room.roomId}
|
||||
client={client}
|
||||
isPasswordlessUser={isPasswordlessUser}
|
||||
hideHeader={header === HeaderStyle.None}
|
||||
@@ -570,7 +651,7 @@ const LoadedCallView: FC<LoadedProps> = ({
|
||||
// Left, and the host decides what happens next:
|
||||
body = returnToLobby ? lobbyView : null;
|
||||
} else if (preload || skipLobby) {
|
||||
// The RTC session is not joined to yet (`isJoined`), but enterRTCSessionOrError should have been called.
|
||||
// Not in the call yet: waiting for the host to say when, or about to join
|
||||
body = null;
|
||||
} else {
|
||||
body = lobbyView;
|
||||
@@ -582,16 +663,16 @@ const LoadedCallView: FC<LoadedProps> = ({
|
||||
setExternalError(null);
|
||||
if (action == "reconnect") {
|
||||
setLeft(false);
|
||||
await enterRTCSessionOrError(rtcSession).catch((e) => {
|
||||
await enterRTCSessionOrError().catch((e) => {
|
||||
logger.error("Error re-entering RTC session", e);
|
||||
});
|
||||
}
|
||||
}}
|
||||
onError={(_error) => {
|
||||
if (rtcSession.isJoined()) onLeft("error");
|
||||
if (isInCall(slot)) onLeft("error");
|
||||
// If there is an error we need to be dismissible again. This is done in
|
||||
// `onLeft` as well; we need it here explicitly in case
|
||||
// rtcSession.isJoined is false.
|
||||
// `onLeft` as well; we need it here explicitly in case we were not in
|
||||
// the call.
|
||||
void hostBridge.setAlwaysOnScreen(false);
|
||||
}}
|
||||
>
|
||||
|
||||
@@ -15,7 +15,7 @@ import {
|
||||
vi,
|
||||
} from "vitest";
|
||||
import { act, render, type RenderResult } from "@testing-library/react";
|
||||
import { BehaviorSubject } from "rxjs";
|
||||
import { BehaviorSubject, NEVER } from "rxjs";
|
||||
import { BrowserRouter } from "react-router-dom";
|
||||
import { TooltipProvider } from "@vector-im/compound-web";
|
||||
import userEvent from "@testing-library/user-event";
|
||||
@@ -25,7 +25,6 @@ import {
|
||||
mockMediaDevices,
|
||||
mockMuteStates,
|
||||
mockRtcMembership,
|
||||
type MockRTCSession,
|
||||
mockRTCSlot,
|
||||
mockRTCMember,
|
||||
testScope,
|
||||
@@ -44,7 +43,7 @@ import { ReactionsSenderProvider } from "../reactions/useReactionsSender";
|
||||
import { useRoomEncryptionSystem } from "../e2ee/sharedKeyManagement";
|
||||
import { MemberAudioRenderer } from "../tracks/MemberAudioRenderer";
|
||||
import type * as MatrixRTCSdk from "@element-hq/matrixrtc-sdk";
|
||||
import { constant, type ObservableScope } from "@element-hq/matrixrtc-sdk";
|
||||
import { constant, type RTCSlot } from "@element-hq/matrixrtc-sdk";
|
||||
import { MediaDevicesContext } from "../MediaDevicesContext";
|
||||
import { type MediaDevices as ECMediaDevices } from "../state/MediaDevices";
|
||||
import { AppBar } from "../AppBar";
|
||||
@@ -73,12 +72,6 @@ vi.mock("../tile/GridTile");
|
||||
vi.mock("../tile/SpotlightTile");
|
||||
vi.mock("../e2ee/sharedKeyManagement");
|
||||
vi.mock("../tracks/MemberAudioRenderer");
|
||||
// ActiveCall builds the slot itself; the view is what these tests are about
|
||||
const createRTCSlotMock = vi.hoisted(() => vi.fn());
|
||||
vi.mock("@element-hq/matrixrtc-sdk", async (importOriginal) => ({
|
||||
...(await importOriginal<typeof MatrixRTCSdk>()),
|
||||
createRTCSlot: createRTCSlotMock,
|
||||
}));
|
||||
vi.mock("react-use-measure", () => ({
|
||||
default: (): [() => void, object] => [(): void => {}, {}],
|
||||
}));
|
||||
@@ -91,32 +84,33 @@ const matrixInfo = {
|
||||
avatarUrl: "",
|
||||
roomId: "",
|
||||
roomName: "",
|
||||
roomAlias: null,
|
||||
roomAvatar: null,
|
||||
e2eeSystem: { kind: E2eeType.NONE },
|
||||
} satisfies MatrixInfo;
|
||||
|
||||
let useRoomEncryptionSystemMock: MockedFunction<typeof useRoomEncryptionSystem>;
|
||||
|
||||
// The view is what these tests are about, so the slot is a stand-in
|
||||
function mockSlot(): RTCSlot {
|
||||
return mockRTCSlot(testScope(), {
|
||||
localMember$: constant(
|
||||
mockRTCMember(true, {
|
||||
membership: localRtcMember,
|
||||
tracks$: constant([]),
|
||||
}),
|
||||
),
|
||||
remoteMembers$: constant([
|
||||
mockRTCMember(false, {
|
||||
membership: aliceRtcMember,
|
||||
tracks$: constant([]),
|
||||
}),
|
||||
]),
|
||||
});
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
|
||||
createRTCSlotMock.mockImplementation((scope: ObservableScope) =>
|
||||
mockRTCSlot(scope, {
|
||||
localMember$: constant(
|
||||
mockRTCMember(true, {
|
||||
membership: localRtcMember,
|
||||
tracks$: constant([]),
|
||||
}),
|
||||
),
|
||||
remoteMembers$: constant([
|
||||
mockRTCMember(false, {
|
||||
membership: aliceRtcMember,
|
||||
tracks$: constant([]),
|
||||
}),
|
||||
]),
|
||||
}),
|
||||
);
|
||||
// MemberAudioRenderer is tested separately.
|
||||
(
|
||||
MemberAudioRenderer as MockedFunction<typeof MemberAudioRenderer>
|
||||
@@ -132,12 +126,11 @@ interface CreateInCallViewArgs {
|
||||
withAppBar?: boolean;
|
||||
}
|
||||
function createInCallView(args: CreateInCallViewArgs = {}): RenderResult & {
|
||||
rtcSession: MockRTCSession;
|
||||
vm: CallViewModel;
|
||||
} {
|
||||
const mediaDevices = args.mediaDevices ?? mockMediaDevices({});
|
||||
const muteState = mockMuteStates();
|
||||
const { vm, footerVm, developerSettingsVm, rtcSession } =
|
||||
const { vm, footerVm, developerSettingsVm, matrixRoom, client } =
|
||||
getBasicCallViewModelEnvironment(
|
||||
[local, alice],
|
||||
undefined,
|
||||
@@ -145,20 +138,15 @@ function createInCallView(args: CreateInCallViewArgs = {}): RenderResult & {
|
||||
args.callViewModelOptions,
|
||||
);
|
||||
|
||||
rtcSession.joined = true;
|
||||
const room = rtcSession.room;
|
||||
const client = room.client;
|
||||
|
||||
const inCallView = (
|
||||
<InCallView
|
||||
client={client}
|
||||
rtcSession={rtcSession.asMockedSession()}
|
||||
muteStates={muteState}
|
||||
vm={vm}
|
||||
footerVm={footerVm}
|
||||
developerSettingsVm={developerSettingsVm}
|
||||
matrixInfo={matrixInfo}
|
||||
matrixRoom={room}
|
||||
matrixRoom={matrixRoom}
|
||||
onShareClick={null}
|
||||
/>
|
||||
);
|
||||
@@ -168,10 +156,7 @@ function createInCallView(args: CreateInCallViewArgs = {}): RenderResult & {
|
||||
const renderResult = render(
|
||||
<BrowserRouter>
|
||||
<MediaDevicesContext value={mediaDevices}>
|
||||
<ReactionsSenderProvider
|
||||
vm={vm}
|
||||
rtcSession={rtcSession.asMockedSession()}
|
||||
>
|
||||
<ReactionsSenderProvider vm={vm} room={matrixRoom} client={client}>
|
||||
<TooltipProvider>{content}</TooltipProvider>
|
||||
</ReactionsSenderProvider>
|
||||
</MediaDevicesContext>
|
||||
@@ -179,7 +164,6 @@ function createInCallView(args: CreateInCallViewArgs = {}): RenderResult & {
|
||||
);
|
||||
return {
|
||||
...renderResult,
|
||||
rtcSession,
|
||||
vm,
|
||||
};
|
||||
}
|
||||
@@ -243,37 +227,53 @@ function fakeLocalMedia(): MatrixRTCSdk.LocalMedia {
|
||||
};
|
||||
}
|
||||
|
||||
function renderActiveCall(slot: RTCSlot): RenderResult {
|
||||
const { matrixRoom } = getBasicRTCSession([local, alice]);
|
||||
return render(
|
||||
<BrowserRouter>
|
||||
<MediaDevicesContext value={mockMediaDevices({})}>
|
||||
<BackgroundEffectsProvider
|
||||
effects={createAppBackgroundEffects(testScope())}
|
||||
>
|
||||
<TooltipProvider>
|
||||
<ActiveCall
|
||||
client={matrixRoom.client}
|
||||
slot={slot}
|
||||
sentCallNotification$={NEVER}
|
||||
matrixRoom={matrixRoom}
|
||||
muteStates={mockMuteStates()}
|
||||
matrixInfo={matrixInfo}
|
||||
onShareClick={null}
|
||||
e2eeSystem={{ kind: E2eeType.NONE }}
|
||||
media={fakeLocalMedia()}
|
||||
onLeft={(): void => {}}
|
||||
/>
|
||||
</TooltipProvider>
|
||||
</BackgroundEffectsProvider>
|
||||
</MediaDevicesContext>
|
||||
</BrowserRouter>,
|
||||
);
|
||||
}
|
||||
|
||||
describe("ActiveCall", () => {
|
||||
it("creates the view models and renders the call", async () => {
|
||||
const mediaDevices = mockMediaDevices({});
|
||||
const { rtcSession, matrixRoom } = getBasicRTCSession([local, alice]);
|
||||
const { findByTestId } = render(
|
||||
<BrowserRouter>
|
||||
<MediaDevicesContext value={mediaDevices}>
|
||||
<BackgroundEffectsProvider
|
||||
effects={createAppBackgroundEffects(testScope())}
|
||||
>
|
||||
<TooltipProvider>
|
||||
<ActiveCall
|
||||
client={matrixRoom.client}
|
||||
rtcSession={rtcSession.asMockedSession()}
|
||||
matrixRoom={matrixRoom}
|
||||
muteStates={mockMuteStates()}
|
||||
matrixInfo={matrixInfo}
|
||||
onShareClick={null}
|
||||
e2eeSystem={{ kind: E2eeType.NONE }}
|
||||
media={fakeLocalMedia()}
|
||||
onLeft={(): void => {}}
|
||||
/>
|
||||
</TooltipProvider>
|
||||
</BackgroundEffectsProvider>
|
||||
</MediaDevicesContext>
|
||||
</BrowserRouter>,
|
||||
);
|
||||
const { findByTestId } = renderActiveCall(mockSlot());
|
||||
// Rendering at all proves ActiveCall created all of its view models
|
||||
expect(await findByTestId("incall_leave")).toBeVisible();
|
||||
});
|
||||
|
||||
it("leaves the slot once gone, so that the next call can join it", async () => {
|
||||
const slot = mockSlot();
|
||||
const { findByTestId, unmount } = renderActiveCall(slot);
|
||||
await findByTestId("incall_leave");
|
||||
expect(slot.join).toHaveBeenCalled();
|
||||
const participation = slot.participation$.value!;
|
||||
expect(participation.leave).not.toHaveBeenCalled();
|
||||
|
||||
unmount();
|
||||
expect(participation.leave).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("lays the call out for the size of its root element", async () => {
|
||||
// jsdom has no layout and no ResizeObserver: the root reports whatever
|
||||
// size we say, and the observer notifies whenever we tell it to
|
||||
@@ -296,7 +296,7 @@ describe("ActiveCall", () => {
|
||||
|
||||
try {
|
||||
const mediaDevices = mockMediaDevices({});
|
||||
const { rtcSession, matrixRoom } = getBasicRTCSession([local, alice]);
|
||||
const { matrixRoom } = getBasicRTCSession([local, alice]);
|
||||
const { findByTestId, container } = render(
|
||||
<BrowserRouter>
|
||||
<RootElementProvider value={root}>
|
||||
@@ -307,7 +307,8 @@ describe("ActiveCall", () => {
|
||||
<TooltipProvider>
|
||||
<ActiveCall
|
||||
client={matrixRoom.client}
|
||||
rtcSession={rtcSession.asMockedSession()}
|
||||
slot={mockSlot()}
|
||||
sentCallNotification$={NEVER}
|
||||
matrixRoom={matrixRoom}
|
||||
muteStates={mockMuteStates()}
|
||||
matrixInfo={matrixInfo}
|
||||
|
||||
+88
-35
@@ -18,7 +18,7 @@ import {
|
||||
type ReactNode,
|
||||
} from "react";
|
||||
import useMeasure from "react-use-measure";
|
||||
import { type MatrixRTCSession } from "matrix-js-sdk/lib/matrixrtc";
|
||||
import { type Observable } from "rxjs";
|
||||
import classNames from "classnames";
|
||||
import { logger as rootLogger } from "matrix-js-sdk/lib/logger";
|
||||
import { useTranslation } from "react-i18next";
|
||||
@@ -31,7 +31,11 @@ import { useRootElement } from "../RootElementContext";
|
||||
import { observeElementSize$ } from "../utils/elementSize";
|
||||
import styles from "./InCallView.module.css";
|
||||
import { GridTile } from "../tile/GridTile";
|
||||
import { SettingsModal, defaultSettingsTab } from "../settings/SettingsModal";
|
||||
import {
|
||||
SettingsModal,
|
||||
type SettingsClientParts,
|
||||
defaultSettingsTab,
|
||||
} from "../settings/SettingsModal";
|
||||
import { useRageshakeRequestModal } from "../settings/submit-rageshake";
|
||||
import { RageshakeRequestModal } from "./RageshakeRequestModal";
|
||||
import { useWakeLock } from "../useWakeLock";
|
||||
@@ -70,9 +74,8 @@ import { ReactionsAudioRenderer } from "./ReactionAudioRenderer";
|
||||
import { ReactionsOverlay } from "./ReactionsOverlay";
|
||||
import { CallEventAudioRenderer } from "./CallEventAudioRenderer";
|
||||
import {
|
||||
createRTCSlot,
|
||||
type RTCParticipationOptions,
|
||||
type RTCSlotOptions,
|
||||
type RTCSlot,
|
||||
constant,
|
||||
} from "@element-hq/matrixrtc-sdk";
|
||||
import {
|
||||
@@ -94,7 +97,10 @@ import {
|
||||
screenShareResolution,
|
||||
} from "../settings/settings";
|
||||
import { Config } from "../config/Config";
|
||||
import { createSentCallNotification$ } from "../state/CallViewModel/CallNotificationLifecycle.ts";
|
||||
import {
|
||||
type CallNotificationWrapper,
|
||||
createSentCallNotification$,
|
||||
} from "../state/CallViewModel/CallNotificationLifecycle.ts";
|
||||
import { ReactionsReader } from "../reactions/ReactionsReader";
|
||||
import { MemberAudioRenderer } from "../tracks/MemberAudioRenderer.tsx";
|
||||
import { muteAllAudio$ } from "../state/MuteAllAudioModel.ts";
|
||||
@@ -132,6 +138,56 @@ export interface ActiveCallProps extends Omit<
|
||||
InCallViewProps,
|
||||
"vm" | "footerVm" | "developerSettingsVm"
|
||||
> {
|
||||
client: Pick<
|
||||
MatrixClient,
|
||||
// Our own identity: call view model, footer, settings
|
||||
| "getUserId"
|
||||
| "getDeviceId"
|
||||
// Developer settings: the local transport and authenticating with it,
|
||||
// `getOpenIdToken` for the JWT service flow, `getLivekitToken` for the
|
||||
// client-server API flow (MSC4195)
|
||||
| "getDomain"
|
||||
| "getOpenIdToken"
|
||||
| "getLivekitToken"
|
||||
// Reactions and raised hands: sending, lowering, and decrypting
|
||||
| "sendEvent"
|
||||
| "redactEvent"
|
||||
| "decryptEventIfNeeded"
|
||||
// `on`/`off`, to listen for `MatrixEventEvent.Decrypted` (reactions once
|
||||
// decrypted)
|
||||
| "on"
|
||||
| "off"
|
||||
// Profile: display name and avatar, for the settings and the call ended view
|
||||
| "getUser"
|
||||
| "setDisplayName"
|
||||
| "setAvatarUrl"
|
||||
| "uploadContent"
|
||||
// Developer settings
|
||||
| "doesServerSupportUnstableFeature"
|
||||
| "getCrypto"
|
||||
>;
|
||||
matrixRoom: Pick<
|
||||
MatrixRoom,
|
||||
// Call view model and reactions
|
||||
| "roomId"
|
||||
// Joined and invited members, for the call view model
|
||||
| "getMembersWithMembership"
|
||||
// Call notifications, for the call view model
|
||||
| "_unstable_getStickyEvents"
|
||||
// Raised hands already in the room, for the reactions reader
|
||||
| "relations"
|
||||
// `on`/`off`, to listen for:
|
||||
// - `RoomStateEvent.Members` (call view model members)
|
||||
// - `RoomEvent.Timeline` and `RoomStickyEventsEvent.Update` (call notifications)
|
||||
// - `RoomEvent.Timeline`, `RoomEvent.Redaction` and
|
||||
// `RoomEvent.LocalEchoUpdated` (reactions and raised hands)
|
||||
| "on"
|
||||
| "off"
|
||||
>;
|
||||
/** The slot to join; the call leaves it again when it ends. */
|
||||
slot: RTCSlot;
|
||||
/** The call notifications sent with our join, so the call can show it ringing. */
|
||||
sentCallNotification$: Observable<CallNotificationWrapper>;
|
||||
e2eeSystem: EncryptionSystem;
|
||||
/** The tracks the lobby opened, for the join to publish. */
|
||||
media: LocalMedia;
|
||||
@@ -159,18 +215,17 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
|
||||
useEffect(() => {
|
||||
rootLogger.info("START CALL VIEW SCOPE");
|
||||
const scope = new ObservableScope();
|
||||
const reactionsReader = new ReactionsReader(scope, props.rtcSession);
|
||||
const reactionsReader = new ReactionsReader(
|
||||
scope,
|
||||
props.slot.members$,
|
||||
props.matrixRoom,
|
||||
props.client,
|
||||
);
|
||||
const { autoLeaveWhenOthersLeft, waitForCallPickup, sendNotificationType } =
|
||||
urlParams;
|
||||
|
||||
const capture = captureSettings();
|
||||
const slot = createRTCSlot(
|
||||
scope,
|
||||
props.client,
|
||||
props.matrixRoom,
|
||||
rtcSlotOptions(props.e2eeSystem),
|
||||
);
|
||||
const rtcParticipation = slot.join({
|
||||
const rtcParticipation = props.slot.join({
|
||||
...rtcParticipationOptions(urlParams),
|
||||
// Without a lobby nothing was captured and the join captures itself
|
||||
publish:
|
||||
@@ -189,6 +244,7 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
|
||||
{
|
||||
rtcParticipation,
|
||||
matrixRoom: props.matrixRoom,
|
||||
client: props.client,
|
||||
mediaDevices,
|
||||
muteStates: props.muteStates,
|
||||
encryptionSystem: props.e2eeSystem,
|
||||
@@ -205,7 +261,7 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
|
||||
waitForCallPickup: waitForCallPickup && sendNotificationType === "ring",
|
||||
sentCallNotification$: createSentCallNotification$(
|
||||
scope,
|
||||
props.rtcSession,
|
||||
props.sentCallNotification$,
|
||||
),
|
||||
},
|
||||
);
|
||||
@@ -214,10 +270,13 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
|
||||
vm.leave$.pipe(scope.bind()).subscribe(props.onLeft);
|
||||
|
||||
return (): void => {
|
||||
// The slot outlives the call, and joins again only once this has left
|
||||
rtcParticipation.leave();
|
||||
scope.end();
|
||||
};
|
||||
}, [
|
||||
props.rtcSession,
|
||||
props.slot,
|
||||
props.sentCallNotification$,
|
||||
props.matrixRoom,
|
||||
props.muteStates,
|
||||
props.e2eeSystem,
|
||||
@@ -251,7 +310,6 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
|
||||
scope.end();
|
||||
};
|
||||
}, [
|
||||
props.rtcSession,
|
||||
props.matrixRoom,
|
||||
props.muteStates,
|
||||
props.e2eeSystem,
|
||||
@@ -268,7 +326,11 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
|
||||
if (developerSettingsVm === null) return null;
|
||||
|
||||
return (
|
||||
<ReactionsSenderProvider vm={vm} rtcSession={props.rtcSession}>
|
||||
<ReactionsSenderProvider
|
||||
vm={vm}
|
||||
room={props.matrixRoom}
|
||||
client={props.client}
|
||||
>
|
||||
<InCallView
|
||||
{...props}
|
||||
vm={vm}
|
||||
@@ -280,13 +342,12 @@ export const ActiveCall: FC<ActiveCallProps> = (props) => {
|
||||
};
|
||||
|
||||
export interface InCallViewProps {
|
||||
client: MatrixClient;
|
||||
client: SettingsClientParts;
|
||||
vm: CallViewModel;
|
||||
footerVm: ViewModel<FooterSnapshot>;
|
||||
developerSettingsVm: ViewModel<DeveloperSettingsSnapshot>;
|
||||
matrixInfo: MatrixInfo;
|
||||
rtcSession: MatrixRTCSession;
|
||||
matrixRoom: MatrixRoom;
|
||||
matrixRoom: Pick<MatrixRoom, "roomId">;
|
||||
muteStates: MuteStates;
|
||||
onShareClick: (() => void) | null;
|
||||
}
|
||||
@@ -798,31 +859,23 @@ export function captureSettings(): CaptureSettings {
|
||||
}
|
||||
|
||||
/**
|
||||
* What the client needs from Element Call's configuration, settings and URL:
|
||||
* What the join needs from Element Call's configuration, settings and URL:
|
||||
* the SDK reads none of them itself. What to publish depends on the mute
|
||||
* switches and the devices, so the caller adds that. Shared with the legacy
|
||||
* SDK bundle so that a widget built from it behaves like the app.
|
||||
*/
|
||||
export function rtcSlotOptions(
|
||||
encryptionSystem: EncryptionSystem,
|
||||
): RTCSlotOptions {
|
||||
return {
|
||||
encryptionSystem,
|
||||
// matrix_rtc_mode in config.json overrides the user's Developer Settings
|
||||
// choice. We merely sample the current mode here, so the user would need
|
||||
// to manually rejoin to switch to a different one.
|
||||
matrixRTCMode:
|
||||
(Config.get().matrix_rtc_mode as MatrixRTCMode | undefined) ??
|
||||
matrixRTCModeSetting.value$.value,
|
||||
};
|
||||
}
|
||||
|
||||
export function rtcParticipationOptions(
|
||||
urlParams: ReturnType<typeof useUrlParams>,
|
||||
): Omit<RTCParticipationOptions, "publish"> {
|
||||
const config = Config.get();
|
||||
const session = config.matrix_rtc_session;
|
||||
return {
|
||||
// matrix_rtc_mode in config.json overrides the user's Developer Settings
|
||||
// choice. We merely sample the current mode here, so the user would need
|
||||
// to manually rejoin to switch to a different one.
|
||||
matrixRTCMode:
|
||||
(config.matrix_rtc_mode as MatrixRTCMode | undefined) ??
|
||||
matrixRTCModeSetting.value$.value,
|
||||
sendNotificationType: urlParams.sendNotificationType,
|
||||
callIntent: urlParams.callIntent,
|
||||
timings: {
|
||||
|
||||
@@ -29,7 +29,7 @@ import { useRoomEncryptionSystem } from "../e2ee/sharedKeyManagement";
|
||||
import { QrCode } from "../QrCode";
|
||||
|
||||
interface Props {
|
||||
room: Room;
|
||||
room: Pick<Room, "roomId" | "name">;
|
||||
open: boolean;
|
||||
onDismiss: () => void;
|
||||
}
|
||||
|
||||
@@ -71,7 +71,6 @@ export const KnockLobbyView: FC<Props> = ({
|
||||
userId: client.getUserId() ?? "",
|
||||
displayName: profile.displayName,
|
||||
avatarUrl: profile.avatarUrl,
|
||||
roomAlias: null,
|
||||
roomId: roomSummary.room_id,
|
||||
roomName: roomSummary.name ?? "",
|
||||
roomAvatar: roomSummary.avatar_url ?? null,
|
||||
|
||||
@@ -91,7 +91,6 @@ const matrixInfo = {
|
||||
avatarUrl: "",
|
||||
roomId: "!room:example.org",
|
||||
roomName: "Test Room",
|
||||
roomAlias: null,
|
||||
roomAvatar: null,
|
||||
e2eeSystem: { kind: E2eeType.NONE } satisfies EncryptionSystem,
|
||||
};
|
||||
|
||||
@@ -7,7 +7,6 @@ Please see LICENSE in the repository root for full details.
|
||||
|
||||
import { type FC, useCallback, useState, type JSX, useEffect } from "react";
|
||||
import { useTranslation } from "react-i18next";
|
||||
import { type MatrixClient } from "matrix-js-sdk";
|
||||
import { Button } from "@vector-im/compound-web";
|
||||
import classNames from "classnames";
|
||||
import { logger } from "matrix-js-sdk/lib/logger";
|
||||
@@ -23,7 +22,11 @@ import { Header, LeftNav, RightNav, RoomHeaderInfo } from "../Header";
|
||||
import { type MatrixInfo, VideoPreview } from "./VideoPreview";
|
||||
import { type MuteStates } from "../state/MuteStates";
|
||||
import { InviteButton } from "../button/InviteButton";
|
||||
import { SettingsModal, defaultSettingsTab } from "../settings/SettingsModal";
|
||||
import {
|
||||
SettingsModal,
|
||||
type SettingsClientParts,
|
||||
defaultSettingsTab,
|
||||
} from "../settings/SettingsModal";
|
||||
import { useRootSizeMatches } from "../useRootSize";
|
||||
import { E2eeType } from "../e2ee/e2eeType";
|
||||
import { LeaveToHomeLink } from "../button/LeaveToHomeLink";
|
||||
@@ -46,7 +49,7 @@ import { captureSettings } from "./InCallView";
|
||||
const noVideoTrack = constant<LocalVideoMediaTrack | null>(null);
|
||||
|
||||
interface Props {
|
||||
client: MatrixClient;
|
||||
client: SettingsClientParts;
|
||||
matrixInfo: MatrixInfo;
|
||||
/** The media to open the devices on; the join takes it over. */
|
||||
media: LocalMedia;
|
||||
|
||||
+29
-4
@@ -6,7 +6,14 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { type FC, useEffect, useState, type ReactNode, useRef } from "react";
|
||||
import {
|
||||
type FC,
|
||||
useEffect,
|
||||
useMemo,
|
||||
useState,
|
||||
type ReactNode,
|
||||
useRef,
|
||||
} from "react";
|
||||
import { type MatrixError } from "matrix-js-sdk";
|
||||
import { logger } from "matrix-js-sdk/lib/logger";
|
||||
import { Trans, useTranslation } from "react-i18next";
|
||||
@@ -27,6 +34,7 @@ import { Link } from "../button/Link";
|
||||
import { ErrorView } from "../ErrorView";
|
||||
import { usePageTitle } from "../usePageTitle";
|
||||
import { useRoomName } from "./useRoomName";
|
||||
import { createCallMatrixBackend } from "../CallMatrixBackend";
|
||||
|
||||
export const RoomPage: FC = (): ReactNode => {
|
||||
const urlParams = useUrlParams();
|
||||
@@ -51,9 +59,14 @@ export const RoomPage: FC = (): ReactNode => {
|
||||
// The page title is the page's to set, not the call's: a host embedding the
|
||||
// call has a title of its own. So it is set here, for whichever room we have
|
||||
// got as far as knowing about.
|
||||
const roomName = useRoomName(
|
||||
groupCallState.kind === "loaded" ? groupCallState.rtcSession.room : null,
|
||||
const loadedRoom =
|
||||
groupCallState.kind === "loaded" ? groupCallState.room : null;
|
||||
const backend = useMemo(
|
||||
() =>
|
||||
client && loadedRoom ? createCallMatrixBackend(client, loadedRoom) : null,
|
||||
[client, loadedRoom],
|
||||
);
|
||||
const roomName = useRoomName(loadedRoom);
|
||||
usePageTitle(
|
||||
roomName ??
|
||||
(groupCallState.kind === "canKnock" ||
|
||||
@@ -90,6 +103,18 @@ export const RoomPage: FC = (): ReactNode => {
|
||||
if (optInAnalytics === null && setOptInAnalytics) setOptInAnalytics(true);
|
||||
}, [optInAnalytics, setOptInAnalytics]);
|
||||
|
||||
useEffect(() => {
|
||||
// Sanity check the room object
|
||||
if (
|
||||
client &&
|
||||
loadedRoom !== null &&
|
||||
client.getRoom(loadedRoom.roomId) !== loadedRoom
|
||||
)
|
||||
logger.warn(
|
||||
`We've ended up with multiple rooms for the same ID (${loadedRoom.roomId}). This indicates a bug in the group call loading code, and may lead to incomplete room state.`,
|
||||
);
|
||||
}, [client, loadedRoom]);
|
||||
|
||||
const wasInWaitForInviteState = useRef<boolean>(false);
|
||||
|
||||
useEffect(() => {
|
||||
@@ -103,7 +128,7 @@ export const RoomPage: FC = (): ReactNode => {
|
||||
case "loaded":
|
||||
return (
|
||||
<CallView
|
||||
client={client!}
|
||||
backend={backend!}
|
||||
rtcSession={groupCallState.rtcSession}
|
||||
isPasswordlessUser={passwordlessUser}
|
||||
confineToRoom={confineToRoom}
|
||||
|
||||
@@ -19,7 +19,6 @@ describe("VideoPreview", () => {
|
||||
roomId: "",
|
||||
roomName: "",
|
||||
e2eeSystem: { kind: E2eeType.NONE },
|
||||
roomAlias: null,
|
||||
roomAvatar: null,
|
||||
};
|
||||
|
||||
|
||||
@@ -25,7 +25,6 @@ export type MatrixInfo = {
|
||||
avatarUrl: string;
|
||||
roomId: string;
|
||||
roomName: string;
|
||||
roomAlias: string | null;
|
||||
roomAvatar: string | null;
|
||||
e2eeSystem: EncryptionSystem;
|
||||
};
|
||||
|
||||
@@ -10,9 +10,11 @@ import { useCallback } from "react";
|
||||
import type { JoinRule, Room } from "matrix-js-sdk";
|
||||
import { useRoomState } from "./useRoomState";
|
||||
|
||||
export function useJoinRule(room: Room): JoinRule {
|
||||
export function useJoinRule(
|
||||
room: Pick<Room, "getJoinRule" | "on" | "off">,
|
||||
): JoinRule {
|
||||
return useRoomState(
|
||||
room,
|
||||
useCallback((state) => state.getJoinRule(), []),
|
||||
useCallback(() => room.getJoinRule(), [room]),
|
||||
);
|
||||
}
|
||||
|
||||
@@ -38,6 +38,7 @@ import { useUrlParams } from "../UrlParams";
|
||||
|
||||
export type GroupCallLoaded = {
|
||||
kind: "loaded";
|
||||
room: Room;
|
||||
rtcSession: MatrixRTCSession;
|
||||
};
|
||||
|
||||
@@ -327,13 +328,15 @@ export const useLoadGroupCall = (
|
||||
return room;
|
||||
};
|
||||
|
||||
const fetchOrCreateGroupCall = async (): Promise<MatrixRTCSession> => {
|
||||
const fetchOrCreateGroupCall = async (): Promise<
|
||||
Pick<GroupCallLoaded, "room" | "rtcSession">
|
||||
> => {
|
||||
const room = await fetchOrCreateRoom();
|
||||
activeRoom.current = room;
|
||||
logger.debug(`Fetched / joined room ${roomIdOrAlias}`);
|
||||
|
||||
const rtcSession = client.matrixRTC.getRoomSession(room);
|
||||
return rtcSession;
|
||||
return { room, rtcSession };
|
||||
};
|
||||
|
||||
const waitForClientSyncing = async (): Promise<void> => {
|
||||
@@ -367,7 +370,9 @@ export const useLoadGroupCall = (
|
||||
logger.log("Start loading group call");
|
||||
waitForClientSyncing()
|
||||
.then(fetchOrCreateGroupCall)
|
||||
.then((rtcSession) => setState({ kind: "loaded", rtcSession }))
|
||||
.then(({ room, rtcSession }) =>
|
||||
setState({ kind: "loaded", room, rtcSession }),
|
||||
)
|
||||
.then(observeMyMembership)
|
||||
.catch((error) => setState({ kind: "failed", error }));
|
||||
}
|
||||
|
||||
@@ -10,7 +10,16 @@ import { type Room } from "matrix-js-sdk";
|
||||
|
||||
import { useRoomState } from "./useRoomState";
|
||||
|
||||
export function useRoomAvatar(room: Room): string | null {
|
||||
export function useRoomAvatar(
|
||||
room: Pick<
|
||||
Room,
|
||||
// The avatar itself
|
||||
| "getMxcAvatarUrl"
|
||||
// `on`/`off` for its changes, for `useRoomState`
|
||||
| "on"
|
||||
| "off"
|
||||
>,
|
||||
): string | null {
|
||||
return useRoomState(
|
||||
room,
|
||||
useCallback(() => room.getMxcAvatarUrl(), [room]),
|
||||
|
||||
@@ -12,9 +12,11 @@ import { useCallback, useSyncExternalStore } from "react";
|
||||
* The room's name, kept up to date. Null when there is no room yet, for a
|
||||
* caller that only sometimes has one.
|
||||
*/
|
||||
export function useRoomName(room: Room): string;
|
||||
export function useRoomName(room: Room | null): string | null;
|
||||
export function useRoomName(room: Room | null): string | null {
|
||||
type RoomNameParts = Pick<Room, "name" | "on" | "off">;
|
||||
|
||||
export function useRoomName(room: RoomNameParts): string;
|
||||
export function useRoomName(room: RoomNameParts | null): string | null;
|
||||
export function useRoomName(room: RoomNameParts | null): string | null {
|
||||
const subscribe = useCallback(
|
||||
(onChange: () => void) => {
|
||||
if (room === null) return (): void => {};
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
/*
|
||||
Copyright 2026 Element Creations Ltd.
|
||||
|
||||
SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { expect, test } from "vitest";
|
||||
import { act, renderHook } from "@testing-library/react";
|
||||
import {
|
||||
JoinRule,
|
||||
RoomEvent,
|
||||
type RoomState,
|
||||
RoomStateEvent,
|
||||
} from "matrix-js-sdk";
|
||||
|
||||
import { mockMatrixRoom } from "../utils/test";
|
||||
import { useJoinRule } from "./useJoinRule";
|
||||
import { useRoomAvatar } from "./useRoomAvatar";
|
||||
|
||||
// The hooks read the room, not the state the events carry
|
||||
const state = {} as RoomState;
|
||||
|
||||
test("the join rule follows the room's state updates", () => {
|
||||
let joinRule = JoinRule.Invite;
|
||||
const room = mockMatrixRoom({ getJoinRule: () => joinRule });
|
||||
const { result } = renderHook(() => useJoinRule(room));
|
||||
expect(result.current).toBe(JoinRule.Invite);
|
||||
|
||||
joinRule = JoinRule.Public;
|
||||
act(() => void room.emit(RoomStateEvent.Update, state));
|
||||
expect(result.current).toBe(JoinRule.Public);
|
||||
});
|
||||
|
||||
test("the avatar follows the room's state being replaced", () => {
|
||||
let avatar: string | null = null;
|
||||
const room = mockMatrixRoom({ getMxcAvatarUrl: () => avatar });
|
||||
const { result } = renderHook(() => useRoomAvatar(room));
|
||||
expect(result.current).toBeNull();
|
||||
|
||||
avatar = "mxc://example.org/avatar";
|
||||
act(() => void room.emit(RoomEvent.CurrentStateUpdated, room, state, state));
|
||||
expect(result.current).toBe("mxc://example.org/avatar");
|
||||
});
|
||||
+17
-22
@@ -5,33 +5,28 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { useCallback } from "react";
|
||||
import {
|
||||
type RoomState,
|
||||
RoomStateEvent,
|
||||
type Room,
|
||||
RoomEvent,
|
||||
} from "matrix-js-sdk";
|
||||
|
||||
import { useTypedEventEmitterState } from "../useEvents";
|
||||
import { useCallback, useSyncExternalStore } from "react";
|
||||
import { RoomStateEvent, type Room, RoomEvent } from "matrix-js-sdk";
|
||||
|
||||
/**
|
||||
* A React hook for values computed from room state.
|
||||
* @param room The room.
|
||||
* @param f A mapping from the current room state to the computed value.
|
||||
* @param f Reads the computed value off the room.
|
||||
* @returns The computed value.
|
||||
*/
|
||||
export function useRoomState<T>(room: Room, f: (state: RoomState) => T): T {
|
||||
// TODO: matrix-js-sdk says that Room.currentState is deprecated, but it's not
|
||||
// clear how to reactively track the current state of the room without it
|
||||
const currentState = useTypedEventEmitterState(
|
||||
room,
|
||||
RoomEvent.CurrentStateUpdated,
|
||||
useCallback(() => room.currentState, [room]),
|
||||
);
|
||||
return useTypedEventEmitterState(
|
||||
currentState,
|
||||
RoomStateEvent.Update,
|
||||
useCallback(() => f(currentState), [f, currentState]),
|
||||
export function useRoomState<T>(room: Pick<Room, "on" | "off">, f: () => T): T {
|
||||
const subscribe = useCallback(
|
||||
(onChange: () => void) => {
|
||||
// The room re-emits the updates of whichever state is current, and says
|
||||
// when that state is replaced
|
||||
room.on(RoomStateEvent.Update, onChange);
|
||||
room.on(RoomEvent.CurrentStateUpdated, onChange);
|
||||
return (): void => {
|
||||
room.off(RoomStateEvent.Update, onChange);
|
||||
room.off(RoomEvent.CurrentStateUpdated, onChange);
|
||||
};
|
||||
},
|
||||
[room],
|
||||
);
|
||||
return useSyncExternalStore(subscribe, f);
|
||||
}
|
||||
|
||||
@@ -111,8 +111,20 @@ const KeyRotationStatus: FC<{ info: KeyRotationInfo }> = ({ info }) => (
|
||||
</p>
|
||||
);
|
||||
|
||||
export type DeveloperSettingsClientParts = Pick<
|
||||
MatrixClient,
|
||||
| "doesServerSupportUnstableFeature"
|
||||
| "getCrypto"
|
||||
| "getUserId"
|
||||
| "getDeviceId"
|
||||
| "getDomain"
|
||||
// To authenticate with a transport
|
||||
| "getLivekitToken"
|
||||
| "getOpenIdToken"
|
||||
>;
|
||||
|
||||
interface Props {
|
||||
client: MatrixClient;
|
||||
client: DeveloperSettingsClientParts;
|
||||
roomId?: string;
|
||||
/** The transports the client is connected to, while in a call. */
|
||||
transports?: TransportInfo[];
|
||||
|
||||
@@ -6,17 +6,16 @@ Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { type FC, useCallback, useEffect, useMemo, useRef } from "react";
|
||||
import { type MatrixClient } from "matrix-js-sdk";
|
||||
import { useTranslation } from "react-i18next";
|
||||
import { logger } from "matrix-js-sdk/lib/logger";
|
||||
|
||||
import { useProfile } from "../profile/useProfile";
|
||||
import { type ProfileClientParts, useProfile } from "../profile/useProfile";
|
||||
import { FieldRow, InputField, ErrorMessage } from "../input/Input";
|
||||
import { AvatarInputField } from "../input/AvatarInputField";
|
||||
import styles from "./ProfileSettingsTab.module.css";
|
||||
|
||||
interface Props {
|
||||
client: MatrixClient;
|
||||
client: ProfileClientParts;
|
||||
}
|
||||
export const ProfileSettingsTab: FC<Props> = ({ client }) => {
|
||||
const { t } = useTranslation();
|
||||
|
||||
@@ -7,8 +7,8 @@ Please see LICENSE in the repository root for full details.
|
||||
|
||||
import { type FC, type ReactNode, useEffect, useState } from "react";
|
||||
import { useTranslation } from "react-i18next";
|
||||
import { type MatrixClient } from "matrix-js-sdk";
|
||||
import { Button, Root as Form, Separator } from "@vector-im/compound-web";
|
||||
import { type MatrixClient } from "matrix-js-sdk";
|
||||
|
||||
import { Modal } from "../Modal";
|
||||
import styles from "./SettingsModal.module.css";
|
||||
@@ -53,12 +53,31 @@ type SettingsTab =
|
||||
| "more"
|
||||
| "developer";
|
||||
|
||||
export type SettingsClientParts = Pick<
|
||||
MatrixClient,
|
||||
// Profile and developer tabs
|
||||
| "getUserId"
|
||||
// Profile tab
|
||||
| "getUser"
|
||||
| "setDisplayName"
|
||||
| "setAvatarUrl"
|
||||
| "uploadContent"
|
||||
// Developer tab
|
||||
| "doesServerSupportUnstableFeature"
|
||||
| "getCrypto"
|
||||
| "getDeviceId"
|
||||
| "getDomain"
|
||||
// Developer tab, to authenticate with a transport
|
||||
| "getLivekitToken"
|
||||
| "getOpenIdToken"
|
||||
>;
|
||||
|
||||
interface Props {
|
||||
open: boolean;
|
||||
onDismiss: () => void;
|
||||
tab: SettingsTab;
|
||||
onTabChange: (tab: SettingsTab) => void;
|
||||
client: MatrixClient;
|
||||
client: SettingsClientParts;
|
||||
roomId?: string;
|
||||
/** The transports the client is connected to, while in a call. */
|
||||
transports?: TransportInfo[];
|
||||
|
||||
@@ -63,44 +63,57 @@ export type CallNotificationWrapper = {
|
||||
event_id: string;
|
||||
} & IRTCNotificationContent;
|
||||
|
||||
/**
|
||||
* The call notifications the session sends with our join: what a host hands
|
||||
* the call as `sentCallNotification$`.
|
||||
*/
|
||||
export function observeSentCallNotification$(
|
||||
matrixRTCSession: Pick<MatrixRTCSession, "on" | "off">,
|
||||
): Observable<CallNotificationWrapper> {
|
||||
return fromEvent(
|
||||
matrixRTCSession,
|
||||
MatrixRTCSessionEvent.DidSendCallNotification,
|
||||
(notification: CallNotificationWrapper) => notification,
|
||||
);
|
||||
}
|
||||
|
||||
export function createSentCallNotification$(
|
||||
scope: ObservableScope,
|
||||
matrixRTCSession: MatrixRTCSession,
|
||||
sentCallNotification$: Observable<CallNotificationWrapper>,
|
||||
): Behavior<CallNotificationWrapper | null> {
|
||||
const sentCallNotification$ = scope.behavior(
|
||||
fromEvent(matrixRTCSession, MatrixRTCSessionEvent.DidSendCallNotification),
|
||||
return scope.behavior<CallNotificationWrapper | null>(
|
||||
sentCallNotification$,
|
||||
null,
|
||||
) as Behavior<CallNotificationWrapper | null>;
|
||||
return sentCallNotification$;
|
||||
);
|
||||
}
|
||||
|
||||
export function createReceivedDecline$(
|
||||
matrixRoom: MatrixRoom,
|
||||
matrixRoom: Pick<MatrixRoom, "_unstable_getStickyEvents" | "on" | "off">,
|
||||
): Observable<MatrixEvent> {
|
||||
// A decline is sticky, so after a gappy sync it arrives only in the sticky
|
||||
// section, which never reaches the timeline. Racing for the first outcome
|
||||
// makes a decline seen in both places harmless.
|
||||
const timeline$ = (
|
||||
fromEvent(matrixRoom, RoomEvent.Timeline) as Observable<
|
||||
Parameters<EventTimelineSetHandlerMap[RoomEvent.Timeline]>
|
||||
>
|
||||
).pipe(map(([event]) => event));
|
||||
const timeline$ = fromEvent(
|
||||
matrixRoom,
|
||||
RoomEvent.Timeline,
|
||||
(...[event]: Parameters<EventTimelineSetHandlerMap[RoomEvent.Timeline]>) =>
|
||||
event,
|
||||
);
|
||||
// The decline can arrive via sync before the send of our notification
|
||||
// resolves, which is when we start listening. To guard against this, we
|
||||
// include what is already in the sticky section.
|
||||
const currentSticky$ = defer(() =>
|
||||
from(matrixRoom._unstable_getStickyEvents()),
|
||||
);
|
||||
const sticky$ = (
|
||||
fromEvent(matrixRoom, RoomStickyEventsEvent.Update) as Observable<
|
||||
Parameters<RoomStickyEventsMap[RoomStickyEventsEvent.Update]>
|
||||
>
|
||||
).pipe(
|
||||
mergeMap(([added, updated]) => [
|
||||
...added,
|
||||
...updated.map(({ current }) => current),
|
||||
]),
|
||||
);
|
||||
const sticky$ = fromEvent(
|
||||
matrixRoom,
|
||||
RoomStickyEventsEvent.Update,
|
||||
(
|
||||
...[added, updated]: Parameters<
|
||||
RoomStickyEventsMap[RoomStickyEventsEvent.Update]
|
||||
>
|
||||
) => [...added, ...updated.map(({ current }) => current)],
|
||||
).pipe(mergeMap((events) => events));
|
||||
return merge(currentSticky$, sticky$, timeline$).pipe(
|
||||
filter((event) => event.getType() === EventType.RTCDecline),
|
||||
);
|
||||
|
||||
@@ -28,6 +28,7 @@ import {
|
||||
} from "@element-hq/matrixrtc-sdk";
|
||||
import {
|
||||
KnownMembership,
|
||||
type MatrixClient,
|
||||
type Room as MatrixRoom,
|
||||
type RoomMember,
|
||||
RoomStateEvent,
|
||||
@@ -193,7 +194,15 @@ export function initialPublishRequests(
|
||||
export interface CallViewModelProps {
|
||||
rtcParticipation: RTCParticipation;
|
||||
/** A call is permanently tied to a single Matrix room. */
|
||||
matrixRoom: MatrixRoom;
|
||||
matrixRoom: Pick<
|
||||
MatrixRoom,
|
||||
| "roomId"
|
||||
| "getMembersWithMembership"
|
||||
| "_unstable_getStickyEvents"
|
||||
| "on"
|
||||
| "off"
|
||||
>;
|
||||
client: Pick<MatrixClient, "getUserId" | "getDeviceId">;
|
||||
mediaDevices: MediaDevices;
|
||||
muteStates: MuteStates;
|
||||
encryptionSystem: EncryptionSystem;
|
||||
@@ -492,6 +501,7 @@ export function createCallViewModel$(
|
||||
{
|
||||
rtcParticipation,
|
||||
matrixRoom,
|
||||
client,
|
||||
mediaDevices,
|
||||
muteStates,
|
||||
encryptionSystem,
|
||||
@@ -502,7 +512,6 @@ export function createCallViewModel$(
|
||||
options: CallViewModelOptions = {},
|
||||
): CallViewModel {
|
||||
const logger = rootLogger.getChild("[CallViewModel]");
|
||||
const client = matrixRoom.client;
|
||||
const userId = client.getUserId();
|
||||
const deviceId = client.getDeviceId();
|
||||
if (!(userId && deviceId))
|
||||
@@ -1646,7 +1655,9 @@ function isPermissionDenied(e: unknown): boolean {
|
||||
}
|
||||
|
||||
/** The members a call can be with: those in the room and those invited. */
|
||||
function roomMembers(room: MatrixRoom): RoomMember[] {
|
||||
function roomMembers(
|
||||
room: Pick<MatrixRoom, "getMembersWithMembership">,
|
||||
): RoomMember[] {
|
||||
return room
|
||||
.getMembersWithMembership(KnownMembership.Join)
|
||||
.concat(room.getMembersWithMembership(KnownMembership.Invite));
|
||||
|
||||
@@ -29,7 +29,10 @@ import {
|
||||
createCallViewModel$,
|
||||
type CallViewModelOptions,
|
||||
} from "./CallViewModel";
|
||||
import { createSentCallNotification$ } from "./CallNotificationLifecycle";
|
||||
import {
|
||||
createSentCallNotification$,
|
||||
observeSentCallNotification$,
|
||||
} from "./CallNotificationLifecycle";
|
||||
import {
|
||||
mockConfig,
|
||||
mockMatrixRoom,
|
||||
@@ -265,6 +268,7 @@ export function withCallViewModel(mode: MatrixRTCMode) {
|
||||
{
|
||||
rtcParticipation,
|
||||
matrixRoom: room,
|
||||
client: room.client,
|
||||
mediaDevices,
|
||||
muteStates,
|
||||
encryptionSystem: { kind: E2eeType.PER_PARTICIPANT },
|
||||
@@ -276,7 +280,7 @@ export function withCallViewModel(mode: MatrixRTCMode) {
|
||||
autoLeaveWhenOthersLeft: false,
|
||||
sentCallNotification$: createSentCallNotification$(
|
||||
scope,
|
||||
rtcSession.asMockedSession(),
|
||||
observeSentCallNotification$(rtcSession.asMockedSession()),
|
||||
),
|
||||
...options,
|
||||
},
|
||||
|
||||
+13
-23
@@ -5,13 +5,10 @@ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { test, expect } from "vitest";
|
||||
import { test, expect, vi } from "vitest";
|
||||
import { act, render, screen } from "@testing-library/react";
|
||||
import { axe } from "vitest-axe";
|
||||
import {
|
||||
RTC_CALL_INTENT_AUDIO,
|
||||
type MatrixRTCSession,
|
||||
} from "matrix-js-sdk/lib/matrixrtc";
|
||||
import { RTC_CALL_INTENT_AUDIO } from "matrix-js-sdk/lib/matrixrtc";
|
||||
import { BehaviorSubject } from "rxjs";
|
||||
|
||||
import { GridTile } from "./GridTile";
|
||||
@@ -36,25 +33,18 @@ global.IntersectionObserver = class MockIntersectionObserver {
|
||||
public disconnect(): void {}
|
||||
} as unknown as typeof IntersectionObserver;
|
||||
|
||||
const fakeRtcSession = {
|
||||
on: () => {},
|
||||
off: () => {},
|
||||
room: {
|
||||
on: () => {},
|
||||
off: () => {},
|
||||
client: {
|
||||
getUserId: () => null,
|
||||
getDeviceId: () => null,
|
||||
on: () => {},
|
||||
off: () => {},
|
||||
},
|
||||
},
|
||||
memberships: [],
|
||||
} as unknown as MatrixRTCSession;
|
||||
const fakeRoom = { roomId: "!room:example.org" };
|
||||
const fakeClient = {
|
||||
getUserId: () => null,
|
||||
getDeviceId: () => null,
|
||||
sendEvent: vi.fn(),
|
||||
redactEvent: vi.fn(),
|
||||
};
|
||||
|
||||
const callVm = {
|
||||
reactions$: constant({}),
|
||||
handsRaised$: constant({}),
|
||||
localMember$: constant(null),
|
||||
} as Partial<CallViewModel> as CallViewModel;
|
||||
|
||||
test("GridTile displays remote media", async () => {
|
||||
@@ -68,7 +58,7 @@ test("GridTile displays remote media", async () => {
|
||||
);
|
||||
|
||||
const { container } = render(
|
||||
<ReactionsSenderProvider vm={callVm} rtcSession={fakeRtcSession}>
|
||||
<ReactionsSenderProvider vm={callVm} room={fakeRoom} client={fakeClient}>
|
||||
<GridTile
|
||||
vm={new GridTileViewModel(constant(vm))}
|
||||
onOpenProfile={() => {}}
|
||||
@@ -99,7 +89,7 @@ test("GridTile displays local media", async () => {
|
||||
);
|
||||
|
||||
const { container } = render(
|
||||
<ReactionsSenderProvider vm={callVm} rtcSession={fakeRtcSession}>
|
||||
<ReactionsSenderProvider vm={callVm} room={fakeRoom} client={fakeClient}>
|
||||
<GridTile
|
||||
vm={new GridTileViewModel(constant(vm))}
|
||||
onOpenProfile={() => {}}
|
||||
@@ -132,7 +122,7 @@ test("GridTile displays ringing media", async () => {
|
||||
});
|
||||
|
||||
const { container } = render(
|
||||
<ReactionsSenderProvider vm={callVm} rtcSession={fakeRtcSession}>
|
||||
<ReactionsSenderProvider vm={callVm} room={fakeRoom} client={fakeClient}>
|
||||
<GridTile
|
||||
vm={new GridTileViewModel(constant(vm))}
|
||||
onOpenProfile={() => {}}
|
||||
|
||||
+1
-21
@@ -35,26 +35,6 @@ export function useEventTarget<T extends Event>(
|
||||
}, [target, eventType, listener, options]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Shortcut for registering a listener on a TypedEventEmitter.
|
||||
*/
|
||||
export function useTypedEventEmitter<
|
||||
Events extends string,
|
||||
Arguments extends ListenerMap<Events>,
|
||||
T extends Events,
|
||||
>(
|
||||
emitter: TypedEventEmitter<Events, Arguments>,
|
||||
eventType: T,
|
||||
listener: Listener<Events, Arguments, T>,
|
||||
): void {
|
||||
useEffect(() => {
|
||||
emitter.on(eventType, listener);
|
||||
return (): void => {
|
||||
emitter.off(eventType, listener);
|
||||
};
|
||||
}, [emitter, eventType, listener]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reactively tracks a value which is recalculated whenever the provided event
|
||||
* emitter emits an event. This is useful for bridging state from matrix-js-sdk
|
||||
@@ -66,7 +46,7 @@ export function useTypedEventEmitterState<
|
||||
T extends Events,
|
||||
State,
|
||||
>(
|
||||
emitter: TypedEventEmitter<Events, Arguments>,
|
||||
emitter: Pick<TypedEventEmitter<Events, Arguments>, "on" | "off">,
|
||||
eventType: T,
|
||||
getState: () => State,
|
||||
): State {
|
||||
|
||||
@@ -1,25 +0,0 @@
|
||||
/*
|
||||
Copyright 2023, 2024 New Vector Ltd.
|
||||
|
||||
SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
|
||||
Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import {
|
||||
type CallMembership,
|
||||
type MatrixRTCSession,
|
||||
MatrixRTCSessionEvent,
|
||||
} from "matrix-js-sdk/lib/matrixrtc";
|
||||
import { useCallback } from "react";
|
||||
|
||||
import { useTypedEventEmitterState } from "./useEvents";
|
||||
|
||||
export function useMatrixRTCSessionMemberships(
|
||||
rtcSession: MatrixRTCSession,
|
||||
): CallMembership[] {
|
||||
return useTypedEventEmitterState(
|
||||
rtcSession,
|
||||
MatrixRTCSessionEvent.MembershipsChanged,
|
||||
useCallback(() => rtcSession.memberships, [rtcSession]),
|
||||
);
|
||||
}
|
||||
+21
-15
@@ -7,6 +7,7 @@ Please see LICENSE in the repository root for full details.
|
||||
|
||||
import { describe, expect, test } from "vitest";
|
||||
import { ConnectionError } from "livekit-client";
|
||||
import { UnsupportedStickyEventsEndpointError } from "matrix-js-sdk";
|
||||
import {
|
||||
ErrorCode as RTCErrorCode,
|
||||
FailToGetOpenIdToken as RTCFailToGetOpenIdToken,
|
||||
@@ -32,10 +33,10 @@ import {
|
||||
InsufficientCapacityError,
|
||||
LivekitConnectionError,
|
||||
MatrixRTCTransportMissingError,
|
||||
MembershipManagerError,
|
||||
NoMatrix2AuthorizationService,
|
||||
PeerConnectionTimeoutError,
|
||||
SFURoomCreationRestrictedError,
|
||||
StickyEventsRequiredError,
|
||||
UnknownCallError,
|
||||
} from "./errors";
|
||||
|
||||
@@ -43,17 +44,6 @@ import {
|
||||
// rather than the global one, so each needs to come out translated rather than
|
||||
// as a raw key.
|
||||
describe("localised errors", () => {
|
||||
test("MembershipManagerError describes the failure and keeps its cause", () => {
|
||||
const cause = new Error("the underlying problem");
|
||||
const error = new MembershipManagerError(cause);
|
||||
|
||||
expect(error.code).toBe(ErrorCode.INTERNAL_MEMBERSHIP_MANAGER);
|
||||
expect(error.category).toBe(ErrorCategory.SYSTEM_FAILURE);
|
||||
expect(error.localisedTitle).not.toContain("error.");
|
||||
expect(error.localisedMessage).not.toContain("error.");
|
||||
expect(error.cause).toBe(cause);
|
||||
});
|
||||
|
||||
test("NoMatrix2AuthorizationService is a configuration problem", () => {
|
||||
const cause = new Error("404");
|
||||
const error = new NoMatrix2AuthorizationService(cause);
|
||||
@@ -100,8 +90,22 @@ describe("fromMatrixRTCError", () => {
|
||||
{
|
||||
name: "membership manager failure",
|
||||
input: new RTCMembershipManagerError(cause),
|
||||
expected: MembershipManagerError,
|
||||
code: ErrorCode.INTERNAL_MEMBERSHIP_MANAGER,
|
||||
expected: ConnectionLostError,
|
||||
code: ErrorCode.CONNECTION_LOST_ERROR,
|
||||
},
|
||||
{
|
||||
name: "membership manager stopped by missing sticky events",
|
||||
// The membership manager's scheduler wraps the original error
|
||||
input: new RTCMembershipManagerError(
|
||||
new Error("The MembershipManager shut down", {
|
||||
cause: new UnsupportedStickyEventsEndpointError(
|
||||
"Server does not support the sticky events",
|
||||
"sendStickyEvent",
|
||||
),
|
||||
}),
|
||||
),
|
||||
expected: StickyEventsRequiredError,
|
||||
code: ErrorCode.STICKY_EVENTS_NOT_SUPPORTED,
|
||||
},
|
||||
{
|
||||
name: "OpenID token failure",
|
||||
@@ -169,7 +173,9 @@ describe("fromMatrixRTCError", () => {
|
||||
});
|
||||
|
||||
test("keeps the SDK error's cause for reporting", () => {
|
||||
const error = fromMatrixRTCError(new RTCMembershipManagerError(cause));
|
||||
const error = fromMatrixRTCError(
|
||||
new RTCNoMatrix2AuthorizationService(cause),
|
||||
);
|
||||
|
||||
expect(error.cause).toBe(cause);
|
||||
});
|
||||
|
||||
+5
-24
@@ -6,6 +6,7 @@ Please see LICENSE in the repository root for full details.
|
||||
*/
|
||||
|
||||
import { type ConnectionError } from "livekit-client";
|
||||
import { UnsupportedStickyEventsEndpointError } from "matrix-js-sdk";
|
||||
import {
|
||||
ErrorCode as RTCErrorCode,
|
||||
FailToGetOpenIdToken as RTCFailToGetOpenIdToken,
|
||||
@@ -28,7 +29,6 @@ export enum ErrorCode {
|
||||
*/
|
||||
MISSING_MATRIX_RTC_TRANSPORT = "MISSING_MATRIX_RTC_TRANSPORT",
|
||||
CONNECTION_LOST_ERROR = "CONNECTION_LOST_ERROR",
|
||||
INTERNAL_MEMBERSHIP_MANAGER = "INTERNAL_MEMBERSHIP_MANAGER",
|
||||
FAILED_TO_START_LIVEKIT = "FAILED_TO_START_LIVEKIT",
|
||||
/** LiveKit indicates that the server has hit its track limits */
|
||||
INSUFFICIENT_CAPACITY_ERROR = "INSUFFICIENT_CAPACITY_ERROR",
|
||||
@@ -46,7 +46,6 @@ export enum ErrorCategory {
|
||||
NETWORK_CONNECTIVITY = "NETWORK_CONNECTIVITY",
|
||||
CLIENT_CONFIGURATION = "CLIENT_CONFIGURATION",
|
||||
UNKNOWN = "UNKNOWN",
|
||||
SYSTEM_FAILURE = "SYSTEM_FAILURE",
|
||||
// SYSTEM_FAILURE / FEDERATION_FAILURE ..
|
||||
}
|
||||
|
||||
@@ -117,27 +116,6 @@ export class ConnectionLostError extends ElementCallError {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Error indicating a failure in the membership manager causing the join call
|
||||
* operation to fail.
|
||||
*/
|
||||
export class MembershipManagerError extends ElementCallError {
|
||||
/**
|
||||
* Creates an instance of MembershipManagerError.
|
||||
*
|
||||
* @param error - The underlying error that caused the membership manager failure.
|
||||
*/
|
||||
public constructor(error: Error) {
|
||||
super(
|
||||
i18n.t("error.membership_manager"),
|
||||
ErrorCode.INTERNAL_MEMBERSHIP_MANAGER,
|
||||
ErrorCategory.SYSTEM_FAILURE,
|
||||
i18n.t("error.membership_manager_description"),
|
||||
error,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Error indicating that this deployment pins `matrix_rtc_mode=matrix_2_0` in
|
||||
* config.json but the homeserver does not advertise MSC4354 (sticky events),
|
||||
@@ -314,7 +292,10 @@ export function fromMatrixRTCError(error: MatrixRTCError): ElementCallError {
|
||||
if (error instanceof RTCTransportMissingError)
|
||||
return new MatrixRTCTransportMissingError(error.domain);
|
||||
if (error instanceof RTCMembershipManagerError)
|
||||
return new MembershipManagerError(causeOf(error));
|
||||
// The membership manager wraps what made it stop
|
||||
return causeOf(error).cause instanceof UnsupportedStickyEventsEndpointError
|
||||
? new StickyEventsRequiredError()
|
||||
: new ConnectionLostError();
|
||||
if (error instanceof RTCFailToGetOpenIdToken)
|
||||
return new FailToGetOpenIdToken(causeOf(error));
|
||||
if (error instanceof RTCNoMatrix2AuthorizationService)
|
||||
|
||||
+63
-33
@@ -17,7 +17,8 @@ import {
|
||||
SyncState,
|
||||
} from "matrix-js-sdk";
|
||||
|
||||
import { E2eeType } from "@element-hq/matrixrtc-sdk";
|
||||
import { E2eeType, type RTCMember } from "@element-hq/matrixrtc-sdk";
|
||||
import { type Behavior } from "../state/Behavior";
|
||||
import {
|
||||
type CallViewModel,
|
||||
createCallViewModel$,
|
||||
@@ -39,7 +40,10 @@ import { type RaisedHandInfo, type ReactionInfo } from "../reactions";
|
||||
import { constant } from "@element-hq/matrixrtc-sdk";
|
||||
import { map } from "rxjs";
|
||||
import { createCallFooterViewModel } from "../components/CallFooterViewModel";
|
||||
import { createSentCallNotification$ } from "../state/CallViewModel/CallNotificationLifecycle";
|
||||
import {
|
||||
createSentCallNotification$,
|
||||
observeSentCallNotification$,
|
||||
} from "../state/CallViewModel/CallNotificationLifecycle";
|
||||
import { HeaderStyle } from "../UrlParams";
|
||||
import { type FooterSnapshot } from "../components/CallFooter";
|
||||
import { type ViewModel } from "../state/ViewModel";
|
||||
@@ -54,43 +58,47 @@ export function getBasicRTCSession(
|
||||
): {
|
||||
rtcSession: MockRTCSession;
|
||||
matrixRoom: Room;
|
||||
client: MatrixClient;
|
||||
rtcMemberships$: BehaviorSubject<CallMembership[]>;
|
||||
/** The memberships as the slot's members. */
|
||||
members$: Behavior<RTCMember[]>;
|
||||
} {
|
||||
const matrixRoomId = "!myRoomId:example.com";
|
||||
const matrixRoomMembers = new Map(members.map((p) => [p.userId, p]));
|
||||
|
||||
const roomEmitter = new EventEmitter();
|
||||
const clientEmitter = new EventEmitter();
|
||||
const client = {
|
||||
getUserId: () => localRtcMember.userId,
|
||||
getDeviceId: () => localRtcMember.deviceId,
|
||||
getSyncState: () => SyncState.Syncing,
|
||||
getDomain: () => "example.com",
|
||||
getAccessToken: () => "fake-token",
|
||||
sendEvent: vitest.fn().mockResolvedValue({ event_id: "$fake:event" }),
|
||||
redactEvent: vitest.fn().mockResolvedValue({ event_id: "$fake:event" }),
|
||||
decryptEventIfNeeded: vitest.fn().mockResolvedValue(undefined),
|
||||
on: vitest
|
||||
.fn()
|
||||
.mockImplementation(
|
||||
(eventName: string, fn: (...args: unknown[]) => void) => {
|
||||
clientEmitter.on(eventName, fn);
|
||||
},
|
||||
),
|
||||
emit: (eventName: string, ...args: unknown[]) =>
|
||||
clientEmitter.emit(eventName, ...args),
|
||||
off: vitest
|
||||
.fn()
|
||||
.mockImplementation(
|
||||
(eventName: string, fn: (...args: unknown[]) => void) => {
|
||||
clientEmitter.off(eventName, fn);
|
||||
},
|
||||
),
|
||||
} as Partial<MatrixClient> as MatrixClient;
|
||||
const matrixRoom = mockMatrixRoom({
|
||||
relations: {
|
||||
getChildEventsForEvent: vitest.fn(),
|
||||
} as Partial<RelationsContainer> as RelationsContainer,
|
||||
client: {
|
||||
getUserId: () => localRtcMember.userId,
|
||||
getDeviceId: () => localRtcMember.deviceId,
|
||||
getSyncState: () => SyncState.Syncing,
|
||||
getDomain: () => "example.com",
|
||||
getAccessToken: () => "fake-token",
|
||||
sendEvent: vitest.fn().mockResolvedValue({ event_id: "$fake:event" }),
|
||||
redactEvent: vitest.fn().mockResolvedValue({ event_id: "$fake:event" }),
|
||||
decryptEventIfNeeded: vitest.fn().mockResolvedValue(undefined),
|
||||
on: vitest
|
||||
.fn()
|
||||
.mockImplementation(
|
||||
(eventName: string, fn: (...args: unknown[]) => void) => {
|
||||
clientEmitter.on(eventName, fn);
|
||||
},
|
||||
),
|
||||
emit: (eventName: string, ...args: unknown[]) =>
|
||||
clientEmitter.emit(eventName, ...args),
|
||||
off: vitest
|
||||
.fn()
|
||||
.mockImplementation(
|
||||
(eventName: string, fn: (...args: unknown[]) => void) => {
|
||||
clientEmitter.off(eventName, fn);
|
||||
},
|
||||
),
|
||||
} as Partial<MatrixClient> as MatrixClient,
|
||||
client,
|
||||
getMember: (userId) => matrixRoomMembers.get(userId) ?? null,
|
||||
getMembers: () => Array.from(matrixRoomMembers.values()),
|
||||
getMembersWithMembership: () => Array.from(matrixRoomMembers.values()),
|
||||
@@ -122,10 +130,29 @@ export function getBasicRTCSession(
|
||||
rtcMemberships$,
|
||||
);
|
||||
|
||||
const members$ = testScope().behavior(
|
||||
rtcMemberships$.pipe(
|
||||
map((memberships) =>
|
||||
memberships.map((membership) => {
|
||||
const inputs = {
|
||||
membership,
|
||||
roomMember: matrixRoomMembers.get(membership.userId),
|
||||
};
|
||||
return membership.userId === localRtcMember.userId &&
|
||||
membership.deviceId === localRtcMember.deviceId
|
||||
? mockRTCMember(true, inputs)
|
||||
: mockRTCMember(false, inputs);
|
||||
}),
|
||||
),
|
||||
),
|
||||
);
|
||||
|
||||
return {
|
||||
rtcSession: fakeRtcSession,
|
||||
matrixRoom,
|
||||
client,
|
||||
rtcMemberships$,
|
||||
members$,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -146,13 +173,13 @@ export function getBasicCallViewModelEnvironment(
|
||||
developerSettingsVm: ViewModel<DeveloperSettingsSnapshot>;
|
||||
rtcMemberships$: BehaviorSubject<CallMembership[]>;
|
||||
rtcSession: MockRTCSession;
|
||||
matrixRoom: Room;
|
||||
client: MatrixClient;
|
||||
handRaisedSubject$: BehaviorSubject<Record<string, RaisedHandInfo>>;
|
||||
reactionsSubject$: BehaviorSubject<Record<string, ReactionInfo>>;
|
||||
} {
|
||||
const { rtcSession, matrixRoom, rtcMemberships$ } = getBasicRTCSession(
|
||||
members,
|
||||
initialRtcMemberships,
|
||||
);
|
||||
const { rtcSession, matrixRoom, client, rtcMemberships$ } =
|
||||
getBasicRTCSession(members, initialRtcMemberships);
|
||||
const handRaisedSubject$ = new BehaviorSubject({});
|
||||
const reactionsSubject$ = new BehaviorSubject({});
|
||||
|
||||
@@ -199,6 +226,7 @@ export function getBasicCallViewModelEnvironment(
|
||||
{
|
||||
rtcParticipation,
|
||||
matrixRoom,
|
||||
client,
|
||||
mediaDevices,
|
||||
muteStates,
|
||||
encryptionSystem: { kind: E2eeType.PER_PARTICIPANT },
|
||||
@@ -209,7 +237,7 @@ export function getBasicCallViewModelEnvironment(
|
||||
{
|
||||
sentCallNotification$: createSentCallNotification$(
|
||||
scope,
|
||||
rtcSession.asMockedSession(),
|
||||
observeSentCallNotification$(rtcSession.asMockedSession()),
|
||||
),
|
||||
...callViewModelOptions,
|
||||
},
|
||||
@@ -229,6 +257,8 @@ export function getBasicCallViewModelEnvironment(
|
||||
developerSettingsVm: createDeveloperSettingsTabViewModel(testScope(), vm),
|
||||
rtcMemberships$,
|
||||
rtcSession,
|
||||
matrixRoom,
|
||||
client,
|
||||
handRaisedSubject$: handRaisedSubject$,
|
||||
reactionsSubject$: reactionsSubject$,
|
||||
};
|
||||
|
||||
+23
-4
@@ -475,6 +475,7 @@ export function mockRTCMember(
|
||||
userId: membership.userId,
|
||||
deviceId: membership.deviceId,
|
||||
memberId: membership.memberId,
|
||||
matrixEventId$: constant(membership.eventId),
|
||||
displayName$: constant(member.rawDisplayName ?? membership.userId),
|
||||
avatarUrl$: constant(member.getMxcAvatarUrl()),
|
||||
transport$: constant(transport),
|
||||
@@ -505,6 +506,13 @@ export interface MockParticipationInputs {
|
||||
* slot whose members are the same ones without their media.
|
||||
*/
|
||||
export function mockRTCParticipation(
|
||||
scope: ObservableScope,
|
||||
inputs: MockParticipationInputs = {},
|
||||
): RTCParticipation {
|
||||
return mockSlotWithParticipation(scope, inputs).participation;
|
||||
}
|
||||
|
||||
function mockSlotWithParticipation(
|
||||
scope: ObservableScope,
|
||||
{
|
||||
localMember$ = constant(null),
|
||||
@@ -512,8 +520,8 @@ export function mockRTCParticipation(
|
||||
state$ = constant<ParticipationState>({ kind: "connected" }),
|
||||
keyRotationSuppressed$ = constant(false),
|
||||
connectedTransports$ = constant([]),
|
||||
}: MockParticipationInputs = {},
|
||||
): RTCParticipation {
|
||||
}: MockParticipationInputs,
|
||||
): { slot: RTCSlot; participation: RTCParticipation } {
|
||||
const members$ = scope.behavior<RTCMember[]>(
|
||||
combineLatest([localMember$, remoteMembers$], (local, remote) =>
|
||||
local === null ? remote : [local, ...remote],
|
||||
@@ -550,7 +558,7 @@ export function mockRTCParticipation(
|
||||
data$: NEVER,
|
||||
};
|
||||
participation$.next(participation);
|
||||
return participation;
|
||||
return { slot, participation };
|
||||
}
|
||||
|
||||
/** The slot of a `mockRTCParticipation`, whose `join()` returns that participation. */
|
||||
@@ -558,7 +566,7 @@ export function mockRTCSlot(
|
||||
scope: ObservableScope,
|
||||
inputs: MockParticipationInputs = {},
|
||||
): RTCSlot {
|
||||
return mockRTCParticipation(scope, inputs).slot;
|
||||
return mockSlotWithParticipation(scope, inputs).slot;
|
||||
}
|
||||
|
||||
export function mockConfig(
|
||||
@@ -603,6 +611,10 @@ export class MockRTCSession extends TypedEventEmitter<
|
||||
.fn()
|
||||
.mockResolvedValue(undefined);
|
||||
|
||||
public stop: ReturnType<typeof vitest.fn> = vitest
|
||||
.fn()
|
||||
.mockResolvedValue(undefined);
|
||||
|
||||
public constructor(
|
||||
public readonly room: Room,
|
||||
public memberships: CallMembership[] = [],
|
||||
@@ -615,6 +627,13 @@ export class MockRTCSession extends TypedEventEmitter<
|
||||
return this.joined;
|
||||
}
|
||||
|
||||
public slotDescription = { application: "m.call", id: "ROOM" };
|
||||
/** The slot event's content; undefined while the room has none. */
|
||||
public rtcSlot: ReturnType<MatrixRTCSession["getRtcSlot"]> = undefined;
|
||||
public getRtcSlot(): ReturnType<MatrixRTCSession["getRtcSlot"]> {
|
||||
return this.rtcSlot;
|
||||
}
|
||||
|
||||
public isKeyRotationSuppressed = false;
|
||||
|
||||
public withMemberships(
|
||||
|
||||
Reference in New Issue
Block a user