review

Author: toger5

spec/unit/embedded.spec.ts

@@ -722,13 +722,14 @@ describe("RoomWidgetClient", () => {
             expect(widgetApi.sendToDevice).toHaveBeenCalledWith("org.example.foo", false, expectedRequestData);
         });
 
-        it("sends encrypted (encryptAndSendToDevices)", async () => {
+        it("sends encrypted (encryptAndSendToDevice)", async () => {
             await makeClient({ sendToDevice: ["org.example.foo"] });
             expect(widgetApi.requestCapabilityToSendToDevice).toHaveBeenCalledWith("org.example.foo");
 
-            const payload = { type: "org.example.foo", hello: "world" };
+            const payload = { hello: "world" };
             const embeddedClient = client as RoomWidgetClient;
-            await embeddedClient.encryptAndSendToDevices(
+            await embeddedClient.encryptAndSendToDevice(
+                "org.example.foo",
                 [
                     { userId: "@alice:example.org", deviceId: "aliceWeb" },
                     { userId: "@bob:example.org", deviceId: "bobDesktop" },

src/client.ts

@@ -7942,6 +7942,14 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
         return this.http.authedRequest(Method.Put, path, undefined, body);
     }
 
+    /**
+     * This will encrypt the payload for all devices in the list and will queue it.
+     * The type of the sent to-device message will be `m.room.encrypted`.
+     * @param eventType - The type of event to send
+     * @param devices - The list of devices to send the event to. Each device is
+     * @param payload - The payload to send. This will be encrypted.
+     * @returns Promise which resolves once queued.
+     */
     public async encryptAndSendToDevice(
         eventType: string,
         devices: { userId: string; deviceId: string }[],

src/embedded.ts

@@ -62,17 +62,6 @@ interface IStateEventRequest {
     stateKey?: string;
 }
 
-export interface OlmDevice {
-    /**
-     * The user ID of the device owner.
-     */
-    userId: string;
-    /**
-     * The device ID of the device.
-     */
-    deviceId: string;
-}
-
 export interface ICapabilities {
     /**
      * Event types that this client expects to send.
@@ -464,6 +453,9 @@ export class RoomWidgetClient extends MatrixClient {
         return {};
     }
 
+    /**
+     * by {@link MatrixClient.encryptAndSendToDevice}.
+     */
     public async encryptAndSendToDevice(
         eventType: string,
         devices: { userId: string; deviceId: string }[],
@@ -511,18 +503,6 @@ export class RoomWidgetClient extends MatrixClient {
             .catch(timeoutToConnectionError);
     }
 
-    public async encryptAndSendToDevices(userDeviceInfoArr: OlmDevice[], payload: object): Promise<void> {
-        // map: user Id → device Id → payload
-        const contentMap: MapWithDefault<string, Map<string, object>> = new MapWithDefault(() => new Map());
-        for (const { userId, deviceId } of userDeviceInfoArr) {
-            contentMap.getOrCreate(userId).set(deviceId, payload);
-        }
-
-        await this.widgetApi
-            .sendToDevice((payload as { type: string }).type, true, recursiveMapToObject(contentMap))
-            .catch(timeoutToConnectionError);
-    }
-
     /**
      * Send an event to a specific list of devices via the widget API. Optionally encrypts the event.
      *

src/matrixrtc/EncryptionManager.ts

@@ -13,10 +13,6 @@ const logger = rootLogger.getChild("MatrixRTCSession");
  * This interface is for testing and for making it possible to interchange the encryption manager.
  * @internal
  */
-/**
- * Interface representing an encryption manager for handling encryption-related
- * operations in a real-time communication context.
- */
 export interface IEncryptionManager {
     /**
      * Joins the encryption manager with the provided configuration.

src/matrixrtc/IKeyTransport.ts

@@ -45,9 +45,17 @@ export interface IKeyTransport {
      */
     sendKey(keyBase64Encoded: string, index: number, members: CallMembership[]): Promise<void>;
 
+    /** Subscribe to keys from this transport. */
     on(event: KeyTransportEvents.ReceivedKeys, listener: KeyTransportEventListener): this;
+    /** Unsubscribe to keys from this transport. */
     off(event: KeyTransportEvents.ReceivedKeys, listener: KeyTransportEventListener): this;
 
+    /** Once start is called the underlying transport will subscribe to its transport system.
+     * Before start is called this transport will not emit any events.
+     */
     start(): void;
+    /** Once stop is called the underlying transport will unsubscribe from its transport system.
+     * After stop is called this transport will not emit any events.
+     */
     stop(): void;
 }

src/matrixrtc/MatrixRTCSession.ts

@@ -380,7 +380,7 @@ export class MatrixRTCSession extends TypedEventEmitter<MatrixRTCSessionEvent, M
             }
             // Create Encryption manager
             let transport;
-            if (joinConfig?.useExperimentalToDeviceTransport == true) {
+            if (joinConfig?.useExperimentalToDeviceTransport) {
                 logger.info("Using experimental to-device transport for encryption keys");
                 transport = new ToDeviceKeyTransport(
                     this.client.getUserId()!,

src/webrtc/call.ts

@@ -2510,7 +2510,7 @@ export class MatrixCall extends TypedEventEmitter<CallEvent, CallEventHandlerMap
                     return;
                 }
 
-                // TODO: Here we were sending the event to the opponent's device as a to-device message with MatrixClient.encryptAndSendToDevices.
+                // TODO: Here we were sending the event to the opponent's device as a to-device message with MatrixClient.encryptAndSendToDevice.
                 // However due to the switch to Rust cryptography we need to migrate to the new encryptToDeviceMessages API.
                 throw new Error("Unimplemented");
             } else {