@stream-io/video-client 0.7.9 → 0.7.11

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

@@ -23,6 +23,6 @@ export declare class CameraManagerState extends InputMediaDeviceManagerState {
     /**
      * @internal
      */
-    setMediaStream(stream: MediaStream | undefined): void;
+    setMediaStream(stream: MediaStream | undefined, rootStream: MediaStream | undefined): void;
     protected getDeviceIdFromStream(stream: MediaStream): string | undefined;
 }

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

@@ -1,8 +1,9 @@
 import { BehaviorSubject, Observable } from 'rxjs';
 import { RxUtils } from '../store';
 export type InputDeviceStatus = 'enabled' | 'disabled' | undefined;
+export type TrackDisableMode = 'stop-tracks' | 'disable-tracks';
 export declare abstract class InputMediaDeviceManagerState<C = MediaTrackConstraints> {
-    readonly disableMode: 'stop-tracks' | 'disable-tracks';
+    readonly disableMode: TrackDisableMode;
     private readonly permissionName;
     protected statusSubject: BehaviorSubject<InputDeviceStatus>;
     protected mediaStreamSubject: BehaviorSubject<MediaStream | undefined>;
@@ -41,7 +42,7 @@ export declare abstract class InputMediaDeviceManagerState<C = MediaTrackConstra
      * @param permissionName the permission name to use for querying.
      * `undefined` means no permission is required.
      */
-    constructor(disableMode?: 'stop-tracks' | 'disable-tracks', permissionName?: PermissionName | undefined);
+    constructor(disableMode?: TrackDisableMode, permissionName?: PermissionName | undefined);
     /**
      * The device status
      */
@@ -67,10 +68,14 @@ export declare abstract class InputMediaDeviceManagerState<C = MediaTrackConstra
      */
     setStatus(status: InputDeviceStatus): void;
     /**
+     * Updates the `mediaStream` state variable.
+     *
      * @internal
      * @param stream the stream to set.
+     * @param rootStream the root stream, applicable when filters are used
+     * as this is the stream that holds the actual deviceId information.
      */
-    setMediaStream(stream: MediaStream | undefined): void;
+    setMediaStream(stream: MediaStream | undefined, rootStream: MediaStream | undefined): void;
     /**
      * @internal
      * @param deviceId the device id to set.

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

@@ -3,13 +3,15 @@ import type { INoiseCancellation } from '@stream-io/audio-filters-web';
 import { Call } from '../Call';
 import { InputMediaDeviceManager } from './InputMediaDeviceManager';
 import { MicrophoneManagerState } from './MicrophoneManagerState';
+import { TrackDisableMode } from './InputMediaDeviceManagerState';
 export declare class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManagerState> {
+    private speakingWhileMutedNotificationEnabled;
     private soundDetectorCleanup?;
     private rnSpeechDetector;
     private noiseCancellation;
     private noiseCancellationChangeUnsubscribe;
     private noiseCancellationRegistration?;
-    constructor(call: Call);
+    constructor(call: Call, disableMode?: TrackDisableMode);
     /**
      * Enables noise cancellation for the microphone.
      *
@@ -23,6 +25,14 @@ export declare class MicrophoneManager extends InputMediaDeviceManager<Microphon
      * Note: not supported in React Native.
      */
     disableNoiseCancellation(): Promise<void>;
+    /**
+     * Enables speaking while muted notification.
+     */
+    enableSpeakingWhileMutedNotification(): Promise<void>;
+    /**
+     * Disables speaking while muted notification.
+     */
+    disableSpeakingWhileMutedNotification(): Promise<void>;
     protected getDevices(): Observable<MediaDeviceInfo[]>;
     protected getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
     protected publishStream(stream: MediaStream): Promise<void>;

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

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { InputMediaDeviceManagerState } from './InputMediaDeviceManagerState';
+import { InputMediaDeviceManagerState, TrackDisableMode } from './InputMediaDeviceManagerState';
 export declare class MicrophoneManagerState extends InputMediaDeviceManagerState {
     private speakingWhileMutedSubject;
     /**
@@ -8,7 +8,7 @@ export declare class MicrophoneManagerState extends InputMediaDeviceManagerState
      * This feature is not available in the React Native SDK.
      */
     speakingWhileMuted$: Observable<boolean>;
-    constructor();
+    constructor(disableMode: TrackDisableMode);
     /**
      * `true` if the user's microphone is muted but they'are speaking.
      *

package/dist/src/store/CallState.d.ts

@@ -5,7 +5,6 @@ import { CallStatsReport } from '../stats';
 import { CallIngressResponse, CallResponse, CallSessionResponse, CallSettingsResponse, EgressResponse, MemberResponse, OwnCapability, ThumbnailResponse, UserResponse, WSEvent } from '../gen/coordinator';
 import { Pin } from '../gen/video/sfu/models/models';
 import { Comparator } from '../sorting';
-import { Logger } from '../coordinator/connection/types';
 /**
  * Represents the state of the current call.
  */
@@ -211,7 +210,7 @@ export declare class CallState {
      * Will provide the thumbnails of this call.
      */
     thumbnails$: Observable<ThumbnailResponse | undefined>;
-    readonly logger: Logger;
+    readonly logger: import("../..").Logger;
     /**
      * A list of comparators that are used to sort the participants.
      *

package/package.json

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

package/src/devices/CameraManagerState.ts

@@ -45,8 +45,11 @@ export class CameraManagerState extends InputMediaDeviceManagerState {
   /**
    * @internal
    */
-  setMediaStream(stream: MediaStream | undefined): void {
-    super.setMediaStream(stream);
+  setMediaStream(
+    stream: MediaStream | undefined,
+    rootStream: MediaStream | undefined,
+  ): void {
+    super.setMediaStream(stream, rootStream);
     if (stream) {
       // RN getSettings() doesn't return facingMode, so we don't verify camera direction
       const direction = isReactNative()
@@ -59,8 +62,7 @@ export class CameraManagerState extends InputMediaDeviceManagerState {
   }
 
   protected getDeviceIdFromStream(stream: MediaStream): string | undefined {
-    return stream.getVideoTracks()[0]?.getSettings().deviceId as
-      | string
-      | undefined;
+    const [track] = stream.getVideoTracks();
+    return track?.getSettings().deviceId;
   }
 }

package/src/devices/InputMediaDeviceManager.ts

@@ -209,7 +209,7 @@ export abstract class InputMediaDeviceManager<
         // @ts-expect-error called to dispose the stream in RN
         this.state.mediaStream.release();
       }
-      this.state.setMediaStream(undefined);
+      this.state.setMediaStream(undefined, undefined);
     }
   }
 
@@ -245,6 +245,7 @@ export abstract class InputMediaDeviceManager<
   protected async unmuteStream() {
     this.logger('debug', 'Starting stream');
     let stream: MediaStream;
+    let rootStream: Promise<MediaStream> | undefined;
     if (
       this.state.mediaStream &&
       this.getTracks().every((t) => t.readyState === 'live')
@@ -315,17 +316,20 @@ export abstract class InputMediaDeviceManager<
           return filterStream;
         };
 
+      // the rootStream represents the stream coming from the actual device
+      // e.g. camera or microphone stream
+      rootStream = this.getStream(constraints as C);
       // we publish the last MediaStream of the chain
       stream = await this.filters.reduce(
         (parent, filter) => parent.then(filter).then(chainWith(parent)),
-        this.getStream(constraints as C),
+        rootStream,
       );
     }
     if (this.call.state.callingState === CallingState.JOINED) {
       await this.publishStream(stream);
     }
     if (this.state.mediaStream !== stream) {
-      this.state.setMediaStream(stream);
+      this.state.setMediaStream(stream, await rootStream);
       this.getTracks().forEach((track) => {
         track.addEventListener('ended', async () => {
           if (this.enablePromise) {

package/src/devices/InputMediaDeviceManagerState.ts

@@ -9,6 +9,7 @@ import { RxUtils } from '../store';
 import { getLogger } from '../logger';
 
 export type InputDeviceStatus = 'enabled' | 'disabled' | undefined;
+export type TrackDisableMode = 'stop-tracks' | 'disable-tracks';
 
 export abstract class InputMediaDeviceManagerState<C = MediaTrackConstraints> {
   protected statusSubject = new BehaviorSubject<InputDeviceStatus>(undefined);
@@ -102,9 +103,7 @@ export abstract class InputMediaDeviceManagerState<C = MediaTrackConstraints> {
    * `undefined` means no permission is required.
    */
   constructor(
-    public readonly disableMode:
-      | 'stop-tracks'
-      | 'disable-tracks' = 'stop-tracks',
+    public readonly disableMode: TrackDisableMode = 'stop-tracks',
     private readonly permissionName: PermissionName | undefined = undefined,
   ) {}
 
@@ -146,13 +145,20 @@ export abstract class InputMediaDeviceManagerState<C = MediaTrackConstraints> {
   }
 
   /**
+   * Updates the `mediaStream` state variable.
+   *
    * @internal
    * @param stream the stream to set.
+   * @param rootStream the root stream, applicable when filters are used
+   * as this is the stream that holds the actual deviceId information.
    */
-  setMediaStream(stream: MediaStream | undefined) {
+  setMediaStream(
+    stream: MediaStream | undefined,
+    rootStream: MediaStream | undefined,
+  ) {
     this.setCurrentValue(this.mediaStreamSubject, stream);
-    if (stream) {
-      this.setDevice(this.getDeviceIdFromStream(stream));
+    if (rootStream) {
+      this.setDevice(this.getDeviceIdFromStream(rootStream));
     }
   }
 

package/src/devices/MicrophoneManager.ts

@@ -3,6 +3,7 @@ import type { INoiseCancellation } from '@stream-io/audio-filters-web';
 import { Call } from '../Call';
 import { InputMediaDeviceManager } from './InputMediaDeviceManager';
 import { MicrophoneManagerState } from './MicrophoneManagerState';
+import { TrackDisableMode } from './InputMediaDeviceManagerState';
 import { getAudioDevices, getAudioStream } from './devices';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { createSoundDetector } from '../helpers/sound-detector';
@@ -16,37 +17,48 @@ import { createSubscription } from '../store/rxUtils';
 import { RNSpeechDetector } from '../helpers/RNSpeechDetector';
 
 export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManagerState> {
+  private speakingWhileMutedNotificationEnabled = true;
   private soundDetectorCleanup?: Function;
   private rnSpeechDetector: RNSpeechDetector | undefined;
   private noiseCancellation: INoiseCancellation | undefined;
   private noiseCancellationChangeUnsubscribe: (() => void) | undefined;
   private noiseCancellationRegistration?: Promise<() => Promise<void>>;
 
-  constructor(call: Call) {
-    super(call, new MicrophoneManagerState(), TrackType.AUDIO);
-
-    combineLatest([
-      this.call.state.callingState$,
-      this.call.state.ownCapabilities$,
-      this.state.selectedDevice$,
-      this.state.status$,
-    ]).subscribe(async ([callingState, ownCapabilities, deviceId, status]) => {
-      if (callingState !== CallingState.JOINED) {
-        if (callingState === CallingState.LEFT) {
-          await this.stopSpeakingWhileMutedDetection();
-        }
-        return;
-      }
-      if (ownCapabilities.includes(OwnCapability.SEND_AUDIO)) {
-        if (status === 'disabled') {
-          await this.startSpeakingWhileMutedDetection(deviceId);
-        } else {
-          await this.stopSpeakingWhileMutedDetection();
-        }
-      } else {
-        await this.stopSpeakingWhileMutedDetection();
-      }
-    });
+  constructor(
+    call: Call,
+    disableMode: TrackDisableMode = isReactNative()
+      ? 'disable-tracks'
+      : 'stop-tracks',
+  ) {
+    super(call, new MicrophoneManagerState(disableMode), TrackType.AUDIO);
+
+    this.subscriptions.push(
+      createSubscription(
+        combineLatest([
+          this.call.state.callingState$,
+          this.call.state.ownCapabilities$,
+          this.state.selectedDevice$,
+          this.state.status$,
+        ]),
+        async ([callingState, ownCapabilities, deviceId, status]) => {
+          if (callingState === CallingState.LEFT) {
+            await this.stopSpeakingWhileMutedDetection();
+          }
+          if (callingState !== CallingState.JOINED) return;
+          if (!this.speakingWhileMutedNotificationEnabled) return;
+
+          if (ownCapabilities.includes(OwnCapability.SEND_AUDIO)) {
+            if (status === 'disabled') {
+              await this.startSpeakingWhileMutedDetection(deviceId);
+            } else {
+              await this.stopSpeakingWhileMutedDetection();
+            }
+          } else {
+            await this.stopSpeakingWhileMutedDetection();
+          }
+        },
+      ),
+    );
 
     this.subscriptions.push(
       createSubscription(this.call.state.callingState$, (callingState) => {
@@ -163,6 +175,24 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
     await this.call.notifyNoiseCancellationStopped();
   }
 
+  /**
+   * Enables speaking while muted notification.
+   */
+  async enableSpeakingWhileMutedNotification() {
+    this.speakingWhileMutedNotificationEnabled = true;
+    if (this.state.status === 'disabled') {
+      await this.startSpeakingWhileMutedDetection(this.state.selectedDevice);
+    }
+  }
+
+  /**
+   * Disables speaking while muted notification.
+   */
+  async disableSpeakingWhileMutedNotification() {
+    this.speakingWhileMutedNotificationEnabled = false;
+    await this.stopSpeakingWhileMutedDetection();
+  }
+
   protected getDevices(): Observable<MediaDeviceInfo[]> {
     return getAudioDevices();
   }
@@ -208,9 +238,7 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
   }
 
   private async stopSpeakingWhileMutedDetection() {
-    if (!this.soundDetectorCleanup) {
-      return;
-    }
+    if (!this.soundDetectorCleanup) return;
     this.state.setSpeakingWhileMuted(false);
     try {
       await this.soundDetectorCleanup();

package/src/devices/MicrophoneManagerState.ts

@@ -1,5 +1,8 @@
 import { BehaviorSubject, distinctUntilChanged, Observable } from 'rxjs';
-import { InputMediaDeviceManagerState } from './InputMediaDeviceManagerState';
+import {
+  InputMediaDeviceManagerState,
+  TrackDisableMode,
+} from './InputMediaDeviceManagerState';
 
 export class MicrophoneManagerState extends InputMediaDeviceManagerState {
   private speakingWhileMutedSubject = new BehaviorSubject<boolean>(false);
@@ -11,9 +14,9 @@ export class MicrophoneManagerState extends InputMediaDeviceManagerState {
    */
   speakingWhileMuted$: Observable<boolean>;
 
-  constructor() {
+  constructor(disableMode: TrackDisableMode) {
     super(
-      'disable-tracks',
+      disableMode,
       // `microphone` is not in the W3C standard yet,
       // but it's supported by Chrome and Safari.
       'microphone' as PermissionName,
@@ -41,8 +44,7 @@ export class MicrophoneManagerState extends InputMediaDeviceManagerState {
   }
 
   protected getDeviceIdFromStream(stream: MediaStream): string | undefined {
-    return stream.getAudioTracks()[0]?.getSettings().deviceId as
-      | string
-      | undefined;
+    const [track] = stream.getAudioTracks();
+    return track?.getSettings().deviceId;
   }
 }

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

@@ -76,6 +76,7 @@ describe('MicrophoneManager', () => {
         streamClient: new StreamClient('abc123'),
         clientStore: new StreamVideoWriteableStateStore(),
       }),
+      'disable-tracks',
     );
   });
   it('list devices', () => {
@@ -147,65 +148,88 @@ describe('MicrophoneManager', () => {
     expect(manager.state.mediaStream).toBeUndefined();
   });
 
-  it(`should start sound detection if mic is disabled`, async () => {
-    await manager.enable();
-    // @ts-expect-error
-    vi.spyOn(manager, 'startSpeakingWhileMutedDetection');
-    await manager.disable();
+  describe('Speaking While Muted', () => {
+    it(`should start sound detection if mic is disabled`, async () => {
+      await manager.enable();
+      // @ts-expect-error
+      vi.spyOn(manager, 'startSpeakingWhileMutedDetection');
+      await manager.disable();
 
-    expect(manager['startSpeakingWhileMutedDetection']).toHaveBeenCalled();
-  });
+      expect(manager['startSpeakingWhileMutedDetection']).toHaveBeenCalled();
+    });
 
-  it(`should stop sound detection if mic is enabled`, async () => {
-    manager.state.setSpeakingWhileMuted(true);
-    manager['soundDetectorCleanup'] = () => {};
+    it(`should stop sound detection if mic is enabled`, async () => {
+      manager.state.setSpeakingWhileMuted(true);
+      manager['soundDetectorCleanup'] = () => {};
 
-    await manager.enable();
+      await manager.enable();
 
-    expect(manager.state.speakingWhileMuted).toBe(false);
-  });
-
-  it('should update speaking while muted state', async () => {
-    const mock = createSoundDetector as Mock;
-    let handler: SoundStateChangeHandler;
-    mock.mockImplementation((_: MediaStream, h: SoundStateChangeHandler) => {
-      handler = h;
+      expect(manager.state.speakingWhileMuted).toBe(false);
     });
-    await manager['startSpeakingWhileMutedDetection']();
 
-    expect(manager.state.speakingWhileMuted).toBe(false);
+    it('should update speaking while muted state', async () => {
+      const mock = createSoundDetector as Mock;
+      let handler: SoundStateChangeHandler;
+      mock.mockImplementation((_: MediaStream, h: SoundStateChangeHandler) => {
+        handler = h;
+      });
+      await manager['startSpeakingWhileMutedDetection']();
 
-    handler!({ isSoundDetected: true, audioLevel: 2 });
+      expect(manager.state.speakingWhileMuted).toBe(false);
 
-    expect(manager.state.speakingWhileMuted).toBe(true);
+      handler!({ isSoundDetected: true, audioLevel: 2 });
 
-    handler!({ isSoundDetected: false, audioLevel: 0 });
+      expect(manager.state.speakingWhileMuted).toBe(true);
 
-    expect(manager.state.speakingWhileMuted).toBe(false);
-  });
+      handler!({ isSoundDetected: false, audioLevel: 0 });
 
-  it('should stop speaking while muted notifications if user loses permission to send audio', async () => {
-    await manager.enable();
-    await manager.disable();
+      expect(manager.state.speakingWhileMuted).toBe(false);
+    });
 
-    // @ts-expect-error
-    vi.spyOn(manager, 'stopSpeakingWhileMutedDetection');
-    manager['call'].state.setOwnCapabilities([]);
+    it('should stop speaking while muted notifications if user loses permission to send audio', async () => {
+      await manager.enable();
+      await manager.disable();
 
-    expect(manager['stopSpeakingWhileMutedDetection']).toHaveBeenCalled();
-  });
+      // @ts-expect-error
+      vi.spyOn(manager, 'stopSpeakingWhileMutedDetection');
+      manager['call'].state.setOwnCapabilities([]);
 
-  it('should start speaking while muted notifications if user gains permission to send audio', async () => {
-    await manager.enable();
-    await manager.disable();
+      expect(manager['stopSpeakingWhileMutedDetection']).toHaveBeenCalled();
+    });
+
+    it('should start speaking while muted notifications if user gains permission to send audio', async () => {
+      await manager.enable();
+      await manager.disable();
 
-    manager['call'].state.setOwnCapabilities([]);
+      manager['call'].state.setOwnCapabilities([]);
 
-    // @ts-expect-error
-    vi.spyOn(manager, 'stopSpeakingWhileMutedDetection');
-    manager['call'].state.setOwnCapabilities([OwnCapability.SEND_AUDIO]);
+      // @ts-expect-error
+      vi.spyOn(manager, 'stopSpeakingWhileMutedDetection');
+      manager['call'].state.setOwnCapabilities([OwnCapability.SEND_AUDIO]);
 
-    expect(manager['stopSpeakingWhileMutedDetection']).toHaveBeenCalled();
+      expect(manager['stopSpeakingWhileMutedDetection']).toHaveBeenCalled();
+    });
+
+    it(`disables speaking while muted notifications`, async () => {
+      // @ts-expect-error - private api
+      vi.spyOn(manager, 'startSpeakingWhileMutedDetection');
+      // @ts-expect-error - private api
+      vi.spyOn(manager, 'stopSpeakingWhileMutedDetection');
+      await manager.disableSpeakingWhileMutedNotification();
+      await manager.disable();
+      expect(manager['stopSpeakingWhileMutedDetection']).toHaveBeenCalled();
+      expect(
+        manager['startSpeakingWhileMutedDetection'],
+      ).not.toHaveBeenCalled();
+    });
+
+    it(`enables speaking while muted notifications`, async () => {
+      // @ts-expect-error - private api
+      vi.spyOn(manager, 'startSpeakingWhileMutedDetection');
+      await manager.enableSpeakingWhileMutedNotification();
+      await manager.disable();
+      expect(manager['startSpeakingWhileMutedDetection']).toHaveBeenCalled();
+    });
   });
 
   describe('Noise Cancellation', () => {

package/src/helpers/RNSpeechDetector.ts

@@ -1,18 +1,6 @@
 import { BaseStats } from '../stats';
 import { SoundStateChangeHandler } from './sound-detector';
-
-/**
- * Flatten the stats report into an array of stats objects.
- *
- * @param report the report to flatten.
- */
-const flatten = (report: RTCStatsReport) => {
-  const stats: RTCStats[] = [];
-  report.forEach((s) => {
-    stats.push(s);
-  });
-  return stats;
-};
+import { flatten } from '../stats/utils';
 
 const AUDIO_LEVEL_THRESHOLD = 0.2;