@100mslive/react-native-hms 1.6.2 → 1.7.0

package/android/build.gradle

@@ -3,7 +3,9 @@ import groovy.json.JsonSlurper
 def sdkVersions = new JsonSlurper().parse file("../sdk-versions.json")
 
 buildscript {
-    ext.kotlin_version = '1.5.30-RC'
+    ext.kotlin_version = "1.6.0"
+    ext.hms_coroutines_version = "1.6.0"
+    ext.ktx_version = "1.6.0"
     if (project == rootProject) {
         repositories {
             google()
@@ -31,10 +33,10 @@ def safeExtGet(prop, fallback) {
 }
 
 android {
-    compileSdkVersion safeExtGet('Hmssdk_compileSdkVersion', 30)
+    compileSdkVersion safeExtGet('Hmssdk_compileSdkVersion', 31)
     defaultConfig {
         minSdkVersion safeExtGet('Hmssdk_minSdkVersion', 21)
-        targetSdkVersion safeExtGet('Hmssdk_targetSdkVersion', 30)
+        targetSdkVersion safeExtGet('Hmssdk_targetSdkVersion', 31)
         versionCode 1
         versionName "1.0"
     }
@@ -68,10 +70,16 @@ repositories {
 dependencies {
     //noinspection GradleDynamicVersion
     implementation "com.facebook.react:react-native:+"
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"  // From node_modules
+    implementation "com.google.code.gson:gson:2.9.0"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation "androidx.core:core-ktx:$ktx_version"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$hms_coroutines_version"
+    implementation "androidx.constraintlayout:constraintlayout:2.1.3"
+    implementation "androidx.appcompat:appcompat:1.3.1"
+
+    // 100ms
     implementation "live.100ms:android-sdk:${sdkVersions["android"]}"
     implementation "live.100ms:video-view:${sdkVersions["android"]}"
-    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.0'
-    implementation 'androidx.constraintlayout:constraintlayout:2.1.3'
-    implementation 'androidx.appcompat:appcompat:1.3.1'
-}
+    implementation "live.100ms:hls-player:${sdkVersions["android"]}"
+    implementation "live.100ms:hls-player-stats:${sdkVersions["android"]}"
+}

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

@@ -130,23 +130,22 @@ object HMSDecoder {
     if (hmsPeer != null) {
       peer.putString(peerUpdateType.ordinal.toString(), hmsPeer.peerID)
 
-      if (peerUpdateType !== null) {
-        when (peerUpdateType) {
-          HMSPeerUpdate.NAME_CHANGED -> {
-            peer.putString("name", hmsPeer.name)
-          }
-          HMSPeerUpdate.METADATA_CHANGED -> {
-            peer.putString("metadata", hmsPeer.metadata)
-          }
-          HMSPeerUpdate.ROLE_CHANGED -> {
-            peer.putMap("role", this.getHmsRole(hmsPeer.hmsRole))
-          }
-          HMSPeerUpdate.NETWORK_QUALITY_UPDATED -> {
-            hmsPeer.networkQuality?.let {
-              peer.putMap("networkQuality", this.getHmsNetworkQuality(it))
-            }
+      when (peerUpdateType) {
+        HMSPeerUpdate.NAME_CHANGED -> {
+          peer.putString("name", hmsPeer.name)
+        }
+        HMSPeerUpdate.METADATA_CHANGED -> {
+          peer.putString("metadata", hmsPeer.metadata)
+        }
+        HMSPeerUpdate.ROLE_CHANGED -> {
+          peer.putMap("role", this.getHmsRole(hmsPeer.hmsRole))
+        }
+        HMSPeerUpdate.NETWORK_QUALITY_UPDATED -> {
+          hmsPeer.networkQuality?.let {
+            peer.putMap("networkQuality", this.getHmsNetworkQuality(it))
           }
         }
+        else -> {}
       }
     }
     return peer

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

@@ -0,0 +1,248 @@
+package com.reactnativehmssdk
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.view.LayoutInflater
+import android.widget.FrameLayout
+import androidx.media3.ui.PlayerView
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import live.hms.hls_player.*
+import live.hms.stats.PlayerStatsListener
+import live.hms.stats.model.PlayerStatsModel
+import live.hms.video.error.HMSException
+import live.hms.video.sdk.HMSSDK
+import java.util.concurrent.TimeUnit
+
+@SuppressLint("ViewConstructor")
+class HMSHLSPlayer(context: ReactContext) : FrameLayout(context) {
+  private var playerView: PlayerView? = null // Exoplayer View
+  private var hmsHlsPlayer: HmsHlsPlayer? = null // 100ms HLS Player
+  private var hmssdkInstance: HMSSDK? = null
+  private var statsMonitorAttached = false
+  private val hmsHlsPlaybackEventsObject = object : HmsHlsPlaybackEvents {
+    override fun onCue(cue: HmsHlsCue) {
+      super.onCue(cue)
+
+      val data = Arguments.createMap()
+      cue.endDate?.let { data.putString("endDate", it.time.toString()) }
+      cue.id?.let { data.putString("id", it) }
+      cue.payloadval?.let { data.putString("payloadval", it) }
+      data.putString("startDate", cue.startDate.time.toString())
+
+      sendHLSPlaybackEventToJS(HMSHLSPlayerConstants.ON_PLAYBACK_CUE_EVENT, data)
+    }
+
+    override fun onPlaybackFailure(error: HmsHlsException) {
+      super.onPlaybackFailure(error)
+
+      val data = Arguments.createMap()
+
+      // error
+      val errorData = Arguments.createMap()
+      errorData.putInt("errorCode", error.error.errorCode)
+      errorData.putString("errorCodeName", error.error.errorCodeName)
+      error.error.message?.let {
+        errorData.putString("message", it)
+      }
+
+      data.putMap("error", errorData)
+
+      sendHLSPlaybackEventToJS(HMSHLSPlayerConstants.ON_PLAYBACK_FAILURE_EVENT, data)
+    }
+
+    override fun onPlaybackStateChanged(state: HmsHlsPlaybackState) {
+      super.onPlaybackStateChanged(state)
+
+      val data = Arguments.createMap()
+      data.putString("state", state.name)
+      sendHLSPlaybackEventToJS(HMSHLSPlayerConstants.ON_PLAYBACK_STATE_CHANGE_EVENT, data)
+    }
+  }
+  private val hmsHlsPlayerStatsListenerObject = object : PlayerStatsListener {
+    override fun onError(error: HMSException) {
+      val data = Arguments.createMap()
+
+      data.putString("action", error.action)
+      data.putInt("code", error.code)
+      data.putString("description", error.description)
+      data.putBoolean("isTerminal", error.isTerminal)
+      data.putString("message", error.message)
+      data.putString("name", error.name)
+
+      sendHLSStatsEventToJS(HMSHLSPlayerConstants.ON_STATS_EVENT_ERROR, data)
+    }
+
+    override fun onEventUpdate(playerStatsModel: PlayerStatsModel) {
+      val data = Arguments.createMap()
+
+      // bandwidth
+      data.putInt("bandWidthEstimate", playerStatsModel.bandwidth.bandWidthEstimate.toInt())
+      data.putInt("totalBytesLoaded", playerStatsModel.bandwidth.totalBytesLoaded.toInt())
+
+      // bufferedDuration
+      data.putInt("bufferedDuration", playerStatsModel.bufferedDuration.toInt())
+
+      // distanceFromLive
+      data.putInt("distanceFromLive", playerStatsModel.distanceFromLive.toInt())
+
+      // frameInfo
+      data.putInt("droppedFrameCount", playerStatsModel.frameInfo.droppedFrameCount)
+
+      // videoInfo
+      data.putInt("averageBitrate", playerStatsModel.videoInfo.averageBitrate)
+      data.putInt("videoHeight", playerStatsModel.videoInfo.videoHeight)
+      data.putInt("videoWidth", playerStatsModel.videoInfo.videoWidth)
+
+      sendHLSStatsEventToJS(HMSHLSPlayerConstants.ON_STATS_EVENT_UPDATE, data)
+    }
+  }
+
+  init {
+    val inflater = getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE) as LayoutInflater
+
+    // Inflating player_view xml
+    val view = inflater.inflate(R.layout.player_view, this)
+
+    // getting Exoplayer View from above xml
+    val localPlayerView = view.findViewById<PlayerView>(R.id.hls_view)
+    playerView = localPlayerView
+
+    val hmssdkCollection = context.getNativeModule(HMSManager::class.java)?.getHmsInstance()
+    hmssdkInstance = hmssdkCollection?.get("12345")?.hmsSDK
+
+    // creating 100ms HLS Player
+    val localHmsHlsPlayer = HmsHlsPlayer(context, hmssdkInstance)
+    hmsHlsPlayer = localHmsHlsPlayer
+
+    // Attaching HLS Player Playback State Events listener
+    localHmsHlsPlayer.addPlayerEventListener(hmsHlsPlaybackEventsObject)
+
+    // setting 100ms HLS Player on Exoplayer
+    localPlayerView.player = localHmsHlsPlayer.getNativePlayer()
+  }
+
+  fun cleanup() {
+    hmsHlsPlayer?.stop()
+    hmsHlsPlayer?.addPlayerEventListener(null)
+    hmsHlsPlayer?.setStatsMonitor(null)
+  }
+
+  fun play(url: String?) {
+    if (url !== null && url.isNotEmpty()) {
+      hmsHlsPlayer?.play(url)
+      return
+    }
+
+    val hlsStreamingState = this.hmssdkInstance?.getRoom()?.hlsStreamingState
+
+    val defaultURL: String? = hlsStreamingState?.let {
+      if (it.running) {
+        it.variants?.get(0)?.hlsStreamUrl
+      } else {
+        null
+      }
+    }
+
+    if (defaultURL !== null) {
+      hmsHlsPlayer?.play(defaultURL)
+    }
+  }
+
+  fun stop() {
+    hmsHlsPlayer?.stop()
+  }
+
+  fun pause() {
+    hmsHlsPlayer?.pause()
+  }
+
+  fun resume() {
+    hmsHlsPlayer?.resume()
+  }
+
+  fun seekForward(seconds: Double) {
+    hmsHlsPlayer?.seekForward(seconds.toLong(), TimeUnit.SECONDS)
+  }
+
+  fun seekBackward(seconds: Double) {
+    hmsHlsPlayer?.seekBackward(seconds.toLong(), TimeUnit.SECONDS)
+  }
+
+  fun seekToLivePosition() {
+    hmsHlsPlayer?.seekToLivePosition()
+  }
+
+  fun setVolume(level: Int) {
+    hmsHlsPlayer?.volume = level
+  }
+
+  fun enableStats(enable: Boolean) {
+    if (enable) {
+      attachStatsMonitor()
+    } else {
+      removeStatsMonitor()
+    }
+  }
+
+  fun enableControls(show: Boolean) {
+    playerView?.let {
+      if (show) {
+        it.useController = true
+        it.showController()
+      } else {
+        it.hideController()
+        it.useController = false
+      }
+    }
+  }
+
+  private fun attachStatsMonitor() {
+    if (statsMonitorAttached) return
+
+    hmsHlsPlayer?.let {
+      it.setStatsMonitor(hmsHlsPlayerStatsListenerObject)
+      statsMonitorAttached = true
+    }
+  }
+
+  private fun removeStatsMonitor() {
+    if (!statsMonitorAttached) return
+
+    hmsHlsPlayer?.setStatsMonitor(null)
+    statsMonitorAttached = false
+  }
+
+  private fun sendHLSPlaybackEventToJS(eventName: String, data: WritableMap) {
+    val event: WritableMap = Arguments.createMap()
+    event.putString("event", eventName)
+    event.putMap("data", data)
+
+    val reactContext = context as ReactContext
+    reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, HMSHLSPlayerConstants.HMS_HLS_PLAYBACK_EVENT, event)
+  }
+
+  private fun sendHLSStatsEventToJS(eventName: String, data: WritableMap) {
+    val event: WritableMap = Arguments.createMap()
+    event.putString("event", eventName)
+    event.putMap("data", data)
+
+    val reactContext = context as ReactContext
+    reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, HMSHLSPlayerConstants.HMS_HLS_STATS_EVENT, event)
+  }
+}
+
+object HMSHLSPlayerConstants {
+  // HLS Playback Events
+  const val HMS_HLS_PLAYBACK_EVENT = "hmsHlsPlaybackEvent"
+  const val ON_PLAYBACK_CUE_EVENT = "ON_PLAYBACK_CUE_EVENT"
+  const val ON_PLAYBACK_FAILURE_EVENT = "ON_PLAYBACK_FAILURE_EVENT"
+  const val ON_PLAYBACK_STATE_CHANGE_EVENT = "ON_PLAYBACK_STATE_CHANGE_EVENT"
+
+  // HLS Playback Stats Events
+  const val HMS_HLS_STATS_EVENT = "hmsHlsStatsEvent"
+  const val ON_STATS_EVENT_UPDATE = "ON_STATS_EVENT_UPDATE"
+  const val ON_STATS_EVENT_ERROR = "ON_STATS_EVENT_ERROR"
+}

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

@@ -0,0 +1,101 @@
+package com.reactnativehmssdk
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+class HMSHLSPlayerManager : SimpleViewManager<HMSHLSPlayer>() {
+  private var reactContext: ThemedReactContext? = null
+
+  override fun getName(): String {
+    return REACT_CLASS
+  }
+
+  override fun createViewInstance(reactContext: ThemedReactContext): HMSHLSPlayer {
+    this.reactContext = reactContext
+    return HMSHLSPlayer(reactContext)
+  }
+
+  override fun onDropViewInstance(view: HMSHLSPlayer) {
+    super.onDropViewInstance(view)
+    view.cleanup()
+  }
+
+  override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any>? {
+    super.getExportedCustomDirectEventTypeConstants()
+
+    return MapBuilder.of(
+      HMSHLSPlayerConstants.HMS_HLS_PLAYBACK_EVENT,
+      MapBuilder.of("registrationName", "onHmsHlsPlaybackEvent"),
+      HMSHLSPlayerConstants.HMS_HLS_STATS_EVENT,
+      MapBuilder.of("registrationName", "onHmsHlsStatsEvent"),
+    )
+  }
+
+  override fun receiveCommand(root: HMSHLSPlayer, commandId: Int, args: ReadableArray?) {
+    super.receiveCommand(root, commandId, args)
+
+    when (commandId) {
+      10 -> root.play(args?.getString(0))
+      20 -> root.stop()
+      30 -> root.pause()
+      40 -> root.resume()
+      50 -> root.seekToLivePosition()
+      60 -> {
+        args.let {
+          if (it != null) {
+            root.seekForward(it.getDouble(0))
+          }
+        }
+      }
+      70 -> {
+        args.let {
+          if (it != null) {
+            root.seekBackward(it.getDouble(0))
+          }
+        }
+      }
+      80 -> {
+        args.let {
+          if (it != null) {
+            root.setVolume(it.getInt(0))
+          }
+        }
+      }
+    }
+  }
+
+  override fun getCommandsMap(): MutableMap<String, Int>? {
+    return MapBuilder.builder<String, Int>()
+      .put("play", 10)
+      .put("stop", 20)
+      .put("pause", 30)
+      .put("resume", 40)
+      .put("seekToLivePosition", 50)
+      .put("seekForward", 60)
+      .put("seekBackward", 70)
+      .put("setVolume", 80)
+      .build()
+  }
+
+  @ReactProp(name = "url")
+  fun setStreamURL(view: HMSHLSPlayer, data: String?) {
+    view.play(data)
+  }
+
+  @ReactProp(name = "enableStats", defaultBoolean = false)
+  fun setEnableStats(view: HMSHLSPlayer, data: Boolean) {
+    view.enableStats(data)
+  }
+
+  @ReactProp(name = "enableControls", defaultBoolean = false)
+  fun setEnableControls(view: HMSHLSPlayer, data: Boolean) {
+    view.enableControls(data)
+  }
+
+  companion object {
+    const val REACT_CLASS = "HMSHLSPlayer"
+  }
+}

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

@@ -255,6 +255,8 @@ object HMSHelper {
     ) {
       val useHardwareEchoCancellation = data.getBoolean("useHardwareEchoCancellation")
       builder.setUseHardwareAcousticEchoCanceler(useHardwareEchoCancellation)
+    } else {
+      builder.setUseHardwareAcousticEchoCanceler(false)
     }
 
     if (areAllRequiredKeysAvailable(data, arrayOf(Pair("initialState", "String")))) {
@@ -425,15 +427,18 @@ object HMSHelper {
 
   fun getRtmpConfig(data: ReadableMap): HMSRecordingConfig? {
     val record = data.getBoolean("record")
-    var meetingURL = ""
+    var meetingURL: String? = null
     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 (meetingURLValid.isNotEmpty()) {
+        if (URLUtil.isValidUrl(meetingURLValid)) {
+          meetingURL = meetingURLValid
+        } else {
+          return null
+        }
       }
     }
 

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

@@ -419,20 +419,6 @@ 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)
-  }
-
   @ReactMethod(isBlockingSynchronousMethod = true)
   fun getPeerProperty(data: ReadableMap): WritableMap? {
     val hms = HMSHelper.getHms(data, hmsCollection) ?: return null