@stream-io/video-client 0.7.11 → 0.7.13

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

@@ -4113,6 +4113,12 @@ export interface ScreensharingSettings {
      * @memberof ScreensharingSettings
      */
     enabled: boolean;
+    /**
+     *
+     * @type {TargetResolution}
+     * @memberof ScreensharingSettings
+     */
+    target_resolution?: TargetResolution;
 }
 /**
  *
@@ -4132,6 +4138,12 @@ export interface ScreensharingSettingsRequest {
      * @memberof ScreensharingSettingsRequest
      */
     enabled?: boolean;
+    /**
+     *
+     * @type {TargetResolution}
+     * @memberof ScreensharingSettingsRequest
+     */
+    target_resolution?: TargetResolution;
 }
 /**
  *

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

@@ -24,4 +24,4 @@ export declare const findOptimalVideoLayers: (videoTrack: MediaStreamTrack, targ
  * @param currentHeight the current height of the track.
  */
 export declare const getComputedMaxBitrate: (targetResolution: TargetResolution, currentWidth: number, currentHeight: number) => number;
-export declare const findOptimalScreenSharingLayers: (videoTrack: MediaStreamTrack, preferences?: ScreenShareSettings) => OptimalVideoLayer[];
+export declare const findOptimalScreenSharingLayers: (videoTrack: MediaStreamTrack, preferences?: ScreenShareSettings, defaultMaxBitrate?: number) => OptimalVideoLayer[];

package/package.json

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

package/src/StreamSfuClient.ts

@@ -34,7 +34,7 @@ import {
   sleep,
 } from './coordinator/connection/utils';
 import { SFUResponse } from './gen/coordinator';
-import { Logger } from './coordinator/connection/types';
+import { LogLevel, Logger } from './coordinator/connection/types';
 import { getLogger } from './logger';
 
 export type StreamSfuClientConstructor = {
@@ -228,6 +228,7 @@ export class StreamSfuClient {
           tracks: subscriptions,
         }),
       this.logger,
+      'debug',
     );
   };
 
@@ -307,6 +308,7 @@ export class StreamSfuClient {
           sessionId: this.sessionId,
         }),
       this.logger,
+      'debug',
     );
   };
 
