@signalapp/ringrtc 2.26.3 → 2.27.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { RingRTCType } from './ringrtc/Service';
-export { AnswerMessage, AudioDevice, BandwidthMode, BusyMessage, Call, CallEndedReason, CallId, CallLogLevel, CallMessageUrgency, CallSettings, CallState, CallingMessage, ConnectionState, DeviceId, GroupCall, GroupCallEndReason, GroupCallObserver, GroupMemberInfo, HangupMessage, HangupType, HttpMethod, IceCandidateMessage, JoinState, LocalDeviceState, OfferMessage, OfferType, OpaqueMessage, PeekInfo, RemoteDeviceState, RingCancelReason, RingRTCType, RingUpdate, UserId, VideoCapturer, VideoRenderer, VideoRequest, callIdFromEra, callIdFromRingId, } from './ringrtc/Service';
+export { AnswerMessage, AudioDevice, BandwidthMode, BusyMessage, Call, CallEndedReason, CallId, CallLogLevel, CallMessageUrgency, CallSettings, CallState, CallingMessage, ConnectionState, DeviceId, GroupCall, GroupCallEndReason, GroupCallObserver, GroupMemberInfo, HangupMessage, HangupType, HttpMethod, HttpResult, IceCandidateMessage, JoinState, LocalDeviceState, OfferMessage, OfferType, OpaqueMessage, PeekInfo, RemoteDeviceState, RingCancelReason, RingRTCType, RingUpdate, UserId, VideoCapturer, VideoRenderer, VideoRequest, callIdFromEra, callIdFromRingId, } from './ringrtc/Service';
 export { CanvasVideoRenderer, GumVideoCapturer, VideoFrameSource, MAX_VIDEO_CAPTURE_AREA, MAX_VIDEO_CAPTURE_BUFFER_SIZE, MAX_VIDEO_CAPTURE_HEIGHT, MAX_VIDEO_CAPTURE_WIDTH, } from './ringrtc/VideoSupport';
+export { CallLinkRootKey, CallLinkRestrictions, CallLinkState, } from './ringrtc/CallLinks';
 export declare const RingRTC: RingRTCType;

package/dist/index.js

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 //
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RingRTC = exports.MAX_VIDEO_CAPTURE_WIDTH = exports.MAX_VIDEO_CAPTURE_HEIGHT = exports.MAX_VIDEO_CAPTURE_BUFFER_SIZE = exports.MAX_VIDEO_CAPTURE_AREA = exports.GumVideoCapturer = exports.CanvasVideoRenderer = exports.callIdFromRingId = exports.callIdFromEra = exports.VideoRequest = exports.RingUpdate = exports.RingRTCType = exports.RingCancelReason = exports.RemoteDeviceState = exports.PeekInfo = exports.OpaqueMessage = exports.OfferType = exports.OfferMessage = exports.LocalDeviceState = exports.JoinState = exports.IceCandidateMessage = exports.HttpMethod = exports.HangupType = exports.HangupMessage = exports.GroupMemberInfo = exports.GroupCallEndReason = exports.GroupCall = exports.ConnectionState = exports.CallingMessage = exports.CallState = exports.CallMessageUrgency = exports.CallLogLevel = exports.CallEndedReason = exports.Call = exports.BusyMessage = exports.BandwidthMode = exports.AnswerMessage = void 0;
+exports.RingRTC = exports.CallLinkState = exports.CallLinkRestrictions = exports.CallLinkRootKey = exports.MAX_VIDEO_CAPTURE_WIDTH = exports.MAX_VIDEO_CAPTURE_HEIGHT = exports.MAX_VIDEO_CAPTURE_BUFFER_SIZE = exports.MAX_VIDEO_CAPTURE_AREA = exports.GumVideoCapturer = exports.CanvasVideoRenderer = exports.callIdFromRingId = exports.callIdFromEra = exports.VideoRequest = exports.RingUpdate = exports.RingRTCType = exports.RingCancelReason = exports.RemoteDeviceState = exports.PeekInfo = exports.OpaqueMessage = exports.OfferType = exports.OfferMessage = exports.LocalDeviceState = exports.JoinState = exports.IceCandidateMessage = exports.HttpMethod = exports.HangupType = exports.HangupMessage = exports.GroupMemberInfo = exports.GroupCallEndReason = exports.GroupCall = exports.ConnectionState = exports.CallingMessage = exports.CallState = exports.CallMessageUrgency = exports.CallLogLevel = exports.CallEndedReason = exports.Call = exports.BusyMessage = exports.BandwidthMode = exports.AnswerMessage = void 0;
 const Service_1 = require("./ringrtc/Service");
 var Service_2 = require("./ringrtc/Service");
 Object.defineProperty(exports, "AnswerMessage", { enumerable: true, get: function () { return Service_2.AnswerMessage; } });
