@stream-io/video-client 1.4.3 → 1.4.4

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

@@ -3,7 +3,7 @@ import { Call } from '../Call';
 import { InputMediaDeviceManagerState } from './InputMediaDeviceManagerState';
 import { Logger } from '../coordinator/connection/types';
 import { TrackType } from '../gen/video/sfu/models/models';
-export type MediaStreamFilter = (stream: MediaStream) => Promise<MediaStream>;
+import { MediaStreamFilter, MediaStreamFilterRegistrationResult } from './filters';
 export declare abstract class InputMediaDeviceManager<T extends InputMediaDeviceManagerState<C>, C = MediaTrackConstraints> {
     protected readonly call: Call;
     readonly state: T;
@@ -17,6 +17,7 @@ export declare abstract class InputMediaDeviceManager<T extends InputMediaDevice
     private isTrackStoppedDueToTrackEnd;
     private filters;
     private statusChangeConcurrencyTag;
+    private filterRegistrationConcurrencyTag;
     protected constructor(call: Call, state: T, trackType: TrackType);
     /**
      * Lists the available audio/video devices
@@ -55,9 +56,9 @@ export declare abstract class InputMediaDeviceManager<T extends InputMediaDevice
      * a new stream with the applied filter.
      *
      * @param filter the filter to register.
-     * @returns a function that will unregister the filter.
+     * @returns MediaStreamFilterRegistrationResult
      */
-    registerFilter(filter: MediaStreamFilter): Promise<() => Promise<void>>;
+    registerFilter(filter: MediaStreamFilter): MediaStreamFilterRegistrationResult;
     /**
      * Will set the default constraints for the device.
      *

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

@@ -12,6 +12,7 @@ export declare class MicrophoneManager extends InputMediaDeviceManager<Microphon
     private noiseCancellation;
     private noiseCancellationChangeUnsubscribe;
     private noiseCancellationRegistration?;
+    private uregisterNoiseCancellation?;
     constructor(call: Call, disableMode?: TrackDisableMode);
     /**
      * Enables noise cancellation for the microphone.

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

@@ -0,0 +1,32 @@
+export type MediaStreamFilter = (input: MediaStream) => MediaStreamFilterResult;
+export type MediaStreamFilterCleanup = () => void;
+export interface MediaStreamFilterResult {
+    /**
+     * Transformed media stream. If the filter is asynchronous, a promise which
+     * resolves with a transformed media stream.
+     */
+    output: MediaStream | Promise<MediaStream>;
+    /**
+     * An optional cleanup callback. It is called when the filter is stopped, and
+     * when it is unregistered.
+     */
+    stop?: MediaStreamFilterCleanup;
+}
+export interface MediaStreamFilterEntry {
+    start: MediaStreamFilter;
+    /**
+     * When the filter is running, it holds a cleanup callback returned when the filter
+     * was started.
+     */
+    stop: MediaStreamFilterCleanup | undefined;
+}
+export interface MediaStreamFilterRegistrationResult {
+    /**
+     * Promise that resolves when the filter is applied to the stream.
+     */
+    registered: Promise<void>;
+    /**
+     * Function that can be called to unregister the filter.
+     */
+    unregister: () => Promise<void>;
+}

package/package.json

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

package/src/devices/InputMediaDeviceManager.ts

@@ -8,9 +8,16 @@ import { Logger } from '../coordinator/connection/types';
 import { getLogger } from '../logger';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { deviceIds$ } from './devices';
-import { settled, withCancellation } from '../helpers/concurrency';
-
-export type MediaStreamFilter = (stream: MediaStream) => Promise<MediaStream>;
+import {
+  settled,
+  withCancellation,
+  withoutConcurrency,
+} from '../helpers/concurrency';
+import {
+  MediaStreamFilter,
+  MediaStreamFilterEntry,
+  MediaStreamFilterRegistrationResult,
+} from './filters';
 
 export abstract class InputMediaDeviceManager<
   T extends InputMediaDeviceManagerState<C>,
@@ -24,8 +31,11 @@ export abstract class InputMediaDeviceManager<
 
   protected subscriptions: Function[] = [];
   private isTrackStoppedDueToTrackEnd = false;
-  private filters: MediaStreamFilter[] = [];
+  private filters: MediaStreamFilterEntry[] = [];
   private statusChangeConcurrencyTag = Symbol('statusChangeConcurrencyTag');
+  private filterRegistrationConcurrencyTag = Symbol(
+    'filterRegistrationConcurrencyTag',
+  );
 
   protected constructor(
     protected readonly call: Call,
@@ -139,14 +149,32 @@ export abstract class InputMediaDeviceManager<
    * a new stream with the applied filter.
    *
    * @param filter the filter to register.
-   * @returns a function that will unregister the filter.
+   * @returns MediaStreamFilterRegistrationResult
    */
-  async registerFilter(filter: MediaStreamFilter) {
-    this.filters.push(filter);
-    await this.applySettingsToStream();
-    return async () => {
-      this.filters = this.filters.filter((f) => f !== filter);
-      await this.applySettingsToStream();
+  registerFilter(
+    filter: MediaStreamFilter,
+  ): MediaStreamFilterRegistrationResult {
+    const entry: MediaStreamFilterEntry = {
+      start: filter,
+      stop: undefined,
+    };
+
+    const registered = withoutConcurrency(
+      this.filterRegistrationConcurrencyTag,
+      async () => {
+        this.filters.push(entry);
+        await this.applySettingsToStream();
+      },
+    );
+
+    return {
+      registered,
+      unregister: () =>
+        withoutConcurrency(this.filterRegistrationConcurrencyTag, async () => {
+          entry.stop?.();
+          this.filters = this.filters.filter((f) => f !== entry);
+          await this.applySettingsToStream();
+        }),
     };
   }
 
@@ -224,6 +252,7 @@ export abstract class InputMediaDeviceManager<
         this.state.mediaStream.release();
       }
       this.state.setMediaStream(undefined, undefined);
+      this.filters.forEach((entry) => entry.stop?.());
     }
   }
 
