@stream-io/video-client 1.40.0 → 1.40.2

package/dist/src/StreamSfuClient.d.ts

@@ -1,5 +1,5 @@
 import { Dispatcher, IceTrickleBuffer } from './rtc';
-import { JoinRequest, JoinResponse } from './gen/video/sfu/event/events';
+import { Error as SfuErrorEvent, JoinRequest, JoinResponse } from './gen/video/sfu/event/events';
 import { ICERestartRequest, SendAnswerRequest, SendStatsRequest, SetPublisherRequest, TrackMuteState, TrackSubscriptionDetails } from './gen/video/sfu/signal_rpc/signal';
 import { ICETrickle } from './gen/video/sfu/models/models';
 import { StreamClient } from './coordinator/connection/client';
@@ -170,3 +170,8 @@ export declare class StreamSfuClient {
     private keepAlive;
     private scheduleConnectionCheck;
 }
+export declare class SfuJoinError extends Error {
+    errorEvent: SfuErrorEvent;
+    unrecoverable: boolean;
+    constructor(event: SfuErrorEvent);
+}

package/dist/src/devices/DeviceManager.d.ts

@@ -12,6 +12,19 @@ export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C =
     stopOnLeave: boolean;
     logger: ScopedLogger;
     state: S;
+    /**
+     * When `true`, the `apply()` method will skip automatically enabling/disabling
+     * the device based on server defaults (`mic_default_on`, `camera_default_on`).
+     *
+     * This is useful when application code wants to handle device preferences
+     * (e.g., persisted user preferences) and prevent server defaults from
+     * overriding them.
+     *
+     * @default false
+     *
+     * @internal
+     */
+    deferServerDefaults: boolean;
     protected readonly call: Call;
     protected readonly trackType: TrackType;
     protected subscriptions: Function[];

package/package.json

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

package/src/Call.ts

