MatrixRTCSessionManager.ts

/*
Copyright 2023 The Matrix.org Foundation C.I.C.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

import { logger as rootLogger } from "../logger.ts";
import { MatrixClient, ClientEvent } from "../client.ts";
import { TypedEventEmitter } from "../models/typed-event-emitter.ts";
import { Room, RoomEvent } from "../models/room.ts";
import { RoomState, RoomStateEvent } from "../models/room-state.ts";
import { MatrixEvent } from "../models/event.ts";
import { MatrixRTCSession } from "./MatrixRTCSession.ts";
import { EventType } from "../@types/event.ts";
import { EncryptionKeysToDeviceContent } from "./types.ts";

const logger = rootLogger.getChild("MatrixRTCSessionManager");

export enum MatrixRTCSessionManagerEvents {
    // A member has joined the MatrixRTC session, creating an active session in a room where there wasn't previously
    SessionStarted = "session_started",
    // All participants have left a given MatrixRTC session.
    SessionEnded = "session_ended",
}

type EventHandlerMap = {
    [MatrixRTCSessionManagerEvents.SessionStarted]: (roomId: string, session: MatrixRTCSession) => void;
    [MatrixRTCSessionManagerEvents.SessionEnded]: (roomId: string, session: MatrixRTCSession) => void;
};

/**
 * Holds all active MatrixRTC session objects and creates new ones as events arrive.
 * This interface is UNSTABLE and may change without warning.
 */
export class MatrixRTCSessionManager extends TypedEventEmitter<MatrixRTCSessionManagerEvents, EventHandlerMap> {
    // All the room-scoped sessions we know about. This will include any where the app
    // has queried for the MatrixRTC sessions in a room, whether it's ever had any members
    // or not). We keep a (lazily created) session object for every room to ensure that there
    // is only ever one single room session object for any given room for the lifetime of the
    // client: that way there can never be any code holding onto a stale object that is no
    // longer the correct session object for the room.
    private roomSessions = new Map<string, MatrixRTCSession>();

    public constructor(private client: MatrixClient) {
        super();
    }

    public start(): void {
        // We shouldn't need to null-check here, but matrix-client.spec.ts mocks getRooms
        // returning nothing, and breaks tests if you change it to return an empty array :'(
        for (const room of this.client.getRooms() ?? []) {
            const session = MatrixRTCSession.roomSessionForRoom(this.client, room);
            if (session.memberships.length > 0) {
                this.roomSessions.set(room.roomId, session);
            }
        }

        this.client.on(ClientEvent.Room, this.onRoom);
        this.client.on(RoomEvent.Timeline, this.onTimeline);
        this.client.on(RoomStateEvent.Events, this.onRoomState);
        this.client.on(ClientEvent.ToDeviceEvent, this.onToDeviceEvent);
    }

    public stop(): void {
        for (const sess of this.roomSessions.values()) {
            sess.stop();
        }
        this.roomSessions.clear();

        this.client.off(ClientEvent.Room, this.onRoom);
        this.client.off(RoomEvent.Timeline, this.onTimeline);
        this.client.off(RoomStateEvent.Events, this.onRoomState);
        this.client.off(ClientEvent.ToDeviceEvent, this.onToDeviceEvent);
    }

    /**
     * Gets the main MatrixRTC session for a room, or undefined if there is
     * no current session
     */
    public getActiveRoomSession(room: Room): MatrixRTCSession | undefined {
        return this.roomSessions.get(room.roomId)!;
    }

    /**
     * Gets the main MatrixRTC session for a room, returning an empty session
     * if no members are currently participating
     */
    public getRoomSession(room: Room): MatrixRTCSession {
        if (!this.roomSessions.has(room.roomId)) {
            this.roomSessions.set(room.roomId, MatrixRTCSession.roomSessionForRoom(this.client, room));
        }

        return this.roomSessions.get(room.roomId)!;
    }

    private onTimeline = (event: MatrixEvent): void => {
        this.consumeCallEncryptionEvent(event, (event) => event.getRoomId(), false);
    };

    private onToDeviceEvent = (event: MatrixEvent): void => {
        if (!event.isEncrypted()) {
            logger.warn("Ignoring unencrypted to-device call encryption event", event);
            return;
        }
        this.consumeCallEncryptionEvent(
            event,
            (event) => event.getContent<EncryptionKeysToDeviceContent>().room_id,
            false,
        );
    };

    /**
     * @param event - the event to consume
     * @param roomIdExtractor - the function to extract the room id from the event
     * @param isRetry - whether this is a retry. If false we will retry decryption failures once
     */
    private consumeCallEncryptionEvent = async (
        event: MatrixEvent,
        roomIdExtractor: (event: MatrixEvent) => string | undefined,
        isRetry: boolean,
    ): Promise<void> => {
        await this.client.decryptEventIfNeeded(event);
        if (event.isDecryptionFailure()) {
            if (!isRetry) {
                logger.warn(
                    `Decryption failed for event ${event.getId()}: ${event.decryptionFailureReason} will retry once only`,
                );
                // retry after 1 second. After this we give up.
                setTimeout(() => this.consumeCallEncryptionEvent(event, roomIdExtractor, true), 1000);
            } else {
                logger.warn(`Decryption failed for event ${event.getId()}: ${event.decryptionFailureReason}`);
            }
            return;
        } else if (isRetry) {
            logger.info(`Decryption succeeded for event ${event.getId()} after retry`);
        }

        if (event.getType() !== EventType.CallEncryptionKeysPrefix) return;
        const roomId = roomIdExtractor(event);
        if (!roomId) {
            logger.error("Received call encryption event with no room_id!");
            return;
        }

        const room = this.client.getRoom(roomId);

        if (!room) {
            logger.error(`Got encryption event for unknown room ${roomId}!`);
            return;
        }
        this.getRoomSession(room).onCallEncryption(event);
    };

    private onRoom = (room: Room): void => {
        this.refreshRoom(room);
    };

    private onRoomState = (event: MatrixEvent, _state: RoomState): void => {
        const room = this.client.getRoom(event.getRoomId());
        if (!room) {
            logger.error(`Got room state event for unknown room ${event.getRoomId()}!`);
            return;
        }

        if (event.getType() == EventType.GroupCallMemberPrefix) {
            this.refreshRoom(room);
        }
    };

    private refreshRoom(room: Room): void {
        const isNewSession = !this.roomSessions.has(room.roomId);
        const sess = this.getRoomSession(room);

        const wasActiveAndKnown = sess.memberships.length > 0 && !isNewSession;

        sess.onMembershipUpdate();

        const nowActive = sess.memberships.length > 0;

        if (wasActiveAndKnown && !nowActive) {
            this.emit(MatrixRTCSessionManagerEvents.SessionEnded, room.roomId, this.roomSessions.get(room.roomId)!);
        } else if (!wasActiveAndKnown && nowActive) {
            this.emit(MatrixRTCSessionManagerEvents.SessionStarted, room.roomId, this.roomSessions.get(room.roomId)!);
        }
    }
}