@100mslive/react-native-hms 1.8.0 → 1.9.1-beta.0

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

@@ -12,6 +12,7 @@ import live.hms.video.error.HMSException
 import live.hms.video.media.settings.HMSLayer
 import live.hms.video.media.tracks.*
 import live.hms.video.sdk.*
+import live.hms.video.sdk.listeners.PeerListResultListener
 import live.hms.video.sdk.models.*
 import live.hms.video.sdk.models.enums.AudioMixingMode
 import live.hms.video.sdk.models.enums.HMSPeerUpdate
@@ -50,6 +51,7 @@ class HMSRNSDK(
   private var eventsEnableStatus = mutableMapOf<String, Boolean>()
   private var sessionStore: HmsSessionStore? = null
   private val keyChangeObservers = mutableMapOf<String, HMSKeyChangeListener?>()
+  private val peerListIterators = mutableMapOf<String, PeerListIterator>()
 
   init {
     val builder = HMSSDK.Builder(reactApplicationContext)
@@ -65,10 +67,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")))) {
@@ -131,6 +135,7 @@ class HMSRNSDK(
     eventsEnableStatus.clear()
     sessionStore = null
     keyChangeObservers.clear()
+    peerListIterators.clear()
     HMSDecoder.clearRestrictDataStates()
   }
 
@@ -144,7 +149,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()
@@ -153,7 +158,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)
@@ -241,6 +246,34 @@ class HMSRNSDK(
             data.putString("id", id)
             delegate.emitEvent("ON_PREVIEW", 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()
+
+            if (addedPeers != null) {
+              for (peer in addedPeers) {
+                addedPeersArray.pushMap(HMSDecoder.getHmsPeerSubset(peer))
+              }
+            }
+
+            if (removedPeers != null) {
+              for (peer in removedPeers) {
+                removedPeersArray.pushMap(HMSDecoder.getHmsPeerSubset(peer))
+              }
+            }
+
+            data.putArray("addedPeers", addedPeersArray)
+            data.putArray("removedPeers", removedPeersArray)
+            delegate.emitEvent("ON_PEER_LIST_UPDATED", data)
+          }
+           */
         },
       )
     } else {
@@ -264,187 +297,212 @@ 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
-                }
-                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)
+            override fun onRemovedFromRoom(notification: HMSRemovedFromRoom) {
+              super.onRemovedFromRoom(notification)
+              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 onError(error: HMSException) {
-                if (eventsEnableStatus["ON_ERROR"] != true) {
-                  return
-                }
-                self.emitHMSError(error)
+              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)
+            }
+
+            override fun onJoin(room: HMSRoom) {
+              if (eventsEnableStatus["ON_JOIN"] != true) {
+                return
               }
+              val roomData = HMSDecoder.getHmsRoomSubset(room)
 
-              override fun onJoin(room: HMSRoom) {
-                if (eventsEnableStatus["ON_JOIN"] != true) {
-                  return
-                }
-                val roomData = HMSDecoder.getHmsRoomSubset(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 (eventsEnableStatus["3"] != true) {
+                return
               }
-
-              override fun onPeerUpdate(
-                type: HMSPeerUpdate,
-                peer: HMSPeer,
+              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
               }
-
-              override fun onRoomUpdate(
-                type: HMSRoomUpdate,
-                hmsRoom: HMSRoom,
+              if (!networkQualityUpdatesAttached &&
+                type === HMSPeerUpdate.NETWORK_QUALITY_UPDATED
               ) {
-                if (eventsEnableStatus["ON_ROOM_UPDATE"] != true) {
-                  return
-                }
+                return
+              }
+              val hmsPeer = HMSDecoder.getHmsPeerSubsetForPeerUpdateEvent(peer, type)
+              delegate.emitEvent("3", hmsPeer)
+            }
+
+            override fun onRoomUpdate(
+              type: HMSRoomUpdate,
+              hmsRoom: HMSRoom,
+            ) {
+              if (eventsEnableStatus["ON_ROOM_UPDATE"] != true) {
+                return
+              }
+
+              val updateType = type.name
+              val roomData = HMSDecoder.getHmsRoomSubset(hmsRoom, type)
 
-                val updateType = type.name
-                val roomData = HMSDecoder.getHmsRoomSubset(hmsRoom, type)
+              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 onTrackUpdate(
+              type: HMSTrackUpdate,
+              track: HMSTrack,
+              peer: HMSPeer,
+            ) {
+              if (eventsEnableStatus["ON_TRACK_UPDATE"] != true) {
+                return
               }
+              val updateType = type.name
+              val hmsPeer = HMSDecoder.getHmsPeerSubset(peer)
+              val hmsTrack = HMSDecoder.getHmsTrack(track)
 
-              override fun onTrackUpdate(
-                type: HMSTrackUpdate,
-                track: HMSTrack,
-                peer: HMSPeer,
-              ) {
-                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 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 onRoleChangeRequest(request: HMSRoleChangeRequest) {
-                recentRoleChangeRequest = request
-                if (eventsEnableStatus["ON_ROLE_CHANGE_REQUEST"] != true) {
-                  return
+              if (addedPeers != null) {
+                for (peer in addedPeers) {
+                  addedPeersArray.pushMap(HMSDecoder.getHmsPeerSubset(peer))
                 }
-                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
+              if (removedPeers != null) {
+                for (peer in removedPeers) {
+                  removedPeersArray.pushMap(HMSDecoder.getHmsPeerSubset(peer))
                 }
-                val data: WritableMap = Arguments.createMap()
-                data.putString("id", id)
-                delegate.emitEvent("ON_SESSION_STORE_AVAILABLE", data)
               }
-            },
-          )
-        } catch (e: HMSException) {
-          self.emitHMSError(e)
-        }
+
+              data.putString("id", id)
+              data.putArray("addedPeers", addedPeersArray)
+              data.putArray("removedPeers", removedPeersArray)
+              delegate.emitEvent("ON_PEER_LIST_UPDATED", data)
+            }
+          },
+        )
 
         hmsSDK?.addAudioObserver(
           object : HMSAudioListener {
@@ -629,7 +687,6 @@ class HMSRNSDK(
       )
     } else {
       val errorMessage = "getAuthTokenByRoomCode: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -676,7 +733,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
         }
@@ -710,13 +767,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)
     }
   }
@@ -745,13 +801,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)
     }
   }
