@stream-io/video-client 1.7.4 → 1.8.0

package/dist/src/Call.d.ts

@@ -1,7 +1,7 @@
 import { Publisher, Subscriber } from './rtc';
 import { CallState } from './store';
-import type { AcceptCallResponse, BlockUserResponse, CollectUserFeedbackResponse, EndCallResponse, GetCallResponse, GetCallStatsResponse, GetOrCreateCallRequest, GetOrCreateCallResponse, GoLiveRequest, GoLiveResponse, JoinCallResponse, ListRecordingsResponse, ListTranscriptionsResponse, MuteUsersResponse, PinRequest, PinResponse, QueryCallMembersRequest, QueryCallMembersResponse, RejectCallResponse, RequestPermissionRequest, RequestPermissionResponse, SendCallEventResponse, SendReactionRequest, SendReactionResponse, StartHLSBroadcastingResponse, StartRecordingRequest, StartRecordingResponse, StartTranscriptionRequest, StartTranscriptionResponse, StopHLSBroadcastingResponse, StopLiveResponse, StopRecordingResponse, StopTranscriptionResponse, UnblockUserResponse, UnpinRequest, UnpinResponse, UpdateCallMembersRequest, UpdateCallMembersResponse, UpdateCallRequest, UpdateCallResponse, UpdateUserPermissionsRequest, UpdateUserPermissionsResponse } from './gen/coordinator';
-import { AudioTrackType, CallConstructor, CallLeaveOptions, DebounceType, JoinCallData, PublishOptions, SubscriptionChanges, TrackMuteType, VideoTrackType } from './types';
+import type { AcceptCallResponse, BlockUserResponse, CollectUserFeedbackResponse, EndCallResponse, GetCallResponse, GetCallStatsResponse, GetOrCreateCallRequest, GetOrCreateCallResponse, GoLiveRequest, GoLiveResponse, JoinCallResponse, ListRecordingsResponse, ListTranscriptionsResponse, MuteUsersResponse, PinRequest, PinResponse, QueryCallMembersRequest, QueryCallMembersResponse, RejectCallResponse, RequestPermissionRequest, RequestPermissionResponse, SendCallEventResponse, SendReactionRequest, SendReactionResponse, StartHLSBroadcastingResponse, StartRecordingRequest, StartRecordingResponse, StartTranscriptionRequest, StartTranscriptionResponse, StopHLSBroadcastingResponse, StopLiveResponse, StopRecordingResponse, StopTranscriptionResponse, UnblockUserResponse, UnpinRequest, UnpinResponse, UpdateCallMembersRequest, UpdateCallMembersResponse, UpdateCallRequest, UpdateCallResponse, UpdateUserPermissionsRequest, UpdateUserPermissionsResponse, VideoResolution } from './gen/coordinator';
+import { AudioTrackType, CallConstructor, CallLeaveOptions, JoinCallData, PublishOptions, TrackMuteType, VideoTrackType } from './types';
 import { VideoLayerSetting } from './gen/video/sfu/event/events';
 import { TrackType } from './gen/video/sfu/models/models';
 import { DynascaleManager } from './helpers/DynascaleManager';
