use sticky events for matrixRTC

toger5 · toger5 · commit dde4abb1f51d · 2025-09-23T19:56:55.000+02:00
Signed-off-by: Timo K &lt;toger5@hotmail.de&gt;
diff --git a/src/matrixrtc/CallMembership.ts b/src/matrixrtc/CallMembership.ts
@@ -86,6 +86,10 @@ export type SessionMembershipData = {
      * (for example caused by a homeserver crashes)
      **/
     expires?: number;
+    /**
+     * the sticky key for sticky events packed application + device_id making up the used slot + device.
+     */
+    sticky_key?: string;
 };
 
 const checkSessionsMembershipData = (data: any, errors: string[]): data is SessionMembershipData => {
diff --git a/src/matrixrtc/MatrixRTCSession.ts b/src/matrixrtc/MatrixRTCSession.ts
@@ -17,7 +17,7 @@ limitations under the License.
 import { type Logger, logger as rootLogger } from "../logger.ts";
 import { TypedEventEmitter } from "../models/typed-event-emitter.ts";
 import { EventTimeline } from "../models/event-timeline.ts";
-import { type Room } from "../models/room.ts";
+import { RoomEvent, type Room } from "../models/room.ts";
 import { type MatrixClient } from "../client.ts";
 import { EventType, RelationType } from "../@types/event.ts";
 import { KnownMembership } from "../@types/membership.ts";
@@ -49,6 +49,7 @@ import {
 } from "./RoomAndToDeviceKeyTransport.ts";
 import { TypedReEmitter } from "../ReEmitter.ts";
 import { ToDeviceKeyTransport } from "./ToDeviceKeyTransport.ts";
+import { type MatrixEvent } from "src/matrix.ts";
 
 /**
  * Events emitted by MatrixRTCSession
@@ -285,7 +286,7 @@ export class MatrixRTCSession extends TypedEventEmitter<
      * @deprecated Use `MatrixRTCSession.sessionMembershipsForRoom` instead.
      */
     public static callMembershipsForRoom(
-        room: Pick<Room, "getLiveTimeline" | "roomId" | "hasMembershipState">,
+        room: Pick<Room, "getLiveTimeline" | "roomId" | "hasMembershipState" | "getStickyEventsMap">,
     ): CallMembership[] {
         return MatrixRTCSession.sessionMembershipsForRoom(room, {
             id: "",
@@ -298,16 +299,24 @@ export class MatrixRTCSession extends TypedEventEmitter<
      * oldest first.
      */
     public static sessionMembershipsForRoom(
-        room: Pick<Room, "getLiveTimeline" | "roomId" | "hasMembershipState">,
+        room: Pick<Room, "getLiveTimeline" | "roomId" | "hasMembershipState" | "getStickyEventsMap">,
         sessionDescription: SessionDescription,
+        useStickyEvents: boolean = true,
     ): 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);
+        let callMemberEvents;
+        if (useStickyEvents) {
+            callMemberEvents = Array.from(room.getStickyEventsMap().values()).filter(
+                (e) => e.getType() === EventType.GroupCallMemberPrefix,
+            );
+        } else {
+            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);
+            }
+            callMemberEvents = roomState.getStateEvents(EventType.GroupCallMemberPrefix);
         }
-        const callMemberEvents = roomState.getStateEvents(EventType.GroupCallMemberPrefix);
 
         const callMemberships: CallMembership[] = [];
         for (const memberEvent of callMemberEvents) {
@@ -422,10 +431,10 @@ export class MatrixRTCSession extends TypedEventEmitter<
             MatrixClient,
             | "getUserId"
             | "getDeviceId"
-            | "sendStateEvent"
-            | "_unstable_sendDelayedStateEvent"
-            | "_unstable_updateDelayedEvent"
             | "sendEvent"
+            | "_unstable_updateDelayedEvent"
+            | "_unstable_sendStickyEvent"
+            | "_unstable_sendStickyDelayedEvent"
             | "cancelPendingEvent"
             | "encryptAndSendToDevice"
             | "off"
@@ -449,9 +458,10 @@ export class MatrixRTCSession extends TypedEventEmitter<
         const roomState = this.roomSubset.getLiveTimeline().getState(EventTimeline.FORWARDS);
         // TODO: double check if this is actually needed. Should be covered by refreshRoom in MatrixRTCSessionManager
         roomState?.on(RoomStateEvent.Members, this.onRoomMemberUpdate);
+        this.roomSubset.on(RoomEvent.StickyEvents, this.onStickyEventUpdate);
+
         this.setExpiryTimer();
     }
-
     /*
      * Returns true if we intend to be participating in the MatrixRTC session.
      * This is determined by checking if the relativeExpiry has been set.
@@ -471,6 +481,7 @@ export class MatrixRTCSession extends TypedEventEmitter<
         }
         const roomState = this.roomSubset.getLiveTimeline().getState(EventTimeline.FORWARDS);
         roomState?.off(RoomStateEvent.Members, this.onRoomMemberUpdate);
+        this.roomSubset.off(RoomEvent.StickyEvents, this.onStickyEventUpdate);
     }
     private reEmitter = new TypedReEmitter<
         MatrixRTCSessionEvent | RoomAndToDeviceEvents | MembershipManagerEvent,
@@ -718,6 +729,12 @@ export class MatrixRTCSession extends TypedEventEmitter<
         this.recalculateSessionMembers();
     };
 
+    private onStickyEventUpdate = (stickyEvents: Map<string, MatrixEvent>, room: Room): void => {
+        if (Array.from(stickyEvents.values()).some((e) => e.getType() === EventType.GroupCallMemberPrefix)) {
+            this.recalculateSessionMembers();
+        }
+    };
+
     /**
      * Call this when something changed that may impacts the current MatrixRTC members in this session.
      */
diff --git a/src/matrixrtc/MembershipManager.ts b/src/matrixrtc/MembershipManager.ts
@@ -34,6 +34,7 @@ import {
     type IMembershipManager,
     type MembershipManagerEventHandlerMap,
 } from "./IMembershipManager.ts";
+import { type EmptyObject } from "src/matrix.ts";
 
 /* MembershipActionTypes:
                            
@@ -77,6 +78,8 @@ On Leave: ─────────  STOP ALL ABOVE
 (s) Successful restart/resend
 */
 
+const STICK_DURATION_MS = 60 * 60 * 1000; // 60 minutes
+
 /**
  * The different types of actions the MembershipManager can take.
  * @internal
@@ -295,9 +298,9 @@ export class MembershipManager
             MatrixClient,
             | "getUserId"
             | "getDeviceId"
-            | "sendStateEvent"
-            | "_unstable_sendDelayedStateEvent"
             | "_unstable_updateDelayedEvent"
+            | "_unstable_sendStickyEvent"
+            | "_unstable_sendStickyDelayedEvent"
         >,
         private getOldestMembership: () => CallMembership | undefined,
         public readonly sessionDescription: SessionDescription,
@@ -371,7 +374,11 @@ export class MembershipManager
         return this.joinConfig?.membershipEventExpiryHeadroomMs ?? 5_000;
     }
     private computeNextExpiryActionTs(iteration: number): number {
-        return this.state.startTime + this.membershipEventExpiryMs * iteration - this.membershipEventExpiryHeadroomMs;
+        return (
+            this.state.startTime +
+            Math.min(this.membershipEventExpiryMs, STICK_DURATION_MS) * iteration -
+            this.membershipEventExpiryHeadroomMs
+        );
     }
     private get delayedLeaveEventDelayMs(): number {
         return this.delayedLeaveEventDelayMsOverride ?? this.joinConfig?.delayedLeaveEventDelayMs ?? 8_000;
@@ -450,14 +457,15 @@ export class MembershipManager
         // (Another client could have canceled it, the homeserver might have removed/lost it due to a restart, ...)
         // In the `then` and `catch` block we treat both cases differently. "if (this.state.hasMemberStateEvent) {} else {}"
         return await this.client
-            ._unstable_sendDelayedStateEvent(
+            ._unstable_sendStickyDelayedEvent(
                 this.room.roomId,
+                STICK_DURATION_MS,
                 {
                     delay: this.delayedLeaveEventDelayMs,
                 },
+                null,
                 EventType.GroupCallMemberPrefix,
-                {}, // leave event
-                this.stateKey,
+                { sticky_key: this.stateKey } as EmptyObject & { sticky_key: string }, // leave event
             )
             .then((response) => {
                 this.state.expectedServerDelayLeaveTs = Date.now() + this.delayedLeaveEventDelayMs;
@@ -482,7 +490,7 @@ export class MembershipManager
                 if (this.manageMaxDelayExceededSituation(e)) {
                     return createInsertActionUpdate(repeatActionType);
                 }
-                const update = this.actionUpdateFromErrors(e, repeatActionType, "sendDelayedStateEvent");
+                const update = this.actionUpdateFromErrors(e, repeatActionType, "_unstable_sendStickyDelayedEvent");
                 if (update) return update;
 
                 if (this.state.hasMemberStateEvent) {
@@ -640,12 +648,10 @@ export class MembershipManager
 
     private async sendJoinEvent(): Promise<ActionUpdate> {
         return await this.client
-            .sendStateEvent(
-                this.room.roomId,
-                EventType.GroupCallMemberPrefix,
-                this.makeMyMembership(this.membershipEventExpiryMs),
-                this.stateKey,
-            )
+            ._unstable_sendStickyEvent(this.room.roomId, STICK_DURATION_MS, null, EventType.GroupCallMemberPrefix, {
+                ...this.makeMyMembership(this.membershipEventExpiryMs),
+                sticky_key: this.stateKey,
+            })
             .then(() => {
                 this.setAndEmitProbablyLeft(false);
                 this.state.startTime = Date.now();
@@ -677,7 +683,11 @@ export class MembershipManager
                 };
             })
             .catch((e) => {
-                const update = this.actionUpdateFromErrors(e, MembershipActionType.SendJoinEvent, "sendStateEvent");
+                const update = this.actionUpdateFromErrors(
+                    e,
+                    MembershipActionType.SendJoinEvent,
+                    "_unstable_sendStickyEvent",
+                );
                 if (update) return update;
                 throw e;
             });
@@ -686,12 +696,10 @@ export class MembershipManager
     private async updateExpiryOnJoinedEvent(): Promise<ActionUpdate> {
         const nextExpireUpdateIteration = this.state.expireUpdateIterations + 1;
         return await this.client
-            .sendStateEvent(
-                this.room.roomId,
-                EventType.GroupCallMemberPrefix,
-                this.makeMyMembership(this.membershipEventExpiryMs * nextExpireUpdateIteration),
-                this.stateKey,
-            )
+            ._unstable_sendStickyEvent(this.room.roomId, STICK_DURATION_MS, null, EventType.GroupCallMemberPrefix, {
+                ...this.makeMyMembership(this.membershipEventExpiryMs),
+                sticky_key: this.stateKey,
+            })
             .then(() => {
                 // Success, we reset retries and schedule update.
                 this.resetRateLimitCounter(MembershipActionType.UpdateExpiry);
@@ -706,22 +714,36 @@ export class MembershipManager
                 };
             })
             .catch((e) => {
-                const update = this.actionUpdateFromErrors(e, MembershipActionType.UpdateExpiry, "sendStateEvent");
+                const update = this.actionUpdateFromErrors(
+                    e,
+                    MembershipActionType.UpdateExpiry,
+                    "_unstable_sendStickyEvent",
+                );
                 if (update) return update;
 
                 throw e;
             });
     }
     private async sendFallbackLeaveEvent(): Promise<ActionUpdate> {
         return await this.client
-            .sendStateEvent(this.room.roomId, EventType.GroupCallMemberPrefix, {}, this.stateKey)
+            ._unstable_sendStickyEvent(
+                this.room.roomId,
+                STICK_DURATION_MS,
+                null,
+                EventType.GroupCallMemberPrefix,
+                { sticky_key: this.stateKey } as EmptyObject & { sticky_key: string }, // leave event
+            )
             .then(() => {
                 this.resetRateLimitCounter(MembershipActionType.SendLeaveEvent);
                 this.state.hasMemberStateEvent = false;
                 return { replace: [] };
             })
             .catch((e) => {
-                const update = this.actionUpdateFromErrors(e, MembershipActionType.SendLeaveEvent, "sendStateEvent");
+                const update = this.actionUpdateFromErrors(
+                    e,
+                    MembershipActionType.SendLeaveEvent,
+                    "_unstable_sendStickyEvent",
+                );
                 if (update) return update;
                 throw e;
             });
