@100mslive/react-native-hms 0.8.0 → 0.8.4

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

@@ -1,6 +1,13 @@
 package com.reactnativehmssdk
 
+import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
+import live.hms.video.media.codec.HMSAudioCodec
+import live.hms.video.media.codec.HMSVideoCodec
+import live.hms.video.media.settings.HMSAudioTrackSettings
+import live.hms.video.media.settings.HMSTrackSettings
+import live.hms.video.media.settings.HMSVideoResolution
+import live.hms.video.media.settings.HMSVideoTrackSettings
 import live.hms.video.media.tracks.*
 import live.hms.video.sdk.models.*
 import live.hms.video.sdk.models.role.*
@@ -22,21 +29,11 @@ object HmsHelper {
               return false
             }
           }
-          "Boolean" -> {
-            if (map.getBoolean(key) == null) {
-              return false
-            }
-          }
           "Array" -> {
             if (map.getArray(key) == null) {
               return false
             }
           }
-          "Int" -> {
-            if (map.getInt(key) == null) {
-              return false
-            }
-          }
           "Map" -> {
             if (map.getMap(key) == null) {
               return false
@@ -163,13 +160,148 @@ object HmsHelper {
     return null
   }
 
+  fun getTrackSettings(data: ReadableMap?): HMSTrackSettings? {
+    if (data == null) {
+      return null
+    }
+
+    var useHardwareEchoCancellation = false
+    val requiredKeysUseHardwareEchoCancellation =
+        this.areAllRequiredKeysAvailable(
+            data,
+            arrayOf(Pair("useHardwareEchoCancellation", "Boolean"))
+        )
+    if (requiredKeysUseHardwareEchoCancellation) {
+      useHardwareEchoCancellation = data.getBoolean("useHardwareEchoCancellation")
+    }
+
+    var video: ReadableMap? = null
+    val requiredKeysVideo = this.areAllRequiredKeysAvailable(data, arrayOf(Pair("video", "Map")))
+    if (requiredKeysVideo) {
+      video = data.getMap("video")
+    }
+
+    var audio: ReadableMap? = null
+    val requiredKeysAudio = this.areAllRequiredKeysAvailable(data, arrayOf(Pair("audio", "Map")))
+    if (requiredKeysAudio) {
+      audio = data.getMap("audio")
+    }
+
+    if (video == null && audio == null && !useHardwareEchoCancellation) {
+      return null
+    }
+
+    val videoSettings = this.getVideoTrackSettings(video)
+    val audioSettings = this.getAudioTrackSettings(audio, useHardwareEchoCancellation)
+    val trackSettingsBuilder = HMSTrackSettings.Builder()
+    return trackSettingsBuilder.audio(audioSettings).video(videoSettings).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)
+    }
+
+    return builder.build()
+  }
+
+  // TODO: find out a way to set settings required to create HMSVideoTrackSettings
+
+  private fun getVideoTrackSettings(data: ReadableMap?): HMSVideoTrackSettings {
+    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)
+      builder.cameraFacing(cameraFacing)
+      if (resolution != null) {
+        builder.resolution(resolution)
+      }
+      builder.maxBitrate(maxBitrate)
+      builder.maxFrameRate(maxFrameRate)
+    }
+    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 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" -> {
+        return HMSVideoTrackSettings.CameraFacing.FRONT
+      }
+      "BACK" -> {
+        return HMSVideoTrackSettings.CameraFacing.BACK
+      }
+    }
+    return HMSVideoTrackSettings.CameraFacing.FRONT
+  }
+
   fun getHms(credentials: ReadableMap, hmsCollection: MutableMap<String, HmsSDK>): HmsSDK? {
     val id = credentials.getString("id")
 
-    if (id != null) {
-      return hmsCollection[id]
+    return if (id != null) {
+      hmsCollection[id]
     } else {
-      return null
+      null
+    }
+  }
+
+  fun getRtmpUrls(rtmpURLsList: ReadableArray?): List<String> {
+    val rtmpURLs = mutableListOf<String>()
+    if (rtmpURLsList !== null) {
+      for (rtmpURL in rtmpURLsList.toArrayList()) {
+        rtmpURLs.add(rtmpURL as String)
+      }
     }
+    return rtmpURLs
   }
 }

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

@@ -23,19 +23,19 @@ class HmsModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMod
   // Example method
   // See https://reactnative.dev/docs/native-modules-android
   @ReactMethod
