@100mslive/react-native-hms 0.9.7 → 0.9.91

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

@@ -6,12 +6,13 @@ import com.facebook.react.bridge.*
 import com.facebook.react.bridge.UiThreadUtil.runOnUiThread
 import java.util.*
 import kotlinx.coroutines.launch
+import live.hms.video.audio.HMSAudioManager
+import live.hms.video.connection.stats.*
 import live.hms.video.error.HMSException
-import live.hms.video.media.tracks.HMSRemoteAudioTrack
-import live.hms.video.media.tracks.HMSTrack
-import live.hms.video.media.tracks.HMSTrackType
+import live.hms.video.media.tracks.*
 import live.hms.video.sdk.*
 import live.hms.video.sdk.models.*
+import live.hms.video.sdk.models.enums.AudioMixingMode
 import live.hms.video.sdk.models.enums.HMSPeerUpdate
 import live.hms.video.sdk.models.enums.HMSRoomUpdate
 import live.hms.video.sdk.models.enums.HMSTrackUpdate
@@ -27,10 +28,15 @@ class HMSRNSDK(
 ) {
   var hmsSDK: HMSSDK? = null
   var screenshareCallback: Promise? = null
+  var audioshareCallback: Promise? = null
+  var isAudioSharing: Boolean = false
   var delegate: HMSManager = HmsDelegate
   private var recentRoleChangeRequest: HMSRoleChangeRequest? = null
   private var context: ReactApplicationContext = reactApplicationContext
   private var previewInProgress: Boolean = false
+  private var reconnectingStage: Boolean = false
+  private var rtcStatsAttached: Boolean = false
+  private var audioMixingMode: AudioMixingMode = AudioMixingMode.TALK_AND_MUSIC
   private var id: String = sdkId
   private var self = this
 
@@ -45,8 +51,7 @@ class HMSRNSDK(
 
   private fun emitCustomError(message: String) {
     val data: WritableMap = Arguments.createMap()
-    val hmsError = HMSException(102, message, message, message, message)
-    data.putString("event", "ON_ERROR")
+    val hmsError = HMSException(6002, message, message, message, message, null, false)
     data.putString("id", id)
     data.putMap("error", HMSDecoder.getError(hmsError))
     delegate.emitEvent("ON_ERROR", data)
@@ -55,20 +60,26 @@ class HMSRNSDK(
   private fun emitRequiredKeysError(message: String) {
     val data: WritableMap = Arguments.createMap()
     val hmsError =
-        HMSException(102, "REQUIRED_KEYS_NOT_FOUND", "SEND_ALL_REQUIRED_KEYS", message, message)
-    data.putString("event", "ON_ERROR")
+        HMSException(
+            6002,
+            "REQUIRED_KEYS_NOT_FOUND",
+            "SEND_ALL_REQUIRED_KEYS",
+            message,
+            message,
+            null,
+            false
+        )
     data.putString("id", id)
     data.putMap("error", HMSDecoder.getError(hmsError))
     delegate.emitEvent("ON_ERROR", data)
   }
 
   private fun rejectCallback(callback: Promise?, message: String) {
-    callback?.reject("102", message)
+    callback?.reject("6002", message)
   }
 
   fun emitHMSError(error: HMSException) {
     val data: WritableMap = Arguments.createMap()
-    data.putString("event", "ON_ERROR")
     data.putString("id", id)
     data.putMap("error", HMSDecoder.getError(error))
     delegate.emitEvent("ON_ERROR", data)
@@ -85,7 +96,7 @@ class HMSRNSDK(
 
   fun preview(credentials: ReadableMap) {
     if (previewInProgress) {
-      self.emitCustomError("PREVIEW_ALREADY_IN_PROGRESS")
+      self.emitCustomError("PREVIEW_IS_IN_PROGRESS")
       return
     }
     val requiredKeys =
@@ -181,6 +192,7 @@ class HMSRNSDK(
             arrayOf(Pair("username", "String"), Pair("authToken", "String"))
         )
     if (requiredKeys === null) {
+      reconnectingStage = false
       val config = HMSHelper.getHmsConfig(credentials)
 
       HMSCoroutineScope.launch {
@@ -312,6 +324,7 @@ class HMSRNSDK(
                 }
 
                 override fun onReconnected() {
+                  reconnectingStage = false
                   val data: WritableMap = Arguments.createMap()
                   data.putString("event", "RECONNECTED")
                   data.putString("id", id)
@@ -319,7 +332,9 @@ class HMSRNSDK(
                 }
 
                 override fun onReconnecting(error: HMSException) {
+                  reconnectingStage = true
                   val data: WritableMap = Arguments.createMap()
+                  data.putMap("error", HMSDecoder.getError(error))
                   data.putString("event", "RECONNECTING")
                   data.putString("id", id)
                   delegate.emitEvent("RECONNECTING", data)
@@ -356,6 +371,109 @@ class HMSRNSDK(
               }
             }
         )
+
+        hmsSDK?.addRtcStatsObserver(
+            object : HMSStatsObserver {
+              override fun onLocalAudioStats(
+                  audioStats: HMSLocalAudioStats,
+                  hmsTrack: HMSTrack?,
+                  hmsPeer: HMSPeer?
+              ) {
+                if (!rtcStatsAttached) {
+                  return
+                }
+                val localAudioStats = HMSDecoder.getLocalAudioStats(audioStats)
+                val track = HMSDecoder.getHmsLocalAudioTrack(hmsTrack as HMSLocalAudioTrack)
+                val peer = HMSDecoder.getHmsPeer(hmsPeer)
+
+                val data: WritableMap = Arguments.createMap()
+                data.putMap("localAudioStats", localAudioStats)
+                data.putMap("track", track)
+                data.putMap("peer", peer)
+                data.putString("id", id)
+                delegate.emitEvent("ON_LOCAL_AUDIO_STATS", data)
+              }
+
+              override fun onLocalVideoStats(
+                  videoStats: HMSLocalVideoStats,
+                  hmsTrack: HMSTrack?,
+                  hmsPeer: HMSPeer?
+              ) {
+                if (!rtcStatsAttached) {
+                  return
+                }
+
+                val localVideoStats = HMSDecoder.getLocalVideoStats(videoStats)
+                val track = HMSDecoder.getHmsLocalVideoTrack(hmsTrack as HMSLocalVideoTrack)
+                val peer = HMSDecoder.getHmsPeer(hmsPeer)
+
+                val data: WritableMap = Arguments.createMap()
+                data.putMap("localVideoStats", localVideoStats)
+                data.putMap("track", track)
+                data.putMap("peer", peer)
+                data.putString("id", id)
+                delegate.emitEvent("ON_LOCAL_VIDEO_STATS", data)
+              }
+
+              override fun onRTCStats(rtcStats: HMSRTCStatsReport) {
+                if (!rtcStatsAttached) {
+                  return
+                }
+                val video = HMSDecoder.getHMSRTCStats(rtcStats.video)
+                val audio = HMSDecoder.getHMSRTCStats(rtcStats.audio)
+                val combined = HMSDecoder.getHMSRTCStats(rtcStats.combined)
+
+                val data: WritableMap = Arguments.createMap()
+                data.putMap("video", video)
+                data.putMap("audio", audio)
+                data.putMap("combined", combined)
+                data.putString("id", id)
+                delegate.emitEvent("ON_RTC_STATS", data)
+              }
+
+              override fun onRemoteAudioStats(
+                  audioStats: HMSRemoteAudioStats,
+                  hmsTrack: HMSTrack?,
+                  hmsPeer: HMSPeer?
+              ) {
+                if (!rtcStatsAttached) {
+                  return
+                }
+
+                val remoteAudioStats = HMSDecoder.getRemoteAudioStats(audioStats)
+                val track = HMSDecoder.getHmsRemoteAudioTrack(hmsTrack as HMSRemoteAudioTrack)
+                val peer = HMSDecoder.getHmsPeer(hmsPeer)
+
+                val data: WritableMap = Arguments.createMap()
+                data.putMap("remoteAudioStats", remoteAudioStats)
+                data.putMap("track", track)
+                data.putMap("peer", peer)
+                data.putString("id", id)
+                delegate.emitEvent("ON_REMOTE_AUDIO_STATS", data)
+              }
+
+              override fun onRemoteVideoStats(
+                  videoStats: HMSRemoteVideoStats,
+                  hmsTrack: HMSTrack?,
+                  hmsPeer: HMSPeer?
+              ) {
+                if (!rtcStatsAttached) {
+                  return
+                }
+
+                val remoteVideoStats = HMSDecoder.getRemoteVideoStats(videoStats)
+                val track = HMSDecoder.getHmsRemoteVideoTrack(hmsTrack as HMSRemoteVideoTrack)
+                val peer = HMSDecoder.getHmsPeer(hmsPeer)
+
+                val data: WritableMap = Arguments.createMap()
+                data.putMap("remoteVideoStats", remoteVideoStats)
+                data.putMap("track", track)
+                data.putMap("peer", peer)
+                data.putString("id", id)
+                delegate.emitEvent("ON_REMOTE_VIDEO_STATS", data)
+              }
+            }
+        )
       }
     } else {
       val errorMessage = "join: $requiredKeys"
@@ -380,19 +498,25 @@ class HMSRNSDK(
   }
 
   fun leave(callback: Promise?) {
-    hmsSDK?.leave(
-        object : HMSActionResultListener {
-          override fun onSuccess() {
-            screenshareCallback = null
-            callback?.resolve(emitHMSSuccess())
-          }
+    if (reconnectingStage) {
+      callback?.reject("101", "Still in reconnecting stage")
+    } else {
+      hmsSDK?.leave(
+          object : HMSActionResultListener {
+            override fun onSuccess() {
+              isAudioSharing = false
+              screenshareCallback = null
+              audioshareCallback = null
+              callback?.resolve(emitHMSSuccess())
+            }
 
-          override fun onError(error: HMSException) {
-            callback?.reject(error.code.toString(), error.message)
-            self.emitHMSError(error)
+            override fun onError(error: HMSException) {
+              callback?.reject(error.code.toString(), error.message)
+              self.emitHMSError(error)
+            }
           }
-        }
-    )
+      )
+    }
   }
 
   fun sendBroadcastMessage(data: ReadableMap, callback: Promise?) {
@@ -611,17 +735,11 @@ class HMSRNSDK(
     val requiredKeys = HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("trackId", "String")))
     if (requiredKeys === null) {
       val trackId = data.getString("trackId")
-      val localTrack = HMSHelper.getTrackFromTrackId(trackId, hmsSDK?.getRoom())
-      if (localTrack == null) {
-        val track = HMSHelper.getTrackFromTrackId(trackId, hmsSDK?.getRoom())
-        if (track != null) {
-          val mute = track.isMute
-          callback?.resolve(mute)
-        } else {
-          callback?.reject("101", "NOT_FOUND")
-        }
+      val track = HMSHelper.getTrackFromTrackId(trackId, hmsSDK?.getRoom())
+      if (track == null) {
+        callback?.reject("101", "TRACK_NOT_FOUND")
       } else {
-        val mute = localTrack.isMute
+        val mute = track.isMute
         callback?.resolve(mute)
       }
     } else {
@@ -709,13 +827,13 @@ class HMSRNSDK(
       )
       recentRoleChangeRequest = null
     } else {
-      val errorMessage = "acceptRoleChange: recentRoleChangeRequest null"
+      val errorMessage = "acceptRoleChange: recentRoleChangeRequest not found"
       self.emitRequiredKeysError(errorMessage)
       rejectCallback(callback, errorMessage)
     }
   }
 
-  fun remoteMuteAllAudio() {
+  fun remoteMuteAllAudio(callback: Promise?) {
     val allAudioTracks = hmsSDK?.getRoom()?.let { HmsUtilities.getAllAudioTracks(it) }
     if (allAudioTracks != null) {
       var customError: HMSException? = null
@@ -731,10 +849,13 @@ class HMSRNSDK(
             }
         )
       }
-      if (customError != null) {
-        self.emitHMSError(customError!!)
+      if (customError === null) {
+        callback?.resolve(emitHMSSuccess())
+      } else {
+        rejectCallback(callback, customError!!.message)
       }
     }
+    rejectCallback(callback, "Audio tracks not found")
   }
 
   fun setPlaybackForAllAudio(data: ReadableMap) {
@@ -802,7 +923,7 @@ class HMSRNSDK(
           callback?.resolve(isPlaybackAllowed)
         }
         else -> {
-          callback?.reject("101", "NOT_FOUND")
+          callback?.reject("101", "TRACK_NOT_FOUND")
         }
       }
     } else {
@@ -850,7 +971,7 @@ class HMSRNSDK(
             }
           }
         }
-        this.emitCustomError("TRACKID_NOT_MATCHED")
+        this.emitCustomError("TRACK_NOT_FOUND")
       } else {
         this.emitCustomError("REMOTE_PEERS_NOT_FOUND")
       }
@@ -914,27 +1035,25 @@ class HMSRNSDK(
             arrayOf(Pair("record", "Boolean"), Pair("meetingURL", "String"))
         )
     if (requiredKeys === null) {
-      val record = data.getBoolean("record")
-      val meetingURL = data.getString("meetingURL") as String
-      var rtmpURLs = data.getArray("rtmpURLs")
-      if (rtmpURLs == null) {
-        rtmpURLs = Arguments.createArray()
-      }
-      val rtmpURLsList = HMSHelper.getRtmpUrls(rtmpURLs)
-      val config = HMSRecordingConfig(meetingURL, rtmpURLsList, record)
-
-      hmsSDK?.startRtmpOrRecording(
-          config,
-          object : HMSActionResultListener {
-            override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
-            }
-            override fun onError(error: HMSException) {
-              callback?.reject(error.code.toString(), error.message)
-              self.emitHMSError(error)
+      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())
+              }
+              override fun onError(error: HMSException) {
+                callback?.reject(error.code.toString(), error.message)
+                self.emitHMSError(error)
+              }
             }
-          }
-      )
+        )
+      }
     } else {
       val errorMessage = "startRTMPOrRecording: $requiredKeys"
       self.emitRequiredKeysError(errorMessage)
@@ -987,32 +1106,19 @@ class HMSRNSDK(
   }
 
   fun startHLSStreaming(data: ReadableMap, callback: Promise?) {
-    val requiredKeys =
-        HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("meetingURLVariants", "Array")))
-    if (requiredKeys === null) {
-      val meetingURLVariants =
-          data.getArray("meetingURLVariants")?.toArrayList() as? ArrayList<HashMap<String, String>>
-      val hlsMeetingUrlVariant = HMSHelper.getHMSHLSMeetingURLVariants(meetingURLVariants)
-      val hlsRecordingConfig = HMSHelper.getHlsRecordingConfig(data)
-      val config = HMSHLSConfig(hlsMeetingUrlVariant, hlsRecordingConfig)
-
-      hmsSDK?.startHLSStreaming(
-          config,
-          object : HMSActionResultListener {
-            override fun onSuccess() {
-              callback?.resolve(emitHMSSuccess())
-            }
-            override fun onError(error: HMSException) {
-              callback?.reject(error.code.toString(), error.message)
-              self.emitHMSError(error)
-            }
+    val hlsConfig = HMSHelper.getHLSConfig(data)
+    hmsSDK?.startHLSStreaming(
+        hlsConfig,
+        object : HMSActionResultListener {
+          override fun onSuccess() {
+            callback?.resolve(emitHMSSuccess())
           }
-      )
-    } else {
-      val errorMessage = "startHLSStreaming: $requiredKeys"
-      self.emitRequiredKeysError(errorMessage)
-      rejectCallback(callback, errorMessage)
-    }
+          override fun onError(error: HMSException) {
+            callback?.reject(error.code.toString(), error.message)
+            self.emitHMSError(error)
+          }
+        }
+    )
   }
 
   fun stopHLSStreaming(callback: Promise?) {
@@ -1079,4 +1185,123 @@ class HMSRNSDK(
       rejectCallback(callback, errorMessage)
     }
   }
+
+  fun enableRTCStats() {
+    rtcStatsAttached = true
+  }
+
+  fun disableRTCStats() {
+    rtcStatsAttached = false
+  }
+
+  fun getAudioDevicesList(callback: Promise?) {
+    callback?.resolve(HMSHelper.getAudioDevicesList(hmsSDK?.getAudioDevicesList()))
+  }
+
+  fun getAudioOutputRouteType(callback: Promise?) {
+    callback?.resolve(hmsSDK?.getAudioOutputRouteType()?.name)
+  }
+
+  fun switchAudioOutput(data: ReadableMap) {
+    val requiredKeys =
+        HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("audioDevice", "String")))
+    if (requiredKeys === null) {
+      val audioDevice = data.getString("audioDevice")
+      hmsSDK?.switchAudioOutput(HMSHelper.getAudioDevice(audioDevice))
+    } else {
+      val errorMessage = "switchAudioOutput: $requiredKeys"
+      self.emitRequiredKeysError(errorMessage)
+    }
+  }
+
+  fun setAudioMode(data: ReadableMap) {
+    val requiredKeys = HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("audioMode", "Int")))
+    if (requiredKeys === null) {
+      val audioMode = data.getInt("audioMode")
+      hmsSDK?.setAudioMode(audioMode)
+    } else {
+      val errorMessage = "setAudioMode: $requiredKeys"
+      self.emitRequiredKeysError(errorMessage)
+    }
+  }
+
+  fun setAudioDeviceChangeListener() {
+    hmsSDK?.setAudioDeviceChangeListener(
+        object : HMSAudioManager.AudioManagerDeviceChangeListener {
+          override fun onAudioDeviceChanged(
+              device: HMSAudioManager.AudioDevice?,
+              audioDevicesList: Set<HMSAudioManager.AudioDevice>?
+          ) {
+            val data: WritableMap = Arguments.createMap()
+            data.putString("device", device?.name)
+            data.putArray("audioDevicesList", HMSHelper.getAudioDevicesSet(audioDevicesList))
+            data.putString("id", id)
+            delegate.emitEvent("ON_AUDIO_DEVICE_CHANGED", data)
+          }
+
+          override fun onError(error: HMSException) {
+            self.emitHMSError(error)
+          }
+        }
+    )
+  }
+
+  fun startAudioshare(data: ReadableMap, callback: Promise?) {
+    val requiredKeys =
+        HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("audioMixingMode", "String")))
+    if (requiredKeys === null) {
+      audioshareCallback = callback
+      runOnUiThread {
+        val intent = Intent(context, HMSAudioshareActivity::class.java)
+        intent.flags = FLAG_ACTIVITY_NEW_TASK
+        intent.putExtra("id", id)
+        intent.putExtra("audioMixingMode", data.getString("audioMixingMode"))
+        context.startActivity(intent)
+      }
+    } else {
+      val errorMessage = "startAudioshare: $requiredKeys"
+      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(callback, errorMessage)
+    }
+  }
+
+  fun isAudioShared(callback: Promise?) {
+    callback?.resolve(isAudioSharing)
+  }
+
+  fun stopAudioshare(callback: Promise?) {
+    hmsSDK?.stopAudioshare(
+        object : HMSActionResultListener {
+          override fun onError(error: HMSException) {
+            audioshareCallback = null
+            callback?.reject(error.code.toString(), error.message)
+            self.emitHMSError(error)
+          }
+          override fun onSuccess() {
+            isAudioSharing = false
+            audioshareCallback = null
+            callback?.resolve(emitHMSSuccess())
+          }
+        }
+    )
+  }
+
+  fun getAudioMixingMode(): AudioMixingMode {
+    return audioMixingMode
+  }
+
+  fun setAudioMixingMode(data: ReadableMap, callback: Promise?) {
+    val requiredKeys =
+        HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("audioMixingMode", "String")))
+    if (requiredKeys === null) {
+      val mode = HMSHelper.getAudioMixingMode(data.getString("audioMixingMode"))
+      audioMixingMode = mode
+      hmsSDK?.setAudioMixingMode(mode)
+      callback?.resolve(emitHMSSuccess())
+    } else {
+      val errorMessage = "setAudioMixingMode: $requiredKeys"
+      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(callback, errorMessage)
+    }
+  }
 }