@@ -779,17 +834,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)
     }
   }
@@ -827,7 +880,7 @@ class HMSRNSDK(
           force,
           object : HMSActionResultListener {
             override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
+              callback?.resolve(getPromiseResolveData())
             }
 
             override fun onError(error: HMSException) {
@@ -838,7 +891,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "changeRole: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -875,7 +927,7 @@ class HMSRNSDK(
           force,
           object : HMSActionResultListener {
             override fun onSuccess() {
-              promise?.resolve(emitHMSSuccess())
+              promise?.resolve(getPromiseResolveData())
             }
 
             override fun onError(error: HMSException) {
@@ -886,7 +938,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "changeRoleOfPeer: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -918,7 +969,7 @@ class HMSRNSDK(
             toHMSRole,
             object : HMSActionResultListener {
               override fun onSuccess() {
-                promise?.resolve(emitHMSSuccess())
+                promise?.resolve(getPromiseResolveData())
               }
 
               override fun onError(error: HMSException) {
@@ -930,7 +981,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "changeRoleOfPeersWithRoles: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -954,7 +1004,7 @@ class HMSRNSDK(
           mute,
           object : HMSActionResultListener {
             override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
+              callback?.resolve(getPromiseResolveData())
             }
 
             override fun onError(error: HMSException) {
@@ -965,7 +1015,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "changeTrackState: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1008,7 +1057,7 @@ class HMSRNSDK(
         encodedTargetedRoles,
         object : HMSActionResultListener {
           override fun onSuccess() {
-            callback?.resolve(emitHMSSuccess())
+            callback?.resolve(getPromiseResolveData())
           }
 
           override fun onError(error: HMSException) {
@@ -1018,7 +1067,6 @@ class HMSRNSDK(
       )
     } else {
       val errorMessage = "changeTrackStateForRoles: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1039,7 +1087,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "isMute: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1054,30 +1101,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)
     }
   }
@@ -1097,7 +1145,7 @@ class HMSRNSDK(
         data.getBoolean("lock"),
         object : HMSActionResultListener {
           override fun onSuccess() {
-            callback?.resolve(emitHMSSuccess())
+            callback?.resolve(getPromiseResolveData())
             cleanup() // resetting states and doing data cleanup
           }
 
@@ -1108,7 +1156,6 @@ class HMSRNSDK(
       )
     } else {
       val errorMessage = "endRoom: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1155,7 +1202,6 @@ class HMSRNSDK(
       )
     } else {
       val errorMessage = "Missing required keys for previewForRole: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1164,7 +1210,7 @@ class HMSRNSDK(
     hmsSDK?.cancelPreview()
     previewForRoleAudioTrack = null
     previewForRoleVideoTrack = null
-    callback?.resolve(emitHMSSuccess())
+    callback?.resolve(getPromiseResolveData())
   }
 
   fun acceptRoleChange(callback: Promise?) {
@@ -1173,7 +1219,7 @@ class HMSRNSDK(
         recentRoleChangeRequest!!,
         object : HMSActionResultListener {
           override fun onSuccess() {
-            callback?.resolve(emitHMSSuccess())
+            callback?.resolve(getPromiseResolveData())
           }
 
           override fun onError(error: HMSException) {
@@ -1186,7 +1232,6 @@ class HMSRNSDK(
       previewForRoleVideoTrack = null
     } else {
       val errorMessage = "acceptRoleChange: recentRoleChangeRequest not found"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1209,7 +1254,7 @@ class HMSRNSDK(
         )
       }
       if (customError === null) {
-        callback?.resolve(emitHMSSuccess())
+        callback?.resolve(getPromiseResolveData())
       } else {
         rejectCallback(callback, customError!!.message)
       }
@@ -1217,25 +1262,23 @@ 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
-        }
+      val remotePeers = hmsSDK?.getRemotePeers()
+
+      remotePeers?.forEach() {
+        it.audioTrack?.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,
@@ -1248,12 +1291,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)
     }
   }
 
@@ -1281,7 +1328,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "isPlaybackAllowed: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1306,7 +1352,7 @@ class HMSRNSDK(
     callback?.resolve(roles)
   }
 
-  fun setVolume(data: ReadableMap) {
+  fun setVolume(data: ReadableMap, callback: Promise?) {
     val requiredKeys =
       HMSHelper.getUnavailableRequiredKey(
         data,
@@ -1339,13 +1385,13 @@ class HMSRNSDK(
             }
           }
         }
-        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)
     }
   }
 
@@ -1367,7 +1413,6 @@ class HMSRNSDK(
       callback?.reject("101", "TRACK_IDS_DO_NOT_MATCH")
     } else {
       val errorMessage = "getVolume: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1386,7 +1431,7 @@ class HMSRNSDK(
           metadata,
           object : HMSActionResultListener {
             override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
+              callback?.resolve(getPromiseResolveData())
             }
 
             override fun onError(error: HMSException) {
@@ -1397,7 +1442,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "changeMetadata: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1415,14 +1459,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) {
@@ -1433,7 +1476,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "startRTMPOrRecording: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1442,7 +1484,7 @@ class HMSRNSDK(
     hmsSDK?.stopRtmpAndRecording(
       object : HMSActionResultListener {
         override fun onSuccess() {
-          callback?.resolve(emitHMSSuccess())
+          callback?.resolve(getPromiseResolveData())
         }
 
         override fun onError(error: HMSException) {
@@ -1476,7 +1518,7 @@ class HMSRNSDK(
 
         override fun onSuccess() {
           screenshareCallback = null
-          callback?.resolve(emitHMSSuccess())
+          callback?.resolve(getPromiseResolveData())
         }
       },
     )
@@ -1491,7 +1533,7 @@ class HMSRNSDK(
       hlsConfig,
       object : HMSActionResultListener {
         override fun onSuccess() {
-          callback?.resolve(emitHMSSuccess())
+          callback?.resolve(getPromiseResolveData())
         }
 
         override fun onError(error: HMSException) {
@@ -1506,7 +1548,7 @@ class HMSRNSDK(
       null,
       object : HMSActionResultListener {
         override fun onSuccess() {
-          callback?.resolve(emitHMSSuccess())
+          callback?.resolve(getPromiseResolveData())
         }
 
         override fun onError(error: HMSException) {
@@ -1548,7 +1590,7 @@ class HMSRNSDK(
           name,
           object : HMSActionResultListener {
             override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
+              callback?.resolve(getPromiseResolveData())
             }
 
             override fun onError(error: HMSException) {
@@ -1557,12 +1599,10 @@ class HMSRNSDK(
           },
         )
       } else {
-        self.emitCustomError("NAME_UNDEFINED")
         callback?.reject("101", "NAME_UNDEFINED")
       }
     } else {
       val errorMessage = "changeName: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1583,26 +1623,32 @@ 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(true)
+      }
     } 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)
     }
   }
 
@@ -1647,7 +1693,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "startAudioshare: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1667,7 +1712,7 @@ class HMSRNSDK(
         override fun onSuccess() {
           isAudioSharing = false
           audioshareCallback = null
-          callback?.resolve(emitHMSSuccess())
+          callback?.resolve(getPromiseResolveData())
         }
       },
     )
@@ -1687,10 +1732,9 @@ class HMSRNSDK(
       val mode = HMSHelper.getAudioMixingMode(data.getString("audioMixingMode"))
       audioMixingMode = mode
       hmsSDK?.setAudioMixingMode(mode)
-      callback?.resolve(emitHMSSuccess())
+      callback?.resolve(getPromiseResolveData())
     } else {
       val errorMessage = "setAudioMixingMode: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
@@ -1733,6 +1777,9 @@ class HMSRNSDK(
         "role" -> {
           result.putMap("role", HMSDecoder.getHmsRole(peer.hmsRole))
         }
+        "isHandRaised" -> {
+          result.putBoolean("isHandRaised", peer.isHandRaised)
+        }
         "customerUserID" -> {
           if (peer.customerUserID !== null) {
             result.putString("customerUserID", peer.customerUserID)
@@ -1836,11 +1883,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)
     }
   }
@@ -1856,11 +1902,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)
     }
   }
@@ -1875,11 +1920,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)
     }
   }
@@ -1899,7 +1943,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "getRemoteVideoTrackFromTrackId: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -1919,7 +1962,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "getRemoteAudioTrackFromTrackId: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -1940,7 +1982,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "getVideoTrackLayer: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -1962,7 +2003,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "getVideoTrackLayerDefinition: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -1994,7 +2034,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "setVideoTrackLayer: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -2072,7 +2111,7 @@ class HMSRNSDK(
         savePath,
       ) { success ->
         if (flashActionOnSuccess > 0) {
-          cameraControl.setFlash(flashActionOnSuccess === 1)
+          cameraControl.setFlash(flashActionOnSuccess == 1)
         }
         if (success) {
           promise?.resolve(imagePath)
@@ -2082,7 +2121,6 @@ class HMSRNSDK(
       }
     } else {
       val errorMessage = "captureImageAtMaxSupportedResolution: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
       rejectCallback(promise, errorMessage)
     }
   }
@@ -2308,4 +2346,137 @@ class HMSRNSDK(
       },
     )
   }
