update IKeyTransport interface to event emitter.

toger5 · toger5 · commit c8e62798efda · 2025-04-02T13:57:24.000+02:00
diff --git a/src/matrixrtc/EncryptionManager.ts b/src/matrixrtc/EncryptionManager.ts
@@ -5,7 +5,7 @@ import { secureRandomBase64Url } from "../randomstring.ts";
 import { decodeBase64, encodeUnpaddedBase64 } from "../base64.ts";
 import { safeGetRetryAfterMs } from "../http-api/errors.ts";
 import { type CallMembership } from "./CallMembership.ts";
-import { type IKeyTransport } from "./IKeyTransport.ts";
+import { KeyTransportEventListener, type IKeyTransport } from "./IKeyTransport.ts";
 
 const logger = rootLogger.getChild("MatrixRTCSession");
 
@@ -43,15 +43,6 @@ export interface IEncryptionManager {
 
     onMembershipsUpdate(oldMemberships: CallMembership[]): void;
 
-    /**
-     * Process `m.call.encryption_keys` events to track the encryption keys for call participants.
-     * This should be called each time the relevant event is received from a room timeline.
-     * If the event is malformed then it will be logged and ignored.
-     *
-     * @param event the event to process
-     */
-    onCallEncryptionEventReceived(event: MatrixEvent): void;
-
     getEncryptionKeys(): Map<string, Array<{ key: Uint8Array; timestamp: number }>>;
 
     statistics: Statistics;
@@ -303,14 +294,8 @@ export class EncryptionManager implements IEncryptionManager {
         }
     };
 
-    public onCallEncryptionEventReceived = (event: MatrixEvent): void => {
-        this.transport.receiveRoomEvent(
-            event,
-            this.statistics,
-            (userId, deviceId, encryptionKeyIndex, encryptionKeyString, timestamp) => {
-                this.setEncryptionKey(userId, deviceId, encryptionKeyIndex, encryptionKeyString, timestamp);
-            },
-        );
+    public onNewKeyReceived: KeyTransportEventListener = (userId, deviceId, keyBase64Encoded, index, timestamp) => {
+        this.setEncryptionKey(userId, deviceId, index, keyBase64Encoded, timestamp);
     };
 
     private storeLastMembershipFingerprints(): void {
diff --git a/src/matrixrtc/IKeyTransport.ts b/src/matrixrtc/IKeyTransport.ts
@@ -14,10 +14,24 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { type MatrixEvent } from "../models/event.ts";
-import { type Statistics } from "./EncryptionManager.ts";
 import { type CallMembership } from "./CallMembership.ts";
 
+export enum KeyTransportEvents {
+    ReceivedKeys = "received_keys",
+}
+
+export type KeyTransportEventListener = (
+    userId: string,
+    deviceId: string,
+    keyBase64Encoded: string,
+    index: number,
+    timestamp: number,
+) => void;
+
+export type KeyTransportEventsHandlerMap = {
+    [KeyTransportEvents.ReceivedKeys]: KeyTransportEventListener;
+};
+
 /**
  * Generic interface for the transport used to share room keys.
  * Keys can be shared using different transports, e.g. to-device messages or room messages.
@@ -31,21 +45,9 @@ export interface IKeyTransport {
      */
     sendKey(keyBase64Encoded: string, index: number, members: CallMembership[]): Promise<void>;
 
-    /**
-     * Takes an incoming event from the transport and extracts the key information.
-     * @param event
-     * @param statistics
-     * @param callback
-     */
-    receiveRoomEvent(
-        event: MatrixEvent,
-        statistics: Statistics,
-        callback: (
-            userId: string,
-            deviceId: string,
-            encryptionKeyIndex: number,
-            encryptionKeyString: string,
-            timestamp: number,
-        ) => void,
-    ): void;
+    on(event: KeyTransportEvents.ReceivedKeys, listener: KeyTransportEventListener): this;
+    off(event: KeyTransportEvents.ReceivedKeys, listener: KeyTransportEventListener): this;
+
+    start(): void;
+    stop(): void;
 }
diff --git a/src/matrixrtc/MatrixRTCSession.ts b/src/matrixrtc/MatrixRTCSession.ts
@@ -24,7 +24,6 @@ import { CallMembership } from "./CallMembership.ts";
 import { RoomStateEvent } from "../models/room-state.ts";
 import { type Focus } from "./focus.ts";
 import { KnownMembership } from "../@types/membership.ts";
-import { type MatrixEvent } from "../models/event.ts";
 import { MembershipManager } from "./NewMembershipManager.ts";
 import { EncryptionManager, type IEncryptionManager, type Statistics } from "./EncryptionManager.ts";
 import { LegacyMembershipManager } from "./LegacyMembershipManager.ts";
@@ -298,7 +297,10 @@ export class MatrixRTCSession extends TypedEventEmitter<MatrixRTCSessionEvent, M
             | "sendEvent"
             | "cancelPendingEvent"
         >,
-        private roomSubset: Pick<Room, "getLiveTimeline" | "roomId" | "getVersion" | "hasMembershipState">,
+        private roomSubset: Pick<
+            Room,
+            "getLiveTimeline" | "roomId" | "getVersion" | "hasMembershipState" | "on" | "off"
+        >,
         public memberships: CallMembership[],
     ) {
         super();
@@ -308,7 +310,7 @@ export class MatrixRTCSession extends TypedEventEmitter<MatrixRTCSessionEvent, M
         roomState?.on(RoomStateEvent.Members, this.onRoomMemberUpdate);
         this.setExpiryTimer();
 
-        const transport = new RoomKeyTransport(this.roomSubset.roomId, this.client);
+        const transport = new RoomKeyTransport(this.roomSubset, this.client, this.statistics);
         this.encryptionManager = new EncryptionManager(
             this.client.getUserId()!,
             this.client.getDeviceId()!,
@@ -488,17 +490,6 @@ export class MatrixRTCSession extends TypedEventEmitter<MatrixRTCSessionEvent, M
         }
     }
 
