@stream-io/video-client 0.7.7 → 0.7.8

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

@@ -1,8 +1,14 @@
+import { afterEach, beforeEach, describe, expect, it, Mock, vi } from 'vitest';
+import type { INoiseCancellation } from '@stream-io/audio-filters-web';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
+import { sleep } from '../../coordinator/connection/utils';
+import {
+  NoiseCancellationSettingsModeEnum,
+  OwnCapability,
+} from '../../gen/coordinator';
+import { TrackType } from '../../gen/video/sfu/models/models';
 import { CallingState, StreamVideoWriteableStateStore } from '../../store';
-
-import { afterEach, beforeEach, describe, expect, it, Mock, vi } from 'vitest';
 import {
   mockAudioDevices,
   mockAudioStream,
@@ -10,14 +16,12 @@ import {
   mockDeviceIds$,
 } from './mocks';
 import { getAudioStream } from '../devices';
-import { TrackType } from '../../gen/video/sfu/models/models';
 import { MicrophoneManager } from '../MicrophoneManager';
 import { of } from 'rxjs';
 import {
   createSoundDetector,
   SoundStateChangeHandler,
 } from '../../helpers/sound-detector';
-import { OwnCapability } from '../../gen/coordinator';
 
 vi.mock('../devices.ts', () => {
   console.log('MOCKING devices API');
@@ -45,6 +49,22 @@ vi.mock('../../Call.ts', () => {
   };
 });
 
+class NoiseCancellationStub implements INoiseCancellation {
+  private listeners: { [event: string]: Array<() => void> } = {};
+
+  isSupported = () => true;
+  init = () => Promise.resolve(undefined);
+  enable = () => this.listeners['change']?.forEach((l) => l(true));
+  disable = () => this.listeners['change']?.forEach((l) => l(false));
+  dispose = () => Promise.resolve(undefined);
+  toFilter = () => async (ms: MediaStream) => ms;
+  on = (event, callback) => {
+    (this.listeners[event] ??= []).push(callback);
+    return () => {};
+  };
+  off = () => {};
+}
+
 describe('MicrophoneManager', () => {
   let manager: MicrophoneManager;
 
@@ -188,6 +208,103 @@ describe('MicrophoneManager', () => {
     expect(manager['stopSpeakingWhileMutedDetection']).toHaveBeenCalled();
   });
 
+  describe('Noise Cancellation', () => {
+    it('should register filter if all preconditions are met', async () => {
+      const call = manager['call'];
+      call.state.setCallingState(CallingState.IDLE);
+      const registerFilter = vi.spyOn(manager, 'registerFilter');
+      const noiseCancellation = new NoiseCancellationStub();
+      const noiseCancellationEnable = vi.spyOn(noiseCancellation, 'enable');
+      await manager.enableNoiseCancellation(noiseCancellation);
+
+      expect(registerFilter).toBeCalled();
+      expect(noiseCancellationEnable).not.toBeCalled();
+    });
+
+    it('should unregister filter when disabling noise cancellation', async () => {
+      const noiseCancellation = new NoiseCancellationStub();
+      await manager.enableNoiseCancellation(noiseCancellation);
+      await manager.disableNoiseCancellation();
+      const call = manager['call'];
+      expect(call.notifyNoiseCancellationStopped).toBeCalled();
+    });
+
+    it('should throw when own capabilities are missing', async () => {
+      const call = manager['call'];
+      call.state.setOwnCapabilities([]);
+
+      await expect(() =>
+        manager.enableNoiseCancellation(new NoiseCancellationStub()),
+      ).rejects.toThrow();
+    });
+
+    it('should throw when noise cancellation is disabled in call settings', async () => {
+      const call = manager['call'];
+      call.state.setOwnCapabilities([OwnCapability.ENABLE_NOISE_CANCELLATION]);
+      call.state.updateFromCallResponse({
+        // @ts-expect-error partial data
+        audio: {
+          noise_cancellation: {
+            mode: NoiseCancellationSettingsModeEnum.DISABLED,
+          },
+        },
+      });
+      await expect(() =>
+        manager.enableNoiseCancellation(new NoiseCancellationStub()),
+      ).rejects.toThrow();
+    });
+
+    it('should automatically enable noise noise suppression after joining a call', async () => {
+      const call = manager['call'];
+      call.state.setCallingState(CallingState.IDLE); // reset state
+      call.state.updateFromCallResponse({
+        settings: {
+          // @ts-expect-error - partial data
+          audio: {
+            noise_cancellation: {
+              mode: NoiseCancellationSettingsModeEnum.AUTO_ON,
+            },
+          },
+        },
+      });
+
+      const noiseCancellation = new NoiseCancellationStub();
+      const noiseCancellationEnable = vi.spyOn(noiseCancellation, 'enable');
+      await manager.enableNoiseCancellation(noiseCancellation);
+
+      expect(noiseCancellationEnable).not.toBeCalled();
+
+      call.state.setCallingState(CallingState.JOINED);
+
+      // it is quite hard to test the "detached" callingState$ subscription
+      // with the current tools and architecture.
+      // that is why we go with the good old sleep
+      await sleep(25);
+
+      expect(noiseCancellationEnable).toBeCalled();
+      expect(call.notifyNoiseCancellationStarting).toBeCalled();
+    });
+
+    it('should automatically disable noise suppression after leaving the call', async () => {
+      const call = manager['call'];
+      const noiseCancellation = new NoiseCancellationStub();
+      const noiseSuppressionDisable = vi.spyOn(noiseCancellation, 'disable');
+      await manager.enableNoiseCancellation(noiseCancellation);
+
+      expect(noiseSuppressionDisable).not.toBeCalled();
+
+      call.state.setCallingState(CallingState.LEFT);
+
+      // it is quite hard to test the "detached" callingState$ subscription
+      // with the current tools and architecture.
+      // that is why we go with the good old sleep
+      await sleep(25);
+
+      expect(noiseSuppressionDisable).toBeCalled();
+      expect(call.notifyNoiseCancellationStopped).toBeCalled();
+    });
+  });
+
   afterEach(() => {
     vi.clearAllMocks();
     vi.resetModules();

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

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { INoiseCancellation } from '@stream-io/audio-filters-web';
 import { MicrophoneManager } from '../MicrophoneManager';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
@@ -119,6 +120,29 @@ describe('MicrophoneManager React Native', () => {
     expect(manager['stopSpeakingWhileMutedDetection']).toHaveBeenCalled();
   });
 
+  describe('Noise Suppression', () => {
+    it('enable: should throw an error in React Native', async () => {
+      await expect(() => {
+        return manager.enableNoiseCancellation(
+          new (class implements INoiseCancellation {
+            isSupported = () => true;
+            init = () => Promise.resolve(undefined);
+            enable = () => {};
+            disable = () => {};
+            dispose = () => Promise.resolve(undefined);
+            toFilter = () => async (ms: MediaStream) => ms;
+            on = () => () => {};
+            off = () => {};
+          })(),
+        );
+      }).rejects.toThrow();
+    });
+
+    it('disable: should throw an error in React Native', async () => {
+      await expect(() => manager.disableNoiseCancellation()).rejects.toThrow();
+    });
+  });
+
   afterEach(() => {
     vi.clearAllMocks();
     vi.resetModules();

package/src/devices/__tests__/mocks.ts

@@ -1,6 +1,9 @@
 import { vi } from 'vitest';
 import { CallingState, CallState } from '../../store';
-import { OwnCapability } from '../../gen/coordinator';
+import {
+  NoiseCancellationSettingsModeEnum,
+  OwnCapability,
+} from '../../gen/coordinator';
 import { Call } from '../../Call';
 import { Subject } from 'rxjs';
 
@@ -71,13 +74,26 @@ export const mockCall = (): Partial<Call> => {
   callState.setOwnCapabilities([
     OwnCapability.SEND_AUDIO,
     OwnCapability.SEND_VIDEO,
+    OwnCapability.ENABLE_NOISE_CANCELLATION,
   ]);
+  callState.updateFromCallResponse({
+    settings: {
+      // @ts-expect-error partial data
+      audio: {
+        noise_cancellation: {
+          mode: NoiseCancellationSettingsModeEnum.AVAILABLE,
+        },
+      },
+    },
+  });
   return {
     state: callState,
     publishVideoStream: vi.fn(),
     publishAudioStream: vi.fn(),
     publishScreenShareStream: vi.fn(),
     stopPublish: vi.fn(),
+    notifyNoiseCancellationStarting: vi.fn().mockResolvedValue(undefined),
+    notifyNoiseCancellationStopped: vi.fn().mockResolvedValue(undefined),
   };
 };
 

package/src/gen/coordinator/index.ts

@@ -86,6 +86,12 @@ export interface AudioSettings {
    * @memberof AudioSettings
    */
   mic_default_on: boolean;
+  /**
+   *
+   * @type {NoiseCancellationSettings}
+   * @memberof AudioSettings
+   */
+  noise_cancellation?: NoiseCancellationSettings;
   /**
    *
    * @type {boolean}
@@ -140,6 +146,12 @@ export interface AudioSettingsRequest {
    * @memberof AudioSettingsRequest
    */
   mic_default_on?: boolean;
+  /**
+   *
+   * @type {NoiseCancellationSettingsRequest}
+   * @memberof AudioSettingsRequest
+   */
+  noise_cancellation?: NoiseCancellationSettingsRequest;
   /**
    *
    * @type {boolean}
@@ -472,9 +484,7 @@ export interface CallEndedEvent {
    */
   user?: UserResponse;
 }
-
 /**
- *
  * @export
  * @interface CallEvent
  */
@@ -510,7 +520,6 @@ export interface CallEvent {
    */
   type: string;
 }
-
 /**
  * This event is sent when HLS broadcasting has failed
  * @export
@@ -2099,7 +2108,6 @@ export interface ClosedCaptionEvent {
    */
   type: string;
 }
-
 /**
  *
  * @export
@@ -2108,10 +2116,10 @@ export interface ClosedCaptionEvent {
 export interface CollectUserFeedbackRequest {
   /**
    *
-   * @type {object}
+   * @type {{ [key:string]: any }}
    * @memberof CollectUserFeedbackRequest
    */
-  custom?: { [key:string]: any };
+  custom?: { [key: string]: any };
   /**
    *
    * @type {number}
@@ -2156,7 +2164,6 @@ export interface CollectUserFeedbackResponse {
    */
   duration: string;
 }
-
 /**
  *
  * @export
@@ -2275,7 +2282,6 @@ export interface Coordinates {
    */
   longitude: number;
 }
-
 /**
  *
  * @export
@@ -2636,7 +2642,6 @@ export interface GeofenceSettingsRequest {
    */
   names?: Array<string>;
 }
-
 /**
  *
  * @export
@@ -2680,7 +2685,6 @@ export interface GeolocationResult {
    */
   subdivision_iso_code: string;
 }
-
 /**
  *
  * @export
@@ -2803,7 +2807,6 @@ export interface GetCallStatsResponse {
    */
   sfus: Array<SFULocationResponse>;
 }
-
 /**
  *
  * @export
@@ -2953,7 +2956,6 @@ export interface GoLiveResponse {
    */
   duration: string;
 }
-
 // Manually added because API spec is faulty
 /**
  *
@@ -2980,7 +2982,6 @@ export interface HealthCheckEvent {
    */
   type: string;
 }