@@ -70,7 +70,6 @@ export declare class Call {
      * @private
      */
     private readonly dispatcher;
-    private trackSubscriptionsSubject;
     private statsReporter?;
     private sfuStatsReporter?;
     private dropTimeout;
@@ -326,17 +325,6 @@ export declare class Call {
      * @internal
      */
     notifyNoiseCancellationStopped: () => Promise<void | import("@protobuf-ts/runtime-rpc").FinishedUnaryCall<import("./gen/video/sfu/signal_rpc/signal").StopNoiseCancellationRequest, import("./gen/video/sfu/signal_rpc/signal").StopNoiseCancellationResponse> | undefined>;
-    /**
-     * Update track subscription configuration for one or more participants.
-     * You have to create a subscription for each participant for all the different kinds of tracks you want to receive.
-     * You can only subscribe for tracks after the participant started publishing the given kind of track.
-     *
-     * @param trackType the kind of subscription to update.
-     * @param changes the list of subscription changes to do.
-     * @param type the debounce type to use for the update.
-     */
-    updateSubscriptionsPartial: (trackType: VideoTrackType, changes: SubscriptionChanges, type?: DebounceType) => void;
-    private updateSubscriptions;
     /**
      * Will enhance the reported stats with additional participant-specific information (`callStatsReport$` state [store variable](./StreamVideoClient.md/#readonlystatestore)).
      * This is usually helpful when detailed stats for a specific participant are needed.
@@ -650,4 +638,20 @@ export declare class Call {
     bindCallThumbnailElement: (imageElement: HTMLImageElement, opts?: {
         fallbackImageSource?: string;
     }) => () => void;
+    /**
+     * Specify preference for incoming video resolution. The preference will
+     * be matched as close as possible, but actual resolution will depend
+     * on the video source quality and client network conditions. Will enable
+     * incoming video, if previously disabled.
+     *
+     * @param resolution preferred resolution, or `undefined` to clear preference
+     * @param sessionIds optionally specify session ids of the participants this
+     * preference has effect on. Affects all participants by default.
+     */
+    setPreferredIncomingVideoResolution: (resolution: VideoResolution | undefined, sessionIds?: string[]) => void;
+    /**
+     * Enables or disables incoming video from all remote call participants,
+     * and removes any preference for preferred resolution.
+     */
+    setIncomingVideoEnabled: (enabled: boolean) => void;
 }

package/dist/src/helpers/DynascaleManager.d.ts

@@ -1,6 +1,21 @@
-import { Call } from '../Call';
-import { AudioTrackType, VideoTrackType } from '../types';
+import { AudioTrackType, DebounceType, VideoTrackType } from '../types';
+import { VideoDimension } from '../gen/video/sfu/models/models';
 import { ViewportTracker } from './ViewportTracker';
+import type { TrackSubscriptionDetails } from '../gen/video/sfu/signal_rpc/signal';
+import type { CallState } from '../store';
+import type { StreamSfuClient } from '../StreamSfuClient';
+import { SpeakerManager } from '../devices';
+type VideoTrackSubscriptionOverride = {
+    enabled: true;
+    dimension: VideoDimension;
+} | {
+    enabled: false;
+};
+declare const globalOverrideKey: unique symbol;
+interface VideoTrackSubscriptionOverrides {
+    [sessionId: string]: VideoTrackSubscriptionOverride | undefined;
+    [globalOverrideKey]?: VideoTrackSubscriptionOverride;
+}
 /**
  * A manager class that handles dynascale related tasks like:
  *
@@ -17,13 +32,34 @@ export declare class DynascaleManager {
      */
     readonly viewportTracker: ViewportTracker;
     private logger;
-    private call;
+    private callState;
+    private speaker;
+    private sfuClient;
+    private pendingSubscriptionsUpdate;
+    private videoTrackSubscriptionOverridesSubject;
+    videoTrackSubscriptionOverrides$: import("rxjs").Observable<VideoTrackSubscriptionOverrides>;
+    incomingVideoSettings$: import("rxjs").Observable<{
+        enabled: boolean;
+        preferredResolution: VideoDimension | undefined;
+        participants: {
+            [k: string]: {
+                enabled: boolean;
+                preferredResolution: VideoDimension | undefined;
+            };
+        };
+        isParticipantVideoEnabled: (sessionId: string) => boolean;
+    }>;
     /**
      * Creates a new DynascaleManager instance.
      *
      * @param call the call to manage.
      */
-    constructor(call: Call);
+    constructor(callState: CallState, speaker: SpeakerManager);
+    setSfuClient(sfuClient: StreamSfuClient | undefined): void;
+    get trackSubscriptions(): TrackSubscriptionDetails[];
+    get videoTrackSubscriptionOverrides(): VideoTrackSubscriptionOverrides;
+    setVideoTrackSubscriptionOverrides: (override: VideoTrackSubscriptionOverride | undefined, sessionIds?: string[]) => VideoTrackSubscriptionOverrides;
+    applyTrackSubscriptions: (debounceType?: DebounceType) => void;
     /**
      * Will begin tracking the given element for visibility changes within the
      * configured viewport element (`call.setViewport`).
@@ -69,3 +105,4 @@ export declare class DynascaleManager {
      */
     bindAudioElement: (audioElement: HTMLAudioElement, sessionId: string, trackType: AudioTrackType) => (() => void) | undefined;
 }
