Group Calls (WIP)

README.md

@@ -307,7 +307,7 @@ The SDK supports end-to-end encryption via the Olm and Megolm protocols, using
 [libolm](https://gitlab.matrix.org/matrix-org/olm). It is left up to the
 application to make libolm available, via the ``Olm`` global.
 
-It is also necessary to call ``matrixClient.initCrypto()`` after creating a new
+It is also necessary to call ``await matrixClient.initCrypto()`` after creating a new
 ``MatrixClient`` (but **before** calling ``matrixClient.startClient()``) to
 initialise the crypto layer.
 

spec/unit/crypto/algorithms/megolm.spec.js

@@ -321,6 +321,12 @@ describe("MegolmDecryption", function() {
                         rotation_period_ms: 9999999999999,
                     },
                 });
+
+                // Fix the mock to call the stuff we need it to
+                mockCrypto.encryptAndSendToDevices = Crypto.prototype.encryptAndSendToDevices;
+                mockCrypto.olmDevice = olmDevice;
+                mockCrypto.baseApis = mockBaseApis;
+
                 mockRoom = {
                     getEncryptionTargetMembers: jest.fn().mockReturnValue(
                         [{ userId: "@alice:home.server" }],

spec/unit/webrtc/call.spec.ts

@@ -145,6 +145,14 @@ describe('Call', function() {
         client.client.mediaHandler = new MockMediaHandler;
         client.client.getMediaHandler = () => client.client.mediaHandler;
         client.httpBackend.when("GET", "/voip/turnServer").respond(200, {});
+        client.client.getRoom = () => {
+            return {
+                getMember: () => {
+                    return {};
+                },
+            };
+        };
+
         call = new MatrixCall({
             client: client.client,
             roomId: '!foo:bar',
@@ -175,6 +183,7 @@ describe('Call', function() {
                     },
                 };
             },
+            getSender: () => "@test:foo",
         });
 
         call.peerConn.addIceCandidate = jest.fn();
@@ -192,6 +201,7 @@ describe('Call', function() {
                     ],
                 };
             },
+            getSender: () => "@test:foo",
         });
         expect(call.peerConn.addIceCandidate.mock.calls.length).toBe(1);
 
@@ -209,6 +219,7 @@ describe('Call', function() {
                     ],
                 };
             },
+            getSender: () => "@test:foo",
         });
         expect(call.peerConn.addIceCandidate.mock.calls.length).toBe(1);
 
@@ -236,6 +247,7 @@ describe('Call', function() {
                     ],
                 };
             },
+            getSender: () => "@test:foo",
         });
 
         call.onRemoteIceCandidatesReceived({
@@ -252,6 +264,7 @@ describe('Call', function() {
                     ],
                 };
             },
+            getSender: () => "@test:foo",
         });
 
         expect(call.peerConn.addIceCandidate.mock.calls.length).toBe(0);
@@ -267,6 +280,7 @@ describe('Call', function() {
                     },
                 };
             },
+            getSender: () => "@test:foo",
         });
 
         expect(call.peerConn.addIceCandidate.mock.calls.length).toBe(1);
@@ -291,6 +305,7 @@ describe('Call', function() {
                     },
                 };
             },
+            getSender: () => "@test:foo",
         });
 
         const identChangedCallback = jest.fn();
@@ -308,6 +323,7 @@ describe('Call', function() {
                     },
                 };
             },
+            getSender: () => "@test:foo",
         });
 
         expect(identChangedCallback).toHaveBeenCalled();
@@ -347,6 +363,7 @@ describe('Call', function() {
                     },
                 };
             },
+            getSender: () => "@test:foo",
         });
 
         call.pushRemoteFeed(new MockMediaStream("remote_stream"));
@@ -376,6 +393,7 @@ describe('Call', function() {
                     },
                 };
             },
+            getSender: () => "@test:foo",
         });
 
         call.setScreensharingEnabledWithoutMetadataSupport = jest.fn();

spec/unit/webrtc/callEventHandler.spec.ts

