@100mslive/react-native-hms 1.3.0 → 1.5.0

package/README.md

@@ -1,6 +1,5 @@
 <a href="https://100ms.live/">
-<img src="https://github.com/100mslive/100ms-react-native/blob/main/100ms.gif" height=256/> 
-<img src="https://github.com/100mslive/100ms-react-native/blob/main/100ms.svg" title="100ms logo" float=center height=256>
+<img src="https://raw.githubusercontent.com/100mslive/react-native-hms/main/100ms.svg" title="100ms logo" float=center height=256>
 </a>
 
 [![npm](https://img.shields.io/npm/v/@100mslive/react-native-hms)](https://www.npmjs.com/package/@100mslive/react-native-hms)
@@ -17,6 +16,11 @@
 
 # 100ms React Native SDK
 
+Integrate Real Time Audio and Video conferencing, Interactive Live Streaming, and Chat in your apps with 100ms React Native SDK.
+
+With support for HLS and RTMP Live Streaming and Recording, Picture-in-Picture (PiP), one-to-one Video Call Modes, Audio Rooms, Video Player and much more, add immersive real-time communications to your apps.
+
+
 📖 Read the Complete Documentation here: https://www.100ms.live/docs/react-native/v2/foundation/basics
 
 ## 🏃 Example App
@@ -120,17 +124,65 @@ More information about Audio Video Permission on iOS & Android is [available her
 
 The package exports all the classes and a HMSSDK class that manages everything.
 
-## Setting up the HMS Instance
+## [Setting up the HMS Instance](https://www.100ms.live/docs/react-native/v2/how--to-guides/install-the-sdk/hmssdk)
 
 First invoke the `build` method which returns an instance of `HMSSDK`. Save this instance to perform all actions related to 100ms.
 
 ```ts
 import { HMSSDK } from '@100mslive/react-native-hms';
 
-// create HMSSDK instance using the build method & save it for further usage
+/**
+ * create HMSSDK instance using the build method & save it for further usage
+ *
+ * Important Note: Don't build new `HMSSDK` instance before destroying the previous one.
+ * for more info checkout {@link https://www.100ms.live/docs/react-native/v2/how--to-guides/install-the-sdk/hmssdk#what-does-destroy-method-do}
+ */
 const hmsInstance = await HMSSDK.build();
 ```
 
+## [Get Authentication Token](https://www.100ms.live/docs/react-native/v2/get-started/quickstart#fetch-token-to-join-the-room)
+
+### Fetch token using room-code method (Recommended)
+
+We can get the authentication token using room-code from meeting URL.
+
+Let's understand the subdomain and code from the sample URL
+
+In this sample url: `http://100ms-rocks.app.100ms.live/meeting/abc-defg-hij`
+ -  Subdomain is `100ms-rocks`
+ -  Room code is `abc-defg-hij`
+
+Now to get the room-code from meeting URL, we can write our own logic or use the `getCode` method from [here](https://github.com/100mslive/react-native-hms/blob/main/example/src/utils/getRoomLinkDetails.ts)
+
+To generate token we will be using `getAuthTokenByRoomCode` method available on `HMSSDK` instance. This method has `roomCode` as a required
+parameter and `userId` & `endpoint` as optional parameter.
+
+Let's checkout the implementation:
+
+```js
+/**
+ * `getAuthTokenByRoomCode` returns a promise which is resolved with "auth token"
+ * checkout {@link https://www.100ms.live/docs/react-native/v2/how--to-guides/install-the-sdk/hmssdk#what-does-destroy-method-do}
+ */
+const token = await hmsInstance.getAuthTokenByRoomCode('YOUR_ROOM_CODE');
+
+/**
+ * Create `HMSConfig` with the above auth token and username
+ */
+const hmsConfig = new HMSConfig({ authToken: token, username: 'John Appleseed' });
+```
+
+### Get temporary token from dashboard
+
+To test audio/video functionality, you need to connect to a 100ms Room. Please check the following steps for the same -
+
+1. Navigate to your [100ms dashboard](https://dashboard.100ms.live/dashboard) or [create an account](https://dashboard.100ms.live/register) if you don't have one.
+2. Use the `Video Conferencing Starter Kit` to create a room with a default template assigned to it to test this app quickly.
+3. Go to the [Rooms page](https://dashboard.100ms.live/rooms) in your dashboard, click on the `Room Id` of the room you created above, and click on the `Join Room` button on the top right.
+4. You will see 100ms demo URLs for the roles created when you deployed the starter kit; you can click on the 'key' icon to copy the token and update the `AUTH_TOKEN` variable in "App.js" file.
+    > Token from 100ms dashboard is for testing purposes only, For production applications you must generate tokens on your own server. Refer to the [Management Token section](/concepts/v2/concepts/security-and-tokens#management-token) in Authentication and Tokens guide for more information.
+
+
 ## [Add Event Listeners](https://www.100ms.live/docs/react-native/v2/features/event-listeners)
 
 Add Event Listeners to get notified about actions happening in the 100ms Room.
@@ -175,6 +227,8 @@ NOTE: `ON_JOIN` Event Listener must be **attached** before calling `join` functi
 // create HMSSDK instance using the build function
 const hmsInstance = await HMSSDK.build();
 
+// Generate 100ms Auth Token by Room Code
+const token = await hmsInstance.getAuthTokenByRoomCode('abc-defg-hij'); // Sample Room Code
 
 // You'll need to add Event Listeners for HMSUpdateListenerActions, which are invoked to notify about updates happening in the room like a peer joins/leaves, a track got muted/unmuted, any errors that occur, etc.
 hmsInstance.addEventListener(HMSUpdateListenerActions.ON_JOIN, onJoinSuccess);
@@ -185,7 +239,7 @@ hmsInstance.addEventListener(HMSUpdateListenerActions.ON_ERROR, onError);
 
 // Next, create an object of HMSConfig class using the available joining configurations.
 let config = new HMSConfig({
-                    authToken: 'eyJH5c...', // client-side token generated from your token service
+                    authToken: token, // client-side token generated by `getAuthTokenByRoomCode` method
                     username: 'John Appleseed',
                 });
 

package/android/build.gradle

@@ -1,6 +1,6 @@
 import groovy.json.JsonSlurper
 
-def sdkVersionsJson = new JsonSlurper().parse file("../sdk-versions.json")
+def sdkVersions = new JsonSlurper().parse file("../sdk-versions.json")
 
 buildscript {
     ext.kotlin_version = '1.5.30-RC'
@@ -69,7 +69,8 @@ dependencies {
     //noinspection GradleDynamicVersion
     implementation "com.facebook.react:react-native:+"
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"  // From node_modules
-    implementation "live.100ms:android-sdk:${sdkVersionsJson["android"]}"
+    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'

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

@@ -1,12 +1,11 @@
 package com.reactnativehmssdk
 
 import com.facebook.react.bridge.*
+import live.hms.video.connection.degredation.QualityLimitationReasons
 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
-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.*
 import live.hms.video.sdk.models.*
 import live.hms.video.sdk.models.enums.HMSPeerUpdate
@@ -77,12 +76,14 @@ object HMSDecoder {
     val room: WritableMap = Arguments.createMap()
     if (hmsRoom != null) {
       room.putString("id", hmsRoom.roomId)
-      room.putString("sessionId", hmsRoom.sessionId)
+      hmsRoom.sessionId?.let {
+        room.putString("sessionId", it)
+      }
       room.putString("name", hmsRoom.name)
       room.putString("metaData", null)
-      hmsRoom.startedAt?.let {
-        room.putString("startedAt", it.toString())
-      }
+      // hmsRoom.startedAt?.let {
+      //   room.putString("startedAt", it.toString())
+      // }
 
       hmsRoom.browserRecordingState?.let {
         room.putMap(
@@ -113,7 +114,9 @@ object HMSDecoder {
         room.putMap("hlsRecordingState", this.getHMSHlsRecordingState(hmsRoom.hlsRecordingState))
       }
 
-      room.putMap("localPeer", this.getHmsLocalPeer(hmsRoom.localPeer))
+      hmsRoom.localPeer?.let {
+        room.putMap("localPeer", this.getHmsLocalPeer(it))
+      }
 
       room.putArray("peers", this.getAllPeers(hmsRoom.peerList))
 
@@ -309,6 +312,10 @@ object HMSDecoder {
         publishSettings.putMap("screen", this.getHmsVideoSettings(it))
       }
 
+      hmsPublishSettings.simulcast?.let {
+        publishSettings.putMap("simulcast", this.getHmsSimulcastSettings(it))
+      }
+
       publishSettings.putArray("allowed", this.getWriteableArray(hmsPublishSettings.allowed))
     }
     return publishSettings
@@ -345,6 +352,50 @@ object HMSDecoder {
     return videoSettings
   }
 
+  private fun getHmsSimulcastSettings(hmsSimulcastSettings: Simulcast?): WritableMap {
+    val simulcastSettings: WritableMap = Arguments.createMap()
+    if (hmsSimulcastSettings != null) {
+      hmsSimulcastSettings.video?.let {
+        simulcastSettings.putMap("video", getHmsVideoSimulcastLayersParams(it))
+      }
+      hmsSimulcastSettings.screen?.let {
+        simulcastSettings.putMap("screen", getHmsVideoSimulcastLayersParams(it))
+      }
+    }
+    return simulcastSettings
+  }
+
+  private fun getHmsVideoSimulcastLayersParams(hmsVideoSimulcastLayersParams: VideoSimulcastLayersParams?): WritableMap {
+    val videoSimulcastLayersParams: WritableMap = Arguments.createMap()
+    if (hmsVideoSimulcastLayersParams != null) {
+      hmsVideoSimulcastLayersParams.layers?.let {
+        val layersParams = Arguments.createArray()
+        it.forEach { layer -> layersParams.pushMap(getHmsLayerParams(layer)) }
+        videoSimulcastLayersParams.putArray("layers", layersParams)
+      }
+    }
+    return videoSimulcastLayersParams
+  }
+
+  private fun getHmsLayerParams(hmsLayerParams: LayerParams?): WritableMap {
+    val layerParams: WritableMap = Arguments.createMap()
+    if (hmsLayerParams != null) {
+      hmsLayerParams.rid?.let {
+        layerParams.putString("rid", it)
+      }
+      hmsLayerParams.maxBitrate?.let {
+        layerParams.putInt("maxBitrate", it)
+      }
+      hmsLayerParams.scaleResolutionDownBy?.let {
+        layerParams.putDouble("scaleResolutionDownBy", it.toDouble())
+      }
+      hmsLayerParams.maxFramerate?.let {
+        layerParams.putInt("maxFramerate", it)
+      }
+    }
+    return layerParams
+  }
+
   fun getHmsLocalPeer(hmsLocalPeer: HMSLocalPeer?): WritableMap {
     val peer: WritableMap = Arguments.createMap()
     if (hmsLocalPeer != null) {
@@ -412,10 +463,11 @@ object HMSDecoder {
     return settings
   }
 
-  private fun getHmsVideoTrackResolution(hmsResolution: HMSVideoResolution): WritableMap {
-    val resolution: WritableMap = Arguments.createMap()
-    resolution.putInt("height", hmsResolution.height)
-    resolution.putInt("width", hmsResolution.width)
+  private fun getHmsVideoTrackResolution(hmsResolution: HMSVideoResolution): WritableArray {
+    val resolution: WritableArray = Arguments.createArray() // [width, height]
+    resolution.pushInt(hmsResolution.width)
+    resolution.pushInt(hmsResolution.height)
+
     return resolution
   }
 
@@ -630,6 +682,11 @@ object HMSDecoder {
     val subscribeSettings: WritableMap = Arguments.createMap()
     if (hmsSubscribeSettings != null) {
       subscribeSettings.putInt("maxSubsBitRate", hmsSubscribeSettings.maxSubsBitRate)
+
+      hmsSubscribeSettings.subscribeDegradationParam?.let {
+        subscribeSettings.putMap("subscribeDegradation", this.getHmsSubscribeDegradationSettings(it))
+      }
+
       subscribeSettings.putArray(
         "subscribeTo",
         this.getWriteableArray(hmsSubscribeSettings.subscribeTo)
@@ -702,26 +759,32 @@ object HMSDecoder {
     return hmsNetworkQuality
   }
 
-  fun getHMSRTCStats(hmsRtcStats: HMSRTCStats?): WritableMap {
-    val rtcStats: WritableMap = Arguments.createMap()
+  fun getHMSRTCStats(hmsRtcStats: HMSRTCStats?): WritableArray {
+    val rtcStats: WritableArray = Arguments.createArray() // [bitrateReceived, bitrateSent, bytesReceived, bytesSent, packetsLost, packetsReceived, roundTripTime]
     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)
+      rtcStats.pushDouble(hmsRtcStats.bitrateReceived)
+      rtcStats.pushDouble(hmsRtcStats.bitrateSent)
+      rtcStats.pushString(hmsRtcStats.bytesReceived.toString())
+      rtcStats.pushString(hmsRtcStats.bytesSent.toString())
+      rtcStats.pushString(hmsRtcStats.packetsLost.toString())
+      rtcStats.pushString(hmsRtcStats.packetsReceived.toString())
+      rtcStats.pushDouble(hmsRtcStats.roundTripTime)
     }
     return rtcStats
   }
 
-  fun getLocalAudioStats(hmsLocalAudioStats: HMSLocalAudioStats?): WritableMap {
-    val localAudioStats: WritableMap = Arguments.createMap()
+  fun getLocalAudioStats(hmsLocalAudioStats: HMSLocalAudioStats?): WritableArray {
+    val localAudioStats: WritableArray = Arguments.createArray()
+
     if (hmsLocalAudioStats != null) {
-      hmsLocalAudioStats.bitrate?.let { localAudioStats.putDouble("bitrate", it) }
-      localAudioStats.putString("bytesSent", hmsLocalAudioStats.bytesSent.toString())
-      hmsLocalAudioStats.roundTripTime?.let { localAudioStats.putDouble("roundTripTime", it) }
+      val bitrate = hmsLocalAudioStats.bitrate ?: -1.0
+      localAudioStats.pushDouble(bitrate)
+
+      val bytesSent = hmsLocalAudioStats.bytesSent.let { if (it === null) "" else it.toString() }
+      localAudioStats.pushString(bytesSent)
+
+      val roundTripTime = hmsLocalAudioStats.roundTripTime ?: -1.0
+      localAudioStats.pushDouble(roundTripTime)
     }
     return localAudioStats
   }
@@ -730,48 +793,119 @@ object HMSDecoder {
     val stats: WritableArray = Arguments.createArray()
 
     for (stat in hmsLocalVideoStats) {
-      val localVideoStats: WritableMap = Arguments.createMap()
+      val localVideoStats: WritableArray = Arguments.createArray() // [bitrate, bytesSent, roundTripTime, frameRate, resolution, layer, qualityLimitationReasons]
 
-      localVideoStats.putString("bytesSent", stat.bytesSent.toString())
-      localVideoStats.putMap(
-        "resolution",
-        stat.resolution?.let { this.getHmsVideoTrackResolution(it) }
-      )
-      stat.bitrate?.let { localVideoStats.putDouble("bitrate", it) }
-      stat.roundTripTime?.let { localVideoStats.putDouble("roundTripTime", it) }
-      stat.frameRate?.let { localVideoStats.putDouble("frameRate", it) }
-      stats.pushMap(localVideoStats)
+      val bitrate = stat.bitrate ?: -1.0
+      localVideoStats.pushDouble(bitrate)
+
+      val bytesSent = stat.bytesSent.let { if (it === null) "" else it.toString() }
+      localVideoStats.pushString(bytesSent)
+
+      val roundTripTime = stat.roundTripTime ?: -1.0
+      localVideoStats.pushDouble(roundTripTime)
+
+      val frameRate = stat.frameRate ?: -1.0
+      localVideoStats.pushDouble(frameRate)
+
+      stat.resolution.let {
+        if (it === null) {
+          localVideoStats.pushNull()
+        } else {
+          localVideoStats.pushArray(getHmsVideoTrackResolution(it)) // [width, height]
+        }
+      }
+
+      val layer = stat.hmsLayer.let { if (it === null) HMSLayer.HIGH.name else it.name }
+      localVideoStats.pushString(layer)
+
+      val qualityLimitationReasons = getHmsQualityLimitationReasons(stat.qualityLimitationReason)
+      localVideoStats.pushMap(qualityLimitationReasons)
+
+      stats.pushArray(localVideoStats)
     }
 
     return stats
   }
 
-  fun getRemoteAudioStats(hmsRemoteAudioStats: HMSRemoteAudioStats?): WritableMap {
-    val remoteAudioStats: WritableMap = Arguments.createMap()
+  private fun getHmsQualityLimitationReasons(hmsQualityLimitationReasons: QualityLimitationReasons?): WritableMap {
+    val qualityLimitationReasons: WritableMap = Arguments.createMap()
+
+    if (hmsQualityLimitationReasons != null) {
+      hmsQualityLimitationReasons.bandWidth?.let { qualityLimitationReasons.putDouble("bandwidth", it) }
+      hmsQualityLimitationReasons.cpu?.let { qualityLimitationReasons.putDouble("cpu", it) }
+      hmsQualityLimitationReasons.none?.let { qualityLimitationReasons.putDouble("none", it) }
+      hmsQualityLimitationReasons.other?.let { qualityLimitationReasons.putDouble("other", it) }
+      hmsQualityLimitationReasons.qualityLimitationResolutionChanges?.let { qualityLimitationReasons.putInt("qualityLimitationResolutionChanges", it.toInt()) }
+      qualityLimitationReasons.putString("reason", hmsQualityLimitationReasons.reason.name)
+    }
+    return qualityLimitationReasons
+  }
+
+  fun getRemoteAudioStats(hmsRemoteAudioStats: HMSRemoteAudioStats?): WritableArray {
+    val remoteAudioStats: WritableArray = Arguments.createArray()
+
     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())
+      val bitrate = hmsRemoteAudioStats.bitrate ?: -1.0
+      remoteAudioStats.pushDouble(bitrate)
+
+      val bytesReceived = hmsRemoteAudioStats.bytesReceived.let { if (it === null) "" else it.toString() }
+      remoteAudioStats.pushString(bytesReceived)
+
+      val jitter = hmsRemoteAudioStats.jitter ?: -1.0
+      remoteAudioStats.pushDouble(jitter)
+
+      val packetsLost = hmsRemoteAudioStats.packetsLost ?: -1
+      remoteAudioStats.pushInt(packetsLost)
+
+      val packetsReceived = hmsRemoteAudioStats.packetsReceived.let { if (it === null) "" else it.toString() }
+      remoteAudioStats.pushString(packetsReceived)
     }
     return remoteAudioStats
   }
 
-  fun getRemoteVideoStats(hmsRemoteVideoStats: HMSRemoteVideoStats?): WritableMap {
-    val remoteVideoStats: WritableMap = Arguments.createMap()
+  fun getRemoteVideoStats(hmsRemoteVideoStats: HMSRemoteVideoStats?): WritableArray {
+    val remoteVideoStats: WritableArray = Arguments.createArray() // [bitrate, bytesReceived, frameRate, jitter, packetsLost, packetsReceived, resolution]
+
     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) }
+      val bitrate = hmsRemoteVideoStats.bitrate ?: -1.0
+      remoteVideoStats.pushDouble(bitrate)
+
+      val bytesReceived = hmsRemoteVideoStats.bytesReceived.let { if (it === null) "" else it.toString() }
+      remoteVideoStats.pushString(bytesReceived)
+
+      val frameRate = hmsRemoteVideoStats.frameRate ?: -1.0
+      remoteVideoStats.pushDouble(frameRate)
+
+      val jitter = hmsRemoteVideoStats.jitter ?: -1.0
+      remoteVideoStats.pushDouble(jitter)
+
+      val packetsLost = hmsRemoteVideoStats.packetsLost ?: -1
+      remoteVideoStats.pushInt(packetsLost)
+
+      val packetsReceived = hmsRemoteVideoStats.packetsReceived.let { if (it === null) "" else it.toString() }
+      remoteVideoStats.pushString(packetsReceived)
+
+      hmsRemoteVideoStats.resolution.let {
+        if (it === null) {
+          remoteVideoStats.pushNull()
+        } else {
+          remoteVideoStats.pushArray(getHmsVideoTrackResolution(it)) // [width, height]
+        }
+      }
     }
     return remoteVideoStats
   }
+
+  private fun getSimulcastLayerDefinition(hmsSimulcastLayerDefinition: HMSSimulcastLayerDefinition): WritableMap {
+    val simulcastLayerDefinition: WritableMap = Arguments.createMap()
+    simulcastLayerDefinition.putString("layer", hmsSimulcastLayerDefinition.layer.name)
+    simulcastLayerDefinition.putArray("resolution", getHmsVideoTrackResolution(hmsSimulcastLayerDefinition.resolution)) // [width, height]
+    return simulcastLayerDefinition
+  }
+
+  fun getSimulcastLayerDefinitions(hmsSimulcastLayerDefinitions: List<HMSSimulcastLayerDefinition>): WritableArray {
+    val simulcastLayerDefinitions: WritableArray = Arguments.createArray()
+    hmsSimulcastLayerDefinitions.forEach { simulcastLayerDefinitions.pushMap(getSimulcastLayerDefinition(it)) }
+    return simulcastLayerDefinitions
+  }
 }

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

@@ -545,6 +545,7 @@ object HMSHelper {
     return config
   }
 
+  // TODO: replace surfaceView with hmsVideoView
   @RequiresApi(Build.VERSION_CODES.N)
   fun captureSurfaceView(
     surfaceView: SurfaceViewRenderer,

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

@@ -370,20 +370,6 @@ 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 enableNetworkQualityUpdates(data: ReadableMap) {
     val hms = HMSHelper.getHms(data, hmsCollection)
@@ -482,6 +468,13 @@ class HMSManager(reactContext: ReactApplicationContext) :
     hms?.restrictData(data, promise)
   }
 
+  @ReactMethod()
+  fun getAuthTokenByRoomCode(data: ReadableMap, promise: Promise) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.getAuthTokenByRoomCode(data, promise)
+  }
+
   // region Person-In-Person Mode Action handing
   private val pipReceiver by lazy {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
@@ -877,6 +870,48 @@ class HMSManager(reactContext: ReactApplicationContext) :
     }
   }
 
+  @ReactMethod
+  fun getRemoteVideoTrackFromTrackId(data: ReadableMap, promise: Promise) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.getRemoteVideoTrackFromTrackId(data, promise)
+  }
+
+  @ReactMethod
+  fun getRemoteAudioTrackFromTrackId(data: ReadableMap, promise: Promise) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.getRemoteAudioTrackFromTrackId(data, promise)
+  }
+
+  @ReactMethod
+  fun getVideoTrackLayer(data: ReadableMap, promise: Promise) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.getVideoTrackLayer(data, promise)
+  }
+
+  @ReactMethod
+  fun getVideoTrackLayerDefinition(data: ReadableMap, promise: Promise) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.getVideoTrackLayerDefinition(data, promise)
+  }
+
+  @ReactMethod
+  fun setVideoTrackLayer(data: ReadableMap, promise: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.setVideoTrackLayer(data, promise)
+  }
+
+  @ReactMethod
+  fun captureImageAtMaxSupportedResolution(data: ReadableMap, promise: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.captureImageAtMaxSupportedResolution(data, promise)
+  }
+
   fun emitEvent(event: String, data: WritableMap) {
     reactApplicationContext
       .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)