@stream-io/video-client 0.6.6 → 0.6.8

package/src/Call.ts

@@ -30,6 +30,7 @@ import {
   GoLiveRequest,
   GoLiveResponse,
   ListRecordingsResponse,
+  ListTranscriptionsResponse,
   MuteUsersRequest,
   MuteUsersResponse,
   OwnCapability,
@@ -48,10 +49,13 @@ import {
   StartHLSBroadcastingResponse,
   StartRecordingRequest,
   StartRecordingResponse,
+  StartTranscriptionRequest,
+  StartTranscriptionResponse,
   StatsOptions,
   StopHLSBroadcastingResponse,
   StopLiveResponse,
   StopRecordingResponse,
+  StopTranscriptionResponse,
   UnblockUserRequest,
   UnblockUserResponse,
   UnpinRequest,
@@ -509,10 +513,10 @@ export class Call {
 
     this.clientStore.unregisterCall(this);
 
-    this.camera.removeSubscriptions();
-    this.microphone.removeSubscriptions();
-    this.screenShare.removeSubscriptions();
-    this.speaker.removeSubscriptions();
+    this.camera.dispose();
+    this.microphone.dispose();
+    this.screenShare.dispose();
+    this.speaker.dispose();
 
     const stopOnLeavePromises: Promise<void>[] = [];
     if (this.camera.stopOnLeave) {
@@ -1582,6 +1586,29 @@ export class Call {
     );
   };
 
+  /**
+   * Starts the transcription of the call.
+   *
+   * @param request the request data.
+   */
+  startTranscription = async (
+    request?: StartTranscriptionRequest,
+  ): Promise<StartTranscriptionResponse> => {
+    return this.streamClient.post<
+      StartTranscriptionResponse,
+      StartTranscriptionRequest
+    >(`${this.streamClientBasePath}/start_transcription`, request);
+  };
+
+  /**
+   * Stops the transcription of the call.
+   */
+  stopTranscription = async (): Promise<StopTranscriptionResponse> => {
+    return this.streamClient.post<StopTranscriptionResponse>(
+      `${this.streamClientBasePath}/stop_transcription`,
+    );
+  };
+
   /**
    * Sends a `call.permission_request` event to all users connected to the call. The call settings object contains infomration about which permissions can be requested during a call (for example a user might be allowed to request permission to publish audio, but not video).
    */
@@ -1859,6 +1886,17 @@ export class Call {
     );
   };
 
+  /**
+   * Retrieves the list of transcriptions for the current call.
+   *
+   * @returns the list of transcriptions.
+   */
+  queryTranscriptions = async (): Promise<ListTranscriptionsResponse> => {
+    return this.streamClient.get<ListTranscriptionsResponse>(
+      `${this.streamClientBasePath}/transcriptions`,
+    );
+  };
+
   /**
    * Retrieve call statistics for a particular call session (historical).
    * Here `callSessionID` is mandatory.

package/src/StreamVideoClient.ts

@@ -13,6 +13,8 @@ import type {
   ListDevicesResponse,
   QueryCallsRequest,
   QueryCallsResponse,
+  QueryCallStatsRequest,
+  QueryCallStatsResponse,
 } from './gen/coordinator';
 import {
   AllClientEvents,
@@ -366,6 +368,19 @@ export class StreamVideoClient {
     };
   };
 
+  /**
+   * Retrieve the list of available call statistics reports matching a particular condition.
+   *
+   * @param data Filter and sort conditions for retrieving available call report summaries.
+   * @returns List with summary of available call reports matching the condition.
+   */
+  queryCallStats = async (data: QueryCallStatsRequest = {}) => {
+    return this.streamClient.post<
+      QueryCallStatsResponse,
+      QueryCallStatsRequest
+    >(`/call/stats`, data);
+  };
+
   /**
    * Returns a list of available data centers available for hosting calls.
    */

package/src/devices/InputMediaDeviceManager.ts

@@ -1,6 +1,7 @@
-import { Observable, Subscription, combineLatest, pairwise } from 'rxjs';
+import { combineLatest, Observable, pairwise } from 'rxjs';
 import { Call } from '../Call';
 import { CallingState } from '../store';
+import { createSubscription } from '../store/rxUtils';
 import { InputMediaDeviceManagerState } from './InputMediaDeviceManagerState';
 import { isReactNative } from '../helpers/platforms';
 import { Logger } from '../coordinator/connection/types';
@@ -8,6 +9,8 @@ import { getLogger } from '../logger';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { deviceIds$ } from './devices';
 
+export type MediaStreamFilter = (stream: MediaStream) => Promise<MediaStream>;
+
 export abstract class InputMediaDeviceManager<
   T extends InputMediaDeviceManagerState<C>,
   C = MediaTrackConstraints,
@@ -25,8 +28,9 @@ export abstract class InputMediaDeviceManager<
    */
   stopOnLeave = true;
   logger: Logger;
-  private subscriptions: Subscription[] = [];
+  private subscriptions: Function[] = [];
   private isTrackStoppedDueToTrackEnd = false;
+  private filters: MediaStreamFilter[] = [];
 
   protected constructor(
     protected readonly call: Call,
@@ -113,6 +117,24 @@ export abstract class InputMediaDeviceManager<
     }
   }
 
+  /**
+   * Registers a filter that will be applied to the stream.
+   *
+   * The registered filter will get the existing stream, and it should return
+   * a new stream with the applied filter.
+   *
+   * @param filter the filter to register.
+   * @returns a function that will unregister the filter.
+   */
+  async registerFilter(filter: MediaStreamFilter) {
+    this.filters.push(filter);
+    await this.applySettingsToStream();
+    return async () => {
+      this.filters = this.filters.filter((f) => f !== filter);
+      await this.applySettingsToStream();
+    };
+  }
+
   /**
    * Will set the default constraints for the device.
    *
@@ -141,8 +163,13 @@ export abstract class InputMediaDeviceManager<
     await this.applySettingsToStream();
   }
 
-  removeSubscriptions = () => {
-    this.subscriptions.forEach((s) => s.unsubscribe());
+  /**
+   * Disposes the manager.
+   *
+   * @internal
+   */
+  dispose = () => {
+    this.subscriptions.forEach((s) => s());
   };
 
   protected async applySettingsToStream() {
@@ -229,7 +256,69 @@ export abstract class InputMediaDeviceManager<
         ...defaultConstraints,
         deviceId: this.state.selectedDevice,
       };
-      stream = await this.getStream(constraints as C);
+
+      /**
+       * Chains two media streams together.
+       *
+       * In our case, filters MediaStreams are derived from their parent MediaStream.
+       * However, once a child filter's track is stopped,
+       * the tracks of the parent MediaStream aren't automatically stopped.
+       * This leads to a situation where the camera indicator light is still on
+       * even though the user stopped publishing video.
+       *
+       * This function works around this issue by stopping the parent MediaStream's tracks
+       * as well once the child filter's tracks are stopped.
+       *
+       * It works by patching the stop() method of the child filter's tracks to also stop
+       * the parent MediaStream's tracks of the same type. Here we assume that
+       * the parent MediaStream has only one track of each type.
+       *
+       * @param parentStream the parent MediaStream. Omit for the root stream.
+       */
+      const chainWith =
+        (parentStream?: Promise<MediaStream>) =>
+        async (filterStream: MediaStream): Promise<MediaStream> => {
+          if (!parentStream) return filterStream;
+          // TODO OL: take care of track.enabled property as well
+          const parent = await parentStream;
+          filterStream.getTracks().forEach((track) => {
+            const originalStop = track.stop;
+            track.stop = function stop() {
+              originalStop.call(track);
+              parent.getTracks().forEach((parentTrack) => {
+                if (parentTrack.kind === track.kind) {
+                  parentTrack.stop();
+                }
+              });
+            };
+          });
+
+          parent.getTracks().forEach((parentTrack) => {
+            // When the parent stream abruptly ends, we propagate the event
+            // to the filter stream.
+            // This usually happens when the camera/microphone permissions
+            // are revoked or when the device is disconnected.
+            const handleParentTrackEnded = () => {
+              filterStream.getTracks().forEach((track) => {
+                if (parentTrack.kind !== track.kind) return;
+                track.stop();
+                track.dispatchEvent(new Event('ended')); // propagate the event
+              });
+            };
+            parentTrack.addEventListener('ended', handleParentTrackEnded);
+            this.subscriptions.push(() => {
+              parentTrack.removeEventListener('ended', handleParentTrackEnded);
+            });
+          });
+
+          return filterStream;
+        };
+
+      // 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),
+      );
     }
     if (this.call.state.callingState === CallingState.JOINED) {
       await this.publishStream(stream);
@@ -268,51 +357,54 @@ export abstract class InputMediaDeviceManager<
 
   private handleDisconnectedOrReplacedDevices() {
     this.subscriptions.push(
-      combineLatest([
-        deviceIds$!.pipe(pairwise()),
-        this.state.selectedDevice$,
-      ]).subscribe(async ([[prevDevices, currentDevices], deviceId]) => {
-        if (!deviceId) {
-          return;
-        }
-        if (this.enablePromise) {
-          await this.enablePromise;
-        }
-        if (this.disablePromise) {
-          await this.disablePromise;
-        }
-
-        let isDeviceDisconnected = false;
-        let isDeviceReplaced = false;
-        const currentDevice = this.findDeviceInList(currentDevices, deviceId);
-        const prevDevice = this.findDeviceInList(prevDevices, deviceId);
-        if (!currentDevice && prevDevice) {
-          isDeviceDisconnected = true;
-        } else if (
-          currentDevice &&
-          prevDevice &&
-          currentDevice.deviceId === prevDevice.deviceId &&
-          currentDevice.groupId !== prevDevice.groupId
-        ) {
-          isDeviceReplaced = true;
-        }
-
-        if (isDeviceDisconnected) {
-          await this.disable();
-          this.select(undefined);
-        }
-        if (isDeviceReplaced) {
-          if (
-            this.isTrackStoppedDueToTrackEnd &&
-            this.state.status === 'disabled'
+      createSubscription(
+        combineLatest([
+          deviceIds$!.pipe(pairwise()),
+          this.state.selectedDevice$,
+        ]),
+        async ([[prevDevices, currentDevices], deviceId]) => {
+          if (!deviceId) {
+            return;
+          }
+          if (this.enablePromise) {
+            await this.enablePromise;
+          }
+          if (this.disablePromise) {
+            await this.disablePromise;
+          }
+
+          let isDeviceDisconnected = false;
+          let isDeviceReplaced = false;
+          const currentDevice = this.findDeviceInList(currentDevices, deviceId);
+          const prevDevice = this.findDeviceInList(prevDevices, deviceId);
+          if (!currentDevice && prevDevice) {
+            isDeviceDisconnected = true;
+          } else if (
+            currentDevice &&
+            prevDevice &&
+            currentDevice.deviceId === prevDevice.deviceId &&
+            currentDevice.groupId !== prevDevice.groupId
           ) {
-            await this.enable();
-            this.isTrackStoppedDueToTrackEnd = false;
-          } else {
-            await this.applySettingsToStream();
+            isDeviceReplaced = true;
+          }
+
+          if (isDeviceDisconnected) {
+            await this.disable();
+            this.select(undefined);
+          }
+          if (isDeviceReplaced) {
+            if (
+              this.isTrackStoppedDueToTrackEnd &&
+              this.state.status === 'disabled'
+            ) {
+              await this.enable();
+              this.isTrackStoppedDueToTrackEnd = false;
+            } else {
+              await this.applySettingsToStream();
+            }
           }
-        }
-      }),
+        },
+      ),
     );
   }
 

package/src/devices/SpeakerManager.ts

@@ -63,7 +63,12 @@ export class SpeakerManager {
     this.state.setDevice(deviceId);
   }
 
-  removeSubscriptions = () => {
+  /**
+   * Disposes the manager.
+   *
+   * @internal
+   */
+  dispose = () => {
     this.subscriptions.forEach((s) => s.unsubscribe());
   };
 

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

@@ -0,0 +1,115 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+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 { mockVideoDevices, mockVideoStream } from './mocks';
+import { TrackType } from '../../gen/video/sfu/models/models';
+
+import '../../rtc/__tests__/mocks/webrtc.mocks';
+
+class TestInputMediaDeviceManagerState extends InputMediaDeviceManagerState {
+  public getDeviceIdFromStream = vi.fn(
+    (stream) => stream.getTracks()[0].getSettings().deviceId,
+  );
+}
+
+class TestInputMediaDeviceManager extends InputMediaDeviceManager<TestInputMediaDeviceManagerState> {
+  public getDevices = vi.fn(() => of(mockVideoDevices));
+  public getStream = vi.fn(() => Promise.resolve(mockVideoStream()));
+  public publishStream = vi.fn();
+  public stopPublishStream = vi.fn();
+  public getTracks = () => this.state.mediaStream?.getTracks() ?? [];
+
+  constructor(call: Call) {
+    super(
+      call,
+      new TestInputMediaDeviceManagerState(
+        'stop-tracks',
+        'camera' as PermissionName,
+      ),
+      TrackType.VIDEO,
+    );
+  }
+}
+
+describe('MediaStream Filters', () => {
+  let manager: TestInputMediaDeviceManager;
+
+  beforeEach(() => {
+    manager = new TestInputMediaDeviceManager(
+      new Call({
+        id: '',
+        type: '',
+        streamClient: new StreamClient('abc123'),
+        clientStore: new StreamVideoWriteableStateStore(),
+      }),
+    );
+  });
+
+  it('should support registering and unregistering of filters', async () => {
+    const mediaStream = new MediaStream();
+    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);
+    await manager.enable();
+
+    expect(filter).toHaveBeenCalled();
+
+    filter.mockClear();
+    await unregister();
+    await manager.enable();
+
+    expect(filter).not.toHaveBeenCalled();
+  });
+
+  it('should chain media streams together', async () => {
+    const createMediaStream = () => {
+      let onEndedCapture: EventListener | null = null;
+      const mediaStream = new MediaStream();
+      const track = new MediaStreamTrack();
+      vi.spyOn(mediaStream, 'getTracks').mockReturnValue([track]);
+      vi.spyOn(track, 'getSettings').mockReturnValue({ deviceId: '123' });
+      vi.spyOn(track, 'addEventListener').mockImplementation((_, fn) => {
+        onEndedCapture = fn as EventListener;
+      });
+      track.dispatchEvent = (event: Event) => {
+        if (onEndedCapture && event.type === 'ended') {
+          onEndedCapture(event);
+        }
+        return true;
+      };
+      return mediaStream;
+    };
+
+    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);
+    await manager.enable();
+
+    expect(filter1).toHaveBeenCalled();
+    expect(filter2).toHaveBeenCalled();
+
+    // stopping should bubble up: filter -> root
+    const rootSpy = vi.spyOn(rootMediaStream.getTracks()[0], 'stop');
+    expect(rootSpy).not.toHaveBeenCalled();
+    filterMediaStream.getTracks()[0].stop();
+    expect(rootSpy).toHaveBeenCalled();
+
+    // stopping should not bubble down: root -> filter
+    const filterSpy = vi.spyOn(filterMediaStream.getTracks()[0], 'stop');
+    rootMediaStream.getTracks()[0].stop();
+    expect(filterSpy).not.toHaveBeenCalled();
+
+    // simulate an abrupt ending of the track
+    rootMediaStream.getTracks()[0].dispatchEvent(new Event('ended'));
+    expect(filterSpy).toHaveBeenCalled();
+  });
+});