@stream-io/video-client 1.53.2 → 1.54.1-beta.0

package/dist/index.es.js

@@ -508,6 +508,7 @@ class ErrorFromResponse extends Error {
     }
 }
 
+/* eslint-disable */
 // @generated by protobuf-ts 2.10.0 with parameter long_type_string,client_generic,server_none,eslint_disable,optimize_code_size
 // @generated from protobuf file "google/protobuf/struct.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
@@ -773,6 +774,7 @@ class ListValue$Type extends MessageType {
  */
 const ListValue = new ListValue$Type();
 
+/* eslint-disable */
 // @generated by protobuf-ts 2.10.0 with parameter long_type_string,client_generic,server_none,eslint_disable,optimize_code_size
 // @generated from protobuf file "google/protobuf/timestamp.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
@@ -1839,6 +1841,12 @@ class TrackInfo$Type extends MessageType {
                 kind: 'scalar',
                 T: 5 /*ScalarType.INT32*/,
             },
+            {
+                no: 13,
+                name: 'self_sub_audio_video',
+                kind: 'scalar',
+                T: 8 /*ScalarType.BOOL*/,
+            },
         ]);
     }
 }
@@ -6641,7 +6649,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.53.2";
+const version = "1.54.1-beta.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -6785,7 +6793,7 @@ const getClientDetails = async () => {
                 .join(' '),
             version: '',
         },
-        webrtcVersion: browserVersion,
+        webrtcVersion: webRtcInfo?.version || '',
     };
 };
 
