feat: report low power mode and thermal info to stats

packages/client/src/client-details.ts

@@ -1,4 +1,8 @@
 import {
+  AndroidState,
+  AndroidThermalState,
+  AppleState,
+  AppleThermalState,
   ClientDetails,
   Device,
   OS,
@@ -12,6 +16,19 @@ type WebRTCInfoType = {
   version: string;
 };
 
+type DeviceState =
+  | {
+      oneofKind: 'android';
+      android: AndroidState;
+    }
+  | {
+      oneofKind: 'apple';
+      apple: AppleState;
+    }
+  | {
+      oneofKind: undefined;
+    };
+
 const version = process.env.PKG_VERSION || '0.0.0';
 const [major, minor, patch] = version.split('.');
 
@@ -25,6 +42,7 @@ let sdkInfo: Sdk | undefined = {
 let osInfo: OS | undefined;
 let deviceInfo: Device | undefined;
 let webRtcInfo: WebRTCInfoType | undefined;
+let deviceState: DeviceState;
 
 export const setSdkInfo = (info: Sdk) => {
   sdkInfo = info;
@@ -62,6 +80,76 @@ export type LocalClientDetailsType = ClientDetails & {
   webRTCInfo?: WebRTCInfoType;
 };
 
+const getAndroidThermalState = (state: string) => {
+  switch (state) {
+    case 'UNKNOWN':
+      return AndroidThermalState.UNSPECIFIED;
+    case 'NONE':
+      return AndroidThermalState.NONE;
+    case 'LIGHT':
+      return AndroidThermalState.LIGHT;
+    case 'MODERATE':
+      return AndroidThermalState.MODERATE;
+    case 'SEVERE':
+      return AndroidThermalState.SEVERE;
+    case 'CRITICAL':
+      return AndroidThermalState.CRITICAL;
+    case 'EMERGENCY':
+      return AndroidThermalState.EMERGENCY;
+    case 'SHUTDOWN':
+      return AndroidThermalState.SHUTDOWN;
+    default:
+      return AndroidThermalState.UNSPECIFIED;
+  }
+};
+
+const getAppleThermalState = (state: string) => {
+  switch (state.toString()) {
+    case '0':
+      return AppleThermalState.UNSPECIFIED;
+    case '1':
+      return AppleThermalState.NOMINAL;
+    case '2':
+      return AppleThermalState.FAIR;
+    case '3':
+      return AppleThermalState.SERIOUS;
+    case '4':
+      return AppleThermalState.CRITICAL;
+    default:
+      return AppleThermalState.UNSPECIFIED;
+  }
+};
+
+export const setDeviceState = (state: {
+  os: string;
+  thermal: string;
+  isLowPowerMode: boolean;
+}) => {
+  if (state.os === 'android') {
+    deviceState = {
+      oneofKind: 'android',
+      android: {
+        thermalState: getAndroidThermalState(state.thermal),
+        isPowerSaverMode: state.isLowPowerMode,
+      },
+    };
+  } else if (state.os === 'ios') {
+    deviceState = {
+      oneofKind: 'apple',
+      apple: {
+        thermalState: getAppleThermalState(state.thermal),
+        isLowPowerModeEnabled: state.isLowPowerMode,
+      },
+    };
+  } else {
+    deviceState = { oneofKind: undefined };
+  }
+};
+
+export const getDeviceState = () => {
+  return deviceState;
+};
+
 export const getClientDetails = (): LocalClientDetailsType => {
   if (isReactNative()) {
     // Since RN doesn't support web, sharing browser info is not required

packages/client/src/stats/SfuStatsReporter.ts

@@ -4,7 +4,11 @@ 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 {
+  getDeviceState,
+  getWebRTCInfo,
+  LocalClientDetailsType,
+} from '../client-details';
 import { InputDevices } from '../gen/video/sfu/models/models';
 import { CameraManager, MicrophoneManager } from '../devices';
 import { createSubscription } from '../store/rxUtils';
@@ -132,7 +136,7 @@ export class SfuStatsReporter {
       publisherStats,
       audioDevices: this.inputDevices.get('mic'),
       videoDevices: this.inputDevices.get('camera'),
-      deviceState: { oneofKind: undefined },
+      deviceState: getDeviceState(),
       telemetry: telemetryData,
     });
   };

packages/react-native-sdk/android/src/main/AndroidManifest.xml

@@ -2,4 +2,5 @@
         package="com.streamvideo.reactnative">
 
     <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.DEVICE_POWER" />
 </manifest>

packages/react-native-sdk/android/src/main/java/com/streamvideo/reactnative/StreamVideoReactNativeModule.kt

@@ -4,8 +4,12 @@ import android.app.AppOpsManager
 import android.app.PictureInPictureParams
 import android.content.Context
 import android.content.pm.PackageManager
+import android.content.BroadcastReceiver
+import android.content.Intent
+import android.content.IntentFilter
 import android.net.Uri
 import android.os.Build
+import android.os.PowerManager
 import android.os.Process
 import android.util.Rational
 import androidx.annotation.RequiresApi
@@ -23,13 +27,18 @@ class StreamVideoReactNativeModule(reactContext: ReactApplicationContext) : Reac
         return NAME;
     }
 
+    private var thermalStatusListener: PowerManager.OnThermalStatusChangedListener? = null
+
     override fun initialize() {
         super.initialize()
         StreamVideoReactNative.pipListeners.add { isInPictureInPictureMode ->
             reactApplicationContext.getJSModule(
                 RCTDeviceEventEmitter::class.java
             ).emit(PIP_CHANGE_EVENT, isInPictureInPictureMode)
         }
+
+        val filter = IntentFilter(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED)
+        reactApplicationContext.registerReceiver(powerReceiver, filter)
     }
 
     @ReactMethod
@@ -81,6 +90,117 @@ class StreamVideoReactNativeModule(reactContext: ReactApplicationContext) : Reac
         StreamVideoReactNative.canAutoEnterPictureInPictureMode = value
     }
 
+    @ReactMethod
+    fun startThermalStatusUpdates(promise: Promise) {
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                val powerManager = reactApplicationContext.getSystemService(ReactApplicationContext.POWER_SERVICE) as PowerManager
+
+                val listener = PowerManager.OnThermalStatusChangedListener { status ->
+                    val thermalStatus = when (status) {
+                        PowerManager.THERMAL_STATUS_NONE -> "NONE"
+                        PowerManager.THERMAL_STATUS_LIGHT -> "LIGHT"
+                        PowerManager.THERMAL_STATUS_MODERATE -> "MODERATE"
+                        PowerManager.THERMAL_STATUS_SEVERE -> "SEVERE"
+                        PowerManager.THERMAL_STATUS_CRITICAL -> "CRITICAL"
+                        PowerManager.THERMAL_STATUS_EMERGENCY -> "EMERGENCY"
+                        PowerManager.THERMAL_STATUS_SHUTDOWN -> "SHUTDOWN"
+                        else -> "UNKNOWN"
+                    }
+
+                    reactApplicationContext
+                        .getJSModule(RCTDeviceEventEmitter::class.java)
+                        .emit("onThermalStatusChanged", thermalStatus)
+                }
+
+                thermalStatusListener = listener
+                powerManager.addThermalStatusListener(listener)
+                // Get initial status
+                getCurrentThermalStatus(promise)
+            } else {
+                promise.resolve("NOT_SUPPORTED")
+            }
+        } catch (e: Exception) {
+            promise.reject("THERMAL_ERROR", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun stopThermalStatusUpdates() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            val powerManager = reactApplicationContext.getSystemService(ReactApplicationContext.POWER_SERVICE) as PowerManager
+            // Store the current listener in a local val for safe null checking
+            val currentListener = thermalStatusListener
+            if (currentListener != null) {
+                powerManager.removeThermalStatusListener(currentListener)
+                thermalStatusListener = null
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getCurrentThermalStatus(promise: Promise) {
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                val powerManager = reactApplicationContext.getSystemService(ReactApplicationContext.POWER_SERVICE) as PowerManager
+                val status = powerManager.currentThermalStatus
+                val thermalStatus = when (status) {
+                    PowerManager.THERMAL_STATUS_NONE -> "NONE"
+                    PowerManager.THERMAL_STATUS_LIGHT -> "LIGHT"
+                    PowerManager.THERMAL_STATUS_MODERATE -> "MODERATE"
+                    PowerManager.THERMAL_STATUS_SEVERE -> "SEVERE"
+                    PowerManager.THERMAL_STATUS_CRITICAL -> "CRITICAL"
+                    PowerManager.THERMAL_STATUS_EMERGENCY -> "EMERGENCY"
+                    PowerManager.THERMAL_STATUS_SHUTDOWN -> "SHUTDOWN"
+                    else -> "UNKNOWN"
+                }
+                promise.resolve(thermalStatus)
+            } else {
+                promise.resolve("NOT_SUPPORTED")
+            }
+        } catch (e: Exception) {
+            promise.reject("THERMAL_ERROR", e.message)
+        }
+    }
+
+    private val powerReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            if (intent?.action == PowerManager.ACTION_POWER_SAVE_MODE_CHANGED) {
+                sendPowerModeEvent()
+            }
+        }
+    }
+
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        reactApplicationContext.unregisterReceiver(powerReceiver)
+    }
+
+    private fun sendPowerModeEvent() {
+        val powerManager = reactApplicationContext.getSystemService(Context.POWER_SERVICE) as PowerManager
+        val isLowPowerMode = powerManager.isPowerSaveMode
+        reactApplicationContext
+            .getJSModule(RCTDeviceEventEmitter::class.java)
+            .emit("powerModeChanged", isLowPowerMode)
+    }
+
+    @ReactMethod
+    fun isLowPowerModeEnabled(promise: Promise) {
+        try {
+            val powerManager = reactApplicationContext.getSystemService(Context.POWER_SERVICE) as PowerManager
+            promise.resolve(powerManager.isPowerSaveMode)
+        } catch (e: Exception) {
+            promise.reject("ERROR", e.message)
+        }
+    }
+
+    override fun getConstants(): Map<String, Any> {
+        return mapOf(
+            "POWER_MODE_EVENT" to "powerModeChanged",
+            "THERMAL_EVENT" to "onThermalStatusChanged"
+        )
+    }
+
     private fun hasPermission(): Boolean {
         return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && reactApplicationContext.packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)) {
             val appOps =

packages/react-native-sdk/ios/DeviceState.m

@@ -0,0 +1,22 @@
+//
+//  DeviceState.m
+//  StreamVideoReactNative
+//
+//  Created by Kristian Martinoski on 3.12.24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface
+RCT_EXTERN_MODULE(DeviceState, RCTEventEmitter)
+RCT_EXTERN_METHOD(isLowPowerModeEnabled:
+                  (RCTPromiseResolveBlock) resolve
+                  reject:(RCTPromiseRejectBlock) reject)
+RCT_EXTERN_METHOD(currentThermalState:
+                  (RCTPromiseResolveBlock) resolve
+                  reject:(RCTPromiseRejectBlock) reject)
+
+@end

packages/react-native-sdk/ios/DeviceState.swift

@@ -0,0 +1,78 @@
+//
+//  DeviceState.swift
+//  StreamVideoReactNative
+//
+//  Created by Kristian Martinoski on 3.12.24.
+//  Copyright © 2024 Facebook. All rights reserved.
+//
+
+import Foundation
+
+@objc(DeviceState)
+class DeviceState:RCTEventEmitter{
+
+  private var hasListeners = false;
+  override init(){
+    super.init();
+    UIDevice.current.isBatteryMonitoringEnabled = true;
+  }
+
+  @objc
+  func isLowPowerModeEnabled(_ resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    resolve(ProcessInfo.processInfo.isLowPowerModeEnabled);
+  }
+
+  @objc
+  func currentThermalState(_ resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+    resolve(ProcessInfo.processInfo.thermalState.rawValue);
+  }
+
+  override func startObserving() {
+    hasListeners = true;
+
+    NotificationCenter.default.addObserver(self,
+      selector: #selector(powerModeDidChange),
+      name: NSNotification.Name.NSProcessInfoPowerStateDidChange, object: nil)
+
+    NotificationCenter.default.addObserver(self,
+      selector: #selector(thermalStateDidChange),
+      name: ProcessInfo.thermalStateDidChangeNotification, object: nil)
+}
+
+  override func stopObserving() {
+    hasListeners = false;
+
+    NotificationCenter.default.removeObserver(self,
+      name: NSNotification.Name.NSProcessInfoPowerStateDidChange, object: nil)
+
+    NotificationCenter.default.removeObserver(self,
+      name: NSNotification.Name.NSProcessInfoPowerStateDidChange, object: nil)
+  }
+
+  @objc func powerModeDidChange() {
+    if(!hasListeners) {
+      return;
+    }
+    let lowPowerEnabled = ProcessInfo.processInfo.isLowPowerModeEnabled;
+
+    self.sendEvent(withName: "isLowPowerModeEnabled", body: lowPowerEnabled);
+
+  }
+
+  @objc func thermalStateDidChange() {
+    if (!hasListeners) {
+      return
+    }
+    let thermalState = ProcessInfo.processInfo.thermalState.rawValue
+    self.sendEvent(withName: "thermalStateDidChange", body: thermalState)
+  }
+
+  override func supportedEvents() -> [String]! {
+    return ["isLowPowerModeEnabled",  "thermalStateDidChange"];
+  }
+
+  override class func requiresMainQueueSetup() -> Bool {
+    return false;
+  }
+
+}

packages/react-native-sdk/ios/StreamVideoReactNative-Bridging-Header.h

@@ -12,3 +12,4 @@
 #import <WebRTC/RTCVideoRenderer.h>
 #import <WebRTC/RTCVideoFrameBuffer.h>
 #import "WebRTCModule.h"
+#import "ProcessorProvider.h"