@stream-io/video-client 1.9.2 → 1.10.0

package/src/stats/SfuStatsReporter.ts

@@ -1,15 +1,23 @@
+import { combineLatest } from 'rxjs';
 import { StreamSfuClient } from '../StreamSfuClient';
-import { StatsOptions } from '../gen/coordinator';
+import { OwnCapability, StatsOptions } from '../gen/coordinator';
 import { getLogger } from '../logger';
 import { Publisher, Subscriber } from '../rtc';
 import { flatten, getSdkName, getSdkVersion } from './utils';
 import { getWebRTCInfo, LocalClientDetailsType } from '../client-details';
+import { InputDevices } from '../gen/video/sfu/models/models';
+import { CameraManager, MicrophoneManager } from '../devices';
+import { createSubscription } from '../store/rxUtils';
+import { CallState } from '../store';
 
 export type SfuStatsReporterOptions = {
   options: StatsOptions;
   clientDetails: LocalClientDetailsType;
   subscriber: Subscriber;
   publisher?: Publisher;
+  microphone: MicrophoneManager;
+  camera: CameraManager;
+  state: CallState;
 };
 
 export class SfuStatsReporter {
@@ -20,34 +28,91 @@ export class SfuStatsReporter {
   private readonly sfuClient: StreamSfuClient;
   private readonly subscriber: Subscriber;
   private readonly publisher?: Publisher;
+  private readonly microphone: MicrophoneManager;
+  private readonly camera: CameraManager;
+  private readonly state: CallState;
 
   private intervalId: NodeJS.Timeout | undefined;
+  private unsubscribeDevicePermissionsSubscription?: () => void;
+  private unsubscribeListDevicesSubscription?: () => void;
   private readonly sdkName: string;
   private readonly sdkVersion: string;
   private readonly webRTCVersion: string;
+  private readonly inputDevices = new Map<'mic' | 'camera', InputDevices>();
 
   constructor(
     sfuClient: StreamSfuClient,
-    { options, clientDetails, subscriber, publisher }: SfuStatsReporterOptions,
+    {
+      options,
+      clientDetails,
+      subscriber,
+      publisher,
+      microphone,
+      camera,
+      state,
+    }: SfuStatsReporterOptions,
   ) {
     this.sfuClient = sfuClient;
     this.options = options;
     this.subscriber = subscriber;
     this.publisher = publisher;
-    const webRTCInfo = getWebRTCInfo();
+    this.microphone = microphone;
+    this.camera = camera;
+    this.state = state;
 
     const { sdk, browser } = clientDetails;
-
     this.sdkName = getSdkName(sdk);
     this.sdkVersion = getSdkVersion(sdk);
 
-    // The WebRTC version if passed from the SDK, it is taken else the browser info is sent.
+    // use the WebRTC version if set by the SDK (React Native) otherwise,
+    // use the browser version as a fallback
+    const webRTCInfo = getWebRTCInfo();
     this.webRTCVersion =
       webRTCInfo?.version ||
       `${browser?.name || ''}-${browser?.version || ''}` ||
       'N/A';
   }
 
+  private observeDevice = (
+    device: CameraManager | MicrophoneManager,
+    kind: 'mic' | 'camera',
+  ) => {
+    const { hasBrowserPermission$ } = device.state;
+    this.unsubscribeDevicePermissionsSubscription?.();
+    this.unsubscribeDevicePermissionsSubscription = createSubscription(
+      combineLatest([hasBrowserPermission$, this.state.ownCapabilities$]),
+      ([hasPermission, ownCapabilities]) => {
+        // cleanup the previous listDevices() subscription in case
+        // permissions or capabilities have changed.
+        // we will subscribe again if everything is in order.
+        this.unsubscribeListDevicesSubscription?.();
+        const hasCapability =
+          kind === 'mic'
+            ? ownCapabilities.includes(OwnCapability.SEND_AUDIO)
+            : ownCapabilities.includes(OwnCapability.SEND_VIDEO);
+        if (!hasPermission || !hasCapability) {
+          this.inputDevices.set(kind, {
+            currentDevice: '',
+            availableDevices: [],
+            isPermitted: false,
+          });
+          return;
+        }
+        this.unsubscribeListDevicesSubscription = createSubscription(
+          combineLatest([device.listDevices(), device.state.selectedDevice$]),
+          ([devices, deviceId]) => {
+            const selected = devices.find((d) => d.deviceId === deviceId);
+            this.inputDevices.set(kind, {
+              currentDevice: selected?.label || deviceId || '',
+              availableDevices: devices.map((d) => d.label),
+              isPermitted: true,
+            });
+          },
+        );
+      },
+    );
+  };
+
   private run = async () => {
     const [subscriberStats, publisherStats] = await Promise.all([
       this.subscriber.getStats().then(flatten).then(JSON.stringify),
@@ -60,11 +125,18 @@ export class SfuStatsReporter {
       webrtcVersion: this.webRTCVersion,
       subscriberStats,
       publisherStats,
+      audioDevices: this.inputDevices.get('mic'),
+      videoDevices: this.inputDevices.get('camera'),
+      deviceState: { oneofKind: undefined },
     });
   };
 
   start = () => {
     if (this.options.reporting_interval_ms <= 0) return;
+
+    this.observeDevice(this.microphone, 'mic');
+    this.observeDevice(this.camera, 'camera');
+
     clearInterval(this.intervalId);
     this.intervalId = setInterval(() => {
       this.run().catch((err) => {
@@ -74,6 +146,12 @@ export class SfuStatsReporter {
   };
 
   stop = () => {
+    this.unsubscribeDevicePermissionsSubscription?.();
+    this.unsubscribeDevicePermissionsSubscription = undefined;
+    this.unsubscribeListDevicesSubscription?.();
+    this.unsubscribeListDevicesSubscription = undefined;
+
+    this.inputDevices.clear();
     clearInterval(this.intervalId);
     this.intervalId = undefined;
   };

package/src/store/rxUtils.ts

@@ -1,5 +1,6 @@
 import { combineLatest, Observable, Subject } from 'rxjs';
 import { withoutConcurrency } from '../helpers/concurrency';
+import { getLogger } from '../logger';
 
 type FunctionPatch<T> = (currentValue: T) => T;
 
@@ -63,12 +64,15 @@ export const setCurrentValue = <T>(subject: Subject<T>, update: Patch<T>) => {
  *
  * @param observable the observable to subscribe to.
  * @param handler the handler to call when the observable emits a value.
+ * @param onError an optional error handler.
  */
 export const createSubscription = <T>(
   observable: Observable<T>,
   handler: (value: T) => void,
+  onError: (error: any) => void = (error) =>
+    getLogger(['RxUtils'])('warn', 'An observable emitted an error', error),
 ) => {
-  const subscription = observable.subscribe(handler);
+  const subscription = observable.subscribe({ next: handler, error: onError });
   return () => {
     subscription.unsubscribe();
   };
@@ -87,10 +91,7 @@ export const createSafeAsyncSubscription = <T>(
   handler: (value: T) => Promise<void>,
 ) => {
   const tag = Symbol();
-  const subscription = observable.subscribe((value) => {
+  return createSubscription(observable, (value) => {
     withoutConcurrency(tag, () => handler(value));
   });
-  return () => {
-    subscription.unsubscribe();
-  };
 };