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

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

@@ -15,6 +15,7 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.events.RCTEventEmitter
 import java.io.ByteArrayOutputStream
 import java.util.*
+import live.hms.video.audio.HMSAudioManager
 import live.hms.video.error.HMSException
 import live.hms.video.media.codec.HMSAudioCodec
 import live.hms.video.media.codec.HMSVideoCodec
@@ -23,6 +24,7 @@ import live.hms.video.media.tracks.HMSRemoteAudioTrack
 import live.hms.video.media.tracks.HMSRemoteVideoTrack
 import live.hms.video.media.tracks.HMSTrack
 import live.hms.video.sdk.models.*
+import live.hms.video.sdk.models.enums.AudioMixingMode
 import live.hms.video.sdk.models.role.HMSRole
 import live.hms.video.utils.HmsUtilities
 import org.webrtc.SurfaceViewRenderer
@@ -248,6 +250,21 @@ object HMSHelper {
     }
   }
 
+  fun getAudioMixingMode(audioMixingMode: String?): AudioMixingMode {
+    when (audioMixingMode) {
+      "TALK_ONLY" -> {
+        return AudioMixingMode.TALK_ONLY
+      }
+      "MUSIC_ONLY" -> {
+        return AudioMixingMode.MUSIC_ONLY
+      }
+      "TALK_AND_MUSIC" -> {
+        return AudioMixingMode.TALK_AND_MUSIC
+      }
+    }
+    return AudioMixingMode.TALK_AND_MUSIC
+  }
+
   private fun getAudioCodec(codecString: String?): HMSAudioCodec {
     when (codecString) {
       "opus" -> {
@@ -304,7 +321,25 @@ object HMSHelper {
     return rtmpURLs
   }
 
-  fun getHMSHLSMeetingURLVariants(
+  fun getHLSConfig(data: ReadableMap?): HMSHLSConfig? {
+    if (data === null) {
+      return data
+    }
+    var hlsMeetingUrlVariant: List<HMSHLSMeetingURLVariant>? = null
+    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("meetingURLVariants", "Array")))) {
+      val meetingURLVariants =
+          data.getArray("meetingURLVariants")?.toArrayList() as? ArrayList<HashMap<String, String>>
+      hlsMeetingUrlVariant = getHMSHLSMeetingURLVariants(meetingURLVariants)
+    }
+    var hlsRecordingConfig: HMSHlsRecordingConfig? = null
+    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("hlsRecordingConfig", "Map")))) {
+      val recordingConfig = data.getMap("hlsRecordingConfig")
+      hlsRecordingConfig = getHlsRecordingConfig(recordingConfig)
+    }
+    return HMSHLSConfig(hlsMeetingUrlVariant, hlsRecordingConfig)
+  }
+
+  private fun getHMSHLSMeetingURLVariants(
       hmsMeetingURLVariants: ArrayList<HashMap<String, String>>?
   ): List<HMSHLSMeetingURLVariant> {
     val meetingURLVariants = mutableListOf<HMSHLSMeetingURLVariant>()
@@ -317,28 +352,25 @@ object HMSHelper {
     return meetingURLVariants
   }
 
-  fun getHlsRecordingConfig(data: ReadableMap): HMSHlsRecordingConfig? {
-    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("hlsRecordingConfig", "Map")))) {
-      val hmsHlsRecordingConfig = data.getMap("hlsRecordingConfig")
-      if (hmsHlsRecordingConfig != null) {
-        var singleFilePerLayer = false
-        var videoOnDemand = false
-        if (areAllRequiredKeysAvailable(
-                hmsHlsRecordingConfig,
-                arrayOf(Pair("singleFilePerLayer", "Boolean"))
-            )
-        ) {
-          singleFilePerLayer = hmsHlsRecordingConfig.getBoolean("singleFilePerLayer")
-        }
-        if (areAllRequiredKeysAvailable(
-                hmsHlsRecordingConfig,
-                arrayOf(Pair("videoOnDemand", "Boolean"))
-            )
-        ) {
-          videoOnDemand = hmsHlsRecordingConfig.getBoolean("videoOnDemand")
-        }
-        return HMSHlsRecordingConfig(singleFilePerLayer, videoOnDemand)
+  private fun getHlsRecordingConfig(hmsHlsRecordingConfig: ReadableMap?): HMSHlsRecordingConfig? {
+    if (hmsHlsRecordingConfig !== null) {
+      var singleFilePerLayer = false
+      var videoOnDemand = false
+      if (areAllRequiredKeysAvailable(
+              hmsHlsRecordingConfig,
+              arrayOf(Pair("singleFilePerLayer", "Boolean"))
+          )
+      ) {
+        singleFilePerLayer = hmsHlsRecordingConfig.getBoolean("singleFilePerLayer")
       }
+      if (areAllRequiredKeysAvailable(
+              hmsHlsRecordingConfig,
+              arrayOf(Pair("videoOnDemand", "Boolean"))
+          )
+      ) {
+        videoOnDemand = hmsHlsRecordingConfig.getBoolean("videoOnDemand")
+      }
+      return HMSHlsRecordingConfig(singleFilePerLayer, videoOnDemand)
     }
     return null
   }
@@ -542,4 +574,45 @@ object HMSHelper {
       reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, "captureFrame", output)
     }
   }