@@ -0,0 +1,83 @@
+import { TestClient } from '../../TestClient';
+import { CallEventHandler } from '../../../src/webrtc/callEventHandler';
+import { MatrixEvent } from '../../../src/models/event';
+import { EventType } from '../../../src/@types/event';
+
+describe('CallEventHandler', function() {
+    let client;
+
+    beforeEach(function() {
+        client = new TestClient("@alice:foo", "somedevice", "token", undefined, {});
+    });
+
+    afterEach(function() {
+        client.stop();
+    });
+
+    it('should enforce inbound toDevice message ordering', async function() {
+        const callEventHandler = new CallEventHandler(client);
+
+        const event1 = new MatrixEvent({
+            type: EventType.CallInvite,
+            content: {
+                call_id: "123",
+                seq: 0,
+            },
+        });
+        callEventHandler["onToDeviceEvent"](event1);
+
+        expect(callEventHandler.callEventBuffer.length).toBe(1);
+        expect(callEventHandler.callEventBuffer[0]).toBe(event1);
+
+        const event2 = new MatrixEvent({
+            type: EventType.CallCandidates,
+            content: {
+                call_id: "123",
+                seq: 1,
+            },
+        });
+        callEventHandler["onToDeviceEvent"](event2);
+
+        expect(callEventHandler.callEventBuffer.length).toBe(2);
+        expect(callEventHandler.callEventBuffer[1]).toBe(event2);
+
+        const event3 = new MatrixEvent({
+            type: EventType.CallCandidates,
+            content: {
+                call_id: "123",
+                seq: 3,
+            },
+        });
+        callEventHandler["onToDeviceEvent"](event3);
+
+        expect(callEventHandler.callEventBuffer.length).toBe(2);
+        expect(callEventHandler.nextSeqByCall.get("123")).toBe(2);
+        expect(callEventHandler.toDeviceEventBuffers.get("123").length).toBe(1);
+
+        const event4 = new MatrixEvent({
+            type: EventType.CallCandidates,
+            content: {
+                call_id: "123",
+                seq: 4,
+            },
+        });
+        callEventHandler["onToDeviceEvent"](event4);
+
+        expect(callEventHandler.callEventBuffer.length).toBe(2);
+        expect(callEventHandler.nextSeqByCall.get("123")).toBe(2);
+        expect(callEventHandler.toDeviceEventBuffers.get("123").length).toBe(2);
+
+        const event5 = new MatrixEvent({
+            type: EventType.CallCandidates,
+            content: {
+                call_id: "123",
+                seq: 2,
+            },
+        });
+        callEventHandler["onToDeviceEvent"](event5);
+
+        expect(callEventHandler.callEventBuffer.length).toBe(5);
+        expect(callEventHandler.nextSeqByCall.get("123")).toBe(5);
+        expect(callEventHandler.toDeviceEventBuffers.get("123").length).toBe(0);
+    });
+});

src/@types/event.ts

