@signalapp/ringrtc 2.42.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.42.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;
@@ -249,7 +249,17 @@ export declare class RingRTCType {
     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;

package/dist/ringrtc/Service.js

@@ -238,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 {
@@ -388,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;
@@ -419,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
@@ -960,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;
         }
@@ -977,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;
@@ -990,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
@@ -1016,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;
             }
@@ -1038,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

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.42.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": "c7ce95993ed4cc77b6b912e052deb4c8671d63e44605c12b576a5872293f687e"
+    "prebuildChecksum": "391a681a172c7ebef3ee8fdf994273030cb5673b556bd5c6fb0f8f78416dbce6"
   },
   "author": "",
   "license": "AGPL-3.0-only",