@@ -335,7 +364,21 @@ export abstract class InputMediaDeviceManager<
       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)),
+        (parent, entry) =>
+          parent
+            .then((inputStream) => {
+              const { stop, output } = entry.start(inputStream);
+              entry.stop = stop;
+              return output;
+            })
+            .then(chainWith(parent), (error) => {
+              this.logger(
+                'warn',
+                'Fitler failed to start and will be ignored',
+                error,
+              );
+              return parent;
+            }),
         rootStream,
       );
     }

package/src/devices/MicrophoneManager.ts

@@ -24,7 +24,8 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
   private rnSpeechDetector: RNSpeechDetector | undefined;
   private noiseCancellation: INoiseCancellation | undefined;
   private noiseCancellationChangeUnsubscribe: (() => void) | undefined;
-  private noiseCancellationRegistration?: Promise<() => Promise<void>>;
+  private noiseCancellationRegistration?: Promise<void>;
+  private uregisterNoiseCancellation?: () => Promise<void>;
 
   constructor(
     call: Call,
@@ -139,9 +140,11 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
         },
       );
 
-      this.noiseCancellationRegistration = this.registerFilter(
+      const registrationResult = this.registerFilter(
         noiseCancellation.toFilter(),
       );
+      this.noiseCancellationRegistration = registrationResult.registered;
+      this.uregisterNoiseCancellation = registrationResult.unregister;
       await this.noiseCancellationRegistration;
 
       // handles an edge case where a noise cancellation is enabled after
@@ -170,8 +173,7 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
     if (isReactNative()) {
       throw new Error('Noise cancellation is not supported in React Native');
     }
-    await this.noiseCancellationRegistration
-      ?.then((unregister) => unregister())
+    await (this.uregisterNoiseCancellation?.() ?? Promise.resolve())
       .then(() => this.noiseCancellation?.disable())
       .then(() => this.noiseCancellationChangeUnsubscribe?.())
       .catch((err) => {

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

@@ -58,8 +58,9 @@ describe('MediaStream Filters', () => {
     const track = new MediaStreamTrack();
     vi.spyOn(mediaStream, 'getTracks').mockReturnValue([track]);
     vi.spyOn(track, 'getSettings').mockReturnValue({ deviceId: '123' });
-    const filter = vi.fn().mockReturnValue(mediaStream);
-    const unregister = await manager.registerFilter(filter);
+    const filter = vi.fn().mockReturnValue({ output: mediaStream });
+    const { registered, unregister } = manager.registerFilter(filter);
+    await registered;
     await manager.enable();
 
     expect(filter).toHaveBeenCalled();
@@ -92,10 +93,10 @@ describe('MediaStream Filters', () => {
 
     const rootMediaStream = createMediaStream();
     const filterMediaStream = createMediaStream();
-    const filter1 = vi.fn().mockReturnValue(rootMediaStream);
-    const filter2 = vi.fn().mockReturnValue(filterMediaStream);
-    await manager.registerFilter(filter1);
-    await manager.registerFilter(filter2);
+    const filter1 = vi.fn().mockReturnValue({ output: rootMediaStream });
+    const filter2 = vi.fn().mockReturnValue({ output: filterMediaStream });
+    await manager.registerFilter(filter1).registered;
+    await manager.registerFilter(filter2).registered;
     await manager.enable();
 
     expect(filter1).toHaveBeenCalled();

package/src/devices/filters.ts

@@ -0,0 +1,38 @@
+export type MediaStreamFilter = (input: MediaStream) => MediaStreamFilterResult;
+export type MediaStreamFilterCleanup = () => void;
+
+export interface MediaStreamFilterResult {
+  /**
+   * Transformed media stream. If the filter is asynchronous, a promise which
+   * resolves with a transformed media stream.
+   */
+  output: MediaStream | Promise<MediaStream>;
+
+  /**
+   * An optional cleanup callback. It is called when the filter is stopped, and
+   * when it is unregistered.
+   */
+  stop?: MediaStreamFilterCleanup;
+}
+
+export interface MediaStreamFilterEntry {
+  start: MediaStreamFilter;
+
+  /**
+   * When the filter is running, it holds a cleanup callback returned when the filter
+   * was started.
+   */
+  stop: MediaStreamFilterCleanup | undefined;
+}
+
+export interface MediaStreamFilterRegistrationResult {
+  /**
+   * Promise that resolves when the filter is applied to the stream.
+   */
+  registered: Promise<void>;
+
+  /**
+   * Function that can be called to unregister the filter.
+   */
+  unregister: () => Promise<void>;
+}