+export {};

package/dist/src/store/CallState.d.ts

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
 import type { Patch } from './rxUtils';
 import { CallingState } from './CallingState';
-import { StreamVideoParticipant, StreamVideoParticipantPatch, StreamVideoParticipantPatches } from '../types';
+import { type StreamVideoParticipant, type StreamVideoParticipantPatch, type StreamVideoParticipantPatches, type SubscriptionChanges, VideoTrackType } from '../types';
 import { CallStatsReport } from '../stats';
 import { CallIngressResponse, CallResponse, CallSessionResponse, CallSettingsResponse, EgressResponse, MemberResponse, OwnCapability, ThumbnailResponse, UserResponse, WSEvent } from '../gen/coordinator';
 import { ReconnectDetails } from '../gen/video/sfu/event/events';
@@ -436,6 +436,16 @@ export declare class CallState {
      * @returns all participants, with all patch applied.
      */
     updateParticipants: (patch: StreamVideoParticipantPatches) => StreamVideoParticipant[];
+    /**
+     * Update track subscription configuration for one or more participants.
+     * You have to create a subscription for each participant for all the different kinds of tracks you want to receive.
+     * You can only subscribe for tracks after the participant started publishing the given kind of track.
+     *
+     * @param trackType the kind of subscription to update.
+     * @param changes the list of subscription changes to do.
+     * @param type the debounce type to use for the update.
+     */
+    updateParticipantTracks: (trackType: VideoTrackType, changes: SubscriptionChanges) => StreamVideoParticipant[];
     /**
      * Updates the call state with the data received from the server.
      *

package/package.json

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

package/src/Call.ts

@@ -8,11 +8,6 @@ import {
 } from './rtc';
 import { muteTypeToTrackType } from './rtc/helpers/tracks';
 import { toRtcConfiguration } from './rtc/helpers/rtcConfiguration';
-import {
-  hasScreenShare,
-  hasScreenShareAudio,
-  hasVideo,
-} from './helpers/participantUtils';
 import {
   registerEventHandlers,
   registerRingingCallEventHandlers,
@@ -79,30 +74,19 @@ import type {
   UpdateCallResponse,
   UpdateUserPermissionsRequest,
   UpdateUserPermissionsResponse,
+  VideoResolution,
 } from './gen/coordinator';
 import { OwnCapability } from './gen/coordinator';
 import {
   AudioTrackType,
   CallConstructor,
   CallLeaveOptions,
-  DebounceType,
   JoinCallData,
   PublishOptions,
-  StreamVideoParticipant,
-  StreamVideoParticipantPatches,
-  SubscriptionChanges,
   TrackMuteType,
   VideoTrackType,
 } from './types';
-import {
-  BehaviorSubject,
-  debounce,
-  map,
-  Subject,
-  takeWhile,
-  timer,
-} from 'rxjs';
-import { TrackSubscriptionDetails } from './gen/video/sfu/signal_rpc/signal';
+import { BehaviorSubject, Subject, takeWhile } from 'rxjs';
 import {
   ReconnectDetails,
   VideoLayerSetting,
@@ -196,7 +180,7 @@ export class Call {
   /**
    * The DynascaleManager instance.
    */
-  readonly dynascaleManager = new DynascaleManager(this);
+  readonly dynascaleManager: DynascaleManager;
 
   subscriber?: Subscriber;
   publisher?: Publisher;
@@ -218,11 +202,6 @@ export class Call {
    */
   private readonly dispatcher = new Dispatcher();
 
-  private trackSubscriptionsSubject = new BehaviorSubject<{
-    type: DebounceType;
-    data: TrackSubscriptionDetails[];
-  }>({ type: DebounceType.MEDIUM, data: [] });
-
   private statsReporter?: StatsReporter;
   private sfuStatsReporter?: SfuStatsReporter;
   private dropTimeout: ReturnType<typeof setTimeout> | undefined;
@@ -304,6 +283,7 @@ export class Call {
     this.microphone = new MicrophoneManager(this);
     this.speaker = new SpeakerManager(this);
     this.screenShare = new ScreenShareManager(this);
+    this.dynascaleManager = new DynascaleManager(this.state, this.speaker);
   }
 
   private async setup() {
@@ -321,19 +301,6 @@ export class Call {
       this.registerEffects();
       this.registerReconnectHandlers();
 
-      this.leaveCallHooks.add(
-        createSubscription(
-          this.trackSubscriptionsSubject.pipe(
-            debounce((v) => timer(v.type)),
-            map((v) => v.data),
-          ),
-          (subscriptions) =>
-            this.sfuClient?.updateSubscriptions(subscriptions).catch((err) => {
-              this.logger('debug', `Failed to update track subscriptions`, err);
-            }),
-        ),
-      );
-
       if (this.state.callingState === CallingState.LEFT) {
         this.state.setCallingState(CallingState.IDLE);
       }
@@ -582,6 +549,7 @@ export class Call {
 
       await this.sfuClient?.leaveAndClose(reason);
       this.sfuClient = undefined;
+      this.dynascaleManager.setSfuClient(undefined);
 
       this.state.setCallingState(CallingState.LEFT);
 
@@ -812,6 +780,7 @@ export class Call {
           })
         : previousSfuClient;
     this.sfuClient = sfuClient;
+    this.dynascaleManager.setSfuClient(sfuClient);
 
     const clientDetails = getClientDetails();
     // we don't need to send JoinRequest if we are re-using an existing healthy SFU client
@@ -904,11 +873,10 @@ export class Call {
     const strategy = this.reconnectStrategy;
     const performingRejoin = strategy === WebsocketReconnectStrategy.REJOIN;
     const announcedTracks = this.publisher?.getAnnouncedTracks() || [];
-    const subscribedTracks = getCurrentValue(this.trackSubscriptionsSubject);
     return {
       strategy,
       announcedTracks,
-      subscriptions: subscribedTracks.data || [],
+      subscriptions: this.dynascaleManager.trackSubscriptions,
       reconnectAttempt: this.reconnectAttempts,
       fromSfuId: migratingFromSfuId || '',
       previousSessionId: performingRejoin ? previousSessionId || '' : '',
@@ -1357,7 +1325,7 @@ export class Call {
   private restoreSubscribedTracks = () => {
     const { remoteParticipants } = this.state;
     if (remoteParticipants.length <= 0) return;
-    this.updateSubscriptions(remoteParticipants, DebounceType.FAST);
+    this.dynascaleManager.applyTrackSubscriptions(undefined);
   };
 
   /**
@@ -1521,87 +1489,6 @@ export class Call {
     });
   };
 
-  /**
-   * Update track subscription configuration for one or more participants.
-   * You have to create a subscription for each participant for all the different kinds of tracks you want to receive.
-   * You can only subscribe for tracks after the participant started publishing the given kind of track.
-   *
-   * @param trackType the kind of subscription to update.
-   * @param changes the list of subscription changes to do.
-   * @param type the debounce type to use for the update.
-   */
-  updateSubscriptionsPartial = (
-    trackType: VideoTrackType,
-    changes: SubscriptionChanges,
-    type: DebounceType = DebounceType.SLOW,
-  ) => {
-    const participants = this.state.updateParticipants(
-      Object.entries(changes).reduce<StreamVideoParticipantPatches>(
-        (acc, [sessionId, change]) => {
-          if (change.dimension) {
-            change.dimension.height = Math.ceil(change.dimension.height);
-            change.dimension.width = Math.ceil(change.dimension.width);
-          }
-          const prop: keyof StreamVideoParticipant | undefined =
-            trackType === 'videoTrack'
-              ? 'videoDimension'
-              : trackType === 'screenShareTrack'
-                ? 'screenShareDimension'
-                : undefined;
-          if (prop) {
-            acc[sessionId] = {
-              [prop]: change.dimension,
-            };
-          }
-          return acc;
-        },
-        {},
-      ),
-    );
-
-    this.updateSubscriptions(participants, type);
-  };
-
-  private updateSubscriptions = (
-    participants: StreamVideoParticipant[],
-    type: DebounceType = DebounceType.SLOW,
-  ) => {
-    const subscriptions: TrackSubscriptionDetails[] = [];
-    for (const p of participants) {
-      // we don't want to subscribe to our own tracks
-      if (p.isLocalParticipant) continue;
-
-      // NOTE: audio tracks don't have to be requested explicitly
-      // as the SFU will implicitly subscribe us to all of them,
-      // once they become available.
-      if (p.videoDimension && hasVideo(p)) {
-        subscriptions.push({
-          userId: p.userId,
-          sessionId: p.sessionId,
-          trackType: TrackType.VIDEO,
-          dimension: p.videoDimension,
-        });
-      }
-      if (p.screenShareDimension && hasScreenShare(p)) {
-        subscriptions.push({
-          userId: p.userId,
-          sessionId: p.sessionId,
-          trackType: TrackType.SCREEN_SHARE,
-          dimension: p.screenShareDimension,
-        });
-      }
-      if (hasScreenShareAudio(p)) {
-        subscriptions.push({
-          userId: p.userId,
-          sessionId: p.sessionId,
-          trackType: TrackType.SCREEN_SHARE_AUDIO,
-        });
-      }
-    }
-    // schedule update
-    this.trackSubscriptionsSubject.next({ type, data: subscriptions });
-  };
-
   /**
    * Will enhance the reported stats with additional participant-specific information (`callStatsReport$` state [store variable](./StreamVideoClient.md/#readonlystatestore)).
    * This is usually helpful when detailed stats for a specific participant are needed.
@@ -2387,4 +2274,41 @@ export class Call {
       imageElement.removeEventListener('error', handleError);
     };
   };
+
+  /**
+   * Specify preference for incoming video resolution. The preference will
+   * be matched as close as possible, but actual resolution will depend
+   * on the video source quality and client network conditions. Will enable
+   * incoming video, if previously disabled.
+   *
+   * @param resolution preferred resolution, or `undefined` to clear preference
+   * @param sessionIds optionally specify session ids of the participants this
+   * preference has effect on. Affects all participants by default.
+   */
+  setPreferredIncomingVideoResolution = (
+    resolution: VideoResolution | undefined,
+    sessionIds?: string[],
+  ) => {
+    this.dynascaleManager.setVideoTrackSubscriptionOverrides(
+      resolution
+        ? {
+            enabled: true,
+            dimension: resolution,
+          }
+        : undefined,
+      sessionIds,
+    );
+    this.dynascaleManager.applyTrackSubscriptions();
+  };
+
+  /**
+   * Enables or disables incoming video from all remote call participants,
+   * and removes any preference for preferred resolution.
+   */
+  setIncomingVideoEnabled = (enabled: boolean) => {
+    this.dynascaleManager.setVideoTrackSubscriptionOverrides(
+      enabled ? undefined : { enabled: false },
+    );
+    this.dynascaleManager.applyTrackSubscriptions();
+  };
 }