-
 /**
  *
  * @export
@@ -3372,6 +3373,55 @@ export interface MuteUsersResponse {
    */
   duration: string;
 }
+/**
+ *
+ * @export
+ * @interface NoiseCancellationSettings
+ */
+export interface NoiseCancellationSettings {
+  /**
+   *
+   * @type {string}
+   * @memberof NoiseCancellationSettings
+   */
+  mode: NoiseCancellationSettingsModeEnum;
+}
+
+/**
+ * @export
+ */
+export const NoiseCancellationSettingsModeEnum = {
+  AVAILABLE: 'available',
+  DISABLED: 'disabled',
+  AUTO_ON: 'auto-on',
+} as const;
+export type NoiseCancellationSettingsModeEnum =
+  (typeof NoiseCancellationSettingsModeEnum)[keyof typeof NoiseCancellationSettingsModeEnum];
+
+/**
+ *
+ * @export
+ * @interface NoiseCancellationSettingsRequest
+ */
+export interface NoiseCancellationSettingsRequest {
+  /**
+   *
+   * @type {string}
+   * @memberof NoiseCancellationSettingsRequest
+   */
+  mode?: NoiseCancellationSettingsRequestModeEnum;
+}
+
+/**
+ * @export
+ */
+export const NoiseCancellationSettingsRequestModeEnum = {
+  AVAILABLE: 'available',
+  DISABLED: 'disabled',
+  AUTO_ON: 'auto-on',
+} as const;
+export type NoiseCancellationSettingsRequestModeEnum =
+  (typeof NoiseCancellationSettingsRequestModeEnum)[keyof typeof NoiseCancellationSettingsRequestModeEnum];
 
 /**
  * All possibility of string to use
@@ -3381,6 +3431,7 @@ export const OwnCapability = {
   BLOCK_USERS: 'block-users',
   CREATE_CALL: 'create-call',
   CREATE_REACTION: 'create-reaction',
+  ENABLE_NOISE_CANCELLATION: 'enable-noise-cancellation',
   END_CALL: 'end-call',
   JOIN_BACKSTAGE: 'join-backstage',
   JOIN_CALL: 'join-call',
@@ -4349,7 +4400,6 @@ export interface Subsession {
    */
   sfu_id: string;
 }
