@stream-io/video-client 1.3.1 → 1.4.1

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+### [1.4.1](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.4.0...@stream-io/video-client-1.4.1) (2024-06-19)
+
+
+### Bug Fixes
+
+* perform full reconnect if ice restart fails ([#1408](https://github.com/GetStream/stream-video-js/issues/1408)) ([641df7e](https://github.com/GetStream/stream-video-js/commit/641df7e50522452171498a9cf3de893472fe7b7b))
+
+## [1.4.0](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.3.1...@stream-io/video-client-1.4.0) (2024-06-19)
+
+
+### Features
+
+* **client:** support join_ahead_time_seconds field in the BackstageSettingsRequest struct ([#1397](https://github.com/GetStream/stream-video-js/issues/1397)) ([ded7a23](https://github.com/GetStream/stream-video-js/commit/ded7a23b1d112b496821bee95fe073f57bd51783))
+
 ### [1.3.1](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.3.0...@stream-io/video-client-1.3.1) (2024-06-12)
 
 

package/dist/index.browser.es.js

@@ -8255,8 +8255,9 @@ class Publisher {
      * @param isDtxEnabled whether DTX is enabled.
      * @param isRedEnabled whether RED is enabled.
      * @param iceRestartDelay the delay in milliseconds to wait before restarting ICE once connection goes to `disconnected` state.
+     * @param onUnrecoverableError a callback to call when an unrecoverable error occurs.
      */
-    constructor({ connectionConfig, sfuClient, dispatcher, state, isDtxEnabled, isRedEnabled, iceRestartDelay = 2500, }) {
+    constructor({ connectionConfig, sfuClient, dispatcher, state, isDtxEnabled, isRedEnabled, iceRestartDelay = 2500, onUnrecoverableError, }) {
         this.transceiverRegistry = {
             [TrackType.AUDIO]: undefined,
             [TrackType.VIDEO]: undefined,
@@ -8777,15 +8778,16 @@ class Publisher {
             logger$3('debug', `ICE Connection state changed to`, state);
             const hasNetworkConnection = this.state.callingState !== CallingState.OFFLINE;
             if (state === 'failed') {
-                logger$3('warn', `Attempting to restart ICE`);
+                logger$3('debug', `Attempting to restart ICE`);
                 this.restartIce().catch((e) => {
                     logger$3('error', `ICE restart error`, e);
+                    this.onUnrecoverableError?.();
                 });
             }
             else if (state === 'disconnected' && hasNetworkConnection) {
                 // when in `disconnected` state, the browser may recover automatically,
                 // hence, we delay the ICE restart
-                logger$3('warn', `Scheduling ICE restart in ${this.iceRestartDelay} ms.`);
+                logger$3('debug', `Scheduling ICE restart in ${this.iceRestartDelay} ms.`);
                 this.iceRestartTimeout = setTimeout(() => {
                     // check if the state is still `disconnected` or `failed`
                     // as the connection may have recovered (or failed) in the meantime
@@ -8793,6 +8795,7 @@ class Publisher {
                         this.pc.iceConnectionState === 'failed') {
                         this.restartIce().catch((e) => {
                             logger$3('error', `ICE restart error`, e);
+                            this.onUnrecoverableError?.();
                         });
                     }
                     else {
@@ -8820,11 +8823,13 @@ class Publisher {
         this.isDtxEnabled = isDtxEnabled;
         this.isRedEnabled = isRedEnabled;
         this.iceRestartDelay = iceRestartDelay;
+        this.onUnrecoverableError = onUnrecoverableError;
         this.unsubscribeOnIceRestart = dispatcher.on('iceRestart', (iceRestart) => {
             if (iceRestart.peerType !== PeerType.PUBLISHER_UNSPECIFIED)
                 return;
             this.restartIce().catch((err) => {
                 logger$3('warn', `ICERestart failed`, err);
+                this.onUnrecoverableError?.();
             });
         });
     }
@@ -8854,8 +8859,9 @@ class Subscriber {
      * @param state the state of the call.
      * @param connectionConfig the connection configuration to use.
      * @param iceRestartDelay the delay in milliseconds to wait before restarting ICE when connection goes to `disconnected` state.
+     * @param onUnrecoverableError a callback to call when an unrecoverable error occurs.
      */
-    constructor({ sfuClient, dispatcher, state, connectionConfig, iceRestartDelay = 2500, }) {
+    constructor({ sfuClient, dispatcher, state, connectionConfig, iceRestartDelay = 2500, onUnrecoverableError, }) {
         this.isIceRestarting = false;
         /**
          * Creates a new `RTCPeerConnection` instance with the given configuration.
@@ -8965,6 +8971,10 @@ class Subscriber {
                 logger$2('debug', 'ICE restart is already in progress');
                 return;
             }
+            if (this.pc.connectionState === 'new') {
+                logger$2('debug', `ICE connection is not yet established, skipping restart.`);
+                return;
+            }
             const previousIsIceRestarting = this.isIceRestarting;
             try {
                 this.isIceRestarting = true;
@@ -8985,17 +8995,18 @@ class Subscriber {
             const participantToUpdate = this.state.participants.find((p) => p.trackLookupPrefix === trackId);
             logger$2('debug', `[onTrack]: Got remote ${trackType} track for userId: ${participantToUpdate?.userId}`, e.track.id, e.track);
             if (!participantToUpdate) {
-                logger$2('error', `[onTrack]: Received track for unknown participant: ${trackId}`, e);
+                logger$2('warn', `[onTrack]: Received track for unknown participant: ${trackId}`, e);
                 return;
             }
+            const trackDebugInfo = `${participantToUpdate.userId} ${trackType}:${trackId}`;
             e.track.addEventListener('mute', () => {
-                logger$2('info', `[onTrack]: Track muted: ${participantToUpdate.userId} ${trackType}:${trackId}`);
+                logger$2('info', `[onTrack]: Track muted: ${trackDebugInfo}`);
             });
             e.track.addEventListener('unmute', () => {
-                logger$2('info', `[onTrack]: Track unmuted: ${participantToUpdate.userId} ${trackType}:${trackId}`);
+                logger$2('info', `[onTrack]: Track unmuted: ${trackDebugInfo}`);
             });
             e.track.addEventListener('ended', () => {
-                logger$2('info', `[onTrack]: Track ended: ${participantToUpdate.userId} ${trackType}:${trackId}`);
+                logger$2('info', `[onTrack]: Track ended: ${trackDebugInfo}`);
             });
             const streamKindProp = {
                 TRACK_TYPE_AUDIO: 'audioStream',
@@ -9065,15 +9076,16 @@ class Subscriber {
                 return;
             const hasNetworkConnection = this.state.callingState !== CallingState.OFFLINE;
             if (state === 'failed') {
-                logger$2('warn', `Attempting to restart ICE`);
+                logger$2('debug', `Attempting to restart ICE`);
                 this.restartIce().catch((e) => {
                     logger$2('error', `ICE restart failed`, e);
+                    this.onUnrecoverableError?.();
                 });
             }
             else if (state === 'disconnected' && hasNetworkConnection) {
                 // when in `disconnected` state, the browser may recover automatically,
                 // hence, we delay the ICE restart
-                logger$2('warn', `Scheduling ICE restart in ${this.iceRestartDelay} ms.`);
+                logger$2('debug', `Scheduling ICE restart in ${this.iceRestartDelay} ms.`);
                 this.iceRestartTimeout = setTimeout(() => {
                     // check if the state is still `disconnected` or `failed`
                     // as the connection may have recovered (or failed) in the meantime
@@ -9081,12 +9093,13 @@ class Subscriber {
                         this.pc.iceConnectionState === 'failed') {
                         this.restartIce().catch((e) => {
                             logger$2('error', `ICE restart failed`, e);
+                            this.onUnrecoverableError?.();
                         });
                     }
                     else {
                         logger$2('debug', `Scheduled ICE restart: connection recovered, canceled.`);
                     }
-                }, 5000);
+                }, this.iceRestartDelay);
             }
         };
         this.onIceGatheringStateChange = () => {
@@ -9102,6 +9115,7 @@ class Subscriber {
         this.sfuClient = sfuClient;
         this.state = state;
         this.iceRestartDelay = iceRestartDelay;
+        this.onUnrecoverableError = onUnrecoverableError;
         this.pc = this.createPeerConnection(connectionConfig);
         this.unregisterOnSubscriberOffer = dispatcher.on('subscriberOffer', (subscriberOffer) => {
             this.negotiate(subscriberOffer).catch((err) => {
@@ -9113,6 +9127,7 @@ class Subscriber {
                 return;
             this.restartIce().catch((err) => {
                 logger$2('warn', `ICERestart failed`, err);
+                this.onUnrecoverableError?.();
             });
         });
     }
@@ -12795,6 +12810,11 @@ class Call {
                     dispatcher: this.dispatcher,
                     state: this.state,
                     connectionConfig,
+                    onUnrecoverableError: () => {
+                        reconnect('full', 'unrecoverable subscriber error').catch((err) => {
+                            this.logger('debug', '[Rejoin]: Rejoin failed', err);
+                        });
+                    },
                 });
             }
             // anonymous users can't publish anything hence, there is no need
@@ -12811,6 +12831,11 @@ class Call {
                     connectionConfig,
                     isDtxEnabled,
                     isRedEnabled,
+                    onUnrecoverableError: () => {
+                        reconnect('full', 'unrecoverable publisher error').catch((err) => {
+                            this.logger('debug', '[Rejoin]: Rejoin failed', err);
+                        });
+                    },
                 });
             }
             if (!this.statsReporter) {
@@ -15384,7 +15409,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "1.3.1" ;
+            const version = "1.4.1" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };