@stream-io/video-client 1.4.0 → 1.4.2

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+### [1.4.2](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-1.4.1...@stream-io/video-client-1.4.2) (2024-06-24)
+
+
+### Bug Fixes
+
+* support for portrait mode recording ([#1418](https://github.com/GetStream/stream-video-js/issues/1418)) ([70a304d](https://github.com/GetStream/stream-video-js/commit/70a304d3f20d93ecfffc97794e8e4974acf88e9a))
+
+### [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)
 
 

package/dist/index.browser.es.js

@@ -122,6 +122,11 @@ const RecordSettingsRequestQualityEnum = {
     _720P: '720p',
     _1080P: '1080p',
     _1440P: '1440p',
+    PORTRAIT_360X640: 'portrait-360x640',
+    PORTRAIT_480X854: 'portrait-480x854',
+    PORTRAIT_720X1280: 'portrait-720x1280',
+    PORTRAIT_1080X1920: 'portrait-1080x1920',
+    PORTRAIT_1440X2560: 'portrait-1440x2560',
 };
 /**
  * @export
@@ -8255,8 +8260,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 +8783,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 +8800,7 @@ class Publisher {
                         this.pc.iceConnectionState === 'failed') {
                         this.restartIce().catch((e) => {
                             logger$3('error', `ICE restart error`, e);
+                            this.onUnrecoverableError?.();
                         });
                     }
                     else {
@@ -8820,11 +8828,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 +8864,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 +8976,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 +9000,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 +9081,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 +9098,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 +9120,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 +9132,7 @@ class Subscriber {
                 return;
             this.restartIce().catch((err) => {
                 logger$2('warn', `ICERestart failed`, err);
+                this.onUnrecoverableError?.();
             });
         });
     }
@@ -12795,6 +12815,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 +12836,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 +15414,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "1.4.0" ;
+            const version = "1.4.2" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };