@stream-io/video-client 1.46.1 → 1.48.0

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

@@ -13,7 +13,6 @@ export declare class MicrophoneManager extends AudioDeviceManager<MicrophoneMana
     private soundDetectorCleanup?;
     private soundDetectorDeviceId?;
     private noAudioDetectorCleanup?;
-    private rnSpeechDetector;
     private noiseCancellation;
     private noiseCancellationChangeUnsubscribe;
     private noiseCancellationRegistration?;

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

@@ -5340,6 +5340,12 @@ export interface JoinCallRequest {
      * @memberof JoinCallRequest
      */
     data?: CallRequest;
+    /**
+     * if true, the participant will be marked as publsihing to large audience
+     * @type {boolean}
+     * @memberof JoinCallRequest
+     */
+    hint_high_scale_livestream_publisher?: boolean;
     /**
      *
      * @type {string}

package/dist/src/types.d.ts

@@ -371,6 +371,17 @@ export type StreamRNVideoSDKGlobals = {
          */
         check(permission: 'microphone' | 'camera'): Promise<boolean>;
     };
+    nativeEvents: {
+        speechActivity: {
+            /**
+             * Subscribes to native speech activity events.
+             * Returns an unsubscribe function.
+             */
+            subscribe(cb: (state: {
+                isSoundDetected: boolean;
+            }) => void): () => void;
+        };
+    };
 };
 declare global {
     var streamRNVideoSDK: StreamRNVideoSDKGlobals | undefined;

package/index.ts

@@ -23,7 +23,6 @@ export * from './src/helpers/DynascaleManager';
 export * from './src/helpers/ViewportTracker';
 export * from './src/helpers/sound-detector';
 export * from './src/helpers/participantUtils';
-export * from './src/helpers/RNSpeechDetector';
 export * as Browsers from './src/helpers/browsers';
 
 export * from './src/logger';

package/package.json

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

package/src/devices/CameraManager.ts

@@ -1,4 +1,4 @@
-import { Observable } from 'rxjs';
+import { firstValueFrom, Observable } from 'rxjs';
 import { Call } from '../Call';
 import { CameraDirection, CameraManagerState } from './CameraManagerState';
 import { DeviceManager } from './DeviceManager';
@@ -140,7 +140,14 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
       this.state.status === undefined &&
       this.state.optimisticStatus === undefined;
     let persistedPreferencesApplied = false;
-    if (shouldApplyDefaults && this.devicePersistence.enabled) {
+    const permissionState = await firstValueFrom(
+      this.state.browserPermissionState$,
+    );
+    if (
+      shouldApplyDefaults &&
+      this.devicePersistence.enabled &&
+      permissionState === 'granted'
+    ) {
       persistedPreferencesApplied =
         await this.applyPersistedPreferences(enabledInCallType);
     }

package/src/devices/DeviceManager.ts

@@ -89,9 +89,19 @@ export abstract class DeviceManager<
     if (this.devicePersistence.enabled) {
       this.subscriptions.push(
         createSubscription(
-          combineLatest([this.state.selectedDevice$, this.state.status$]),
-          ([selectedDevice, status]) => {
-            if (!status) return;
+          combineLatest([
+            this.state.selectedDevice$,
+            this.state.status$,
+            this.state.browserPermissionState$,
+          ]),
+          ([selectedDevice, status, browserPermissionState]) => {
+            if (
+              !status ||
+              (this.isTrackStoppedDueToTrackEnd && status === 'disabled') ||
+              browserPermissionState !== 'granted'
+            )
+              return;
+
             this.persistPreference(selectedDevice, status);
           },
         ),

package/src/devices/MicrophoneManager.ts

@@ -24,7 +24,6 @@ import {
   createSafeAsyncSubscription,
   createSubscription,
 } from '../store/rxUtils';
-import { RNSpeechDetector } from '../helpers/RNSpeechDetector';
 import { withoutConcurrency } from '../helpers/concurrency';
 import { disposeOfMediaStream } from './utils';
 import { promiseWithResolvers } from '../helpers/promise';
@@ -36,7 +35,6 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
   private soundDetectorCleanup?: () => Promise<void>;
   private soundDetectorDeviceId?: string;
   private noAudioDetectorCleanup?: () => Promise<void>;
-  private rnSpeechDetector: RNSpeechDetector | undefined;
   private noiseCancellation: INoiseCancellation | undefined;
   private noiseCancellationChangeUnsubscribe: (() => void) | undefined;
   private noiseCancellationRegistration?: Promise<void>;
@@ -356,7 +354,14 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
       this.state.status === undefined &&
       this.state.optimisticStatus === undefined;
     let persistedPreferencesApplied = false;
-    if (shouldApplyDefaults && this.devicePersistence.enabled) {
+    const permissionState = await firstValueFrom(
+      this.state.browserPermissionState$,
+    );
+    if (
+      shouldApplyDefaults &&
+      this.devicePersistence.enabled &&
+      permissionState === 'granted'
+    ) {
       persistedPreferencesApplied = await this.applyPersistedPreferences(true);
     }
 
@@ -415,13 +420,19 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
       await this.teardownSpeakingWhileMutedDetection();
 
       if (isReactNative()) {
-        this.rnSpeechDetector = new RNSpeechDetector();
-        const unsubscribe = await this.rnSpeechDetector.start((event) => {
+        const speechActivity =
+          globalThis.streamRNVideoSDK?.nativeEvents?.speechActivity;
+        if (!speechActivity) {
+          this.logger.warn(
+            'Native speech activity not available, make sure the "@stream-io/react-native-webrtc" peer dependency version is satisfied',
+          );
+          return;
+        }
+        const unsubscribe = speechActivity.subscribe((event) => {
           this.state.setSpeakingWhileMuted(event.isSoundDetected);
         });
         this.soundDetectorCleanup = async () => {
           unsubscribe();
-          this.rnSpeechDetector = undefined;
         };
       } else {
         // Need to start a new stream that's not connected to publisher

package/src/devices/SpeakerManager.ts

@@ -2,7 +2,11 @@ import { combineLatest } from 'rxjs';
 import { Call } from '../Call';
 import { isReactNative } from '../helpers/platforms';
 import { SpeakerState } from './SpeakerState';
-import { deviceIds$, getAudioOutputDevices } from './devices';
+import {
+  deviceIds$,
+  getAudioBrowserPermission,
+  getAudioOutputDevices,
+} from './devices';
 import {
   AudioSettingsRequestDefaultDeviceEnum,
   CallSettingsResponse,
@@ -111,9 +115,17 @@ export class SpeakerManager {
 
     if (!isReactNative() && this.devicePersistence.enabled) {
       this.subscriptions.push(
-        createSubscription(this.state.selectedDevice$, (selectedDevice) => {
-          this.persistSpeakerDevicePreference(selectedDevice);
-        }),
+        createSubscription(
+          combineLatest([
+            this.state.selectedDevice$,
+            getAudioBrowserPermission(this.call.tracer).asStateObservable(),
+          ]),
+          ([selectedDevice, browserPermissionState]) => {
+            if (!selectedDevice || browserPermissionState !== 'granted') return;
+
+            this.persistSpeakerDevicePreference(selectedDevice);
+          },
+        ),
       );
     }
   }

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

@@ -306,6 +306,9 @@ describe('CameraManager', () => {
     });
 
     it('should skip defaults when preferences are applied', async () => {
+      vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+        of('granted'),
+      );
       const devicePersistence = { enabled: true, storageKey: '' };
       const persistedManager = new CameraManager(call, devicePersistence);
       const applySpy = vi
@@ -329,6 +332,32 @@ describe('CameraManager', () => {
       expect(enableSpy).not.toHaveBeenCalled();
     });
 
+    it('should skip persisted preferences when permission is not granted', async () => {
+      vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+        of('prompt'),
+      );
+      const devicePersistence = { enabled: true, storageKey: '' };
+      const persistedManager = new CameraManager(call, devicePersistence);
+      const applySpy = vi.spyOn(
+        persistedManager as never,
+        'applyPersistedPreferences',
+      );
+      const enableSpy = vi.spyOn(persistedManager, 'enable');
+
+      await persistedManager.apply(
+        fromPartial({
+          enabled: true,
+          target_resolution: { width: 640, height: 480 },
+          camera_facing: 'front',
+          camera_default_on: true,
+        }),
+        true,
+      );
+
+      expect(applySpy).not.toHaveBeenCalled();
+      expect(enableSpy).toHaveBeenCalled();
+    });
+
     it('should not apply defaults when device is not pristine', async () => {
       manager.state.setStatus('enabled');
       const selectDirectionSpy = vi.spyOn(manager, 'selectDirection');
@@ -445,6 +474,9 @@ describe('CameraManager', () => {
           createVideoStreamForDevice(selectedDevice.deviceId),
         );
       });
+      vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+        of('granted'),
+      );
 
       const stressManager = new CameraManager(call, {
         enabled: true,

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

@@ -76,6 +76,9 @@ describe('Device Manager', () => {
   beforeEach(() => {
     storageKey = '@test/device-preferences';
     localStorageMock = createLocalStorageMock();
+    vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+      of('granted'),
+    );
     Object.defineProperty(window, 'localStorage', {
       configurable: true,
       value: localStorageMock,
@@ -455,6 +458,74 @@ describe('Device Manager', () => {
         },
       ]);
     });
+
+    it('stores preferences when permission is granted', async () => {
+      const persistenceEnabledManager = new TestInputMediaDeviceManager(
+        manager['call'],
+        { enabled: true, storageKey },
+      );
+      const listDevicesSpy = vi.spyOn(persistenceEnabledManager, 'listDevices');
+
+      emitDeviceIds(mockVideoDevices);
+      persistenceEnabledManager.state.setDevice(mockVideoDevices[0].deviceId);
+      persistenceEnabledManager.state.setStatus('enabled');
+
+      expect(readPreferences(storageKey).camera).toBeDefined();
+      expect(listDevicesSpy).toHaveBeenCalled();
+      expect(readPreferences(storageKey).camera).toEqual([
+        {
+          selectedDeviceId: mockVideoDevices[0].deviceId,
+          selectedDeviceLabel: mockVideoDevices[0].label,
+          muted: false,
+        },
+      ]);
+    });
+
+    it('does not store preferences when permission is not granted', async () => {
+      vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+        of('prompt'),
+      );
+      const persistenceEnabledManager = new TestInputMediaDeviceManager(
+        manager['call'],
+        { enabled: true, storageKey },
+      );
+      const listDevicesSpy = vi.spyOn(persistenceEnabledManager, 'listDevices');
+
+      emitDeviceIds(mockVideoDevices);
+      persistenceEnabledManager.state.setDevice(mockVideoDevices[0].deviceId);
+      persistenceEnabledManager.state.setStatus('enabled');
+
+      expect(readPreferences(storageKey).camera).toBeUndefined();
+      expect(listDevicesSpy).not.toHaveBeenCalled();
+    });
+
+    it('does not overwrite preferences when track ends unexpectedly', async () => {
+      const persistenceEnabledManager = new TestInputMediaDeviceManager(
+        manager['call'],
+        { enabled: true, storageKey },
+      );
+
+      await persistenceEnabledManager.enable();
+
+      expect(readPreferences(storageKey).camera).toEqual([
+        {
+          selectedDeviceId: mockVideoDevices[0].deviceId,
+          selectedDeviceLabel: mockVideoDevices[0].label,
+          muted: false,
+        },
+      ]);
+
+      const [track] = persistenceEnabledManager.state.mediaStream!.getTracks();
+      await ((track as MockTrack).eventHandlers['ended'] as Function)();
+
+      expect(readPreferences(storageKey).camera).toEqual([
+        {
+          selectedDeviceId: mockVideoDevices[0].deviceId,
+          selectedDeviceLabel: mockVideoDevices[0].label,
+          muted: false,
+        },
+      ]);
+    });
   });
 
   describe('applyPersistedPreferences', () => {

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

@@ -479,6 +479,29 @@ describe('MicrophoneManager', () => {
       expect(enableSpy).not.toHaveBeenCalled();
     });
 
+    it('should skip persisted preferences when permission is not granted', async () => {
+      vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+        of('prompt'),
+      );
+      const devicePersistence = { enabled: true, storageKey: '' };
+      const persistedManager = new MicrophoneManager(
+        call,
+        devicePersistence,
+        'disable-tracks',
+      );
+      const applySpy = vi.spyOn(
+        persistedManager as never,
+        'applyPersistedPreferences',
+      );
+      const enableSpy = vi.spyOn(persistedManager, 'enable');
+
+      // @ts-expect-error - partial data
+      await persistedManager.apply({ mic_default_on: true }, true);
+
+      expect(applySpy).not.toHaveBeenCalled();
+      expect(enableSpy).toHaveBeenCalled();
+    });
+
     it('should not apply defaults when mic is not pristine', async () => {
       manager.state.setStatus('enabled');
       const applySpy = vi.spyOn(manager as never, 'applyPersistedPreferences');

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

@@ -12,11 +12,12 @@ import {
 import { of } from 'rxjs';
 import '../../rtc/__tests__/mocks/webrtc.mocks';
 import { OwnCapability } from '../../gen/coordinator';
-import { SoundStateChangeHandler } from '../../helpers/sound-detector';
 import { settled, withoutConcurrency } from '../../helpers/concurrency';
 
-let handler: SoundStateChangeHandler = () => {};
-let unsubscribeHandlers: ReturnType<typeof vi.fn>[] = [];
+let speechActivityCallback:
+  | ((state: { isSoundDetected: boolean }) => void)
+  | null = null;
+let unsubscribeMocks: ReturnType<typeof vi.fn>[] = [];
 
 vi.mock('../../helpers/platforms.ts', () => {
   return {
@@ -46,28 +47,21 @@ vi.mock('../../Call.ts', () => {
   };
 });
 
-vi.mock('../../helpers/RNSpeechDetector.ts', () => {
-  console.log('MOCKING RNSpeechDetector');
-  return {
-    RNSpeechDetector: vi.fn().mockImplementation(() => ({
-      start: vi.fn((callback) => {
-        handler = callback;
-        const unsubscribe = vi.fn();
-        unsubscribeHandlers.push(unsubscribe);
-        return unsubscribe;
-      }),
-      stop: vi.fn(),
-      onSpeakingDetectedStateChange: vi.fn(),
-    })),
-  };
-});
-
 describe('MicrophoneManager React Native', () => {
   let manager: MicrophoneManager;
   let checkPermissionMock: ReturnType<typeof vi.fn>;
+  let subscribeMock: ReturnType<typeof vi.fn>;
+
   beforeEach(() => {
-    unsubscribeHandlers = [];
+    speechActivityCallback = null;
+    unsubscribeMocks = [];
     checkPermissionMock = vi.fn(async () => true);
+    subscribeMock = vi.fn((cb) => {
+      speechActivityCallback = cb;
+      const unsub = vi.fn();
+      unsubscribeMocks.push(unsub);
+      return unsub;
+    });
 
     globalThis.streamRNVideoSDK = {
       callManager: {
@@ -78,6 +72,11 @@ describe('MicrophoneManager React Native', () => {
       permissions: {
         check: checkPermissionMock,
       },
+      nativeEvents: {
+        speechActivity: {
+          subscribe: subscribeMock,
+        },
+      },
     };
 
     const devicePersistence = { enabled: false, storageKey: '' };
@@ -100,7 +99,7 @@ describe('MicrophoneManager React Native', () => {
 
     await vi.waitUntil(() => fn.mock.calls.length > 0, { timeout: 100 });
     expect(fn).toHaveBeenCalled();
-    expect(manager['rnSpeechDetector']?.start).toHaveBeenCalled();
+    expect(subscribeMock).toHaveBeenCalled();
   });
 
   it('should check native microphone permission before starting detection', async () => {
@@ -146,15 +145,15 @@ describe('MicrophoneManager React Native', () => {
 
   it('should update speaking while muted state', async () => {
     await manager['startSpeakingWhileMutedDetection']();
-    expect(manager['rnSpeechDetector']?.start).toHaveBeenCalled();
+    expect(subscribeMock).toHaveBeenCalled();
 
     expect(manager.state.speakingWhileMuted).toBe(false);
 
-    handler!({ isSoundDetected: true, audioLevel: 2 });
+    speechActivityCallback!({ isSoundDetected: true });
 
     expect(manager.state.speakingWhileMuted).toBe(true);
 
-    handler!({ isSoundDetected: false, audioLevel: 0 });
+    speechActivityCallback!({ isSoundDetected: false });
 
     expect(manager.state.speakingWhileMuted).toBe(false);
   });
@@ -163,21 +162,21 @@ describe('MicrophoneManager React Native', () => {
     await manager['startSpeakingWhileMutedDetection']('device-1');
     await manager['startSpeakingWhileMutedDetection']('device-1');
 
-    expect(unsubscribeHandlers).toHaveLength(1);
+    expect(unsubscribeMocks).toHaveLength(1);
 
     await manager['stopSpeakingWhileMutedDetection']();
-    expect(unsubscribeHandlers[0]).toHaveBeenCalledTimes(1);
+    expect(unsubscribeMocks[0]).toHaveBeenCalledTimes(1);
   });
 
   it('should cleanup previous speech detector before starting a new one', async () => {
     await manager['startSpeakingWhileMutedDetection']('device-1');
     await manager['startSpeakingWhileMutedDetection']('device-2');
 
-    expect(unsubscribeHandlers).toHaveLength(2);
-    expect(unsubscribeHandlers[0]).toHaveBeenCalledTimes(1);
+    expect(unsubscribeMocks).toHaveLength(2);
+    expect(unsubscribeMocks[0]).toHaveBeenCalledTimes(1);
 
     await manager['stopSpeakingWhileMutedDetection']();
-    expect(unsubscribeHandlers[1]).toHaveBeenCalledTimes(1);
+    expect(unsubscribeMocks[1]).toHaveBeenCalledTimes(1);
   });
 
   it('should stop speaking while muted notifications if user loses permission to send audio', async () => {

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

@@ -37,6 +37,9 @@ describe('SpeakerManager.test', () => {
   beforeEach(() => {
     storageKey = '@test/speaker-preferences';
     localStorageMock = createLocalStorageMock();
+    vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+      of('granted'),
+    );
     Object.defineProperty(window, 'localStorage', {
       configurable: true,
       value: localStorageMock,
@@ -125,6 +128,31 @@ describe('SpeakerManager.test', () => {
     expect(manager.state.selectedDevice).toBe('');
   });
 
+  it('persists speaker selection when permission is granted', async () => {
+    const persistedManager = new SpeakerManager(
+      new Call({
+        id: '',
+        type: '',
+        streamClient: new StreamClient('abc123'),
+        clientStore: new StreamVideoWriteableStateStore(),
+      }),
+      { enabled: true, storageKey },
+    );
+    const listDevicesSpy = vi.spyOn(persistedManager, 'listDevices');
+    const audioOutputDevice = {
+      deviceId: 'speaker-1',
+      kind: 'audiooutput',
+      label: 'Speaker 1',
+      groupId: 'speaker-group',
+    } as MediaDeviceInfo;
+
+    emitDeviceIds([audioOutputDevice]);
+    persistedManager.select(audioOutputDevice.deviceId);
+
+    expect(listDevicesSpy).toHaveBeenCalled();
+    expect(persistedManager.state.selectedDevice).toBe('speaker-1');
+  });
+
   describe('apply (web)', () => {
     it('does nothing when persistence is disabled', () => {
       const selectSpy = vi.spyOn(manager, 'select');

package/src/gen/coordinator/index.ts

@@ -5344,6 +5344,12 @@ export interface JoinCallRequest {
    * @memberof JoinCallRequest
    */
   data?: CallRequest;
+  /**
+   * if true, the participant will be marked as publsihing to large audience
+   * @type {boolean}
+   * @memberof JoinCallRequest
+   */
+  hint_high_scale_livestream_publisher?: boolean;
   /**
    *
    * @type {string}

package/src/types.ts

@@ -462,6 +462,15 @@ export type StreamRNVideoSDKGlobals = {
      */
     check(permission: 'microphone' | 'camera'): Promise<boolean>;
   };
+  nativeEvents: {
+    speechActivity: {
+      /**
+       * Subscribes to native speech activity events.
+       * Returns an unsubscribe function.
+       */
+      subscribe(cb: (state: { isSoundDetected: boolean }) => void): () => void;
+    };
+  };
 };
 
 declare global {

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

@@ -1,23 +0,0 @@
-import { SoundStateChangeHandler } from './sound-detector';
-export declare class RNSpeechDetector {
-    private readonly pc1;
-    private readonly pc2;
-    private audioStream;
-    private externalAudioStream;
-    private isStopped;
-    constructor(externalAudioStream?: MediaStream);
-    /**
-     * Starts the speech detection.
-     */
-    start(onSoundDetectedStateChanged: SoundStateChangeHandler): Promise<() => void>;
-    /**
-     * Stops the speech detection and releases all allocated resources.
-     */
-    private stop;
-    /**
-     * Public method that detects the audio levels and returns the status.
-     */
-    private onSpeakingDetectedStateChange;
-    private cleanupAudioStream;
-    private forwardIceCandidate;
-}