@signalapp/ringrtc 2.23.0 → 2.24.0

package/dist/ringrtc/Service.d.ts

@@ -2,6 +2,7 @@
 import { GumVideoCaptureOptions, VideoPixelFormatEnum } from './VideoSupport';
 declare class Config {
     use_new_audio_device_module: boolean;
+    field_trials: Record<string, string> | undefined;
 }
 declare type GroupId = Buffer;
 declare type GroupCallUserId = Buffer;
@@ -50,7 +51,8 @@ export declare class RingRTCType {
     private _callInfoByCallId;
     private getCallInfoKey;
     handleOutgoingSignaling: ((remoteUserId: UserId, message: CallingMessage) => Promise<boolean>) | null;
-    handleIncomingCall: ((call: Call) => Promise<CallSettings | null>) | null;
+    handleIncomingCall: ((call: Call) => Promise<boolean>) | null;
+    handleStartCall: ((call: Call) => Promise<boolean>) | null;
     handleAutoEndedIncomingCallRequest: ((callId: CallId, remoteUserId: UserId, reason: CallEndedReason, ageSec: number, wasVideoCall: boolean, receivedAtCounter: number | undefined) => void) | null;
     handleLogMessage: ((level: CallLogLevel, fileName: string, line: number, message: string) => void) | null;
     handleSendHttpRequest: ((requestId: number, url: string, method: HttpMethod, headers: {
@@ -62,11 +64,11 @@ export declare class RingRTCType {
     constructor();
     setConfig(config: Config): void;
     setSelfUuid(uuid: Buffer): void;
-    startOutgoingCall(remoteUserId: UserId, isVideoCall: boolean, localDeviceId: DeviceId, settings: CallSettings): Call;
+    startOutgoingCall(remoteUserId: UserId, isVideoCall: boolean, localDeviceId: DeviceId): Call;
     cancelGroupRing(groupId: GroupId, ringId: bigint, reason: RingCancelReason | null): void;
     onStartOutgoingCall(remoteUserId: UserId, callId: CallId): void;
     onStartIncomingCall(remoteUserId: UserId, callId: CallId, isVideoCall: boolean): void;
-    private proceed;
+    proceed(callId: CallId, settings: CallSettings): void;
     onCallState(remoteUserId: UserId, state: CallState): void;
     onCallEnded(remoteUserId: UserId, callId: CallId, reason: CallEndedReason, ageSec: number): void;
     onRemoteVideoEnabled(remoteUserId: UserId, enabled: boolean): void;
@@ -153,7 +155,6 @@ export declare class Call {
     callId: CallId;
     private readonly _isIncoming;
     private readonly _isVideoCall;
-    settings: CallSettings | null;
     private _state;
     private _outgoingAudioEnabled;
     private _outgoingVideoEnabled;
@@ -172,7 +173,7 @@ export declare class Call {
     handleNetworkRouteChanged?: () => void;
     handleAudioLevels?: () => void;
     renderVideoFrame?: (width: number, height: number, buffer: Buffer) => void;
-    constructor(callManager: CallManager, remoteUserId: UserId, callId: CallId, isIncoming: boolean, isVideoCall: boolean, settings: CallSettings | null, state: CallState);
+    constructor(callManager: CallManager, remoteUserId: UserId, callId: CallId, isIncoming: boolean, isVideoCall: boolean, state: CallState);
     get remoteUserId(): UserId;
     get isIncoming(): boolean;
     get isVideoCall(): boolean;

package/dist/ringrtc/Service.js

@@ -3,6 +3,25 @@
 // Copyright 2019-2021 Signal Messenger, LLC
 // SPDX-License-Identifier: AGPL-3.0-only
 //
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -15,8 +34,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CallLogLevel = exports.CallEndedReason = exports.CallState = exports.RingCancelReason = exports.BandwidthMode = exports.HangupType = exports.OpaqueMessage = exports.HangupMessage = exports.BusyMessage = exports.IceCandidateMessage = exports.AnswerMessage = exports.OfferType = exports.OfferMessage = exports.CallingMessage = exports.GroupCall = exports.VideoRequest = exports.GroupMemberInfo = exports.RemoteDeviceState = exports.LocalDeviceState = exports.HttpMethod = exports.RingUpdate = exports.CallMessageUrgency = exports.GroupCallEndReason = exports.JoinState = exports.ConnectionState = exports.Call = exports.RingRTCType = exports.ReceivedAudioLevel = exports.NetworkRoute = exports.PeekInfo = exports.PeekDeviceInfo = void 0;
 /* tslint:disable max-classes-per-file */
-const os = require("os");
-const process = require("process");
+const os = __importStar(require("os"));
+const process = __importStar(require("process"));
 // tslint:disable-next-line no-var-requires no-require-imports
 const Native = require('../../build/' +
     os.platform() +
@@ -38,7 +57,10 @@ class NativeCallManager {
         this.createCallEndpoint(config);
     }
     createCallEndpoint(config) {
-        const callEndpoint = Native.createCallEndpoint(this, config.use_new_audio_device_module);
+        const fieldTrialsString = Object.entries(config.field_trials || {})
+            .map(([k, v]) => `${k}/${v}`)
+            .join('/') + '/';
+        const callEndpoint = Native.createCallEndpoint(this, config.use_new_audio_device_module, fieldTrialsString);
         Object.defineProperty(this, Native.callEndpointPropertyKey, {
             value: callEndpoint,
             configurable: true, // allows it to be changed
@@ -207,6 +229,7 @@ class RingRTCType {
         // Set by UX
         this.handleOutgoingSignaling = null;
         this.handleIncomingCall = null;
+        this.handleStartCall = null;
         this.handleAutoEndedIncomingCallRequest = null;
         this.handleLogMessage = null;
         this.handleSendHttpRequest = null;
@@ -231,10 +254,10 @@ class RingRTCType {
         this.callManager.setSelfUuid(uuid);
     }
     // Called by UX
-    startOutgoingCall(remoteUserId, isVideoCall, localDeviceId, settings) {
+    startOutgoingCall(remoteUserId, isVideoCall, localDeviceId) {
         const callId = this.callManager.createOutgoingCall(remoteUserId, isVideoCall, localDeviceId);
         const isIncoming = false;
-        const call = new Call(this.callManager, remoteUserId, callId, isIncoming, isVideoCall, settings, CallState.Prering);
+        const call = new Call(this.callManager, remoteUserId, callId, isIncoming, isVideoCall, CallState.Prering);
         this._call = call;
         // We won't actually send anything until the remote side accepts.
         call.outgoingAudioEnabled = true;
@@ -250,11 +273,26 @@ class RingRTCType {
     // Called by Rust
     onStartOutgoingCall(remoteUserId, callId) {
         const call = this._call;
-        if (!call || call.remoteUserId !== remoteUserId || !call.settings) {
+        if (!call || call.remoteUserId !== remoteUserId) {
             return;
         }
         call.callId = callId;
-        this.proceed(callId, call.settings);
+        const handleStartCall = this.handleStartCall;
+        if (!handleStartCall) {
+            call.ignore();
+            return;
+        }
+        handleStartCall(call)
+            .then(result => {
+            if (!result) {
+                this.logWarn('RingRTC.handleStartCall failed for outgoing call. Call ignored.');
+                call.ignore();
+            }
+        })
+            .catch(e => {
+            this.logError('RingRTC.handleStartCall exception: ' + e.toString());
+            call.ignore();
+        });
     }
     // Called by Rust
     onStartIncomingCall(remoteUserId, callId, isVideoCall) {
@@ -277,24 +315,38 @@ class RingRTCType {
             return;
         }
         const isIncoming = true;
-        const call = new Call(this.callManager, remoteUserId, callId, isIncoming, isVideoCall, null, CallState.Prering);
-        // Callback to UX not set
+        const call = new Call(this.callManager, remoteUserId, callId, isIncoming, isVideoCall, CallState.Prering);
         const handleIncomingCall = this.handleIncomingCall;
-        if (!handleIncomingCall) {
+        const handleStartCall = this.handleStartCall;
+        if (!handleIncomingCall || !handleStartCall) {
             call.ignore();
             return;
         }
         this._call = call;
-        // tslint:disable no-floating-promises
-        (() => __awaiter(this, void 0, void 0, function* () {
-            const settings = yield handleIncomingCall(call);
-            if (!settings) {
+        handleIncomingCall(call)
+            .then(success => {
+            if (!success) {
+                this.logWarn('RingRTC.handleIncomingCall failed for incoming call. Call ignored.');
                 call.ignore();
-                return;
             }
-            call.settings = settings;
-            this.proceed(callId, settings);
-        }))();
+            else {
+                handleStartCall(call)
+                    .then(success => {
+                    if (!success) {
+                        this.logWarn('RingRTC.handleStartCall failed for incoming call. Call ignored.');
+                        call.ignore();
+                    }
+                })
+                    .catch(e => {
+                    this.logError('RingRTC.handleStartCall exception: ' + e.toString());
+                    call.ignore();
+                });
+            }
+        })
+            .catch(e => {
+            this.logError('RingRTC.handleIncomingCall exception: ' + e.toString());
+            call.ignore();
+        });
     }
     proceed(callId, settings) {
         silly_deadlock_protection(() => {
@@ -861,7 +913,7 @@ class RingRTCType {
 }
 exports.RingRTCType = RingRTCType;
 class Call {
-    constructor(callManager, remoteUserId, callId, isIncoming, isVideoCall, settings, state) {
+    constructor(callManager, remoteUserId, callId, isIncoming, isVideoCall, state) {
         this._outgoingAudioEnabled = false;
         this._outgoingVideoEnabled = false;
         this._outgoingVideoIsScreenShare = false;
@@ -877,7 +929,6 @@ class Call {
         this.callId = callId;
         this._isIncoming = isIncoming;
         this._isVideoCall = isVideoCall;
-        this.settings = settings;
         this._state = state;
     }
     get remoteUserId() {

package/dist/ringrtc/VideoSupport.js

@@ -144,6 +144,7 @@ class GumVideoCapturer {
                     chromeMediaSourceId: options.screenShareSourceId,
                     maxWidth: options.maxWidth,
                     maxHeight: options.maxHeight,
+                    minFrameRate: 1,
                     maxFrameRate: options.maxFramerate,
                 },
             };
@@ -230,7 +231,7 @@ class GumVideoCapturer {
         if (track == undefined || this.spawnedSenderRunning) {
             return;
         }
-        if (track.readyState === "ended") {
+        if (track.readyState === 'ended') {
             this.stopCapturing();
             index_1.RingRTC.logError(`spawnSender(): Video track ended before spawning sender`);
             return;

package/dist/test/CallingClass.d.ts

@@ -0,0 +1,25 @@
+export declare class CallingClass {
+    private _name;
+    private _id;
+    private _localDeviceId;
+    private _call;
+    private _delayIncomingCallSettingsRequest;
+    private _delayOutgoingCallSettingsRequest;
+    set delayIncomingCallSettingsRequest(value: number);
+    set delayOutgoingCallSettingsRequest(value: number);
+    constructor(name: string, id: string);
+    private setupCallCallbacks;
+    private handleOutgoingSignaling;
+    private handleIncomingCall;
+    private handleStartCall;
+    private handleAutoEndedIncomingCallRequest;
+    private handleLogMessage;
+    private handleSendHttpRequest;
+    private handleSendCallMessage;
+    private handleSendCallMessageToGroup;
+    private handleGroupCallRingUpdate;
+    private getCallSettings;
+    initialize(): void;
+    startOutgoingDirectCall(remoteUserId: string): Promise<void>;
+    hangup(): boolean;
+}

package/dist/test/CallingClass.js

@@ -0,0 +1,197 @@
+"use strict";
+//
+// Copyright 2023 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallingClass = void 0;
+const Service_1 = require("../ringrtc/Service");
+const index_1 = require("../index");
+const long_1 = __importDefault(require("long"));
+const Utils_1 = require("./Utils");
+// This class mimics the Desktop Client CallingClass in ts/services/calling.ts to facilitate testing
+class CallingClass {
+    constructor(name, id) {
+        this._name = name;
+        this._id = id;
+        this._localDeviceId = 1;
+        this._delayIncomingCallSettingsRequest = 0;
+        this._delayOutgoingCallSettingsRequest = 0;
+    }
+    set delayIncomingCallSettingsRequest(value) {
+        this._delayIncomingCallSettingsRequest = value;
+    }
+    set delayOutgoingCallSettingsRequest(value) {
+        this._delayIncomingCallSettingsRequest = value;
+    }
+    setupCallCallbacks(call) {
+        // eslint-disable-next-line no-param-reassign
+        call.handleStateChanged = () => __awaiter(this, void 0, void 0, function* () {
+            (0, Utils_1.log)('handleCallStateChanged');
+            (0, Utils_1.log)(`call.state === ${call.state}`);
+            if (call.state === Service_1.CallState.Ended) {
+                (0, Utils_1.log)(`call.endedReason === ${call.endedReason}`);
+                this._call = undefined;
+            }
+        });
+        // eslint-disable-next-line no-param-reassign
+        call.handleRemoteVideoEnabled = () => {
+            (0, Utils_1.log)('handleRemoteVideoEnabled');
+        };
+        // eslint-disable-next-line no-param-reassign
+        call.handleRemoteSharingScreen = () => {
+            (0, Utils_1.log)('handleRemoteSharingScreen');
+        };
+    }
+    ////////////////////////////////////////////////////////////////////////////////
+    // Callbacks
+    handleOutgoingSignaling(remoteUserId, message, urgency) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, Utils_1.log)('handleOutgoingSignaling remoteUserId: ' + remoteUserId);
+            return true;
+        });
+    }
+    handleIncomingCall(call) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, Utils_1.log)('handleIncomingCall');
+            this._call = call;
+            this.setupCallCallbacks(call);
+            return true;
+        });
+    }
+    handleStartCall(call) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const callSettings = yield this.getCallSettings(call.isIncoming);
+            index_1.RingRTC.proceed(call.callId, callSettings);
+            return true;
+        });
+    }
+    handleAutoEndedIncomingCallRequest(callId, remoteUserId, reason, ageInSeconds, wasVideoCall, receivedAtCounter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, Utils_1.log)('handleAutoEndedIncomingCallRequest');
+        });
+    }
+    handleLogMessage(level, fileName, line, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (level) {
+                case Service_1.CallLogLevel.Info:
+                    // FgGray
+                    console.log(`\x1b[90m${fileName}:${line} ${message}\x1b[0m`);
+                    break;
+                case Service_1.CallLogLevel.Warn:
+                    // FgYellow
+                    console.warn(`\x1b[33m${fileName}:${line} ${message}\x1b[0m`);
+                    break;
+                case Service_1.CallLogLevel.Error:
+                    // FgRed
+                    console.error(`\x1b[31m${fileName}:${line} ${message}\x1b[0m`);
+                    break;
+                default:
+                    break;
+            }
+        });
+    }
+    handleSendHttpRequest(requestId, url, method, headers, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, Utils_1.log)('handleSendHttpRequest');
+        });
+    }
+    handleSendCallMessage(recipient, data, urgency) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, Utils_1.log)('handleSendCallMessage');
+            return true;
+        });
+    }
+    handleSendCallMessageToGroup(groupIdBytes, data, urgency) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, Utils_1.log)('handleSendCallMessageToGroup');
+        });
+    }
+    handleGroupCallRingUpdate(groupIdBytes, ringId, ringerBytes, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, Utils_1.log)('handleGroupCallRingUpdate');
+        });
+    }
+    ////////////////////////////////////////////////////////////////////////////////
+    // Support
+    getCallSettings(isIncoming) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isIncoming) {
+                (0, Utils_1.log)('getCallSettings delayed by ' +
+                    this._delayIncomingCallSettingsRequest.toString() +
+                    'ms');
+                yield (0, Utils_1.sleep)(this._delayIncomingCallSettingsRequest);
+            }
+            else {
+                (0, Utils_1.log)('getCallSettings delayed by ' +
+                    this._delayOutgoingCallSettingsRequest.toString() +
+                    'ms');
+                yield (0, Utils_1.sleep)(this._delayOutgoingCallSettingsRequest);
+            }
+            return {
+                iceServer: {
+                    urls: ['stun:turn3.voip.signal.org'],
+                },
+                hideIp: false,
+                bandwidthMode: Service_1.BandwidthMode.Normal,
+            };
+        });
+    }
+    ////////////////////////////////////////////////////////////////////////////////
+    // Actions
+    initialize() {
+        (0, Utils_1.log)('initialize');
+        index_1.RingRTC.setConfig({
+            use_new_audio_device_module: true,
+            field_trials: undefined,
+        });
+        index_1.RingRTC.handleOutgoingSignaling = this.handleOutgoingSignaling.bind(this);
+        index_1.RingRTC.handleIncomingCall = this.handleIncomingCall.bind(this);
+        index_1.RingRTC.handleStartCall = this.handleStartCall.bind(this);
+        index_1.RingRTC.handleAutoEndedIncomingCallRequest =
+            this.handleAutoEndedIncomingCallRequest.bind(this);
+        index_1.RingRTC.handleLogMessage = this.handleLogMessage.bind(this);
+        index_1.RingRTC.handleSendHttpRequest = this.handleSendHttpRequest.bind(this);
+        index_1.RingRTC.handleSendCallMessage = this.handleSendCallMessage.bind(this);
+        index_1.RingRTC.handleSendCallMessageToGroup =
+            this.handleSendCallMessageToGroup.bind(this);
+        index_1.RingRTC.handleGroupCallRingUpdate =
+            this.handleGroupCallRingUpdate.bind(this);
+        index_1.RingRTC.setSelfUuid(Buffer.from((0, Utils_1.uuidToBytes)(this._id)));
+    }
+    startOutgoingDirectCall(remoteUserId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, Utils_1.log)('startOutgoingDirectCall');
+            if (index_1.RingRTC.call && index_1.RingRTC.call.state !== Service_1.CallState.Ended) {
+                (0, Utils_1.log)('Call already in progress, new call not allowed.');
+                return;
+            }
+            const call = index_1.RingRTC.startOutgoingCall(remoteUserId, false, this._localDeviceId);
+            (0, Utils_1.log)('Outgoing callId ' + long_1.default.fromValue(call.callId).toString());
+            index_1.RingRTC.setOutgoingAudio(call.callId, true);
+            this._call = call;
+            this.setupCallCallbacks(call);
+        });
+    }
+    hangup() {
+        (0, Utils_1.log)('hangup');
+        if (this._call) {
+            index_1.RingRTC.hangup(this._call.callId);
+            return true;
+        }
+        return false;
+    }
+}
+exports.CallingClass = CallingClass;