package/ios/HMSDecoder.swift

@@ -320,16 +320,18 @@ class HMSDecoder: NSObject {
 
         let endRoom = permissions.endRoom ?? false
         let removeOthers = permissions.removeOthers ?? false
-        let stopPresentation = permissions.stopPresentation ?? false
-        let muteAll = permissions.muteAll ?? false
+        let browserRecording = permissions.browserRecording ?? false
+        let hlsStreaming = permissions.hlsStreaming ?? false
+        let rtmpStreaming = permissions.rtmpStreaming ?? false
         let mute = permissions.mute ?? false
         let unmute = permissions.unmute ?? false
         let changeRole = permissions.changeRole ?? false
 
         return ["endRoom": endRoom,
                 "removeOthers": removeOthers,
-                "stopPresentation": stopPresentation,
-                "muteAll": muteAll,
+                "browserRecording": browserRecording,
+                "hlsStreaming": hlsStreaming,
+                "rtmpStreaming": rtmpStreaming,
                 "mute": mute,
                 "unmute": unmute,
                 "changeRole": changeRole]
@@ -478,16 +480,15 @@ class HMSDecoder: NSObject {
 
     static func getError(_ errorObj: HMSError?) -> [String: Any]? {
         if let error = errorObj {
-            let code = error.code
+            let code = error.code.rawValue
             let description = error.description
-            let localizedDescription = error.localizedDescription
-            let debugDescription = error.debugDescription
             let message = error.message
             let name = error.id
             let id = error.id
             let action = error.action
+            let isTerminal = false
 
-            return ["code": code, "description": description, "localizedDescription": localizedDescription, "debugDescription": debugDescription, "message": message, "name": name, "action": action, "id": id]
+            return ["code": code, "description": description, "message": message, "name": name, "action": action, "id": id, "isTerminal": isTerminal]
         } else {
             return nil
         }

package/ios/HMSHelper.swift

@@ -3,6 +3,19 @@ import Foundation
 
 class HMSHelper: NSObject {
 
+    static func getUnavailableRequiredKey(_ data: NSDictionary, _ requiredKeys: [String]) -> String {
+        for (key) in requiredKeys {
+            let value = data.object(forKey: key)
+            if (value == nil) {
+                return key + "_Is_Required"
+            }
+            if (value is NSNull) {
+                return key + "_Is_Null"
+            }
+        }
+        return "SEND_ALL_REQUIRED_KEYS"
+    }
+
     static func getPeerFromPeerId(_ peerID: String?, remotePeers: [HMSRemotePeer]?, localPeer: HMSLocalPeer?) -> HMSPeer? {
 
         guard let peerID = peerID, let peers = remotePeers else { return nil }
@@ -215,18 +228,15 @@ class HMSHelper: NSObject {
         return hlsVariants
     }
     
-    static func getHlsRecordingConfig(_ data: NSDictionary) -> HMSHLSRecordingConfig? {
-        guard let meetingURLVariants = data.value(forKey: "hlsRecordingConfig") as? NSDictionary
-        else {
-            return nil
-        }
-        guard let singleFilePerLayer = meetingURLVariants.value(forKey: "singleFilePerLayer") as? Bool ,
-        let videoOnDemand = meetingURLVariants.value(forKey: "videoOnDemand") as? Bool
+    static func getHlsRecordingConfig(_ config: NSDictionary?) -> HMSHLSRecordingConfig? {
+        guard let hlsRecordingConfig = config
         else {
             return nil
         }
+        let singleFilePerLayer = hlsRecordingConfig.value(forKey: "singleFilePerLayer") as? Bool
+        let videoOnDemand = hlsRecordingConfig.value(forKey: "videoOnDemand") as? Bool
         
-        return HMSHLSRecordingConfig(singleFilePerLayer: singleFilePerLayer, enableVOD: videoOnDemand)
+        return HMSHLSRecordingConfig(singleFilePerLayer: singleFilePerLayer ?? false, enableVOD: videoOnDemand ?? false)
     }
 
     static func getHMSHLSMeetingURLVariant(_ variant: [String: Any]) -> HMSHLSMeetingURLVariant? {

package/ios/HMSManager.m

@@ -26,7 +26,7 @@ RCT_EXTERN_METHOD(setVolume: (NSDictionary) data)
 RCT_EXTERN_METHOD(build : (NSDictionary) data :(RCTPromiseResolveBlock) resolve :(RCTPromiseRejectBlock) reject)
 RCT_EXTERN_METHOD(leave: (NSDictionary) data :(RCTPromiseResolveBlock) resolve :(RCTPromiseRejectBlock) reject)
 RCT_EXTERN_METHOD(setPlaybackForAllAudio: (NSDictionary) mute)
-RCT_EXTERN_METHOD(remoteMuteAllAudio: (NSDictionary) data)
+RCT_EXTERN_METHOD(remoteMuteAllAudio: (NSDictionary) data :(RCTPromiseResolveBlock) resolve :(RCTPromiseRejectBlock) reject)
 RCT_EXTERN_METHOD(isPlaybackAllowed: (NSDictionary) data :(RCTPromiseResolveBlock) resolve :(RCTPromiseRejectBlock) reject)
 RCT_EXTERN_METHOD(changeMetadata: (NSDictionary) data :(RCTPromiseResolveBlock) resolve :(RCTPromiseRejectBlock) reject)
 RCT_EXTERN_METHOD(startRTMPOrRecording: (NSDictionary) data :(RCTPromiseResolveBlock) resolve :(RCTPromiseRejectBlock) reject)

package/ios/HMSManager.swift

@@ -23,6 +23,7 @@ class HMSManager: RCTEventEmitter {
     let ON_LOCAL_VIDEO_STATS = "ON_LOCAL_VIDEO_STATS"
     let ON_REMOTE_AUDIO_STATS = "ON_REMOTE_AUDIO_STATS"
     let ON_REMOTE_VIDEO_STATS = "ON_REMOTE_VIDEO_STATS"
+    let ON_AUDIO_DEVICE_CHANGED = "ON_AUDIO_DEVICE_CHANGED"
 
     // MARK: - Setup
 
@@ -30,12 +31,12 @@ class HMSManager: RCTEventEmitter {
         super.init()
     }
     
-   override class func requiresMainQueueSetup() -> Bool {
-       true
-   }
+    override class func requiresMainQueueSetup() -> Bool {
+        true
+    }
     
     override func supportedEvents() -> [String]! {
-        return [ON_JOIN, ON_PREVIEW, ON_ROOM_UPDATE, ON_PEER_UPDATE, ON_TRACK_UPDATE, ON_ERROR, ON_MESSAGE, ON_SPEAKER, RECONNECTING, RECONNECTED, ON_ROLE_CHANGE_REQUEST, ON_CHANGE_TRACK_STATE_REQUEST, ON_REMOVED_FROM_ROOM, ON_RTC_STATS, ON_LOCAL_AUDIO_STATS, ON_LOCAL_VIDEO_STATS, ON_REMOTE_AUDIO_STATS, ON_REMOTE_VIDEO_STATS]
+        return [ON_JOIN, ON_PREVIEW, ON_ROOM_UPDATE, ON_PEER_UPDATE, ON_TRACK_UPDATE, ON_ERROR, ON_MESSAGE, ON_SPEAKER, RECONNECTING, RECONNECTED, ON_ROLE_CHANGE_REQUEST, ON_CHANGE_TRACK_STATE_REQUEST, ON_REMOVED_FROM_ROOM, ON_RTC_STATS, ON_LOCAL_AUDIO_STATS, ON_LOCAL_VIDEO_STATS, ON_REMOTE_AUDIO_STATS, ON_REMOTE_VIDEO_STATS, ON_AUDIO_DEVICE_CHANGED]
     }
 
     // MARK: - HMS SDK Actions
@@ -225,10 +226,10 @@ class HMSManager: RCTEventEmitter {
     }
     
     @objc
-    func remoteMuteAllAudio(_ data: NSDictionary) {
+    func remoteMuteAllAudio(_ data: NSDictionary, _ resolve: RCTPromiseResolveBlock?, _ reject: RCTPromiseRejectBlock?) {
         let hms = HMSHelper.getHms(data, hmsCollection)
 
-        hms?.remoteMuteAllAudio()
+        hms?.remoteMuteAllAudio(resolve, reject)
     }
 
     @objc