@@ -44,5 +44,9 @@ Object.defineProperty(exports, "MAX_VIDEO_CAPTURE_AREA", { enumerable: true, get
 Object.defineProperty(exports, "MAX_VIDEO_CAPTURE_BUFFER_SIZE", { enumerable: true, get: function () { return VideoSupport_1.MAX_VIDEO_CAPTURE_BUFFER_SIZE; } });
 Object.defineProperty(exports, "MAX_VIDEO_CAPTURE_HEIGHT", { enumerable: true, get: function () { return VideoSupport_1.MAX_VIDEO_CAPTURE_HEIGHT; } });
 Object.defineProperty(exports, "MAX_VIDEO_CAPTURE_WIDTH", { enumerable: true, get: function () { return VideoSupport_1.MAX_VIDEO_CAPTURE_WIDTH; } });
+var CallLinks_1 = require("./ringrtc/CallLinks");
+Object.defineProperty(exports, "CallLinkRootKey", { enumerable: true, get: function () { return CallLinks_1.CallLinkRootKey; } });
+Object.defineProperty(exports, "CallLinkRestrictions", { enumerable: true, get: function () { return CallLinks_1.CallLinkRestrictions; } });
+Object.defineProperty(exports, "CallLinkState", { enumerable: true, get: function () { return CallLinks_1.CallLinkState; } });
 exports.RingRTC = new Service_1.RingRTCType();
 //# sourceMappingURL=index.js.map

package/dist/ringrtc/CallLinks.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+export declare class CallLinkRootKey {
+    readonly bytes: Buffer;
+    private constructor();
+    static parse(str: string): CallLinkRootKey;
+    static fromBytes(bytes: Buffer): CallLinkRootKey;
+    static generate(): CallLinkRootKey;
+    static generateAdminPassKey(): Buffer;
+    deriveRoomId(): Buffer;
+    toString(): string;
+}
+export declare class CallLinkState {
+    name: string;
+    restrictions: CallLinkRestrictions;
+    revoked: boolean;
+    expiration: Date;
+    constructor(name: string, restrictions: CallLinkRestrictions, revoked: boolean, expiration: Date);
+}
+export declare enum CallLinkRestrictions {
+    None = 0,
+    AdminApproval = 1,
+    Unknown = 2
+}

package/dist/ringrtc/CallLinks.js

@@ -0,0 +1,55 @@
+"use strict";
+//
+// Copyright 2023 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallLinkRestrictions = exports.CallLinkState = exports.CallLinkRootKey = void 0;
+const Native_1 = __importDefault(require("./Native"));
+class CallLinkRootKey {
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    static parse(str) {
+        return new CallLinkRootKey(Native_1.default.CallLinkRootKey_parse(str));
+    }
+    static fromBytes(bytes) {
+        Native_1.default.CallLinkRootKey_validate(bytes);
+        return new CallLinkRootKey(bytes);
+    }
+    static generate() {
+        return new CallLinkRootKey(Native_1.default.CallLinkRootKey_generate());
+    }
+    static generateAdminPassKey() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return Native_1.default.CallLinkRootKey_generateAdminPasskey();
+    }
+    deriveRoomId() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return Native_1.default.CallLinkRootKey_deriveRoomId(this.bytes);
+    }
+    toString() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return Native_1.default.CallLinkRootKey_toFormattedString(this.bytes);
+    }
+}
+exports.CallLinkRootKey = CallLinkRootKey;
+class CallLinkState {
+    constructor(name, restrictions, revoked, expiration) {
+        this.name = name;
+        this.restrictions = restrictions;
+        this.revoked = revoked;
+        this.expiration = expiration;
+    }
+}
+exports.CallLinkState = CallLinkState;
+var CallLinkRestrictions;
+(function (CallLinkRestrictions) {
+    CallLinkRestrictions[CallLinkRestrictions["None"] = 0] = "None";
+    CallLinkRestrictions[CallLinkRestrictions["AdminApproval"] = 1] = "AdminApproval";
+    CallLinkRestrictions[CallLinkRestrictions["Unknown"] = 2] = "Unknown";
+})(CallLinkRestrictions = exports.CallLinkRestrictions || (exports.CallLinkRestrictions = {}));
+//# sourceMappingURL=CallLinks.js.map

