mirror of
https://github.com/vector-im/element-call.git
synced 2026-10-16 23:45:50 +00:00
Robin
b4bd1f81a0
The OpenID flow moves to src/livekit/auth/openID.ts with the SFU config types in a sibling file, takes an options object, and replaces the MatrixRTC mode with the role we take on the transport plus the session's slot ID instead of a hard-coded m.call#ROOM. This changes behaviour: publishers on a livekit_service_url transport always use the legacy /sfu/get endpoint, so that subscribers can predict their user:device participant identity, and subscribers always use the default /get_token endpoint. The MatrixRTC mode no longer influences which endpoint is used. On the SDK this lands as sdk/src/media-backend/livekit/auth/ with the connection map, the discriminated connection state and the client-server API flow of the following commits of element-hq/element-call#4331, which rewrite the same files: - Model ConnectionState as a discriminated union - Show the whole transport in debug UI and logs (SDK part) - Let the publishing Connection authenticate itself - Reduce ConnectionManager to a ConnectionMap - Use the unstable LiveKit transport type - Identify transports by server name as well as URLs - Get SFU tokens and delegate delayed leaves through the MSC4195 CS API - Fall back to get_token as subscriber on widget API errors - Share a connection between homeservers using the same JWT service - Make the auth choice mode independent again Co-authored-by: Johannes Marbach <n0-0ne+github@mailbox.org> (cherry picked from commit adb380cd9ed108856e42d992fc03ced8c44f1e56)
120 lines
3.2 KiB
TypeScript
120 lines
3.2 KiB
TypeScript
/*
|
|
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 {
|
|
ConnectionState as LivekitConnectionState,
|
|
type RemoteParticipant,
|
|
type Room as LivekitRoom,
|
|
RoomEvent,
|
|
} from "livekit-client";
|
|
import {
|
|
distinctUntilChanged,
|
|
filter,
|
|
fromEvent,
|
|
map,
|
|
merge,
|
|
type Observable,
|
|
share,
|
|
switchMap,
|
|
} from "rxjs";
|
|
|
|
import { type Behavior } from "../../reactive/Behavior";
|
|
import {
|
|
type Epoch,
|
|
type ObservableScope,
|
|
} from "../../reactive/ObservableScope";
|
|
import { type DataPacket } from "../api";
|
|
import { type Connection } from "./Connection";
|
|
import { type ConnectionMap } from "./ConnectionMap";
|
|
|
|
interface Props {
|
|
scope: ObservableScope;
|
|
connectionMap$: Behavior<Epoch<ConnectionMap>>;
|
|
/** The local member's connection, which carries what we send. */
|
|
connection$: Behavior<Connection | null>;
|
|
}
|
|
|
|
export interface DataChannel {
|
|
data$: Observable<DataPacket>;
|
|
sendData: (topic: string, text: string) => Promise<void>;
|
|
}
|
|
|
|
/**
|
|
* A text channel beside the media: LiveKit's reliable data packets, received
|
|
* on every connection the client holds and sent on the local member's. The
|
|
* sender is reported by its identity; the packet's own claim of who sent it
|
|
* never reaches the host.
|
|
*/
|
|
export function createDataChannel$({
|
|
scope,
|
|
connectionMap$,
|
|
connection$,
|
|
}: Props): DataChannel {
|
|
const decoder = new TextDecoder();
|
|
const encoder = new TextEncoder();
|
|
|
|
const rooms$ = connectionMap$.pipe(
|
|
map(({ value }) => value.getConnections().map((c) => c.livekitRoom)),
|
|
distinctUntilChanged(
|
|
(a, b) => a.length === b.length && a.every((room, i) => room === b[i]),
|
|
),
|
|
);
|
|
|
|
const data$ = rooms$.pipe(
|
|
switchMap((rooms) => merge(...rooms.map(receivedOn))),
|
|
map(({ payload, participant, topic }): DataPacket | null =>
|
|
// Only the server sends without a participant; a host has no use for it
|
|
participant === undefined
|
|
? null
|
|
: {
|
|
senderId: participant.identity,
|
|
topic: topic ?? "",
|
|
text: decoder.decode(payload),
|
|
},
|
|
),
|
|
filter((packet) => packet !== null),
|
|
scope.bind(),
|
|
share(),
|
|
);
|
|
|
|
const sendData = async (topic: string, text: string): Promise<void> => {
|
|
const connection = connection$.value;
|
|
const state = connection?.state$.value;
|
|
if (
|
|
connection === null ||
|
|
state?.state !== "authenticated" ||
|
|
state.livekitState !== LivekitConnectionState.Connected
|
|
)
|
|
throw new Error("Cannot send data: the local transport is not connected");
|
|
await connection.livekitRoom.localParticipant.publishData(
|
|
encoder.encode(text),
|
|
{ reliable: true, topic },
|
|
);
|
|
};
|
|
|
|
return { data$, sendData };
|
|
}
|
|
|
|
interface Received {
|
|
payload: Uint8Array;
|
|
participant: RemoteParticipant | undefined;
|
|
topic: string | undefined;
|
|
}
|
|
|
|
function receivedOn(room: LivekitRoom): Observable<Received> {
|
|
return fromEvent(
|
|
room,
|
|
RoomEvent.DataReceived,
|
|
(
|
|
payload: Uint8Array,
|
|
participant?: RemoteParticipant,
|
|
_kind?: unknown,
|
|
topic?: string,
|
|
): Received => ({ payload, participant, topic }),
|
|
);
|
|
}
|