Add the parent event to the CallMembership.

Signed-off-by: Timo K <[email protected]>

Author: toger5

src/matrixrtc/CallMembership.ts

@@ -218,9 +218,17 @@ export class CallMembership {
     private membershipData: MembershipData;
 
     private parentEventData: { eventId: string; sender: string };
+    /**
+     *
+     * @param parentEvent
+     * @param data
+     * @param relatedEvent
+     * @throws if the data does not match any known membership format.
+     */
     public constructor(
         private parentEvent: MatrixEvent,
         data: any,
+        private relatedEvent?: MatrixEvent,
     ) {
         const sessionErrors: string[] = [];
         const rtcErrors: string[] = [];
@@ -341,8 +349,7 @@ export class CallMembership {
         const { kind, data } = this.membershipData;
         switch (kind) {
             case "rtc":
-                // TODO we need to read the referenced (relation) event if available to get the real created_ts
-                return this.parentEvent.getTs();
+                return this.relatedEvent?.getTs() ?? this.parentEvent.getTs();
             default: // "session":
                 return data.created_ts ?? this.parentEvent.getTs();
         }
@@ -356,7 +363,8 @@ export class CallMembership {
         const { kind, data } = this.membershipData;
         switch (kind) {
             case "rtc":
-                return undefined;
+                // TODO use the sticky property of the rtc membership to determine expiry?
+                return this.createdTs() + DEFAULT_EXPIRE_DURATION;
             default: // "session":
                 // TODO: calculate this from the MatrixRTCSession join configuration directly
                 return this.createdTs() + (data.expires ?? DEFAULT_EXPIRE_DURATION);
@@ -367,16 +375,10 @@ export class CallMembership {
      * @returns The number of milliseconds until the membership expires or undefined if applicable
      */
     public getMsUntilExpiry(): number | undefined {
-        const { kind } = this.membershipData;
-        switch (kind) {
-            case "rtc":
-                return undefined;
-            default: // "session":
-                // Assume that local clock is sufficiently in sync with other clocks in the distributed system.
-                // We used to try and adjust for the local clock being skewed, but there are cases where this is not accurate.
-                // The current implementation allows for the local clock to be -infinity to +MatrixRTCSession.MEMBERSHIP_EXPIRY_TIME/2
-                return this.getAbsoluteExpiry()! - Date.now();
-        }
+        // Assume that local clock is sufficiently in sync with other clocks in the distributed system.
+        // We used to try and adjust for the local clock being skewed, but there are cases where this is not accurate.
+        // The current implementation allows for the local clock to be -infinity to +MatrixRTCSession.MEMBERSHIP_EXPIRY_TIME/2
+        return this.getAbsoluteExpiry()! - Date.now();
     }
 
     /**

src/matrixrtc/MatrixRTCSession.ts

@@ -50,6 +50,7 @@ import {
 } from "./RoomAndToDeviceKeyTransport.ts";
 import { TypedReEmitter } from "../ReEmitter.ts";
 import { ToDeviceKeyTransport } from "./ToDeviceKeyTransport.ts";
+import { MatrixEvent } from "src/matrix.ts";
 
 /**
  * Events emitted by MatrixRTCSession
@@ -308,10 +309,10 @@ export class MatrixRTCSession extends TypedEventEmitter<
      *
      * @deprecated Use `MatrixRTCSession.sessionMembershipsForSlot` instead.
      */
-    public static callMembershipsForRoom(
-        room: Pick<Room, "getLiveTimeline" | "roomId" | "hasMembershipState">,
-    ): CallMembership[] {
-        return MatrixRTCSession.sessionMembershipsForSlot(room, {
+    public static async callMembershipsForRoom(
+        room: Pick<Room, "getLiveTimeline" | "roomId" | "hasMembershipState" | "findEventById" | "client">,
+    ): Promise<CallMembership[]> {
+        return await MatrixRTCSession.sessionMembershipsForSlot(room, {
             id: "",
             application: "m.call",
         });
@@ -320,72 +321,67 @@ export class MatrixRTCSession extends TypedEventEmitter<
     /**
      * @deprecated use `MatrixRTCSession.slotMembershipsForRoom` instead.
      */
-    public static sessionMembershipsForRoom(
-        room: Pick<Room, "getLiveTimeline" | "roomId" | "hasMembershipState">,
+    public static async sessionMembershipsForRoom(
+        room: Pick<Room, "getLiveTimeline" | "roomId" | "hasMembershipState" | "findEventById" | "client">,
         sessionDescription: SlotDescription,
-    ): CallMembership[] {
-        return this.sessionMembershipsForSlot(room, sessionDescription);
+    ): Promise<CallMembership[]> {
+        return await this.sessionMembershipsForSlot(room, sessionDescription);
     }
 
     /**
      * Returns all the call memberships for a room that match the provided `sessionDescription`,
      * oldest first.
      */
-    public static sessionMembershipsForSlot(
-        room: Pick<Room, "getLiveTimeline" | "roomId" | "hasMembershipState">,
+    public static async sessionMembershipsForSlot(
+        room: Pick<Room, "getLiveTimeline" | "roomId" | "hasMembershipState" | "findEventById" | "client">,
         slotDescription: SlotDescription,
-    ): CallMembership[] {
+        existingMemberships?: CallMembership[],
+    ): Promise<CallMembership[]> {
         const logger = rootLogger.getChild(`[MatrixRTCSession ${room.roomId}]`);
         const roomState = room.getLiveTimeline().getState(EventTimeline.FORWARDS);
         if (!roomState) {
             logger.warn("Couldn't get state for room " + room.roomId);
             throw new Error("Could't get state for room " + room.roomId);
         }
         const callMemberEvents = roomState.getStateEvents(EventType.GroupCallMemberPrefix);
-
+        // TODO optimise this to reuse existing memberships instead of always creating new ones.
         const callMemberships: CallMembership[] = [];
+
         for (const memberEvent of callMemberEvents) {
-            const content = memberEvent.getContent();
-            const eventKeysCount = Object.keys(content).length;
-            // Dont even bother about empty events (saves us from costly type/"key in" checks in bigger rooms)
-            if (eventKeysCount === 0) continue;
-
-            const membershipContents: any[] = [];
-
-            // We first decide if its a MSC4143 event (per device state key)
-            if (eventKeysCount > 1 && "focus_active" in content) {
-                // We have a MSC4143 event membership event
-                membershipContents.push(content);
-            } else if (eventKeysCount === 1 && "memberships" in content) {
-                logger.warn(`Legacy event found. Those are ignored, they do not contribute to the MatrixRTC session`);
-            }
+            let membership = existingMemberships?.find((m) => m.eventId === memberEvent.getId());
+            if (!membership) {
+                const content = memberEvent.getContent();
 
-            if (membershipContents.length === 0) continue;
+                const relatedEventId = memberEvent.relationEventId;
+                const relatedEvent = relatedEventId
+                    ? room.findEventById(relatedEventId)
+                    : new MatrixEvent(await room.client.fetchRoomEvent(room.roomId, relatedEventId!));
 
-            for (const membershipData of membershipContents) {
                 try {
-                    const membership = new CallMembership(memberEvent, membershipData);
-
-                    if (!deepCompare(membership.slotDescription, slotDescription)) {
-                        logger.info(
-                            `Ignoring membership of user ${membership.sender} for a different session:  ${JSON.stringify(membership.slotDescription)}`,
-                        );
-                        continue;
-                    }
-
-                    if (membership.isExpired()) {
-                        logger.info(`Ignoring expired device membership ${membership.sender}/${membership.deviceId}`);
-                        continue;
-                    }
-                    if (!room.hasMembershipState(membership.sender ?? "", KnownMembership.Join)) {
-                        logger.info(`Ignoring membership of user ${membership.sender} who is not in the room.`);
-                        continue;
-                    }
-                    callMemberships.push(membership);
+                    membership = new CallMembership(memberEvent, content, relatedEvent);
                 } catch (e) {
                     logger.warn("Couldn't construct call membership: ", e);
+                    continue;
+                }
+                // static check for newly created memberships
+                if (!deepCompare(membership.slotDescription, slotDescription)) {
+                    logger.info(
+                        `Ignoring membership of user ${membership.sender} for a different session:  ${JSON.stringify(membership.slotDescription)}`,
+                    );
+                    continue;
                 }
             }
+
+            // Dynamic checks for all (including existing) memberships
+            if (membership.isExpired()) {
+                logger.info(`Ignoring expired device membership ${membership.sender}/${membership.deviceId}`);
+                continue;
+            }
+            if (!room.hasMembershipState(membership.sender ?? "", KnownMembership.Join)) {
+                logger.info(`Ignoring membership of user ${membership.sender} who is not in the room.`);
+                continue;
+            }
+            callMemberships.push(membership);
         }
 
         callMemberships.sort((a, b) => a.createdTs() - b.createdTs());
@@ -409,15 +405,22 @@ export class MatrixRTCSession extends TypedEventEmitter<
      *
      * @deprecated Use `MatrixRTCSession.sessionForSlot` with sessionDescription `{ id: "", application: "m.call" }` instead.
      */
-    public static roomSessionForRoom(client: MatrixClient, room: Room): MatrixRTCSession {
-        const callMemberships = MatrixRTCSession.sessionMembershipsForSlot(room, { id: "", application: "m.call" });
+    public static async roomSessionForRoom(client: MatrixClient, room: Room): Promise<MatrixRTCSession> {
+        const callMemberships = await MatrixRTCSession.sessionMembershipsForSlot(room, {
+            id: "",
+            application: "m.call",
+        });
         return new MatrixRTCSession(client, room, callMemberships, { id: "", application: "m.call" });
     }
 
     /**
      * @deprecated Use `MatrixRTCSession.sessionForSlot` instead.
      */
-    public static sessionForRoom(client: MatrixClient, room: Room, slotDescription: SlotDescription): MatrixRTCSession {
+    public static async sessionForRoom(
+        client: MatrixClient,
+        room: Room,
+        slotDescription: SlotDescription,
+    ): Promise<MatrixRTCSession> {
         return this.sessionForSlot(client, room, slotDescription);
     }
 
@@ -426,8 +429,12 @@ export class MatrixRTCSession extends TypedEventEmitter<
      * This returned session can be used to find out if there are active sessions
      * for the requested room and `slotDescription`.
      */
-    public static sessionForSlot(client: MatrixClient, room: Room, slotDescription: SlotDescription): MatrixRTCSession {
-        const callMemberships = MatrixRTCSession.sessionMembershipsForSlot(room, slotDescription);
+    public static async sessionForSlot(
+        client: MatrixClient,
+        room: Room,
+        slotDescription: SlotDescription,
+    ): Promise<MatrixRTCSession> {
+        const callMemberships = await MatrixRTCSession.sessionMembershipsForSlot(room, slotDescription);
 
         return new MatrixRTCSession(client, room, callMemberships, slotDescription);
     }
@@ -799,46 +806,50 @@ export class MatrixRTCSession extends TypedEventEmitter<
      */
     private recalculateSessionMembers = (): void => {
         const oldMemberships = this.memberships;
-        this.memberships = MatrixRTCSession.sessionMembershipsForSlot(this.room, this.slotDescription);
-
-        this._slotId = this._slotId ?? this.memberships[0]?.slotId;
-
-        const changed =
-            oldMemberships.length != this.memberships.length ||
-            oldMemberships.some((m, i) => !CallMembership.equal(m, this.memberships[i]));
-
-        if (changed) {
-            this.logger.info(
-                `Memberships for call in room ${this.roomSubset.roomId} have changed: emitting (${this.memberships.length} members)`,
-            );
-            logDurationSync(this.logger, "emit MatrixRTCSessionEvent.MembershipsChanged", () => {
-                this.emit(MatrixRTCSessionEvent.MembershipsChanged, oldMemberships, this.memberships);
-            });
-
-            void this.membershipManager?.onRTCSessionMemberUpdate(this.memberships);
-            // The `ownMembership` will be set when calling `onRTCSessionMemberUpdate`.
-            const ownMembership = this.membershipManager?.ownMembership;
-            if (this.pendingNotificationToSend && ownMembership && oldMemberships.length === 0) {
-                // If we're the first member in the call, we're responsible for
-                // sending the notification event
-                if (ownMembership.eventId && this.joinConfig?.notificationType) {
-                    this.sendCallNotify(
-                        ownMembership.eventId,
-                        this.joinConfig.notificationType,
-                        ownMembership.callIntent,
+        void MatrixRTCSession.sessionMembershipsForSlot(this.room, this.slotDescription, oldMemberships).then(
+            (newMemberships) => {
+                this.memberships = newMemberships;
+                this._slotId = this._slotId ?? this.memberships[0]?.slotId;
+
+                const changed =
+                    oldMemberships.length != this.memberships.length ||
+                    // If they have the same length, this is enough to check "changed"
+                    oldMemberships.some((m, i) => !CallMembership.equal(m, this.memberships[i]));
+
+                if (changed) {
+                    this.logger.info(
+                        `Memberships for call in room ${this.roomSubset.roomId} have changed: emitting (${this.memberships.length} members)`,
                     );
-                } else {
-                    this.logger.warn("Own membership eventId is undefined, cannot send call notification");
+                    logDurationSync(this.logger, "emit MatrixRTCSessionEvent.MembershipsChanged", () => {
+                        this.emit(MatrixRTCSessionEvent.MembershipsChanged, oldMemberships, this.memberships);
+                    });
+
+                    void this.membershipManager?.onRTCSessionMemberUpdate(this.memberships);
+                    // The `ownMembership` will be set when calling `onRTCSessionMemberUpdate`.
+                    const ownMembership = this.membershipManager?.ownMembership;
+                    if (this.pendingNotificationToSend && ownMembership && oldMemberships.length === 0) {
+                        // If we're the first member in the call, we're responsible for
+                        // sending the notification event
+                        if (ownMembership.eventId && this.joinConfig?.notificationType) {
+                            this.sendCallNotify(
+                                ownMembership.eventId,
+                                this.joinConfig.notificationType,
+                                ownMembership.callIntent,
+                            );
+                        } else {
+                            this.logger.warn("Own membership eventId is undefined, cannot send call notification");
+                        }
+                    }
+                    // If anyone else joins the session it is no longer our responsibility to send the notification.
+                    // (If we were the joiner we already did sent the notification in the block above.)
+                    if (this.memberships.length > 0) this.pendingNotificationToSend = undefined;
                 }
-            }
-            // If anyone else joins the session it is no longer our responsibility to send the notification.
-            // (If we were the joiner we already did sent the notification in the block above.)
-            if (this.memberships.length > 0) this.pendingNotificationToSend = undefined;
-        }
-        // This also needs to be done if `changed` = false
-        // A member might have updated their fingerprint (created_ts)
-        void this.encryptionManager?.onMembershipsUpdate(oldMemberships);
+                // This also needs to be done if `changed` = false
+                // A member might have updated their fingerprint (created_ts)
+                void this.encryptionManager?.onMembershipsUpdate(oldMemberships);
 
-        this.setExpiryTimer();
+                this.setExpiryTimer();
+            },
+        );
     };
 }