@stream-io/video-client 1.32.0 → 1.33.1

package/src/devices/MicrophoneManager.ts

@@ -1,11 +1,14 @@
 import { combineLatest, Observable } from 'rxjs';
 import type { INoiseCancellation } from '@stream-io/audio-filters-web';
 import { Call } from '../Call';
-import { InputMediaDeviceManager } from './InputMediaDeviceManager';
+import {
+  AudioDeviceManager,
+  createAudioConstraints,
+} from './AudioDeviceManager';
 import { MicrophoneManagerState } from './MicrophoneManagerState';
-import { TrackDisableMode } from './InputMediaDeviceManagerState';
+import { TrackDisableMode } from './DeviceManagerState';
 import { getAudioDevices, getAudioStream } from './devices';
-import { TrackType } from '../gen/video/sfu/models/models';
+import { AudioBitrateProfile, TrackType } from '../gen/video/sfu/models/models';
 import { createSoundDetector } from '../helpers/sound-detector';
 import { isReactNative } from '../helpers/platforms';
 import {
@@ -21,7 +24,7 @@ import {
 import { RNSpeechDetector } from '../helpers/RNSpeechDetector';
 import { withoutConcurrency } from '../helpers/concurrency';
 
-export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManagerState> {
+export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState> {
   private speakingWhileMutedNotificationEnabled = true;
   private soundDetectorConcurrencyTag = Symbol('soundDetectorConcurrencyTag');
   private soundDetectorCleanup?: Function;
@@ -245,16 +248,33 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
     }
   }
 
-  protected getDevices(): Observable<MediaDeviceInfo[]> {
+  protected override getDevices(): Observable<MediaDeviceInfo[]> {
     return getAudioDevices(this.call.tracer);
   }
 
-  protected getStream(
+  protected override getStream(
     constraints: MediaTrackConstraints,
   ): Promise<MediaStream> {
     return getAudioStream(constraints, this.call.tracer);
   }
 
+  protected override doSetAudioBitrateProfile(profile: AudioBitrateProfile) {
+    this.setDefaultConstraints({
+      ...this.state.defaultConstraints,
+      ...createAudioConstraints(profile),
+    });
+
+    if (this.noiseCancellation) {
+      const disableAudioProcessing =
+        profile === AudioBitrateProfile.MUSIC_HIGH_QUALITY;
+      if (disableAudioProcessing) {
+        this.noiseCancellation.disable(); // disable for high quality music mode
+      } else {
+        this.noiseCancellation.enable(); // restore it for other modes if available
+      }
+    }
+  }
+
   private async startSpeakingWhileMutedDetection(deviceId?: string) {
     await withoutConcurrency(this.soundDetectorConcurrencyTag, async () => {
       await this.stopSpeakingWhileMutedDetection();

package/src/devices/MicrophoneManagerState.ts

@@ -1,33 +1,30 @@
-import { BehaviorSubject, distinctUntilChanged, Observable } from 'rxjs';
+import { BehaviorSubject, distinctUntilChanged } from 'rxjs';
 import { RxUtils } from '../store';
-import {
-  InputMediaDeviceManagerState,
-  TrackDisableMode,
-} from './InputMediaDeviceManagerState';
+import { TrackDisableMode } from './DeviceManagerState';
+import { AudioDeviceManagerState } from './AudioDeviceManagerState';
 import { getAudioBrowserPermission, resolveDeviceId } from './devices';
+import { AudioBitrateProfile } from '../gen/video/sfu/models/models';
 
-export class MicrophoneManagerState extends InputMediaDeviceManagerState {
+export class MicrophoneManagerState extends AudioDeviceManagerState<MediaTrackConstraints> {
   private speakingWhileMutedSubject = new BehaviorSubject<boolean>(false);
 
   /**
-   * An Observable that emits `true` if the user's microphone is muted but they'are speaking.
-   *
-   * This feature is not available in the React Native SDK.
+   * An Observable that emits `true` if the user's microphone is muted, but they're speaking.
    */
-  speakingWhileMuted$: Observable<boolean>;
+  speakingWhileMuted$ = this.speakingWhileMutedSubject
+    .asObservable()
+    .pipe(distinctUntilChanged());
 
   constructor(disableMode: TrackDisableMode) {
-    super(disableMode, getAudioBrowserPermission());
-
-    this.speakingWhileMuted$ = this.speakingWhileMutedSubject
-      .asObservable()
-      .pipe(distinctUntilChanged());
+    super(
+      disableMode,
+      getAudioBrowserPermission(),
+      AudioBitrateProfile.VOICE_STANDARD_UNSPECIFIED,
+    );
   }
 
   /**
-   * `true` if the user's microphone is muted but they'are speaking.
-   *
-   * This feature is not available in the React Native SDK.
+   * `true` if the user's microphone is muted but they're speaking.
    */
   get speakingWhileMuted() {
     return RxUtils.getCurrentValue(this.speakingWhileMuted$);
@@ -40,7 +37,9 @@ export class MicrophoneManagerState extends InputMediaDeviceManagerState {
     RxUtils.setCurrentValue(this.speakingWhileMutedSubject, isSpeaking);
   }
 
-  protected getDeviceIdFromStream(stream: MediaStream): string | undefined {
+  protected override getDeviceIdFromStream(
+    stream: MediaStream,
+  ): string | undefined {
     const [track] = stream.getAudioTracks();
     const unresolvedDeviceId = track?.getSettings().deviceId;
     return resolveDeviceId(unresolvedDeviceId, 'audioinput');

package/src/devices/ScreenShareManager.ts

@@ -1,13 +1,16 @@
 import { Observable, of } from 'rxjs';
-import { InputMediaDeviceManager } from './InputMediaDeviceManager';
+import {
+  AudioDeviceManager,
+  createAudioConstraints,
+} from './AudioDeviceManager';
 import { ScreenShareState } from './ScreenShareState';
 import { Call } from '../Call';
-import { TrackType } from '../gen/video/sfu/models/models';
+import { AudioBitrateProfile, TrackType } from '../gen/video/sfu/models/models';
 import { getScreenShareStream } from './devices';
 import { ScreenShareSettings } from '../types';
 import { createSubscription } from '../store/rxUtils';
 
-export class ScreenShareManager extends InputMediaDeviceManager<
+export class ScreenShareManager extends AudioDeviceManager<
   ScreenShareState,
   DisplayMediaStreamOptions
 > {
@@ -23,6 +26,7 @@ export class ScreenShareManager extends InputMediaDeviceManager<
 
         if (maybeTargetResolution) {
           this.setDefaultConstraints({
+            ...this.state.defaultConstraints,
             video: {
               width: maybeTargetResolution.width,
               height: maybeTargetResolution.height,
@@ -73,7 +77,7 @@ export class ScreenShareManager extends InputMediaDeviceManager<
     return of([]); // there are no devices to be listed for Screen Share
   }
 
-  protected async getStream(
+  protected override async getStream(
     constraints: DisplayMediaStreamOptions,
   ): Promise<MediaStream> {
     if (!this.state.audioEnabled) {
@@ -92,6 +96,21 @@ export class ScreenShareManager extends InputMediaDeviceManager<
     return stream;
   }
 
+  protected override doSetAudioBitrateProfile(profile: AudioBitrateProfile) {
+    const { defaultConstraints } = this.state;
+    const baseAudioConstraints =
+      typeof defaultConstraints?.audio !== 'boolean'
+        ? defaultConstraints?.audio
+        : null;
+    this.setDefaultConstraints({
+      ...defaultConstraints,
+      audio: {
+        ...baseAudioConstraints,
+        ...createAudioConstraints(profile),
+      },
+    });
+  }
+
   protected override async stopPublishStream(): Promise<void> {
     return this.call.stopPublish(
       TrackType.SCREEN_SHARE,

package/src/devices/ScreenShareState.ts

@@ -1,9 +1,10 @@
 import { BehaviorSubject, distinctUntilChanged } from 'rxjs';
-import { InputMediaDeviceManagerState } from './InputMediaDeviceManagerState';
+import { AudioDeviceManagerState } from './AudioDeviceManagerState';
+import { AudioBitrateProfile } from '../gen/video/sfu/models/models';
 import { ScreenShareSettings } from '../types';
 import { RxUtils } from '../store';
 
-export class ScreenShareState extends InputMediaDeviceManagerState<DisplayMediaStreamOptions> {
+export class ScreenShareState extends AudioDeviceManagerState<DisplayMediaStreamOptions> {
   private audioEnabledSubject = new BehaviorSubject<boolean>(true);
   private settingsSubject = new BehaviorSubject<
     ScreenShareSettings | undefined
@@ -21,10 +22,17 @@ export class ScreenShareState extends InputMediaDeviceManagerState<DisplayMediaS
    */
   settings$ = this.settingsSubject.asObservable();
 
+  /**
+   * Constructs a new ScreenShareState instance.
+   */
+  constructor() {
+    super('stop-tracks', undefined, AudioBitrateProfile.MUSIC_HIGH_QUALITY);
+  }
+
   /**
    * @internal
    */
-  protected getDeviceIdFromStream = (
+  protected override getDeviceIdFromStream = (
     stream: MediaStream,
   ): string | undefined => {
     const [track] = stream.getTracks();

package/src/devices/SpeakerState.ts

@@ -1,4 +1,4 @@
-import { BehaviorSubject, distinctUntilChanged, Observable } from 'rxjs';
+import { BehaviorSubject, distinctUntilChanged } from 'rxjs';
 import { RxUtils } from '../store';
 import { checkIfAudioOutputChangeSupported } from './devices';
 import { Tracer } from '../stats';
@@ -16,26 +16,18 @@ export class SpeakerState {
    *
    * Note: this feature is not supported in React Native
    */
-  selectedDevice$: Observable<string>;
+  selectedDevice$ = this.selectedDeviceSubject
+    .asObservable()
+    .pipe(distinctUntilChanged());
 
   /**
    * An Observable that emits the currently selected volume
    *
    * Note: this feature is not supported in React Native
    */
-  volume$: Observable<number>;
+  volume$ = this.volumeSubject.asObservable().pipe(distinctUntilChanged());
 
-  private tracer: Tracer;
-
-  constructor(tracer: Tracer) {
-    this.tracer = tracer;
-    this.selectedDevice$ = this.selectedDeviceSubject
-      .asObservable()
-      .pipe(distinctUntilChanged());
-    this.volume$ = this.volumeSubject
-      .asObservable()
-      .pipe(distinctUntilChanged());
-  }
+  constructor(private tracer: Tracer) {}
 
   /**
    * The currently selected device

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

@@ -106,6 +106,7 @@ describe('CameraManager', () => {
     expect(manager['call'].publish).toHaveBeenCalledWith(
       manager.state.mediaStream,
       TrackType.VIDEO,
+      undefined,
     );
   });
 

package/src/devices/__tests__/{InputMediaDeviceManager.test.ts → DeviceManager.test.ts}

@@ -12,8 +12,8 @@ import {
   mockVideoDevices,
   mockVideoStream,
 } from './mocks';
-import { InputMediaDeviceManager } from '../InputMediaDeviceManager';
-import { InputMediaDeviceManagerState } from '../InputMediaDeviceManagerState';
+import { DeviceManager } from '../DeviceManager';
+import { DeviceManagerState } from '../DeviceManagerState';
 import { of } from 'rxjs';
 import { TrackType } from '../../gen/video/sfu/models/models';
 
@@ -34,13 +34,13 @@ vi.mock('../devices.ts', () => {
   };
 });
 
-class TestInputMediaDeviceManagerState extends InputMediaDeviceManagerState {
+class TestInputMediaDeviceManagerState extends DeviceManagerState {
   public getDeviceIdFromStream = vi.fn(
     (stream) => stream.getVideoTracks()[0].getSettings().deviceId,
   );
 }
 
-class TestInputMediaDeviceManager extends InputMediaDeviceManager<TestInputMediaDeviceManagerState> {
+class TestInputMediaDeviceManager extends DeviceManager<TestInputMediaDeviceManagerState> {
   public getDevices = vi.fn(() => of(mockVideoDevices));
   public getStream = vi.fn(() => Promise.resolve(mockVideoStream()));
   public publishStream = vi.fn();

package/src/devices/__tests__/{InputMediaDeviceManagerFilters.test.ts → DeviceManagerFilters.test.ts}

@@ -3,8 +3,8 @@ import { of } from 'rxjs';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
 import { StreamVideoWriteableStateStore } from '../../store';
-import { InputMediaDeviceManagerState } from '../InputMediaDeviceManagerState';
-import { InputMediaDeviceManager } from '../InputMediaDeviceManager';
+import { DeviceManagerState } from '../DeviceManagerState';
+import { DeviceManager } from '../DeviceManager';
 import {
   mockBrowserPermission,
   mockVideoDevices,
@@ -14,13 +14,13 @@ import { TrackType } from '../../gen/video/sfu/models/models';
 
 import '../../rtc/__tests__/mocks/webrtc.mocks';
 
-class TestInputMediaDeviceManagerState extends InputMediaDeviceManagerState {
+class TestInputMediaDeviceManagerState extends DeviceManagerState {
   public getDeviceIdFromStream = vi.fn(
     (stream) => stream.getTracks()[0].getSettings().deviceId,
   );
 }
 
-class TestInputMediaDeviceManager extends InputMediaDeviceManager<TestInputMediaDeviceManagerState> {
+class TestInputMediaDeviceManager extends DeviceManager<TestInputMediaDeviceManagerState> {
   public getDevices = vi.fn(() => of(mockVideoDevices));
   public getStream = vi.fn(() => Promise.resolve(mockVideoStream()));
   public publishStream = vi.fn();

package/src/devices/__tests__/{InputMediaDeviceManagerState.test.ts → DeviceManagerState.test.ts}

@@ -1,9 +1,9 @@
 import { beforeAll, describe, expect, it, vi } from 'vitest';
-import { InputMediaDeviceManagerState } from '../InputMediaDeviceManagerState';
+import { DeviceManagerState } from '../DeviceManagerState';
 import { firstValueFrom } from 'rxjs';
 import { BrowserPermission } from '../BrowserPermission';
 
-class TestInputMediaDeviceManagerState extends InputMediaDeviceManagerState {
+class TestInputMediaDeviceManagerState extends DeviceManagerState {
   constructor() {
     super(
       'stop-tracks',

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

@@ -7,7 +7,10 @@ import {
   NoiseCancellationSettingsModeEnum,
   OwnCapability,
 } from '../../gen/coordinator';
-import { TrackType } from '../../gen/video/sfu/models/models';
+import {
+  AudioBitrateProfile,
+  TrackType,
+} from '../../gen/video/sfu/models/models';
 import { CallingState, StreamVideoWriteableStateStore } from '../../store';
 import {
   mockAudioDevices,
@@ -100,6 +103,7 @@ describe('MicrophoneManager', () => {
     expect(manager['call'].publish).toHaveBeenCalledWith(
       manager.state.mediaStream,
       TrackType.AUDIO,
+      { audioBitrateProfile: AudioBitrateProfile.VOICE_STANDARD_UNSPECIFIED },
     );
   });
 
@@ -367,6 +371,42 @@ describe('MicrophoneManager', () => {
     });
   });
 
+  describe('Hi-Fi Audio', () => {
+    it('enables hi-fi audio', async () => {
+      call.state.updateFromCallResponse({
+        // @ts-expect-error partial data
+        settings: { audio: { hifi_audio_enabled: true } },
+      });
+
+      await manager.enable();
+
+      // @ts-expect-error - private api
+      const apply = vi.spyOn(manager, 'applySettingsToStream');
+      const publish = vi.spyOn(call, 'publish');
+      const profile = AudioBitrateProfile.MUSIC_HIGH_QUALITY;
+      await manager.setAudioBitrateProfile(profile);
+
+      expect(apply).toHaveBeenCalledOnce();
+      expect(publish).toHaveBeenCalledWith(
+        manager.state.mediaStream,
+        TrackType.AUDIO,
+        { audioBitrateProfile: profile },
+      );
+    });
+
+    it('throws an error when enabling hi-fi audio if not allowed', async () => {
+      call.state.updateFromCallResponse({
+        // @ts-expect-error partial data
+        settings: { audio: { hifi_audio_enabled: false } },
+      });
+
+      await manager.enable();
+      await expect(() =>
+        manager.setAudioBitrateProfile(AudioBitrateProfile.VOICE_HIGH_QUALITY),
+      ).rejects.toThrowError();
+    });
+  });
+
   afterEach(() => {
     vi.clearAllMocks();
     vi.resetModules();

package/src/devices/__tests__/NoiseCancellationStub.ts

@@ -3,9 +3,10 @@ import type { INoiseCancellation } from '@stream-io/audio-filters-web';
 export class NoiseCancellationStub implements INoiseCancellation {
   private listeners: { [event: string]: Array<(arg: boolean) => void> } = {};
 
+  canAutoEnable = async () => true;
   isSupported = () => true;
   init = () => Promise.resolve(undefined);
-  isEnabled = () => true;
+  isEnabled = async () => true;
   enable = () => this.listeners['change']?.forEach((l) => l(true));
   disable = () => this.listeners['change']?.forEach((l) => l(false));
   setSuppressionLevel = () => {};
@@ -16,4 +17,5 @@ export class NoiseCancellationStub implements INoiseCancellation {
     return () => {};
   };
   off = () => {};
+  resume = () => {};
 }

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

@@ -6,7 +6,10 @@ import { CallingState, StreamVideoWriteableStateStore } from '../../store';
 import * as RxUtils from '../../store/rxUtils';
 import { mockCall, mockDeviceIds$, mockScreenShareStream } from './mocks';
 import { getScreenShareStream } from '../devices';
-import { TrackType } from '../../gen/video/sfu/models/models';
+import {
+  AudioBitrateProfile,
+  TrackType,
+} from '../../gen/video/sfu/models/models';
 import { Tracer } from '../../stats';
 
 vi.mock('../devices.ts', () => {
@@ -121,6 +124,7 @@ describe('ScreenShareManager', () => {
     expect(call.publish).toHaveBeenCalledWith(
       manager.state.mediaStream,
       TrackType.SCREEN_SHARE,
+      { audioBitrateProfile: AudioBitrateProfile.MUSIC_HIGH_QUALITY },
     );
   });
 

package/src/devices/index.ts

@@ -1,7 +1,7 @@
 export * from './utils';
 export * from './devices';
-export * from './InputMediaDeviceManager';
-export * from './InputMediaDeviceManagerState';
+export * from './DeviceManager';
+export * from './DeviceManagerState';
 export * from './CameraManager';
 export * from './CameraManagerState';
 export * from './MicrophoneManager';

package/src/events/__tests__/internal.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
+import { fromPartial } from '@total-typescript/shoehorn';
 import { Call } from '../../Call';
 import { Dispatcher } from '../../rtc';
 import { CallState } from '../../store';
@@ -30,13 +31,12 @@ describe('internal events', () => {
     dispatcher.dispatch({
       eventPayload: {
         oneofKind: 'connectionQualityChanged',
-        // @ts-expect-error incomplete data
         connectionQualityChanged: {
           connectionQualityUpdates: [
-            {
+            fromPartial({
               sessionId: 'session-1',
               connectionQuality: ConnectionQuality.EXCELLENT,
-            },
+            }),
           ],
         },
       },
@@ -60,7 +60,6 @@ describe('internal events', () => {
     dispatcher.dispatch({
       eventPayload: {
         oneofKind: 'healthCheckResponse',
-        // @ts-expect-error incomplete data
         healthCheckResponse: { participantCount: { total: 5, anonymous: 2 } },
       },
     });
@@ -118,20 +117,35 @@ describe('internal events', () => {
   it('handles pinUpdated', () => {
     const state = new CallState();
     state.setParticipants([
-      // @ts-expect-error incomplete data
-      { userId: 'u1', sessionId: 'session-1', pin: { isLocalPin: false } },
-      // @ts-expect-error incomplete data
-      { userId: 'u2', sessionId: 'session-2', pin: { isLocalPin: false } },
+      fromPartial({
+        userId: 'u1',
+        sessionId: 'session-1',
+        publishedTracks: [],
+      }),
+      fromPartial({
+        userId: 'u2',
+        sessionId: 'session-2',
+        publishedTracks: [],
+      }),
     ]);
-    const update = watchPinsUpdated(state);
-    update({ pins: [{ userId: 'u1', sessionId: 'session-1' }] });
+
+    watchPinsUpdated(state)({
+      pins: [{ userId: 'u1', sessionId: 'session-1' }],
+    });
+
     expect(state.participants).toEqual([
       {
         userId: 'u1',
         sessionId: 'session-1',
         pin: { isLocalPin: false, pinnedAt: expect.any(Number) },
+        publishedTracks: [],
+      },
+      {
+        userId: 'u2',
+        sessionId: 'session-2',
+        pin: undefined,
+        publishedTracks: [],
       },
-      { userId: 'u2', sessionId: 'session-2', pin: undefined },
     ]);
   });