@100mslive/react-native-hms 0.9.3 → 0.9.6

package/README.md

@@ -192,10 +192,9 @@ const styles = StyleSheet.create({
 });
 
 // trackId can be acquired from the method explained above
-// sink is passed false video would be removed. It is a ios only prop, for android it is handled by the package itself.
 // scaleType can be selected from HMSVideoViewMode as required
 // mirror can be passed as true to flip videos horizontally
-<HmsView sink={true} style={styles.hmsView} trackId={trackId} mirror={true} scaleType={HMSVideoViewMode.ASPECT_FIT} />
+<HmsView style={styles.hmsView} trackId={trackId} mirror={true} scaleType={HMSVideoViewMode.ASPECT_FIT} />
 
 ...
 ```

package/android/build.gradle

@@ -63,7 +63,7 @@ dependencies {
     //noinspection GradleDynamicVersion
     implementation "com.facebook.react:react-native:+"
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"  // From node_modules
-    implementation 'com.github.100mslive.android-sdk:lib:2.3.4'
+    implementation 'com.github.100mslive.android-sdk:lib:2.3.9'
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.0'
     implementation 'androidx.constraintlayout:constraintlayout:2.1.0'
     implementation 'androidx.appcompat:appcompat:1.3.1'

package/android/src/main/java/com/reactnativehmssdk/{HmsDecoder.kt → HMSDecoder.kt}

@@ -11,12 +11,13 @@ import live.hms.video.sdk.models.*
 import live.hms.video.sdk.models.role.*
 import live.hms.video.sdk.models.trackchangerequest.HMSChangeTrackStateRequest
 
-object HmsDecoder {
+object HMSDecoder {
 
   fun getHmsRoom(hmsRoom: HMSRoom?): WritableMap {
     val room: WritableMap = Arguments.createMap()
     if (hmsRoom != null) {
       room.putString("id", hmsRoom.roomId)
+      room.putString("sessionId", hmsRoom.sessionId)
       room.putString("name", hmsRoom.name)
       room.putString("metaData", null)
       room.putString("startedAt", hmsRoom.startedAt.toString())
@@ -33,6 +34,7 @@ object HmsDecoder {
           this.getHMSServerRecordingState(hmsRoom.serverRecordingState)
       )
       room.putMap("hlsStreamingState", this.getHMSHlsStreamingState(hmsRoom.hlsStreamingState))
+      room.putMap("hlsRecordingState", this.getHMSHlsRecordingState(hmsRoom.hlsRecordingState))
       room.putMap("localPeer", this.getHmsLocalPeer(hmsRoom.localPeer))
       room.putArray("peers", this.getAllPeers(hmsRoom.peerList))
       room.putInt("peerCount", hmsRoom.peerCount)
@@ -354,37 +356,18 @@ object HmsDecoder {
     return changeTrackStateRequest
   }
 
-  fun getError(error: HMSException): WritableMap {
-    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)
-
-    return decodedError
-  }
-
-  private fun getCustomError(message: String?, code: Int?): WritableMap {
-    val decodedError: WritableMap = Arguments.createMap()
-    var customCode = 101
-    var customMessage = "SOMETHING WENT WRONG"
-    if (code !== null) {
-      customCode = code.toInt()
+  fun getError(error: HMSException?): WritableMap? {
+    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)
+      return decodedError
     }
-    if (message !== null) {
-      customMessage = message
-    }
-    decodedError.putInt("code", customCode)
-    decodedError.putString("localizedDescription", customMessage)
-    decodedError.putString("description", customMessage)
-    decodedError.putString("message", customMessage)
-    decodedError.putInt("name", customCode)
-    decodedError.putInt("action", customCode)
-
-    return decodedError
+    return null
   }
 
   private fun getHMSBrowserRecordingState(data: HMSBrowserRecordingState?): ReadableMap {
@@ -394,7 +377,7 @@ object HmsDecoder {
       input.putString("startedAt", data.startedAt.toString())
       input.putString("stoppedAt", data.stoppedAt.toString())
       input.putBoolean("running", data.running)
-      input.putMap("error", this.getCustomError(data.error?.message, data.error?.code))
+      input.putMap("error", this.getError(data.error))
     }
     return input
   }
@@ -405,7 +388,7 @@ object HmsDecoder {
       input.putBoolean("running", data.running)
       input.putString("startedAt", data.startedAt.toString())
       input.putString("stoppedAt", data.stoppedAt.toString())
-      input.putMap("error", this.getCustomError(data.error?.message, data.error?.code))
+      input.putMap("error", this.getError(data.error))
     }
     return input
   }
@@ -415,7 +398,7 @@ object HmsDecoder {
     if (data !== null) {
       input.putBoolean("running", data.running)
       input.putString("startedAt", data.startedAt.toString())
-      input.putMap("error", data.error?.let { this.getError(it) })
+      input.putMap("error", this.getError(data.error))
     }
     return input
   }
@@ -429,6 +412,27 @@ object HmsDecoder {
     return input
   }
 
+  private fun getHMSHlsRecordingState(data: HmsHlsRecordingState?): ReadableMap {
+    val input = Arguments.createMap()
+    if (data !== null) {
+      data.running?.let { input.putBoolean("running", it) }
+      input.putString("startedAt", data.startedAt.toString())
+      // input.putMap("hlsRecordingConfig", this.getHMSHlsRecordingConfig(data.hlsRecordingConfig))
+      data.hlsRecordingConfig?.let { input.putBoolean("singleFilePerLayer", it.singleFilePerLayer) }
+      data.hlsRecordingConfig?.let { input.putBoolean("videoOnDemand", it.videoOnDemand) }
+    }
+    return input
+  }
+
+  //  private fun getHMSHlsRecordingConfig(data: HMSHlsRecordingConfig?): ReadableMap {
+  //    val input = Arguments.createMap()
+  //    if (data !== null) {
+  //      input.putBoolean("singleFilePerLayer", data.singleFilePerLayer)
+  //      input.putBoolean("videoOnDemand", data.videoOnDemand)
+  //    }
+  //    return input
+  //  }
+
   private fun getHMSHLSVariant(data: ArrayList<HMSHLSVariant>?): ReadableArray {
     val variants = Arguments.createArray()
     if (data !== null) {

package/android/src/main/java/com/reactnativehmssdk/{HmsHelper.kt → HMSHelper.kt}

@@ -1,19 +1,35 @@
 package com.reactnativehmssdk
 
+import android.content.Context
+import android.graphics.Bitmap
+import android.os.Build
+import android.os.Handler
+import android.util.Base64
+import android.util.Log
+import android.view.PixelCopy
+import androidx.annotation.RequiresApi
+import com.facebook.react.bridge.*
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import java.io.ByteArrayOutputStream
+import java.util.*
+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.tracks.*
+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.role.*
+import live.hms.video.sdk.models.role.HMSRole
 import live.hms.video.utils.HmsUtilities
+import org.webrtc.SurfaceViewRenderer
 
-object HmsHelper {
+object HMSHelper {
 
   fun areAllRequiredKeysAvailable(
       map: ReadableMap?,
@@ -48,6 +64,39 @@ object HmsHelper {
     return true
   }
 
+  fun getUnavailableRequiredKey(
+      map: ReadableMap?,
+      requiredKeys: Array<Pair<String, String>>
+  ): String? {
+    if (map == null) {
+      return "Object_Is_Null"
+    }
+    for ((key, value) in requiredKeys) {
+      if (map.hasKey(key)) {
+        when (value) {
+          "String" -> {
+            if (map.getString(key) == null) {
+              return key + "_Is_Null"
+            }
+          }
+          "Array" -> {
+            if (map.getArray(key) == null) {
+              return key + "_Is_Null"
+            }
+          }
+          "Map" -> {
+            if (map.getMap(key) == null) {
+              return key + "_Is_Null"
+            }
+          }
+        }
+      } else {
+        return key + "_Is_Required"
+      }
+    }
+    return null
+  }
+
   fun getPeerFromPeerId(peerId: String?, room: HMSRoom?): HMSPeer? {
     if (peerId != null && room != null) {
       return HmsUtilities.getPeer(peerId, room)
@@ -237,7 +286,7 @@ object HmsHelper {
     return HMSVideoTrackSettings.CameraFacing.FRONT
   }
 
-  fun getHms(credentials: ReadableMap, hmsCollection: MutableMap<String, HmsSDK>): HmsSDK? {
+  fun getHms(credentials: ReadableMap, hmsCollection: MutableMap<String, HMSRNSDK>): HMSRNSDK? {
     val id = credentials.getString("id")
 
     return if (id != null) {
@@ -403,4 +452,64 @@ object HmsHelper {
     }
     return config
   }
+
+  @RequiresApi(Build.VERSION_CODES.N)
+  fun captureSurfaceView(
+      surfaceView: SurfaceViewRenderer,
+      sdkId: String,
+      args: ReadableArray?,
+      context: Context,
+      id: Int
+  ) {
+    val output = Arguments.createMap()
+    if (args != null) {
+      output.putInt("requestId", args.getInt(0))
+    } else {
+      output.putInt("requestId", -1)
+    }
+    val reactContext = context as ReactContext
+    try {
+      val bitmap: Bitmap =
+          Bitmap.createBitmap(surfaceView.width, surfaceView.height, Bitmap.Config.ARGB_8888)
+      PixelCopy.request(
+          surfaceView,
+          bitmap,
+          { copyResult ->
+            if (copyResult == PixelCopy.SUCCESS) {
+              Log.d("captureSurfaceView", "bitmap: $bitmap")
+              val byteArrayOutputStream = ByteArrayOutputStream()
+              bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteArrayOutputStream)
+              val byteArray = byteArrayOutputStream.toByteArray()
+              val encoded: String = Base64.encodeToString(byteArray, Base64.DEFAULT)
+              Log.d("captureSurfaceView", "Base64: $encoded")
+              output.putString("result", encoded)
+              reactContext
+                  .getJSModule(RCTEventEmitter::class.java)
+                  .receiveEvent(id, "captureFrame", output)
+            } else {
+              Log.e("captureSurfaceView", "copyResult: $copyResult")
+              HMSManager.hmsCollection[sdkId]?.emitHMSError(
+                  HMSException(
+                      103,
+                      copyResult.toString(),
+                      copyResult.toString(),
+                      copyResult.toString(),
+                      copyResult.toString()
+                  )
+              )
+              output.putString("error", copyResult.toString())
+              reactContext
+                  .getJSModule(RCTEventEmitter::class.java)
+                  .receiveEvent(id, "captureFrame", output)
+            }
+          },
+          Handler()
+      )
+    } catch (e: Exception) {
+      Log.e("captureSurfaceView", "error: $e")
+      HMSManager.hmsCollection[sdkId]?.emitHMSError(e as HMSException)
+      output.putString("error", e.message)
+      reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, "captureFrame", output)
+    }
+  }
 }

package/android/src/main/java/com/reactnativehmssdk/{HmsModule.kt → HMSManager.kt}

@@ -6,21 +6,21 @@ import android.os.Bundle
 import com.facebook.react.bridge.*
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.DeviceEventManagerModule
-import com.reactnativehmssdk.HmsModule.Companion.REACT_CLASS
+import com.reactnativehmssdk.HMSManager.Companion.REACT_CLASS
 import java.util.UUID
 
 @ReactModule(name = REACT_CLASS)
-class HmsModule(reactContext: ReactApplicationContext) :
+class HMSManager(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext), Application.ActivityLifecycleCallbacks {
   companion object {
-    const val REACT_CLASS = "HmsManager"
-    var hmsCollection = mutableMapOf<String, HmsSDK>()
+    const val REACT_CLASS = "HMSManager"
+    var hmsCollection = mutableMapOf<String, HMSRNSDK>()
   }
   override fun getName(): String {
-    return "HmsManager"
+    return "HMSManager"
   }
 
-  fun getHmsInstance(): MutableMap<String, HmsSDK> {
+  fun getHmsInstance(): MutableMap<String, HMSRNSDK> {
     return hmsCollection
   }
 
@@ -32,14 +32,14 @@ class HmsModule(reactContext: ReactApplicationContext) :
     if (hasItem) {
       val uuid = UUID.randomUUID()
       val randomUUIDString = uuid.toString()
-      val sdkInstance = HmsSDK(data, this, randomUUIDString, reactApplicationContext)
+      val sdkInstance = HMSRNSDK(data, this, randomUUIDString, reactApplicationContext)
 
       hmsCollection[randomUUIDString] = sdkInstance
 
       callback?.resolve(randomUUIDString)
     } else {
       val randomUUIDString = "12345"
-      val sdkInstance = HmsSDK(data, this, randomUUIDString, reactApplicationContext)
+      val sdkInstance = HMSRNSDK(data, this, randomUUIDString, reactApplicationContext)
 
       hmsCollection[randomUUIDString] = sdkInstance
 
@@ -49,168 +49,168 @@ class HmsModule(reactContext: ReactApplicationContext) :
 
   @ReactMethod
   fun preview(credentials: ReadableMap) {
-    val hms = HmsHelper.getHms(credentials, hmsCollection)
+    val hms = HMSHelper.getHms(credentials, hmsCollection)
 
     hms?.preview(credentials)
   }
 
   @ReactMethod
   fun join(credentials: ReadableMap) {
-    val hms = HmsHelper.getHms(credentials, hmsCollection)
+    val hms = HMSHelper.getHms(credentials, hmsCollection)
 
     hms?.join(credentials)
   }
 
   @ReactMethod
   fun setLocalMute(data: ReadableMap) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.setLocalMute(data)
   }
 
   @ReactMethod
   fun setLocalVideoMute(data: ReadableMap) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.setLocalVideoMute(data)
   }
 
   @ReactMethod
   fun switchCamera(data: ReadableMap) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.switchCamera()
   }
 
   @ReactMethod
   fun leave(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.leave(callback)
   }
 
   @ReactMethod
   fun sendBroadcastMessage(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.sendBroadcastMessage(data, callback)
   }
 
   @ReactMethod
   fun sendGroupMessage(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.sendGroupMessage(data, callback)
   }
 
   @ReactMethod
   fun sendDirectMessage(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.sendDirectMessage(data, callback)
   }
 
   @ReactMethod
   fun changeRole(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.changeRole(data, callback)
   }
 
   @ReactMethod
   fun changeTrackState(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.changeTrackState(data, callback)
   }
 
   @ReactMethod
   fun changeTrackStateForRoles(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.changeTrackStateForRoles(data, callback)
   }
 
   @ReactMethod
   fun isMute(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.isMute(data, callback)
   }
 
   @ReactMethod
   fun removePeer(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.removePeer(data, callback)
   }
 
   @ReactMethod
   fun isPlaybackAllowed(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.isPlaybackAllowed(data, callback)
   }
 
   @ReactMethod
   fun getRoom(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getRoom(callback)
   }
 
   @ReactMethod
   fun setPlaybackAllowed(data: ReadableMap) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.setPlaybackAllowed(data)
   }
 
   @ReactMethod
   fun endRoom(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.endRoom(data, callback)
   }
 
   @ReactMethod
   fun acceptRoleChange(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.acceptRoleChange(callback)
   }
 
   @ReactMethod
   fun setVolume(data: ReadableMap) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.setVolume(data)
   }
 
   @ReactMethod
   fun getVolume(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getVolume(data, callback)
   }
 
   @ReactMethod
   fun setPlaybackForAllAudio(data: ReadableMap) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.setPlaybackForAllAudio(data)
   }
 
   @ReactMethod
   fun remoteMuteAllAudio(data: ReadableMap) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.remoteMuteAllAudio()
   }
 
   @ReactMethod
   fun changeMetadata(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.changeMetadata(data, callback)
   }
@@ -218,21 +218,21 @@ class HmsModule(reactContext: ReactApplicationContext) :
   @ReactMethod
   fun startScreenshare(data: ReadableMap, callback: Promise?) {
     currentActivity?.application?.registerActivityLifecycleCallbacks(this)
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.startScreenshare(callback)
   }
 
   @ReactMethod
   fun isScreenShared(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.isScreenShared(callback)
   }
 
   @ReactMethod
   fun stopScreenshare(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     currentActivity?.application?.unregisterActivityLifecycleCallbacks(this)
     hms?.stopScreenshare(callback)
@@ -240,46 +240,56 @@ class HmsModule(reactContext: ReactApplicationContext) :
 
   @ReactMethod
   fun startRTMPOrRecording(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.startRTMPOrRecording(data, callback)
   }
 
   @ReactMethod
   fun stopRtmpAndRecording(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.stopRtmpAndRecording(callback)
   }
 
   @ReactMethod
   fun startHLSStreaming(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.startHLSStreaming(data, callback)
   }
 
   @ReactMethod
   fun stopHLSStreaming(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.stopHLSStreaming(callback)
   }
 
   @ReactMethod
   fun resetVolume(data: ReadableMap) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.resetVolume()
   }
 
   @ReactMethod
   fun changeName(data: ReadableMap, callback: Promise?) {
-    val hms = HmsHelper.getHms(data, hmsCollection)
+    val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.changeName(data, callback)
   }
 
+  @ReactMethod
+  fun destroy(data: ReadableMap, callback: Promise?) {
+    val id = data.getString("id")
+    hmsCollection.remove(id)
+    val result: WritableMap = Arguments.createMap()
+    result.putBoolean("success", true)
+    result.putString("message", "$id removed")
+    callback?.resolve(result)
+  }
+
   fun emitEvent(event: String, data: WritableMap) {
     reactApplicationContext
         .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)