@100mslive/react-native-hms 1.0.0 → 1.1.0

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

@@ -20,10 +20,10 @@ import live.hms.video.utils.HMSCoroutineScope
 import live.hms.video.utils.HmsUtilities
 
 class HMSRNSDK(
-    data: ReadableMap?,
-    HmsDelegate: HMSManager,
-    sdkId: String,
-    reactApplicationContext: ReactApplicationContext
+  data: ReadableMap?,
+  HmsDelegate: HMSManager,
+  sdkId: String,
+  reactApplicationContext: ReactApplicationContext
 ) {
   var hmsSDK: HMSSDK? = null
   var screenshareCallback: Promise? = null
@@ -81,15 +81,15 @@ class HMSRNSDK(
   private fun emitRequiredKeysError(message: String) {
     val data: WritableMap = Arguments.createMap()
     val hmsError =
-        HMSException(
-            6002,
-            "REQUIRED_KEYS_NOT_FOUND",
-            "SEND_ALL_REQUIRED_KEYS",
-            message,
-            message,
-            null,
-            false
-        )
+      HMSException(
+        6002,
+        "REQUIRED_KEYS_NOT_FOUND",
+        "SEND_ALL_REQUIRED_KEYS",
+        message,
+        message,
+        null,
+        false
+      )
     data.putString("id", id)
     data.putMap("error", HMSDecoder.getError(hmsError))
     delegate.emitEvent("ON_ERROR", data)
@@ -108,7 +108,7 @@ class HMSRNSDK(
 
   fun emitHMSSuccess(message: HMSMessage? = null): ReadableMap {
     val hmsMessage =
-        if (message !== null) message.message else "function call executed successfully"
+      if (message !== null) message.message else "function call executed successfully"
     val data: WritableMap = Arguments.createMap()
     data.putBoolean("success", true)
     data.putString("message", hmsMessage)
@@ -121,72 +121,72 @@ class HMSRNSDK(
       return
     }
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(
-            credentials,
-            arrayOf(Pair("username", "String"), Pair("authToken", "String"))
-        )
+      HMSHelper.getUnavailableRequiredKey(
+        credentials,
+        arrayOf(Pair("username", "String"), Pair("authToken", "String"))
+      )
     if (requiredKeys === null) {
       previewInProgress = true
       val config = HMSHelper.getHmsConfig(credentials)
 
       hmsSDK?.preview(
-          config,
-          object : HMSPreviewListener {
-            override fun onError(error: HMSException) {
-              self.emitHMSError(error)
-              previewInProgress = false
-            }
+        config,
+        object : HMSPreviewListener {
+          override fun onError(error: HMSException) {
+            self.emitHMSError(error)
+            previewInProgress = false
+          }
 
-            override fun onPeerUpdate(type: HMSPeerUpdate, peer: HMSPeer) {
-              if (type === HMSPeerUpdate.AUDIO_TOGGLED ||
-                      type === HMSPeerUpdate.VIDEO_TOGGLED ||
-                      type === HMSPeerUpdate.BECAME_DOMINANT_SPEAKER ||
-                      type === HMSPeerUpdate.NO_DOMINANT_SPEAKER ||
-                      type === HMSPeerUpdate.RESIGNED_DOMINANT_SPEAKER ||
-                      type === HMSPeerUpdate.STARTED_SPEAKING ||
-                      type === HMSPeerUpdate.STOPPED_SPEAKING
-              ) {
-                return
-              }
-              if (!networkQualityUpdatesAttached && type === HMSPeerUpdate.NETWORK_QUALITY_UPDATED
-              ) {
-                return
-              }
-              val updateType = type.name
-              val hmsPeer = HMSDecoder.getHmsPeer(peer)
+          override fun onPeerUpdate(type: HMSPeerUpdate, peer: HMSPeer) {
+            if (type === HMSPeerUpdate.AUDIO_TOGGLED ||
+              type === HMSPeerUpdate.VIDEO_TOGGLED ||
+              type === HMSPeerUpdate.BECAME_DOMINANT_SPEAKER ||
+              type === HMSPeerUpdate.NO_DOMINANT_SPEAKER ||
+              type === HMSPeerUpdate.RESIGNED_DOMINANT_SPEAKER ||
+              type === HMSPeerUpdate.STARTED_SPEAKING ||
+              type === HMSPeerUpdate.STOPPED_SPEAKING
+            ) {
+              return
+            }
+            if (!networkQualityUpdatesAttached && type === HMSPeerUpdate.NETWORK_QUALITY_UPDATED
+            ) {
+              return
+            }
+            val updateType = type.name
+            val hmsPeer = HMSDecoder.getHmsPeer(peer)
 
-              val data: WritableMap = Arguments.createMap()
+            val data: WritableMap = Arguments.createMap()
 
-              data.putMap("peer", hmsPeer)
-              data.putString("type", updateType)
-              data.putString("id", id)
-              delegate.emitEvent("ON_PEER_UPDATE", data)
-            }
+            data.putMap("peer", hmsPeer)
+            data.putString("type", updateType)
+            data.putString("id", id)
+            delegate.emitEvent("ON_PEER_UPDATE", data)
+          }
 
-            override fun onRoomUpdate(type: HMSRoomUpdate, hmsRoom: HMSRoom) {
-              val updateType = type.name
-              val roomData = HMSDecoder.getHmsRoom(hmsRoom)
+          override fun onRoomUpdate(type: HMSRoomUpdate, hmsRoom: HMSRoom) {
+            val updateType = type.name
+            val roomData = HMSDecoder.getHmsRoom(hmsRoom)
 
-              val data: WritableMap = Arguments.createMap()
+            val data: WritableMap = Arguments.createMap()
 
-              data.putString("type", updateType)
-              data.putMap("room", roomData)
-              data.putString("id", id)
-              delegate.emitEvent("ON_ROOM_UPDATE", data)
-            }
+            data.putString("type", updateType)
+            data.putMap("room", roomData)
+            data.putString("id", id)
+            delegate.emitEvent("ON_ROOM_UPDATE", data)
+          }
 
-            override fun onPreview(room: HMSRoom, localTracks: Array<HMSTrack>) {
-              val previewTracks = HMSDecoder.getPreviewTracks(localTracks)
-              val hmsRoom = HMSDecoder.getHmsRoom(room)
-              val data: WritableMap = Arguments.createMap()
+          override fun onPreview(room: HMSRoom, localTracks: Array<HMSTrack>) {
+            val previewTracks = HMSDecoder.getPreviewTracks(localTracks)
+            val hmsRoom = HMSDecoder.getHmsRoom(room)
+            val data: WritableMap = Arguments.createMap()
 
-              data.putArray("previewTracks", previewTracks)
-              data.putMap("room", hmsRoom)
-              data.putString("id", id)
-              delegate.emitEvent("ON_PREVIEW", data)
-              previewInProgress = false
-            }
+            data.putArray("previewTracks", previewTracks)
+            data.putMap("room", hmsRoom)
+            data.putString("id", id)
+            delegate.emitEvent("ON_PREVIEW", data)
+            previewInProgress = false
           }
+        }
       )
     } else {
       val errorMessage = "preview: $requiredKeys"
@@ -200,10 +200,10 @@ class HMSRNSDK(
       return
     }
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(
-            credentials,
-            arrayOf(Pair("username", "String"), Pair("authToken", "String"))
-        )
+      HMSHelper.getUnavailableRequiredKey(
+        credentials,
+        arrayOf(Pair("username", "String"), Pair("authToken", "String"))
+      )
     if (requiredKeys === null) {
       reconnectingStage = false
       val config = HMSHelper.getHmsConfig(credentials)
@@ -211,264 +211,266 @@ class HMSRNSDK(
       HMSCoroutineScope.launch {
         try {
           hmsSDK?.join(
-              config,
-              object : HMSUpdateListener {
-                override fun onChangeTrackStateRequest(details: HMSChangeTrackStateRequest) {
-                  val decodedChangeTrackStateRequest =
-                      HMSDecoder.getHmsChangeTrackStateRequest(details, id)
-                  delegate.emitEvent(
-                      "ON_CHANGE_TRACK_STATE_REQUEST",
-                      decodedChangeTrackStateRequest
-                  )
-                }
+            config,
+            object : HMSUpdateListener {
+              override fun onChangeTrackStateRequest(details: HMSChangeTrackStateRequest) {
+                val decodedChangeTrackStateRequest =
+                  HMSDecoder.getHmsChangeTrackStateRequest(details, id)
+                delegate.emitEvent(
+                  "ON_CHANGE_TRACK_STATE_REQUEST",
+                  decodedChangeTrackStateRequest
+                )
+              }
 
-                override fun onRemovedFromRoom(notification: HMSRemovedFromRoom) {
-                  super.onRemovedFromRoom(notification)
+              override fun onRemovedFromRoom(notification: HMSRemovedFromRoom) {
+                super.onRemovedFromRoom(notification)
 
-                  val data: WritableMap = Arguments.createMap()
-                  val requestedBy =
-                      HMSDecoder.getHmsRemotePeer(notification.peerWhoRemoved as HMSRemotePeer?)
-                  val roomEnded = notification.roomWasEnded
-                  val reason = notification.reason
+                val data: WritableMap = Arguments.createMap()
+                val requestedBy =
+                  HMSDecoder.getHmsRemotePeer(notification.peerWhoRemoved as HMSRemotePeer?)
+                val roomEnded = notification.roomWasEnded
+                val reason = notification.reason
+
+                data.putMap("requestedBy", requestedBy)
+                data.putBoolean("roomEnded", roomEnded)
+                data.putString("reason", reason)
+                data.putString("id", id)
 
-                  data.putMap("requestedBy", requestedBy)
-                  data.putBoolean("roomEnded", roomEnded)
-                  data.putString("reason", reason)
-                  data.putString("id", id)
+                delegate.emitEvent("ON_REMOVED_FROM_ROOM", data)
+              }
 
-                  delegate.emitEvent("ON_REMOVED_FROM_ROOM", data)
-                }
+              override fun onError(error: HMSException) {
+                self.emitHMSError(error)
+              }
 
-                override fun onError(error: HMSException) {
-                  self.emitHMSError(error)
-                }
+              override fun onJoin(room: HMSRoom) {
+                val roomData = HMSDecoder.getHmsRoom(room)
 
-                override fun onJoin(room: HMSRoom) {
-                  val roomData = HMSDecoder.getHmsRoom(room)
+                val data: WritableMap = Arguments.createMap()
 
-                  val data: WritableMap = Arguments.createMap()
+                data.putMap("room", roomData)
+                data.putString("id", id)
+                delegate.emitEvent("ON_JOIN", data)
+              }
 
-                  data.putMap("room", roomData)
-                  data.putString("id", id)
-                  delegate.emitEvent("ON_JOIN", data)
+              override fun onPeerUpdate(type: HMSPeerUpdate, peer: HMSPeer) {
+                if (type === HMSPeerUpdate.AUDIO_TOGGLED ||
+                  type === HMSPeerUpdate.VIDEO_TOGGLED ||
+                  type === HMSPeerUpdate.BECAME_DOMINANT_SPEAKER ||
+                  type === HMSPeerUpdate.NO_DOMINANT_SPEAKER ||
+                  type === HMSPeerUpdate.RESIGNED_DOMINANT_SPEAKER ||
+                  type === HMSPeerUpdate.STARTED_SPEAKING ||
+                  type === HMSPeerUpdate.STOPPED_SPEAKING
+                ) {
+                  return
                 }
-
-                override fun onPeerUpdate(type: HMSPeerUpdate, peer: HMSPeer) {
-                  if (type === HMSPeerUpdate.AUDIO_TOGGLED ||
-                          type === HMSPeerUpdate.VIDEO_TOGGLED ||
-                          type === HMSPeerUpdate.BECAME_DOMINANT_SPEAKER ||
-                          type === HMSPeerUpdate.NO_DOMINANT_SPEAKER ||
-                          type === HMSPeerUpdate.RESIGNED_DOMINANT_SPEAKER ||
-                          type === HMSPeerUpdate.STARTED_SPEAKING ||
-                          type === HMSPeerUpdate.STOPPED_SPEAKING
-                  ) {
-                    return
-                  }
-                  if (!networkQualityUpdatesAttached &&
-                          type === HMSPeerUpdate.NETWORK_QUALITY_UPDATED
-                  ) {
-                    return
-                  }
-                  val updateType = type.name
-                  val hmsPeer = HMSDecoder.getHmsPeer(peer)
-
-                  val data: WritableMap = Arguments.createMap()
-
-                  data.putMap("peer", hmsPeer)
-                  data.putString("type", updateType)
-                  data.putString("id", id)
-                  delegate.emitEvent("ON_PEER_UPDATE", data)
+                if (!networkQualityUpdatesAttached &&
+                  type === HMSPeerUpdate.NETWORK_QUALITY_UPDATED
+                ) {
+                  return
                 }
+                val updateType = type.name
+                val hmsPeer = HMSDecoder.getHmsPeer(peer)
 
-                override fun onRoomUpdate(type: HMSRoomUpdate, hmsRoom: HMSRoom) {
-                  val updateType = type.name
-                  val roomData = HMSDecoder.getHmsRoom(hmsRoom)
+                val data: WritableMap = Arguments.createMap()
 
-                  val data: WritableMap = Arguments.createMap()
+                data.putMap("peer", hmsPeer)
+                data.putString("type", updateType)
+                data.putString("id", id)
+                delegate.emitEvent("ON_PEER_UPDATE", data)
+              }
 
-                  data.putString("type", updateType)
-                  data.putMap("room", roomData)
-                  data.putString("id", id)
-                  delegate.emitEvent("ON_ROOM_UPDATE", data)
-                }
+              override fun onRoomUpdate(type: HMSRoomUpdate, hmsRoom: HMSRoom) {
+                val updateType = type.name
+                val roomData = HMSDecoder.getHmsRoom(hmsRoom)
 
-                override fun onTrackUpdate(type: HMSTrackUpdate, track: HMSTrack, peer: HMSPeer) {
-                  val updateType = type.name
-                  val hmsPeer = HMSDecoder.getHmsPeer(peer)
-                  val hmsTrack = HMSDecoder.getHmsTrack(track)
+                val data: WritableMap = Arguments.createMap()
 
-                  val data: WritableMap = Arguments.createMap()
+                data.putString("type", updateType)
+                data.putMap("room", roomData)
+                data.putString("id", id)
+                delegate.emitEvent("ON_ROOM_UPDATE", data)
+              }
 
-                  data.putMap("peer", hmsPeer)
-                  data.putMap("track", hmsTrack)
-                  data.putString("type", updateType)
-                  data.putString("id", id)
-                  delegate.emitEvent("ON_TRACK_UPDATE", data)
-                }
+              override fun onTrackUpdate(type: HMSTrackUpdate, track: HMSTrack, peer: HMSPeer) {
+                val updateType = type.name
+                val hmsPeer = HMSDecoder.getHmsPeer(peer)
+                val hmsTrack = HMSDecoder.getHmsTrack(track)
 
-                override fun onMessageReceived(message: HMSMessage) {
-                  val data: WritableMap = Arguments.createMap()
+                val data: WritableMap = Arguments.createMap()
 
-                  data.putMap("sender", HMSDecoder.getHmsPeer(message.sender))
-                  data.putString("message", message.message)
-                  data.putString("type", message.type)
-                  data.putString("time", message.serverReceiveTime.toString())
-                  data.putString("id", id)
-                  data.putMap("recipient", HMSDecoder.getHmsMessageRecipient(message.recipient))
+                data.putMap("peer", hmsPeer)
+                data.putMap("track", hmsTrack)
+                data.putString("type", updateType)
+                data.putString("id", id)
+                delegate.emitEvent("ON_TRACK_UPDATE", data)
+              }
 
-                  delegate.emitEvent("ON_MESSAGE", data)
-                }
+              override fun onMessageReceived(message: HMSMessage) {
+                val data: WritableMap = Arguments.createMap()
 
-                override fun onReconnected() {
-                  reconnectingStage = false
-                  val data: WritableMap = Arguments.createMap()
-                  data.putString("event", "RECONNECTED")
-                  data.putString("id", id)
-                  delegate.emitEvent("RECONNECTED", data)
-                }
+                data.putMap("sender", HMSDecoder.getHmsPeer(message.sender))
+                data.putString("message", message.message)
+                data.putString("type", message.type)
+                data.putString("time", message.serverReceiveTime.toString())
+                data.putString("id", id)
+                data.putMap("recipient", HMSDecoder.getHmsMessageRecipient(message.recipient))
 
-                override fun onReconnecting(error: HMSException) {
-                  reconnectingStage = true
-                  val data: WritableMap = Arguments.createMap()
-                  data.putMap("error", HMSDecoder.getError(error))
-                  data.putString("event", "RECONNECTING")
-                  data.putString("id", id)
-                  delegate.emitEvent("RECONNECTING", data)
-                }
+                delegate.emitEvent("ON_MESSAGE", data)
+              }
 
-                override fun onRoleChangeRequest(request: HMSRoleChangeRequest) {
-                  val decodedChangeRoleRequest = HMSDecoder.getHmsRoleChangeRequest(request, id)
-                  delegate.emitEvent("ON_ROLE_CHANGE_REQUEST", decodedChangeRoleRequest)
-                  recentRoleChangeRequest = request
-                }
+              override fun onReconnected() {
+                reconnectingStage = false
+                val data: WritableMap = Arguments.createMap()
+                data.putString("event", "RECONNECTED")
+                data.putString("id", id)
+                delegate.emitEvent("RECONNECTED", data)
+              }
+
+              override fun onReconnecting(error: HMSException) {
+                reconnectingStage = true
+                val data: WritableMap = Arguments.createMap()
+                data.putMap("error", HMSDecoder.getError(error))
+                data.putString("event", "RECONNECTING")
+                data.putString("id", id)
+                delegate.emitEvent("RECONNECTING", data)
+              }
+
+              override fun onRoleChangeRequest(request: HMSRoleChangeRequest) {
+                val decodedChangeRoleRequest = HMSDecoder.getHmsRoleChangeRequest(request, id)
+                delegate.emitEvent("ON_ROLE_CHANGE_REQUEST", decodedChangeRoleRequest)
+                recentRoleChangeRequest = request
               }
+            }
           )
         } catch (e: HMSException) {
           self.emitHMSError(e)
         }
 
         hmsSDK?.addAudioObserver(
-            object : HMSAudioListener {
-              override fun onAudioLevelUpdate(speakers: Array<HMSSpeaker>) {
-                val data: WritableMap = Arguments.createMap()
-                data.putString("event", "ON_SPEAKER")
+          object : HMSAudioListener {
+            override fun onAudioLevelUpdate(speakers: Array<HMSSpeaker>) {
+              val data: WritableMap = Arguments.createMap()
+              data.putString("event", "ON_SPEAKER")
 
-                val peers: WritableArray = Arguments.createArray()
-                for (speaker in speakers) {
+              val peers: WritableArray = Arguments.createArray()
+              for (speaker in speakers) {
+                speaker.peer?.let {
                   val speakerArray: WritableMap = Arguments.createMap()
-                  speakerArray.putMap("peer", HMSDecoder.getHmsPeer(speaker.peer))
+                  speakerArray.putMap("peer", HMSDecoder.getHmsPeer(it))
                   speakerArray.putInt("level", speaker.level)
                   speakerArray.putMap("track", HMSDecoder.getHmsTrack(speaker.hmsTrack))
                   peers.pushMap(speakerArray)
                 }
-                data.putArray("speakers", peers)
-                data.putString("id", id)
-                delegate.emitEvent("ON_SPEAKER", data)
               }
+              data.putArray("speakers", peers)
+              data.putString("id", id)
+              delegate.emitEvent("ON_SPEAKER", data)
             }
+          }
         )
 
         hmsSDK?.addRtcStatsObserver(
-            object : HMSStatsObserver {
-              override fun onLocalAudioStats(
-                  audioStats: HMSLocalAudioStats,
-                  hmsTrack: HMSTrack?,
-                  hmsPeer: HMSPeer?
-              ) {
-                if (!rtcStatsAttached) {
-                  return
-                }
-                val localAudioStats = HMSDecoder.getLocalAudioStats(audioStats)
-                val track = HMSDecoder.getHmsLocalAudioTrack(hmsTrack as HMSLocalAudioTrack)
-                val peer = HMSDecoder.getHmsPeer(hmsPeer)
+          object : HMSStatsObserver {
+            override fun onLocalAudioStats(
+              audioStats: HMSLocalAudioStats,
+              hmsTrack: HMSTrack?,
+              hmsPeer: HMSPeer?
+            ) {
+              if (!rtcStatsAttached) {
+                return
+              }
+              val localAudioStats = HMSDecoder.getLocalAudioStats(audioStats)
+              val track = HMSDecoder.getHmsLocalAudioTrack(hmsTrack as HMSLocalAudioTrack)
+              val peer = HMSDecoder.getHmsPeer(hmsPeer)
 
-                val data: WritableMap = Arguments.createMap()
-                data.putMap("localAudioStats", localAudioStats)
-                data.putMap("track", track)
-                data.putMap("peer", peer)
-                data.putString("id", id)
-                delegate.emitEvent("ON_LOCAL_AUDIO_STATS", data)
+              val data: WritableMap = Arguments.createMap()
+              data.putMap("localAudioStats", localAudioStats)
+              data.putMap("track", track)
+              data.putMap("peer", peer)
+              data.putString("id", id)
+              delegate.emitEvent("ON_LOCAL_AUDIO_STATS", data)
+            }
+
+            override fun onLocalVideoStats(
+              videoStats: HMSLocalVideoStats,
+              hmsTrack: HMSTrack?,
+              hmsPeer: HMSPeer?
+            ) {
+              if (!rtcStatsAttached) {
+                return
               }
 
-              override fun onLocalVideoStats(
-                  videoStats: HMSLocalVideoStats,
-                  hmsTrack: HMSTrack?,
-                  hmsPeer: HMSPeer?
-              ) {
-                if (!rtcStatsAttached) {
-                  return
-                }
+              val localVideoStats = HMSDecoder.getLocalVideoStats(videoStats)
+              val track = HMSDecoder.getHmsLocalVideoTrack(hmsTrack as HMSLocalVideoTrack)
+              val peer = HMSDecoder.getHmsPeer(hmsPeer)
 
-                val localVideoStats = HMSDecoder.getLocalVideoStats(videoStats)
-                val track = HMSDecoder.getHmsLocalVideoTrack(hmsTrack as HMSLocalVideoTrack)
-                val peer = HMSDecoder.getHmsPeer(hmsPeer)
+              val data: WritableMap = Arguments.createMap()
+              data.putMap("localVideoStats", localVideoStats)
+              data.putMap("track", track)
+              data.putMap("peer", peer)
+              data.putString("id", id)
+              delegate.emitEvent("ON_LOCAL_VIDEO_STATS", data)
+            }
 
-                val data: WritableMap = Arguments.createMap()
-                data.putMap("localVideoStats", localVideoStats)
-                data.putMap("track", track)
-                data.putMap("peer", peer)
-                data.putString("id", id)
-                delegate.emitEvent("ON_LOCAL_VIDEO_STATS", data)
+            override fun onRTCStats(rtcStats: HMSRTCStatsReport) {
+              if (!rtcStatsAttached) {
+                return
               }
+              val video = HMSDecoder.getHMSRTCStats(rtcStats.video)
+              val audio = HMSDecoder.getHMSRTCStats(rtcStats.audio)
+              val combined = HMSDecoder.getHMSRTCStats(rtcStats.combined)
 
-              override fun onRTCStats(rtcStats: HMSRTCStatsReport) {
-                if (!rtcStatsAttached) {
-                  return
-                }
-                val video = HMSDecoder.getHMSRTCStats(rtcStats.video)
-                val audio = HMSDecoder.getHMSRTCStats(rtcStats.audio)
-                val combined = HMSDecoder.getHMSRTCStats(rtcStats.combined)
+              val data: WritableMap = Arguments.createMap()
+              data.putMap("video", video)
+              data.putMap("audio", audio)
+              data.putMap("combined", combined)
+              data.putString("id", id)
+              delegate.emitEvent("ON_RTC_STATS", data)
+            }
 
-                val data: WritableMap = Arguments.createMap()
-                data.putMap("video", video)
-                data.putMap("audio", audio)
-                data.putMap("combined", combined)
-                data.putString("id", id)
-                delegate.emitEvent("ON_RTC_STATS", data)
+            override fun onRemoteAudioStats(
+              audioStats: HMSRemoteAudioStats,
+              hmsTrack: HMSTrack?,
+              hmsPeer: HMSPeer?
+            ) {
+              if (!rtcStatsAttached) {
+                return
               }
 
-              override fun onRemoteAudioStats(
-                  audioStats: HMSRemoteAudioStats,
-                  hmsTrack: HMSTrack?,
-                  hmsPeer: HMSPeer?
-              ) {
-                if (!rtcStatsAttached) {
-                  return
-                }
+              val remoteAudioStats = HMSDecoder.getRemoteAudioStats(audioStats)
+              val track = HMSDecoder.getHmsRemoteAudioTrack(hmsTrack as HMSRemoteAudioTrack)
+              val peer = HMSDecoder.getHmsPeer(hmsPeer)
 
-                val remoteAudioStats = HMSDecoder.getRemoteAudioStats(audioStats)
-                val track = HMSDecoder.getHmsRemoteAudioTrack(hmsTrack as HMSRemoteAudioTrack)
-                val peer = HMSDecoder.getHmsPeer(hmsPeer)
+              val data: WritableMap = Arguments.createMap()
+              data.putMap("remoteAudioStats", remoteAudioStats)
+              data.putMap("track", track)
+              data.putMap("peer", peer)
+              data.putString("id", id)
+              delegate.emitEvent("ON_REMOTE_AUDIO_STATS", data)
+            }
 
-                val data: WritableMap = Arguments.createMap()
-                data.putMap("remoteAudioStats", remoteAudioStats)
-                data.putMap("track", track)
-                data.putMap("peer", peer)
-                data.putString("id", id)
-                delegate.emitEvent("ON_REMOTE_AUDIO_STATS", data)
+            override fun onRemoteVideoStats(
+              videoStats: HMSRemoteVideoStats,
+              hmsTrack: HMSTrack?,
+              hmsPeer: HMSPeer?
+            ) {
+              if (!rtcStatsAttached) {
+                return
               }
 
-              override fun onRemoteVideoStats(
-                  videoStats: HMSRemoteVideoStats,
-                  hmsTrack: HMSTrack?,
-                  hmsPeer: HMSPeer?
-              ) {
-                if (!rtcStatsAttached) {
-                  return
-                }
+              val remoteVideoStats = HMSDecoder.getRemoteVideoStats(videoStats)
+              val track = HMSDecoder.getHmsRemoteVideoTrack(hmsTrack as HMSRemoteVideoTrack)
+              val peer = HMSDecoder.getHmsPeer(hmsPeer)
 
-                val remoteVideoStats = HMSDecoder.getRemoteVideoStats(videoStats)
-                val track = HMSDecoder.getHmsRemoteVideoTrack(hmsTrack as HMSRemoteVideoTrack)
-                val peer = HMSDecoder.getHmsPeer(hmsPeer)
-
-                val data: WritableMap = Arguments.createMap()
-                data.putMap("remoteVideoStats", remoteVideoStats)
-                data.putMap("track", track)
-                data.putMap("peer", peer)
-                data.putString("id", id)
-                delegate.emitEvent("ON_REMOTE_VIDEO_STATS", data)
-              }
+              val data: WritableMap = Arguments.createMap()
+              data.putMap("remoteVideoStats", remoteVideoStats)
+              data.putMap("track", track)
+              data.putMap("peer", peer)
+              data.putString("id", id)
+              delegate.emitEvent("ON_REMOTE_VIDEO_STATS", data)
             }
+          }
         )
       }
     } else {
@@ -493,49 +495,65 @@ class HMSRNSDK(
     }
   }
 
-  fun leave(callback: Promise?) {
+  fun leave(callback: Promise?, fromPIP: Boolean = false) {
     if (reconnectingStage) {
-      callback?.reject("101", "Still in reconnecting stage")
+      val errorMessage = "Still in reconnecting stage"
+
+      if (fromPIP) {
+        self.emitHMSError(HMSException(101, errorMessage, "PIP Action", "Leave called from PIP Window", "HMSRNSDK #Function leave"))
+      } else {
+        callback?.reject("101", errorMessage)
+      }
     } else {
       hmsSDK?.leave(
-          object : HMSActionResultListener {
-            override fun onSuccess() {
-              isAudioSharing = false
-              screenshareCallback = null
-              audioshareCallback = null
-              networkQualityUpdatesAttached = false
-              rtcStatsAttached = false
+        object : HMSActionResultListener {
+          override fun onSuccess() {
+            isAudioSharing = false
+            screenshareCallback = null
+            audioshareCallback = null
+            networkQualityUpdatesAttached = false
+            rtcStatsAttached = false
+            if (fromPIP) {
+              context.currentActivity?.moveTaskToBack(false)
+
+              val map: WritableMap = Arguments.createMap()
+              map.putString("id", id)
+              delegate.emitEvent("ON_PIP_ROOM_LEAVE", map)
+            } else {
               callback?.resolve(emitHMSSuccess())
             }
+          }
 
-            override fun onError(error: HMSException) {
+          override fun onError(error: HMSException) {
+            if (!fromPIP) {
               callback?.reject(error.code.toString(), error.message)
-              self.emitHMSError(error)
             }
+            self.emitHMSError(error)
           }
+        }
       )
     }
   }
 
   fun sendBroadcastMessage(data: ReadableMap, callback: Promise?) {
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(
-            data,
-            arrayOf(Pair("message", "String"), Pair("type", "String"))
-        )
+      HMSHelper.getUnavailableRequiredKey(
+        data,
+        arrayOf(Pair("message", "String"), Pair("type", "String"))
+      )
     if (requiredKeys === null) {
       hmsSDK?.sendBroadcastMessage(
-          data.getString("message") as String,
-          data.getString("type") as String,
-          object : HMSMessageResultListener {
-            override fun onError(error: HMSException) {
-              self.emitHMSError(error)
-              callback?.reject(error.code.toString(), error.message)
-            }
-            override fun onSuccess(hmsMessage: HMSMessage) {
-              callback?.resolve(emitHMSSuccess(hmsMessage))
-            }
+        data.getString("message") as String,
+        data.getString("type") as String,
+        object : HMSMessageResultListener {
+          override fun onError(error: HMSException) {
+            self.emitHMSError(error)
+            callback?.reject(error.code.toString(), error.message)
+          }
+          override fun onSuccess(hmsMessage: HMSMessage) {
+            callback?.resolve(emitHMSSuccess(hmsMessage))
           }
+        }
       )
     } else {
       val errorMessage = "sendBroadcastMessage: $requiredKeys"
@@ -546,28 +564,28 @@ class HMSRNSDK(
 
   fun sendGroupMessage(data: ReadableMap, callback: Promise?) {
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(
-            data,
-            arrayOf(Pair("message", "String"), Pair("roles", "Array"), Pair("type", "String"))
-        )
+      HMSHelper.getUnavailableRequiredKey(
+        data,
+        arrayOf(Pair("message", "String"), Pair("roles", "Array"), Pair("type", "String"))
+      )
     if (requiredKeys === null) {
       val targetedRoles = data.getArray("roles")?.toArrayList() as? ArrayList<String>
       val roles = hmsSDK?.getRoles()
       val encodedTargetedRoles = HMSHelper.getRolesFromRoleNames(targetedRoles, roles)
 
       hmsSDK?.sendGroupMessage(
-          data.getString("message") as String,
-          data.getString("type") as String,
-          encodedTargetedRoles,
-          object : HMSMessageResultListener {
-            override fun onError(error: HMSException) {
-              self.emitHMSError(error)
-              callback?.reject(error.code.toString(), error.message)
-            }
-            override fun onSuccess(hmsMessage: HMSMessage) {
-              callback?.resolve(emitHMSSuccess(hmsMessage))
-            }
+        data.getString("message") as String,
+        data.getString("type") as String,
+        encodedTargetedRoles,
+        object : HMSMessageResultListener {
+          override fun onError(error: HMSException) {
+            self.emitHMSError(error)
+            callback?.reject(error.code.toString(), error.message)
           }
+          override fun onSuccess(hmsMessage: HMSMessage) {
+            callback?.resolve(emitHMSSuccess(hmsMessage))
+          }
+        }
       )
     } else {
       val errorMessage = "sendGroupMessage: $requiredKeys"
@@ -578,27 +596,27 @@ class HMSRNSDK(
 
   fun sendDirectMessage(data: ReadableMap, callback: Promise?) {
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(
-            data,
-            arrayOf(Pair("message", "String"), Pair("peerId", "String"), Pair("type", "String"))
-        )
+      HMSHelper.getUnavailableRequiredKey(
+        data,
+        arrayOf(Pair("message", "String"), Pair("peerId", "String"), Pair("type", "String"))
+      )
     if (requiredKeys === null) {
       val peerId = data.getString("peerId")
       val peer = HMSHelper.getPeerFromPeerId(peerId, hmsSDK?.getRoom())
       if (peer != null) {
         hmsSDK?.sendDirectMessage(
-            data.getString("message") as String,
-            data.getString("type") as String,
-            peer,
-            object : HMSMessageResultListener {
-              override fun onError(error: HMSException) {
-                self.emitHMSError(error)
-                callback?.reject(error.code.toString(), error.message)
-              }
-              override fun onSuccess(hmsMessage: HMSMessage) {
-                callback?.resolve(emitHMSSuccess(hmsMessage))
-              }
+          data.getString("message") as String,
+          data.getString("type") as String,
+          peer,
+          object : HMSMessageResultListener {
+            override fun onError(error: HMSException) {
+              self.emitHMSError(error)
+              callback?.reject(error.code.toString(), error.message)
             }
+            override fun onSuccess(hmsMessage: HMSMessage) {
+              callback?.resolve(emitHMSSuccess(hmsMessage))
+            }
+          }
         )
       } else {
         self.emitCustomError("PEER_NOT_FOUND")
@@ -611,12 +629,13 @@ class HMSRNSDK(
     }
   }
 
+  @kotlin.Deprecated("Use #Function changeRoleOfPeer instead")
   fun changeRole(data: ReadableMap, callback: Promise?) {
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(
-            data,
-            arrayOf(Pair("peerId", "String"), Pair("role", "String"), Pair("force", "Boolean"))
-        )
+      HMSHelper.getUnavailableRequiredKey(
+        data,
+        arrayOf(Pair("peerId", "String"), Pair("role", "String"), Pair("force", "Boolean"))
+      )
     if (requiredKeys === null) {
       val peerId = data.getString("peerId")
       val role = data.getString("role")
@@ -628,18 +647,18 @@ class HMSRNSDK(
 
         if (hmsRole != null && hmsPeer != null) {
           hmsSDK?.changeRole(
-              hmsPeer,
-              hmsRole,
-              force,
-              object : HMSActionResultListener {
-                override fun onSuccess() {
-                  callback?.resolve(emitHMSSuccess())
-                }
-                override fun onError(error: HMSException) {
-                  self.emitHMSError(error)
-                  callback?.reject(error.code.toString(), error.message)
-                }
+            hmsPeer,
+            hmsRole,
+            force,
+            object : HMSActionResultListener {
+              override fun onSuccess() {
+                callback?.resolve(emitHMSSuccess())
+              }
+              override fun onError(error: HMSException) {
+                self.emitHMSError(error)
+                callback?.reject(error.code.toString(), error.message)
               }
+            }
           )
         }
       }
@@ -650,29 +669,109 @@ class HMSRNSDK(
     }
   }
 
-  fun changeTrackState(data: ReadableMap, callback: Promise?) {
+  fun changeRoleOfPeer(data: ReadableMap, promise: Promise?) {
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(
-            data,
-            arrayOf(Pair("trackId", "String"), Pair("mute", "Boolean"))
-        )
+      HMSHelper.getUnavailableRequiredKey(
+        data,
+        arrayOf(Pair("peerId", "String"), Pair("role", "String"), Pair("force", "Boolean"))
+      )
     if (requiredKeys === null) {
-      val trackId = data.getString("trackId")
-      val mute = data.getBoolean("mute")
-      val track = HMSHelper.getTrackFromTrackId(trackId, hmsSDK?.getRoom())
-      if (track != null) {
-        hmsSDK?.changeTrackState(
-            track,
-            mute,
+      val peerId = data.getString("peerId")
+      val role = data.getString("role")
+      val force = data.getBoolean("force")
+
+      if (peerId !== null && role !== null) {
+        val hmsPeer = HMSHelper.getPeerFromPeerId(peerId, hmsSDK?.getRoom())
+        val hmsRole = HMSHelper.getRoleFromRoleName(role, hmsSDK?.getRoles())
+
+        if (hmsRole != null && hmsPeer != null) {
+          hmsSDK?.changeRoleOfPeer(
+            hmsPeer,
+            hmsRole,
+            force,
             object : HMSActionResultListener {
               override fun onSuccess() {
-                callback?.resolve(emitHMSSuccess())
+                promise?.resolve(emitHMSSuccess())
               }
               override fun onError(error: HMSException) {
                 self.emitHMSError(error)
-                callback?.reject(error.code.toString(), error.message)
+                promise?.reject(error.code.toString(), error.message)
               }
             }
+          )
+        }
+      }
+    } else {
+      val errorMessage = "changeRoleOfPeer: $requiredKeys"
+      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(promise, errorMessage)
+    }
+  }
+
+  fun changeRoleOfPeersWithRoles(data: ReadableMap, promise: Promise?) {
+    val requiredKeys =
+      HMSHelper.getUnavailableRequiredKey(
+        data,
+        arrayOf(Pair("ofRoles", "Array"), Pair("toRole", "String"))
+      )
+    if (requiredKeys === null) {
+      val ofRoles = data.getArray("ofRoles")
+      val toRole = data.getString("toRole")
+
+      if (ofRoles !== null && toRole !== null) {
+        val hmsRoles = hmsSDK?.getRoles()
+
+        val ofRolesArrayList = ArrayList(ofRoles.toArrayList().map { it.toString() })
+
+        val ofHMSRoles = HMSHelper.getRolesFromRoleNames(ofRolesArrayList, hmsRoles)
+        val toHMSRole = HMSHelper.getRoleFromRoleName(toRole, hmsRoles)
+
+        if (toHMSRole !== null) {
+          hmsSDK?.changeRoleOfPeersWithRoles(
+            ofHMSRoles,
+            toHMSRole,
+            object : HMSActionResultListener {
+              override fun onSuccess() {
+                promise?.resolve(emitHMSSuccess())
+              }
+              override fun onError(error: HMSException) {
+                self.emitHMSError(error)
+                promise?.reject(error.code.toString(), error.message)
+              }
+            }
+          )
+        }
+      }
+    } else {
+      val errorMessage = "changeRoleOfPeersWithRoles: $requiredKeys"
+      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(promise, errorMessage)
+    }
+  }
+
+  fun changeTrackState(data: ReadableMap, callback: Promise?) {
+    val requiredKeys =
+      HMSHelper.getUnavailableRequiredKey(
+        data,
+        arrayOf(Pair("trackId", "String"), Pair("mute", "Boolean"))
+      )
+    if (requiredKeys === null) {
+      val trackId = data.getString("trackId")
+      val mute = data.getBoolean("mute")
+      val track = HMSHelper.getTrackFromTrackId(trackId, hmsSDK?.getRoom())
+      if (track != null) {
+        hmsSDK?.changeTrackState(
+          track,
+          mute,
+          object : HMSActionResultListener {
+            override fun onSuccess() {
+              callback?.resolve(emitHMSSuccess())
+            }
+            override fun onError(error: HMSException) {
+              self.emitHMSError(error)
+              callback?.reject(error.code.toString(), error.message)
+            }
+          }
         )
       }
     } else {
@@ -687,40 +786,43 @@ class HMSRNSDK(
     if (requiredKeys === null) {
       val mute: Boolean = data.getBoolean("mute")
       val type =
-          if (HMSHelper.areAllRequiredKeysAvailable(data, arrayOf(Pair("type", "String")))) {
-            if (data.getString("type") == HMSTrackType.AUDIO.toString()) HMSTrackType.AUDIO
-            else HMSTrackType.VIDEO
+        if (HMSHelper.areAllRequiredKeysAvailable(data, arrayOf(Pair("type", "String")))) {
+          if (data.getString("type") == HMSTrackType.AUDIO.toString()) {
+            HMSTrackType.AUDIO
           } else {
-            null
+            HMSTrackType.VIDEO
           }
+        } else {
+          null
+        }
       val source =
-          if (HMSHelper.areAllRequiredKeysAvailable(data, arrayOf(Pair("source", "String")))) {
-            data.getString("source")
-          } else {
-            null
-          }
+        if (HMSHelper.areAllRequiredKeysAvailable(data, arrayOf(Pair("source", "String")))) {
+          data.getString("source")
+        } else {
+          null
+        }
       val targetedRoles =
-          if (HMSHelper.areAllRequiredKeysAvailable(data, arrayOf(Pair("roles", "Array")))) {
-            data.getArray("roles")?.toArrayList() as? ArrayList<String>
-          } else {
-            null
-          }
+        if (HMSHelper.areAllRequiredKeysAvailable(data, arrayOf(Pair("roles", "Array")))) {
+          data.getArray("roles")?.toArrayList() as? ArrayList<String>
+        } else {
+          null
+        }
       val roles = hmsSDK?.getRoles()
       val encodedTargetedRoles = HMSHelper.getRolesFromRoleNames(targetedRoles, roles)
       hmsSDK?.changeTrackState(
-          mute,
-          type,
-          source,
-          encodedTargetedRoles,
-          object : HMSActionResultListener {
-            override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
-            }
-            override fun onError(error: HMSException) {
-              self.emitHMSError(error)
-              callback?.reject(error.code.toString(), error.message)
-            }
+        mute,
+        type,
+        source,
+        encodedTargetedRoles,
+        object : HMSActionResultListener {
+          override fun onSuccess() {
+            callback?.resolve(emitHMSSuccess())
+          }
+          override fun onError(error: HMSException) {
+            self.emitHMSError(error)
+            callback?.reject(error.code.toString(), error.message)
           }
+        }
       )
     } else {
       val errorMessage = "changeTrackStateForRoles: $requiredKeys"
@@ -749,27 +851,27 @@ class HMSRNSDK(
 
   fun removePeer(data: ReadableMap, callback: Promise?) {
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(
-            data,
-            arrayOf(Pair("peerId", "String"), Pair("reason", "String"))
-        )
+      HMSHelper.getUnavailableRequiredKey(
+        data,
+        arrayOf(Pair("peerId", "String"), Pair("reason", "String"))
+      )
     if (requiredKeys === null) {
       val peerId = data.getString("peerId")
       val peer = HMSHelper.getRemotePeerFromPeerId(peerId, hmsSDK?.getRoom())
 
       if (peer != null) {
         hmsSDK?.removePeerRequest(
-            peer,
-            data.getString("reason") as String,
-            object : HMSActionResultListener {
-              override fun onSuccess() {
-                callback?.resolve(emitHMSSuccess())
-              }
-              override fun onError(error: HMSException) {
-                self.emitHMSError(error)
-                callback?.reject(error.code.toString(), error.message)
-              }
+          peer,
+          data.getString("reason") as String,
+          object : HMSActionResultListener {
+            override fun onSuccess() {
+              callback?.resolve(emitHMSSuccess())
             }
+            override fun onError(error: HMSException) {
+              self.emitHMSError(error)
+              callback?.reject(error.code.toString(), error.message)
+            }
+          }
         )
       } else {
         self.emitCustomError("PEER_NOT_FOUND")
@@ -784,23 +886,23 @@ class HMSRNSDK(
 
   fun endRoom(data: ReadableMap, callback: Promise?) {
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(
-            data,
-            arrayOf(Pair("lock", "Boolean"), Pair("reason", "String"))
-        )
+      HMSHelper.getUnavailableRequiredKey(
+        data,
+        arrayOf(Pair("lock", "Boolean"), Pair("reason", "String"))
+      )
     if (requiredKeys === null) {
       hmsSDK?.endRoom(
-          data.getString("reason") as String,
-          data.getBoolean("lock"),
-          object : HMSActionResultListener {
-            override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
-            }
-            override fun onError(error: HMSException) {
-              self.emitHMSError(error)
-              callback?.reject(error.code.toString(), error.message)
-            }
+        data.getString("reason") as String,
+        data.getBoolean("lock"),
+        object : HMSActionResultListener {
+          override fun onSuccess() {
+            callback?.resolve(emitHMSSuccess())
+          }
+          override fun onError(error: HMSException) {
+            self.emitHMSError(error)
+            callback?.reject(error.code.toString(), error.message)
           }
+        }
       )
     } else {
       val errorMessage = "endRoom: $requiredKeys"
@@ -812,16 +914,16 @@ class HMSRNSDK(
   fun acceptRoleChange(callback: Promise?) {
     if (recentRoleChangeRequest !== null) {
       hmsSDK?.acceptChangeRole(
-          recentRoleChangeRequest!!,
-          object : HMSActionResultListener {
-            override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
-            }
-            override fun onError(error: HMSException) {
-              self.emitHMSError(error)
-              callback?.reject(error.code.toString(), error.message)
-            }
+        recentRoleChangeRequest!!,
+        object : HMSActionResultListener {
+          override fun onSuccess() {
+            callback?.resolve(emitHMSSuccess())
+          }
+          override fun onError(error: HMSException) {
+            self.emitHMSError(error)
+            callback?.reject(error.code.toString(), error.message)
           }
+        }
       )
       recentRoleChangeRequest = null
     } else {
@@ -837,14 +939,14 @@ class HMSRNSDK(
       var customError: HMSException? = null
       for (audioTrack in allAudioTracks) {
         hmsSDK?.changeTrackState(
-            audioTrack,
-            true,
-            object : HMSActionResultListener {
-              override fun onSuccess() {}
-              override fun onError(error: HMSException) {
-                customError = error
-              }
+          audioTrack,
+          true,
+          object : HMSActionResultListener {
+            override fun onSuccess() {}
+            override fun onError(error: HMSException) {
+              customError = error
             }
+          }
         )
       }
       if (customError === null) {
@@ -885,10 +987,10 @@ class HMSRNSDK(
 
   fun setPlaybackAllowed(data: ReadableMap) {
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(
-            data,
-            arrayOf(Pair("trackId", "String"), Pair("playbackAllowed", "Boolean"))
-        )
+      HMSHelper.getUnavailableRequiredKey(
+        data,
+        arrayOf(Pair("trackId", "String"), Pair("playbackAllowed", "Boolean"))
+      )
     if (requiredKeys === null) {
       val trackId = data.getString("trackId")
       val playbackAllowed = data.getBoolean("playbackAllowed")
@@ -953,10 +1055,10 @@ class HMSRNSDK(
 
   fun setVolume(data: ReadableMap) {
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(
-            data,
-            arrayOf(Pair("trackId", "String"), Pair("volume", "Float"))
-        )
+      HMSHelper.getUnavailableRequiredKey(
+        data,
+        arrayOf(Pair("trackId", "String"), Pair("volume", "Float"))
+      )
 
     if (requiredKeys === null) {
       val trackId = data.getString("trackId")
@@ -1016,22 +1118,22 @@ class HMSRNSDK(
 
   fun changeMetadata(data: ReadableMap, callback: Promise?) {
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("metadata", "String")))
+      HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("metadata", "String")))
     if (requiredKeys === null) {
       val metadata = data.getString("metadata")
 
       if (metadata != null) {
         hmsSDK?.changeMetadata(
-            metadata,
-            object : HMSActionResultListener {
-              override fun onSuccess() {
-                callback?.resolve(emitHMSSuccess())
-              }
-              override fun onError(error: HMSException) {
-                callback?.reject(error.code.toString(), error.message)
-                self.emitHMSError(error)
-              }
+          metadata,
+          object : HMSActionResultListener {
+            override fun onSuccess() {
+              callback?.resolve(emitHMSSuccess())
             }
+            override fun onError(error: HMSException) {
+              callback?.reject(error.code.toString(), error.message)
+              self.emitHMSError(error)
+            }
+          }
         )
       }
     } else {
@@ -1043,10 +1145,10 @@ class HMSRNSDK(
 
   fun startRTMPOrRecording(data: ReadableMap, callback: Promise?) {
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(
-            data,
-            arrayOf(Pair("record", "Boolean"), Pair("meetingURL", "String"))
-        )
+      HMSHelper.getUnavailableRequiredKey(
+        data,
+        arrayOf(Pair("record", "Boolean"), Pair("meetingURL", "String"))
+      )
     if (requiredKeys === null) {
       val config = HMSHelper.getRtmpConfig(data)
       if (config === null) {
@@ -1055,16 +1157,16 @@ class HMSRNSDK(
         rejectCallback(callback, errorMessage)
       } else {
         hmsSDK?.startRtmpOrRecording(
-            config,
-            object : HMSActionResultListener {
-              override fun onSuccess() {
-                callback?.resolve(emitHMSSuccess())
-              }
-              override fun onError(error: HMSException) {
-                callback?.reject(error.code.toString(), error.message)
-                self.emitHMSError(error)
-              }
+          config,
+          object : HMSActionResultListener {
+            override fun onSuccess() {
+              callback?.resolve(emitHMSSuccess())
+            }
+            override fun onError(error: HMSException) {
+              callback?.reject(error.code.toString(), error.message)
+              self.emitHMSError(error)
             }
+          }
         )
       }
     } else {
@@ -1076,15 +1178,15 @@ class HMSRNSDK(
 
   fun stopRtmpAndRecording(callback: Promise?) {
     hmsSDK?.stopRtmpAndRecording(
-        object : HMSActionResultListener {
-          override fun onSuccess() {
-            callback?.resolve(emitHMSSuccess())
-          }
-          override fun onError(error: HMSException) {
-            callback?.reject(error.code.toString(), error.message)
-            self.emitHMSError(error)
-          }
+      object : HMSActionResultListener {
+        override fun onSuccess() {
+          callback?.resolve(emitHMSSuccess())
         }
+        override fun onError(error: HMSException) {
+          callback?.reject(error.code.toString(), error.message)
+          self.emitHMSError(error)
+        }
+      }
     )
   }
 
@@ -1104,48 +1206,48 @@ class HMSRNSDK(
 
   fun stopScreenshare(callback: Promise?) {
     hmsSDK?.stopScreenshare(
-        object : HMSActionResultListener {
-          override fun onError(error: HMSException) {
-            screenshareCallback = null
-            callback?.reject(error.code.toString(), error.message)
-            self.emitHMSError(error)
-          }
-          override fun onSuccess() {
-            screenshareCallback = null
-            callback?.resolve(emitHMSSuccess())
-          }
+      object : HMSActionResultListener {
+        override fun onError(error: HMSException) {
+          screenshareCallback = null
+          callback?.reject(error.code.toString(), error.message)
+          self.emitHMSError(error)
         }
+        override fun onSuccess() {
+          screenshareCallback = null
+          callback?.resolve(emitHMSSuccess())
+        }
+      }
     )
   }
 
   fun startHLSStreaming(data: ReadableMap, callback: Promise?) {
     val hlsConfig = HMSHelper.getHLSConfig(data)
     hmsSDK?.startHLSStreaming(
-        hlsConfig,
-        object : HMSActionResultListener {
-          override fun onSuccess() {
-            callback?.resolve(emitHMSSuccess())
-          }
-          override fun onError(error: HMSException) {
-            callback?.reject(error.code.toString(), error.message)
-            self.emitHMSError(error)
-          }
+      hlsConfig,
+      object : HMSActionResultListener {
+        override fun onSuccess() {
+          callback?.resolve(emitHMSSuccess())
         }
+        override fun onError(error: HMSException) {
+          callback?.reject(error.code.toString(), error.message)
+          self.emitHMSError(error)
+        }
+      }
     )
   }
 
   fun stopHLSStreaming(callback: Promise?) {
     hmsSDK?.stopHLSStreaming(
-        null,
-        object : HMSActionResultListener {
-          override fun onSuccess() {
-            callback?.resolve(emitHMSSuccess())
-          }
-          override fun onError(error: HMSException) {
-            callback?.reject(error.code.toString(), error.message)
-            self.emitHMSError(error)
-          }
+      null,
+      object : HMSActionResultListener {
+        override fun onSuccess() {
+          callback?.resolve(emitHMSSuccess())
         }
+        override fun onError(error: HMSException) {
+          callback?.reject(error.code.toString(), error.message)
+          self.emitHMSError(error)
+        }
+      }
     )
   }
 
@@ -1162,7 +1264,6 @@ class HMSRNSDK(
 
         for (track in auxTracks) {
           if (track.type === HMSTrackType.AUDIO) {
-
             (track as? HMSRemoteAudioTrack)?.setVolume(10.0)
           }
         }
@@ -1176,17 +1277,17 @@ class HMSRNSDK(
       val name = data.getString("name")
       if (name != null && name != "") {
         hmsSDK?.changeName(
-            name,
-            object : HMSActionResultListener {
-              override fun onSuccess() {
-                callback?.resolve(emitHMSSuccess())
-              }
+          name,
+          object : HMSActionResultListener {
+            override fun onSuccess() {
+              callback?.resolve(emitHMSSuccess())
+            }
 
-              override fun onError(error: HMSException) {
-                callback?.reject(error.code.toString(), error.message)
-                self.emitHMSError(error)
-              }
+            override fun onError(error: HMSException) {
+              callback?.reject(error.code.toString(), error.message)
+              self.emitHMSError(error)
             }
+          }
         )
       } else {
         self.emitCustomError("NAME_UNDEFINED")
@@ -1225,7 +1326,7 @@ class HMSRNSDK(
 
   fun switchAudioOutput(data: ReadableMap) {
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("audioDevice", "String")))
+      HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("audioDevice", "String")))
     if (requiredKeys === null) {
       val audioDevice = data.getString("audioDevice")
       hmsSDK?.switchAudioOutput(HMSHelper.getAudioDevice(audioDevice))
@@ -1248,28 +1349,28 @@ class HMSRNSDK(
 
   fun setAudioDeviceChangeListener() {
     hmsSDK?.setAudioDeviceChangeListener(
-        object : HMSAudioManager.AudioManagerDeviceChangeListener {
-          override fun onAudioDeviceChanged(
-              device: HMSAudioManager.AudioDevice?,
-              audioDevicesList: Set<HMSAudioManager.AudioDevice>?
-          ) {
-            val data: WritableMap = Arguments.createMap()
-            data.putString("device", device?.name)
-            data.putArray("audioDevicesList", HMSHelper.getAudioDevicesSet(audioDevicesList))
-            data.putString("id", id)
-            delegate.emitEvent("ON_AUDIO_DEVICE_CHANGED", data)
-          }
+      object : HMSAudioManager.AudioManagerDeviceChangeListener {
+        override fun onAudioDeviceChanged(
+          device: HMSAudioManager.AudioDevice?,
+          audioDevicesList: Set<HMSAudioManager.AudioDevice>?
+        ) {
+          val data: WritableMap = Arguments.createMap()
+          data.putString("device", device?.name)
+          data.putArray("audioDevicesList", HMSHelper.getAudioDevicesSet(audioDevicesList))
+          data.putString("id", id)
+          delegate.emitEvent("ON_AUDIO_DEVICE_CHANGED", data)
+        }
 
-          override fun onError(error: HMSException) {
-            self.emitHMSError(error)
-          }
+        override fun onError(error: HMSException) {
+          self.emitHMSError(error)
         }
+      }
     )
   }
 
   fun startAudioshare(data: ReadableMap, callback: Promise?) {
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("audioMixingMode", "String")))
+      HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("audioMixingMode", "String")))
     if (requiredKeys === null) {
       audioshareCallback = callback
       runOnUiThread {
@@ -1292,18 +1393,18 @@ class HMSRNSDK(
 
   fun stopAudioshare(callback: Promise?) {
     hmsSDK?.stopAudioshare(
-        object : HMSActionResultListener {
-          override fun onError(error: HMSException) {
-            audioshareCallback = null
-            callback?.reject(error.code.toString(), error.message)
-            self.emitHMSError(error)
-          }
-          override fun onSuccess() {
-            isAudioSharing = false
-            audioshareCallback = null
-            callback?.resolve(emitHMSSuccess())
-          }
+      object : HMSActionResultListener {
+        override fun onError(error: HMSException) {
+          audioshareCallback = null
+          callback?.reject(error.code.toString(), error.message)
+          self.emitHMSError(error)
         }
+        override fun onSuccess() {
+          isAudioSharing = false
+          audioshareCallback = null
+          callback?.resolve(emitHMSSuccess())
+        }
+      }
     )
   }
 
@@ -1313,7 +1414,7 @@ class HMSRNSDK(
 
   fun setAudioMixingMode(data: ReadableMap, callback: Promise?) {
     val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("audioMixingMode", "String")))
+      HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("audioMixingMode", "String")))
     if (requiredKeys === null) {
       val mode = HMSHelper.getAudioMixingMode(data.getString("audioMixingMode"))
       audioMixingMode = mode
@@ -1330,17 +1431,17 @@ class HMSRNSDK(
     if (data.hasKey("sessionMetaData")) {
       val sessionMetaData = data.getString("sessionMetaData")
       hmsSDK?.setSessionMetaData(
-          sessionMetaData,
-          object : HMSActionResultListener {
-            override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
-            }
+        sessionMetaData,
+        object : HMSActionResultListener {
+          override fun onSuccess() {
+            callback?.resolve(emitHMSSuccess())
+          }
 
-            override fun onError(error: HMSException) {
-              callback?.reject(error.code.toString(), error.message)
-              self.emitHMSError(error)
-            }
+          override fun onError(error: HMSException) {
+            callback?.reject(error.code.toString(), error.message)
+            self.emitHMSError(error)
           }
+        }
       )
     } else {
       val errorMessage = "setSessionMetaData: sessionMetaData_Is_Required"
@@ -1351,16 +1452,16 @@ class HMSRNSDK(
 
   fun getSessionMetaData(callback: Promise?) {
     hmsSDK?.getSessionMetaData(
-        object : HMSSessionMetadataListener {
-          override fun onSuccess(sessionMetadata: String?) {
-            callback?.resolve(sessionMetadata)
-          }
+      object : HMSSessionMetadataListener {
+        override fun onSuccess(sessionMetadata: String?) {
+          callback?.resolve(sessionMetadata)
+        }
 
-          override fun onError(error: HMSException) {
-            callback?.reject(error.code.toString(), error.message)
-            self.emitHMSError(error)
-          }
+        override fun onError(error: HMSException) {
+          callback?.reject(error.code.toString(), error.message)
+          self.emitHMSError(error)
         }
+      }
     )
   }
 }