Release 1.7.0: Develop to main

.trunk/trunk.yaml

@@ -1,23 +1,23 @@
 version: 0.1
 cli:
-  version: 1.9.1
+  version: 1.11.0
 plugins:
   sources:
     - id: trunk
-      ref: v0.0.17
+      ref: v0.0.18
       uri: https://github.com/trunk-io/plugins
 lint:
   enabled:
     - oxipng@8.0.0
-    - yamllint@1.31.0
+    - yamllint@1.32.0
     - ktlint@0.49.1
     - svgo@3.0.2
     - prettier@2.8.8
     - shfmt@3.5.0
-    - gitleaks@8.16.3
+    - gitleaks@8.17.0
     - shellcheck@0.9.0
     - git-diff-check
-    - markdownlint@0.34.0
+    - markdownlint@0.35.0
     - buildifier@6.1.2
 runtimes:
   enabled:

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"]}"
+}

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

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"
+}