Compare commits

...
Author SHA1 Message Date
Timo K. aee75d7d72 Introduce Backend concept (just renames for now. no new strucutre) 2026-11-20 04:42:54 +01:00
Timo K. 5235fd0e65 make EC component rtcSession independent, more own js-sdk wrapped
methods
Everything related to the session is now burried inside the SDK.
2026-11-20 03:11:26 +01:00
Timo K. 0f5969677f remove the rtcSession from everything below the CallView!!!!
This is a big step in the js-sdk independence of EC.
It concludes a clear position where we can start building the
matrixBackend.
2026-11-20 02:23:22 +01:00
Timo K. d492b9d93a Make the reactions logic independent of the rtcSession 2026-11-20 01:51:54 +01:00
Timo K. 800e8d2a39 SDK api updated (rtcMode slot->join, RTCMember.eventId)
Two things were added
 - The rtc mode is now passed on join and not part of the slot (it is a
   participation prop only, uninteresting for non joined slots, its per
   participant anyhow)
 - RTCMember.matrixEventId$ includes the event id which we need in the
   rtc sdk as some apps (e.g. call) might need it.
2026-11-20 01:44:40 +01:00
Timo K. 2a8836e44a never use rtcSession.room (Relation classes refactor)
make sure everything is passed through dedicated room / client props.
2026-11-20 01:01:28 +01:00
Timo K. f6b5dd0b7e Use implementations for rtc related methods of our own js-sdk
getRTCTransports
getOpenIdToken
getLivekitToken
delegateDelayedLeave
2026-11-20 01:00:33 +01:00
Timo K. 3176992d5d Make the client Picks transparent up to the component 2026-11-20 00:43:37 +01:00
Timo K. f934cd158f Make the room Picks transparent up to the component. 2026-11-20 00:11:06 +01:00
Timo K. ab7d2d3893 Allocate a new js-sdk matrixRTCSession for the embedded component (no
more peer dep)
2026-11-19 23:46:59 +01:00
Timo K. 0e1badf559 api iteration: only pass the participation the slot data that makes
sense
 - dont pass the participation$ itself
 - dont pass the join fn.
2026-11-19 23:45:53 +01:00
Timo K. c835409cd2 createRTCSlot takes the MatrixRTC session via fn param 2026-11-19 23:43:35 +01:00
Timo K. 79c9900568 Mark everything below the CallView with Pick<> 2026-11-19 22:36:51 +01:00
Timo K. f2207ce21f Make callViewModel declare what it really needs from room (using
`Pick<>`
2026-11-19 21:58:14 +01:00
64 changed files with 2276 additions and 924 deletions
+93
View File
@@ -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;
}
+118
View File
@@ -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 };
}
+108
View File
@@ -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
View File
@@ -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}
-2
View File
@@ -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.",
+5 -5
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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 =
+5
View File
@@ -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,
+17 -14
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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;
}
+85
View File
@@ -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 };
}
+129
View File
@@ -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
View File
@@ -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`. */
+69 -21
View File
@@ -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,
);
+15 -6
View File
@@ -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) {
+5 -2
View File
@@ -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(
+6
View File
@@ -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),
+1
View File
@@ -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;
+42
View File
@@ -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 };
}
+77
View File
@@ -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
View File
@@ -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();
+20 -22
View File
@@ -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 -8
View File
@@ -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,
+35 -27
View File
@@ -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"));
+6 -1
View File
@@ -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;
+173 -57
View File
@@ -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,
+87 -66
View File
@@ -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) {
+40 -38
View File
@@ -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 (
+2 -3
View File
@@ -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
View File
@@ -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
View File
@@ -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);
}}
>
+67 -66
View File
@@ -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
View File
@@ -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: {
+1 -1
View File
@@ -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;
}
-1
View File
@@ -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,
-1
View File
@@ -91,7 +91,6 @@ const matrixInfo = {
avatarUrl: "",
roomId: "!room:example.org",
roomName: "Test Room",
roomAlias: null,
roomAvatar: null,
e2eeSystem: { kind: E2eeType.NONE } satisfies EncryptionSystem,
};
+6 -3
View File
@@ -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
View File
@@ -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}
-1
View File
@@ -19,7 +19,6 @@ describe("VideoPreview", () => {
roomId: "",
roomName: "",
e2eeSystem: { kind: E2eeType.NONE },
roomAlias: null,
roomAvatar: null,
};
-1
View File
@@ -25,7 +25,6 @@ export type MatrixInfo = {
avatarUrl: string;
roomId: string;
roomName: string;
roomAlias: string | null;
roomAvatar: string | null;
e2eeSystem: EncryptionSystem;
};
+4 -2
View File
@@ -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]),
);
}
+8 -3
View File
@@ -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 -1
View File
@@ -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]),
+5 -3
View File
@@ -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 => {};
+44
View File
@@ -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
View File
@@ -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);
}
+13 -1
View File
@@ -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[];
+2 -3
View File
@@ -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();
+21 -2
View File
@@ -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),
);
+14 -3
View File
@@ -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
View File
@@ -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
View File
@@ -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 {
-25
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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(