-
 /**
  *
  * @export
@@ -4913,7 +4963,6 @@ export interface UserResponse {
    */
   updated_at: string;
 }
-
 /**
  *
  * @export
@@ -5132,6 +5181,44 @@ export interface UserStats {
    */
   session_stats: Array<UserSessionStats>;
 }
+/**
+ *
+ * @export
+ * @interface VideoQuality
+ */
+export interface VideoQuality {
+  /**
+   *
+   * @type {VideoResolution}
+   * @memberof VideoQuality
+   */
+  resolution?: VideoResolution;
+  /**
+   *
+   * @type {string}
+   * @memberof VideoQuality
+   */
+  usage_type?: string;
+}
+/**
+ *
+ * @export
+ * @interface VideoResolution
+ */
+export interface VideoResolution {
+  /**
+   *
+   * @type {number}
+   * @memberof VideoResolution
+   */
+  height: number;
+  /**
+   *
+   * @type {number}
+   * @memberof VideoResolution
+   */
+  width: number;
+}
 /**
  *
  * @export
@@ -5230,40 +5317,6 @@ export const VideoSettingsRequestCameraFacingEnum = {
 export type VideoSettingsRequestCameraFacingEnum =
   (typeof VideoSettingsRequestCameraFacingEnum)[keyof typeof VideoSettingsRequestCameraFacingEnum];
 
-/**
- *
- * @export
- * @interface VideoQuality
- */
-export interface VideoQuality {
-  /**
-   *
-   * @type {VideoResolution}
-   * @memberof VideoQuality
-   */
-  resolution: VideoResolution;
-}
-
-/**
- *
- * @export
- * @interface VideoResolution
- */
-export interface VideoResolution {
-  /**
-   *
-   * @type {number}
-   * @memberof VideoResolution
-   */
-  height: number;
-  /**
-   *
-   * @type {number}
-   * @memberof VideoResolution
-   */
-  width: number;
-}
-
 /**
  *
  * @export

package/src/gen/google/protobuf/struct.ts

@@ -1,5 +1,5 @@
 /* eslint-disable */
