@100mslive/react-native-hms 0.9.93 → 1.0.0

package/android/src/main/java/com/reactnativehmssdk/HMSHelper.kt

@@ -10,15 +10,12 @@ import android.view.PixelCopy
 import android.webkit.URLUtil
 import androidx.annotation.RequiresApi
 import com.facebook.react.bridge.*
-import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.events.RCTEventEmitter
 import java.io.ByteArrayOutputStream
 import java.util.*
 import live.hms.video.audio.HMSAudioManager
 import live.hms.video.error.HMSException
-import live.hms.video.media.codec.HMSAudioCodec
-import live.hms.video.media.codec.HMSVideoCodec
+import live.hms.video.events.AgentType
 import live.hms.video.media.settings.*
 import live.hms.video.media.tracks.HMSRemoteAudioTrack
 import live.hms.video.media.tracks.HMSRemoteVideoTrack
@@ -26,6 +23,8 @@ import live.hms.video.media.tracks.HMSTrack
 import live.hms.video.sdk.models.*
 import live.hms.video.sdk.models.enums.AudioMixingMode
 import live.hms.video.sdk.models.role.HMSRole
+import live.hms.video.services.LogAlarmManager
+import live.hms.video.utils.HMSLogger
 import live.hms.video.utils.HmsUtilities
 import org.webrtc.SurfaceViewRenderer
 
@@ -161,93 +160,148 @@ object HMSHelper {
     return null
   }
 