+
+  fun raiseLocalPeerHand(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    hmsSDK?.raiseLocalPeerHand(
+      object : HMSActionResultListener {
+        override fun onError(error: HMSException) {
+          promise?.reject(error.code.toString(), error.message)
+        }
+
+        override fun onSuccess() {
+          promise?.resolve(true)
+        }
+      },
+    )
+  }
+
+  fun lowerLocalPeerHand(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    hmsSDK?.lowerLocalPeerHand(
+      object : HMSActionResultListener {
+        override fun onError(error: HMSException) {
+          promise?.reject(error.code.toString(), error.message)
+        }
+
+        override fun onSuccess() {
+          promise?.resolve(true)
+        }
+      },
+    )
+  }
+
+  fun lowerRemotePeerHand(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val peerId = data.getString("peerId")
+    peerId?.let { peerID ->
+      hmsSDK?.getRoom()?.let { room ->
+        val peer = HMSHelper.getPeerFromPeerId(peerID, room)
+        peer?.let { peer ->
+          hmsSDK?.lowerRemotePeerHand(
+            forPeer = peer,
+            object : HMSActionResultListener {
+              override fun onError(error: HMSException) {
+                promise?.reject(error.code.toString(), error.message)
+              }
+
+              override fun onSuccess() {
+                promise?.resolve(true)
+              }
+            },
+          )
+        }
+      }
+    }
+  }
+
+  fun getPeerListIterator(data: ReadableMap): WritableMap? {
+    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 {
+      val iterator = it.getPeerListIterator(options)
+
+      peerListIterators[uniqueId] = iterator
+      val map = Arguments.createMap()
+      map.putBoolean("success", true)
+      map.putString("uniqueId", uniqueId)
+      return map
+    }
+    print("Error in getPeerListIterator: HMS SDK is not available")
+    return null
+  }
+
+  fun peerListIteratorHasNext(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val uniqueId = data.getString("uniqueId")
+
+    peerListIterators[uniqueId]?.let {
+      promise?.resolve(it.hasNext())
+      return
+    }
+    promise?.reject("101", "PeerListIterator is not available")
+  }
+
+  fun peerListIteratorNext(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val uniqueId = data.getString("uniqueId")
+
+    val peerListIterator = peerListIterators[uniqueId]
+
+    if (peerListIterator == null) {
+      promise?.reject("101", "PeerListIterator is not available")
+      return
+    }
+
+    peerListIterator.next(
+      object : PeerListResultListener {
+        override fun onError(error: HMSException) {
+          promise?.reject(error.code.toString(), error.message)
+        }
+
+        override fun onSuccess(result: ArrayList<HMSPeer>) {
+          val resultData: WritableMap = Arguments.createMap()
+
+          resultData.putInt("totalCount", peerListIterator.totalCount)
+
+          val array: WritableArray = Arguments.createArray()
+          for (peer in result) {
+            val hmsPeer = HMSDecoder.getHmsPeer(peer)
+            array.pushMap(hmsPeer)
+          }
+
+          resultData.putArray("peers", array)
+
+          promise?.resolve(resultData)
+        }
+      },
+    )
+  }
 }