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

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

@@ -31,7 +31,9 @@ object HMSDecoder {
 
       when (hmsRoomUpdateType) {
         HMSRoomUpdate.ROOM_PEER_COUNT_UPDATED -> {
-          room.putInt("peerCount", hmsRoom.peerCount)
+          // When ROOM_PEER_COUNT_UPDATED update type is received then `peerCount` should be a valid value
+          // using `0` as default
+          room.putInt("peerCount", hmsRoom.peerCount ?: 0)
         }
         HMSRoomUpdate.HLS_RECORDING_STATE_UPDATED -> {
           hmsRoom.hlsRecordingState?.let {
@@ -67,6 +69,15 @@ object HMSDecoder {
             )
           }
         }
+        HMSRoomUpdate.ROOM_MUTED -> {
+          print("ROOM_MUTED received")
+        }
+        HMSRoomUpdate.ROOM_UNMUTED -> {
+          print("ROOM_UNMUTED received")
+        }
+        else -> {
+          print("Unknown Room Update Type received")
+        }
       }
     }
     return room
@@ -120,7 +131,13 @@ object HMSDecoder {
 
       room.putArray("peers", this.getAllPeers(hmsRoom.peerList))
 
-      room.putInt("peerCount", hmsRoom.peerCount)
+      hmsRoom.peerCount.let {
+        if (it == null) {
+          room.putNull("peerCount")
+        } else {
+          room.putInt("peerCount", it)
+        }
+      }
     }
     return room
   }
@@ -130,23 +147,24 @@ 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 -> {
+          print("Unknown Peer Update Type received")
+        }
       }
     }
     return peer
@@ -173,6 +191,9 @@ object HMSDecoder {
               peer.putMap("networkQuality", this.getHmsNetworkQuality(it))
             }
           }
+          else -> {
+            print("Unknown Peer Update Type received")
+          }
         }
       }
     }
@@ -582,6 +603,8 @@ object HMSDecoder {
   fun getHMSBrowserRecordingState(data: HMSBrowserRecordingState?): ReadableMap {
     val input = Arguments.createMap()
     if (data !== null) {
+      input.putBoolean("initialising", false)
+
       input.putBoolean("running", data.running)
 
       data.startedAt?.let {

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

@@ -169,7 +169,8 @@ object HMSHelper {
     ) {
       val version = data.getString("version") as String
       val sdkVersion = data.getString("sdkVersion") as String
-      return FrameworkInfo(AgentType.REACT_NATIVE, sdkVersion, version)
+      val isPrebuilt = data.getBoolean("isPrebuilt")
+      return FrameworkInfo(AgentType.REACT_NATIVE, sdkVersion, version, isPrebuilt)
     }
     return null
   }
@@ -255,6 +256,8 @@ object HMSHelper {
     ) {
       val useHardwareEchoCancellation = data.getBoolean("useHardwareEchoCancellation")
       builder.setUseHardwareAcousticEchoCanceler(useHardwareEchoCancellation)
+    } else {
+      builder.setUseHardwareAcousticEchoCanceler(false)
     }
 
     if (areAllRequiredKeysAvailable(data, arrayOf(Pair("initialState", "String")))) {
@@ -425,15 +428,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
@@ -940,6 +926,13 @@ class HMSManager(reactContext: ReactApplicationContext) :
     hms?.removeKeyChangeListener(data, promise)
   }
 
+  @ReactMethod
+  fun getRoomLayout(data: ReadableMap, promise: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.getRoomLayout(data, promise)
+  }
+
   fun emitEvent(event: String, data: WritableMap) {
     reactApplicationContext
       .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)