@stream-io/video-client 1.4.0 → 1.4.2

package/dist/src/gen/coordinator/index.d.ts

@@ -4999,6 +4999,11 @@ export declare const RecordSettingsRequestQualityEnum: {
     readonly _720P: "720p";
     readonly _1080P: "1080p";
     readonly _1440P: "1440p";
+    readonly PORTRAIT_360X640: "portrait-360x640";
+    readonly PORTRAIT_480X854: "portrait-480x854";
+    readonly PORTRAIT_720X1280: "portrait-720x1280";
+    readonly PORTRAIT_1080X1920: "portrait-1080x1920";
+    readonly PORTRAIT_1440X2560: "portrait-1440x2560";
 };
 export type RecordSettingsRequestQualityEnum = (typeof RecordSettingsRequestQualityEnum)[keyof typeof RecordSettingsRequestQualityEnum];
 /**

package/dist/src/rtc/Publisher.d.ts

@@ -12,6 +12,7 @@ export type PublisherConstructorOpts = {
     isDtxEnabled: boolean;
     isRedEnabled: boolean;
     iceRestartDelay?: number;
+    onUnrecoverableError?: () => void;
 };
 /**
  * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
@@ -35,6 +36,7 @@ export declare class Publisher {
     private readonly isDtxEnabled;
     private readonly isRedEnabled;
     private readonly unsubscribeOnIceRestart;
+    private readonly onUnrecoverableError?;
     private readonly iceRestartDelay;
     private isIceRestarting;
     private iceRestartTimeout?;
@@ -59,8 +61,9 @@ export declare 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, }: PublisherConstructorOpts);
+    constructor({ connectionConfig, sfuClient, dispatcher, state, isDtxEnabled, isRedEnabled, iceRestartDelay, onUnrecoverableError, }: PublisherConstructorOpts);
     private createPeerConnection;
     /**
      * Closes the publisher PeerConnection and cleans up the resources.

package/dist/src/rtc/Subscriber.d.ts

@@ -7,6 +7,7 @@ export type SubscriberOpts = {
     state: CallState;
     connectionConfig?: RTCConfiguration;
     iceRestartDelay?: number;
+    onUnrecoverableError?: () => void;
 };
 /**
  * A wrapper around the `RTCPeerConnection` that handles the incoming
@@ -18,6 +19,7 @@ export declare class Subscriber {
     private state;
     private readonly unregisterOnSubscriberOffer;
     private readonly unregisterOnIceRestart;
+    private readonly onUnrecoverableError?;
     private readonly iceRestartDelay;
     private isIceRestarting;
     private iceRestartTimeout?;
@@ -36,8 +38,9 @@ export declare 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, }: SubscriberOpts);
+    constructor({ sfuClient, dispatcher, state, connectionConfig, iceRestartDelay, onUnrecoverableError, }: SubscriberOpts);
     /**
      * Creates a new `RTCPeerConnection` instance with the given configuration.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "packageManager": "yarn@3.2.4",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",

package/src/Call.ts

@@ -1014,6 +1014,11 @@ export class Call {
         dispatcher: this.dispatcher,
         state: this.state,
         connectionConfig,
+        onUnrecoverableError: () => {
+          reconnect('full', 'unrecoverable subscriber error').catch((err) => {
+            this.logger('debug', '[Rejoin]: Rejoin failed', err);
+          });
+        },
       });
     }
 
@@ -1031,6 +1036,11 @@ export class Call {
         connectionConfig,
         isDtxEnabled,
         isRedEnabled,
+        onUnrecoverableError: () => {
+          reconnect('full', 'unrecoverable publisher error').catch((err) => {
+            this.logger('debug', '[Rejoin]: Rejoin failed', err);
+          });
+        },
       });
     }
 

package/src/gen/coordinator/index.ts

@@ -4985,6 +4985,11 @@ export 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',
 } as const;
 export type RecordSettingsRequestQualityEnum =
   (typeof RecordSettingsRequestQualityEnum)[keyof typeof RecordSettingsRequestQualityEnum];

package/src/rtc/Publisher.ts

@@ -36,6 +36,7 @@ export type PublisherConstructorOpts = {
   isDtxEnabled: boolean;
   isRedEnabled: boolean;
   iceRestartDelay?: number;
+  onUnrecoverableError?: () => void;
 };
 
 /**
@@ -94,6 +95,7 @@ export class Publisher {
   private readonly isRedEnabled: boolean;
 
   private readonly unsubscribeOnIceRestart: () => void;
+  private readonly onUnrecoverableError?: () => void;
 
   private readonly iceRestartDelay: number;
   private isIceRestarting = false;
@@ -127,6 +129,7 @@ export 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,
@@ -136,6 +139,7 @@ export class Publisher {
     isDtxEnabled,
     isRedEnabled,
     iceRestartDelay = 2500,
+    onUnrecoverableError,
   }: PublisherConstructorOpts) {
     this.pc = this.createPeerConnection(connectionConfig);
     this.sfuClient = sfuClient;
@@ -143,11 +147,13 @@ export 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('warn', `ICERestart failed`, err);
+        this.onUnrecoverableError?.();
       });
     });
   }
@@ -813,14 +819,15 @@ export class Publisher {
       this.state.callingState !== CallingState.OFFLINE;
 
     if (state === 'failed') {
-      logger('warn', `Attempting to restart ICE`);
+      logger('debug', `Attempting to restart ICE`);
       this.restartIce().catch((e) => {
         logger('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('warn', `Scheduling ICE restart in ${this.iceRestartDelay} ms.`);
+      logger('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
@@ -830,6 +837,7 @@ export class Publisher {
         ) {
           this.restartIce().catch((e) => {
             logger('error', `ICE restart error`, e);
+            this.onUnrecoverableError?.();
           });
         } else {
           logger(

package/src/rtc/Subscriber.ts

@@ -12,6 +12,7 @@ export type SubscriberOpts = {
   state: CallState;
   connectionConfig?: RTCConfiguration;
   iceRestartDelay?: number;
+  onUnrecoverableError?: () => void;
 };
 
 const logger = getLogger(['Subscriber']);
@@ -27,6 +28,7 @@ export class Subscriber {
 
   private readonly unregisterOnSubscriberOffer: () => void;
   private readonly unregisterOnIceRestart: () => void;
+  private readonly onUnrecoverableError?: () => void;
 
   private readonly iceRestartDelay: number;
   private isIceRestarting = false;
@@ -53,6 +55,7 @@ export 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,
@@ -60,10 +63,12 @@ export class Subscriber {
     state,
     connectionConfig,
     iceRestartDelay = 2500,
+    onUnrecoverableError,
   }: SubscriberOpts) {
     this.sfuClient = sfuClient;
     this.state = state;
     this.iceRestartDelay = iceRestartDelay;
+    this.onUnrecoverableError = onUnrecoverableError;
 
     this.pc = this.createPeerConnection(connectionConfig);
 
@@ -80,6 +85,7 @@ export class Subscriber {
       if (iceRestart.peerType !== PeerType.SUBSCRIBER) return;
       this.restartIce().catch((err) => {
         logger('warn', `ICERestart failed`, err);
+        this.onUnrecoverableError?.();
       });
     });
   }
@@ -223,6 +229,13 @@ export class Subscriber {
       logger('debug', 'ICE restart is already in progress');
       return;
     }
+    if (this.pc.connectionState === 'new') {
+      logger(
+        'debug',
+        `ICE connection is not yet established, skipping restart.`,
+      );
+      return;
+    }
     const previousIsIceRestarting = this.isIceRestarting;
     try {
       this.isIceRestarting = true;
@@ -251,32 +264,24 @@ export class Subscriber {
     );
     if (!participantToUpdate) {
       logger(
-        'error',
+        'warn',
         `[onTrack]: Received track for unknown participant: ${trackId}`,
         e,
       );
       return;
     }
 
+    const trackDebugInfo = `${participantToUpdate.userId} ${trackType}:${trackId}`;
     e.track.addEventListener('mute', () => {
-      logger(
-        'info',
-        `[onTrack]: Track muted: ${participantToUpdate.userId} ${trackType}:${trackId}`,
-      );
+      logger('info', `[onTrack]: Track muted: ${trackDebugInfo}`);
     });
 
     e.track.addEventListener('unmute', () => {
-      logger(
-        'info',
-        `[onTrack]: Track unmuted: ${participantToUpdate.userId} ${trackType}:${trackId}`,
-      );
+      logger('info', `[onTrack]: Track unmuted: ${trackDebugInfo}`);
     });
 
     e.track.addEventListener('ended', () => {
-      logger(
-        'info',
-        `[onTrack]: Track ended: ${participantToUpdate.userId} ${trackType}:${trackId}`,
-      );
+      logger('info', `[onTrack]: Track ended: ${trackDebugInfo}`);
     });
 
     const streamKindProp = (
@@ -366,14 +371,15 @@ export class Subscriber {
       this.state.callingState !== CallingState.OFFLINE;
 
     if (state === 'failed') {
-      logger('warn', `Attempting to restart ICE`);
+      logger('debug', `Attempting to restart ICE`);
       this.restartIce().catch((e) => {
         logger('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('warn', `Scheduling ICE restart in ${this.iceRestartDelay} ms.`);
+      logger('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
@@ -383,6 +389,7 @@ export class Subscriber {
         ) {
           this.restartIce().catch((e) => {
             logger('error', `ICE restart failed`, e);
+            this.onUnrecoverableError?.();
           });
         } else {
           logger(
@@ -390,7 +397,7 @@ export class Subscriber {
             `Scheduled ICE restart: connection recovered, canceled.`,
           );
         }
-      }, 5000);
+      }, this.iceRestartDelay);
     }
   };
 

package/src/rtc/__tests__/Subscriber.test.ts

@@ -168,6 +168,15 @@ describe('Subscriber', () => {
       expect(sfuClient.iceRestart).not.toHaveBeenCalled();
     });
 
+    it('should skip ICE restart when connection is still new', async () => {
+      sfuClient.iceRestart = vi.fn();
+      // @ts-ignore
+      subscriber['pc'].connectionState = 'new';
+
+      await subscriber.restartIce();
+      expect(sfuClient.iceRestart).not.toHaveBeenCalled();
+    });
+
     it(`should perform ICE restart when connection state changes to 'failed'`, () => {
       vi.spyOn(subscriber, 'restartIce').mockResolvedValue();
       // @ts-ignore