@@ -8429,7 +8437,7 @@ class Publisher extends BasePeerConnection {
     /**
      * Constructs a new `Publisher` instance.
      */
-    constructor(baseOptions, publishOptions) {
+    constructor(baseOptions, publishOptions, opts = {}) {
         super(PeerType.PUBLISHER_UNSPECIFIED, baseOptions);
         this.transceiverCache = new TransceiverCache();
         this.clonedTracks = new Set();
@@ -8850,6 +8858,7 @@ class Publisher extends BasePeerConnection {
                 muted: !isTrackLive,
                 codec: publishOption.codec,
                 publishOptionId: publishOption.id,
+                selfSubAudioVideo: this.selfSubEnabled,
             };
         };
         this.cloneTrack = (track) => {
@@ -8930,6 +8939,7 @@ class Publisher extends BasePeerConnection {
             });
         };
         this.publishOptions = publishOptions;
+        this.selfSubEnabled = opts.selfSubEnabled ?? false;
         this.on('iceRestart', (iceRestart) => {
             if (iceRestart.peerType !== PeerType.PUBLISHER_UNSPECIFIED)
                 return;
@@ -9011,6 +9021,13 @@ class Subscriber extends BasePeerConnection {
      */
     constructor(opts) {
         super(PeerType.SUBSCRIBER, opts);
+        /**
+         * Remote streams received from the SFU. For a self-sub case
+         * we need to be able to distinguish between the local capture stream.
+         * The map will never contain local streams so we can safely use it to
+         * check if the stream is remote and dispose it when needed.
+         */
+        this.trackedStreams = new WeakSet();
         /**
          * Restarts the ICE connection and renegotiates with the SFU.
          */
@@ -9045,6 +9062,7 @@ class Subscriber extends BasePeerConnection {
             // example: `e3f6aaf8-b03d-4911-be36-83f47d37a76a:TRACK_TYPE_VIDEO`
             const [trackId, rawTrackType] = primaryStream.id.split(':');
             const participantToUpdate = this.state.participants.find((p) => p.trackLookupPrefix === trackId);
+            const isSelfSub = !!participantToUpdate?.isLocalParticipant;
             this.logger.debug(`[onTrack]: Got remote ${rawTrackType} track for userId: ${participantToUpdate?.userId}`, track.id, track);
             const trackType = toTrackType(rawTrackType);
             if (!trackType) {
@@ -9069,6 +9087,9 @@ class Subscriber extends BasePeerConnection {
                 this.setRemoteTrackInterrupted(trackId, trackType, true);
             }
             this.trackIdToTrackType.set(track.id, trackType);
+            if (isSelfSub) {
+                this.trackedStreams.add(primaryStream);
+            }
             if (!participantToUpdate) {
                 this.logger.warn(`[onTrack]: Received track for unknown participant: ${trackId}`, e);
                 this.state.registerOrphanedTrack({
@@ -9084,6 +9105,12 @@ class Subscriber extends BasePeerConnection {
                 this.logger.error(`Unknown track type: ${rawTrackType}`);
                 return;
             }
+            // Self-sub loopback audio routes to the speaker by default, which
+            // would echo the local user's voice. Default-mute here; consumers
+            // (the loopback recording hook) re-enable explicitly when needed.
+            if (isSelfSub && e.track.kind === 'audio') {
+                e.track.enabled = false;
+            }
             // get the previous stream to dispose it later
             // usually this happens during migration, when the stream is replaced
             // with a new one but the old one is still in the state
@@ -9092,8 +9119,12 @@ class Subscriber extends BasePeerConnection {
             this.state.updateParticipant(participantToUpdate.sessionId, {
                 [streamKindProp]: primaryStream,
             });
-            // now, dispose the previous stream if it exists
             if (previousStream) {
+                if (isSelfSub && !this.trackedStreams.has(previousStream)) {
+                    // this is the local capture stream, we don't want to dispose it
+                    this.logger.debug(`[onTrack]: Skipping cleanup of previous ${e.track.kind} stream for userId: ${participantToUpdate.userId} because it is not tracked`);
+                    return;
+                }
                 this.logger.info(`[onTrack]: Cleaning up previous remote ${track.kind} tracks for userId: ${participantToUpdate.userId}`);
                 previousStream.getTracks().forEach((t) => {
                     t.stop();
@@ -13916,6 +13947,7 @@ class Call {
         // maintain the order of publishing tracks to restore them after a reconnection
         // it shouldn't contain duplicates
         this.trackPublishOrder = [];
+        this.selfSubEnabled = false;
         this.hasJoinedOnce = false;
         this.deviceSettingsAppliedOnce = false;
         this.initialized = false;
@@ -14265,6 +14297,30 @@ class Call {
                 await Promise.all(stopOnLeavePromises);
             });
         };
+        /**
+         * The largest video publish dimension across the current publish options.
+         *
+         * @internal
+         */
+        this.getMaxVideoPublishDimension = () => {
+            if (!this.currentPublishOptions)
+                return undefined;
+            let maxDimension;
+            let maxArea = 0;
+            for (const opt of this.currentPublishOptions) {
+                if (opt.trackType !== TrackType.VIDEO)
+                    continue;
+                const dim = opt.videoDimension;
+                if (!dim || !dim.width || !dim.height)
+                    continue;
+                const area = dim.width * dim.height;
+                if (area > maxArea) {
+                    maxDimension = dim;
+                    maxArea = area;
+                }
+            }
+            return maxDimension;
+        };
         /**
          * Update from the call response from the "call.ring" event
          * @internal
@@ -14411,7 +14467,7 @@ class Call {
          *
          * @returns a promise which resolves once the call join-flow has finished.
          */
-        this.join = async ({ maxJoinRetries = 3, joinResponseTimeout, rpcRequestTimeout, ...data } = {}) => {
+        this.join = async ({ maxJoinRetries = 3, joinResponseTimeout, rpcRequestTimeout, selfSubEnabled = false, ...data } = {}) => {
             const callingState = this.state.callingState;
             if ([CallingState.JOINED, CallingState.JOINING].includes(callingState)) {
                 throw new Error(`Illegal State: call.join() shall be called only once`);
@@ -14419,6 +14475,9 @@ class Call {
             if (data?.ring) {
                 this.ringingSubject.next(true);
             }
+            // we need this to be set before the callingx.joinCall() is
+            // called to avoid registering the test call in the CallKit/Telecom
+            this.selfSubEnabled = selfSubEnabled;
             const callingX = globalThis.streamRNVideoSDK?.callingX;
             if (callingX) {
                 // for Android/iOS, we need to start the call in the callingx library as soon as possible
@@ -14555,7 +14614,7 @@ class Call {
                 ]);
                 const isReconnecting = this.reconnectStrategy !== WebsocketReconnectStrategy.UNSPECIFIED;
                 const reconnectDetails = isReconnecting
-                    ? this.getReconnectDetails(data?.migrating_from, previousSessionId)
+                    ? this.getReconnectDetails(previousSfuClient?.edgeName, previousSessionId)
                     : undefined;
                 const preferredPublishOptions = !isReconnecting
                     ? this.getPreferredPublishOptions()
@@ -14808,7 +14867,9 @@ class Call {
                 if (closePreviousInstances && this.publisher) {
                     await this.publisher.dispose();
                 }
-                this.publisher = new Publisher(basePeerConnectionOptions, publishOptions);
+                this.publisher = new Publisher(basePeerConnectionOptions, publishOptions, {
+                    selfSubEnabled: this.selfSubEnabled,
+                });
             }
             this.statsReporter?.stop();
             if (this.statsReportingIntervalInMs > 0) {
@@ -14924,6 +14985,7 @@ class Call {
                 const reconnectStartTime = Date.now();
                 this.reconnectStrategy = strategy;
                 this.reconnectReason = reason;
+                const sfuRejoinFailures = new Map();
                 const markAsReconnectingFailed = async () => {
                     try {
                         // attempt to fetch the call data from the server, as the call
@@ -14982,7 +15044,8 @@ class Call {
                     if (this.reconnectStrategy !== WebsocketReconnectStrategy.FAST) {
                         this.reconnectAttempts++;
                     }
-                    const currentStrategy = WebsocketReconnectStrategy[this.reconnectStrategy];
+                    const attemptedStrategy = this.reconnectStrategy;
+                    const currentStrategy = WebsocketReconnectStrategy[attemptedStrategy];
                     try {
                         // wait until the network is available
                         await this.networkAvailableTask?.promise;
@@ -14995,9 +15058,24 @@ class Call {
                             case WebsocketReconnectStrategy.FAST:
                                 await this.reconnectFast();
                                 break;
-                            case WebsocketReconnectStrategy.REJOIN:
-                                await this.reconnectRejoin();
+                            case WebsocketReconnectStrategy.REJOIN: {
+                                const confirmedBadSfus = Array.from(sfuRejoinFailures)
+                                    .filter(([, failures]) => failures >= 2)
+                                    .map(([sfu]) => sfu);
+                                if (this.joinCallData && confirmedBadSfus.length) {
+                                    this.joinCallData.migrating_from =
+                                        confirmedBadSfus[confirmedBadSfus.length - 1];
+                                    this.joinCallData.migrating_from_list = confirmedBadSfus;
+                                }
+                                try {
+                                    await this.reconnectRejoin();
+                                }
+                                finally {
+                                    delete this.joinCallData?.migrating_from;
+                                    delete this.joinCallData?.migrating_from_list;
+                                }
                                 break;
+                            }
                             case WebsocketReconnectStrategy.MIGRATE:
                                 await this.reconnectMigrate();
                                 break;
@@ -15010,6 +15088,15 @@ class Call {
                         break; // do-while loop, reconnection worked, exit the loop
                     }
                     catch (error) {
+                        if (attemptedStrategy === WebsocketReconnectStrategy.REJOIN) {
+                            const failedSfu = this.credentials?.server.edge_name;
+                            if (failedSfu) {
+                                const switchSfu = error instanceof SfuJoinError &&
+                                    SfuJoinError.isJoinErrorCode(error.errorEvent);
+                                const failures = (sfuRejoinFailures.get(failedSfu) ?? 0) + 1;
+                                sfuRejoinFailures.set(failedSfu, switchSfu ? Math.max(failures, 2) : failures);
+                            }
+                        }
                         if (this.state.callingState === CallingState.OFFLINE) {
                             this.logger.debug(`[Reconnect] Can't reconnect while offline, stopping reconnection attempts`);
                             break;
@@ -15205,6 +15292,8 @@ class Call {
                     this.state.setCallingState(CallingState.OFFLINE);
                 }
                 else {
+                    if (!this.networkAvailableTask)
+                        return;
                     this.logger.debug('[Reconnect] Going online');
                     this.sfuClient?.close(StreamSfuClient.DISPOSE_OLD_SOCKET, 'Closing WS to reconnect after going online');
                     // we went online, release the previous waiters and reset the state
@@ -16276,6 +16365,12 @@ class Call {
     get currentUserId() {
         return this.clientStore.connectedUser?.id;
     }
+    /**
+     * A flag indicating whether self-subscription is enabled for the call.
+     */
+    get isSelfSubEnabled() {
+        return this.selfSubEnabled;
+    }
     /**
      * A flag indicating whether the call was created by the current user.
      */
@@ -17463,11 +17558,11 @@ class StreamClient {
             return await this.wsConnection.connect(this.defaultWSTimeout);
         };
         this.getSdkVersion = () => this.options.clientAppIdentifier?.sdkVersion ||
-            "1.53.2";
+            "1.54.1-beta.0";
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.53.2", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.54.1-beta.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -18145,6 +18240,8 @@ class ClientEventReporter {
             };
         };
         this.send = (body) => {
+            if (!this.enabled)
+                return;
             void this.sendWithRetry(body);
         };
         this.sendWithRetry = async (body) => {
@@ -18170,6 +18267,7 @@ class ClientEventReporter {
             return false;
         };
         this.streamClient = options.streamClient;
+        this.enabled = options.enabled ?? true;
     }
 }
 const readPermissionStatus = (permission) => {
@@ -18650,6 +18748,7 @@ class StreamVideoClient {
         this.streamClient = createCoordinatorClient(apiKey, clientOptions);
         this.clientEventReporter = new ClientEventReporter({
             streamClient: this.streamClient,
+            enabled: clientOptions?.clientEventsReportingEnabled ?? true,
         });
         this.writeableStateStore = new StreamVideoWriteableStateStore();
         this.readOnlyStateStore = new StreamVideoReadOnlyStateStore(this.writeableStateStore);