-  fun getTrackSettings(data: ReadableMap?): HMSTrackSettings? {
-    if (data == null) {
-      return null
+  fun getFrameworkInfo(data: ReadableMap?): FrameworkInfo? {
+    if (data != null &&
+            this.areAllRequiredKeysAvailable(
+                data,
+                arrayOf(Pair("version", "String"), Pair("sdkVersion", "String"))
+            )
+    ) {
+      val version = data.getString("version") as String
+      val sdkVersion = data.getString("sdkVersion") as String
+      return FrameworkInfo(AgentType.REACT_NATIVE, sdkVersion, version)
     }
+    return null
+  }
 
-    var useHardwareEchoCancellation = false
-    val requiredKeysUseHardwareEchoCancellation =
-        this.areAllRequiredKeysAvailable(
-            data,
-            arrayOf(Pair("useHardwareEchoCancellation", "Boolean"))
-        )
-    if (requiredKeysUseHardwareEchoCancellation) {
-      useHardwareEchoCancellation = data.getBoolean("useHardwareEchoCancellation")
+  fun getLogSettings(data: ReadableMap?): HMSLogSettings? {
+    if (data != null &&
+            this.areAllRequiredKeysAvailable(
+                data,
+                arrayOf(
+                    Pair("level", "String"),
+                    Pair("maxDirSizeInBytes", "String"),
+                    Pair("isLogStorageEnabled", "Boolean")
+                )
+            )
+    ) {
+      val level = getLogLevel(data.getString("level"))
+      val maxDirSizeInBytes = getLogAlarmManager(data.getString("maxDirSizeInBytes"))
+      val isLogStorageEnabled = data.getBoolean("isLogStorageEnabled")
+      return HMSLogSettings(maxDirSizeInBytes, isLogStorageEnabled, level)
     }
+    return null
+  }
 
-    var video: ReadableMap? = null
-    val requiredKeysVideo = this.areAllRequiredKeysAvailable(data, arrayOf(Pair("video", "Map")))
-    if (requiredKeysVideo) {
-      video = data.getMap("video")
+  private fun getLogAlarmManager(logAlarmManager: String?): Long {
+    when (logAlarmManager) {
+      "DEFAULT_DIR_SIZE" -> {
+        return LogAlarmManager.DEFAULT_DIR_SIZE
+      }
+      "DEFAULT_LOGS_FILE_NAME" -> {
+        return LogAlarmManager.DEFAULT_LOGS_FILE_NAME.toLong()
+      }
+      "MAX_DIR_SIZE" -> {
+        return LogAlarmManager.MAX_DIR_SIZE.toLong()
+      }
     }
+    return LogAlarmManager.DEFAULT_DIR_SIZE
+  }
 
-    var audio: ReadableMap? = null
-    val requiredKeysAudio = this.areAllRequiredKeysAvailable(data, arrayOf(Pair("audio", "Map")))
-    if (requiredKeysAudio) {
-      audio = data.getMap("audio")
+  private fun getLogLevel(logLevel: String?): HMSLogger.LogLevel {
+    when (logLevel) {
+      "VERBOSE" -> {
+        return HMSLogger.LogLevel.VERBOSE
+      }
+      "WARN" -> {
+        return HMSLogger.LogLevel.WARN
+      }
+      "ERROR" -> {
+        return HMSLogger.LogLevel.ERROR
+      }
     }
+    return HMSLogger.LogLevel.VERBOSE
+  }
 
-    if (video == null && audio == null && !useHardwareEchoCancellation) {
+  fun getTrackSettings(data: ReadableMap?): HMSTrackSettings? {
+    if (data == null) {
       return null
     }
+    val builder = HMSTrackSettings.Builder()
+    if (this.areAllRequiredKeysAvailable(data, arrayOf(Pair("video", "Map")))) {
+      val video = data.getMap("video")
+      val videoSettings = this.getVideoTrackSettings(video)
+      if (videoSettings != null) {
+        builder.video(videoSettings)
+      }
+    }
 
-    val videoSettings = this.getVideoTrackSettings(video)
-    val audioSettings = this.getAudioTrackSettings(audio, useHardwareEchoCancellation)
-    val trackSettingsBuilder = HMSTrackSettings.Builder()
-    return trackSettingsBuilder.audio(audioSettings).video(videoSettings).build()
+    if (this.areAllRequiredKeysAvailable(data, arrayOf(Pair("audio", "Map")))) {
+      val audio = data.getMap("audio")
+      val audioSettings = this.getAudioTrackSettings(audio)
+      if (audioSettings != null) {
+        builder.audio(audioSettings)
+      }
+    }
+    return builder.build()
   }
 
-  private fun getAudioTrackSettings(
-      data: ReadableMap?,
-      useHardwareEchoCancellation: Boolean
-  ): HMSAudioTrackSettings {
-    val builder =
-        HMSAudioTrackSettings.Builder()
-            .setUseHardwareAcousticEchoCanceler(useHardwareEchoCancellation)
-
-    if (data != null) {
-      val maxBitrate = data.getInt("maxBitrate")
-      val codec = getAudioCodec(data.getString("codec"))
-
-      builder.maxBitrate(maxBitrate)
-      builder.codec(codec)
+  private fun getAudioTrackSettings(data: ReadableMap?): HMSAudioTrackSettings? {
+    if (data == null) {
+      return null
+    }
+    val builder = HMSAudioTrackSettings.Builder()
+    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("useHardwareEchoCancellation", "Boolean")))
+    ) {
+      val useHardwareEchoCancellation = data.getBoolean("useHardwareEchoCancellation")
+      builder.setUseHardwareAcousticEchoCanceler(useHardwareEchoCancellation)
     }
 
+    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("initialState", "String")))) {
+      val initialState = getHMSTrackSettingsInitState(data.getString("initialState"))
+      builder.initialState(initialState)
+    }
     return builder.build()
   }
 
-  // TODO: find out a way to set settings required to create HMSVideoTrackSettings
-
-  private fun getVideoTrackSettings(data: ReadableMap?): HMSVideoTrackSettings {
+  private fun getVideoTrackSettings(data: ReadableMap?): HMSVideoTrackSettings? {
+    if (data == null) {
+      return null
+    }
     val builder = HMSVideoTrackSettings.Builder()
-    if (data != null) {
-      val codec = getVideoCodec(data.getString("codec"))
-      val resolution = getVideoResolution(data.getMap("resolution"))
-      val maxBitrate = data.getInt("maxBitrate")
-      val maxFrameRate = data.getInt("maxFrameRate")
-      val cameraFacing = getCameraFacing(data.getString("cameraFacing"))
 
-      builder.codec(codec)
+    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("cameraFacing", "String")))) {
+      val cameraFacing = getCameraFacing(data.getString("cameraFacing"))
       builder.cameraFacing(cameraFacing)
-      if (resolution != null) {
-        builder.resolution(resolution)
-      }
-      builder.maxBitrate(maxBitrate)
-      builder.maxFrameRate(maxFrameRate)
+    }
+
+    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("disableAutoResize", "Boolean")))) {
+      val disableAutoResize = data.getBoolean("disableAutoResize")
+      builder.disableAutoResize(disableAutoResize)
+    }
+
+    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("initialState", "String")))) {
+      val initialState = getHMSTrackSettingsInitState(data.getString("initialState"))
+      builder.initialState(initialState)
+    }
+
+    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("forceSoftwareDecoder", "Boolean")))) {
+      val forceSoftwareDecoder = data.getBoolean("forceSoftwareDecoder")
+      builder.forceSoftwareDecoder(forceSoftwareDecoder)
     }
     return builder.build()
   }
 
