@100mslive/react-native-hms 0.9.7 → 0.9.91

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

@@ -1,6 +1,7 @@
 package com.reactnativehmssdk
 
 import com.facebook.react.bridge.*
+import live.hms.video.connection.stats.*
 import live.hms.video.connection.stats.quality.HMSNetworkQuality
 import live.hms.video.error.HMSException
 import live.hms.video.media.settings.HMSAudioTrackSettings
@@ -125,10 +126,10 @@ object HMSDecoder {
       permissions.putBoolean("endRoom", hmsPermissions.endRoom)
       permissions.putBoolean("removeOthers", hmsPermissions.removeOthers)
       permissions.putBoolean("mute", hmsPermissions.mute)
-      permissions.putBoolean("changeRoleForce", hmsPermissions.changeRoleForce)
+      permissions.putBoolean("browserRecording", hmsPermissions.browserRecording)
       permissions.putBoolean("unmute", hmsPermissions.unmute)
-      permissions.putBoolean("recording", hmsPermissions.recording)
-      permissions.putBoolean("streaming", hmsPermissions.streaming)
+      permissions.putBoolean("hlsStreaming", hmsPermissions.hlsStreaming)
+      permissions.putBoolean("rtmpStreaming", hmsPermissions.rtmpStreaming)
       permissions.putBoolean("changeRole", hmsPermissions.changeRole)
     }
     return permissions
@@ -197,7 +198,7 @@ object HMSDecoder {
     return peer
   }
 