+
+  fun getAudioDevicesList(audioDevicesList: List<HMSAudioManager.AudioDevice>?): ReadableArray {
+    val hmsAudioDevicesList = Arguments.createArray()
+    if (audioDevicesList != null) {
+      for (audioDevice in audioDevicesList) {
+        hmsAudioDevicesList.pushString(audioDevice.name)
+      }
+    }
+    return hmsAudioDevicesList
+  }
+
+  fun getAudioDevicesSet(audioDevicesSet: Set<HMSAudioManager.AudioDevice>?): ReadableArray {
+    val hmsAudioDevicesSet = Arguments.createArray()
+    if (audioDevicesSet != null) {
+      for (audioDevice in audioDevicesSet) {
+        hmsAudioDevicesSet.pushString(audioDevice.name)
+      }
+    }
+    return hmsAudioDevicesSet
+  }
+
+  fun getAudioDevice(audioDevice: String?): HMSAudioManager.AudioDevice {
+    when (audioDevice) {
+      "AUTOMATIC" -> {
+        return HMSAudioManager.AudioDevice.AUTOMATIC
+      }
+      "BLUETOOTH" -> {
+        return HMSAudioManager.AudioDevice.BLUETOOTH
+      }
+      "EARPIECE" -> {
+        return HMSAudioManager.AudioDevice.EARPIECE
+      }
+      "SPEAKER_PHONE" -> {
+        return HMSAudioManager.AudioDevice.SPEAKER_PHONE
+      }
+      "WIRED_HEADSET" -> {
+        return HMSAudioManager.AudioDevice.WIRED_HEADSET
+      }
+    }
+    return HMSAudioManager.AudioDevice.SPEAKER_PHONE
+  }
 }

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

@@ -238,6 +238,43 @@ class HMSManager(reactContext: ReactApplicationContext) :
     hms?.stopScreenshare(callback)
   }
 
+  @ReactMethod
+  fun startAudioshare(data: ReadableMap, callback: Promise?) {
+    currentActivity?.application?.registerActivityLifecycleCallbacks(this)
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.startAudioshare(data, callback)
+  }
+
+  @ReactMethod
+  fun isAudioShared(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.isAudioShared(callback)
+  }
+
+  @ReactMethod
+  fun stopAudioshare(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    currentActivity?.application?.unregisterActivityLifecycleCallbacks(this)
+    hms?.stopAudioshare(callback)
+  }
+
+  @ReactMethod
+  fun getAudioMixingMode(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    callback?.resolve(hms?.getAudioMixingMode()?.name)
+  }
+
+  @ReactMethod
+  fun setAudioMixingMode(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.setAudioMixingMode(data, callback)
+  }
+
   @ReactMethod
   fun startRTMPOrRecording(data: ReadableMap, callback: Promise?) {
     val hms = HMSHelper.getHms(data, hmsCollection)
@@ -290,6 +327,55 @@ class HMSManager(reactContext: ReactApplicationContext) :
     callback?.resolve(result)
   }
 
+  @ReactMethod
+  fun enableRTCStats(data: ReadableMap) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.enableRTCStats()
+  }
+
+  @ReactMethod
+  fun disableRTCStats(data: ReadableMap) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.disableRTCStats()
+  }
+
+  @ReactMethod
+  fun getAudioDevicesList(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.getAudioDevicesList(callback)
+  }
+
+  @ReactMethod
+  fun getAudioOutputRouteType(data: ReadableMap, callback: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.getAudioOutputRouteType(callback)
+  }
+
+  @ReactMethod
+  fun switchAudioOutput(data: ReadableMap) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.switchAudioOutput(data)
+  }
+
+  @ReactMethod
+  fun setAudioMode(data: ReadableMap) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.setAudioMode(data)
+  }
+
+  @ReactMethod
+  fun setAudioDeviceChangeListener(data: ReadableMap) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.setAudioDeviceChangeListener()
+  }
+
   fun emitEvent(event: String, data: WritableMap) {
     reactApplicationContext
         .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)

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,11 +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
 
@@ -46,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)
@@ -56,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)
@@ -361,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"
@@ -391,7 +504,9 @@ class HMSRNSDK(
       hmsSDK?.leave(
           object : HMSActionResultListener {
             override fun onSuccess() {
+              isAudioSharing = false
               screenshareCallback = null
+              audioshareCallback = null
               callback?.resolve(emitHMSSuccess())
             }
 
@@ -991,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?) {
@@ -1083,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

@@ -228,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? {