-  private fun getVideoResolution(map: ReadableMap?): HMSVideoResolution? {
-    val width = map?.getDouble("width")
-    val height = map?.getDouble("height")
-
-    return if (width != null && height != null) {
-      HMSVideoResolution(width = width.toInt(), height = height.toInt())
-    } else {
-      null
+  private fun getHMSTrackSettingsInitState(initState: String?): HMSTrackSettings.InitState {
+    when (initState) {
+      "UNMUTED" -> {
+        return HMSTrackSettings.InitState.UNMUTED
+      }
+      "MUTED" -> {
+        return HMSTrackSettings.InitState.MUTED
+      }
     }
+    return HMSTrackSettings.InitState.UNMUTED
   }
 
   fun getAudioMixingMode(audioMixingMode: String?): AudioMixingMode {
@@ -265,30 +319,6 @@ object HMSHelper {
     return AudioMixingMode.TALK_AND_MUSIC
   }
 
-  private fun getAudioCodec(codecString: String?): HMSAudioCodec {
-    when (codecString) {
-      "opus" -> {
-        return HMSAudioCodec.OPUS
-      }
-    }
-    return HMSAudioCodec.OPUS
-  }
-
-  private fun getVideoCodec(codecString: String?): HMSVideoCodec {
-    when (codecString) {
-      "H264" -> {
-        return HMSVideoCodec.H264
-      }
-      "VP8" -> {
-        return HMSVideoCodec.VP8
-      }
-      "VP9" -> {
-        return HMSVideoCodec.VP9
-      }
-    }
-    return HMSVideoCodec.H264
-  }
-
   private fun getCameraFacing(cameraFacing: String?): HMSVideoTrackSettings.CameraFacing {
     when (cameraFacing) {
       "FRONT" -> {

package/android/src/main/java/com/reactnativehmssdk/HMSManager.kt

@@ -2,7 +2,12 @@ package com.reactnativehmssdk
 
 import android.app.Activity
 import android.app.Application
+import android.app.PictureInPictureParams
+import android.content.pm.PackageManager
+import android.os.Build
 import android.os.Bundle
+import android.util.Rational
+import androidx.annotation.RequiresApi
 import com.facebook.react.bridge.*
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.DeviceEventManagerModule
@@ -159,6 +164,27 @@ class HMSManager(reactContext: ReactApplicationContext) :
     hms?.getRoom(callback)
   }
 
+  @ReactMethod
+  fun getLocalPeer(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.getLocalPeer(callback)
+  }
+
+  @ReactMethod
+  fun getRemotePeers(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.getRemotePeers(callback)
+  }
+
+  @ReactMethod
+  fun getRoles(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.getRoles(callback)
+  }
+
   @ReactMethod
   fun setPlaybackAllowed(data: ReadableMap) {
     val hms = HMSHelper.getHms(data, hmsCollection)
@@ -341,6 +367,20 @@ class HMSManager(reactContext: ReactApplicationContext) :
     hms?.disableRTCStats()
   }
 
+  @ReactMethod
+  fun enableNetworkQualityUpdates(data: ReadableMap) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.enableNetworkQualityUpdates()
+  }
+
+  @ReactMethod
+  fun disableNetworkQualityUpdates(data: ReadableMap) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.disableNetworkQualityUpdates()
+  }
+
   @ReactMethod
   fun getAudioDevicesList(data: ReadableMap, callback: Promise?) {
     val hms = HMSHelper.getHms(data, hmsCollection)
@@ -376,6 +416,162 @@ class HMSManager(reactContext: ReactApplicationContext) :
     hms?.setAudioDeviceChangeListener()
   }
 
+  @ReactMethod
+  fun setSessionMetaData(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.setSessionMetaData(data, callback)
+  }
+
+  @ReactMethod
+  fun getSessionMetaData(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.getSessionMetaData(callback)
+  }
+
+  data class PipParamConfig(val aspectRatio: Pair<Int, Int>?)
+
+  @ReactMethod
+  fun handlePipActions(action: String, data: ReadableMap?, promise: Promise?) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      promise?.reject(Throwable("PIP mode is not supported!"))
+      return
+    }
+
+    try {
+      when(action) {
+        "isPipModeSupported" -> {
+          val result = isPipModeSupported()
+          promise?.resolve(result)
+        }
+        "enablePipMode" -> {
+          val result = enablePipMode(data)
+          promise?.resolve(result)
+        }
+        "setPictureInPictureParams" -> {
+          val result = setPictureInPictureParams(data)
+          promise?.resolve(result)
+        }
+      }
+    } catch (e: Exception) {
+      promise?.reject(e)
+    }
+  }
+
+  /**
+   * Builds and returns PictureInPictureParams as per given config
+   * Currently we are supporting only "aspectRatio" in config
+   */
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun buildPipParams(config: PipParamConfig): PictureInPictureParams {
+    val pipParams = PictureInPictureParams.Builder().let {
+      if (config.aspectRatio !== null) {
+        it.setAspectRatio(Rational(
+          config.aspectRatio.first,
+          config.aspectRatio.second
+        ))
+      }
+
+//      TODO:= We need compileSdkVersion >= 31 for autoEnterEnabled
+//      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && config.autoEnterEnabled !== null)
+//        it.setAutoEnterEnabled(config.autoEnterEnabled)
+//      }
+
+      it.build()
+    }
+
+    return pipParams
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun readableMapToPipParamConfig(data: ReadableMap?): PipParamConfig {
+    var aspectRatio: Pair<Int, Int>? = null;
+//    TODO:= We need compileSdkVersion >= 31 for autoEnterEnabled
+//    var autoEnterEnabled: Boolean? = null;
+
+    if (data !== null) {
+      if (data.hasKey("aspectRatio")) {
+        val aspectRatioArray = data.getArray("aspectRatio")
+
+        if (aspectRatioArray !== null) {
+          val firstItemType = aspectRatioArray.getType(0)
+          var firstItem: Int? = null
+          if (firstItemType === ReadableType.Number) {
+            firstItem = aspectRatioArray.getInt(0)
+          }
+
+          val secondItemType = aspectRatioArray.getType(1)
+          var secondItem: Int? = null
+          if (secondItemType === ReadableType.Number) {
+            secondItem = aspectRatioArray.getInt(1)
+          }
+
+          if (firstItem !== null && secondItem !== null) {
+            aspectRatio = Pair(firstItem, secondItem)
+          }
+        }
+      }
+
+//      TODO:= We need compileSdkVersion >= 31 for autoEnterEnabled
+//      if (data.hasKey("autoEnterEnabled")) {
+//        val autoEnterEnabledType = data.getType("autoEnterEnabled")
+//
+//        if (autoEnterEnabledType === ReadableType.Boolean) {
+//          autoEnterEnabled = data.getBoolean("autoEnterEnabled")
+//        }
+//      }
+    }
+
+    return PipParamConfig(aspectRatio)
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun setPictureInPictureParams(data: ReadableMap?): Boolean {
+    if (!isPipModeSupported()) {
+      throw Throwable(message = "PIP Mode is not supported!")
+    }
+
+    val activity = currentActivity;
+
+    if (activity !== null) {
+      val pipParamConfig = readableMapToPipParamConfig(data)
+      val pipParams = buildPipParams(pipParamConfig)
+
+      activity.setPictureInPictureParams(pipParams)
+      return true
+    }
+
+    return false
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun isPipModeSupported(): Boolean {
+    return reactApplicationContext.packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun enablePipMode(data: ReadableMap?): Boolean {
+    try {
+      if (!isPipModeSupported()) {
+        throw Throwable(message = "PIP Mode is not supported!")
+      }
+
+      val activity = currentActivity;
+
+      if (activity !== null) {
+        val pipParamConfig = readableMapToPipParamConfig(data)
+        val pipParams = buildPipParams(pipParamConfig)
+
+        return activity.enterPictureInPictureMode(pipParams)
+      }
+
+      return false;
+    } catch (e: Exception) {
+      throw e
+    }
+  }
+
   fun emitEvent(event: String, data: WritableMap) {
     reactApplicationContext
         .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)