package/dist/ringrtc/Native.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/ringrtc/Native.js

@@ -0,0 +1,34 @@
+"use strict";
+//
+// Copyright 2023 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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os = __importStar(require("os"));
+const process = __importStar(require("process"));
+// eslint-disable-next-line @typescript-eslint/no-var-requires, import/no-dynamic-require
+exports.default = require(`../../build/${os.platform()}/libringrtc-${process.arch}.node`);
+//# sourceMappingURL=Native.js.map

package/dist/ringrtc/Service.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { GumVideoCaptureOptions, VideoPixelFormatEnum } from './VideoSupport';
+import { CallLinkState, CallLinkRestrictions, CallLinkRootKey } from './CallLinks';
 export declare const callIdFromEra: (era: string) => CallId;
 export declare function callIdFromRingId(ringId: bigint): CallId;
 declare class Config {
@@ -45,11 +46,19 @@ export declare class ReceivedAudioLevel {
     level: RawAudioLevel;
     constructor(demuxId: number, level: RawAudioLevel);
 }
+export type HttpResult<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    errorStatusCode: number;
+};
 export declare class RingRTCType {
     private readonly callManager;
     private _call;
     private _groupCallByClientId;
     private _peekRequests;
+    private _callLinkRequests;
     private _callInfoByCallId;
     private getCallInfoKey;
     handleOutgoingSignaling: ((remoteUserId: UserId, message: CallingMessage) => Promise<boolean>) | null;
@@ -84,6 +93,101 @@ export declare class RingRTCType {
     onSendHangup(remoteUserId: UserId, remoteDeviceId: DeviceId, callId: CallId, broadcast: boolean, hangupType: HangupType, deviceId: DeviceId | null): void;
     onSendBusy(remoteUserId: UserId, remoteDeviceId: DeviceId, callId: CallId, broadcast: boolean): void;
     private sendSignaling;
+    /**
+     * Asynchronous request to get information about a call link.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     *
+     * Expected failure codes include:
+     * - 404: the room does not exist (or expired so long ago that it has been removed from the server)
+     */
+    readCallLink(sfuUrl: string, authCredentialPresentation: Buffer, linkRootKey: CallLinkRootKey): Promise<HttpResult<CallLinkState>>;
+    /**
+     * Asynchronous request to create a new call link.
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @example
+     * const linkKey = CallLinkRootKey.generate();
+     * const adminPasskey = CallLinkRootKey.generateAdminPasskey();
+     * const roomId = linkKey.deriveRoomId();
+     * const credential = requestCreateCredentialFromChatServer(roomId); // using libsignal
+     * const secretParams = CallLinkSecretParams.deriveFromRootKey(linkKey.bytes);
+     * const credentialPresentation = credential.present(roomId, secretParams).serialize();
+     * const serializedPublicParams = secretParams.getPublicParams().serialize();
+     * const result = await RingRTC.createCallLink(sfuUrl, credentialPresentation, linkKey, adminPasskey, serializedPublicParams);
+     * if (result.success) {
+     *   const state = result.value;
+     *   // In actuality you may not want to do this until the user clicks Done.
+     *   saveToDatabase(linkKey.bytes, adminPasskey, state);
+     *   syncToOtherDevices(linkKey.bytes, adminPasskey);
+     * } else {
+     *   switch (result.errorStatusCode) {
+     *   case 409:
+     *     // The room already exists (and isn't yours), i.e. you've hit a 1-in-a-billion conflict.
+     *     // Fall through to kicking the user out to try again later.
+     *   default:
+     *     // Unexpected error, kick the user out for now.
+     *   }
+     * }
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param createCredentialPresentation - a serialized CreateCallLinkCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the arbitrary passkey to use for the new room
+     * @param callLinkPublicParams - the serialized CallLinkPublicParams for the new room
+     */
+    createCallLink(sfuUrl: string, createCredentialPresentation: Buffer, linkRootKey: CallLinkRootKey, adminPasskey: Buffer, callLinkPublicParams: Buffer): Promise<HttpResult<CallLinkState>>;
+    /**
+     * Asynchronous request to update a call link's name.
+     *
+     * Possible failure codes include:
+     * - 401: the room does not exist (and this is the wrong API to create a new room)
+     * - 403: the admin passkey is incorrect
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the passkey specified when the link was created
+     * @param newName - the new name to use
+     */
+    updateCallLinkName(sfuUrl: string, authCredentialPresentation: Buffer, linkRootKey: CallLinkRootKey, adminPasskey: Buffer, newName: string): Promise<HttpResult<CallLinkState>>;
+    /**
+     * Asynchronous request to update a call link's restrictions.
+     *
+     * Possible failure codes include:
+     * - 401: the room does not exist (and this is the wrong API to create a new room)
+     * - 403: the admin passkey is incorrect
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the passkey specified when the link was created
+     * @param restrictions - the new restrictions to use
+     */
+    updateCallLinkRestrictions(sfuUrl: string, authCredentialPresentation: Buffer, linkRootKey: CallLinkRootKey, adminPasskey: Buffer, restrictions: Exclude<CallLinkRestrictions, CallLinkRestrictions.Unknown>): Promise<HttpResult<CallLinkState>>;
+    /**
+     * Asynchronous request to revoke or un-revoke a call link.
+     *
+     * Possible failure codes include:
+     * - 401: the room does not exist (and this is the wrong API to create a new room)
+     * - 403: the admin passkey is incorrect
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the passkey specified when the link was created
+     * @param revoked - whether the link should now be revoked
+     */
+    updateCallLinkRevocation(sfuUrl: string, authCredentialPresentation: Buffer, linkRootKey: CallLinkRootKey, adminPasskey: Buffer, revoked: boolean): Promise<HttpResult<CallLinkState>>;
     receivedHttpResponse(requestId: number, status: number, body: Buffer): void;
     httpRequestFailed(requestId: number, debugInfo: string | undefined): void;
     getGroupCall(groupId: Buffer, sfuUrl: string, hkdfExtraInfo: Buffer, audioLevelsIntervalMillis: number | undefined, observer: GroupCallObserver): GroupCall | undefined;
@@ -97,6 +201,12 @@ export declare class RingRTCType {
     handleRemoteDevicesChanged(clientId: GroupCallClientId, remoteDeviceStates: Array<RemoteDeviceState>): void;
     handlePeekChanged(clientId: GroupCallClientId, info: PeekInfo): void;
     handlePeekResponse(requestId: number, info: PeekInfo): void;
+    handleCallLinkResponse(requestId: number, statusCode: number, state: {
+        name: string;
+        rawRestrictions: number;
+        revoked: boolean;
+        expiration: Date;
+    } | undefined): void;
     handleEnded(clientId: GroupCallClientId, reason: GroupCallEndReason): void;
     groupCallRingUpdate(groupId: GroupId, ringIdString: string, sender: GroupCallUserId, state: RingUpdate): void;
     onLogMessage(level: number, fileName: string, line: number, message: string): void;
@@ -455,6 +565,9 @@ 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;
+    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;
     peekGroupCall(requestId: number, sfu_url: string, membership_proof: Buffer, group_members: Array<GroupMemberInfo>): void;
     getAudioInputs(): Array<AudioDevice>;
     setAudioInput(index: number): void;

package/dist/ringrtc/Service.js

@@ -35,14 +35,16 @@ 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 });
 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 = exports.callIdFromRingId = exports.callIdFromEra = void 0;
 /* eslint-disable max-classes-per-file */
-const os = __importStar(require("os"));
 const process = __importStar(require("process"));
-// eslint-disable-next-line @typescript-eslint/no-var-requires, import/no-dynamic-require
-const Native = require(`../../build/${os.platform()}/libringrtc-${process.arch}.node`);
-exports.callIdFromEra = Native.callIdFromEra;
+const CallLinks_1 = require("./CallLinks");
+const Native_1 = __importDefault(require("./Native"));
+exports.callIdFromEra = Native_1.default.callIdFromEra;
 function callIdFromRingId(ringId) {
     return {
         low: Number(BigInt.asIntN(32, ringId)),
@@ -65,22 +67,25 @@ class NativeCallManager {
         this.createCallEndpoint(config);
     }
     createCallEndpoint(config) {
-        const fieldTrials = Object.assign({ 'RingRTC-AnyAddressPortsKillSwitch': 'Enabled' }, config.field_trials);
+        const fieldTrials = Object.assign({
+            'RingRTC-AnyAddressPortsKillSwitch': 'Enabled',
+            'WebRTC-Audio-OpusSetSignalVoiceWithDtx': 'Enabled',
+        }, config.field_trials);
         /* eslint-disable prefer-template */
         const fieldTrialsString = Object.entries(fieldTrials)
             .map(([k, v]) => `${k}/${v}`)
             .join('/') + '/';
         /* eslint-enable prefer-template */
-        Object.defineProperty(this, Native.callEndpointPropertyKey, {
+        Object.defineProperty(this, Native_1.default.callEndpointPropertyKey, {
             configurable: true,
             get() {
-                const callEndpoint = Native.createCallEndpoint(this, config.use_new_audio_device_module, fieldTrialsString);
+                const callEndpoint = Native_1.default.createCallEndpoint(this, config.use_new_audio_device_module, fieldTrialsString);
                 if (process.platform === 'darwin') {
                     // Preload devices to work around
                     // https://bugs.chromium.org/p/chromium/issues/detail?id=1287628
                     void window.navigator.mediaDevices.enumerateDevices();
                 }
-                Object.defineProperty(this, Native.callEndpointPropertyKey, {
+                Object.defineProperty(this, Native_1.default.callEndpointPropertyKey, {
                     configurable: true,
                     value: callEndpoint,
                 });
@@ -92,76 +97,79 @@ class NativeCallManager {
 }
 // Mirror methods onto NativeCallManager.
 // This is done through direct assignment rather than wrapper methods to avoid indirection.
-NativeCallManager.prototype.setSelfUuid = Native.cm_setSelfUuid;
+NativeCallManager.prototype.setSelfUuid = Native_1.default.cm_setSelfUuid;
 NativeCallManager.prototype.createOutgoingCall =
-    Native.cm_createOutgoingCall;
-NativeCallManager.prototype.proceed = Native.cm_proceed;
-NativeCallManager.prototype.accept = Native.cm_accept;
-NativeCallManager.prototype.ignore = Native.cm_ignore;
-NativeCallManager.prototype.hangup = Native.cm_hangup;
+    Native_1.default.cm_createOutgoingCall;
+NativeCallManager.prototype.proceed = Native_1.default.cm_proceed;
+NativeCallManager.prototype.accept = Native_1.default.cm_accept;
+NativeCallManager.prototype.ignore = Native_1.default.cm_ignore;
+NativeCallManager.prototype.hangup = Native_1.default.cm_hangup;
 NativeCallManager.prototype.cancelGroupRing =
-    Native.cm_cancelGroupRing;
+    Native_1.default.cm_cancelGroupRing;
 NativeCallManager.prototype.signalingMessageSent =
-    Native.cm_signalingMessageSent;
+    Native_1.default.cm_signalingMessageSent;
 NativeCallManager.prototype.signalingMessageSendFailed =
-    Native.cm_signalingMessageSendFailed;
+    Native_1.default.cm_signalingMessageSendFailed;
 NativeCallManager.prototype.updateBandwidthMode =
-    Native.cm_updateBandwidthMode;
-NativeCallManager.prototype.receivedOffer = Native.cm_receivedOffer;
-NativeCallManager.prototype.receivedAnswer = Native.cm_receivedAnswer;
+    Native_1.default.cm_updateBandwidthMode;
+NativeCallManager.prototype.receivedOffer = Native_1.default.cm_receivedOffer;
+NativeCallManager.prototype.receivedAnswer = Native_1.default.cm_receivedAnswer;
 NativeCallManager.prototype.receivedIceCandidates =
-    Native.cm_receivedIceCandidates;
-NativeCallManager.prototype.receivedHangup = Native.cm_receivedHangup;
-NativeCallManager.prototype.receivedBusy = Native.cm_receivedBusy;
+    Native_1.default.cm_receivedIceCandidates;
+NativeCallManager.prototype.receivedHangup = Native_1.default.cm_receivedHangup;
+NativeCallManager.prototype.receivedBusy = Native_1.default.cm_receivedBusy;
 NativeCallManager.prototype.receivedCallMessage =
-    Native.cm_receivedCallMessage;
+    Native_1.default.cm_receivedCallMessage;
 NativeCallManager.prototype.receivedHttpResponse =
-    Native.cm_receivedHttpResponse;
+    Native_1.default.cm_receivedHttpResponse;
 NativeCallManager.prototype.httpRequestFailed =
-    Native.cm_httpRequestFailed;
+    Native_1.default.cm_httpRequestFailed;
 NativeCallManager.prototype.setOutgoingAudioEnabled =
-    Native.cm_setOutgoingAudioEnabled;
+    Native_1.default.cm_setOutgoingAudioEnabled;
 NativeCallManager.prototype.setOutgoingVideoEnabled =
-    Native.cm_setOutgoingVideoEnabled;
+    Native_1.default.cm_setOutgoingVideoEnabled;
 NativeCallManager.prototype.setOutgoingVideoIsScreenShare =
-    Native.cm_setOutgoingVideoIsScreenShare;
-NativeCallManager.prototype.sendVideoFrame = Native.cm_sendVideoFrame;
+    Native_1.default.cm_setOutgoingVideoIsScreenShare;
+NativeCallManager.prototype.sendVideoFrame = Native_1.default.cm_sendVideoFrame;
 NativeCallManager.prototype.receiveVideoFrame =
-    Native.cm_receiveVideoFrame;
+    Native_1.default.cm_receiveVideoFrame;
 NativeCallManager.prototype.receiveGroupCallVideoFrame =
-    Native.cm_receiveGroupCallVideoFrame;
+    Native_1.default.cm_receiveGroupCallVideoFrame;
 NativeCallManager.prototype.createGroupCallClient =
-    Native.cm_createGroupCallClient;
+    Native_1.default.cm_createGroupCallClient;
 NativeCallManager.prototype.deleteGroupCallClient =
-    Native.cm_deleteGroupCallClient;
-NativeCallManager.prototype.connect = Native.cm_connect;
-NativeCallManager.prototype.join = Native.cm_join;
-NativeCallManager.prototype.leave = Native.cm_leave;
-NativeCallManager.prototype.disconnect = Native.cm_disconnect;
-NativeCallManager.prototype.groupRing = Native.cm_groupRing;
+    Native_1.default.cm_deleteGroupCallClient;
+NativeCallManager.prototype.connect = Native_1.default.cm_connect;
+NativeCallManager.prototype.join = Native_1.default.cm_join;
+NativeCallManager.prototype.leave = Native_1.default.cm_leave;
+NativeCallManager.prototype.disconnect = Native_1.default.cm_disconnect;
+NativeCallManager.prototype.groupRing = Native_1.default.cm_groupRing;
 NativeCallManager.prototype.setOutgoingAudioMuted =
-    Native.cm_setOutgoingAudioMuted;
+    Native_1.default.cm_setOutgoingAudioMuted;
 NativeCallManager.prototype.setOutgoingVideoMuted =
-    Native.cm_setOutgoingVideoMuted;
+    Native_1.default.cm_setOutgoingVideoMuted;
 NativeCallManager.prototype.setOutgoingGroupCallVideoIsScreenShare =
-    Native.cm_setOutgoingGroupCallVideoIsScreenShare;
-NativeCallManager.prototype.setPresenting = Native.cm_setPresenting;
+    Native_1.default.cm_setOutgoingGroupCallVideoIsScreenShare;
+NativeCallManager.prototype.setPresenting = Native_1.default.cm_setPresenting;
 NativeCallManager.prototype.resendMediaKeys =
-    Native.cm_resendMediaKeys;
+    Native_1.default.cm_resendMediaKeys;
 NativeCallManager.prototype.setBandwidthMode =
-    Native.cm_setBandwidthMode;
-NativeCallManager.prototype.requestVideo = Native.cm_requestVideo;
+    Native_1.default.cm_setBandwidthMode;
+NativeCallManager.prototype.requestVideo = Native_1.default.cm_requestVideo;
 NativeCallManager.prototype.setGroupMembers =
-    Native.cm_setGroupMembers;
+    Native_1.default.cm_setGroupMembers;
 NativeCallManager.prototype.setMembershipProof =
-    Native.cm_setMembershipProof;
-NativeCallManager.prototype.peekGroupCall = Native.cm_peekGroupCall;
-NativeCallManager.prototype.getAudioInputs = Native.cm_getAudioInputs;
-NativeCallManager.prototype.setAudioInput = Native.cm_setAudioInput;
+    Native_1.default.cm_setMembershipProof;
+NativeCallManager.prototype.readCallLink = Native_1.default.cm_readCallLink;
+NativeCallManager.prototype.createCallLink = Native_1.default.cm_createCallLink;
+NativeCallManager.prototype.updateCallLink = Native_1.default.cm_updateCallLink;
+NativeCallManager.prototype.peekGroupCall = Native_1.default.cm_peekGroupCall;
+NativeCallManager.prototype.getAudioInputs = Native_1.default.cm_getAudioInputs;
+NativeCallManager.prototype.setAudioInput = Native_1.default.cm_setAudioInput;
 NativeCallManager.prototype.getAudioOutputs =
-    Native.cm_getAudioOutputs;
-NativeCallManager.prototype.setAudioOutput = Native.cm_setAudioOutput;
-NativeCallManager.prototype.processEvents = Native.cm_processEvents;
+    Native_1.default.cm_getAudioOutputs;
+NativeCallManager.prototype.setAudioOutput = Native_1.default.cm_setAudioOutput;
+NativeCallManager.prototype.processEvents = Native_1.default.cm_processEvents;
 class PeekDeviceInfo {
     constructor(demuxId, userId) {
         this.demuxId = demuxId;
@@ -270,6 +278,7 @@ class RingRTCType {
         this._call = null;
         this._groupCallByClientId = new Map();
         this._peekRequests = new Requests();
+        this._callLinkRequests = new Requests();
         this._callInfoByCallId = new Map();
     }
     setConfig(config) {
@@ -542,6 +551,138 @@ class RingRTCType {
             }
         }))().catch(e => this.logError(e.toString()));
     }
+    // Call Links
+    /**
+     * Asynchronous request to get information about a call link.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     *
+     * Expected failure codes include:
+     * - 404: the room does not exist (or expired so long ago that it has been removed from the server)
+     */
+    readCallLink(sfuUrl, authCredentialPresentation, linkRootKey) {
+        const [requestId, promise] = this._callLinkRequests.add();
+        // Response comes back via handleCallLinkResponse
+        sillyDeadlockProtection(() => {
+            this.callManager.readCallLink(requestId, sfuUrl, authCredentialPresentation, linkRootKey.bytes);
+        });
+        return promise;
+    }
+    /**
+     * Asynchronous request to create a new call link.
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @example
+     * const linkKey = CallLinkRootKey.generate();
+     * const adminPasskey = CallLinkRootKey.generateAdminPasskey();
+     * const roomId = linkKey.deriveRoomId();
+     * const credential = requestCreateCredentialFromChatServer(roomId); // using libsignal
+     * const secretParams = CallLinkSecretParams.deriveFromRootKey(linkKey.bytes);
+     * const credentialPresentation = credential.present(roomId, secretParams).serialize();
+     * const serializedPublicParams = secretParams.getPublicParams().serialize();
+     * const result = await RingRTC.createCallLink(sfuUrl, credentialPresentation, linkKey, adminPasskey, serializedPublicParams);
+     * if (result.success) {
+     *   const state = result.value;
+     *   // In actuality you may not want to do this until the user clicks Done.
+     *   saveToDatabase(linkKey.bytes, adminPasskey, state);
+     *   syncToOtherDevices(linkKey.bytes, adminPasskey);
+     * } else {
+     *   switch (result.errorStatusCode) {
+     *   case 409:
+     *     // The room already exists (and isn't yours), i.e. you've hit a 1-in-a-billion conflict.
+     *     // Fall through to kicking the user out to try again later.
+     *   default:
+     *     // Unexpected error, kick the user out for now.
+     *   }
+     * }
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param createCredentialPresentation - a serialized CreateCallLinkCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the arbitrary passkey to use for the new room
+     * @param callLinkPublicParams - the serialized CallLinkPublicParams for the new room
+     */
+    createCallLink(sfuUrl, createCredentialPresentation, linkRootKey, adminPasskey, callLinkPublicParams) {
+        const [requestId, promise] = this._callLinkRequests.add();
+        // Response comes back via handleCallLinkResponse
+        sillyDeadlockProtection(() => {
+            this.callManager.createCallLink(requestId, sfuUrl, createCredentialPresentation, linkRootKey.bytes, adminPasskey, callLinkPublicParams);
+        });
+        return promise;
+    }
+    /**
+     * Asynchronous request to update a call link's name.
+     *
+     * Possible failure codes include:
+     * - 401: the room does not exist (and this is the wrong API to create a new room)
+     * - 403: the admin passkey is incorrect
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the passkey specified when the link was created
+     * @param newName - the new name to use
+     */
+    updateCallLinkName(sfuUrl, authCredentialPresentation, linkRootKey, adminPasskey, newName) {
+        const [requestId, promise] = this._callLinkRequests.add();
+        // Response comes back via handleCallLinkResponse
+        sillyDeadlockProtection(() => {
+            this.callManager.updateCallLink(requestId, sfuUrl, authCredentialPresentation, linkRootKey.bytes, adminPasskey, newName, undefined, undefined);
+        });
+        return promise;
+    }
+    /**
+     * Asynchronous request to update a call link's restrictions.
+     *
+     * Possible failure codes include:
+     * - 401: the room does not exist (and this is the wrong API to create a new room)
+     * - 403: the admin passkey is incorrect
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the passkey specified when the link was created
+     * @param restrictions - the new restrictions to use
+     */
+    updateCallLinkRestrictions(sfuUrl, authCredentialPresentation, linkRootKey, adminPasskey, restrictions) {
+        const [requestId, promise] = this._callLinkRequests.add();
+        // Response comes back via handleCallLinkResponse
+        sillyDeadlockProtection(() => {
+            this.callManager.updateCallLink(requestId, sfuUrl, authCredentialPresentation, linkRootKey.bytes, adminPasskey, undefined, restrictions, undefined);
+        });
+        return promise;
+    }
+    /**
+     * Asynchronous request to revoke or un-revoke a call link.
+     *
+     * Possible failure codes include:
+     * - 401: the room does not exist (and this is the wrong API to create a new room)
+     * - 403: the admin passkey is incorrect
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the passkey specified when the link was created
+     * @param revoked - whether the link should now be revoked
+     */
+    updateCallLinkRevocation(sfuUrl, authCredentialPresentation, linkRootKey, adminPasskey, revoked) {
+        const [requestId, promise] = this._callLinkRequests.add();
+        // Response comes back via handleCallLinkResponse
+        sillyDeadlockProtection(() => {
+            this.callManager.updateCallLink(requestId, sfuUrl, authCredentialPresentation, linkRootKey.bytes, adminPasskey, undefined, undefined, revoked);
+        });
+        return promise;
+    }
+    // HTTP callbacks
     receivedHttpResponse(requestId, status, body) {
         sillyDeadlockProtection(() => {
             try {
@@ -676,6 +817,37 @@ class RingRTCType {
         });
     }
     // Called by Rust
+    handleCallLinkResponse(requestId, statusCode, state) {
+        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;
+                }
+                result = {
+                    success: true,
+                    value: new CallLinks_1.CallLinkState(state.name, restrictions, state.revoked, state.expiration),
+                };
+            }
+            else {
+                result = { success: false, errorStatusCode: statusCode };
+            }
+            if (!this._callLinkRequests.resolve(requestId, result)) {
+                this.logWarn(`Invalid request ID for handleCallLinkResponse: ${requestId}`);
+            }
+        });
+    }
+    // Called by Rust
     handleEnded(clientId, reason) {
         sillyDeadlockProtection(() => {
             const groupCall = this._groupCallByClientId.get(clientId);

package/dist/ringrtc/VideoSupport.js

@@ -178,6 +178,16 @@ class GumVideoCapturer {
                     }
                     return;
                 }
+                if (this.mediaStream !== undefined &&
+                    this.mediaStream.getVideoTracks().length > 0) {
+                    // We have a stream and track for the requested camera already. Stop
+                    // the duplicate track that we just started.
+                    index_1.RingRTC.logWarn('startCapturing(): dropping duplicate call to startCapturing');
+                    for (const track of mediaStream.getVideoTracks()) {
+                        track.stop();
+                    }
+                    return;
+                }
                 this.mediaStream = mediaStream;
                 if (!this.spawnedSenderRunning &&
                     this.mediaStream != undefined &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalapp/ringrtc",
-  "version": "2.26.3",
+  "version": "2.27.0",
   "description": "Signal Messenger voice and video calling library.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,7 +23,7 @@
   },
   "config": {
     "prebuildUrl": "https://build-artifacts.signal.org/libraries/ringrtc-desktop-build-v${npm_package_version}.tar.gz",
-    "prebuildChecksum": "5d580631487a2d988c93c872792d6a4ab91e57f9fad2d2e29ed2991163bc8288"
+    "prebuildChecksum": "864c376c4998ae9a0a832c5753089e881d5466e2bbae5d11dae7486226129d5a"
   },
   "author": "",
   "license": "AGPL-3.0-only",