package/dist/test/RingRTC-test.js

@@ -12,15 +12,46 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const chai_1 = require("chai");
-const chaiAsPromised = require("chai-as-promised");
+const chai_as_promised_1 = __importDefault(require("chai-as-promised"));
+const crypto_1 = require("crypto");
 const index_1 = require("../index");
-(0, chai_1.use)(chaiAsPromised);
+const long_1 = __importDefault(require("long"));
+const chai_2 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const sinon_chai_1 = __importDefault(require("sinon-chai"));
+const CallingClass_1 = require("./CallingClass");
+const Utils_1 = require("./Utils");
+(0, chai_1.use)(chai_as_promised_1.default);
+(0, chai_2.should)();
+(0, chai_1.use)(sinon_chai_1.default);
+function generateOfferCallingMessage(callId) {
+    // Audio-only hex based SDP generated from a direct client call
+    const audioOnlySdp = Buffer.from('22560a204b18bc751315cb718c643db7b3a65aaabe826c7094932afaf5aebc86d36bb6491204484b6b481a18524b3041496f63334245514e5670424b57786f38787051712204082e1034220408281034220208082880897a', 'hex');
+    return {
+        offer: {
+            callId: callId,
+            opaque: audioOnlySdp,
+            type: index_1.OfferType.AudioCall,
+        },
+    };
+}
 describe('RingRTC', () => {
-    it('testsInitialization', () => {
-        chai_1.assert.isNotNull(index_1.RingRTC, "RingRTC didn't initialize!");
-    });
+    const identity_key_length = 31;
+    const user1_name = 'user1';
+    const user1_id = '11';
+    const user1_device_id = 11;
+    const user1_identity_key = (0, crypto_1.randomBytes)(identity_key_length);
+    const user2_id = '22';
+    const user2_device_id = 22;
+    const user2_identity_key = (0, crypto_1.randomBytes)(identity_key_length);
+    let handleOutgoingSignalingSpy;
+    let handleIncomingCallSpy;
+    let handleAutoEndedIncomingCallRequestSpy;
     it('reports an age for expired offers', () => __awaiter(void 0, void 0, void 0, function* () {
         const offer = {
             offer: {
@@ -68,4 +99,113 @@ describe('RingRTC', () => {
             index_1.RingRTC.handleAutoEndedIncomingCallRequest = null;
         }
     }));
+    function initializeSpies() {
+        handleAutoEndedIncomingCallRequestSpy = sinon_1.default.spy(index_1.RingRTC, 'handleAutoEndedIncomingCallRequest');
+        handleIncomingCallSpy = sinon_1.default.spy(index_1.RingRTC, 'handleIncomingCall');
+        handleOutgoingSignalingSpy = sinon_1.default.spy(index_1.RingRTC, 'handleOutgoingSignaling');
+    }
+    it('can initialize RingRTC', () => {
+        chai_1.assert.isNotNull(index_1.RingRTC, "RingRTC didn't initialize!");
+    });
+    it('can establish outgoing call', () => __awaiter(void 0, void 0, void 0, function* () {
+        let calling = new CallingClass_1.CallingClass(user1_name, user1_id);
+        calling.initialize();
+        initializeSpies();
+        yield calling.startOutgoingDirectCall(user2_id);
+        yield (0, Utils_1.sleep)(1000);
+        // An offer and at least one ICE message should have been sent.
+        (0, chai_1.expect)(handleOutgoingSignalingSpy.callCount).to.be.gt(1);
+        yield (0, Utils_1.sleep)(2000);
+        // Cleanup.
+        const handleStateChangedSpy = sinon_1.default.spy(index_1.RingRTC.call, 'handleStateChanged');
+        (0, chai_1.expect)(calling.hangup()).to.be.true;
+        yield (0, Utils_1.sleep)(500);
+        handleStateChangedSpy.should.have.been.calledOnce;
+        (0, chai_1.expect)(calling.hangup()).to.be.false;
+        yield (0, Utils_1.sleep)(100);
+    }));
+    it('can establish incoming call', () => __awaiter(void 0, void 0, void 0, function* () {
+        let calling = new CallingClass_1.CallingClass(user1_name, user1_id);
+        calling.initialize();
+        initializeSpies();
+        // Generate incoming calling message
+        const message_age_sec = 1;
+        const message_received_at_counter = 10;
+        const callId = new long_1.default(1, 1, true);
+        const offerCallingMessage = generateOfferCallingMessage(callId);
+        index_1.RingRTC.handleCallingMessage(user2_id, Buffer.from((0, Utils_1.uuidToBytes)(user2_id)), user2_device_id, user1_device_id, message_age_sec, message_received_at_counter, offerCallingMessage, user2_identity_key, user1_identity_key);
+        yield (0, Utils_1.sleep)(1000);
+        handleIncomingCallSpy.should.have.been.calledOnce;
+        chai_1.assert.equal(index_1.CallState.Prering, index_1.RingRTC.call.state);
+        // Hangup call
+        (0, chai_1.expect)(calling.hangup()).to.be.true;
+        yield (0, Utils_1.sleep)(500);
+        // Validate hangup related callbacks and call state
+        handleAutoEndedIncomingCallRequestSpy.should.have.been.calledOnce;
+        (0, chai_1.expect)(handleOutgoingSignalingSpy.callCount).to.be.gt(1);
+        chai_1.assert.equal(index_1.CallState.Ended, index_1.RingRTC.call.state);
+    }));
+    it('outgoing call wins glare when incoming call id is lower', () => __awaiter(void 0, void 0, void 0, function* () {
+        let calling = new CallingClass_1.CallingClass(user1_name, user1_id);
+        calling.initialize();
+        initializeSpies();
+        yield runGlareScenario(calling, true, 0, 0);
+    }));
+    it('outgoing call wins glare when incoming call id is lower even when outgoing call settings are delayed', () => __awaiter(void 0, void 0, void 0, function* () {
+        let calling = new CallingClass_1.CallingClass(user1_name, user1_id);
+        calling.initialize();
+        initializeSpies();
+        yield runGlareScenario(calling, true, 0, 1000);
+    }));
+    it('outgoing call loses glare when incoming call id is higher even when outgoing call settings are delayed', () => __awaiter(void 0, void 0, void 0, function* () {
+        let calling = new CallingClass_1.CallingClass(user1_name, user1_id);
+        calling.initialize();
+        initializeSpies();
+        yield runGlareScenario(calling, false, 0, 1000);
+    }));
+    it('outgoing call loses glare when incoming call id is higher', () => __awaiter(void 0, void 0, void 0, function* () {
+        let calling = new CallingClass_1.CallingClass(user1_name, user1_id);
+        calling.initialize();
+        initializeSpies();
+        yield runGlareScenario(calling, false, 0, 0);
+    }));
+    function runGlareScenario(calling, outgoingWinner, delayIncomingCallSetings, delayOutgoingCallSetings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            calling.delayOutgoingCallSettingsRequest = delayOutgoingCallSetings;
+            calling.delayIncomingCallSettingsRequest = delayIncomingCallSetings;
+            const outgoingCallLatch = (0, Utils_1.countDownLatch)(1);
+            calling
+                .startOutgoingDirectCall(user2_id)
+                .then(result => {
+                (0, Utils_1.log)('Outgoing call succeeded as expected');
+                outgoingCallLatch.countDown();
+            })
+                .catch(e => {
+                chai_1.assert.fail('Outgoing call should not have failed');
+            });
+            yield outgoingCallLatch.finished;
+            const outgoingCallId = long_1.default.fromValue(index_1.RingRTC.call.callId);
+            // Generate a call id based on the desired glare winner
+            const incomingCallId = outgoingCallId.unsigned
+                ? new long_1.default(outgoingWinner ? outgoingCallId.low - 1 : outgoingCallId.low + 1, outgoingCallId.high, outgoingCallId.unsigned)
+                : new long_1.default(outgoingWinner ? outgoingCallId.low + 1 : outgoingCallId.low - 1, outgoingCallId.high, outgoingCallId.unsigned);
+            // Generate incoming calling message
+            const message_age_sec = 1;
+            const message_received_at_counter = 10;
+            const offerCallingMessage = generateOfferCallingMessage(incomingCallId);
+            // Initiate an incoming call
+            index_1.RingRTC.handleCallingMessage(user2_id, Buffer.from((0, Utils_1.uuidToBytes)(user2_id)), user2_device_id, user1_device_id, message_age_sec, message_received_at_counter, offerCallingMessage, user2_identity_key, user1_identity_key);
+            yield (0, Utils_1.sleep)(1000);
+            if (outgoingWinner) {
+                chai_1.assert.isTrue(outgoingCallId.eq(long_1.default.fromValue(index_1.RingRTC.call.callId)));
+            }
+            else {
+                chai_1.assert.isTrue(incomingCallId.eq(long_1.default.fromValue(index_1.RingRTC.call.callId)));
+            }
+            // Cleanup.
+            (0, chai_1.expect)(calling.hangup()).to.be.true;
+            yield (0, Utils_1.sleep)(500);
+            chai_1.assert.equal(index_1.CallState.Ended, index_1.RingRTC.call.state);
+        });
+    }
 });

package/dist/test/Utils.d.ts

@@ -0,0 +1,7 @@
+export declare function countDownLatch(count: number): {
+    countDown: () => void;
+    finished: Promise<unknown>;
+};
+export declare function log(line: string): void;
+export declare let sleep: (timeout: number) => Promise<void>;
+export declare function uuidToBytes(uuid: string): Uint8Array;

package/dist/test/Utils.js

@@ -0,0 +1,51 @@
+"use strict";
+//
+// Copyright 2023 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuidToBytes = exports.sleep = exports.log = exports.countDownLatch = void 0;
+const lodash_1 = require("lodash");
+const chai_1 = require("chai");
+function countDownLatch(count) {
+    (0, chai_1.assert)(count > 0, 'count must be a positive number');
+    let resolve;
+    const finished = new Promise(resolveInternal => {
+        resolve = resolveInternal;
+    });
+    const countDown = () => {
+        count--;
+        if (count == 0) {
+            resolve();
+        }
+    };
+    return {
+        countDown: countDown,
+        finished,
+    };
+}
+exports.countDownLatch = countDownLatch;
+function log(line) {
+    // Standard logging used for checkpoints.
+    // Use --renderer to see the log output. (edit: Maybe always shown now?)
+    // BgYellow
+    console.log(`\x1b[43m${line}\x1b[0m`);
+}
+exports.log = log;
+let sleep = (timeout) => {
+    return new Promise(resolve => {
+        setTimeout(() => {
+            // BgBlue
+            console.log(`\x1b[44msleeping ${timeout} ms\x1b[0m`);
+            resolve();
+        }, timeout);
+    });
+};
+exports.sleep = sleep;
+function uuidToBytes(uuid) {
+    if (uuid.length !== 36) {
+        return new Uint8Array(0);
+    }
+    return Uint8Array.from((0, lodash_1.chunk)(uuid.replace(/-/g, ''), 2).map(pair => parseInt(pair.join(''), 16)));
+}
+exports.uuidToBytes = uuidToBytes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalapp/ringrtc",
-  "version": "2.23.0",
+  "version": "2.24.0",
   "description": "Signal Messenger voice and video calling library.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,7 +11,7 @@
   "scripts": {
     "build": "tsc",
     "clean": "rimraf dist",
-    "test": "electron-mocha --recursive dist/test",
+    "test": "electron-mocha --recursive dist/test --timeout 10000",
     "eslint": "eslint --cache .",
     "lint": "yarn format --list-different && yarn eslint",
     "format": "prettier --write \"*.{css,js,json,md,scss,ts,tsx}\" \"./**/*.{css,js,json,md,scss,ts,tsx}\"",
@@ -20,7 +20,7 @@
   },
   "config": {
     "prebuildUrl": "https://build-artifacts.signal.org/libraries/ringrtc-desktop-build-v${npm_package_version}.tar.gz",
-    "prebuildChecksum": "92f2a82a2acc5b853855a17b57f31354166783ec938f2452563f07e32e263c78"
+    "prebuildChecksum": "7f7f7a795d4387d59e5262c6a3b8efb910f2d3f9c60a18316e49bb9a29d65343"
   },
   "author": "",
   "license": "AGPL-3.0-only",
@@ -31,10 +31,12 @@
     "@types/chai": "4.2.18",
     "@types/chai-as-promised": "^7.1.3",
     "@types/dom-mediacapture-transform": "0.1.2",
+    "@types/long": "4.0.1",
     "@types/mocha": "5.2.7",
     "@types/node": "14.14.37",
     "@types/offscreencanvas": "^2019.6.4",
     "@types/react": "16.8.5",
+    "@types/sinon-chai": "^3.2.9",
     "chai": "4.3.5",
     "chai-as-promised": "^7.1.1",
     "electron": "15.3.2",
@@ -46,9 +48,12 @@
     "eslint-plugin-mocha": "9.0.0",
     "eslint-plugin-more": "1.0.5",
     "eslint-plugin-react": "7.28.0",
+    "long": "4.0.0",
     "mocha": "9.2.0",
     "prettier": "^2.5.1",
     "rimraf": "3.0.2",
+    "sinon": "^15.0.1",
+    "sinon-chai": "^3.7.0",
     "typescript": "4.5.2",
     "yarn-audit-fix": "^9.2.2"
   }