@100mslive/react-native-hms 2.0.0-alpha.0 → 2.0.0-alpha.1

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

@@ -2,6 +2,7 @@ package com.reactnativehmssdk
 
 import android.content.Intent
 import android.content.Intent.FLAG_ACTIVITY_NEW_TASK
+import android.os.Build
 import com.facebook.react.bridge.*
 import com.facebook.react.bridge.UiThreadUtil.runOnUiThread
 import com.google.gson.JsonElement
@@ -19,6 +20,7 @@ import live.hms.video.sdk.models.enums.HMSPeerUpdate
 import live.hms.video.sdk.models.enums.HMSRoomUpdate
 import live.hms.video.sdk.models.enums.HMSTrackUpdate
 import live.hms.video.sdk.models.trackchangerequest.HMSChangeTrackStateRequest
+import live.hms.video.sdk.transcripts.HmsTranscripts
 import live.hms.video.sessionstore.HMSKeyChangeListener
 import live.hms.video.sessionstore.HmsSessionStore
 import live.hms.video.signal.init.*
@@ -29,7 +31,7 @@ import java.util.Date
 
 class HMSRNSDK(
   data: ReadableMap?,
-  HmsDelegate: HMSManager,
+  HmsDelegate: HMSManagerImpl,
   sdkId: String,
   reactApplicationContext: ReactApplicationContext,
 ) {
@@ -37,7 +39,7 @@ class HMSRNSDK(
   var screenshareCallback: Promise? = null
   var audioshareCallback: Promise? = null
   var isAudioSharing: Boolean = false
-  var delegate: HMSManager = HmsDelegate
+  var delegate: HMSManagerImpl = HmsDelegate
   var previewForRoleVideoTrack: HMSLocalVideoTrack? = null
   var previewForRoleAudioTrack: HMSLocalAudioTrack? = null
   private var recentRoleChangeRequest: HMSRoleChangeRequest? = null
@@ -48,10 +50,13 @@ class HMSRNSDK(
   private var audioMixingMode: AudioMixingMode = AudioMixingMode.TALK_AND_MUSIC
   private var id: String = sdkId
   private var self = this
-  private var eventsEnableStatus = mutableMapOf<String, Boolean>()
+  var eventsEnableStatus = mutableMapOf<String, Boolean>()
   private var sessionStore: HmsSessionStore? = null
   private val keyChangeObservers = mutableMapOf<String, HMSKeyChangeListener?>()
-  private val peerListIterators = mutableMapOf<Int, PeerListIterator>()
+  private val peerListIterators = mutableMapOf<String, PeerListIterator>()
+  private var roomMutedLocally = false
+
+  var interactivityCenter: HMSRNInteractivityCenter? = null
 
   init {
     val builder = HMSSDK.Builder(reactApplicationContext)
@@ -67,10 +72,12 @@ class HMSRNSDK(
       if (frameworkInfo != null) {
         builder.setFrameworkInfo(frameworkInfo)
       } else {
-        emitCustomError("Unable to decode framework info")
+        val errorMessage = "Unable to decode framework info"
+        throw HMSException(6002, errorMessage, errorMessage, errorMessage, errorMessage, null, false)
       }
     } else {
-      emitCustomError("Framework info not sent in build function")
+      val errorMessage = "Framework info not sent in build function"
+      throw HMSException(6002, errorMessage, errorMessage, errorMessage, errorMessage, null, false)
     }
 
     if (HMSHelper.areAllRequiredKeysAvailable(data, arrayOf(Pair("logSettings", "Map")))) {
@@ -80,7 +87,18 @@ class HMSRNSDK(
       }
     }
 
+    if (data?.hasKey("haltPreviewJoinForPermissionsRequest") == true) {
+      val halt = data?.getBoolean("haltPreviewJoinForPermissionsRequest")
+      if (halt != null) {
+        builder.haltPreviewJoinForPermissionsRequest(halt)
+      }
+    }
+
     this.hmsSDK = builder.build()
+
+    hmsSDK?.let {
+      interactivityCenter = HMSRNInteractivityCenter(it, this)
+    }
   }
 
   private fun emitCustomError(message: String) {
@@ -134,6 +152,7 @@ class HMSRNSDK(
     sessionStore = null
     keyChangeObservers.clear()
     peerListIterators.clear()
+    roomMutedLocally = false
     HMSDecoder.clearRestrictDataStates()
   }
 
@@ -147,7 +166,7 @@ class HMSRNSDK(
     delegate.emitEvent("ON_ERROR", data)
   }
 
-  fun emitHMSSuccess(message: HMSMessage? = null): ReadableMap {
+  fun getPromiseResolveData(message: HMSMessage? = null): ReadableMap {
     val hmsMessage =
       if (message !== null) message.message else "function call executed successfully"
     val data: WritableMap = Arguments.createMap()
@@ -156,7 +175,7 @@ class HMSRNSDK(
     return data
   }
 
-  fun emitHMSMessageSuccess(hmsMessage: HMSMessage): ReadableMap {
+  fun getPromiseResolveMessageData(hmsMessage: HMSMessage): ReadableMap {
     val data: WritableMap = Arguments.createMap()
     data.putString("message", hmsMessage.message)
     data.putString("messageId", hmsMessage.messageId)
@@ -245,9 +264,11 @@ class HMSRNSDK(
             delegate.emitEvent("ON_PREVIEW", data)
           }
 
-          /*
-          override fun peerListUpdated(addedPeers: ArrayList<HMSPeer>?, removedPeers: ArrayList<HMSPeer>?) {
-
+          override fun peerListUpdated(
+            addedPeers: ArrayList<HMSPeer>?,
+            removedPeers: ArrayList<HMSPeer>?,
+          ) {
+            super.peerListUpdated(addedPeers, removedPeers)
             if (eventsEnableStatus["ON_PEER_LIST_UPDATED"] != true) {
               return
             }
@@ -267,11 +288,22 @@ class HMSRNSDK(
               }
             }
 
+            data.putString("id", id)
             data.putArray("addedPeers", addedPeersArray)
             data.putArray("removedPeers", removedPeersArray)
             delegate.emitEvent("ON_PEER_LIST_UPDATED", data)
           }
-           */
+
+          override fun onPermissionsRequested(permissions: List<String>) {
+            if (eventsEnableStatus["ON_PERMISSIONS_REQUESTED"] != true) {
+              return
+            }
+            val data: WritableMap = Arguments.createMap()
+
+            data.putArray("permissions", Arguments.fromList(permissions))
+            data.putString("id", id)
+            delegate.emitEvent("ON_PERMISSIONS_REQUESTED", data)
+          }
         },
       )
     } else {
@@ -295,216 +327,267 @@ class HMSRNSDK(
       val config = HMSHelper.getHmsConfig(credentials)
 
       HMSCoroutineScope.launch {
-        try {
-          hmsSDK?.join(
-            config,
-            object : HMSUpdateListener {
-              override fun onChangeTrackStateRequest(details: HMSChangeTrackStateRequest) {
-                if (eventsEnableStatus["ON_CHANGE_TRACK_STATE_REQUEST"] != true) {
-                  return
-                }
-                val decodedChangeTrackStateRequest =
-                  HMSDecoder.getHmsChangeTrackStateRequest(details, id)
-                delegate.emitEvent(
-                  "ON_CHANGE_TRACK_STATE_REQUEST",
-                  decodedChangeTrackStateRequest,
-                )
+        hmsSDK?.join(
+          config,
+          object : HMSUpdateListener {
+            override fun onChangeTrackStateRequest(details: HMSChangeTrackStateRequest) {
+              if (eventsEnableStatus["ON_CHANGE_TRACK_STATE_REQUEST"] != true) {
+                return
               }
+              val decodedChangeTrackStateRequest =
+                HMSDecoder.getHmsChangeTrackStateRequest(details, id)
+              delegate.emitEvent(
+                "ON_CHANGE_TRACK_STATE_REQUEST",
+                decodedChangeTrackStateRequest,
+              )
+            }
 
-              override fun onRemovedFromRoom(notification: HMSRemovedFromRoom) {
-                super.onRemovedFromRoom(notification)
-                if (eventsEnableStatus["ON_REMOVED_FROM_ROOM"] != true) {
-                  cleanup() // resetting states and doing data cleanup
-                  return
+            override fun onRemovedFromRoom(notification: HMSRemovedFromRoom) {
+              super.onRemovedFromRoom(notification)
+
+              context.currentActivity?.let {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && it.isInPictureInPictureMode) {
+                  it.moveTaskToBack(false)
                 }
-                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)
-
-                delegate.emitEvent("ON_REMOVED_FROM_ROOM", data)
-                cleanup() // resetting states and doing data cleanup
               }
 
-              override fun onError(error: HMSException) {
-                if (eventsEnableStatus["ON_ERROR"] != true) {
-                  return
-                }
-                self.emitHMSError(error)
+              if (eventsEnableStatus["ON_REMOVED_FROM_ROOM"] != true) {
+                cleanup() // resetting states and doing data cleanup
+                return
               }
+              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)
 
-              override fun onJoin(room: HMSRoom) {
-                if (eventsEnableStatus["ON_JOIN"] != true) {
-                  return
-                }
-                val roomData = HMSDecoder.getHmsRoomSubset(room)
+              delegate.emitEvent("ON_REMOVED_FROM_ROOM", data)
+              cleanup() // resetting states and doing data cleanup
+            }
 
-                val data: WritableMap = Arguments.createMap()
+            override fun onError(error: HMSException) {
+              if (eventsEnableStatus["ON_ERROR"] != true) {
+                return
+              }
+              self.emitHMSError(error)
+            }
 
-                data.putMap("room", roomData)
-                data.putString("id", id)
-                delegate.emitEvent("ON_JOIN", data)
+            override fun onJoin(room: HMSRoom) {
+              if (eventsEnableStatus["ON_JOIN"] != true) {
+                return
               }
+              val roomData = HMSDecoder.getHmsRoomSubset(room)
 
-              override fun onPeerUpdate(
-                type: HMSPeerUpdate,
-                peer: HMSPeer,
+              val data: WritableMap = Arguments.createMap()
+
+              data.putMap("room", roomData)
+              data.putString("id", id)
+              delegate.emitEvent("ON_JOIN", data)
+            }
+
+            override fun onPeerUpdate(
+              type: HMSPeerUpdate,
+              peer: HMSPeer,
+            ) {
+              if (eventsEnableStatus["3"] != true) {
+                return
+              }
+              if (type === HMSPeerUpdate.BECAME_DOMINANT_SPEAKER ||
+                type === HMSPeerUpdate.NO_DOMINANT_SPEAKER
               ) {
-                if (eventsEnableStatus["3"] != true) {
-                  return
-                }
-                if (type === HMSPeerUpdate.BECAME_DOMINANT_SPEAKER ||
-                  type === HMSPeerUpdate.NO_DOMINANT_SPEAKER
-                ) {
-                  return
-                }
-                if (!networkQualityUpdatesAttached &&
-                  type === HMSPeerUpdate.NETWORK_QUALITY_UPDATED
-                ) {
-                  return
-                }
-                val hmsPeer = HMSDecoder.getHmsPeerSubsetForPeerUpdateEvent(peer, type)
-                delegate.emitEvent("3", hmsPeer)
+                return
               }
+              if (!networkQualityUpdatesAttached &&
+                type === HMSPeerUpdate.NETWORK_QUALITY_UPDATED
+              ) {
+                return
+              }
+              val hmsPeer = HMSDecoder.getHmsPeerSubsetForPeerUpdateEvent(peer, type)
+              delegate.emitEvent("3", hmsPeer)
+            }
 
-              override fun onRoomUpdate(
-                type: HMSRoomUpdate,
-                hmsRoom: HMSRoom,
+            override fun onRoomUpdate(
+              type: HMSRoomUpdate,
+              hmsRoom: HMSRoom,
+            ) {
+              val peerCount = hmsRoom.peerCount
+              if (
+                type == HMSRoomUpdate.ROOM_PEER_COUNT_UPDATED &&
+                peerCount != null &&
+                peerCount <= 1 // `peerCount` includes local peer
               ) {
-                if (eventsEnableStatus["ON_ROOM_UPDATE"] != true) {
-                  return
+                context.currentActivity?.let {
+                  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && it.isInPictureInPictureMode) {
+                    it.moveTaskToBack(false)
+                  }
                 }
+              }
 
-                val updateType = type.name
-                val roomData = HMSDecoder.getHmsRoomSubset(hmsRoom, type)
+              if (eventsEnableStatus["ON_ROOM_UPDATE"] != true) {
+                return
+              }
 
-                val data: WritableMap = Arguments.createMap()
+              val updateType = type.name
+              val roomData = HMSDecoder.getHmsRoomSubset(hmsRoom, type)
 
-                data.putString("type", updateType)
-                data.putMap("room", roomData)
-                data.putString("id", id)
-                delegate.emitEvent("ON_ROOM_UPDATE", data)
-              }
+              val data: WritableMap = Arguments.createMap()
 
-              override fun onTrackUpdate(
-                type: HMSTrackUpdate,
-                track: HMSTrack,
-                peer: HMSPeer,
+              data.putString("type", updateType)
+              data.putMap("room", roomData)
+              data.putString("id", id)
+              delegate.emitEvent("ON_ROOM_UPDATE", data)
+            }
+
+            override fun onTrackUpdate(
+              type: HMSTrackUpdate,
+              track: HMSTrack,
+              peer: HMSPeer,
+            ) {
+              if (
+                roomMutedLocally &&
+                type == HMSTrackUpdate.TRACK_ADDED &&
+                track.type == HMSTrackType.AUDIO &&
+                !peer.isLocal
               ) {
-                if (eventsEnableStatus["ON_TRACK_UPDATE"] != true) {
-                  return
+                val room = hmsSDK?.getRoom()
+                val remoteAudioTrack = HMSHelper.getRemoteAudioTrackFromTrackId(track.trackId, room)
+                remoteAudioTrack?.let {
+                  it.isPlaybackAllowed = !roomMutedLocally
                 }
-                val updateType = type.name
-                val hmsPeer = HMSDecoder.getHmsPeerSubset(peer)
-                val hmsTrack = HMSDecoder.getHmsTrack(track)
+              }
+
+              if (eventsEnableStatus["ON_TRACK_UPDATE"] != true) {
+                return
+              }
+              val updateType = type.name
+              val hmsPeer = HMSDecoder.getHmsPeerSubset(peer)
+              val hmsTrack = HMSDecoder.getHmsTrack(track)
 
-                val data: WritableMap = Arguments.createMap()
+              val data: WritableMap = Arguments.createMap()
+
+              data.putMap("peer", hmsPeer)
+              data.putMap("track", hmsTrack)
+              data.putString("type", updateType)
+              data.putString("id", id)
+              delegate.emitEvent("ON_TRACK_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 onMessageReceived(message: HMSMessage) {
+              if (eventsEnableStatus["ON_MESSAGE"] != true) {
+                return
               }
+              val data: WritableMap = Arguments.createMap()
 
-              override fun onMessageReceived(message: HMSMessage) {
-                if (eventsEnableStatus["ON_MESSAGE"] != true) {
-                  return
-                }
-                val data: WritableMap = Arguments.createMap()
+              data.putMap("sender", HMSDecoder.getHmsPeerSubset(message.sender))
+              data.putString("message", message.message)
+              data.putString("messageId", message.messageId)
+              data.putString("type", message.type)
+              data.putString("time", message.serverReceiveTime.toString())
+              data.putString("id", id)
+              data.putMap("recipient", HMSDecoder.getHmsMessageRecipient(message.recipient))
 
-                data.putMap("sender", HMSDecoder.getHmsPeerSubset(message.sender))
-                data.putString("message", message.message)
-                data.putString("messageId", message.messageId)
-                data.putString("type", message.type)
-                data.putString("time", message.serverReceiveTime.toString())
-                data.putString("id", id)
-                data.putMap("recipient", HMSDecoder.getHmsMessageRecipient(message.recipient))
+              delegate.emitEvent("ON_MESSAGE", data)
+            }
 
-                delegate.emitEvent("ON_MESSAGE", data)
+            override fun onReconnected() {
+              reconnectingStage = false
+              if (eventsEnableStatus["RECONNECTED"] != true) {
+                return
               }
+              val data: WritableMap = Arguments.createMap()
+              data.putString("event", "RECONNECTED")
+              data.putString("id", id)
+              delegate.emitEvent("RECONNECTED", data)
+            }
 
-              override fun onReconnected() {
-                reconnectingStage = false
-                if (eventsEnableStatus["RECONNECTED"] != true) {
-                  return
-                }
-                val data: WritableMap = Arguments.createMap()
-                data.putString("event", "RECONNECTED")
-                data.putString("id", id)
-                delegate.emitEvent("RECONNECTED", data)
+            override fun onReconnecting(error: HMSException) {
+              reconnectingStage = true
+              if (eventsEnableStatus["RECONNECTING"] != true) {
+                return
               }
+              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 onReconnecting(error: HMSException) {
-                reconnectingStage = true
-                if (eventsEnableStatus["RECONNECTING"] != true) {
-                  return
-                }
-                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) {
+              recentRoleChangeRequest = request
+              if (eventsEnableStatus["ON_ROLE_CHANGE_REQUEST"] != true) {
+                return
               }
+              val decodedChangeRoleRequest = HMSDecoder.getHmsRoleChangeRequest(request, id)
+              delegate.emitEvent("ON_ROLE_CHANGE_REQUEST", decodedChangeRoleRequest)
+            }
 
-              override fun onRoleChangeRequest(request: HMSRoleChangeRequest) {
-                recentRoleChangeRequest = request
-                if (eventsEnableStatus["ON_ROLE_CHANGE_REQUEST"] != true) {
-                  return
-                }
-                val decodedChangeRoleRequest = HMSDecoder.getHmsRoleChangeRequest(request, id)
-                delegate.emitEvent("ON_ROLE_CHANGE_REQUEST", decodedChangeRoleRequest)
+            override fun onSessionStoreAvailable(sessionStore: HmsSessionStore) {
+              self.sessionStore = sessionStore
+              if (eventsEnableStatus["ON_SESSION_STORE_AVAILABLE"] != true) {
+                return
               }
+              val data: WritableMap = Arguments.createMap()
+              data.putString("id", id)
+              delegate.emitEvent("ON_SESSION_STORE_AVAILABLE", data)
+            }
 
-              override fun onSessionStoreAvailable(sessionStore: HmsSessionStore) {
-                self.sessionStore = sessionStore
-                if (eventsEnableStatus["ON_SESSION_STORE_AVAILABLE"] != true) {
-                  return
-                }
-                val data: WritableMap = Arguments.createMap()
-                data.putString("id", id)
-                delegate.emitEvent("ON_SESSION_STORE_AVAILABLE", data)
+            override fun peerListUpdated(
+              addedPeers: ArrayList<HMSPeer>?,
+              removedPeers: ArrayList<HMSPeer>?,
+            ) {
+              if (eventsEnableStatus["ON_PEER_LIST_UPDATED"] != true) {
+                return
               }
+              val data: WritableMap = Arguments.createMap()
+              val addedPeersArray: WritableArray = Arguments.createArray()
+              val removedPeersArray: WritableArray = Arguments.createArray()
 
-              override fun peerListUpdated(
-                addedPeers: ArrayList<HMSPeer>?,
-                removedPeers: ArrayList<HMSPeer>?,
-              ) {
-                if (eventsEnableStatus["ON_PEER_LIST_UPDATED"] != true) {
-                  return
+              if (addedPeers != null) {
+                for (peer in addedPeers) {
+                  addedPeersArray.pushMap(HMSDecoder.getHmsPeerSubset(peer))
                 }
-                val data: WritableMap = Arguments.createMap()
-                val addedPeersArray: WritableArray = Arguments.createArray()
-                val removedPeersArray: WritableArray = Arguments.createArray()
+              }
 
-                if (addedPeers != null) {
-                  for (peer in addedPeers) {
-                    addedPeersArray.pushMap(HMSDecoder.getHmsPeerSubset(peer))
-                  }
+              if (removedPeers != null) {
+                for (peer in removedPeers) {
+                  removedPeersArray.pushMap(HMSDecoder.getHmsPeerSubset(peer))
                 }
+              }
 
-                if (removedPeers != null) {
-                  for (peer in removedPeers) {
-                    removedPeersArray.pushMap(HMSDecoder.getHmsPeerSubset(peer))
-                  }
-                }
+              data.putString("id", id)
+              data.putArray("addedPeers", addedPeersArray)
+              data.putArray("removedPeers", removedPeersArray)
+              delegate.emitEvent("ON_PEER_LIST_UPDATED", data)
+            }
+
+            override fun onTranscripts(transcripts: HmsTranscripts) {
+              if (eventsEnableStatus["ON_TRANSCRIPTS"] != true) {
+                return
+              }
+              val data: WritableMap = Arguments.createMap()
+              val transcriptsArray = HMSDecoder.getHmsTranscripts(transcripts.transcripts)
+              data.putArray("transcripts", transcriptsArray)
+              data.putString("id", id)
+              delegate.emitEvent("ON_TRANSCRIPTS", data)
+            }
 
-                data.putString("id", id)
-                data.putArray("addedPeers", addedPeersArray)
-                data.putArray("removedPeers", removedPeersArray)
-                delegate.emitEvent("ON_PEER_LIST_UPDATED", data)
+            override fun onPermissionsRequested(permissions: List<String>) {
+              if (eventsEnableStatus["ON_PERMISSIONS_REQUESTED"] != true) {
+                return
               }
-            },
-          )
-        } catch (e: HMSException) {
-          self.emitHMSError(e)
-        }
+              val data: WritableMap = Arguments.createMap()
+
+              data.putArray("permissions", Arguments.fromList(permissions))
+              data.putString("id", id)
+              delegate.emitEvent("ON_PERMISSIONS_REQUESTED", data)
+            }
+          },
+        )
 
         hmsSDK?.addAudioObserver(
           object : HMSAudioListener {
@@ -689,7 +772,6 @@ class HMSRNSDK(
       )
     } else {
       val errorMessage = "getAuthTokenByRoomCode: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -736,7 +818,7 @@ class HMSRNSDK(
             map.putString("id", id)
             delegate.emitEvent("ON_PIP_ROOM_LEAVE", map)
           } else {
-            callback?.resolve(emitHMSSuccess())
+            callback?.resolve(getPromiseResolveData())
           }
           cleanup() // resetting states and doing data cleanup
         }
@@ -770,13 +852,12 @@ class HMSRNSDK(
           }
 
           override fun onSuccess(hmsMessage: HMSMessage) {
-            callback?.resolve(emitHMSMessageSuccess(hmsMessage))
+            callback?.resolve(getPromiseResolveMessageData(hmsMessage))
           }
         },
       )
     } else {
       val errorMessage = "sendBroadcastMessage: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -805,13 +886,12 @@ class HMSRNSDK(
           }
 
           override fun onSuccess(hmsMessage: HMSMessage) {
-            callback?.resolve(emitHMSMessageSuccess(hmsMessage))
+            callback?.resolve(getPromiseResolveMessageData(hmsMessage))
           }
         },
       )
     } else {
       val errorMessage = "sendGroupMessage: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -839,17 +919,15 @@ class HMSRNSDK(
             }
 
             override fun onSuccess(hmsMessage: HMSMessage) {
-              callback?.resolve(emitHMSMessageSuccess(hmsMessage))
+              callback?.resolve(getPromiseResolveMessageData(hmsMessage))
             }
           },
         )
       } else {
-        self.emitCustomError("PEER_NOT_FOUND")
         callback?.reject("101", "PEER_NOT_FOUND")
       }
     } else {
       val errorMessage = "sendDirectMessage: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -887,7 +965,7 @@ class HMSRNSDK(
           force,
           object : HMSActionResultListener {
             override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
+              callback?.resolve(getPromiseResolveData())
             }
 
             override fun onError(error: HMSException) {
@@ -898,7 +976,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "changeRole: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -935,7 +1012,7 @@ class HMSRNSDK(
           force,
           object : HMSActionResultListener {
             override fun onSuccess() {
-              promise?.resolve(emitHMSSuccess())
+              promise?.resolve(getPromiseResolveData())
             }
 
             override fun onError(error: HMSException) {
@@ -946,7 +1023,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "changeRoleOfPeer: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -978,7 +1054,7 @@ class HMSRNSDK(
             toHMSRole,
             object : HMSActionResultListener {
               override fun onSuccess() {
-                promise?.resolve(emitHMSSuccess())
+                promise?.resolve(getPromiseResolveData())
               }
 
               override fun onError(error: HMSException) {
@@ -990,7 +1066,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "changeRoleOfPeersWithRoles: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -1014,7 +1089,7 @@ class HMSRNSDK(
           mute,
           object : HMSActionResultListener {
             override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
+              callback?.resolve(getPromiseResolveData())
             }
 
             override fun onError(error: HMSException) {
@@ -1025,7 +1100,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "changeTrackState: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1068,7 +1142,7 @@ class HMSRNSDK(
         encodedTargetedRoles,
         object : HMSActionResultListener {
           override fun onSuccess() {
-            callback?.resolve(emitHMSSuccess())
+            callback?.resolve(getPromiseResolveData())
           }
 
           override fun onError(error: HMSException) {
@@ -1078,7 +1152,6 @@ class HMSRNSDK(
       )
     } else {
       val errorMessage = "changeTrackStateForRoles: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1099,7 +1172,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "isMute: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1114,30 +1186,31 @@ class HMSRNSDK(
         arrayOf(Pair("peerId", "String"), Pair("reason", "String")),
       )
     if (requiredKeys === null) {
-      val peerId = data.getString("peerId")
-      val peer = HMSHelper.getRemotePeerFromPeerId(peerId, hmsSDK?.getRoom())
+      HMSCoroutineScope.launch {
+        val peerId = data.getString("peerId")
 
-      if (peer != null) {
-        hmsSDK?.removePeerRequest(
-          peer,
-          data.getString("reason") as String,
-          object : HMSActionResultListener {
-            override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
-            }
+        val peer = HMSHelper.getRemotePeerFromPeerId(peerId, hmsSDK)
 
-            override fun onError(error: HMSException) {
-              callback?.reject(error.code.toString(), error.message)
-            }
-          },
-        )
-      } else {
-        self.emitCustomError("PEER_NOT_FOUND")
-        callback?.reject("101", "PEER_NOT_FOUND")
+        if (peer != null) {
+          hmsSDK?.removePeerRequest(
+            peer,
+            data.getString("reason") as String,
+            object : HMSActionResultListener {
+              override fun onSuccess() {
+                callback?.resolve(getPromiseResolveData())
+              }
+
+              override fun onError(error: HMSException) {
+                callback?.reject(error.code.toString(), error.message)
+              }
+            },
+          )
+        } else {
+          callback?.reject("101", "PEER_NOT_FOUND")
+        }
       }
     } else {
       val errorMessage = "removePeer: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1157,7 +1230,7 @@ class HMSRNSDK(
         data.getBoolean("lock"),
         object : HMSActionResultListener {
           override fun onSuccess() {
-            callback?.resolve(emitHMSSuccess())
+            callback?.resolve(getPromiseResolveData())
             cleanup() // resetting states and doing data cleanup
           }
 
@@ -1168,7 +1241,6 @@ class HMSRNSDK(
       )
     } else {
       val errorMessage = "endRoom: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1215,7 +1287,6 @@ class HMSRNSDK(
       )
     } else {
       val errorMessage = "Missing required keys for previewForRole: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1224,7 +1295,7 @@ class HMSRNSDK(
     hmsSDK?.cancelPreview()
     previewForRoleAudioTrack = null
     previewForRoleVideoTrack = null
-    callback?.resolve(emitHMSSuccess())
+    callback?.resolve(getPromiseResolveData())
   }
 
   fun acceptRoleChange(callback: Promise?) {
@@ -1233,7 +1304,7 @@ class HMSRNSDK(
         recentRoleChangeRequest!!,
         object : HMSActionResultListener {
           override fun onSuccess() {
-            callback?.resolve(emitHMSSuccess())
+            callback?.resolve(getPromiseResolveData())
           }
 
           override fun onError(error: HMSException) {
@@ -1246,7 +1317,6 @@ class HMSRNSDK(
       previewForRoleVideoTrack = null
     } else {
       val errorMessage = "acceptRoleChange: recentRoleChangeRequest not found"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1269,7 +1339,7 @@ class HMSRNSDK(
         )
       }
       if (customError === null) {
-        callback?.resolve(emitHMSSuccess())
+        callback?.resolve(getPromiseResolveData())
       } else {
         rejectCallback(callback, customError!!.message)
       }
@@ -1277,25 +1347,33 @@ class HMSRNSDK(
     rejectCallback(callback, "Audio tracks not found")
   }
 
-  fun setPlaybackForAllAudio(data: ReadableMap) {
+  fun setPlaybackForAllAudio(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val requiredKeys = HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("mute", "Boolean")))
     if (requiredKeys === null) {
       val mute = data.getBoolean("mute")
-      val peers = hmsSDK?.getRemotePeers()
-      if (peers != null) {
-        for (remotePeer in peers) {
-          val peerId = remotePeer.peerID
-          val peer = HMSHelper.getRemotePeerFromPeerId(peerId, hmsSDK?.getRoom())
-          peer?.audioTrack?.isPlaybackAllowed = !mute
+      self.roomMutedLocally = mute
+
+      val allAudioTracks = HMSHelper.getAllAudioTracks(hmsSDK?.getRoom())
+
+      allAudioTracks?.forEach {
+        if (it is HMSRemoteAudioTrack) {
+          it.isPlaybackAllowed = !mute
         }
       }
+      callback?.resolve(true)
     } else {
       val errorMessage = "setPlaybackForAllAudio: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(callback, errorMessage)
     }
   }
 
-  fun setPlaybackAllowed(data: ReadableMap) {
+  fun setPlaybackAllowed(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val requiredKeys =
       HMSHelper.getUnavailableRequiredKey(
         data,
@@ -1308,12 +1386,16 @@ class HMSRNSDK(
       val remoteVideoTrack = HMSHelper.getRemoteVideoTrackFromTrackId(trackId, hmsSDK?.getRoom())
       if (remoteAudioTrack != null) {
         remoteAudioTrack.isPlaybackAllowed = playbackAllowed
+        callback?.resolve(true)
       } else if (remoteVideoTrack != null) {
         remoteVideoTrack.isPlaybackAllowed = playbackAllowed
+        callback?.resolve(true)
+      } else {
+        callback?.reject("101", "setPlaybackAllowed: No remote audio and video track found!")
       }
     } else {
       val errorMessage = "setPlaybackAllowed: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(callback, errorMessage)
     }
   }
 
@@ -1341,7 +1423,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "isPlaybackAllowed: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1366,7 +1447,10 @@ class HMSRNSDK(
     callback?.resolve(roles)
   }
 
-  fun setVolume(data: ReadableMap) {
+  fun setVolume(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val requiredKeys =
       HMSHelper.getUnavailableRequiredKey(
         data,
@@ -1385,6 +1469,7 @@ class HMSRNSDK(
 
           if (audioTrackId == trackId) {
             peer.audioTrack?.setVolume(volume)
+            callback?.resolve(null)
             return
           }
 
@@ -1394,18 +1479,19 @@ class HMSRNSDK(
 
               if (trackExtracted != null) {
                 trackExtracted.setVolume(volume)
+                callback?.resolve(null)
                 return
               }
             }
           }
         }
-        this.emitCustomError("TRACK_NOT_FOUND")
+        callback?.reject("101", "TRACK_NOT_FOUND")
       } else {
-        this.emitCustomError("REMOTE_PEERS_NOT_FOUND")
+        callback?.reject("101", "REMOTE_PEERS_NOT_FOUND")
       }
     } else {
       val errorMessage = "setVolume: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(callback, errorMessage)
     }
   }
 
@@ -1427,7 +1513,6 @@ class HMSRNSDK(
       callback?.reject("101", "TRACK_IDS_DO_NOT_MATCH")
     } else {
       val errorMessage = "getVolume: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1446,7 +1531,7 @@ class HMSRNSDK(
           metadata,
           object : HMSActionResultListener {
             override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
+              callback?.resolve(getPromiseResolveData())
             }
 
             override fun onError(error: HMSException) {
@@ -1457,7 +1542,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "changeMetadata: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1475,14 +1559,13 @@ class HMSRNSDK(
       val config = HMSHelper.getRtmpConfig(data)
       if (config === null) {
         val errorMessage = "startRTMPOrRecording: INVALID_MEETING_URL_PASSED"
-        self.emitRequiredKeysError(errorMessage)
         rejectCallback(callback, errorMessage)
       } else {
         hmsSDK?.startRtmpOrRecording(
           config,
           object : HMSActionResultListener {
             override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
+              callback?.resolve(getPromiseResolveData())
             }
 
             override fun onError(error: HMSException) {
@@ -1493,7 +1576,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "startRTMPOrRecording: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1502,7 +1584,7 @@ class HMSRNSDK(
     hmsSDK?.stopRtmpAndRecording(
       object : HMSActionResultListener {
         override fun onSuccess() {
-          callback?.resolve(emitHMSSuccess())
+          callback?.resolve(getPromiseResolveData())
         }
 
         override fun onError(error: HMSException) {
@@ -1514,6 +1596,7 @@ class HMSRNSDK(
 
   fun startScreenshare(callback: Promise?) {
     screenshareCallback = callback
+    HMSManagerImpl.startingScreenShare = true
     runOnUiThread {
       val intent = Intent(context, HmsScreenshareActivity::class.java)
       intent.flags = FLAG_ACTIVITY_NEW_TASK
@@ -1536,12 +1619,14 @@ class HMSRNSDK(
 
         override fun onSuccess() {
           screenshareCallback = null
-          callback?.resolve(emitHMSSuccess())
+          callback?.resolve(getPromiseResolveData())
         }
       },
     )
   }
 
+  // region - HLS Streaming
+
   fun startHLSStreaming(
     data: ReadableMap,
     callback: Promise?,
@@ -1551,7 +1636,7 @@ class HMSRNSDK(
       hlsConfig,
       object : HMSActionResultListener {
         override fun onSuccess() {
-          callback?.resolve(emitHMSSuccess())
+          callback?.resolve(getPromiseResolveData())
         }
 
         override fun onError(error: HMSException) {
@@ -1566,7 +1651,7 @@ class HMSRNSDK(
       null,
       object : HMSActionResultListener {
         override fun onSuccess() {
-          callback?.resolve(emitHMSSuccess())
+          callback?.resolve(getPromiseResolveData())
         }
 
         override fun onError(error: HMSException) {
@@ -1576,26 +1661,42 @@ class HMSRNSDK(
     )
   }
 
-  fun resetVolume() {
-    val remotePeers = hmsSDK?.getRemotePeers()
+  fun sendHLSTimedMetadata(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
+    val metadataArrayList = data.getArray("metadata")?.toArrayList() as? ArrayList<HashMap<String, Any>>
+
+    if (metadataArrayList == null) {
+      val errorMessage = "sendHLSTimedMetadata: INVALID_METADATA"
+      rejectCallback(callback, errorMessage)
+      return
+    }
 
-    if (remotePeers != null) {
-      for (peer in remotePeers) {
-        val playbackAllowed = peer.audioTrack?.isPlaybackAllowed
-        if (playbackAllowed !== null && playbackAllowed) {
-          peer.audioTrack?.setVolume(10.0)
+    val metadata =
+      metadataArrayList.mapNotNull { map ->
+        val payload = map["payload"] as? String
+        val duration = map["duration"] as? Double
+
+        payload?.let { HMSHLSTimedMetadata(it, duration?.toLong() ?: 1) }
+      }
+
+    hmsSDK?.setHlsSessionMetadata(
+      metadata,
+      object : HMSActionResultListener {
+        override fun onSuccess() {
+          callback?.resolve(true)
         }
-        val auxTracks = peer.auxiliaryTracks
 
-        for (track in auxTracks) {
-          if (track.type === HMSTrackType.AUDIO) {
-            (track as? HMSRemoteAudioTrack)?.setVolume(10.0)
-          }
+        override fun onError(error: HMSException) {
+          callback?.reject(error.code.toString(), error.message)
         }
-      }
-    }
+      },
+    )
   }
 
+  // endregion
+
   fun changeName(
     data: ReadableMap,
     callback: Promise?,
@@ -1608,7 +1709,7 @@ class HMSRNSDK(
           name,
           object : HMSActionResultListener {
             override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
+              callback?.resolve(getPromiseResolveData())
             }
 
             override fun onError(error: HMSException) {
@@ -1617,12 +1718,10 @@ class HMSRNSDK(
           },
         )
       } else {
-        self.emitCustomError("NAME_UNDEFINED")
         callback?.reject("101", "NAME_UNDEFINED")
       }
     } else {
       val errorMessage = "changeName: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1643,26 +1742,38 @@ class HMSRNSDK(
     callback?.resolve(hmsSDK?.getAudioOutputRouteType()?.name)
   }
 
-  fun switchAudioOutput(data: ReadableMap) {
+  fun switchAudioOutput(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val requiredKeys =
       HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("audioDevice", "String")))
     if (requiredKeys === null) {
       val audioDevice = data.getString("audioDevice")
-      hmsSDK?.switchAudioOutput(HMSHelper.getAudioDevice(audioDevice))
+      hmsSDK?.let {
+        it.switchAudioOutput(HMSHelper.getAudioDevice(audioDevice))
+        callback?.resolve(null)
+      }
     } else {
       val errorMessage = "switchAudioOutput: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(callback, errorMessage)
     }
   }
 
-  fun setAudioMode(data: ReadableMap) {
+  fun setAudioMode(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val requiredKeys = HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("audioMode", "Int")))
     if (requiredKeys === null) {
       val audioMode = data.getInt("audioMode")
-      hmsSDK?.setAudioMode(audioMode)
+      hmsSDK?.let {
+        it.setAudioMode(audioMode)
+        callback?.resolve(true)
+      }
     } else {
       val errorMessage = "setAudioMode: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(callback, errorMessage)
     }
   }
 
@@ -1670,21 +1781,22 @@ class HMSRNSDK(
     hmsSDK?.setAudioDeviceChangeListener(
       object : HMSAudioManager.AudioManagerDeviceChangeListener {
         override fun onAudioDeviceChanged(
-          device: HMSAudioManager.AudioDevice?,
-          audioDevicesList: Set<HMSAudioManager.AudioDevice>?,
+          selectedAudioDevice: HMSAudioManager.AudioDevice,
+          availableAudioDevices: Set<HMSAudioManager.AudioDevice>,
         ) {
           if (eventsEnableStatus["ON_AUDIO_DEVICE_CHANGED"] != true) {
             return
           }
+
           val data: WritableMap = Arguments.createMap()
-          data.putString("device", device?.name)
-          data.putArray("audioDevicesList", HMSHelper.getAudioDevicesSet(audioDevicesList))
+          data.putString("device", selectedAudioDevice.name)
+          data.putArray("audioDevicesList", HMSHelper.getAudioDevicesSet(availableAudioDevices))
           data.putString("id", id)
           delegate.emitEvent("ON_AUDIO_DEVICE_CHANGED", data)
         }
 
-        override fun onError(error: HMSException) {
-          self.emitHMSError(error)
+        override fun onError(e: HMSException) {
+          self.emitHMSError(e)
         }
       },
     )
@@ -1707,7 +1819,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "startAudioshare: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1727,15 +1838,13 @@ class HMSRNSDK(
         override fun onSuccess() {
           isAudioSharing = false
           audioshareCallback = null
-          callback?.resolve(emitHMSSuccess())
+          callback?.resolve(true)
         }
       },
     )
   }
 
-  fun getAudioMixingMode(): AudioMixingMode {
-    return audioMixingMode
-  }
+  fun getAudioMixingMode(): AudioMixingMode = audioMixingMode
 
   fun setAudioMixingMode(
     data: ReadableMap,
@@ -1747,10 +1856,9 @@ class HMSRNSDK(
       val mode = HMSHelper.getAudioMixingMode(data.getString("audioMixingMode"))
       audioMixingMode = mode
       hmsSDK?.setAudioMixingMode(mode)
-      callback?.resolve(emitHMSSuccess())
+      callback?.resolve(true)
     } else {
       val errorMessage = "setAudioMixingMode: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1782,6 +1890,9 @@ class HMSRNSDK(
         "isLocal" -> {
           result.putBoolean("isLocal", peer.isLocal)
         }
+        "type" -> {
+          result.putString("type", peer.type.name)
+        }
         "networkQuality" -> {
           if (peer.networkQuality !== null) {
             result.putMap("networkQuality", HMSDecoder.getHmsNetworkQuality(peer.networkQuality))
@@ -1880,6 +1991,12 @@ class HMSRNSDK(
         "hlsRecordingState" -> {
           data.putMap("hlsRecordingState", HMSDecoder.getHMSHlsRecordingState(hmsRoom.hlsRecordingState))
         }
+        "isLargeRoom" -> {
+          data.putBoolean("isLargeRoom", hmsRoom.isLargeRoom)
+        }
+        "transcriptions" -> {
+          data.putArray("transcriptions", HMSDecoder.getTranscriptionsList(hmsRoom.transcriptions))
+        }
       }
 
       return data
@@ -1899,11 +2016,10 @@ class HMSRNSDK(
 
       if (eventType != null) {
         eventsEnableStatus[eventType] = true
-        promise?.resolve(emitHMSSuccess())
+        promise?.resolve(getPromiseResolveData())
       }
     } else {
       val errorMessage = "enableEvent: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -1919,11 +2035,10 @@ class HMSRNSDK(
 
       if (eventType != null) {
         eventsEnableStatus[eventType] = false
-        promise?.resolve(emitHMSSuccess())
+        promise?.resolve(getPromiseResolveData())
       }
     } else {
       val errorMessage = "disableEvent: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -1938,11 +2053,10 @@ class HMSRNSDK(
       val roleName = data.getString("roleName")
       if (roleName != null) {
         HMSDecoder.setRestrictRoleData(roleName, true)
-        promise?.resolve(emitHMSSuccess())
+        promise?.resolve(getPromiseResolveData())
       }
     } else {
       val errorMessage = "restrictData: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -1962,7 +2076,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "getRemoteVideoTrackFromTrackId: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -1982,7 +2095,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "getRemoteAudioTrackFromTrackId: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -2003,7 +2115,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "getVideoTrackLayer: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -2025,7 +2136,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "getVideoTrackLayerDefinition: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -2057,7 +2167,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "setVideoTrackLayer: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -2135,7 +2244,7 @@ class HMSRNSDK(
         savePath,
       ) { success ->
         if (flashActionOnSuccess > 0) {
-          cameraControl.setFlash(flashActionOnSuccess === 1)
+          cameraControl.setFlash(flashActionOnSuccess == 1)
         }
         if (success) {
           promise?.resolve(imagePath)
@@ -2145,7 +2254,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "captureImageAtMaxSupportedResolution: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -2159,7 +2267,6 @@ class HMSRNSDK(
     val requiredKeys = HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("key", "String")))
     if (requiredKeys === null) {
       val key = data.getString("key")!!
-      val value = data.getString("value")
 
       sessionStore.let {
         if (it === null) {
@@ -2168,18 +2275,27 @@ class HMSRNSDK(
           return
         }
 
+        val value: Any? =
+          when (data.getType("value")) {
+            ReadableType.Boolean -> data.getBoolean("value")
+            ReadableType.Map -> data.getMap("value")?.toHashMap()
+            ReadableType.String -> data.getString("value")
+            ReadableType.Array -> data.getArray("value")?.toArrayList()
+            ReadableType.Number -> data.getDouble("value")
+            ReadableType.Null -> null
+          }
+
         it.set(
           value, // data/value
           key, // key
           object : HMSActionResultListener {
             override fun onError(error: HMSException) {
-              promise?.reject(error.code.toString(), error.message)
+              promise?.reject(error.code.toString(), error.description)
             }
 
             override fun onSuccess() {
               val result: WritableMap = Arguments.createMap()
               result.putBoolean("success", true)
-              result.putString("finalValue", value)
               promise?.resolve(result)
             }
           },
@@ -2219,9 +2335,13 @@ class HMSRNSDK(
                   promise?.resolve(null)
                 } else {
                   if (sm.isJsonPrimitive) {
-                    promise?.resolve(sm.asString)
+                    promise?.resolve(sm)
                   } else if (sm.isJsonNull) {
                     promise?.resolve(null)
+                  } else if (sm.isJsonArray) {
+                    promise?.resolve(HMSDecoder.getReadableArrayFromJsonArray(sm.asJsonArray))
+                  } else if (sm.isJsonObject) {
+                    promise?.resolve(HMSDecoder.getReadableMapFromJsonObject(sm.asJsonObject))
                   } else {
                     promise?.resolve(sm.toString())
                   }
@@ -2265,12 +2385,23 @@ class HMSRNSDK(
 
               value.let { sm ->
                 if (sm == null) {
-                  map.putString("value", null)
+                  map.putNull("value")
                 } else {
                   if (sm.isJsonPrimitive) {
-                    map.putString("value", sm.asString)
+                    val primitive = sm.asJsonPrimitive
+                    if (primitive.isBoolean) {
+                      map.putBoolean("value", primitive.asBoolean)
+                    } else if (primitive.isNumber) {
+                      map.putDouble("value", primitive.asDouble)
+                    } else {
+                      map.putString("value", sm.asString)
+                    }
                   } else if (sm.isJsonNull) {
-                    map.putString("value", null)
+                    map.putNull("value")
+                  } else if (sm.isJsonArray) {
+                    map.putArray("value", HMSDecoder.getReadableArrayFromJsonArray(sm.asJsonArray))
+                  } else if (sm.isJsonObject) {
+                    map.putMap("value", HMSDecoder.getReadableMapFromJsonObject(sm.asJsonObject))
                   } else {
                     map.putString("value", sm.toString())
                   }
@@ -2433,7 +2564,12 @@ class HMSRNSDK(
   }
 
   fun getPeerListIterator(data: ReadableMap): WritableMap? {
-    val uniqueId = data.getInt("uniqueId")
+    val uniqueId = data.getString("uniqueId")
+    if (uniqueId == null) {
+      print("Error in getPeerListIterator: uniqueId is not available")
+      return null
+    }
+
     val options = HMSHelper.getPeerListIteratorOptions(data)
 
     hmsSDK?.let {
@@ -2442,7 +2578,7 @@ class HMSRNSDK(
       peerListIterators[uniqueId] = iterator
       val map = Arguments.createMap()
       map.putBoolean("success", true)
-      map.putInt("uniqueId", uniqueId)
+      map.putString("uniqueId", uniqueId)
       return map
     }
     print("Error in getPeerListIterator: HMS SDK is not available")
@@ -2453,7 +2589,7 @@ class HMSRNSDK(
     data: ReadableMap,
     promise: Promise?,
   ) {
-    val uniqueId = data.getInt("uniqueId")
+    val uniqueId = data.getString("uniqueId")
 
     peerListIterators[uniqueId]?.let {
       promise?.resolve(it.hasNext())
@@ -2466,7 +2602,7 @@ class HMSRNSDK(
     data: ReadableMap,
     promise: Promise?,
   ) {
-    val uniqueId = data.getInt("uniqueId")
+    val uniqueId = data.getString("uniqueId")
 
     val peerListIterator = peerListIterators[uniqueId]
 
@@ -2482,14 +2618,69 @@ class HMSRNSDK(
         }
 
         override fun onSuccess(result: ArrayList<HMSPeer>) {
-          val array = Arguments.createArray()
+          val resultData: WritableMap = Arguments.createMap()
+
+          resultData.putInt("totalCount", peerListIterator.totalCount)
+
+          val array: WritableArray = Arguments.createArray()
           for (peer in result) {
-            val hmsPeer = HMSDecoder.getHmsPeerSubset(peer, null)
+            val hmsPeer = HMSDecoder.getHmsPeer(peer)
             array.pushMap(hmsPeer)
           }
-          promise?.resolve(array)
+
+          resultData.putArray("peers", array)
+
+          promise?.resolve(resultData)
+        }
+      },
+    )
+  }
+
+  // region Webrtc Transcription
+  fun handleRealTimeTranscription(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    when (data.getString("action")) {
+      "start" -> startRealTimeTranscription(data, promise)
+      "stop" -> stopRealTimeTranscription(data, promise)
+    }
+  }
+
+  private fun startRealTimeTranscription(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    hmsSDK?.startRealTimeTranscription(
+      TranscriptionsMode.CAPTION,
+      object : HMSActionResultListener {
+        override fun onError(error: HMSException) {
+          promise?.reject(error.code.toString(), error.message)
+        }
+
+        override fun onSuccess() {
+          promise?.resolve(true)
+        }
+      },
+    )
+  }
+
+  private fun stopRealTimeTranscription(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    hmsSDK?.stopRealTimeTranscription(
+      TranscriptionsMode.CAPTION,
+      object : HMSActionResultListener {
+        override fun onError(error: HMSException) {
+          promise?.reject(error.code.toString(), error.message)
+        }
+
+        override fun onSuccess() {
+          promise?.resolve(true)
         }
       },
     )
   }
+  // endregion Webrtc Transcription
 }