review

Author: toger5

spec/unit/matrixrtc/MatrixRTCSession.spec.ts

@@ -201,59 +201,6 @@ describe("MatrixRTCSession", () => {
         });
     });
 
-    describe("updateCallMembershipEvent", () => {
-        const mockFocus = { type: "livekit", livekit_service_url: "https://test.org" };
-        const joinSessionConfig = {};
-
-        const sessionMembershipData: MembershipData = {
-            call_id: "",
-            scope: "m.room",
-            application: "m.call",
-            user_id: "@mock:user.example",
-            device_id: "AAAAAAA_session",
-            focus_active: mockFocus,
-            foci_preferred: [mockFocus],
-        };
-
-        let sendStateEventMock: jest.Mock;
-        let sendDelayedStateMock: jest.Mock;
-
-        let sentStateEvent: Promise<void>;
-        let sentDelayedState: Promise<void>;
-
-        beforeEach(() => {
-            sentStateEvent = new Promise((resolve) => {
-                sendStateEventMock = jest.fn(resolve);
-            });
-            sentDelayedState = new Promise((resolve) => {
-                sendDelayedStateMock = jest.fn(() => {
-                    resolve();
-                    return {
-                        delay_id: "id",
-                    };
-                });
-            });
-            client.sendStateEvent = sendStateEventMock;
-            client._unstable_sendDelayedStateEvent = sendDelayedStateMock;
-        });
-
-        async function testSession(membershipData: MembershipData): Promise<void> {
-            sess = MatrixRTCSession.roomSessionForRoom(client, makeMockRoom([membershipData]));
-
-            sess.joinRoomSession([mockFocus], mockFocus, joinSessionConfig);
-            await Promise.race([sentStateEvent, new Promise((resolve) => setTimeout(resolve, 500))]);
-
-            expect(sendStateEventMock).toHaveBeenCalledTimes(1);
-
-            await Promise.race([sentDelayedState, new Promise((resolve) => setTimeout(resolve, 500))]);
-            expect(sendDelayedStateMock).toHaveBeenCalledTimes(1);
-        }
-
-        it("sends events", async () => {
-            await testSession(sessionMembershipData);
-        });
-    });
-
     describe("getOldestMembership", () => {
         it("returns the oldest membership event", () => {
             jest.useFakeTimers();
@@ -376,7 +323,7 @@ describe("MatrixRTCSession", () => {
                 "sender_ts": expect.any(Number),
             });
 
-            // check if deprecated notify event is also sent
+            // Check if deprecated notify event is also sent.
             expect(client.sendEvent).toHaveBeenCalledWith(mockRoom!.roomId, EventType.CallNotify, {
                 "application": "m.call",
                 "m.mentions": { user_ids: [], room: true },

src/@types/event.ts

@@ -164,7 +164,6 @@ export enum RelationType {
     // Once we support *only* the stable prefix, THREAD_RELATION_TYPE can die and we can switch to this.
     Thread = "m.thread",
     unstable_RTCNotificationParent = "org.matrix.msc4075.rtc.notification.parent",
-    unstable_RTCNotificationDecline = "org.matrix.msc4075.rtc.notification.decline",
 }
 
 export enum MsgType {

src/matrixrtc/MatrixRTCSession.ts

@@ -194,6 +194,7 @@ export class MatrixRTCSession extends TypedEventEmitter<
     private joinConfig?: SessionConfig;
     private logger: Logger;
 
+    private pendingNotificationToSend: undefined | Exclude<RTCNotificationType, "decline">;
     /**
      * This timeout is responsible to track any expiration. We need to know when we have to start
      * to ignore other call members. There is no callback for this. This timeout will always be configured to
@@ -459,6 +460,7 @@ export class MatrixRTCSession extends TypedEventEmitter<
         }
 
         this.joinConfig = joinConfig;
+        this.pendingNotificationToSend = this.joinConfig?.notificationType;
 
         // Join!
         this.membershipManager!.join(fociPreferred, fociActive, (e) => {
@@ -490,9 +492,10 @@ export class MatrixRTCSession extends TypedEventEmitter<
         this.logger.info(`Leaving call session in room ${this.roomSubset.roomId}`);
 
         this.encryptionManager!.leave();
-        const leavePromise = this.membershipManager!.leave(timeout);
 
+        const leavePromise = this.membershipManager!.leave(timeout);
         this.emit(MatrixRTCSessionEvent.JoinStateChanged, false);
+
         return await leavePromise;
     }
 
@@ -562,33 +565,30 @@ export class MatrixRTCSession extends TypedEventEmitter<
     /**
      * Sends a notification corresponding to the configured notify type.
      */
-    private sendCallNotify(parentEventId: string): void {
-        const notificationType = this.joinConfig?.notificationType;
-        if (notificationType !== undefined) {
-            // Send legacy event:
-
-            this.client
-                .sendEvent(this.roomSubset.roomId, EventType.CallNotify, {
-                    "application": "m.call",
-                    "m.mentions": { user_ids: [], room: true },
-                    "notify_type": notificationType === "notification" ? "notify" : notificationType,
-                    "call_id": this.callId!,
-                })
-                .catch((e) => this.logger.error("Failed to send call notification", e));
-            // Send new event:
-            this.client
-                .sendEvent(this.roomSubset.roomId, EventType.RTCNotification, {
-                    "m.mentions": { user_ids: [], room: true },
-                    "notification_type": notificationType,
-                    "m.relates_to": {
-                        event_id: parentEventId,
-                        rel_type: RelationType.unstable_RTCNotificationParent,
-                    },
-                    "sender_ts": Date.now(),
-                    "lifetime": 30_000, // 30 seconds
-                })
-                .catch((e) => this.logger.error("Failed to send call notification", e));
-        }
+    private sendCallNotify(parentEventId: string, notificationType: Exclude<RTCNotificationType, "decline">): void {
+        // Send legacy event:
+        this.client
+            .sendEvent(this.roomSubset.roomId, EventType.CallNotify, {
+                "application": "m.call",
+                "m.mentions": { user_ids: [], room: true },
+                "notify_type": notificationType === "notification" ? "notify" : notificationType,
+                "call_id": this.callId!,
+            })
+            .catch((e) => this.logger.error("Failed to send call notification", e));
+
+        // Send new event:
+        this.client
+            .sendEvent(this.roomSubset.roomId, EventType.RTCNotification, {
+                "m.mentions": { user_ids: [], room: true },
+                "notification_type": notificationType,
+                "m.relates_to": {
+                    event_id: parentEventId,
+                    rel_type: RelationType.unstable_RTCNotificationParent,
+                },
+                "sender_ts": Date.now(),
+                "lifetime": 30_000, // 30 seconds
+            })
+            .catch((e) => this.logger.error("Failed to send call notification", e));
     }
 
     /**
@@ -631,16 +631,20 @@ export class MatrixRTCSession extends TypedEventEmitter<
             });
 
             void this.membershipManager?.onRTCSessionMemberUpdate(this.memberships);
+            // The `ownMembership` will be set when calling `onRTCSessionMemberUpdate`.
             const ownMembership = this.membershipManager?.ownMembership;
-            if (ownMembership && oldMemberships.length === 0) {
+            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.sendCallNotify(ownMembership.eventId);
+                if (ownMembership.eventId && this.joinConfig?.notificationType) {
+                    this.sendCallNotify(ownMembership.eventId, this.joinConfig.notificationType);
                 } 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;
         }
         // This also needs to be done if `changed` = false
         // A member might have updated their fingerprint (created_ts)