-    /**
-     * Process `m.call.encryption_keys` events to track the encryption keys for call participants.
-     * This should be called each time the relevant event is received from a room timeline.
-     * If the event is malformed then it will be logged and ignored.
-     *
-     * @param event the event to process
-     */
-    public onCallEncryption = (event: MatrixEvent): void => {
-        this.encryptionManager.onCallEncryptionEventReceived(event);
-    };
-
     /**
      * @deprecated use onRoomMemberUpdate or onRTCSessionMemberUpdate instead. this should be called when any membership in the call is updated
      * the old name might have implied to only need to call this when your own membership changes.
diff --git a/src/matrixrtc/MatrixRTCSessionManager.ts b/src/matrixrtc/MatrixRTCSessionManager.ts
@@ -65,7 +65,6 @@ export class MatrixRTCSessionManager extends TypedEventEmitter<MatrixRTCSessionM
         }
 
         this.client.on(ClientEvent.Room, this.onRoom);
-        this.client.on(RoomEvent.Timeline, this.onTimeline);
         this.client.on(RoomStateEvent.Events, this.onRoomState);
     }
 
@@ -76,7 +75,6 @@ export class MatrixRTCSessionManager extends TypedEventEmitter<MatrixRTCSessionM
         this.roomSessions.clear();
 
         this.client.off(ClientEvent.Room, this.onRoom);
-        this.client.off(RoomEvent.Timeline, this.onTimeline);
         this.client.off(RoomStateEvent.Events, this.onRoomState);
     }
 
@@ -100,37 +98,6 @@ export class MatrixRTCSessionManager extends TypedEventEmitter<MatrixRTCSessionM
         return this.roomSessions.get(room.roomId)!;
     }
 
-    private async consumeCallEncryptionEvent(event: MatrixEvent, isRetry = false): Promise<void> {
-        await this.client.decryptEventIfNeeded(event);
-        if (event.isDecryptionFailure()) {
-            if (!isRetry) {
-                logger.warn(
-                    `Decryption failed for event ${event.getId()}: ${event.decryptionFailureReason} will retry once only`,
-                );
-                // retry after 1 second. After this we give up.
-                setTimeout(() => void this.consumeCallEncryptionEvent(event, true), 1000);
-            } else {
-                logger.warn(`Decryption failed for event ${event.getId()}: ${event.decryptionFailureReason}`);
-            }
-            return;
-        } else if (isRetry) {
-            logger.info(`Decryption succeeded for event ${event.getId()} after retry`);
-        }
-
-        if (event.getType() !== EventType.CallEncryptionKeysPrefix) return Promise.resolve();
-
-        const room = this.client.getRoom(event.getRoomId());
-        if (!room) {
-            logger.error(`Got room state event for unknown room ${event.getRoomId()}!`);
-            return Promise.resolve();
-        }
-
-        this.getRoomSession(room).onCallEncryption(event);
-    }
-    private onTimeline = (event: MatrixEvent): void => {
-        void this.consumeCallEncryptionEvent(event);
-    };
-
     private onRoom = (room: Room): void => {
         this.refreshRoom(room);
     };
@@ -152,7 +119,8 @@ export class MatrixRTCSessionManager extends TypedEventEmitter<MatrixRTCSessionM
         const sess = this.getRoomSession(room);
 
         const wasActiveAndKnown = sess.memberships.length > 0 && !isNewSession;
-
+        // TODO remove this and make the session subscribe to this manually.
+        // move away from magically called methods. Prefer explicit subscriptions.
         sess.onRTCSessionMemberUpdate();
 
         const nowActive = sess.memberships.length > 0;
diff --git a/src/matrixrtc/RoomKeyTransport.ts b/src/matrixrtc/RoomKeyTransport.ts
@@ -19,21 +19,64 @@ import type { EncryptionKeysEventContent } from "./types.ts";
 import { EventType } from "../@types/event.ts";
 import { type MatrixError } from "../http-api/errors.ts";
 import { logger, type Logger } from "../logger.ts";
-import { type IKeyTransport } from "./IKeyTransport.ts";
+import { KeyTransportEvents, KeyTransportEventsHandlerMap, type IKeyTransport } from "./IKeyTransport.ts";
 import { type MatrixEvent } from "../models/event.ts";
 import { type Statistics } from "./EncryptionManager.ts";
 import { type CallMembership } from "./CallMembership.ts";
+import { Room, RoomEvent, TypedEventEmitter } from "../matrix.ts";
 
-export class RoomKeyTransport implements IKeyTransport {
+export class RoomKeyTransport
+    extends TypedEventEmitter<KeyTransportEvents, KeyTransportEventsHandlerMap>
+    implements IKeyTransport
+{
     private readonly prefixedLogger: Logger;
 
     public constructor(
-        private roomId: string,
+        private room: Pick<Room, "on" | "off" | "roomId">,
         private client: Pick<MatrixClient, "sendEvent" | "getDeviceId" | "getUserId" | "cancelPendingEvent">,
+        private statistics: Statistics,
     ) {
-        this.prefixedLogger = logger.getChild(`[RTC: ${roomId} RoomKeyTransport]`);
+        super();
+        this.prefixedLogger = logger.getChild(`[RTC: ${room.roomId} RoomKeyTransport]`);
+    }
+    public start(): void {
+        this.room.on(RoomEvent.Timeline, this.onTimeline);
+    }
+    public stop(): void {
+        this.room.off(RoomEvent.Timeline, this.onTimeline);
     }
 
+    private async consumeCallEncryptionEvent(event: MatrixEvent, isRetry = false): Promise<void> {
+        // we should not need this
+        // await this.client.decryptEventIfNeeded(event);
+        if (event.isDecryptionFailure()) {
+            if (!isRetry) {
+                logger.warn(
+                    `Decryption failed for event ${event.getId()}: ${event.decryptionFailureReason} will retry once only`,
+                );
+                // retry after 1 second. After this we give up.
+                setTimeout(() => void this.consumeCallEncryptionEvent(event, true), 1000);
+            } else {
+                logger.warn(`Decryption failed for event ${event.getId()}: ${event.decryptionFailureReason}`);
+            }
+            return;
+        } else if (isRetry) {
+            logger.info(`Decryption succeeded for event ${event.getId()} after retry`);
+        }
+
+        if (event.getType() !== EventType.CallEncryptionKeysPrefix) return Promise.resolve();
+
+        if (!this.room) {
+            logger.error(`Got room state event for unknown room ${event.getRoomId()}!`);
+            return Promise.resolve();
+        }
+
+        this.onEncryptionEvent(event);
+    }
+    private onTimeline = (event: MatrixEvent): void => {
+        void this.consumeCallEncryptionEvent(event);
+    };
+
     /** implements {@link IKeyTransport#sendKey} */
     public async sendKey(keyBase64Encoded: string, index: number, members: CallMembership[]): Promise<void> {
         // members not used in room transports as the keys are sent to all room members
@@ -50,7 +93,7 @@ export class RoomKeyTransport implements IKeyTransport {
         };
 
         try {
-            await this.client.sendEvent(this.roomId, EventType.CallEncryptionKeysPrefix, content);
+            await this.client.sendEvent(this.room.roomId, EventType.CallEncryptionKeysPrefix, content);
         } catch (error) {
             this.prefixedLogger.error("Failed to send call encryption keys", error);
             const matrixError = error as MatrixError;
@@ -63,17 +106,7 @@ export class RoomKeyTransport implements IKeyTransport {
         }
     }
 
-    public receiveRoomEvent(
-        event: MatrixEvent,
-        statistics: Statistics,
-        callback: (
-            userId: string,
-            deviceId: string,
-            encryptionKeyIndex: number,
-            encryptionKeyString: string,
-            timestamp: number,
-        ) => void,
-    ): void {
+    public onEncryptionEvent(event: MatrixEvent): void {
         const userId = event.getSender();
         const content = event.getContent<EncryptionKeysEventContent>();
 
@@ -106,9 +139,9 @@ export class RoomKeyTransport implements IKeyTransport {
             return;
         }
 
-        statistics.counters.roomEventEncryptionKeysReceived += 1;
+        this.statistics.counters.roomEventEncryptionKeysReceived += 1;
         const age = Date.now() - (typeof content.sent_ts === "number" ? content.sent_ts : event.getTs());
-        statistics.totals.roomEventEncryptionKeysReceivedTotalAge += age;
+        this.statistics.totals.roomEventEncryptionKeysReceivedTotalAge += age;
 
         for (const key of content.keys) {
             if (!key) {
@@ -137,7 +170,14 @@ export class RoomKeyTransport implements IKeyTransport {
                 logger.debug(
                     `Embedded-E2EE-LOG onCallEncryption userId=${userId}:${deviceId} encryptionKeyIndex=${encryptionKeyIndex} age=${age}ms`,
                 );
-                callback(userId, deviceId, encryptionKeyIndex, encryptionKey, event.getTs());
+                this.emit(
+                    KeyTransportEvents.ReceivedKeys,
+                    userId,
+                    deviceId,
+                    encryptionKey,
+                    encryptionKeyIndex,
+                    event.getTs(),
+                );
             }
         }
     }
