@unwanted/matrix-sdk-mini 34.12.0-1 → 34.12.0-2

package/src/webrtc/groupCall.ts

@@ -1,1735 +0,0 @@
-import { TypedEventEmitter } from "../models/typed-event-emitter.ts";
-import { CallFeed, SPEAKING_THRESHOLD } from "./callFeed.ts";
-import { MatrixClient, IMyDevice } from "../client.ts";
-import {
-    CallErrorCode,
-    CallEvent,
-    CallEventHandlerMap,
-    CallState,
-    genCallID,
-    MatrixCall,
-    setTracksEnabled,
-    createNewMatrixCall,
-    CallError,
-} from "./call.ts";
-import { RoomMember } from "../models/room-member.ts";
-import { Room } from "../models/room.ts";
-import { RoomStateEvent } from "../models/room-state.ts";
-import { logger } from "../logger.ts";
-import { ReEmitter } from "../ReEmitter.ts";
-import { SDPStreamMetadataPurpose } from "./callEventTypes.ts";
-import { MatrixEvent } from "../models/event.ts";
-import { EventType } from "../@types/event.ts";
-import { CallEventHandlerEvent } from "./callEventHandler.ts";
-import { GroupCallEventHandlerEvent } from "./groupCallEventHandler.ts";
-import { IScreensharingOpts } from "./mediaHandler.ts";
-import { mapsEqual } from "../utils.ts";
-import { GroupCallStats } from "./stats/groupCallStats.ts";
-import {
-    ByteSentStatsReport,
-    CallFeedReport,
-    ConnectionStatsReport,
-    StatsReport,
-    SummaryStatsReport,
-} from "./stats/statsReport.ts";
-import { SummaryStatsReportGatherer } from "./stats/summaryStatsReportGatherer.ts";
-import { CallFeedStatsReporter } from "./stats/callFeedStatsReporter.ts";
-import { KnownMembership } from "../@types/membership.ts";
-import { CallMembershipData } from "../matrixrtc/CallMembership.ts";
-
-export enum GroupCallIntent {
-    Ring = "m.ring",
-    Prompt = "m.prompt",
-    Room = "m.room",
-}
-
-export enum GroupCallType {
-    Video = "m.video",
-    Voice = "m.voice",
-}
-
-export enum GroupCallTerminationReason {
-    CallEnded = "call_ended",
-}
-
-export type CallsByUserAndDevice = Map<string, Map<string, MatrixCall>>;
-
-/**
- * Because event names are just strings, they do need
- * to be unique over all event types of event emitter.
- * Some objects could emit more then one set of events.
- */
-export enum GroupCallEvent {
-    GroupCallStateChanged = "group_call_state_changed",
-    ActiveSpeakerChanged = "active_speaker_changed",
-    CallsChanged = "calls_changed",
-    UserMediaFeedsChanged = "user_media_feeds_changed",
-    ScreenshareFeedsChanged = "screenshare_feeds_changed",
-    LocalScreenshareStateChanged = "local_screenshare_state_changed",
-    LocalMuteStateChanged = "local_mute_state_changed",
-    ParticipantsChanged = "participants_changed",
-    Error = "group_call_error",
-}
-
-export type GroupCallEventHandlerMap = {
-    [GroupCallEvent.GroupCallStateChanged]: (newState: GroupCallState, oldState: GroupCallState) => void;
-    [GroupCallEvent.ActiveSpeakerChanged]: (activeSpeaker: CallFeed | undefined) => void;
-    [GroupCallEvent.CallsChanged]: (calls: CallsByUserAndDevice) => void;
-    [GroupCallEvent.UserMediaFeedsChanged]: (feeds: CallFeed[]) => void;
-    [GroupCallEvent.ScreenshareFeedsChanged]: (feeds: CallFeed[]) => void;
-    [GroupCallEvent.LocalScreenshareStateChanged]: (
-        isScreensharing: boolean,
-        feed?: CallFeed,
-        sourceId?: string,
-    ) => void;
-    [GroupCallEvent.LocalMuteStateChanged]: (audioMuted: boolean, videoMuted: boolean) => void;
-    [GroupCallEvent.ParticipantsChanged]: (participants: Map<RoomMember, Map<string, ParticipantState>>) => void;
-    /**
-     * Fires whenever an error occurs when call.js encounters an issue with setting up the call.
-     * <p>
-     * The error given will have a code equal to either `MatrixCall.ERR_LOCAL_OFFER_FAILED` or
-     * `MatrixCall.ERR_NO_USER_MEDIA`. `ERR_LOCAL_OFFER_FAILED` is emitted when the local client
-     * fails to create an offer. `ERR_NO_USER_MEDIA` is emitted when the user has denied access
-     * to their audio/video hardware.
-     * @param error - The error raised by MatrixCall.
-     * @example
-     * ```
-     * matrixCall.on("error", function(err){
-     *   console.error(err.code, err);
-     * });
-     * ```
-     */
-    [GroupCallEvent.Error]: (error: GroupCallError) => void;
-};
-
-export enum GroupCallStatsReportEvent {
-    ConnectionStats = "GroupCall.connection_stats",
-    ByteSentStats = "GroupCall.byte_sent_stats",
-    SummaryStats = "GroupCall.summary_stats",
-    CallFeedStats = "GroupCall.call_feed_stats",
-}
-
-/**
- * The final report-events that get consumed by client.
- */
-export type GroupCallStatsReportEventHandlerMap = {
-    [GroupCallStatsReportEvent.ConnectionStats]: (report: GroupCallStatsReport<ConnectionStatsReport>) => void;
-    [GroupCallStatsReportEvent.ByteSentStats]: (report: GroupCallStatsReport<ByteSentStatsReport>) => void;
-    [GroupCallStatsReportEvent.SummaryStats]: (report: GroupCallStatsReport<SummaryStatsReport>) => void;
-    [GroupCallStatsReportEvent.CallFeedStats]: (report: GroupCallStatsReport<CallFeedReport>) => void;
-};
-
-export enum GroupCallErrorCode {
-    NoUserMedia = "no_user_media",
-    UnknownDevice = "unknown_device",
-    PlaceCallFailed = "place_call_failed",
-}
-
-export interface GroupCallStatsReport<
-    T extends ConnectionStatsReport | ByteSentStatsReport | SummaryStatsReport | CallFeedReport,
-> {
-    report: T;
-}
-
-export class GroupCallError extends Error {
-    public code: string;
-
-    public constructor(code: GroupCallErrorCode, msg: string, err?: Error) {
-        // Still don't think there's any way to have proper nested errors
-        if (err) {
-            super(msg + ": " + err);
-        } else {
-            super(msg);
-        }
-
-        this.code = code;
-    }
-}
-
-export class GroupCallUnknownDeviceError extends GroupCallError {
-    public constructor(public userId: string) {
-        super(GroupCallErrorCode.UnknownDevice, "No device found for " + userId);
-    }
-}
-
-export class OtherUserSpeakingError extends Error {
-    public constructor() {
-        super("Cannot unmute: another user is speaking");
-    }
-}
-
-export interface IGroupCallDataChannelOptions {
-    ordered: boolean;
-    maxPacketLifeTime: number;
-    maxRetransmits: number;
-    protocol: string;
-}
-
-export interface IGroupCallRoomState {
-    "m.intent": GroupCallIntent;
-    "m.type": GroupCallType;
-    "m.terminated"?: GroupCallTerminationReason;
-    "io.element.ptt"?: boolean;
-    // TODO: Specify data-channels
-    "dataChannelsEnabled"?: boolean;
-    "dataChannelOptions"?: IGroupCallDataChannelOptions;
-
-    "io.element.livekit_service_url"?: string;
-}
-
-export interface IGroupCallRoomMemberFeed {
-    purpose: SDPStreamMetadataPurpose;
-}
-
-export interface IGroupCallRoomMemberDevice {
-    device_id: string;
-    session_id: string;
-    expires_ts: number;
-    feeds: IGroupCallRoomMemberFeed[];
-}
-
-export interface IGroupCallRoomMemberCallState {
-    "m.call_id": string;
-    "m.foci"?: string[];
-    "m.devices": IGroupCallRoomMemberDevice[];
-}
-
-export interface IGroupCallRoomMemberState {
-    "m.calls": IGroupCallRoomMemberCallState[];
-}
-
-// XXX: this hasn't made it into the MSC yet
-export interface ExperimentalGroupCallRoomMemberState {
-    memberships: CallMembershipData[];
-}
-
-export enum GroupCallState {
-    LocalCallFeedUninitialized = "local_call_feed_uninitialized",
-    InitializingLocalCallFeed = "initializing_local_call_feed",
-    LocalCallFeedInitialized = "local_call_feed_initialized",
-    Entered = "entered",
-    Ended = "ended",
-}
-
-export interface ParticipantState {
-    sessionId: string;
-    screensharing: boolean;
-}
-
-interface ICallHandlers {
-    onCallFeedsChanged: (feeds: CallFeed[]) => void;
-    onCallStateChanged: (state: CallState, oldState: CallState | undefined) => void;
-    onCallHangup: (call: MatrixCall) => void;
-    onCallReplaced: (newCall: MatrixCall) => void;
-}
-
-const DEVICE_TIMEOUT = 1000 * 60 * 60; // 1 hour
-
-function getCallUserId(call: MatrixCall): string | null {
-    return call.getOpponentMember()?.userId || call.invitee || null;
-}
-
-export class GroupCall extends TypedEventEmitter<
-    GroupCallEvent | CallEvent | GroupCallStatsReportEvent,
-    GroupCallEventHandlerMap & CallEventHandlerMap & GroupCallStatsReportEventHandlerMap
-> {
-    // Config
-    public activeSpeakerInterval = 1000;
-    public retryCallInterval = 5000;
-    public participantTimeout = 1000 * 15;
-    public pttMaxTransmitTime = 1000 * 20;
-
-    public activeSpeaker?: CallFeed;
-    public localCallFeed?: CallFeed;
-    public localScreenshareFeed?: CallFeed;
-    public localDesktopCapturerSourceId?: string;
-    public readonly userMediaFeeds: CallFeed[] = [];
-    public readonly screenshareFeeds: CallFeed[] = [];
-    public groupCallId: string;
-    public readonly allowCallWithoutVideoAndAudio: boolean;
-
-    private readonly calls = new Map<string, Map<string, MatrixCall>>(); // user_id -> device_id -> MatrixCall
-    private callHandlers = new Map<string, Map<string, ICallHandlers>>(); // user_id -> device_id -> ICallHandlers
-    private activeSpeakerLoopInterval?: ReturnType<typeof setTimeout>;
-    private retryCallLoopInterval?: ReturnType<typeof setTimeout>;
-    private retryCallCounts: Map<string, Map<string, number>> = new Map(); // user_id -> device_id -> count
-    private reEmitter: ReEmitter;
-    private transmitTimer: ReturnType<typeof setTimeout> | null = null;
-    private participantsExpirationTimer: ReturnType<typeof setTimeout> | null = null;
-    private resendMemberStateTimer: ReturnType<typeof setInterval> | null = null;
-    private initWithAudioMuted = false;
-    private initWithVideoMuted = false;
-    private initCallFeedPromise?: Promise<void>;
-    private _livekitServiceURL?: string;
-
-    private stats: GroupCallStats | undefined;
-    /**
-     * Configure default webrtc stats collection interval in ms
-     * Disable collecting webrtc stats by setting interval to 0
-     */
-    private statsCollectIntervalTime = 0;
-
-    public constructor(
-        private client: MatrixClient,
-        public room: Room,
-        public type: GroupCallType,
-        public isPtt: boolean,
-        public intent: GroupCallIntent,
-        groupCallId?: string,
-        private dataChannelsEnabled?: boolean,
-        private dataChannelOptions?: IGroupCallDataChannelOptions,
-        isCallWithoutVideoAndAudio?: boolean,
-        // this tells the js-sdk not to actually establish any calls to exchange media and just to
-        // create the group call signaling events, with the intention that the actual media will be
-        // handled using livekit. The js-sdk doesn't contain any code to do the actual livekit call though.
-        private useLivekit = false,
-        livekitServiceURL?: string,
-    ) {
-        super();
-        this.reEmitter = new ReEmitter(this);
-        this.groupCallId = groupCallId ?? genCallID();
-        this._livekitServiceURL = livekitServiceURL;
-        this.creationTs =
-            room.currentState.getStateEvents(EventType.GroupCallPrefix, this.groupCallId)?.getTs() ?? null;
-        this.updateParticipants();
-
-        room.on(RoomStateEvent.Update, this.onRoomState);
-        this.on(GroupCallEvent.ParticipantsChanged, this.onParticipantsChanged);
-        this.on(GroupCallEvent.GroupCallStateChanged, this.onStateChanged);
-        this.on(GroupCallEvent.LocalScreenshareStateChanged, this.onLocalFeedsChanged);
-        this.allowCallWithoutVideoAndAudio = !!isCallWithoutVideoAndAudio;
-    }
-
-    private onConnectionStats = (report: ConnectionStatsReport): void => {
-        // Final emit of the summary event, to be consumed by the client
-        this.emit(GroupCallStatsReportEvent.ConnectionStats, { report });
-    };
-
-    private onByteSentStats = (report: ByteSentStatsReport): void => {
-        // Final emit of the summary event, to be consumed by the client
-        this.emit(GroupCallStatsReportEvent.ByteSentStats, { report });
-    };
-
-    private onSummaryStats = (report: SummaryStatsReport): void => {
-        SummaryStatsReportGatherer.extendSummaryReport(report, this.participants);
-        // Final emit of the summary event, to be consumed by the client
-        this.emit(GroupCallStatsReportEvent.SummaryStats, { report });
-    };
-
-    private onCallFeedReport = (report: CallFeedReport): void => {
-        if (this.localCallFeed) {
-            report = CallFeedStatsReporter.expandCallFeedReport(report, [this.localCallFeed], "from-local-feed");
-        }
-
-        const callFeeds: CallFeed[] = [];
-        this.forEachCall((call) => {
-            if (call.callId === report.callId) {
-                call.getFeeds().forEach((f) => callFeeds.push(f));
-            }
-        });
-
-        report = CallFeedStatsReporter.expandCallFeedReport(report, callFeeds, "from-call-feed");
-        this.emit(GroupCallStatsReportEvent.CallFeedStats, { report });
-    };
-
-    public async create(): Promise<GroupCall> {
-        this.creationTs = Date.now();
-        this.client.groupCallEventHandler!.groupCalls.set(this.room.roomId, this);
-        this.client.emit(GroupCallEventHandlerEvent.Outgoing, this);
-
-        await this.sendCallStateEvent();
-
-        return this;
-    }
-
-    private async sendCallStateEvent(): Promise<void> {
-        const groupCallState: IGroupCallRoomState = {
-            "m.intent": this.intent,
-            "m.type": this.type,
-            "io.element.ptt": this.isPtt,
-            // TODO: Specify data-channels better
-            "dataChannelsEnabled": this.dataChannelsEnabled,
-            "dataChannelOptions": this.dataChannelsEnabled ? this.dataChannelOptions : undefined,
-        };
-        if (this.livekitServiceURL) {
-            groupCallState["io.element.livekit_service_url"] = this.livekitServiceURL;
-        }
-
-        await this.client.sendStateEvent(this.room.roomId, EventType.GroupCallPrefix, groupCallState, this.groupCallId);
-    }
-
-    public get livekitServiceURL(): string | undefined {
-        return this._livekitServiceURL;
-    }
-
-    public updateLivekitServiceURL(newURL: string): Promise<void> {
-        this._livekitServiceURL = newURL;
-        return this.sendCallStateEvent();
-    }
-
-    private _state = GroupCallState.LocalCallFeedUninitialized;
-
-    /**
-     * The group call's state.
-     */
-    public get state(): GroupCallState {
-        return this._state;
-    }
-
-    private set state(value: GroupCallState) {
-        const prevValue = this._state;
-        if (value !== prevValue) {
-            this._state = value;
-            this.emit(GroupCallEvent.GroupCallStateChanged, value, prevValue);
-        }
-    }
-
-    private _participants = new Map<RoomMember, Map<string, ParticipantState>>();
-
-    /**
-     * The current participants in the call, as a map from members to device IDs
-     * to participant info.
-     */
-    public get participants(): Map<RoomMember, Map<string, ParticipantState>> {
-        return this._participants;
-    }
-
-    private set participants(value: Map<RoomMember, Map<string, ParticipantState>>) {
-        const prevValue = this._participants;
-        const participantStateEqual = (x: ParticipantState, y: ParticipantState): boolean =>
-            x.sessionId === y.sessionId && x.screensharing === y.screensharing;
-        const deviceMapsEqual = (x: Map<string, ParticipantState>, y: Map<string, ParticipantState>): boolean =>
-            mapsEqual(x, y, participantStateEqual);
-
-        // Only update if the map actually changed
-        if (!mapsEqual(value, prevValue, deviceMapsEqual)) {
-            this._participants = value;
-            this.emit(GroupCallEvent.ParticipantsChanged, value);
-        }
-    }
-
-    private _creationTs: number | null = null;
-
-    /**
-     * The timestamp at which the call was created, or null if it has not yet
-     * been created.
-     */
-    public get creationTs(): number | null {
-        return this._creationTs;
-    }
-
-    private set creationTs(value: number | null) {
-        this._creationTs = value;
-    }
-
-    private _enteredViaAnotherSession = false;
-
-    /**
-     * Whether the local device has entered this call via another session, such
-     * as a widget.
-     */
-    public get enteredViaAnotherSession(): boolean {
-        return this._enteredViaAnotherSession;
-    }
-
-    public set enteredViaAnotherSession(value: boolean) {
-        this._enteredViaAnotherSession = value;
-        this.updateParticipants();
-    }
-
-    /**
-     * Executes the given callback on all calls in this group call.
-     * @param f - The callback.
-     */
-    public forEachCall(f: (call: MatrixCall) => void): void {
-        for (const deviceMap of this.calls.values()) {
-            for (const call of deviceMap.values()) f(call);
-        }
-    }
-
-    public getLocalFeeds(): CallFeed[] {
-        const feeds: CallFeed[] = [];
-
-        if (this.localCallFeed) feeds.push(this.localCallFeed);
-        if (this.localScreenshareFeed) feeds.push(this.localScreenshareFeed);
-
-        return feeds;
-    }
-
-    public hasLocalParticipant(): boolean {
-        return (
-            this.participants.get(this.room.getMember(this.client.getUserId()!)!)?.has(this.client.getDeviceId()!) ??
-            false
-        );
-    }
-
-    /**
-     * Determines whether the given call is one that we were expecting to exist
-     * given our knowledge of who is participating in the group call.
-     */
-    private callExpected(call: MatrixCall): boolean {
-        const userId = getCallUserId(call);
-        const member = userId === null ? null : this.room.getMember(userId);
-        const deviceId = call.getOpponentDeviceId();
-        return member !== null && deviceId !== undefined && this.participants.get(member)?.get(deviceId) !== undefined;
-    }
-
-    public async initLocalCallFeed(): Promise<void> {
-        if (this.useLivekit) {
-            logger.info("Livekit group call: not starting local call feed.");
-            return;
-        }
-
-        if (this.state !== GroupCallState.LocalCallFeedUninitialized) {
-            throw new Error(`Cannot initialize local call feed in the "${this.state}" state.`);
-        }
-        this.state = GroupCallState.InitializingLocalCallFeed;
-
-        // wraps the real method to serialise calls, because we don't want to try starting
-        // multiple call feeds at once
-        if (this.initCallFeedPromise) return this.initCallFeedPromise;
-
-        try {
-            this.initCallFeedPromise = this.initLocalCallFeedInternal();
-            await this.initCallFeedPromise;
-        } finally {
-            this.initCallFeedPromise = undefined;
-        }
-    }
-
-    private async initLocalCallFeedInternal(): Promise<void> {
-        logger.log(`GroupCall ${this.groupCallId} initLocalCallFeedInternal() running`);
-
-        let stream: MediaStream;
-
-        try {
-            stream = await this.client.getMediaHandler().getUserMediaStream(true, this.type === GroupCallType.Video);
-        } catch (error) {
-            // If is allowed to join a call without a media stream, then we
-            // don't throw an error here. But we need an empty Local Feed to establish
-            // a connection later.
-            if (this.allowCallWithoutVideoAndAudio) {
-                stream = new MediaStream();
-            } else {
-                this.state = GroupCallState.LocalCallFeedUninitialized;
-                throw error;
-            }
-        }
-
-        // The call could've been disposed while we were waiting, and could
-        // also have been started back up again (hello, React 18) so if we're
-        // still in this 'initializing' state, carry on, otherwise bail.
-        if (this._state !== GroupCallState.InitializingLocalCallFeed) {
-            this.client.getMediaHandler().stopUserMediaStream(stream);
-            throw new Error("Group call disposed while gathering media stream");
-        }
-
-        const callFeed = new CallFeed({
-            client: this.client,
-            roomId: this.room.roomId,
-            userId: this.client.getUserId()!,
-            deviceId: this.client.getDeviceId()!,
-            stream,
-            purpose: SDPStreamMetadataPurpose.Usermedia,
-            audioMuted: this.initWithAudioMuted || stream.getAudioTracks().length === 0 || this.isPtt,
-            videoMuted: this.initWithVideoMuted || stream.getVideoTracks().length === 0,
-        });
-
-        setTracksEnabled(stream.getAudioTracks(), !callFeed.isAudioMuted());
-        setTracksEnabled(stream.getVideoTracks(), !callFeed.isVideoMuted());
-
-        this.localCallFeed = callFeed;
-        this.addUserMediaFeed(callFeed);
-
-        this.state = GroupCallState.LocalCallFeedInitialized;
-    }
-
-    public async updateLocalUsermediaStream(stream: MediaStream): Promise<void> {
-        if (this.localCallFeed) {
-            const oldStream = this.localCallFeed.stream;
-            this.localCallFeed.setNewStream(stream);
-            const micShouldBeMuted = this.localCallFeed.isAudioMuted();
-            const vidShouldBeMuted = this.localCallFeed.isVideoMuted();
-            logger.log(
-                `GroupCall ${this.groupCallId} updateLocalUsermediaStream() (oldStreamId=${oldStream.id}, newStreamId=${stream.id}, micShouldBeMuted=${micShouldBeMuted}, vidShouldBeMuted=${vidShouldBeMuted})`,
-            );
-            setTracksEnabled(stream.getAudioTracks(), !micShouldBeMuted);
-            setTracksEnabled(stream.getVideoTracks(), !vidShouldBeMuted);
-            this.client.getMediaHandler().stopUserMediaStream(oldStream);
-        }
-    }
-
-    public async enter(): Promise<void> {
-        if (this.state === GroupCallState.LocalCallFeedUninitialized) {
-            await this.initLocalCallFeed();
-        } else if (this.state !== GroupCallState.LocalCallFeedInitialized) {
-            throw new Error(`Cannot enter call in the "${this.state}" state`);
-        }
-
-        logger.log(`GroupCall ${this.groupCallId} enter() running`);
-        this.state = GroupCallState.Entered;
-
-        this.client.on(CallEventHandlerEvent.Incoming, this.onIncomingCall);
-
-        for (const call of this.client.callEventHandler!.calls.values()) {
-            this.onIncomingCall(call);
-        }
-
-        if (!this.useLivekit) {
-            this.retryCallLoopInterval = setInterval(this.onRetryCallLoop, this.retryCallInterval);
-
-            this.activeSpeaker = undefined;
-            this.onActiveSpeakerLoop();
-            this.activeSpeakerLoopInterval = setInterval(this.onActiveSpeakerLoop, this.activeSpeakerInterval);
-        }
-    }
-
-    private dispose(): void {
-        if (this.localCallFeed) {
-            this.removeUserMediaFeed(this.localCallFeed);
-            this.localCallFeed = undefined;
-        }
-
-        if (this.localScreenshareFeed) {
-            this.client.getMediaHandler().stopScreensharingStream(this.localScreenshareFeed.stream);
-            this.removeScreenshareFeed(this.localScreenshareFeed);
-            this.localScreenshareFeed = undefined;
-            this.localDesktopCapturerSourceId = undefined;
-        }
-
-        this.client.getMediaHandler().stopAllStreams();
-
-        if (this.transmitTimer !== null) {
-            clearTimeout(this.transmitTimer);
-            this.transmitTimer = null;
-        }
-
-        if (this.retryCallLoopInterval !== undefined) {
-            clearInterval(this.retryCallLoopInterval);
-            this.retryCallLoopInterval = undefined;
-        }
-
-        if (this.participantsExpirationTimer !== null) {
-            clearTimeout(this.participantsExpirationTimer);
-            this.participantsExpirationTimer = null;
-        }
-
-        if (this.state !== GroupCallState.Entered) {
-            return;
-        }
-
-        this.forEachCall((call) => call.hangup(CallErrorCode.UserHangup, false));
-
-        this.activeSpeaker = undefined;
-        clearInterval(this.activeSpeakerLoopInterval);
-
-        this.retryCallCounts.clear();
-        clearInterval(this.retryCallLoopInterval);
-
-        this.client.removeListener(CallEventHandlerEvent.Incoming, this.onIncomingCall);
-        this.stats?.stop();
-    }
-
-    public leave(): void {
-        this.dispose();
-        this.state = GroupCallState.LocalCallFeedUninitialized;
-    }
-
-    public async terminate(emitStateEvent = true): Promise<void> {
-        this.dispose();
-
-        this.room.off(RoomStateEvent.Update, this.onRoomState);
-        this.client.groupCallEventHandler!.groupCalls.delete(this.room.roomId);
-        this.client.emit(GroupCallEventHandlerEvent.Ended, this);
-        this.state = GroupCallState.Ended;
-
-        if (emitStateEvent) {
-            const existingStateEvent = this.room.currentState.getStateEvents(
-                EventType.GroupCallPrefix,
-                this.groupCallId,
-            )!;
-
-            await this.client.sendStateEvent(
-                this.room.roomId,
-                EventType.GroupCallPrefix,
-                {
-                    ...existingStateEvent.getContent(),
-                    "m.terminated": GroupCallTerminationReason.CallEnded,
-                },
-                this.groupCallId,
-            );
-        }
-    }
-
-    /*
-     * Local Usermedia
-     */
-
-    public isLocalVideoMuted(): boolean {
-        if (this.localCallFeed) {
-            return this.localCallFeed.isVideoMuted();
-        }
-
-        return true;
-    }
-
-    public isMicrophoneMuted(): boolean {
-        if (this.localCallFeed) {
-            return this.localCallFeed.isAudioMuted();
-        }
-
-        return true;
-    }
-
-    /**
-     * Sets the mute state of the local participants's microphone.
-     * @param muted - Whether to mute the microphone
-     * @returns Whether muting/unmuting was successful
-     */
-    public async setMicrophoneMuted(muted: boolean): Promise<boolean> {
-        // hasAudioDevice can block indefinitely if the window has lost focus,
-        // and it doesn't make much sense to keep a device from being muted, so
-        // we always allow muted = true changes to go through
-        if (!muted && !(await this.client.getMediaHandler().hasAudioDevice())) {
-            return false;
-        }
-
-        const sendUpdatesBefore = !muted && this.isPtt;
-
-        // set a timer for the maximum transmit time on PTT calls
-        if (this.isPtt) {
-            // Set or clear the max transmit timer
-            if (!muted && this.isMicrophoneMuted()) {
-                this.transmitTimer = setTimeout(() => {
-                    this.setMicrophoneMuted(true);
-                }, this.pttMaxTransmitTime);
-            } else if (muted && !this.isMicrophoneMuted()) {
-                if (this.transmitTimer !== null) clearTimeout(this.transmitTimer);
-                this.transmitTimer = null;
-            }
-        }
-
-        this.forEachCall((call) => call.localUsermediaFeed?.setAudioVideoMuted(muted, null));
-
-        const sendUpdates = async (): Promise<void> => {
-            const updates: Promise<void>[] = [];
-            this.forEachCall((call) => updates.push(call.sendMetadataUpdate()));
-
-            await Promise.all(updates).catch((e) =>
-                logger.info(
-                    `GroupCall ${this.groupCallId} setMicrophoneMuted() failed to send some metadata updates`,
-                    e,
-                ),
-            );
-        };
-
-        if (sendUpdatesBefore) await sendUpdates();
-
-        if (this.localCallFeed) {
-            logger.log(
-                `GroupCall ${this.groupCallId} setMicrophoneMuted() (streamId=${this.localCallFeed.stream.id}, muted=${muted})`,
-            );
-
-            const hasPermission = await this.checkAudioPermissionIfNecessary(muted);
-
-            if (!hasPermission) {
-                return false;
-            }
-
-            this.localCallFeed.setAudioVideoMuted(muted, null);
-            // I don't believe its actually necessary to enable these tracks: they
-            // are the one on the GroupCall's own CallFeed and are cloned before being
-            // given to any of the actual calls, so these tracks don't actually go
-            // anywhere. Let's do it anyway to avoid confusion.
-            setTracksEnabled(this.localCallFeed.stream.getAudioTracks(), !muted);
-        } else {
-            logger.log(`GroupCall ${this.groupCallId} setMicrophoneMuted() no stream muted (muted=${muted})`);
-            this.initWithAudioMuted = muted;
-        }
-
-        this.forEachCall((call) =>
-            setTracksEnabled(call.localUsermediaFeed!.stream.getAudioTracks(), !muted && this.callExpected(call)),
-        );
-        this.emit(GroupCallEvent.LocalMuteStateChanged, muted, this.isLocalVideoMuted());
-
-        if (!sendUpdatesBefore) await sendUpdates();
-
-        return true;
-    }
-
-    /**
-     * If we allow entering a call without a camera and without video, it can happen that the access rights to the
-     * devices have not yet been queried. If a stream does not yet have an audio track, we assume that the rights have
-     * not yet been checked.
-     *
-     * `this.client.getMediaHandler().getUserMediaStream` clones the current stream, so it only wanted to be called when
-     * not Audio Track exists.
-     * As such, this is a compromise, because, the access rights should always be queried before the call.
-     */
-    private async checkAudioPermissionIfNecessary(muted: boolean): Promise<boolean> {
-        // We needed this here to avoid an error in case user join a call without a device.
-        try {
-            if (!muted && this.localCallFeed && !this.localCallFeed.hasAudioTrack) {
-                const stream = await this.client
-                    .getMediaHandler()
-                    .getUserMediaStream(true, !this.localCallFeed.isVideoMuted());
-                if (stream?.getTracks().length === 0) {
-                    // if case permission denied to get a stream stop this here
-                    /* istanbul ignore next */
-                    logger.log(
-                        `GroupCall ${this.groupCallId} setMicrophoneMuted() no device to receive local stream, muted=${muted}`,
-                    );
-                    return false;
-                }
-            }
-        } catch {
-            /* istanbul ignore next */
-            logger.log(
-                `GroupCall ${this.groupCallId} setMicrophoneMuted() no device or permission to receive local stream, muted=${muted}`,
-            );
-            return false;
-        }
-
-        return true;
-    }
-
-    /**
-     * Sets the mute state of the local participants's video.
-     * @param muted - Whether to mute the video
-     * @returns Whether muting/unmuting was successful
-     */
-    public async setLocalVideoMuted(muted: boolean): Promise<boolean> {
-        // hasAudioDevice can block indefinitely if the window has lost focus,
-        // and it doesn't make much sense to keep a device from being muted, so
-        // we always allow muted = true changes to go through
-        if (!muted && !(await this.client.getMediaHandler().hasVideoDevice())) {
-            return false;
-        }
-
-        if (this.localCallFeed) {
-            /* istanbul ignore next */
-            logger.log(
-                `GroupCall ${this.groupCallId} setLocalVideoMuted() (stream=${this.localCallFeed.stream.id}, muted=${muted})`,
-            );
-
-            try {
-                const stream = await this.client.getMediaHandler().getUserMediaStream(true, !muted);
-                await this.updateLocalUsermediaStream(stream);
-                this.localCallFeed.setAudioVideoMuted(null, muted);
-                setTracksEnabled(this.localCallFeed.stream.getVideoTracks(), !muted);
-            } catch {
-                // No permission to video device
-                /* istanbul ignore next */
-                logger.log(
-                    `GroupCall ${this.groupCallId} setLocalVideoMuted() no device or permission to receive local stream, muted=${muted}`,
-                );
-                return false;
-            }
-        } else {
-            logger.log(`GroupCall ${this.groupCallId} setLocalVideoMuted() no stream muted (muted=${muted})`);
-            this.initWithVideoMuted = muted;
-        }
-
-        const updates: Promise<unknown>[] = [];
-        this.forEachCall((call) => updates.push(call.setLocalVideoMuted(muted)));
-        await Promise.all(updates);
-
-        // We setTracksEnabled again, independently from the call doing it
-        // internally, since we might not be expecting the call
-        this.forEachCall((call) =>
-            setTracksEnabled(call.localUsermediaFeed!.stream.getVideoTracks(), !muted && this.callExpected(call)),
-        );
-
-        this.emit(GroupCallEvent.LocalMuteStateChanged, this.isMicrophoneMuted(), muted);
-
-        return true;
-    }
-
-    public async setScreensharingEnabled(enabled: boolean, opts: IScreensharingOpts = {}): Promise<boolean> {
-        if (enabled === this.isScreensharing()) {
-            return enabled;
-        }
-
-        if (enabled) {
-            try {
-                logger.log(
-                    `GroupCall ${this.groupCallId} setScreensharingEnabled() is asking for screensharing permissions`,
-                );
-                const stream = await this.client.getMediaHandler().getScreensharingStream(opts);
-
-                for (const track of stream.getTracks()) {
-                    const onTrackEnded = (): void => {
-                        this.setScreensharingEnabled(false);
-                        track.removeEventListener("ended", onTrackEnded);
-                    };
-
-                    track.addEventListener("ended", onTrackEnded);
-                }
-
-                logger.log(
-                    `GroupCall ${this.groupCallId} setScreensharingEnabled() granted screensharing permissions. Setting screensharing enabled on all calls`,
-                );
-
-                this.localDesktopCapturerSourceId = opts.desktopCapturerSourceId;
-                this.localScreenshareFeed = new CallFeed({
-                    client: this.client,
-                    roomId: this.room.roomId,
-                    userId: this.client.getUserId()!,
-                    deviceId: this.client.getDeviceId()!,
-                    stream,
-                    purpose: SDPStreamMetadataPurpose.Screenshare,
-                    audioMuted: false,
-                    videoMuted: false,
-                });
-                this.addScreenshareFeed(this.localScreenshareFeed);
-
-                this.emit(
-                    GroupCallEvent.LocalScreenshareStateChanged,
-                    true,
-                    this.localScreenshareFeed,
-                    this.localDesktopCapturerSourceId,
-                );
-
-                // TODO: handle errors
-                this.forEachCall((call) => call.pushLocalFeed(this.localScreenshareFeed!.clone()));
-
-                return true;
-            } catch (error) {
-                if (opts.throwOnFail) throw error;
-                logger.error(
-                    `GroupCall ${this.groupCallId} setScreensharingEnabled() enabling screensharing error`,
-                    error,
-                );
-                this.emit(
-                    GroupCallEvent.Error,
-                    new GroupCallError(
-                        GroupCallErrorCode.NoUserMedia,
-                        "Failed to get screen-sharing stream: ",
-                        error as Error,
-                    ),
-                );
-                return false;
-            }
-        } else {
-            this.forEachCall((call) => {
-                if (call.localScreensharingFeed) call.removeLocalFeed(call.localScreensharingFeed);
-            });
-            this.client.getMediaHandler().stopScreensharingStream(this.localScreenshareFeed!.stream);
-            this.removeScreenshareFeed(this.localScreenshareFeed!);
-            this.localScreenshareFeed = undefined;
-            this.localDesktopCapturerSourceId = undefined;
-            this.emit(GroupCallEvent.LocalScreenshareStateChanged, false, undefined, undefined);
-            return false;
-        }
-    }
-
-    public isScreensharing(): boolean {
-        return !!this.localScreenshareFeed;
-    }
-
-    /*
-     * Call Setup
-     *
-     * There are two different paths for calls to be created:
-     * 1. Incoming calls triggered by the Call.incoming event.
-     * 2. Outgoing calls to the initial members of a room or new members
-     *    as they are observed by the RoomState.members event.
-     */
-
-    private onIncomingCall = (newCall: MatrixCall): void => {
-        // The incoming calls may be for another room, which we will ignore.
-        if (newCall.roomId !== this.room.roomId) {
-            return;
-        }
-
-        if (newCall.state !== CallState.Ringing) {
-            logger.warn(
-                `GroupCall ${this.groupCallId} onIncomingCall() incoming call no longer in ringing state - ignoring`,
-            );
-            return;
-        }
-
-        if (!newCall.groupCallId || newCall.groupCallId !== this.groupCallId) {
-            logger.log(
-                `GroupCall ${this.groupCallId} onIncomingCall() ignored because it doesn't match the current group call`,
-            );
-            newCall.reject();
-            return;
-        }
-
-        const opponentUserId = newCall.getOpponentMember()?.userId;
-        if (opponentUserId === undefined) {
-            logger.warn(`GroupCall ${this.groupCallId} onIncomingCall() incoming call with no member - ignoring`);
-            return;
-        }
-
-        if (this.useLivekit) {
-            logger.info("Received incoming call whilst in signaling-only mode! Ignoring.");
-            return;
-        }
-
-        const deviceMap = this.calls.get(opponentUserId) ?? new Map<string, MatrixCall>();
-        const prevCall = deviceMap.get(newCall.getOpponentDeviceId()!);
-
-        if (prevCall?.callId === newCall.callId) return;
-
-        logger.log(
-            `GroupCall ${this.groupCallId} onIncomingCall() incoming call (userId=${opponentUserId}, callId=${newCall.callId})`,
-        );
-
-        if (prevCall) prevCall.hangup(CallErrorCode.Replaced, false);
-        // We must do this before we start initialising / answering the call as we
-        // need to know it is the active call for this user+deviceId and to not ignore
-        // events from it.
-        deviceMap.set(newCall.getOpponentDeviceId()!, newCall);
-        this.calls.set(opponentUserId, deviceMap);
-
-        this.initCall(newCall);
-
-        const feeds = this.getLocalFeeds().map((feed) => feed.clone());
-        if (!this.callExpected(newCall)) {
-            // Disable our tracks for users not explicitly participating in the
-            // call but trying to receive the feeds
-            for (const feed of feeds) {
-                setTracksEnabled(feed.stream.getAudioTracks(), false);
-                setTracksEnabled(feed.stream.getVideoTracks(), false);
-            }
-        }
-        newCall.answerWithCallFeeds(feeds);
-
-        this.emit(GroupCallEvent.CallsChanged, this.calls);
-    };
-
-    /**
-     * Determines whether a given participant expects us to call them (versus
-     * them calling us).
-     * @param userId - The participant's user ID.
-     * @param deviceId - The participant's device ID.
-     * @returns Whether we need to place an outgoing call to the participant.
-     */
-    private wantsOutgoingCall(userId: string, deviceId: string): boolean {
-        const localUserId = this.client.getUserId()!;
-        const localDeviceId = this.client.getDeviceId()!;
-        return (
-            // If a user's ID is less than our own, they'll call us
-            userId >= localUserId &&
-            // If this is another one of our devices, compare device IDs to tell whether it'll call us
-            (userId !== localUserId || deviceId > localDeviceId)
-        );
-    }
-
-    /**
-     * Places calls to all participants that we're responsible for calling.
-     */
-    private placeOutgoingCalls(): void {
-        let callsChanged = false;
-
-        for (const [{ userId }, participantMap] of this.participants) {
-            const callMap = this.calls.get(userId) ?? new Map<string, MatrixCall>();
-
-            for (const [deviceId, participant] of participantMap) {
-                const prevCall = callMap.get(deviceId);
-
-                if (
-                    prevCall?.getOpponentSessionId() !== participant.sessionId &&
-                    this.wantsOutgoingCall(userId, deviceId)
-                ) {
-                    callsChanged = true;
-
-                    if (prevCall !== undefined) {
-                        logger.debug(
-                            `GroupCall ${this.groupCallId} placeOutgoingCalls() replacing call (userId=${userId}, deviceId=${deviceId}, callId=${prevCall.callId})`,
-                        );
-                        prevCall.hangup(CallErrorCode.NewSession, false);
-                    }
-
-                    const newCall = createNewMatrixCall(this.client, this.room.roomId, {
-                        invitee: userId,
-                        opponentDeviceId: deviceId,
-                        opponentSessionId: participant.sessionId,
-                        groupCallId: this.groupCallId,
-                    });
-
-                    if (newCall === null) {
-                        logger.error(
-                            `GroupCall ${this.groupCallId} placeOutgoingCalls() failed to create call (userId=${userId}, device=${deviceId})`,
-                        );
-                        callMap.delete(deviceId);
-                    } else {
-                        this.initCall(newCall);
-                        callMap.set(deviceId, newCall);
-
-                        logger.debug(
-                            `GroupCall ${this.groupCallId} placeOutgoingCalls() placing call (userId=${userId}, deviceId=${deviceId}, sessionId=${participant.sessionId})`,
-                        );
-
-                        newCall
-                            .placeCallWithCallFeeds(
-                                this.getLocalFeeds().map((feed) => feed.clone()),
-                                participant.screensharing,
-                            )
-                            .then(() => {
-                                if (this.dataChannelsEnabled) {
-                                    newCall.createDataChannel("datachannel", this.dataChannelOptions);
-                                }
-                            })
-                            .catch((e) => {
-                                logger.warn(
-                                    `GroupCall ${this.groupCallId} placeOutgoingCalls() failed to place call (userId=${userId})`,
-                                    e,
-                                );
-
-                                if (e instanceof CallError && e.code === GroupCallErrorCode.UnknownDevice) {
-                                    this.emit(GroupCallEvent.Error, e);
-                                } else {
-                                    this.emit(
-                                        GroupCallEvent.Error,
-                                        new GroupCallError(
-                                            GroupCallErrorCode.PlaceCallFailed,
-                                            `Failed to place call to ${userId}`,
-                                        ),
-                                    );
-                                }
-
-                                newCall.hangup(CallErrorCode.SignallingFailed, false);
-                                if (callMap.get(deviceId) === newCall) callMap.delete(deviceId);
-                            });
-                    }
-                }
-            }
-
-            if (callMap.size > 0) {
-                this.calls.set(userId, callMap);
-            } else {
-                this.calls.delete(userId);
-            }
-        }
-
-        if (callsChanged) this.emit(GroupCallEvent.CallsChanged, this.calls);
-    }
-
-    /*
-     * Room Member State
-     */
-
-    private getMemberStateEvents(): MatrixEvent[];
-    private getMemberStateEvents(userId: string): MatrixEvent | null;
-    private getMemberStateEvents(userId?: string): MatrixEvent[] | MatrixEvent | null {
-        return userId === undefined
-            ? this.room.currentState.getStateEvents(EventType.GroupCallMemberPrefix)
-            : this.room.currentState.getStateEvents(EventType.GroupCallMemberPrefix, userId);
-    }
-
-    private onRetryCallLoop = (): void => {
-        let needsRetry = false;
-
-        for (const [{ userId }, participantMap] of this.participants) {
-            const callMap = this.calls.get(userId);
-            let retriesMap = this.retryCallCounts.get(userId);
-
-            for (const [deviceId, participant] of participantMap) {
-                const call = callMap?.get(deviceId);
-                const retries = retriesMap?.get(deviceId) ?? 0;
-
-                if (
-                    call?.getOpponentSessionId() !== participant.sessionId &&
-                    this.wantsOutgoingCall(userId, deviceId) &&
-                    retries < 3
-                ) {
-                    if (retriesMap === undefined) {
-                        retriesMap = new Map();
-                        this.retryCallCounts.set(userId, retriesMap);
-                    }
-                    retriesMap.set(deviceId, retries + 1);
-                    needsRetry = true;
-                }
-            }
-        }
-
-        if (needsRetry) this.placeOutgoingCalls();
-    };
-
-    private initCall(call: MatrixCall): void {
-        const opponentMemberId = getCallUserId(call);
-
-        if (!opponentMemberId) {
-            throw new Error("Cannot init call without user id");
-        }
-
-        const onCallFeedsChanged = (): void => this.onCallFeedsChanged(call);
-        const onCallStateChanged = (state: CallState, oldState?: CallState): void =>
-            this.onCallStateChanged(call, state, oldState);
-        const onCallHangup = this.onCallHangup;
-        const onCallReplaced = (newCall: MatrixCall): void => this.onCallReplaced(call, newCall);
-
-        let deviceMap = this.callHandlers.get(opponentMemberId);
-        if (deviceMap === undefined) {
-            deviceMap = new Map();
-            this.callHandlers.set(opponentMemberId, deviceMap);
-        }
-
-        deviceMap.set(call.getOpponentDeviceId()!, {
-            onCallFeedsChanged,
-            onCallStateChanged,
-            onCallHangup,
-            onCallReplaced,
-        });
-
-        call.on(CallEvent.FeedsChanged, onCallFeedsChanged);
-        call.on(CallEvent.State, onCallStateChanged);
-        call.on(CallEvent.Hangup, onCallHangup);
-        call.on(CallEvent.Replaced, onCallReplaced);
-
-        call.isPtt = this.isPtt;
-
-        this.reEmitter.reEmit(call, Object.values(CallEvent));
-
-        call.initStats(this.getGroupCallStats());
-
-        onCallFeedsChanged();
-    }
-
-    private disposeCall(call: MatrixCall, hangupReason: CallErrorCode): void {
-        const opponentMemberId = getCallUserId(call);
-        const opponentDeviceId = call.getOpponentDeviceId()!;
-
-        if (!opponentMemberId) {
-            throw new Error("Cannot dispose call without user id");
-        }
-
-        const deviceMap = this.callHandlers.get(opponentMemberId)!;
-        const { onCallFeedsChanged, onCallStateChanged, onCallHangup, onCallReplaced } =
-            deviceMap.get(opponentDeviceId)!;
-
-        call.removeListener(CallEvent.FeedsChanged, onCallFeedsChanged);
-        call.removeListener(CallEvent.State, onCallStateChanged);
-        call.removeListener(CallEvent.Hangup, onCallHangup);
-        call.removeListener(CallEvent.Replaced, onCallReplaced);
-
-        deviceMap.delete(opponentMemberId);
-        if (deviceMap.size === 0) this.callHandlers.delete(opponentMemberId);
-
-        if (call.hangupReason === CallErrorCode.Replaced) {
-            return;
-        }
-
-        const usermediaFeed = this.getUserMediaFeed(opponentMemberId, opponentDeviceId);
-
-        if (usermediaFeed) {
-            this.removeUserMediaFeed(usermediaFeed);
-        }
-
-        const screenshareFeed = this.getScreenshareFeed(opponentMemberId, opponentDeviceId);
-
-        if (screenshareFeed) {
-            this.removeScreenshareFeed(screenshareFeed);
-        }
-    }
-
-    private onCallFeedsChanged = (call: MatrixCall): void => {
-        const opponentMemberId = getCallUserId(call);
-        const opponentDeviceId = call.getOpponentDeviceId()!;
-
-        if (!opponentMemberId) {
-            throw new Error("Cannot change call feeds without user id");
-        }
-
-        const currentUserMediaFeed = this.getUserMediaFeed(opponentMemberId, opponentDeviceId);
-        const remoteUsermediaFeed = call.remoteUsermediaFeed;
-        const remoteFeedChanged = remoteUsermediaFeed !== currentUserMediaFeed;
-
-        const deviceMap = this.calls.get(opponentMemberId);
-        const currentCallForUserDevice = deviceMap?.get(opponentDeviceId);
-        if (currentCallForUserDevice?.callId !== call.callId) {
-            // the call in question is not the current call for this user/deviceId
-            // so ignore feed events from it otherwise we'll remove our real feeds
-            return;
-        }
-
-        if (remoteFeedChanged) {
-            if (!currentUserMediaFeed && remoteUsermediaFeed) {
-                this.addUserMediaFeed(remoteUsermediaFeed);
-            } else if (currentUserMediaFeed && remoteUsermediaFeed) {
-                this.replaceUserMediaFeed(currentUserMediaFeed, remoteUsermediaFeed);
-            } else if (currentUserMediaFeed && !remoteUsermediaFeed) {
-                this.removeUserMediaFeed(currentUserMediaFeed);
-            }
-        }
-
-        const currentScreenshareFeed = this.getScreenshareFeed(opponentMemberId, opponentDeviceId);
-        const remoteScreensharingFeed = call.remoteScreensharingFeed;
-        const remoteScreenshareFeedChanged = remoteScreensharingFeed !== currentScreenshareFeed;
-
-        if (remoteScreenshareFeedChanged) {
-            if (!currentScreenshareFeed && remoteScreensharingFeed) {
-                this.addScreenshareFeed(remoteScreensharingFeed);
-            } else if (currentScreenshareFeed && remoteScreensharingFeed) {
-                this.replaceScreenshareFeed(currentScreenshareFeed, remoteScreensharingFeed);
-            } else if (currentScreenshareFeed && !remoteScreensharingFeed) {
-                this.removeScreenshareFeed(currentScreenshareFeed);
-            }
-        }
-    };
-
-    private onCallStateChanged = (call: MatrixCall, state: CallState, _oldState: CallState | undefined): void => {
-        if (state === CallState.Ended) return;
-
-        const audioMuted = this.localCallFeed!.isAudioMuted();
-
-        if (call.localUsermediaStream && call.isMicrophoneMuted() !== audioMuted) {
-            call.setMicrophoneMuted(audioMuted);
-        }
-
-        const videoMuted = this.localCallFeed!.isVideoMuted();
-
-        if (call.localUsermediaStream && call.isLocalVideoMuted() !== videoMuted) {
-            call.setLocalVideoMuted(videoMuted);
-        }
-
-        const opponentUserId = call.getOpponentMember()?.userId;
-        if (state === CallState.Connected && opponentUserId) {
-            const retriesMap = this.retryCallCounts.get(opponentUserId);
-            retriesMap?.delete(call.getOpponentDeviceId()!);
-            if (retriesMap?.size === 0) this.retryCallCounts.delete(opponentUserId);
-        }
-    };
-
-    private onCallHangup = (call: MatrixCall): void => {
-        if (call.hangupReason === CallErrorCode.Replaced) return;
-
-        const opponentUserId = call.getOpponentMember()?.userId ?? this.room.getMember(call.invitee!)!.userId;
-        const deviceMap = this.calls.get(opponentUserId);
-
-        // Sanity check that this call is in fact in the map
-        if (deviceMap?.get(call.getOpponentDeviceId()!) === call) {
-            this.disposeCall(call, call.hangupReason as CallErrorCode);
-            deviceMap.delete(call.getOpponentDeviceId()!);
-            if (deviceMap.size === 0) this.calls.delete(opponentUserId);
-            this.emit(GroupCallEvent.CallsChanged, this.calls);
-        }
-    };
-
-    private onCallReplaced = (prevCall: MatrixCall, newCall: MatrixCall): void => {
-        const opponentUserId = prevCall.getOpponentMember()!.userId;
-
-        let deviceMap = this.calls.get(opponentUserId);
-        if (deviceMap === undefined) {
-            deviceMap = new Map();
-            this.calls.set(opponentUserId, deviceMap);
-        }
-
-        prevCall.hangup(CallErrorCode.Replaced, false);
-        this.initCall(newCall);
-        deviceMap.set(prevCall.getOpponentDeviceId()!, newCall);
-        this.emit(GroupCallEvent.CallsChanged, this.calls);
-    };
-
-    /*
-     * UserMedia CallFeed Event Handlers
-     */
-
-    public getUserMediaFeed(userId: string, deviceId: string): CallFeed | undefined {
-        return this.userMediaFeeds.find((f) => f.userId === userId && f.deviceId! === deviceId);
-    }
-
-    private addUserMediaFeed(callFeed: CallFeed): void {
-        this.userMediaFeeds.push(callFeed);
-        callFeed.measureVolumeActivity(true);
-        this.emit(GroupCallEvent.UserMediaFeedsChanged, this.userMediaFeeds);
-    }
-
-    private replaceUserMediaFeed(existingFeed: CallFeed, replacementFeed: CallFeed): void {
-        const feedIndex = this.userMediaFeeds.findIndex(
-            (f) => f.userId === existingFeed.userId && f.deviceId! === existingFeed.deviceId,
-        );
-
-        if (feedIndex === -1) {
-            throw new Error("Couldn't find user media feed to replace");
-        }
-
-        this.userMediaFeeds.splice(feedIndex, 1, replacementFeed);
-
-        existingFeed.dispose();
-        replacementFeed.measureVolumeActivity(true);
-        this.emit(GroupCallEvent.UserMediaFeedsChanged, this.userMediaFeeds);
-    }
-
-    private removeUserMediaFeed(callFeed: CallFeed): void {
-        const feedIndex = this.userMediaFeeds.findIndex(
-            (f) => f.userId === callFeed.userId && f.deviceId! === callFeed.deviceId,
-        );
-
-        if (feedIndex === -1) {
-            throw new Error("Couldn't find user media feed to remove");
-        }
-
-        this.userMediaFeeds.splice(feedIndex, 1);
-
-        callFeed.dispose();
-        this.emit(GroupCallEvent.UserMediaFeedsChanged, this.userMediaFeeds);
-
-        if (this.activeSpeaker === callFeed) {
-            this.activeSpeaker = this.userMediaFeeds[0];
-            this.emit(GroupCallEvent.ActiveSpeakerChanged, this.activeSpeaker);
-        }
-    }
-
-    private onActiveSpeakerLoop = (): void => {
-        let topAvg: number | undefined = undefined;
-        let nextActiveSpeaker: CallFeed | undefined = undefined;
-
-        for (const callFeed of this.userMediaFeeds) {
-            if (callFeed.isLocal() && this.userMediaFeeds.length > 1) continue;
-
-            const total = callFeed.speakingVolumeSamples.reduce(
-                (acc, volume) => acc + Math.max(volume, SPEAKING_THRESHOLD),
-            );
-            const avg = total / callFeed.speakingVolumeSamples.length;
-
-            if (!topAvg || avg > topAvg) {
-                topAvg = avg;
-                nextActiveSpeaker = callFeed;
-            }
-        }
-
-        if (nextActiveSpeaker && this.activeSpeaker !== nextActiveSpeaker && topAvg && topAvg > SPEAKING_THRESHOLD) {
-            this.activeSpeaker = nextActiveSpeaker;
-            this.emit(GroupCallEvent.ActiveSpeakerChanged, this.activeSpeaker);
-        }
-    };
-
-    /*
-     * Screenshare Call Feed Event Handlers
-     */
-
-    public getScreenshareFeed(userId: string, deviceId: string): CallFeed | undefined {
-        return this.screenshareFeeds.find((f) => f.userId === userId && f.deviceId! === deviceId);
-    }
-
-    private addScreenshareFeed(callFeed: CallFeed): void {
-        this.screenshareFeeds.push(callFeed);
-        this.emit(GroupCallEvent.ScreenshareFeedsChanged, this.screenshareFeeds);
-    }
-
-    private replaceScreenshareFeed(existingFeed: CallFeed, replacementFeed: CallFeed): void {
-        const feedIndex = this.screenshareFeeds.findIndex(
-            (f) => f.userId === existingFeed.userId && f.deviceId! === existingFeed.deviceId,
-        );
-
-        if (feedIndex === -1) {
-            throw new Error("Couldn't find screenshare feed to replace");
-        }
-
-        this.screenshareFeeds.splice(feedIndex, 1, replacementFeed);
-
-        existingFeed.dispose();
-        this.emit(GroupCallEvent.ScreenshareFeedsChanged, this.screenshareFeeds);
-    }
-
-    private removeScreenshareFeed(callFeed: CallFeed): void {
-        const feedIndex = this.screenshareFeeds.findIndex(
-            (f) => f.userId === callFeed.userId && f.deviceId! === callFeed.deviceId,
-        );
-
-        if (feedIndex === -1) {
-            throw new Error("Couldn't find screenshare feed to remove");
-        }
-
-        this.screenshareFeeds.splice(feedIndex, 1);
-
-        callFeed.dispose();
-        this.emit(GroupCallEvent.ScreenshareFeedsChanged, this.screenshareFeeds);
-    }
-
-    /**
-     * Recalculates and updates the participant map to match the room state.
-     */
-    private updateParticipants(): void {
-        const localMember = this.room.getMember(this.client.getUserId()!)!;
-        if (!localMember) {
-            // The client hasn't fetched enough of the room state to get our own member
-            // event. This probably shouldn't happen, but sanity check & exit for now.
-            logger.warn(
-                `GroupCall ${this.groupCallId} updateParticipants() tried to update participants before local room member is available`,
-            );
-            return;
-        }
-
-        if (this.participantsExpirationTimer !== null) {
-            clearTimeout(this.participantsExpirationTimer);
-            this.participantsExpirationTimer = null;
-        }
-
-        if (this.state === GroupCallState.Ended) {
-            this.participants = new Map();
-            return;
-        }
-
-        const participants = new Map<RoomMember, Map<string, ParticipantState>>();
-        const now = Date.now();
-        const entered = this.state === GroupCallState.Entered || this.enteredViaAnotherSession;
-        let nextExpiration = Infinity;
-
-        for (const e of this.getMemberStateEvents()) {
-            const member = this.room.getMember(e.getStateKey()!);
-            const content = e.getContent<Record<any, unknown>>();
-            const calls: Record<any, unknown>[] = Array.isArray(content["m.calls"]) ? content["m.calls"] : [];
-            const call = calls.find((call) => call["m.call_id"] === this.groupCallId);
-            const devices: Record<any, unknown>[] = Array.isArray(call?.["m.devices"]) ? call!["m.devices"] : [];
-
-            // Filter out invalid and expired devices
-            let validDevices = devices.filter(
-                (d) =>
-                    typeof d.device_id === "string" &&
-                    typeof d.session_id === "string" &&
-                    typeof d.expires_ts === "number" &&
-                    d.expires_ts > now &&
-                    Array.isArray(d.feeds),
-            ) as unknown as IGroupCallRoomMemberDevice[];
-
-            // Apply local echo for the unentered case
-            if (!entered && member?.userId === this.client.getUserId()!) {
-                validDevices = validDevices.filter((d) => d.device_id !== this.client.getDeviceId()!);
-            }
-
-            // Must have a connected device and be joined to the room
-            if (validDevices.length > 0 && member?.membership === KnownMembership.Join) {
-                const deviceMap = new Map<string, ParticipantState>();
-                participants.set(member, deviceMap);
-
-                for (const d of validDevices) {
-                    deviceMap.set(d.device_id, {
-                        sessionId: d.session_id,
-                        screensharing: d.feeds.some((f) => f.purpose === SDPStreamMetadataPurpose.Screenshare),
-                    });
-                    if (d.expires_ts < nextExpiration) nextExpiration = d.expires_ts;
-                }
-            }
-        }
-
-        // Apply local echo for the entered case
-        if (entered) {
-            let deviceMap = participants.get(localMember);
-            if (deviceMap === undefined) {
-                deviceMap = new Map();
-                participants.set(localMember, deviceMap);
-            }
-
-            if (!deviceMap.has(this.client.getDeviceId()!)) {
-                deviceMap.set(this.client.getDeviceId()!, {
-                    sessionId: this.client.getSessionId(),
-                    screensharing: this.getLocalFeeds().some((f) => f.purpose === SDPStreamMetadataPurpose.Screenshare),
-                });
-            }
-        }
-
-        this.participants = participants;
-        if (nextExpiration < Infinity) {
-            this.participantsExpirationTimer = setTimeout(() => this.updateParticipants(), nextExpiration - now);
-        }
-    }
-
-    /**
-     * Updates the local user's member state with the devices returned by the given function.
-     * @param fn - A function from the current devices to the new devices. If it
-     *   returns null, the update will be skipped.
-     * @param keepAlive - Whether the request should outlive the window.
-     */
-    private async updateDevices(
-        fn: (devices: IGroupCallRoomMemberDevice[]) => IGroupCallRoomMemberDevice[] | null,
-        keepAlive = false,
-    ): Promise<void> {
-        const now = Date.now();
-        const localUserId = this.client.getUserId()!;
-
-        const event = this.getMemberStateEvents(localUserId);
-        const content = event?.getContent<Record<any, unknown>>() ?? {};
-        const calls: Record<any, unknown>[] = Array.isArray(content["m.calls"]) ? content["m.calls"] : [];
-
-        let call: Record<any, unknown> | null = null;
-        const otherCalls: Record<any, unknown>[] = [];
-        for (const c of calls) {
-            if (c["m.call_id"] === this.groupCallId) {
-                call = c;
-            } else {
-                otherCalls.push(c);
-            }
-        }
-        if (call === null) call = {};
-
-        const devices: Record<any, unknown>[] = Array.isArray(call["m.devices"]) ? call["m.devices"] : [];
-
-        // Filter out invalid and expired devices
-        const validDevices = devices.filter(
-            (d) =>
-                typeof d.device_id === "string" &&
-                typeof d.session_id === "string" &&
-                typeof d.expires_ts === "number" &&
-                d.expires_ts > now &&
-                Array.isArray(d.feeds),
-        ) as unknown as IGroupCallRoomMemberDevice[];
-
-        const newDevices = fn(validDevices);
-        if (newDevices === null) return;
-
-        const newCalls = [...(otherCalls as unknown as IGroupCallRoomMemberCallState[])];
-        if (newDevices.length > 0) {
-            newCalls.push({
-                ...call,
-                "m.call_id": this.groupCallId,
-                "m.devices": newDevices,
-            });
-        }
-
-        const newContent: IGroupCallRoomMemberState = { "m.calls": newCalls };
-
-        await this.client.sendStateEvent(this.room.roomId, EventType.GroupCallMemberPrefix, newContent, localUserId, {
-            keepAlive,
-        });
-    }
-
-    private async addDeviceToMemberState(): Promise<void> {
-        await this.updateDevices((devices) => [
-            ...devices.filter((d) => d.device_id !== this.client.getDeviceId()!),
-            {
-                device_id: this.client.getDeviceId()!,
-                session_id: this.client.getSessionId(),
-                expires_ts: Date.now() + DEVICE_TIMEOUT,
-                feeds: this.getLocalFeeds().map((feed) => ({ purpose: feed.purpose })),
-                // TODO: Add data channels
-            },
-        ]);
-    }
-
-    private async updateMemberState(): Promise<void> {
-        // Clear the old update interval before proceeding
-        if (this.resendMemberStateTimer !== null) {
-            clearInterval(this.resendMemberStateTimer);
-            this.resendMemberStateTimer = null;
-        }
-
-        if (this.state === GroupCallState.Entered) {
-            // Add the local device
-            await this.addDeviceToMemberState();
-
-            // Resend the state event every so often so it doesn't become stale
-            this.resendMemberStateTimer = setInterval(
-                async () => {
-                    logger.log(`GroupCall ${this.groupCallId} updateMemberState() resending call member state"`);
-                    try {
-                        await this.addDeviceToMemberState();
-                    } catch (e) {
-                        logger.error(
-                            `GroupCall ${this.groupCallId} updateMemberState() failed to resend call member state`,
-                            e,
-                        );
-                    }
-                },
-                (DEVICE_TIMEOUT * 3) / 4,
-            );
-        } else {
-            // Remove the local device
-            await this.updateDevices(
-                (devices) => devices.filter((d) => d.device_id !== this.client.getDeviceId()!),
-                true,
-            );
-        }
-    }
-
-    /**
-     * Cleans up our member state by filtering out logged out devices, inactive
-     * devices, and our own device (if we know we haven't entered).
-     */
-    public async cleanMemberState(): Promise<void> {
-        const { devices: myDevices } = await this.client.getDevices();
-        const deviceMap = new Map<string, IMyDevice>(myDevices.map((d) => [d.device_id, d]));
-
-        // updateDevices takes care of filtering out inactive devices for us
-        await this.updateDevices((devices) => {
-            const newDevices = devices.filter((d) => {
-                const device = deviceMap.get(d.device_id);
-                return (
-                    device?.last_seen_ts !== undefined &&
-                    !(
-                        d.device_id === this.client.getDeviceId()! &&
-                        this.state !== GroupCallState.Entered &&
-                        !this.enteredViaAnotherSession
-                    )
-                );
-            });
-
-            // Skip the update if the devices are unchanged
-            return newDevices.length === devices.length ? null : newDevices;
-        });
-    }
-
-    private onRoomState = (): void => this.updateParticipants();
-
-    private onParticipantsChanged = (): void => {
-        // Re-run setTracksEnabled on all calls, so that participants that just
-        // left get denied access to our media, and participants that just
-        // joined get granted access
-        this.forEachCall((call) => {
-            const expected = this.callExpected(call);
-            for (const feed of call.getLocalFeeds()) {
-                setTracksEnabled(feed.stream.getAudioTracks(), !feed.isAudioMuted() && expected);
-                setTracksEnabled(feed.stream.getVideoTracks(), !feed.isVideoMuted() && expected);
-            }
-        });
-
-        if (this.state === GroupCallState.Entered && !this.useLivekit) this.placeOutgoingCalls();
-
-        // Update the participants stored in the stats object
-    };
-
-    private onStateChanged = (newState: GroupCallState, oldState: GroupCallState): void => {
-        if (
-            newState === GroupCallState.Entered ||
-            oldState === GroupCallState.Entered ||
-            newState === GroupCallState.Ended
-        ) {
-            // We either entered, left, or ended the call
-            this.updateParticipants();
-            this.updateMemberState().catch((e) =>
-                logger.error(
-                    `GroupCall ${this.groupCallId} onStateChanged() failed to update member state devices"`,
-                    e,
-                ),
-            );
-        }
-    };
-
-    private onLocalFeedsChanged = (): void => {
-        if (this.state === GroupCallState.Entered) {
-            this.updateMemberState().catch((e) =>
-                logger.error(
-                    `GroupCall ${this.groupCallId} onLocalFeedsChanged() failed to update member state feeds`,
-                    e,
-                ),
-            );
-        }
-    };
-
-    public getGroupCallStats(): GroupCallStats {
-        if (this.stats === undefined) {
-            const userID = this.client.getUserId() || "unknown";
-            this.stats = new GroupCallStats(this.groupCallId, userID, this.statsCollectIntervalTime);
-            this.stats.reports.on(StatsReport.CONNECTION_STATS, this.onConnectionStats);
-            this.stats.reports.on(StatsReport.BYTE_SENT_STATS, this.onByteSentStats);
-            this.stats.reports.on(StatsReport.SUMMARY_STATS, this.onSummaryStats);
-            this.stats.reports.on(StatsReport.CALL_FEED_REPORT, this.onCallFeedReport);
-        }
-        return this.stats;
-    }
-
-    public setGroupCallStatsInterval(interval: number): void {
-        this.statsCollectIntervalTime = interval;
-        if (this.stats !== undefined) {
-            this.stats.stop();
-            this.stats.setInterval(interval);
-            if (interval > 0) {
-                this.stats.start();
-            }
-        }
-    }
-}