@signalapp/ringrtc 2.40.0 → 2.42.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.40.0
+## libsignal-core 0.1.0, partial-default-derive 0.1.0, regex-aot 0.1.0, ringrtc 2.42.0
 
 ```
 GNU AFFERO GENERAL PUBLIC LICENSE

package/dist/ringrtc/Service.d.ts

@@ -16,6 +16,20 @@ export interface Reaction {
     demuxId: number;
     value: string;
 }
+/** type returned by Rust */
+export interface RawPeekInfo {
+    devices: Array<PeekDeviceInfo>;
+    creator?: GroupCallUserId;
+    eraId?: string;
+    maxDevices?: number;
+    /** @deprecated Use {@link #deviceCountIncludingPendingDevices} and {@link #deviceCountExcludingPendingDevices} as appropriate */
+    deviceCount: number;
+    deviceCountIncludingPendingDevices: number;
+    deviceCountExcludingPendingDevices: number;
+    pendingUsers: Array<GroupCallUserId>;
+    callLinkState?: RawCallLinkState;
+}
+/** type derived from RawPeekInfo */
 export interface PeekInfo {
     devices: Array<PeekDeviceInfo>;
     creator?: GroupCallUserId;
@@ -26,6 +40,7 @@ export interface PeekInfo {
     deviceCountIncludingPendingDevices: number;
     deviceCountExcludingPendingDevices: number;
     pendingUsers: Array<GroupCallUserId>;
+    callLinkState?: CallLinkState;
 }
 export declare enum PeekStatusCodes {
     EXPIRED_CALL_LINK = 703,
@@ -55,6 +70,12 @@ export declare class ReceivedAudioLevel {
     level: RawAudioLevel;
     constructor(demuxId: number, level: RawAudioLevel);
 }
+interface RawCallLinkState {
+    name: string;
+    rawRestrictions: number;
+    revoked: boolean;
+    expiration: Date;
+}
 export type EmptyObj = Record<PropertyKey, never>;
 export type HttpResult<T> = {
     success: true;
@@ -83,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;
@@ -216,17 +238,13 @@ export declare class RingRTCType {
     handleReactions(clientId: GroupCallClientId, reactions: Array<Reaction>): void;
     handleRaisedHands(clientId: GroupCallClientId, raisedHands: Array<number>): void;
     handleRemoteDevicesChanged(clientId: GroupCallClientId, remoteDeviceStates: Array<RemoteDeviceState>): void;
-    handlePeekChanged(clientId: GroupCallClientId, info: PeekInfo): void;
-    handlePeekResponse(requestId: number, statusCode: number, info: PeekInfo | undefined): void;
-    handleCallLinkResponse(requestId: number, statusCode: number, state: {
-        name: string;
-        rawRestrictions: number;
-        revoked: boolean;
-        expiration: Date;
-    } | undefined): void;
+    handlePeekChanged(clientId: GroupCallClientId, rawInfo: RawPeekInfo): void;
+    handlePeekResponse(requestId: number, statusCode: number, rawInfo: RawPeekInfo | undefined): void;
+    handleCallLinkResponse(requestId: number, statusCode: number, state: RawCallLinkState | undefined): void;
     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;
@@ -497,6 +515,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;
@@ -621,6 +640,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;
@@ -654,8 +674,8 @@ export interface CallManagerCallbacks {
     handleConnectionStateChanged(clientId: GroupCallClientId, connectionState: ConnectionState): void;
     handleJoinStateChanged(clientId: GroupCallClientId, joinState: JoinState, demuxId: number | undefined): void;
     handleRemoteDevicesChanged(clientId: GroupCallClientId, remoteDeviceStates: Array<RemoteDeviceState>): void;
-    handlePeekChanged(clientId: GroupCallClientId, info: PeekInfo): void;
-    handlePeekResponse(requestId: number, statusCode: number, info: PeekInfo | undefined): void;
+    handlePeekChanged(clientId: GroupCallClientId, rawInfo: RawPeekInfo): void;
+    handlePeekResponse(requestId: number, statusCode: number, rawInfo: RawPeekInfo | undefined): void;
     handleEnded(clientId: GroupCallClientId, reason: GroupCallEndReason): void;
     onLogMessage(level: number, fileName: string, line: number, message: string): 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";
@@ -187,6 +189,32 @@ exports.ReceivedAudioLevel = ReceivedAudioLevel;
 function normalizeAudioLevel(raw) {
     return raw / 32767;
 }
+function rawCallLinkStateToCallLinkState(raw) {
+    if (raw) {
+        let restrictions;
+        switch (raw.rawRestrictions) {
+            case 0:
+                restrictions = CallLinks_1.CallLinkRestrictions.None;
+                break;
+            case 1:
+                restrictions = CallLinks_1.CallLinkRestrictions.AdminApproval;
+                break;
+            default:
+                restrictions = CallLinks_1.CallLinkRestrictions.Unknown;
+                break;
+        }
+        return new CallLinks_1.CallLinkState(raw.name, restrictions, raw.revoked, raw.expiration);
+    }
+    else {
+        return undefined;
+    }
+}
+function rawPeekInfoToPeekInfo(raw) {
+    return {
+        ...raw,
+        callLinkState: rawCallLinkStateToCallLinkState(raw.callLinkState),
+    };
+}
 class Requests {
     constructor() {
         this._resolveById = new Map();
@@ -234,6 +262,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();
@@ -821,21 +850,23 @@ class RingRTCType {
         });
     }
     // Called by Rust
-    handlePeekChanged(clientId, info) {
+    handlePeekChanged(clientId, rawInfo) {
         sillyDeadlockProtection(() => {
             const groupCall = this._groupCallByClientId.get(clientId);
             if (!groupCall) {
                 this.logError('handlePeekChanged(): GroupCall not found in map!');
                 return;
             }
+            const info = rawPeekInfoToPeekInfo(rawInfo);
             groupCall.handlePeekChanged(info);
         });
     }
     // Called by Rust
-    handlePeekResponse(requestId, statusCode, info) {
+    handlePeekResponse(requestId, statusCode, rawInfo) {
         sillyDeadlockProtection(() => {
             let result;
-            if (info) {
+            if (rawInfo) {
+                const info = rawPeekInfoToPeekInfo(rawInfo);
                 result = { success: true, value: info };
             }
             else {
@@ -851,22 +882,11 @@ class RingRTCType {
         sillyDeadlockProtection(() => {
             // Recreate the state so that we have the correct prototype, in case we add more methods to CallLinkState.
             let result;
-            if (state) {
-                let restrictions;
-                switch (state.rawRestrictions) {
-                    case 0:
-                        restrictions = CallLinks_1.CallLinkRestrictions.None;
-                        break;
-                    case 1:
-                        restrictions = CallLinks_1.CallLinkRestrictions.AdminApproval;
-                        break;
-                    default:
-                        restrictions = CallLinks_1.CallLinkRestrictions.Unknown;
-                        break;
-                }
+            const s = rawCallLinkStateToCallLinkState(state);
+            if (s) {
                 result = {
                     success: true,
-                    value: new CallLinks_1.CallLinkState(state.name, restrictions, state.revoked, state.expiration),
+                    value: s,
                 };
             }
             else {
@@ -916,6 +936,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);
@@ -1654,6 +1680,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalapp/ringrtc",
-  "version": "2.40.0",
+  "version": "2.42.0",
   "description": "Signal Messenger voice and video calling library.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,13 +25,13 @@
   },
   "config": {
     "prebuildUrl": "https://build-artifacts.signal.org/libraries/ringrtc-desktop-build-v${npm_package_version}.tar.gz",
-    "prebuildChecksum": "fbdbd8ac3923dde1e82addb15b4a08ef7660c6e8b9f412139eaff19d8b67d0d4"
+    "prebuildChecksum": "c7ce95993ed4cc77b6b912e052deb4c8671d63e44605c12b576a5872293f687e"
   },
   "author": "",
   "license": "AGPL-3.0-only",
   "dependencies": {
     "https-proxy-agent": "7.0.1",
-    "tar": "^6.1.0"
+    "tar": "^6.2.1"
   },
   "devDependencies": {
     "@types/chai": "4.3.11",