@stream-io/video-client 1.31.0 → 1.32.0

package/dist/src/StreamVideoClient.d.ts

@@ -30,6 +30,7 @@ export declare class StreamVideoClient {
     private eventHandlersToUnregister;
     private readonly connectionConcurrencyTag;
     private static _instances;
+    private rejectCallWhenBusy;
     /**
      * You should create only one instance of `StreamVideoClient`.
      */
@@ -176,4 +177,5 @@ export declare class StreamVideoClient {
      * @param tokenOrProvider a token or a function that returns a token.
      */
     private connectAnonymousUser;
+    private shouldRejectCall;
 }

package/dist/src/coordinator/connection/types.d.ts

@@ -149,6 +149,10 @@ export type StreamClientOptions = Partial<AxiosRequestConfig> & {
      * @param allErrors all errors.
      */
     onConnectUserError?: (lastError: Error, allErrors: Error[]) => void;
+    /**
+     * When set to true, the incoming calls are rejected when the user is busy in an another call.
+     */
+    rejectCallWhenBusy?: boolean;
 };
 export type ClientAppIdentifier = {
     sdkName?: 'react' | 'react-native' | 'plain-javascript' | (string & {});

package/dist/src/gen/video/sfu/event/events.d.ts

@@ -420,6 +420,14 @@ export interface JoinRequest {
      * @generated from protobuf field: string session_id = 2;
      */
     sessionId: string;
+    /**
+     * user_session id can change during reconnects, this helps us to
+     * identify the user across reconnects and should remain consistent until the user explicitly
+     * disconnects, is kicked or the call is ended.
+     *
+     * @generated from protobuf field: string unified_session_id = 13;
+     */
+    unifiedSessionId: string;
     /**
      * dumb SDP that allow us to extract subscriber's decode codecs
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.31.0",
+  "version": "1.32.0",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",

package/src/Call.ts

@@ -874,8 +874,6 @@ export class Call {
       throw new Error(`Illegal State: call.join() shall be called only once`);
     }
 
-    this.state.setCallingState(CallingState.JOINING);
-
     // we will count the number of join failures per SFU.
     // once the number of failures reaches 2, we will piggyback on the `migrating_from`
     // field to force the coordinator to provide us another SFU
@@ -905,8 +903,6 @@ export class Call {
         }
 
         if (attempt === maxJoinRetries - 1) {
-          // restore the previous call state if the join-flow fails
-          this.state.setCallingState(callingState);
           throw err;
         }
       }
@@ -981,6 +977,7 @@ export class Call {
           })
         : previousSfuClient;
     this.sfuClient = sfuClient;
+    this.unifiedSessionId ??= sfuClient.sessionId;
     this.dynascaleManager.setSfuClient(sfuClient);
 
     const clientDetails = await getClientDetails();
@@ -1008,6 +1005,7 @@ export class Call {
       try {
         const { callState, fastReconnectDeadlineSeconds, publishOptions } =
           await sfuClient.join({
+            unifiedSessionId: this.unifiedSessionId,
             subscriberSdp,
             publisherSdp,
             clientDetails,
@@ -1061,6 +1059,7 @@ export class Call {
         statsOptions,
         publishOptions: this.currentPublishOptions || [],
         closePreviousInstances: !performingMigration,
+        unifiedSessionId: this.unifiedSessionId,
       });
     }
 
@@ -1222,6 +1221,7 @@ export class Call {
     clientDetails: ClientDetails;
     publishOptions: PublishOption[];
     closePreviousInstances: boolean;
+    unifiedSessionId: string;
   }) => {
     const {
       sfuClient,
@@ -1230,6 +1230,7 @@ export class Call {
       statsOptions,
       publishOptions,
       closePreviousInstances,
+      unifiedSessionId,
     } = opts;
     const { enable_rtc_stats: enableTracing } = statsOptions;
     if (closePreviousInstances && this.subscriber) {
@@ -1288,7 +1289,6 @@ export class Call {
     this.tracer.setEnabled(enableTracing);
     this.sfuStatsReporter?.stop();
     if (statsOptions?.reporting_interval_ms > 0) {
-      this.unifiedSessionId ??= sfuClient.sessionId;
       this.sfuStatsReporter = new SfuStatsReporter(sfuClient, {
         clientDetails,
         options: statsOptions,
@@ -1298,7 +1298,7 @@ export class Call {
         camera: this.camera,
         state: this.state,
         tracer: this.tracer,
-        unifiedSessionId: this.unifiedSessionId,
+        unifiedSessionId,
       });
       this.sfuStatsReporter.start();
     }

package/src/StreamVideoClient.ts

@@ -1,6 +1,7 @@
 import { Call } from './Call';
 import { StreamClient } from './coordinator/connection/client';
 import {
+  CallingState,
   StreamVideoReadOnlyStateStore,
   StreamVideoWriteableStateStore,
 } from './store';
@@ -74,6 +75,7 @@ export class StreamVideoClient {
   );
 
   private static _instances = new Map<string, StreamVideoClient>();
+  private rejectCallWhenBusy = false;
 
   /**
    * You should create only one instance of `StreamVideoClient`.
@@ -95,6 +97,7 @@ export class StreamVideoClient {
     setLogger(rootLogger, clientOptions?.logLevel || 'warn');
 
     this.logger = getLogger(['client']);
+    this.rejectCallWhenBusy = clientOptions?.rejectCallWhenBusy ?? false;
 
     this.streamClient = createCoordinatorClient(apiKey, clientOptions);
 
@@ -206,7 +209,18 @@ export class StreamVideoClient {
         let call = this.writeableStateStore.findCall(e.call.type, e.call.id);
         if (call) {
           if (ringing) {
-            await call.updateFromRingingEvent(e as CallRingEvent);
+            if (this.shouldRejectCall(call.cid)) {
+              this.logger(
+                'info',
+                `Leaving call with busy reject reason ${call.cid} because user is busy`,
+              );
+              // remove the instance from the state store
+              await call.leave();
+              // explicitly reject the call with busy reason as calling state was not ringing before and leave would not call it therefore
+              await call.reject('busy');
+            } else {
+              await call.updateFromRingingEvent(e as CallRingEvent);
+            }
           } else {
             call.state.updateFromCallResponse(e.call);
           }
@@ -221,11 +235,21 @@ export class StreamVideoClient {
           clientStore: this.writeableStateStore,
           ringing,
         });
-        call.state.updateFromCallResponse(e.call);
 
         if (ringing) {
-          await call.get();
+          if (this.shouldRejectCall(call.cid)) {
+            this.logger(
+              'info',
+              `Rejecting call ${call.cid} because user is busy`,
+            );
+            // call is not in the state store yet, so just reject api is enough
+            await call.reject('busy');
+          } else {
+            await call.updateFromRingingEvent(e as CallRingEvent);
+            await call.get();
+          }
         } else {
+          call.state.updateFromCallResponse(e.call);
           this.writeableStateStore.registerCall(call);
           this.logger('info', `New call created and registered: ${call.cid}`);
         }
@@ -572,4 +596,19 @@ export class StreamVideoClient {
       this.streamClient.connectAnonymousUser(user, tokenOrProvider),
     );
   };
+
+  private shouldRejectCall = (currentCallId: string) => {
+    if (!this.rejectCallWhenBusy) return false;
+
+    const hasOngoingRingingCall = this.state.calls.some(
+      (c) =>
+        c.cid !== currentCallId &&
+        c.ringing &&
+        c.state.callingState !== CallingState.IDLE &&
+        c.state.callingState !== CallingState.LEFT &&
+        c.state.callingState !== CallingState.RECONNECTING_FAILED,
+    );
+
+    return hasOngoingRingingCall;
+  };
 }

package/src/coordinator/connection/types.ts

@@ -216,6 +216,11 @@ export type StreamClientOptions = Partial<AxiosRequestConfig> & {
    * @param allErrors all errors.
    */
   onConnectUserError?: (lastError: Error, allErrors: Error[]) => void;
+
+  /**
+   * When set to true, the incoming calls are rejected when the user is busy in an another call.
+   */
+  rejectCallWhenBusy?: boolean;
 };
 
 export type ClientAppIdentifier = {

package/src/gen/video/sfu/event/events.ts

@@ -471,6 +471,14 @@ export interface JoinRequest {
    * @generated from protobuf field: string session_id = 2;
    */
   sessionId: string;
+  /**
+   * user_session id can change during reconnects, this helps us to
+   * identify the user across reconnects and should remain consistent until the user explicitly
+   * disconnects, is kicked or the call is ended.
+   *
+   * @generated from protobuf field: string unified_session_id = 13;
+   */
+  unifiedSessionId: string;
   /**
    * dumb SDP that allow us to extract subscriber's decode codecs
    *
@@ -1353,6 +1361,12 @@ class JoinRequest$Type extends MessageType<JoinRequest> {
     super('stream.video.sfu.event.JoinRequest', [
       { no: 1, name: 'token', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
       { no: 2, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
+      {
+        no: 13,
+        name: 'unified_session_id',
+        kind: 'scalar',
+        T: 9 /*ScalarType.STRING*/,
+      },
       {
         no: 3,
         name: 'subscriber_sdp',