@stream-io/video-client 1.40.0 → 1.40.1

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.1",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",

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);