-// @generated by protobuf-ts 2.9.3 with parameter long_type_string,client_generic,server_none,eslint_disable
+// @generated by protobuf-ts 2.9.4 with parameter long_type_string,client_generic,server_none,eslint_disable
 // @generated from protobuf file "google/protobuf/struct.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //

package/src/gen/google/protobuf/timestamp.ts

@@ -1,5 +1,5 @@
 /* eslint-disable */
-// @generated by protobuf-ts 2.9.3 with parameter long_type_string,client_generic,server_none,eslint_disable
+// @generated by protobuf-ts 2.9.4 with parameter long_type_string,client_generic,server_none,eslint_disable
 // @generated from protobuf file "google/protobuf/timestamp.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //

package/src/gen/video/sfu/event/events.ts

@@ -1,5 +1,5 @@
 /* eslint-disable */
-// @generated by protobuf-ts 2.9.3 with parameter long_type_string,client_generic,server_none,eslint_disable
+// @generated by protobuf-ts 2.9.4 with parameter long_type_string,client_generic,server_none,eslint_disable
 // @generated from protobuf file "video/sfu/event/events.proto" (package "stream.video.sfu.event", syntax proto3)
 // tslint:disable
 import type {

package/src/gen/video/sfu/models/models.ts

@@ -1,5 +1,5 @@
 /* eslint-disable */
-// @generated by protobuf-ts 2.9.3 with parameter long_type_string,client_generic,server_none,eslint_disable
+// @generated by protobuf-ts 2.9.4 with parameter long_type_string,client_generic,server_none,eslint_disable
 // @generated from protobuf file "video/sfu/models/models.proto" (package "stream.video.sfu.models", syntax proto3)
 // tslint:disable
 import type {

package/src/gen/video/sfu/signal_rpc/signal.client.ts

@@ -1,5 +1,5 @@
 /* eslint-disable */
-// @generated by protobuf-ts 2.9.3 with parameter long_type_string,client_generic,server_none,eslint_disable
+// @generated by protobuf-ts 2.9.4 with parameter long_type_string,client_generic,server_none,eslint_disable
 // @generated from protobuf file "video/sfu/signal_rpc/signal.proto" (package "stream.video.sfu.signal", syntax proto3)
 // tslint:disable
 import type {
@@ -19,6 +19,10 @@ import type {
   SendStatsResponse,
   SetPublisherRequest,
   SetPublisherResponse,
+  StartNoiseCancellationRequest,
+  StartNoiseCancellationResponse,
+  StopNoiseCancellationRequest,
+  StopNoiseCancellationResponse,
   UpdateMuteStatesRequest,
   UpdateMuteStatesResponse,
   UpdateSubscriptionsRequest,
@@ -89,6 +93,20 @@ export interface ISignalServerClient {
     input: SendStatsRequest,
     options?: RpcOptions,
   ): UnaryCall<SendStatsRequest, SendStatsResponse>;
+  /**
+   * @generated from protobuf rpc: StartNoiseCancellation(stream.video.sfu.signal.StartNoiseCancellationRequest) returns (stream.video.sfu.signal.StartNoiseCancellationResponse);
+   */
+  startNoiseCancellation(
+    input: StartNoiseCancellationRequest,
+    options?: RpcOptions,
+  ): UnaryCall<StartNoiseCancellationRequest, StartNoiseCancellationResponse>;
+  /**
+   * @generated from protobuf rpc: StopNoiseCancellation(stream.video.sfu.signal.StopNoiseCancellationRequest) returns (stream.video.sfu.signal.StopNoiseCancellationResponse);
+   */
+  stopNoiseCancellation(
+    input: StopNoiseCancellationRequest,
+    options?: RpcOptions,
+  ): UnaryCall<StopNoiseCancellationRequest, StopNoiseCancellationResponse>;
 }
 /**
  * @generated from protobuf service stream.video.sfu.signal.SignalServer
@@ -223,4 +241,32 @@ export class SignalServerClient implements ISignalServerClient, ServiceInfo {
       input,
     );
   }
+  /**
+   * @generated from protobuf rpc: StartNoiseCancellation(stream.video.sfu.signal.StartNoiseCancellationRequest) returns (stream.video.sfu.signal.StartNoiseCancellationResponse);
+   */
+  startNoiseCancellation(
+    input: StartNoiseCancellationRequest,
+    options?: RpcOptions,
+  ): UnaryCall<StartNoiseCancellationRequest, StartNoiseCancellationResponse> {
+    const method = this.methods[7],
+      opt = this._transport.mergeOptions(options);
+    return stackIntercept<
+      StartNoiseCancellationRequest,
+      StartNoiseCancellationResponse
+    >('unary', this._transport, method, opt, input);
+  }
+  /**
+   * @generated from protobuf rpc: StopNoiseCancellation(stream.video.sfu.signal.StopNoiseCancellationRequest) returns (stream.video.sfu.signal.StopNoiseCancellationResponse);
+   */
+  stopNoiseCancellation(
+    input: StopNoiseCancellationRequest,
+    options?: RpcOptions,
+  ): UnaryCall<StopNoiseCancellationRequest, StopNoiseCancellationResponse> {
+    const method = this.methods[8],
+      opt = this._transport.mergeOptions(options);
+    return stackIntercept<
+      StopNoiseCancellationRequest,
+      StopNoiseCancellationResponse
+    >('unary', this._transport, method, opt, input);
+  }
 }