@@ -421,6 +423,7 @@ const MAX_RETRIES = 5;
 const retryable = async <I extends object, O extends SfuResponseWithError>(
   rpc: () => UnaryCall<I, O>,
   logger: Logger,
+  level: LogLevel = 'error',
 ) => {
   let retryAttempt = 0;
   let rpcCallResult: FinishedUnaryCall<I, O>;
@@ -431,16 +434,11 @@ const retryable = async <I extends object, O extends SfuResponseWithError>(
     }
 
     rpcCallResult = await rpc();
-    logger(
-      'trace',
-      `SFU RPC response received for ${rpcCallResult.method.name}`,
-      rpcCallResult,
-    );
 
     // if the RPC call failed, log the error and retry
     if (rpcCallResult.response.error) {
       logger(
-        'error',
+        level,
         `SFU RPC Error (${rpcCallResult.method.name}):`,
         rpcCallResult.response.error,
       );

package/src/devices/ScreenShareManager.ts

@@ -5,6 +5,7 @@ import { Call } from '../Call';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { getScreenShareStream } from './devices';
 import { ScreenShareSettings } from '../types';
+import { createSubscription } from '../store/rxUtils';
 
 export class ScreenShareManager extends InputMediaDeviceManager<
   ScreenShareState,
@@ -12,6 +13,21 @@ export class ScreenShareManager extends InputMediaDeviceManager<
 > {
   constructor(call: Call) {
     super(call, new ScreenShareState(), TrackType.SCREEN_SHARE);
+
+    this.subscriptions.push(
+      createSubscription(call.state.settings$, (settings) => {
+        const maybeTargetResolution = settings?.screensharing.target_resolution;
+
+        if (maybeTargetResolution) {
+          this.setDefaultConstraints({
+            video: {
+              width: maybeTargetResolution.width,
+              height: maybeTargetResolution.height,
+            },
+          });
+        }
+      }),
+    );
   }
 
   /**

package/src/devices/__tests__/ScreenShareManager.test.ts

@@ -58,9 +58,11 @@ describe('ScreenShareManager', () => {
     await manager.enable();
     expect(manager.state.status).toEqual('enabled');
 
-    expect(getScreenShareStream).toHaveBeenCalledWith({
-      deviceId: undefined,
-    });
+    expect(getScreenShareStream).toHaveBeenCalledWith(
+      expect.objectContaining({
+        deviceId: undefined,
+      }),
+    );
   });
 
   it('get stream with no audio', async () => {
@@ -68,10 +70,12 @@ describe('ScreenShareManager', () => {
     await manager.enable();
     expect(manager.state.status).toEqual('enabled');
 
-    expect(getScreenShareStream).toHaveBeenCalledWith({
-      deviceId: undefined,
-      audio: false,
-    });
+    expect(getScreenShareStream).toHaveBeenCalledWith(
+      expect.objectContaining({
+        deviceId: undefined,
+        audio: false,
+      }),
+    );
   });
 
   it('should get device id from stream', async () => {
@@ -81,6 +85,30 @@ describe('ScreenShareManager', () => {
     expect(manager.state.selectedDevice).toEqual('screen');
   });
 
+  it('should use call settings to set up constraints', async () => {
+    const call = manager['call'];
+    call.state.setCurrentValue(call.state['settingsSubject'], {
+      // @ts-expect-error partial data
+      screensharing: {
+        target_resolution: {
+          width: 800,
+          height: 600,
+          bitrate: 192000,
+        },
+      },
+    });
+
+    await manager.enable();
+    expect(getScreenShareStream).toHaveBeenCalledWith(
+      expect.objectContaining({
+        video: {
+          width: 800,
+          height: 600,
+        },
+      }),
+    );
+  });
+
   it('publishes screen share stream', async () => {
     const call = manager['call'];
     call.state.setCallingState(CallingState.JOINED);

package/src/devices/__tests__/mocks.ts

@@ -84,6 +84,10 @@ export const mockCall = (): Partial<Call> => {
           mode: NoiseCancellationSettingsModeEnum.AVAILABLE,
         },
       },
+      // @ts-expect-error partial data
+      screensharing: {
+        target_resolution: undefined,
+      },
     },
   });
   return {

package/src/events/__tests__/call.test.ts

@@ -305,6 +305,10 @@ const fakeMetadata = (): CallResponse => {
         auto_cancel_timeout_ms: 30000,
         incoming_call_timeout_ms: 30000,
       },
+      // @ts-ignore
+      screensharing: {
+        target_resolution: undefined,
+      },
     },
   };
 };

package/src/gen/coordinator/index.ts

@@ -4104,6 +4104,12 @@ export interface ScreensharingSettings {
    * @memberof ScreensharingSettings
    */
   enabled: boolean;
+  /**
+   *
+   * @type {TargetResolution}
+   * @memberof ScreensharingSettings
+   */
+  target_resolution?: TargetResolution;
 }
 /**
  *
@@ -4123,6 +4129,12 @@ export interface ScreensharingSettingsRequest {
    * @memberof ScreensharingSettingsRequest
    */
   enabled?: boolean;
+  /**
+   *
+   * @type {TargetResolution}
+   * @memberof ScreensharingSettingsRequest
+   */
+  target_resolution?: TargetResolution;
 }
 /**
  *

package/src/rtc/Publisher.ts

@@ -240,11 +240,18 @@ export class Publisher {
     if (!transceiver) {
       const { settings } = this.state;
       const targetResolution = settings?.video.target_resolution;
+      const screenShareBitrate =
+        settings?.screensharing.target_resolution?.bitrate;
+
       const videoEncodings =
         trackType === TrackType.VIDEO
           ? findOptimalVideoLayers(track, targetResolution)
           : trackType === TrackType.SCREEN_SHARE
-          ? findOptimalScreenSharingLayers(track, opts.screenShareSettings)
+          ? findOptimalScreenSharingLayers(
+              track,
+              opts.screenShareSettings,
+              screenShareBitrate,
+            )
           : undefined;
 
       let preferredCodec = opts.preferredCodec;

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

@@ -28,6 +28,17 @@ describe('videoLayers', () => {
     ]);
   });
 
+  it('should use default max bitrate if none is provided in preferences', () => {
+    const track = new MediaStreamTrack();
+    vi.spyOn(track, 'getSettings').mockReturnValue({
+      width: 1920,
+      height: 1080,
+    });
+
+    const layers = findOptimalScreenSharingLayers(track, undefined, 192000);
+    expect(layers).toMatchObject([{ maxBitrate: 192000 }]);
+  });
+
   it('should find optimal video layers', () => {
     const track = new MediaStreamTrack();
     const width = 1920;

package/src/rtc/videoLayers.ts

@@ -131,6 +131,7 @@ const withSimulcastConstraints = (
 export const findOptimalScreenSharingLayers = (
   videoTrack: MediaStreamTrack,
   preferences?: ScreenShareSettings,
+  defaultMaxBitrate = 3000000,
 ): OptimalVideoLayer[] => {
   const settings = videoTrack.getSettings();
   return [
@@ -140,7 +141,7 @@ export const findOptimalScreenSharingLayers = (
       width: settings.width || 0,
       height: settings.height || 0,
       scaleResolutionDownBy: 1,
-      maxBitrate: preferences?.maxBitrate ?? 3000000,
+      maxBitrate: preferences?.maxBitrate ?? defaultMaxBitrate,
       maxFramerate: preferences?.maxFramerate ?? 30,
     },
   ];