@@ -87,6 +87,10 @@ export enum EventType {
     RoomKeyRequest = "m.room_key_request",
     ForwardedRoomKey = "m.forwarded_room_key",
     Dummy = "m.dummy",
+
+    // Group call events
+    GroupCallPrefix = "org.matrix.msc3401.call",
+    GroupCallMemberPrefix = "org.matrix.msc3401.call.member",
 }
 
 export enum RelationType {

src/client.ts

@@ -144,7 +144,14 @@ import { IHierarchyRoom, ISpaceSummaryEvent, ISpaceSummaryRoom } from "./@types/
 import { IPusher, IPusherRequest, IPushRules, PushRuleAction, PushRuleKind, RuleId } from "./@types/PushRules";
 import { IThreepid } from "./@types/threepids";
 import { CryptoStore } from "./crypto/store/base";
+import {
+    GroupCall,
+    IGroupCallDataChannelOptions,
+    GroupCallIntent,
+    GroupCallType,
+} from "./webrtc/groupCall";
 import { MediaHandler } from "./webrtc/mediaHandler";
+import { GroupCallEventHandler } from "./webrtc/groupCallEventHandler";
 
 export type Store = IStore;
 export type SessionStore = WebStorageSessionStore;
@@ -705,6 +712,7 @@ export class MatrixClient extends EventEmitter {
     public crypto: Crypto; // XXX: Intended private, used in code.
     public cryptoCallbacks: ICryptoCallbacks; // XXX: Intended private, used in code.
     public callEventHandler: CallEventHandler; // XXX: Intended private, used in code.
+    public groupCallEventHandler: GroupCallEventHandler;
     public supportsCallTransfer = false; // XXX: Intended private, used in code.
     public forceTURN = false; // XXX: Intended private, used in code.
     public iceCandidatePoolSize = 0; // XXX: Intended private, used in code.
@@ -749,7 +757,8 @@ export class MatrixClient extends EventEmitter {
     protected checkTurnServersIntervalID: number;
     protected exportedOlmDeviceToImport: IOlmDevice;
     protected txnCtr = 0;
-    protected mediaHandler = new MediaHandler();
+    protected mediaHandler = new MediaHandler(this);
+    protected sessionId: string;
 
     constructor(opts: IMatrixClientCreateOpts) {
         super();
@@ -763,6 +772,7 @@ export class MatrixClient extends EventEmitter {
         this.usingExternalCrypto = opts.usingExternalCrypto;
         this.store = opts.store || new StubStore();
         this.deviceId = opts.deviceId || null;
+        this.sessionId = randomString(10);
 
         const userId = opts.userId || null;
         this.credentials = { userId };
@@ -824,6 +834,7 @@ export class MatrixClient extends EventEmitter {
         const call = createNewMatrixCall(this, undefined, undefined);
         if (call) {
             this.callEventHandler = new CallEventHandler(this);
+            this.groupCallEventHandler = new GroupCallEventHandler(this);
             this.canSupportVoip = true;
             // Start listening for calls after the initial sync is done
             // We do not need to backfill the call event buffer
@@ -1014,7 +1025,7 @@ export class MatrixClient extends EventEmitter {
         this.peekSync?.stopPeeking();
 
         this.callEventHandler?.stop();
-        this.callEventHandler = null;
+        this.groupCallEventHandler?.stop();
 
         global.clearInterval(this.checkTurnServersIntervalID);
         if (this.clientWellKnownIntervalID !== undefined) {
@@ -1249,6 +1260,14 @@ export class MatrixClient extends EventEmitter {
         return this.deviceId;
     }
 
+    /**
+     * Get the session ID of this client
+     * @return {string} session ID
+     */
+    public getSessionId(): string {
+        return this.sessionId;
+    }
+
     /**
      * Check if the runtime environment supports VoIP calling.
      * @return {boolean} True if VoIP is supported.
@@ -1293,6 +1312,52 @@ export class MatrixClient extends EventEmitter {
         return createNewMatrixCall(this, roomId);
     }
 
+    /**
+     * Creates a new group call and sends the associated state event
+     * to alert other members that the room now has a group call.
+     *
+     * @param {string} roomId The room the call is to be placed in.
+     * @return {GroupCall}
+     */
+    public async createGroupCall(
+        roomId: string,
+        type: GroupCallType,
+        isPtt: boolean,
+        intent: GroupCallIntent,
+        dataChannelsEnabled?: boolean,
+        dataChannelOptions?: IGroupCallDataChannelOptions,
+    ): Promise<GroupCall> {
+        if (this.getGroupCallForRoom(roomId)) {
+            throw new Error(`${roomId} already has an existing group call`);
+        }
+
+        const room = this.getRoom(roomId);
+
+        if (!room) {
+            throw new Error(`Cannot find room ${roomId}`);
+        }
+
+        return new GroupCall(
+            this,
+            room,
+            type,
+            isPtt,
+            intent,
+            undefined,
+            dataChannelsEnabled,
+            dataChannelOptions,
+        ).create();
+    }
+
+    /**
+     * Get an existing group call for the provided room.
+     * @param roomId
+     * @returns {GroupCall} The group call or null if it doesn't already exist.
+     */
+    public getGroupCallForRoom(roomId: string): GroupCall | null {
+        return this.groupCallEventHandler.groupCalls.get(roomId) || null;
+    }
+
     /**
      * Get the current sync state.
      * @return {?SyncState} the sync state, which may be null.
@@ -5608,6 +5673,7 @@ export class MatrixClient extends EventEmitter {
     private startCallEventHandler = (): void => {
         if (this.isInitialSyncComplete()) {
             this.callEventHandler.start();
+            this.groupCallEventHandler.start();
             this.off("sync", this.startCallEventHandler);
         }
     };