@@ -1,4 +1,4 @@
-import { StreamSfuClient } from './StreamSfuClient';
+import { SfuJoinError, StreamSfuClient } from './StreamSfuClient';
 import {
   BasePeerConnectionOpts,
   Dispatcher,
@@ -908,7 +908,10 @@ export class Call {
         break;
       } catch (err) {
         this.logger.warn(`Failed to join call (${attempt})`, this.cid);
-        if (err instanceof ErrorFromResponse && err.unrecoverable) {
+        if (
+          (err instanceof ErrorFromResponse && err.unrecoverable) ||
+          (err instanceof SfuJoinError && err.unrecoverable)
+        ) {
           // if the error is unrecoverable, we should not retry as that signals
           // that connectivity is good, but the coordinator doesn't allow the user
           // to join the call due to some reason (e.g., ended call, expired token...)

package/src/StreamSfuClient.ts

@@ -14,6 +14,7 @@ import {
   SfuEventKinds,
 } from './rtc';
 import {
+  Error as SfuErrorEvent,
   JoinRequest,
   JoinResponse,
   SfuRequest,
@@ -26,7 +27,10 @@ import {
   TrackMuteState,
   TrackSubscriptionDetails,
 } from './gen/video/sfu/signal_rpc/signal';
-import { ICETrickle } from './gen/video/sfu/models/models';
+import {
+  ICETrickle,
+  WebsocketReconnectStrategy,
+} from './gen/video/sfu/models/models';
 import { StreamClient } from './coordinator/connection/client';
 import { generateUUIDv4 } from './coordinator/connection/utils';
 import { Credentials } from './gen/coordinator';
@@ -537,15 +541,27 @@ export class StreamSfuClient {
     const current = this.joinResponseTask;
 
     let timeoutId: NodeJS.Timeout | undefined = undefined;
+    const unsubscribeJoinErrorEvents = this.dispatcher.on('error', (event) => {
+      const { error, reconnectStrategy } = event;
+      if (!error) return;
+      if (reconnectStrategy === WebsocketReconnectStrategy.DISCONNECT) {
+        clearTimeout(timeoutId);
+        unsubscribe?.();
+        unsubscribeJoinErrorEvents();
+        current.reject(new SfuJoinError(event));
+      }
+    });
     const unsubscribe = this.dispatcher.on('joinResponse', (joinResponse) => {
       clearTimeout(timeoutId);
       unsubscribe();
+      unsubscribeJoinErrorEvents();
       this.keepAlive();
       current.resolve(joinResponse);
     });
 
     timeoutId = setTimeout(() => {
       unsubscribe();
+      unsubscribeJoinErrorEvents();
       const message = `Waiting for "joinResponse" has timed out after ${this.joinResponseTimeout}ms`;
       this.tracer?.trace('joinRequestTimeout', message);
       current.reject(new Error(message));
@@ -631,3 +647,15 @@ export class StreamSfuClient {
     }, this.unhealthyTimeoutInMs);
   };
 }
+
+export class SfuJoinError extends Error {
+  errorEvent: SfuErrorEvent;
+  unrecoverable: boolean;
+
+  constructor(event: SfuErrorEvent) {
+    super(event.error?.message || 'Join Error');
+    this.errorEvent = event;
+    this.unrecoverable =
+      event.reconnectStrategy === WebsocketReconnectStrategy.DISCONNECT;
+  }
+}

package/src/devices/CameraManager.ts

@@ -3,7 +3,7 @@ import { Call } from '../Call';
 import { CameraDirection, CameraManagerState } from './CameraManagerState';
 import { DeviceManager } from './DeviceManager';
 import { getVideoDevices, getVideoStream } from './devices';
-import { OwnCapability, VideoSettingsResponse } from '../gen/coordinator';
+import { VideoSettingsResponse } from '../gen/coordinator';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { isMobile } from '../helpers/compatibility';
 import { isReactNative } from '../helpers/platforms';
@@ -79,8 +79,15 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
    * @internal
    */
   async selectTargetResolution(resolution: { width: number; height: number }) {
-    this.targetResolution.height = resolution.height;
-    this.targetResolution.width = resolution.width;
+    // normalize target resolution to landscape format.
+    // on mobile devices, the device itself adjusts the resolution to portrait or landscape
+    // depending on the orientation of the device. using portrait resolution
+    // will result in falling back to the default resolution (640x480).
+    let { width, height } = resolution;
+    if (width < height) [width, height] = [height, width];
+    this.targetResolution.height = height;
+    this.targetResolution.width = width;
+
     if (this.state.optimisticStatus === 'enabled') {
       try {
         await this.statusChangeSettled();
@@ -92,11 +99,8 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
     if (this.enabled && this.state.mediaStream) {
       const [videoTrack] = this.state.mediaStream.getVideoTracks();
       if (!videoTrack) return;
-      const { width, height } = videoTrack.getSettings();
-      if (
-        width !== this.targetResolution.width ||
-        height !== this.targetResolution.height
-      ) {
+      const { width: w, height: h } = videoTrack.getSettings();
+      if (w !== width || h !== height) {
         await this.applySettingsToStream();
         this.logger.debug(
           `${width}x${height} target resolution applied to media stream`,
@@ -112,43 +116,27 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
    * @param publish whether to publish the stream after applying the settings.
    */
   async apply(settings: VideoSettingsResponse, publish: boolean) {
-    const hasPublishedVideo = !!this.call.state.localParticipant?.videoStream;
-    const hasPermission = this.call.permissionsContext.hasPermission(
-      OwnCapability.SEND_AUDIO,
-    );
-    if (hasPublishedVideo || !hasPermission) return;
-
     // Wait for any in progress camera operation
     await this.statusChangeSettled();
+    await this.selectTargetResolution(settings.target_resolution);
+
+    // apply a direction and enable the camera only if in "pristine" state
+    // and server defaults are not deferred to application code
+    const canPublish = this.call.permissionsContext.canPublish(this.trackType);
+    if (this.state.status === undefined && !this.deferServerDefaults) {
+      if (!this.state.direction && !this.state.selectedDevice) {
+        const direction = settings.camera_facing === 'front' ? 'front' : 'back';
+        await this.selectDirection(direction);
+      }
 
-    const { target_resolution, camera_facing, camera_default_on, enabled } =
-      settings;
-    // normalize target resolution to landscape format.
-    // on mobile devices, the device itself adjusts the resolution to portrait or landscape
-    // depending on the orientation of the device. using portrait resolution
-    // will result in falling back to the default resolution (640x480).
-    let { width, height } = target_resolution;
-    if (width < height) [width, height] = [height, width];
-    await this.selectTargetResolution({ width, height });
-
-    // Set camera direction if it's not yet set
-    if (!this.state.direction && !this.state.selectedDevice) {
-      this.state.setDirection(camera_facing === 'front' ? 'front' : 'back');
+      if (canPublish && settings.camera_default_on && settings.enabled) {
+        await this.enable();
+      }
     }
 
-    if (!publish) return;
-
     const { mediaStream } = this.state;
-    if (this.enabled && mediaStream) {
-      // The camera is already enabled (e.g. lobby screen). Publish the stream
+    if (canPublish && publish && this.enabled && mediaStream) {
       await this.publishStream(mediaStream);
-    } else if (
-      this.state.status === undefined &&
-      camera_default_on &&
-      enabled
-    ) {
-      // Start camera if backend config specifies, and there is no local setting
-      await this.enable();
     }
   }
 

package/src/devices/DeviceManager.ts

@@ -32,6 +32,20 @@ export abstract class DeviceManager<
 
   state: S;
 
+  /**
+   * When `true`, the `apply()` method will skip automatically enabling/disabling
+   * the device based on server defaults (`mic_default_on`, `camera_default_on`).
+   *
+   * This is useful when application code wants to handle device preferences
+   * (e.g., persisted user preferences) and prevent server defaults from
+   * overriding them.
+   *
+   * @default false
+   *
+   * @internal
+   */
+  deferServerDefaults = false;
+
   protected readonly call: Call;
   protected readonly trackType: TrackType;
   protected subscriptions: Function[] = [];

package/src/devices/MicrophoneManager.ts

@@ -230,25 +230,21 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
    * @param publish whether to publish the stream after applying the settings.
    */
   async apply(settings: AudioSettingsResponse, publish: boolean) {
-    if (!publish) return;
-
-    const hasPublishedAudio = !!this.call.state.localParticipant?.audioStream;
-    const hasPermission = this.call.permissionsContext.hasPermission(
-      OwnCapability.SEND_AUDIO,
-    );
-    if (hasPublishedAudio || !hasPermission) return;
-
     // Wait for any in progress mic operation
     await this.statusChangeSettled();
 
-    // Publish media stream that was set before we joined
+    const canPublish = this.call.permissionsContext.canPublish(this.trackType);
+    // apply server-side settings only when the device state is pristine
+    // and server defaults are not deferred to application code
+    if (this.state.status === undefined && !this.deferServerDefaults) {
+      if (canPublish && settings.mic_default_on) {
+        await this.enable();
+      }
+    }
+
     const { mediaStream } = this.state;
-    if (this.enabled && mediaStream) {
-      // The mic is already enabled (e.g. lobby screen). Publish the stream
+    if (canPublish && publish && this.enabled && mediaStream) {
       await this.publishStream(mediaStream);
-    } else if (this.state.status === undefined && settings.mic_default_on) {
-      // Start mic if backend config specifies, and there is no local setting
-      await this.enable();
     }
   }
 

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

@@ -3,6 +3,7 @@ import { StreamClient } from '../../coordinator/connection/client';
 import { CallingState, StreamVideoWriteableStateStore } from '../../store';
 
 import { afterEach, beforeEach, describe, expect, it, Mock, vi } from 'vitest';
+import { fromPartial } from '@total-typescript/shoehorn';
 import {
   mockBrowserPermission,
   mockCall,
@@ -296,21 +297,20 @@ describe('CameraManager', () => {
     });
 
     it('should not enable the camera when the user does not have permission', async () => {
-      call.permissionsContext.hasPermission = vi.fn().mockReturnValue(false);
+      call.permissionsContext.canPublish = vi.fn().mockReturnValue(false);
       vi.spyOn(manager, 'enable');
       await manager.apply(
-        // @ts-expect-error - partial settings
-        {
+        fromPartial({
           target_resolution: { width: 640, height: 480 },
           camera_facing: 'front',
           camera_default_on: true,
-        },
+        }),
         true,
       );
 
-      expect(manager.state.direction).toBe(undefined);
+      expect(manager.state.direction).toBe('front');
       expect(manager.state.status).toBe(undefined);
-      expect(manager['targetResolution']).toEqual({ width: 1280, height: 720 });
+      expect(manager['targetResolution']).toEqual({ width: 640, height: 480 });
       expect(manager.enable).not.toHaveBeenCalled();
     });
 

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

@@ -329,7 +329,7 @@ describe('MicrophoneManager', () => {
     beforeEach(() => {
       // @ts-expect-error - read only property
       call.permissionsContext = new PermissionsContext();
-      call.permissionsContext.hasPermission = vi.fn().mockReturnValue(true);
+      call.permissionsContext.canPublish = vi.fn().mockReturnValue(true);
     });
 
     it('should turn the mic on when set on dashboard', async () => {
@@ -346,15 +346,8 @@ describe('MicrophoneManager', () => {
       expect(enable).not.toHaveBeenCalled();
     });
 
-    it('should not turn on the mic when publish is false', async () => {
-      const enable = vi.spyOn(manager, 'enable');
-      // @ts-expect-error - partial data
-      await manager.apply({ mic_default_on: true }, false);
-      expect(enable).not.toHaveBeenCalled();
-    });
-
     it('should not turn on the mic when permission is missing', async () => {
-      call.permissionsContext.hasPermission = vi.fn().mockReturnValue(false);
+      call.permissionsContext.canPublish = vi.fn().mockReturnValue(false);
       const enable = vi.spyOn(manager, 'enable');
       // @ts-expect-error - partial data
       await manager.apply({ mic_default_on: true }, true);