-  fun build(callback: Promise?) {
+  fun build(data: ReadableMap?, callback: Promise?) {
     val hasItem = hmsCollection.containsKey("12345")
     if (hasItem) {
       val uuid = UUID.randomUUID()
       val randomUUIDString = uuid.toString()
-      val sdkInstance: HmsSDK = HmsSDK(this, randomUUIDString, reactApplicationContext)
+      val sdkInstance = HmsSDK(data, this, randomUUIDString, reactApplicationContext)
 
       hmsCollection[randomUUIDString] = sdkInstance
 
       callback?.resolve(randomUUIDString)
     } else {
       val randomUUIDString = "12345"
-      val sdkInstance: HmsSDK = HmsSDK(this, randomUUIDString, reactApplicationContext)
+      val sdkInstance = HmsSDK(data, this, randomUUIDString, reactApplicationContext)
 
       hmsCollection[randomUUIDString] = sdkInstance
 
@@ -86,45 +86,45 @@ class HmsModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMod
   }
 
   @ReactMethod
-  fun sendBroadcastMessage(data: ReadableMap) {
+  fun sendBroadcastMessage(data: ReadableMap, callback: Promise?) {
     val hms = HmsHelper.getHms(data, hmsCollection)
 
-    hms?.sendBroadcastMessage(data)
+    hms?.sendBroadcastMessage(data, callback)
   }
 
   @ReactMethod
-  fun sendGroupMessage(data: ReadableMap) {
+  fun sendGroupMessage(data: ReadableMap, callback: Promise?) {
     val hms = HmsHelper.getHms(data, hmsCollection)
 
-    hms?.sendGroupMessage(data)
+    hms?.sendGroupMessage(data, callback)
   }
 
   @ReactMethod
-  fun sendDirectMessage(data: ReadableMap) {
+  fun sendDirectMessage(data: ReadableMap, callback: Promise?) {
     val hms = HmsHelper.getHms(data, hmsCollection)
 
-    hms?.sendDirectMessage(data)
+    hms?.sendDirectMessage(data, callback)
   }
 
   @ReactMethod
-  fun changeRole(data: ReadableMap) {
+  fun changeRole(data: ReadableMap, callback: Promise?) {
     val hms = HmsHelper.getHms(data, hmsCollection)
 
-    hms?.changeRole(data)
+    hms?.changeRole(data, callback)
   }
 
   @ReactMethod
-  fun changeTrackState(data: ReadableMap) {
+  fun changeTrackState(data: ReadableMap, callback: Promise?) {
     val hms = HmsHelper.getHms(data, hmsCollection)
 
-    hms?.changeTrackState(data)
+    hms?.changeTrackState(data, callback)
   }
 
   @ReactMethod
-  fun changeTrackStateRoles(data: ReadableMap) {
+  fun changeTrackStateRoles(data: ReadableMap, callback: Promise?) {
     val hms = HmsHelper.getHms(data, hmsCollection)
 
-    hms?.changeTrackStateRoles(data)
+    hms?.changeTrackStateRoles(data, callback)
   }
 
   @ReactMethod
@@ -135,10 +135,10 @@ class HmsModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMod
   }
 
   @ReactMethod
-  fun removePeer(data: ReadableMap) {
+  fun removePeer(data: ReadableMap, callback: Promise?) {
     val hms = HmsHelper.getHms(data, hmsCollection)
 
-    hms?.removePeer(data)
+    hms?.removePeer(data, callback)
   }
 
   @ReactMethod
@@ -163,17 +163,31 @@ class HmsModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMod
   }
 
   @ReactMethod
-  fun endRoom(data: ReadableMap) {
+  fun endRoom(data: ReadableMap, callback: Promise?) {
     val hms = HmsHelper.getHms(data, hmsCollection)
 
-    hms?.endRoom(data)
+    hms?.endRoom(data, callback)
   }
 
   @ReactMethod
-  fun acceptRoleChange(data: ReadableMap) {
+  fun acceptRoleChange(data: ReadableMap, callback: Promise?) {
     val hms = HmsHelper.getHms(data, hmsCollection)
 
-    hms?.acceptRoleChange()
+    hms?.acceptRoleChange(callback)
+  }
+
+  @ReactMethod
+  fun setVolume(data: ReadableMap) {
+    val hms = HmsHelper.getHms(data, hmsCollection)
+
+    hms?.setVolume(data)
+  }
+
+  @ReactMethod
+  fun getVolume(data: ReadableMap, callback: Promise?) {
+    val hms = HmsHelper.getHms(data, hmsCollection)
+
+    hms?.getVolume(data, callback)
   }
 
   @ReactMethod
@@ -183,6 +197,27 @@ class HmsModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaMod
     hms?.muteAllPeersAudio(data)
   }
 
+  @ReactMethod
+  fun changeMetadata(data: ReadableMap, callback: Promise?) {
+    val hms = HmsHelper.getHms(data, hmsCollection)
+
+    hms?.changeMetadata(data, callback)
+  }
+
+  @ReactMethod
+  fun startRTMPOrRecording(data: ReadableMap, callback: Promise?) {
+    val hms = HmsHelper.getHms(data, hmsCollection)
+
+    hms?.startRTMPOrRecording(data, callback)
+  }
+
+  @ReactMethod
+  fun stopRtmpAndRecording(data: ReadableMap, callback: Promise?) {
+    val hms = HmsHelper.getHms(data, hmsCollection)
+
+    hms?.stopRtmpAndRecording(callback)
+  }
+
   fun emitEvent(event: String, data: WritableMap) {
     reactApplicationContext
         .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)