-  private fun getHmsLocalAudioTrack(track: HMSLocalAudioTrack?): WritableMap {
+  fun getHmsLocalAudioTrack(track: HMSLocalAudioTrack?): WritableMap {
     val hmsTrack: WritableMap = Arguments.createMap()
     if (track != null) {
       hmsTrack.putDouble("volume", track.volume)
@@ -211,7 +212,7 @@ object HMSDecoder {
     return hmsTrack
   }
 
-  private fun getHmsLocalVideoTrack(track: HMSLocalVideoTrack?): WritableMap {
+  fun getHmsLocalVideoTrack(track: HMSLocalVideoTrack?): WritableMap {
     val hmsTrack: WritableMap = Arguments.createMap()
     if (track != null) {
       hmsTrack.putBoolean("isDegraded", track.isDegraded)
@@ -263,7 +264,7 @@ object HMSDecoder {
     return resolution
   }
 
-  fun getHmsRemotePeers(remotePeers: Array<HMSRemotePeer>?): WritableArray {
+  fun getHmsRemotePeers(remotePeers: List<HMSRemotePeer>?): WritableArray {
     val peers: WritableArray = Arguments.createArray()
     if (remotePeers != null) {
       for (peer in remotePeers) {
@@ -292,7 +293,7 @@ object HMSDecoder {
     return peer
   }
 
-  private fun getHmsRemoteAudioTrack(track: HMSRemoteAudioTrack?): WritableMap {
+  fun getHmsRemoteAudioTrack(track: HMSRemoteAudioTrack?): WritableMap {
     val hmsTrack: WritableMap = Arguments.createMap()
     if (track != null) {
       hmsTrack.putBoolean("isPlaybackAllowed", track.isPlaybackAllowed)
@@ -305,7 +306,7 @@ object HMSDecoder {
     return hmsTrack
   }
 
-  private fun getHmsRemoteVideoTrack(track: HMSRemoteVideoTrack?): WritableMap {
+  fun getHmsRemoteVideoTrack(track: HMSRemoteVideoTrack?): WritableMap {
     val hmsTrack: WritableMap = Arguments.createMap()
     if (track != null) {
       hmsTrack.putBoolean("isDegraded", track.isDegraded)
@@ -360,11 +361,11 @@ object HMSDecoder {
     if (error !== null) {
       val decodedError: WritableMap = Arguments.createMap()
       decodedError.putInt("code", error.code)
-      decodedError.putString("localizedDescription", error.localizedMessage)
       decodedError.putString("description", error.description)
       decodedError.putString("message", error.message)
       decodedError.putString("name", error.name)
       decodedError.putString("action", error.action)
+      decodedError.putBoolean("isTerminal", error.isTerminal)
       return decodedError
     }
     return null
@@ -485,7 +486,7 @@ object HMSDecoder {
     return subscribeDegradationParams
   }
 
-  private fun getAllPeers(peers: Array<HMSPeer>?): WritableArray {
+  private fun getAllPeers(peers: List<HMSPeer>?): WritableArray {
     val decodedPeers: WritableArray = Arguments.createArray()
     if (peers != null) {
       for (peer in peers) {
@@ -524,4 +525,72 @@ object HMSDecoder {
     }
     return hmsNetworkQuality
   }
+
+  fun getHMSRTCStats(hmsRtcStats: HMSRTCStats?): WritableMap {
+    val rtcStats: WritableMap = Arguments.createMap()
+    if (hmsRtcStats != null) {
+      rtcStats.putDouble("bitrateReceived", hmsRtcStats.bitrateReceived)
+      rtcStats.putDouble("bitrateSent", hmsRtcStats.bitrateSent)
+      rtcStats.putString("bytesSent", hmsRtcStats.bytesSent.toString())
+      rtcStats.putString("bytesReceived", hmsRtcStats.bytesReceived.toString())
+      rtcStats.putString("packetsLost", hmsRtcStats.packetsLost.toString())
+      rtcStats.putString("packetsReceived", hmsRtcStats.packetsReceived.toString())
+      rtcStats.putDouble("roundTripTime", hmsRtcStats.roundTripTime)
+    }
+    return rtcStats
+  }
+
+  fun getLocalAudioStats(hmsLocalAudioStats: HMSLocalAudioStats?): WritableMap {
+    val localAudioStats: WritableMap = Arguments.createMap()
+    if (hmsLocalAudioStats != null) {
+      hmsLocalAudioStats.bitrate?.let { localAudioStats.putDouble("bitrate", it) }
+      localAudioStats.putString("bytesSent", hmsLocalAudioStats.bytesSent.toString())
+      hmsLocalAudioStats.roundTripTime?.let { localAudioStats.putDouble("roundTripTime", it) }
+    }
+    return localAudioStats
+  }
+
+  fun getLocalVideoStats(hmsLocalVideoStats: HMSLocalVideoStats?): WritableMap {
+    val localVideoStats: WritableMap = Arguments.createMap()
+    if (hmsLocalVideoStats != null) {
+      localVideoStats.putString("bytesSent", hmsLocalVideoStats.bytesSent.toString())
+      localVideoStats.putMap(
+          "resolution",
+          hmsLocalVideoStats.resolution?.let { this.getHmsVideoTrackResolution(it) }
+      )
+      hmsLocalVideoStats.bitrate?.let { localVideoStats.putDouble("bitrate", it) }
+      hmsLocalVideoStats.roundTripTime?.let { localVideoStats.putDouble("roundTripTime", it) }
+      hmsLocalVideoStats.frameRate?.let { localVideoStats.putDouble("frameRate", it) }
+    }
+    return localVideoStats
+  }
+
+  fun getRemoteAudioStats(hmsRemoteAudioStats: HMSRemoteAudioStats?): WritableMap {
+    val remoteAudioStats: WritableMap = Arguments.createMap()
+    if (hmsRemoteAudioStats != null) {
+      hmsRemoteAudioStats.bitrate?.let { remoteAudioStats.putDouble("bitrate", it) }
+      remoteAudioStats.putString("bytesReceived", hmsRemoteAudioStats.bytesReceived.toString())
+      hmsRemoteAudioStats.jitter?.let { remoteAudioStats.putDouble("jitter", it) }
+      hmsRemoteAudioStats.packetsLost?.let { remoteAudioStats.putInt("packetsLost", it) }
+      remoteAudioStats.putString("packetsReceived", hmsRemoteAudioStats.packetsReceived.toString())
+    }
+    return remoteAudioStats
+  }
+
+  fun getRemoteVideoStats(hmsRemoteVideoStats: HMSRemoteVideoStats?): WritableMap {
+    val remoteVideoStats: WritableMap = Arguments.createMap()
+    if (hmsRemoteVideoStats != null) {
+      remoteVideoStats.putString("bytesReceived", hmsRemoteVideoStats.bytesReceived.toString())
+      remoteVideoStats.putString("packetsReceived", hmsRemoteVideoStats.packetsReceived.toString())
+      hmsRemoteVideoStats.bitrate?.let { remoteVideoStats.putDouble("bitrate", it) }
+      remoteVideoStats.putMap(
+          "resolution",
+          hmsRemoteVideoStats.resolution?.let { this.getHmsVideoTrackResolution(it) }
+      )
+      hmsRemoteVideoStats.frameRate?.let { remoteVideoStats.putDouble("frameRate", it) }
+      hmsRemoteVideoStats.jitter?.let { remoteVideoStats.putDouble("jitter", it) }
+      hmsRemoteVideoStats.packetsLost?.let { remoteVideoStats.putInt("packetsLost", it) }
+    }
+    return remoteVideoStats
+  }
 }

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

@@ -7,6 +7,7 @@ import android.os.Handler
 import android.util.Base64
 import android.util.Log
 import android.view.PixelCopy
+import android.webkit.URLUtil
 import androidx.annotation.RequiresApi
 import com.facebook.react.bridge.*
 import com.facebook.react.bridge.ReadableArray
@@ -14,17 +15,16 @@ 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.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.settings.*
 import live.hms.video.media.tracks.HMSRemoteAudioTrack
 import live.hms.video.media.tracks.HMSRemoteVideoTrack
 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.utils.HmsUtilities
 import org.webrtc.SurfaceViewRenderer
@@ -250,6 +250,21 @@ object HMSHelper {
     }
   }
 
+  fun getAudioMixingMode(audioMixingMode: String?): AudioMixingMode {
+    when (audioMixingMode) {
+      "TALK_ONLY" -> {
+        return AudioMixingMode.TALK_ONLY
+      }
+      "MUSIC_ONLY" -> {
+        return AudioMixingMode.MUSIC_ONLY
+      }
+      "TALK_AND_MUSIC" -> {
+        return AudioMixingMode.TALK_AND_MUSIC
+      }
+    }
+    return AudioMixingMode.TALK_AND_MUSIC
+  }
+
   private fun getAudioCodec(codecString: String?): HMSAudioCodec {
     when (codecString) {
       "opus" -> {
@@ -296,7 +311,7 @@ object HMSHelper {
     }
   }
 
-  fun getRtmpUrls(rtmpURLsList: ReadableArray?): List<String> {
+  private fun getRtmpUrls(rtmpURLsList: ReadableArray?): List<String> {
     val rtmpURLs = mutableListOf<String>()
     if (rtmpURLsList !== null) {
       for (rtmpURL in rtmpURLsList.toArrayList()) {
@@ -306,7 +321,25 @@ object HMSHelper {
     return rtmpURLs
   }
 
-  fun getHMSHLSMeetingURLVariants(
+  fun getHLSConfig(data: ReadableMap?): HMSHLSConfig? {
+    if (data === null) {
+      return data
+    }
+    var hlsMeetingUrlVariant: List<HMSHLSMeetingURLVariant>? = null
+    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("meetingURLVariants", "Array")))) {
+      val meetingURLVariants =
+          data.getArray("meetingURLVariants")?.toArrayList() as? ArrayList<HashMap<String, String>>
+      hlsMeetingUrlVariant = getHMSHLSMeetingURLVariants(meetingURLVariants)
+    }
+    var hlsRecordingConfig: HMSHlsRecordingConfig? = null
+    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("hlsRecordingConfig", "Map")))) {
+      val recordingConfig = data.getMap("hlsRecordingConfig")
+      hlsRecordingConfig = getHlsRecordingConfig(recordingConfig)
+    }
+    return HMSHLSConfig(hlsMeetingUrlVariant, hlsRecordingConfig)
+  }
+
+  private fun getHMSHLSMeetingURLVariants(
       hmsMeetingURLVariants: ArrayList<HashMap<String, String>>?
   ): List<HMSHLSMeetingURLVariant> {
     val meetingURLVariants = mutableListOf<HMSHLSMeetingURLVariant>()
@@ -319,28 +352,25 @@ object HMSHelper {
     return meetingURLVariants
   }
 
-  fun getHlsRecordingConfig(data: ReadableMap): HMSHlsRecordingConfig? {
-    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("hlsRecordingConfig", "Map")))) {
-      val hmsHlsRecordingConfig = data.getMap("hlsRecordingConfig")
-      if (hmsHlsRecordingConfig != null) {
-        var singleFilePerLayer = false
-        var videoOnDemand = false
-        if (areAllRequiredKeysAvailable(
-                hmsHlsRecordingConfig,
-                arrayOf(Pair("singleFilePerLayer", "Boolean"))
-            )
-        ) {
-          singleFilePerLayer = hmsHlsRecordingConfig.getBoolean("singleFilePerLayer")
-        }
-        if (areAllRequiredKeysAvailable(
-                hmsHlsRecordingConfig,
-                arrayOf(Pair("videoOnDemand", "Boolean"))
-            )
-        ) {
-          videoOnDemand = hmsHlsRecordingConfig.getBoolean("videoOnDemand")
-        }
-        return HMSHlsRecordingConfig(singleFilePerLayer, videoOnDemand)
+  private fun getHlsRecordingConfig(hmsHlsRecordingConfig: ReadableMap?): HMSHlsRecordingConfig? {
+    if (hmsHlsRecordingConfig !== null) {
+      var singleFilePerLayer = false
+      var videoOnDemand = false
+      if (areAllRequiredKeysAvailable(
+              hmsHlsRecordingConfig,
+              arrayOf(Pair("singleFilePerLayer", "Boolean"))
+          )
+      ) {
+        singleFilePerLayer = hmsHlsRecordingConfig.getBoolean("singleFilePerLayer")
       }
+      if (areAllRequiredKeysAvailable(
+              hmsHlsRecordingConfig,
+              arrayOf(Pair("videoOnDemand", "Boolean"))
+          )
+      ) {
+        videoOnDemand = hmsHlsRecordingConfig.getBoolean("videoOnDemand")
+      }
+      return HMSHlsRecordingConfig(singleFilePerLayer, videoOnDemand)
     }
     return null
   }
@@ -357,6 +387,38 @@ object HMSHelper {
     return meetingURLVariant
   }
 
+  private fun getResolution(data: ReadableMap): HMSRtmpVideoResolution {
+    val height = data.getInt("height")
+    val width = data.getInt("width")
+    return HMSRtmpVideoResolution(width, height)
+  }
+
+  fun getRtmpConfig(data: ReadableMap): HMSRecordingConfig? {
+    val record = data.getBoolean("record")
+    var meetingURL = ""
+    var rtmpURLs = listOf<String>()
+    var resolution: HMSRtmpVideoResolution? = null
+    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("meetingURL", "String")))) {
+      val meetingURLValid = data.getString("meetingURL") as String
+      if (URLUtil.isValidUrl(meetingURLValid)) {
+        meetingURL = meetingURLValid
+      } else {
+        return null
+      }
+    }
+
+    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("rtmpURLs", "Array")))) {
+      val rtmpURLsValid = data.getArray("rtmpURLs")
+      rtmpURLs = this.getRtmpUrls(rtmpURLsValid)
+    }
+
+    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("resolution", "Map")))) {
+      val resolutionValid = data.getMap("resolution")
+      resolution = resolutionValid?.let { this.getResolution(it) }
+    }
+    return HMSRecordingConfig(meetingURL, rtmpURLs, record, resolution)
+  }
+
   fun getHmsConfig(credentials: ReadableMap): HMSConfig {
     var config =
         HMSConfig(
@@ -512,4 +574,45 @@ object HMSHelper {
       reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, "captureFrame", output)
     }
   }
+
+  fun getAudioDevicesList(audioDevicesList: List<HMSAudioManager.AudioDevice>?): ReadableArray {
+    val hmsAudioDevicesList = Arguments.createArray()
+    if (audioDevicesList != null) {
+      for (audioDevice in audioDevicesList) {
+        hmsAudioDevicesList.pushString(audioDevice.name)
+      }
+    }
+    return hmsAudioDevicesList
+  }
+
+  fun getAudioDevicesSet(audioDevicesSet: Set<HMSAudioManager.AudioDevice>?): ReadableArray {
+    val hmsAudioDevicesSet = Arguments.createArray()
+    if (audioDevicesSet != null) {
+      for (audioDevice in audioDevicesSet) {
+        hmsAudioDevicesSet.pushString(audioDevice.name)
+      }
+    }
+    return hmsAudioDevicesSet
+  }
+
+  fun getAudioDevice(audioDevice: String?): HMSAudioManager.AudioDevice {
+    when (audioDevice) {
+      "AUTOMATIC" -> {
+        return HMSAudioManager.AudioDevice.AUTOMATIC
+      }
+      "BLUETOOTH" -> {
+        return HMSAudioManager.AudioDevice.BLUETOOTH
+      }
+      "EARPIECE" -> {
+        return HMSAudioManager.AudioDevice.EARPIECE
+      }
+      "SPEAKER_PHONE" -> {
+        return HMSAudioManager.AudioDevice.SPEAKER_PHONE
+      }
+      "WIRED_HEADSET" -> {
+        return HMSAudioManager.AudioDevice.WIRED_HEADSET
+      }
+    }
+    return HMSAudioManager.AudioDevice.SPEAKER_PHONE
+  }
 }

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

@@ -202,10 +202,10 @@ class HMSManager(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun remoteMuteAllAudio(data: ReadableMap) {
+  fun remoteMuteAllAudio(data: ReadableMap, callback: Promise?) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
-    hms?.remoteMuteAllAudio()
+    hms?.remoteMuteAllAudio(callback)
   }
 
   @ReactMethod
@@ -238,6 +238,43 @@ class HMSManager(reactContext: ReactApplicationContext) :
     hms?.stopScreenshare(callback)
   }
 
+  @ReactMethod
+  fun startAudioshare(data: ReadableMap, callback: Promise?) {
+    currentActivity?.application?.registerActivityLifecycleCallbacks(this)
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.startAudioshare(data, callback)
+  }
+
+  @ReactMethod
+  fun isAudioShared(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.isAudioShared(callback)
+  }
+
+  @ReactMethod
+  fun stopAudioshare(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    currentActivity?.application?.unregisterActivityLifecycleCallbacks(this)
+    hms?.stopAudioshare(callback)
+  }
+
+  @ReactMethod
+  fun getAudioMixingMode(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    callback?.resolve(hms?.getAudioMixingMode()?.name)
+  }
+
+  @ReactMethod
+  fun setAudioMixingMode(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.setAudioMixingMode(data, callback)
+  }
+
   @ReactMethod
   fun startRTMPOrRecording(data: ReadableMap, callback: Promise?) {
     val hms = HMSHelper.getHms(data, hmsCollection)
@@ -290,6 +327,55 @@ class HMSManager(reactContext: ReactApplicationContext) :
     callback?.resolve(result)
   }
 
+  @ReactMethod
+  fun enableRTCStats(data: ReadableMap) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.enableRTCStats()
+  }
+
+  @ReactMethod
+  fun disableRTCStats(data: ReadableMap) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.disableRTCStats()
+  }
+
+  @ReactMethod
+  fun getAudioDevicesList(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.getAudioDevicesList(callback)
+  }
+
+  @ReactMethod
+  fun getAudioOutputRouteType(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.getAudioOutputRouteType(callback)
+  }
+
+  @ReactMethod
+  fun switchAudioOutput(data: ReadableMap) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.switchAudioOutput(data)
+  }
+
+  @ReactMethod
+  fun setAudioMode(data: ReadableMap) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.setAudioMode(data)
+  }
+
+  @ReactMethod
+  fun setAudioDeviceChangeListener(data: ReadableMap) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.setAudioDeviceChangeListener()
+  }
+
   fun emitEvent(event: String, data: WritableMap) {
     reactApplicationContext
         .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)