@signalapp/ringrtc 2.41.0 → 2.43.0

package/dist/acknowledgments.md

@@ -669,7 +669,7 @@ For more information on this, and how to apply and follow the GNU AGPL, see
 
 ```
 
-## libsignal-core 0.1.0, partial-default-derive 0.1.0, regex-aot 0.1.0, ringrtc 2.41.0
+## libsignal-core 0.1.0, mrp 2.43.0, partial-default-derive 0.1.0, regex-aot 0.1.0, ringrtc 2.43.0
 
 ```
 GNU AFFERO GENERAL PUBLIC LICENSE

package/dist/ringrtc/Service.d.ts

@@ -96,7 +96,7 @@ export declare class RingRTCType {
     handleOutgoingSignaling: ((remoteUserId: UserId, message: CallingMessage) => Promise<boolean>) | 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;
+    handleAutoEndedIncomingCallRequest: ((callId: CallId, remoteUserId: UserId, reason: CallEndedReason, ageSec: number, wasVideoCall: boolean, receivedAtCounter: number | undefined, receivedAtDate: number | undefined) => void) | null;
     handleLogMessage: ((level: CallLogLevel, fileName: string, line: number, message: string) => void) | null;
     handleSendHttpRequest: ((requestId: number, url: string, method: HttpMethod, headers: {
         [name: string]: string;
@@ -104,6 +104,7 @@ export declare class RingRTCType {
     handleSendCallMessage: ((recipientUuid: Buffer, message: Buffer, urgency: CallMessageUrgency) => void) | null;
     handleSendCallMessageToGroup: ((groupId: Buffer, message: Buffer, urgency: CallMessageUrgency, overrideRecipients: Array<Buffer>) => void) | null;
     handleGroupCallRingUpdate: ((groupId: Buffer, ringId: bigint, sender: Buffer, update: RingUpdate) => void) | null;
+    handleRtcStatsReport: ((reportJson: string) => void) | null;
     constructor();
     setConfig(config: Config): void;
     setSelfUuid(uuid: Buffer): void;
@@ -243,11 +244,22 @@ export declare class RingRTCType {
     handleEmptyResponse(requestId: number, statusCode: number, state: EmptyObj | undefined): void;
     handleEnded(clientId: GroupCallClientId, reason: GroupCallEndReason): void;
     groupCallRingUpdate(groupId: GroupId, ringId: bigint, sender: GroupCallUserId, state: RingUpdate): void;
+    handleRtcStatsReportComplete(reportJson: string): void;
     onLogMessage(level: number, fileName: string, line: number, message: string): void;
     logError(message: string): void;
     logWarn(message: string): void;
     logInfo(message: string): void;
-    handleCallingMessage(remoteUserId: UserId, remoteUuid: Buffer | null, remoteDeviceId: DeviceId, localDeviceId: DeviceId, messageAgeSec: number, messageReceivedAtCounter: number, message: CallingMessage, senderIdentityKey: Buffer, receiverIdentityKey: Buffer): void;
+    handleCallingMessage(message: CallingMessage, options: {
+        remoteUserId: UserId;
+        remoteUuid?: Buffer;
+        remoteDeviceId: DeviceId;
+        localDeviceId: DeviceId;
+        ageSec: number;
+        receivedAtCounter: number;
+        receivedAtDate: number;
+        senderIdentityKey: Buffer;
+        receiverIdentityKey: Buffer;
+    }): void;
     sendHttpRequest(requestId: number, url: string, method: HttpMethod, headers: {
         [name: string]: string;
     }, body: Buffer | undefined): void;
@@ -513,6 +525,7 @@ export declare class GroupCall {
     sendVideoFrame(width: number, height: number, format: VideoPixelFormatEnum, buffer: Buffer): void;
     getVideoSource(remoteDemuxId: number): GroupCallVideoFrameSource;
     setRemoteAspectRatio(remoteDemuxId: number, aspectRatio: number): void;
+    setRtcStatsInterval(intervalMillis: number): void;
 }
 declare class GroupCallVideoFrameSource {
     private readonly _callManager;
@@ -637,6 +650,7 @@ export interface CallManager {
     setGroupMembers(clientId: GroupCallClientId, members: Array<GroupMemberInfo>): void;
     setMembershipProof(clientId: GroupCallClientId, proof: Buffer): void;
     receiveGroupCallVideoFrame(clientId: GroupCallClientId, remoteDemuxId: number, buffer: Buffer, maxWidth: number, maxHeight: number): [number, number] | undefined;
+    setRtcStatsInterval(clientId: GroupCallClientId, intervalMillis: number): void;
     readCallLink(requestId: number, sfuUrl: string, authCredentialPresentation: Buffer, linkRootKey: Buffer): void;
     createCallLink(requestId: number, sfuUrl: string, createCredentialPresentation: Buffer, linkRootKey: Buffer, adminPasskey: Buffer, callLinkPublicParams: Buffer): void;
     updateCallLink(requestId: number, sfuUrl: string, authCredentialPresentation: Buffer, linkRootKey: Buffer, adminPasskey: Buffer, newName: string | undefined, newRestrictions: number | undefined, newRevoked: boolean | undefined): void;

package/dist/ringrtc/Service.js

@@ -139,6 +139,8 @@ NativeCallManager.prototype.getAudioOutputs =
     Native_1.default.cm_getAudioOutputs;
 NativeCallManager.prototype.setAudioOutput = Native_1.default.cm_setAudioOutput;
 NativeCallManager.prototype.processEvents = Native_1.default.cm_processEvents;
+NativeCallManager.prototype.setRtcStatsInterval =
+    Native_1.default.cm_setRtcStatsInterval;
 var PeekStatusCodes;
 (function (PeekStatusCodes) {
     PeekStatusCodes[PeekStatusCodes["EXPIRED_CALL_LINK"] = 703] = "EXPIRED_CALL_LINK";
@@ -236,9 +238,10 @@ class Requests {
     }
 }
 class CallInfo {
-    constructor(isVideoCall, receivedAtCounter) {
+    constructor(isVideoCall, receivedAtCounter, receivedAtDate) {
         this.isVideoCall = isVideoCall;
         this.receivedAtCounter = receivedAtCounter;
+        this.receivedAtDate = receivedAtDate;
     }
 }
 class RingRTCType {
@@ -260,6 +263,7 @@ class RingRTCType {
         this.handleSendCallMessage = null;
         this.handleSendCallMessageToGroup = null;
         this.handleGroupCallRingUpdate = null;
+        this.handleRtcStatsReport = null;
         this.callManager = new NativeCallManager(this);
         this._call = null;
         this._groupCallByClientId = new Map();
@@ -385,9 +389,10 @@ class RingRTCType {
     // Called by Rust
     onCallEnded(remoteUserId, callId, reason, ageSec) {
         const callInfo = this._callInfoByCallId.get(this.getCallInfoKey(callId));
-        const { isVideoCall, receivedAtCounter } = callInfo || {
+        const { isVideoCall, receivedAtCounter, receivedAtDate } = callInfo || {
             isVideoCall: false,
             receivedAtCounter: undefined,
+            receivedAtDate: undefined,
         };
         this._callInfoByCallId.delete(this.getCallInfoKey(callId));
         const call = this._call;
@@ -416,7 +421,7 @@ class RingRTCType {
             reason === CallEndedReason.ReceivedOfferExpired ||
             (call.state === CallState.Prering && call.isIncoming)) {
             if (this.handleAutoEndedIncomingCallRequest) {
-                this.handleAutoEndedIncomingCallRequest(callId, remoteUserId, reason, ageSec, isVideoCall, receivedAtCounter);
+                this.handleAutoEndedIncomingCallRequest(callId, remoteUserId, reason, ageSec, isVideoCall, receivedAtCounter, receivedAtDate);
             }
             if (call && call.state === CallState.Prering && call.isIncoming) {
                 // Set the state to Ended without triggering a state update since we
@@ -933,6 +938,12 @@ class RingRTCType {
         });
     }
     // Called by Rust
+    handleRtcStatsReportComplete(reportJson) {
+        if (this.handleRtcStatsReport) {
+            this.handleRtcStatsReport(reportJson);
+        }
+    }
+    // Called by Rust
     onLogMessage(level, fileName, line, message) {
         if (this.handleLogMessage) {
             this.handleLogMessage(level, fileName, line, message);
@@ -951,9 +962,9 @@ class RingRTCType {
         this.onLogMessage(CallLogLevel.Info, 'Service.ts', 0, message);
     }
     // Called by MessageReceiver
-    handleCallingMessage(remoteUserId, remoteUuid, remoteDeviceId, localDeviceId, messageAgeSec, messageReceivedAtCounter, message, senderIdentityKey, receiverIdentityKey) {
+    handleCallingMessage(message, options) {
         if (message.destinationDeviceId &&
-            message.destinationDeviceId !== localDeviceId) {
+            message.destinationDeviceId !== options.localDeviceId) {
             // Drop the message as it isn't for this device, handleIgnoredCall() is not needed.
             return;
         }
@@ -968,9 +979,9 @@ class RingRTCType {
             }
             const offerType = message.offer.type || OfferType.AudioCall;
             // Save the call details for later when the call is ended.
-            const callInfo = new CallInfo(offerType === OfferType.VideoCall, messageReceivedAtCounter);
+            const callInfo = new CallInfo(offerType === OfferType.VideoCall, options.receivedAtCounter, options.receivedAtDate);
             this._callInfoByCallId.set(this.getCallInfoKey(callId), callInfo);
-            this.callManager.receivedOffer(remoteUserId, remoteDeviceId, localDeviceId, messageAgeSec, callId, offerType, opaque, senderIdentityKey, receiverIdentityKey);
+            this.callManager.receivedOffer(options.remoteUserId, options.remoteDeviceId, options.localDeviceId, options.ageSec, callId, offerType, opaque, options.senderIdentityKey, options.receiverIdentityKey);
         }
         if (message.answer?.callId) {
             const callId = message.answer.callId;
@@ -981,7 +992,7 @@ class RingRTCType {
                 this.logError('handleCallingMessage(): opaque not received for answer, remote should update');
                 return;
             }
-            this.callManager.receivedAnswer(remoteUserId, remoteDeviceId, callId, opaque, senderIdentityKey, receiverIdentityKey);
+            this.callManager.receivedAnswer(options.remoteUserId, options.remoteDeviceId, callId, opaque, options.senderIdentityKey, options.receiverIdentityKey);
         }
         if (message.iceCandidates && message.iceCandidates.length > 0) {
             // We assume they all have the same .callId
@@ -1007,20 +1018,20 @@ class RingRTCType {
                 this.logWarn('handleCallingMessage(): No call ID in ice message');
                 return;
             }
-            this.callManager.receivedIceCandidates(remoteUserId, remoteDeviceId, callId, candidates);
+            this.callManager.receivedIceCandidates(options.remoteUserId, options.remoteDeviceId, callId, candidates);
         }
         if (message.hangup?.callId) {
             const callId = message.hangup.callId;
             const hangupType = message.hangup.type || HangupType.Normal;
             const hangupDeviceId = message.hangup.deviceId || null;
-            this.callManager.receivedHangup(remoteUserId, remoteDeviceId, callId, hangupType, hangupDeviceId);
+            this.callManager.receivedHangup(options.remoteUserId, options.remoteDeviceId, callId, hangupType, hangupDeviceId);
         }
         if (message.busy?.callId) {
             const callId = message.busy.callId;
-            this.callManager.receivedBusy(remoteUserId, remoteDeviceId, callId);
+            this.callManager.receivedBusy(options.remoteUserId, options.remoteDeviceId, callId);
         }
         if (message.opaque) {
-            if (remoteUuid == null) {
+            if (options.remoteUuid === undefined) {
                 this.logError('handleCallingMessage(): opaque message received without UUID!');
                 return;
             }
@@ -1029,7 +1040,7 @@ class RingRTCType {
                 this.logError('handleCallingMessage(): opaque message received without data!');
                 return;
             }
-            this.callManager.receivedCallMessage(remoteUuid, remoteDeviceId, localDeviceId, data, messageAgeSec);
+            this.callManager.receivedCallMessage(options.remoteUuid, options.remoteDeviceId, options.localDeviceId, data, options.ageSec);
         }
     }
     // Called by Rust
@@ -1671,6 +1682,9 @@ class GroupCall {
             this._observer.onRemoteDeviceStatesChanged(this);
         }
     }
+    setRtcStatsInterval(intervalMillis) {
+        this._callManager.setRtcStatsInterval(this._clientId, intervalMillis);
+    }
 }
 exports.GroupCall = GroupCall;
 // Implements VideoSource for use in CanvasVideoRenderer

package/dist/ringrtc/VideoSupport.d.ts

@@ -42,8 +42,8 @@ export declare class GumVideoCapturer {
     constructor(defaultCaptureOptions: GumVideoCaptureOptions);
     capturing(): boolean;
     setLocalPreview(localPreview: Ref<HTMLVideoElement> | undefined): void;
-    enableCapture(): void;
-    enableCaptureAndSend(sender: VideoFrameSender, options?: GumVideoCaptureOptions): void;
+    enableCapture(): Promise<void>;
+    enableCaptureAndSend(sender?: VideoFrameSender, options?: GumVideoCaptureOptions): Promise<void>;
     disable(): void;
     setPreferredDevice(deviceId: string): Promise<void>;
     enumerateDevices(): Promise<Array<MediaDeviceInfo>>;

package/dist/ringrtc/VideoSupport.js

@@ -72,14 +72,16 @@ class GumVideoCapturer {
         }
         this.updateLocalPreviewIntervalId = setInterval(this.updateLocalPreviewSourceObject.bind(this), 1000);
     }
-    enableCapture() {
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.startCapturing(this.defaultCaptureOptions);
+    async enableCapture() {
+        return this.startCapturing(this.defaultCaptureOptions);
     }
-    enableCaptureAndSend(sender, options) {
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.startCapturing(options ?? this.defaultCaptureOptions);
-        this.startSending(sender);
+    async enableCaptureAndSend(sender, options) {
+        const startCapturingPromise = this.startCapturing(options ?? this.defaultCaptureOptions);
+        if (sender) {
+            this.startSending(sender);
+        }
+        // Bubble up the error.
+        return startCapturingPromise;
     }
     disable() {
         this.stopCapturing();
@@ -95,11 +97,8 @@ class GumVideoCapturer {
         if (this.captureOptions) {
             const { captureOptions, sender } = this;
             this.disable();
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            this.startCapturing(captureOptions);
-            if (sender) {
-                this.startSending(sender);
-            }
+            // Bubble up the error if starting video failed.
+            return this.enableCaptureAndSend(sender, captureOptions);
         }
     }
     async enumerateDevices() {
@@ -191,6 +190,8 @@ class GumVideoCapturer {
                 // We couldn't open the camera.  Oh well.
                 this.captureOptions = undefined;
             }
+            // Re-raise so that callers can surface this condition to the user.
+            throw e;
         }
     }
     stopCapturing() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalapp/ringrtc",
-  "version": "2.41.0",
+  "version": "2.43.0",
   "description": "Signal Messenger voice and video calling library.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,7 +25,7 @@
   },
   "config": {
     "prebuildUrl": "https://build-artifacts.signal.org/libraries/ringrtc-desktop-build-v${npm_package_version}.tar.gz",
-    "prebuildChecksum": "50e54adb31b0c40911e82c0192732323abe850b4990f4794ccc99a0a21bf85b4"
+    "prebuildChecksum": "391a681a172c7ebef3ee8fdf994273030cb5673b556bd5c6fb0f8f78416dbce6"
   },
   "author": "",
   "license": "AGPL-3.0-only",