@stream-io/video-client 1.46.0 → 1.47.0

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/helpers/RNSpeechDetector.d.ts

@@ -1,9 +1,10 @@
 import { SoundStateChangeHandler } from './sound-detector';
 export declare class RNSpeechDetector {
-    private pc1;
-    private pc2;
+    private readonly pc1;
+    private readonly pc2;
     private audioStream;
     private externalAudioStream;
+    private isStopped;
     constructor(externalAudioStream?: MediaStream);
     /**
      * Starts the speech detection.
@@ -18,4 +19,5 @@ export declare class RNSpeechDetector {
      */
     private onSpeakingDetectedStateChange;
     private cleanupAudioStream;
+    private forwardIceCandidate;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.46.0",
+  "version": "1.47.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

@@ -356,7 +356,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);
     }
 

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__/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/helpers/RNSpeechDetector.ts

@@ -3,10 +3,11 @@ import { SoundStateChangeHandler } from './sound-detector';
 import { videoLoggerSystem } from '../logger';
 
 export class RNSpeechDetector {
-  private pc1 = new RTCPeerConnection({});
-  private pc2 = new RTCPeerConnection({});
+  private readonly pc1 = new RTCPeerConnection({});
+  private readonly pc2 = new RTCPeerConnection({});
   private audioStream: MediaStream | undefined;
   private externalAudioStream: MediaStream | undefined;
+  private isStopped = false;
 
   constructor(externalAudioStream?: MediaStream) {
     this.externalAudioStream = externalAudioStream;
@@ -16,31 +17,40 @@ export class RNSpeechDetector {
    * Starts the speech detection.
    */
   public async start(onSoundDetectedStateChanged: SoundStateChangeHandler) {
+    let detachListeners: (() => void) | undefined;
+    let unsubscribe: (() => void) | undefined;
+
     try {
+      this.isStopped = false;
       const audioStream =
         this.externalAudioStream != null
           ? this.externalAudioStream
           : await navigator.mediaDevices.getUserMedia({ audio: true });
       this.audioStream = audioStream;
 
-      this.pc1.addEventListener('icecandidate', (e) => {
-        this.pc2.addIceCandidate(e.candidate).catch(() => {
-          // do nothing
-        });
-      });
-      this.pc2.addEventListener('icecandidate', async (e) => {
-        this.pc1.addIceCandidate(e.candidate).catch(() => {
-          // do nothing
-        });
-      });
-      this.pc2.addEventListener('track', (e) => {
+      const onPc1IceCandidate = (e: RTCPeerConnectionIceEvent) => {
+        this.forwardIceCandidate(this.pc2, e.candidate);
+      };
+      const onPc2IceCandidate = (e: RTCPeerConnectionIceEvent) => {
+        this.forwardIceCandidate(this.pc1, e.candidate);
+      };
+      const onTrackPc2 = (e: RTCTrackEvent) => {
         e.streams[0].getTracks().forEach((track) => {
           // In RN, the remote track is automatically added to the audio output device
           // so we need to mute it to avoid hearing the audio back
           // @ts-expect-error _setVolume is a private method in react-native-webrtc
           track._setVolume(0);
         });
-      });
+      };
+
+      this.pc1.addEventListener('icecandidate', onPc1IceCandidate);
+      this.pc2.addEventListener('icecandidate', onPc2IceCandidate);
+      this.pc2.addEventListener('track', onTrackPc2);
+      detachListeners = () => {
+        this.pc1.removeEventListener('icecandidate', onPc1IceCandidate);
+        this.pc2.removeEventListener('icecandidate', onPc2IceCandidate);
+        this.pc2.removeEventListener('track', onTrackPc2);
+      };
 
       audioStream
         .getTracks()
@@ -51,14 +61,19 @@ export class RNSpeechDetector {
       const answer = await this.pc2.createAnswer();
       await this.pc1.setRemoteDescription(answer);
       await this.pc2.setLocalDescription(answer);
-      const unsubscribe = this.onSpeakingDetectedStateChange(
+      unsubscribe = this.onSpeakingDetectedStateChange(
         onSoundDetectedStateChanged,
       );
       return () => {
-        unsubscribe();
+        detachListeners?.();
+        unsubscribe?.();
         this.stop();
       };
     } catch (error) {
+      detachListeners?.();
+      unsubscribe?.();
+      this.stop();
+
       const logger = videoLoggerSystem.getLogger('RNSpeechDetector');
       logger.error('error handling permissions: ', error);
       return () => {};
@@ -69,6 +84,9 @@ export class RNSpeechDetector {
    * Stops the speech detection and releases all allocated resources.
    */
   private stop() {
+    if (this.isStopped) return;
+    this.isStopped = true;
+
     this.pc1.close();
     this.pc2.close();
 
@@ -185,4 +203,22 @@ export class RNSpeechDetector {
       this.audioStream.release();
     }
   }
+
+  private forwardIceCandidate(
+    destination: RTCPeerConnection,
+    candidate: RTCIceCandidate | null,
+  ) {
+    if (
+      this.isStopped ||
+      !candidate ||
+      destination.signalingState === 'closed'
+    ) {
+      return;
+    }
+    destination.addIceCandidate(candidate).catch(() => {
+      // silently ignore the error
+      const logger = videoLoggerSystem.getLogger('RNSpeechDetector');
+      logger.info('cannot add ice candidate - ignoring');
+    });
+  }
 }

package/src/helpers/__tests__/RNSpeechDetector.test.ts

@@ -0,0 +1,52 @@
+import '../../rtc/__tests__/mocks/webrtc.mocks';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { RNSpeechDetector } from '../RNSpeechDetector';
+
+describe('RNSpeechDetector', () => {
+  // Shared test setup stubs RTCPeerConnection with a vi.fn constructor.
+  // We keep a typed handle to that constructor to inspect created instances.
+  let rtcPeerConnectionMockCtor: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    rtcPeerConnectionMockCtor =
+      globalThis.RTCPeerConnection as unknown as ReturnType<typeof vi.fn>;
+    rtcPeerConnectionMockCtor.mockClear();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('ignores late ICE candidates after cleanup', async () => {
+    const stream = {
+      getTracks: () => [],
+    } as unknown as MediaStream;
+    const detector = new RNSpeechDetector(stream);
+
+    const cleanup = await detector.start(() => {});
+    cleanup();
+
+    // start() creates two peer connections (pc1 and pc2). We pull them from
+    // constructor call results to inspect listener wiring and ICE forwarding.
+    const [pc1, pc2] = rtcPeerConnectionMockCtor.mock.results.map(
+      (result) => result.value,
+    );
+
+    // Find the registered ICE callback and invoke it manually after cleanup to
+    // simulate a late ICE event arriving during teardown.
+    const onIceCandidate = pc1.addEventListener.mock.calls.find(
+      ([eventName]: [string]) => eventName === 'icecandidate',
+    )?.[1] as ((e: RTCPeerConnectionIceEvent) => void) | undefined;
+
+    expect(onIceCandidate).toBeDefined();
+    onIceCandidate?.({
+      candidate: { candidate: 'candidate:1 1 UDP 0 127.0.0.1 11111 typ host' },
+    } as unknown as RTCPeerConnectionIceEvent);
+
+    expect(pc1.removeEventListener).toHaveBeenCalledWith(
+      'icecandidate',
+      onIceCandidate,
+    );
+    expect(pc2.addIceCandidate).not.toHaveBeenCalled();
+  });
+});