@stream-io/video-client 1.9.3 → 1.10.0

package/dist/index.cjs.js

@@ -862,6 +862,76 @@ var WebsocketReconnectStrategy;
      */
     WebsocketReconnectStrategy[WebsocketReconnectStrategy["MIGRATE"] = 4] = "MIGRATE";
 })(WebsocketReconnectStrategy || (WebsocketReconnectStrategy = {}));
+/**
+ * AndroidThermalState is reported by the Android API. The full list of values is documented here
+ * https://developer.android.com/reference/android/os/PowerManager.html#getCurrentThermalStatus()
+ *
+ * @generated from protobuf enum stream.video.sfu.models.AndroidThermalState
+ */
+var AndroidThermalState;
+(function (AndroidThermalState) {
+    /**
+     * @generated from protobuf enum value: ANDROID_THERMAL_STATE_UNSPECIFIED = 0;
+     */
+    AndroidThermalState[AndroidThermalState["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: ANDROID_THERMAL_STATE_NONE = 1;
+     */
+    AndroidThermalState[AndroidThermalState["NONE"] = 1] = "NONE";
+    /**
+     * @generated from protobuf enum value: ANDROID_THERMAL_STATE_LIGHT = 2;
+     */
+    AndroidThermalState[AndroidThermalState["LIGHT"] = 2] = "LIGHT";
+    /**
+     * @generated from protobuf enum value: ANDROID_THERMAL_STATE_MODERATE = 3;
+     */
+    AndroidThermalState[AndroidThermalState["MODERATE"] = 3] = "MODERATE";
+    /**
+     * @generated from protobuf enum value: ANDROID_THERMAL_STATE_SEVERE = 4;
+     */
+    AndroidThermalState[AndroidThermalState["SEVERE"] = 4] = "SEVERE";
+    /**
+     * @generated from protobuf enum value: ANDROID_THERMAL_STATE_CRITICAL = 5;
+     */
+    AndroidThermalState[AndroidThermalState["CRITICAL"] = 5] = "CRITICAL";
+    /**
+     * @generated from protobuf enum value: ANDROID_THERMAL_STATE_EMERGENCY = 6;
+     */
+    AndroidThermalState[AndroidThermalState["EMERGENCY"] = 6] = "EMERGENCY";
+    /**
+     * @generated from protobuf enum value: ANDROID_THERMAL_STATE_SHUTDOWN = 7;
+     */
+    AndroidThermalState[AndroidThermalState["SHUTDOWN"] = 7] = "SHUTDOWN";
+})(AndroidThermalState || (AndroidThermalState = {}));
+/**
+ * AppleThermalState is the thermal state as reported by Apple devices when available or applicable to the platform.
+ * The full list of states (enum) is available here: https://developer.apple.com/documentation/foundation/processinfo/thermalstate
+ *
+ * @generated from protobuf enum stream.video.sfu.models.AppleThermalState
+ */
+var AppleThermalState;
+(function (AppleThermalState) {
+    /**
+     * @generated from protobuf enum value: APPLE_THERMAL_STATE_UNSPECIFIED = 0;
+     */
+    AppleThermalState[AppleThermalState["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: APPLE_THERMAL_STATE_NOMINAL = 1;
+     */
+    AppleThermalState[AppleThermalState["NOMINAL"] = 1] = "NOMINAL";
+    /**
+     * @generated from protobuf enum value: APPLE_THERMAL_STATE_FAIR = 2;
+     */
+    AppleThermalState[AppleThermalState["FAIR"] = 2] = "FAIR";
+    /**
+     * @generated from protobuf enum value: APPLE_THERMAL_STATE_SERIOUS = 3;
+     */
+    AppleThermalState[AppleThermalState["SERIOUS"] = 3] = "SERIOUS";
+    /**
+     * @generated from protobuf enum value: APPLE_THERMAL_STATE_CRITICAL = 4;
+     */
+    AppleThermalState[AppleThermalState["CRITICAL"] = 4] = "CRITICAL";
+})(AppleThermalState || (AppleThermalState = {}));
 // @generated message type with reflection information, may provide speed optimized methods
 class CallState$Type extends runtime.MessageType {
     constructor() {
@@ -1300,9 +1370,92 @@ class CallGrants$Type extends runtime.MessageType {
  * @generated MessageType for protobuf message stream.video.sfu.models.CallGrants
  */
 const CallGrants = new CallGrants$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class InputDevices$Type extends runtime.MessageType {
+    constructor() {
+        super('stream.video.sfu.models.InputDevices', [
+            {
+                no: 1,
+                name: 'available_devices',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'current_device',
+                kind: 'scalar',
+                T: 9 /*ScalarType.STRING*/,
+            },
+            { no: 3, name: 'is_permitted', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.InputDevices
+ */
+const InputDevices = new InputDevices$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AndroidState$Type extends runtime.MessageType {
+    constructor() {
+        super('stream.video.sfu.models.AndroidState', [
+            {
+                no: 1,
+                name: 'thermal_state',
+                kind: 'enum',
+                T: () => [
+                    'stream.video.sfu.models.AndroidThermalState',
+                    AndroidThermalState,
+                    'ANDROID_THERMAL_STATE_',
+                ],
+            },
+            {
+                no: 2,
+                name: 'is_power_saver_mode',
+                kind: 'scalar',
+                T: 8 /*ScalarType.BOOL*/,
+            },
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.AndroidState
+ */
+const AndroidState = new AndroidState$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AppleState$Type extends runtime.MessageType {
+    constructor() {
+        super('stream.video.sfu.models.AppleState', [
+            {
+                no: 1,
+                name: 'thermal_state',
+                kind: 'enum',
+                T: () => [
+                    'stream.video.sfu.models.AppleThermalState',
+                    AppleThermalState,
+                    'APPLE_THERMAL_STATE_',
+                ],
+            },
+            {
+                no: 2,
+                name: 'is_low_power_mode_enabled',
+                kind: 'scalar',
+                T: 8 /*ScalarType.BOOL*/,
+            },
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message stream.video.sfu.models.AppleState
+ */
+const AppleState = new AppleState$Type();
 
 var models = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    AndroidState: AndroidState,
+    get AndroidThermalState () { return AndroidThermalState; },
+    AppleState: AppleState,
+    get AppleThermalState () { return AppleThermalState; },
     Browser: Browser,
     Call: Call$1,
     get CallEndedReason () { return CallEndedReason; },
@@ -1316,6 +1469,7 @@ var models = /*#__PURE__*/Object.freeze({
     get ErrorCode () { return ErrorCode; },
     get GoAwayReason () { return GoAwayReason; },
     ICETrickle: ICETrickle$1,
+    InputDevices: InputDevices,
     OS: OS,
     Participant: Participant,
     ParticipantCount: ParticipantCount,
@@ -1415,6 +1569,22 @@ class SendStatsRequest$Type extends runtime.MessageType {
                 kind: 'scalar',
                 T: 9 /*ScalarType.STRING*/,
             },
+            { no: 7, name: 'audio_devices', kind: 'message', T: () => InputDevices },
+            { no: 8, name: 'video_devices', kind: 'message', T: () => InputDevices },
+            {
+                no: 9,
+                name: 'android',
+                kind: 'message',
+                oneof: 'deviceState',
+                T: () => AndroidState,
+            },
+            {
+                no: 10,
+                name: 'apple',
+                kind: 'message',
+                oneof: 'deviceState',
+                T: () => AppleState,
+            },
         ]);
     }
 }
@@ -2959,7 +3129,7 @@ const retryable = async (rpc, signal) => {
     return result;
 };
 
-const version = "1.9.3";
+const version = "1.10.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -3689,9 +3859,10 @@ const setCurrentValue = (subject, update) => {
  *
  * @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.
  */
-const createSubscription = (observable, handler) => {
-    const subscription = observable.subscribe(handler);
+const createSubscription = (observable, handler, onError = (error) => getLogger(['RxUtils'])('warn', 'An observable emitted an error', error)) => {
+    const subscription = observable.subscribe({ next: handler, error: onError });
     return () => {
         subscription.unsubscribe();
     };
@@ -3706,12 +3877,9 @@ const createSubscription = (observable, handler) => {
  */
 const createSafeAsyncSubscription = (observable, handler) => {
     const tag = Symbol();
-    const subscription = observable.subscribe((value) => {
+    return createSubscription(observable, (value) => {
         withoutConcurrency(tag, () => handler(value));
     });
-    return () => {
-        subscription.unsubscribe();
-    };
 };
 
 var rxUtils = /*#__PURE__*/Object.freeze({
@@ -6981,8 +7149,38 @@ const aggregate = (stats) => {
 };
 
 class SfuStatsReporter {
-    constructor(sfuClient, { options, clientDetails, subscriber, publisher }) {
+    constructor(sfuClient, { options, clientDetails, subscriber, publisher, microphone, camera, state, }) {
         this.logger = getLogger(['SfuStatsReporter']);
+        this.inputDevices = new Map();
+        this.observeDevice = (device, kind) => {
+            const { hasBrowserPermission$ } = device.state;
+            this.unsubscribeDevicePermissionsSubscription?.();
+            this.unsubscribeDevicePermissionsSubscription = createSubscription(rxjs.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(rxjs.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,
+                    });
+                });
+            });
+        };
         this.run = async () => {
             const [subscriberStats, publisherStats] = await Promise.all([
                 this.subscriber.getStats().then(flatten).then(JSON.stringify),
@@ -6994,11 +7192,16 @@ class SfuStatsReporter {
                 webrtcVersion: this.webRTCVersion,
                 subscriberStats,
                 publisherStats,
+                audioDevices: this.inputDevices.get('mic'),
+                videoDevices: this.inputDevices.get('camera'),
+                deviceState: { oneofKind: undefined },
             });
         };
         this.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) => {
@@ -7007,6 +7210,11 @@ class SfuStatsReporter {
             }, this.options.reporting_interval_ms);
         };
         this.stop = () => {
+            this.unsubscribeDevicePermissionsSubscription?.();
+            this.unsubscribeDevicePermissionsSubscription = undefined;
+            this.unsubscribeListDevicesSubscription?.();
+            this.unsubscribeListDevicesSubscription = undefined;
+            this.inputDevices.clear();
             clearInterval(this.intervalId);
             this.intervalId = undefined;
         };
@@ -7014,11 +7222,15 @@ class SfuStatsReporter {
         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 || ''}` ||
@@ -9803,6 +10015,9 @@ class Call {
                     options: statsOptions,
                     subscriber: this.subscriber,
                     publisher: this.publisher,
+                    microphone: this.microphone,
+                    camera: this.camera,
+                    state: this.state,
                 });
                 this.sfuStatsReporter.start();
             }
@@ -12112,7 +12327,7 @@ class StreamClient {
             }
             if ((this._isUsingServerAuth() || this.node) &&
                 !this.options.allowServerSideConnect) {
-                this.logger('warn', 'Please do not use connectUser server side. connectUser impacts MAU and concurrent connection usage and thus your bill. If you have a valid use-case, add "allowServerSideConnect: true" to the client options to disable this warning.');
+                this.logger('warn', 'Please do not use connectUser server side. Use our @stream-io/node-sdk instead: https://getstream.io/video/docs/api/');
             }
             // we generate the client id client side
             this.userID = user.id;
@@ -12488,7 +12703,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "1.9.3";
+            const version = "1.10.0";
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };