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

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

@@ -5,6 +5,7 @@ import android.app.Application
 import android.app.PendingIntent
 import android.content.Intent
 import android.content.pm.PackageManager
+import android.content.res.Configuration
 import android.os.Build
 import android.os.Bundle
 import android.util.Rational
@@ -21,6 +22,32 @@ class HMSManager(reactContext: ReactApplicationContext) :
   companion object {
     const val REACT_CLASS = "HMSManager"
     var hmsCollection = mutableMapOf<String, HMSRNSDK>()
+
+    var reactAppContext: ReactApplicationContext? = null
+    var pipParamConfig: PipParamConfig? = null;
+    var pipParamsUntyped: Any? = null;
+    var emitter: DeviceEventManagerModule.RCTDeviceEventEmitter? = null
+
+    fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean, newConfig: Configuration) {
+      emitter?.let {
+        val data = Arguments.createMap()
+        data.putBoolean("isInPictureInPictureMode", isInPictureInPictureMode)
+
+        it.emit("ON_PIP_MODE_CHANGED", data)
+      }
+    }
+
+    fun onUserLeaveHint() {
+      val pipParams = pipParamsUntyped
+      if (
+        Build.VERSION.SDK_INT >= Build.VERSION_CODES.O &&
+        Build.VERSION.SDK_INT < Build.VERSION_CODES.S &&
+        pipParamConfig?.autoEnterPipMode == true &&
+        pipParams is android.app.PictureInPictureParams
+      ) {
+        reactAppContext?.currentActivity?.enterPictureInPictureMode(pipParams)
+      }
+    }
   }
 
   override fun getName(): String {
@@ -31,10 +58,28 @@ class HMSManager(reactContext: ReactApplicationContext) :
     return hmsCollection
   }
 
+  private fun setupPip() {
+    if (emitter == null) {
+      reactAppContext = reactApplicationContext
+
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        currentActivity?.let {
+         pipReceiver?.register(it)
+        }
+      }
+
+      emitter = reactApplicationContext
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+    }
+  }
+
   // Example method
   // See https://reactnative.dev/docs/native-modules-android
   @ReactMethod
-  fun build(data: ReadableMap?, callback: Promise?) {
+  fun build(
+    data: ReadableMap?,
+    callback: Promise?,
+  ) {
     val hasItem = hmsCollection.containsKey("12345")
     if (hasItem) {
       val uuid = UUID.randomUUID()
@@ -90,28 +135,40 @@ class HMSManager(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun leave(data: ReadableMap, callback: Promise?) {
+  fun leave(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.leave(callback)
   }
 
   @ReactMethod
-  fun sendBroadcastMessage(data: ReadableMap, callback: Promise?) {
+  fun sendBroadcastMessage(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.sendBroadcastMessage(data, callback)
   }
 
   @ReactMethod
-  fun sendGroupMessage(data: ReadableMap, callback: Promise?) {
+  fun sendGroupMessage(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.sendGroupMessage(data, callback)
   }
 
   @ReactMethod
-  fun sendDirectMessage(data: ReadableMap, callback: Promise?) {
+  fun sendDirectMessage(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.sendDirectMessage(data, callback)
@@ -119,84 +176,120 @@ class HMSManager(reactContext: ReactApplicationContext) :
 
   @kotlin.Deprecated("Use #Function changeRoleOfPeer instead")
   @ReactMethod
-  fun changeRole(data: ReadableMap, callback: Promise?) {
+  fun changeRole(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.changeRole(data, callback)
   }
 
   @ReactMethod
-  fun changeRoleOfPeer(data: ReadableMap, promise: Promise?) {
+  fun changeRoleOfPeer(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.changeRoleOfPeer(data, promise)
   }
 
   @ReactMethod
-  fun changeRoleOfPeersWithRoles(data: ReadableMap, promise: Promise?) {
+  fun changeRoleOfPeersWithRoles(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.changeRoleOfPeersWithRoles(data, promise)
   }
 
   @ReactMethod
-  fun changeTrackState(data: ReadableMap, callback: Promise?) {
+  fun changeTrackState(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.changeTrackState(data, callback)
   }
 
   @ReactMethod
-  fun changeTrackStateForRoles(data: ReadableMap, callback: Promise?) {
+  fun changeTrackStateForRoles(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.changeTrackStateForRoles(data, callback)
   }
 
   @ReactMethod
-  fun isMute(data: ReadableMap, callback: Promise?) {
+  fun isMute(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.isMute(data, callback)
   }
 
   @ReactMethod
-  fun removePeer(data: ReadableMap, callback: Promise?) {
+  fun removePeer(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.removePeer(data, callback)
   }
 
   @ReactMethod
-  fun isPlaybackAllowed(data: ReadableMap, callback: Promise?) {
+  fun isPlaybackAllowed(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.isPlaybackAllowed(data, callback)
   }
 
   @ReactMethod
-  fun getRoom(data: ReadableMap, callback: Promise?) {
+  fun getRoom(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getRoom(callback)
   }
 
   @ReactMethod
-  fun getLocalPeer(data: ReadableMap, callback: Promise?) {
+  fun getLocalPeer(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getLocalPeer(callback)
   }
 
   @ReactMethod
-  fun getRemotePeers(data: ReadableMap, callback: Promise?) {
+  fun getRemotePeers(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getRemotePeers(callback)
   }
 
   @ReactMethod
-  fun getRoles(data: ReadableMap, callback: Promise?) {
+  fun getRoles(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getRoles(callback)
@@ -210,14 +303,40 @@ class HMSManager(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun endRoom(data: ReadableMap, callback: Promise?) {
+  fun endRoom(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.endRoom(data, callback)
   }
 
   @ReactMethod
-  fun acceptRoleChange(data: ReadableMap, callback: Promise?) {
+  fun previewForRole(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.previewForRole(data, callback)
+  }
+
+  @ReactMethod
+  fun cancelPreview(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.cancelPreview(callback)
+  }
+
+  @ReactMethod
+  fun acceptRoleChange(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.acceptRoleChange(callback)
@@ -231,7 +350,10 @@ class HMSManager(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun getVolume(data: ReadableMap, callback: Promise?) {
+  fun getVolume(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getVolume(data, callback)
@@ -245,21 +367,30 @@ class HMSManager(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun remoteMuteAllAudio(data: ReadableMap, callback: Promise?) {
+  fun remoteMuteAllAudio(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.remoteMuteAllAudio(callback)
   }
 
   @ReactMethod
-  fun changeMetadata(data: ReadableMap, callback: Promise?) {
+  fun changeMetadata(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.changeMetadata(data, callback)
   }
 
   @ReactMethod
-  fun startScreenshare(data: ReadableMap, callback: Promise?) {
+  fun startScreenshare(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     currentActivity?.application?.registerActivityLifecycleCallbacks(this)
     val hms = HMSHelper.getHms(data, hmsCollection)
 
@@ -267,14 +398,20 @@ class HMSManager(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun isScreenShared(data: ReadableMap, callback: Promise?) {
+  fun isScreenShared(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.isScreenShared(callback)
   }
 
   @ReactMethod
-  fun stopScreenshare(data: ReadableMap, callback: Promise?) {
+  fun stopScreenshare(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     currentActivity?.application?.unregisterActivityLifecycleCallbacks(this)
@@ -282,7 +419,10 @@ class HMSManager(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun startAudioshare(data: ReadableMap, callback: Promise?) {
+  fun startAudioshare(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     currentActivity?.application?.registerActivityLifecycleCallbacks(this)
     val hms = HMSHelper.getHms(data, hmsCollection)
 
@@ -290,14 +430,20 @@ class HMSManager(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun isAudioShared(data: ReadableMap, callback: Promise?) {
+  fun isAudioShared(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.isAudioShared(callback)
   }
 
   @ReactMethod
-  fun stopAudioshare(data: ReadableMap, callback: Promise?) {
+  fun stopAudioshare(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     currentActivity?.application?.unregisterActivityLifecycleCallbacks(this)
@@ -305,42 +451,60 @@ class HMSManager(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun getAudioMixingMode(data: ReadableMap, callback: Promise?) {
+  fun getAudioMixingMode(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     callback?.resolve(hms?.getAudioMixingMode()?.name)
   }
 
   @ReactMethod
-  fun setAudioMixingMode(data: ReadableMap, callback: Promise?) {
+  fun setAudioMixingMode(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.setAudioMixingMode(data, callback)
   }
 
   @ReactMethod
-  fun startRTMPOrRecording(data: ReadableMap, callback: Promise?) {
+  fun startRTMPOrRecording(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.startRTMPOrRecording(data, callback)
   }
 
   @ReactMethod
-  fun stopRtmpAndRecording(data: ReadableMap, callback: Promise?) {
+  fun stopRtmpAndRecording(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.stopRtmpAndRecording(callback)
   }
 
   @ReactMethod
-  fun startHLSStreaming(data: ReadableMap, callback: Promise?) {
+  fun startHLSStreaming(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.startHLSStreaming(data, callback)
   }
 
   @ReactMethod
-  fun stopHLSStreaming(data: ReadableMap, callback: Promise?) {
+  fun stopHLSStreaming(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.stopHLSStreaming(callback)
@@ -354,14 +518,20 @@ class HMSManager(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun changeName(data: ReadableMap, callback: Promise?) {
+  fun changeName(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.changeName(data, callback)
   }
 
   @ReactMethod
-  fun destroy(data: ReadableMap, callback: Promise?) {
+  fun destroy(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val id = data.getString("id")
     hmsCollection.remove(id)
     val result: WritableMap = Arguments.createMap()
@@ -385,14 +555,20 @@ class HMSManager(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun getAudioDevicesList(data: ReadableMap, callback: Promise?) {
+  fun getAudioDevicesList(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getAudioDevicesList(callback)
   }
 
   @ReactMethod
-  fun getAudioOutputRouteType(data: ReadableMap, callback: Promise?) {
+  fun getAudioOutputRouteType(
+    data: ReadableMap,
+    callback: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getAudioOutputRouteType(callback)
@@ -434,28 +610,40 @@ class HMSManager(reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun enableEvent(data: ReadableMap, promise: Promise?) {
+  fun enableEvent(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.enableEvent(data, promise)
   }
 
   @ReactMethod
-  fun disableEvent(data: ReadableMap, promise: Promise?) {
+  fun disableEvent(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.disableEvent(data, promise)
   }
 
   @ReactMethod()
-  fun restrictData(data: ReadableMap, promise: Promise?) {
+  fun restrictData(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.restrictData(data, promise)
   }
 
   @ReactMethod()
-  fun getAuthTokenByRoomCode(data: ReadableMap, promise: Promise) {
+  fun getAuthTokenByRoomCode(
+    data: ReadableMap,
+    promise: Promise,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getAuthTokenByRoomCode(data, promise)
@@ -537,58 +725,68 @@ class HMSManager(reactContext: ReactApplicationContext) :
 
       when (code) {
         PipActionReceiver.PIPActions.localAudio.requestCode -> {
-          val audioActionIdx = pipRemoteActionsList.indexOfFirst { it is android.app.RemoteAction && it.title == PipActionReceiver.PIPActions.localAudio.title }
+          val audioActionIdx =
+            pipRemoteActionsList.indexOfFirst {
+              it is android.app.RemoteAction && it.title == PipActionReceiver.PIPActions.localAudio.title
+            }
           if (audioActionIdx >= 0) {
-            pipRemoteActionsList[audioActionIdx] = android.app.RemoteAction(
-              android.graphics.drawable.Icon.createWithResource(
-                reactApplicationContext,
-                if (hmssdk?.getLocalPeer()?.audioTrack?.isMute === true) R.drawable.ic_mic_off_24 else R.drawable.ic_mic_24,
-              ),
-              PipActionReceiver.PIPActions.localAudio.title,
-              PipActionReceiver.PIPActions.localAudio.description,
-              PendingIntent.getBroadcast(
-                reactApplicationContext,
-                PipActionReceiver.PIPActions.localAudio.requestCode,
-                Intent(PipActionReceiver.PIP_INTENT_ACTION).putExtra(PipActionReceiver.PIPActions.localAudio.title, PipActionReceiver.PIPActions.localAudio.requestCode),
-                PendingIntent.FLAG_IMMUTABLE,
-              ),
-            )
+            pipRemoteActionsList[audioActionIdx] =
+              android.app.RemoteAction(
+                android.graphics.drawable.Icon.createWithResource(
+                  reactApplicationContext,
+                  if (hmssdk?.getLocalPeer()?.audioTrack?.isMute === true) R.drawable.ic_mic_off_24 else R.drawable.ic_mic_24,
+                ),
+                PipActionReceiver.PIPActions.localAudio.title,
+                PipActionReceiver.PIPActions.localAudio.description,
+                PendingIntent.getBroadcast(
+                  reactApplicationContext,
+                  PipActionReceiver.PIPActions.localAudio.requestCode,
+                  Intent(PipActionReceiver.PIP_INTENT_ACTION).putExtra(PipActionReceiver.PIPActions.localAudio.title, PipActionReceiver.PIPActions.localAudio.requestCode),
+                  PendingIntent.FLAG_IMMUTABLE,
+                ),
+              )
           }
         }
         PipActionReceiver.PIPActions.localVideo.requestCode -> {
-          val videoActionIdx = pipRemoteActionsList.indexOfFirst { it is android.app.RemoteAction && it.title == PipActionReceiver.PIPActions.localVideo.title }
+          val videoActionIdx =
+            pipRemoteActionsList.indexOfFirst {
+              it is android.app.RemoteAction && it.title == PipActionReceiver.PIPActions.localVideo.title
+            }
           if (videoActionIdx >= 0) {
             val isVideoMute = hmssdk?.getLocalPeer()?.videoTrack?.isMute
             val updatedIcon = if (isVideoMute === true) R.drawable.ic_camera_toggle_off else R.drawable.ic_camera_toggle_on
-            pipRemoteActionsList[videoActionIdx] = android.app.RemoteAction(
-              android.graphics.drawable.Icon.createWithResource(
-                reactApplicationContext,
-                updatedIcon,
-              ),
-              PipActionReceiver.PIPActions.localVideo.title,
-              PipActionReceiver.PIPActions.localVideo.description,
-              PendingIntent.getBroadcast(
-                reactApplicationContext,
-                PipActionReceiver.PIPActions.localVideo.requestCode,
-                Intent(PipActionReceiver.PIP_INTENT_ACTION).putExtra(PipActionReceiver.PIPActions.localVideo.title, PipActionReceiver.PIPActions.localVideo.requestCode),
-                PendingIntent.FLAG_IMMUTABLE,
-              ),
-            )
+            pipRemoteActionsList[videoActionIdx] =
+              android.app.RemoteAction(
+                android.graphics.drawable.Icon.createWithResource(
+                  reactApplicationContext,
+                  updatedIcon,
+                ),
+                PipActionReceiver.PIPActions.localVideo.title,
+                PipActionReceiver.PIPActions.localVideo.description,
+                PendingIntent.getBroadcast(
+                  reactApplicationContext,
+                  PipActionReceiver.PIPActions.localVideo.requestCode,
+                  Intent(PipActionReceiver.PIP_INTENT_ACTION).putExtra(PipActionReceiver.PIPActions.localVideo.title, PipActionReceiver.PIPActions.localVideo.requestCode),
+                  PendingIntent.FLAG_IMMUTABLE,
+                ),
+              )
           }
         }
       }
 
-      val pipParams = android.app.PictureInPictureParams.Builder().let {
-        it.setActions(pipRemoteActionsList.filterIsInstance<android.app.RemoteAction>())
-        it.build()
-      }
+      val pipParams =
+        android.app.PictureInPictureParams.Builder().let {
+          it.setActions(pipRemoteActionsList.filterIsInstance<android.app.RemoteAction>())
+          it.build()
+        }
 
       activity.setPictureInPictureParams(pipParams)
     }
   }
   // endregion
 
-  private data class PipParamConfig(
+  data class PipParamConfig(
+    val autoEnterPipMode: Boolean,
     val aspectRatio: Pair<Int, Int>?,
     val showEndButton: Boolean,
     val showVideoButton: Boolean,
@@ -596,7 +794,11 @@ class HMSManager(reactContext: ReactApplicationContext) :
   )
 
   @ReactMethod
-  fun handlePipActions(action: String, data: ReadableMap, promise: Promise?) {
+  fun handlePipActions(
+    action: String,
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
       promise?.reject(Throwable("PIP mode is not supported!"))
       return
@@ -608,6 +810,8 @@ class HMSManager(reactContext: ReactApplicationContext) :
     }
 
     try {
+      setupPip()
+
       PipActionReceiver.sdkIdForPIP = data.getString("id")
 
       when (action) {
@@ -615,8 +819,8 @@ class HMSManager(reactContext: ReactApplicationContext) :
           val result = isPipModeSupported()
           promise?.resolve(result)
         }
-        "enablePipMode" -> {
-          val result = enablePipMode(data)
+        "enterPipMode" -> {
+          val result = enterPipMode(data)
           promise?.resolve(result)
         }
         "setPictureInPictureParams" -> {
@@ -637,94 +841,96 @@ class HMSManager(reactContext: ReactApplicationContext) :
       return null
     }
 
-    val pipParams = android.app.PictureInPictureParams.Builder().let {
-      if (config.aspectRatio !== null) {
-        it.setAspectRatio(
-          Rational(
-            config.aspectRatio.first,
-            config.aspectRatio.second,
-          ),
-        )
-      }
+    val pipParams =
+      android.app.PictureInPictureParams.Builder().let {
+        if (config.aspectRatio !== null) {
+          it.setAspectRatio(
+            Rational(
+              config.aspectRatio.first,
+              config.aspectRatio.second,
+            ),
+          )
+        }
 
-//      TODO:= We need compileSdkVersion >= 31 for autoEnterEnabled
-//      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && config.autoEnterEnabled !== null)
-//        it.setAutoEnterEnabled(config.autoEnterEnabled)
-//      }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+          it.setAutoEnterEnabled(config.autoEnterPipMode)
+        }
 
-      // region Setting RemoteActions on PictureInPictureParams
-      val hmssdk = getHmsInstance()[PipActionReceiver.sdkIdForPIP!!]?.hmsSDK
+        // region Setting RemoteActions on PictureInPictureParams
+        val hmssdk = getHmsInstance()[PipActionReceiver.sdkIdForPIP!!]?.hmsSDK
 
-      pipRemoteActionsList.clear()
+        pipRemoteActionsList.clear()
 
-      val localPeer = hmssdk?.getLocalPeer()
-      val allowedPublishing = localPeer?.hmsRole?.publishParams?.allowed
+        val localPeer = hmssdk?.getLocalPeer()
+        val allowedPublishing = localPeer?.hmsRole?.publishParams?.allowed
 
-      if (config.showAudioButton && allowedPublishing?.contains("audio") === true) {
-        pipRemoteActionsList.add(
-          android.app.RemoteAction(
-            android.graphics.drawable.Icon.createWithResource(
-              reactApplicationContext,
-              if (localPeer?.audioTrack?.isMute === true) R.drawable.ic_mic_off_24 else R.drawable.ic_mic_24,
-            ),
-            PipActionReceiver.PIPActions.localAudio.title,
-            PipActionReceiver.PIPActions.localAudio.description,
-            PendingIntent.getBroadcast(
-              reactApplicationContext,
-              PipActionReceiver.PIPActions.localAudio.requestCode,
-              Intent(PipActionReceiver.PIP_INTENT_ACTION).putExtra(PipActionReceiver.PIPActions.localAudio.title, PipActionReceiver.PIPActions.localAudio.requestCode),
-              PendingIntent.FLAG_IMMUTABLE,
+        if (config.showAudioButton && allowedPublishing?.contains("audio") === true) {
+          pipRemoteActionsList.add(
+            android.app.RemoteAction(
+              android.graphics.drawable.Icon.createWithResource(
+                reactApplicationContext,
+                if (localPeer?.audioTrack?.isMute === true) R.drawable.ic_mic_off_24 else R.drawable.ic_mic_24,
+              ),
+              PipActionReceiver.PIPActions.localAudio.title,
+              PipActionReceiver.PIPActions.localAudio.description,
+              PendingIntent.getBroadcast(
+                reactApplicationContext,
+                PipActionReceiver.PIPActions.localAudio.requestCode,
+                Intent(
+                  PipActionReceiver.PIP_INTENT_ACTION,
+                ).putExtra(PipActionReceiver.PIPActions.localAudio.title, PipActionReceiver.PIPActions.localAudio.requestCode),
+                PendingIntent.FLAG_IMMUTABLE,
+              ),
             ),
-          ),
-        )
-      }
+          )
+        }
 
-      if (config.showEndButton) {
-        pipRemoteActionsList.add(
-          android.app.RemoteAction(
-            android.graphics.drawable.Icon.createWithResource(reactApplicationContext, R.drawable.ic_call_end_24),
-            PipActionReceiver.PIPActions.endMeet.title,
-            PipActionReceiver.PIPActions.endMeet.description,
-            PendingIntent.getBroadcast(
-              reactApplicationContext,
-              PipActionReceiver.PIPActions.endMeet.requestCode,
-              Intent(PipActionReceiver.PIP_INTENT_ACTION).putExtra(
-                PipActionReceiver.PIPActions.endMeet.title,
+        if (config.showEndButton) {
+          pipRemoteActionsList.add(
+            android.app.RemoteAction(
+              android.graphics.drawable.Icon.createWithResource(reactApplicationContext, R.drawable.ic_call_end_24),
+              PipActionReceiver.PIPActions.endMeet.title,
+              PipActionReceiver.PIPActions.endMeet.description,
+              PendingIntent.getBroadcast(
+                reactApplicationContext,
                 PipActionReceiver.PIPActions.endMeet.requestCode,
+                Intent(PipActionReceiver.PIP_INTENT_ACTION).putExtra(
+                  PipActionReceiver.PIPActions.endMeet.title,
+                  PipActionReceiver.PIPActions.endMeet.requestCode,
+                ),
+                PendingIntent.FLAG_IMMUTABLE,
               ),
-              PendingIntent.FLAG_IMMUTABLE,
             ),
-          ),
-        )
-      }
+          )
+        }
 
-      if (config.showVideoButton && allowedPublishing?.contains("video") === true) {
-        pipRemoteActionsList.add(
-          android.app.RemoteAction(
-            android.graphics.drawable.Icon.createWithResource(
-              reactApplicationContext,
-              if (localPeer?.videoTrack?.isMute === true) R.drawable.ic_camera_toggle_off else R.drawable.ic_camera_toggle_on,
-            ),
-            PipActionReceiver.PIPActions.localVideo.title,
-            PipActionReceiver.PIPActions.localVideo.description,
-            PendingIntent.getBroadcast(
-              reactApplicationContext,
-              PipActionReceiver.PIPActions.localVideo.requestCode,
-              Intent(PipActionReceiver.PIP_INTENT_ACTION).putExtra(
-                PipActionReceiver.PIPActions.localVideo.title,
+        if (config.showVideoButton && allowedPublishing?.contains("video") === true) {
+          pipRemoteActionsList.add(
+            android.app.RemoteAction(
+              android.graphics.drawable.Icon.createWithResource(
+                reactApplicationContext,
+                if (localPeer?.videoTrack?.isMute === true) R.drawable.ic_camera_toggle_off else R.drawable.ic_camera_toggle_on,
+              ),
+              PipActionReceiver.PIPActions.localVideo.title,
+              PipActionReceiver.PIPActions.localVideo.description,
+              PendingIntent.getBroadcast(
+                reactApplicationContext,
                 PipActionReceiver.PIPActions.localVideo.requestCode,
+                Intent(PipActionReceiver.PIP_INTENT_ACTION).putExtra(
+                  PipActionReceiver.PIPActions.localVideo.title,
+                  PipActionReceiver.PIPActions.localVideo.requestCode,
+                ),
+                PendingIntent.FLAG_IMMUTABLE,
               ),
-              PendingIntent.FLAG_IMMUTABLE,
             ),
-          ),
-        )
-      }
+          )
+        }
 
-      it.setActions(pipRemoteActionsList.filterIsInstance<android.app.RemoteAction>())
-      // endregion
+        it.setActions(pipRemoteActionsList.filterIsInstance<android.app.RemoteAction>())
+        // endregion
 
-      it.build()
-    }
+        it.build()
+      }
 
     return pipParams
   }
@@ -735,14 +941,12 @@ class HMSManager(reactContext: ReactApplicationContext) :
       return null
     }
 
+    var autoEnterPipMode = false
     var aspectRatio: Pair<Int, Int> = Pair(16, 9)
     var showEndButton = false
     var showAudioButton = false
     var showVideoButton = false
 
-//    TODO:= We need compileSdkVersion >= 31 for autoEnterEnabled
-//    var autoEnterEnabled: Boolean? = null;
-
     if (data !== null) {
       if (data.hasKey("aspectRatio")) {
         val aspectRatioArray = data.getArray("aspectRatio")
@@ -778,17 +982,17 @@ class HMSManager(reactContext: ReactApplicationContext) :
         showVideoButton = data.getBoolean("videoButton")
       }
 
-//      TODO:= We need compileSdkVersion >= 31 for autoEnterEnabled
-//      if (data.hasKey("autoEnterEnabled")) {
-//        val autoEnterEnabledType = data.getType("autoEnterEnabled")
-//
-//        if (autoEnterEnabledType === ReadableType.Boolean) {
-//          autoEnterEnabled = data.getBoolean("autoEnterEnabled")
-//        }
-//      }
+      if (data.hasKey("autoEnterPipMode")) {
+        val autoEnterPipModeType = data.getType("autoEnterPipMode")
+
+        if (autoEnterPipModeType === ReadableType.Boolean) {
+          autoEnterPipMode = data.getBoolean("autoEnterPipMode")
+        }
+      }
     }
 
     return PipParamConfig(
+      autoEnterPipMode = autoEnterPipMode,
       aspectRatio = aspectRatio,
       showEndButton = showEndButton,
       showAudioButton = showAudioButton,
@@ -813,6 +1017,10 @@ class HMSManager(reactContext: ReactApplicationContext) :
       if (pipParams !is android.app.PictureInPictureParams) {
         return false
       }
+
+      HMSManager.pipParamConfig = pipParamConfig
+      HMSManager.pipParamsUntyped = pipParams
+
       activity.setPictureInPictureParams(pipParams)
       return true
     } catch (e: Exception) {
@@ -829,7 +1037,7 @@ class HMSManager(reactContext: ReactApplicationContext) :
   }
 
   @RequiresApi(Build.VERSION_CODES.O)
-  private fun enablePipMode(data: ReadableMap): Boolean {
+  private fun enterPipMode(data: ReadableMap): Boolean {
     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
       return false
     }
@@ -845,101 +1053,189 @@ class HMSManager(reactContext: ReactApplicationContext) :
       if (pipParams !is android.app.PictureInPictureParams) {
         return false
       }
-      pipReceiver?.register(activity)
-      val entered = activity.enterPictureInPictureMode(pipParams)
-      if (entered === false) {
-        pipReceiver?.unregister(activity)
-      }
-      return entered
+
+      HMSManager.pipParamConfig = pipParamConfig
+      HMSManager.pipParamsUntyped = pipParams
+
+      return activity.enterPictureInPictureMode(pipParams)
     } catch (e: Exception) {
       throw e
     }
   }
 
   @ReactMethod
-  fun getRemoteVideoTrackFromTrackId(data: ReadableMap, promise: Promise) {
+  fun getRemoteVideoTrackFromTrackId(
+    data: ReadableMap,
+    promise: Promise,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getRemoteVideoTrackFromTrackId(data, promise)
   }
 
   @ReactMethod
-  fun getRemoteAudioTrackFromTrackId(data: ReadableMap, promise: Promise) {
+  fun getRemoteAudioTrackFromTrackId(
+    data: ReadableMap,
+    promise: Promise,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getRemoteAudioTrackFromTrackId(data, promise)
   }
 
   @ReactMethod
-  fun getVideoTrackLayer(data: ReadableMap, promise: Promise) {
+  fun getVideoTrackLayer(
+    data: ReadableMap,
+    promise: Promise,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getVideoTrackLayer(data, promise)
   }
 
   @ReactMethod
-  fun getVideoTrackLayerDefinition(data: ReadableMap, promise: Promise) {
+  fun getVideoTrackLayerDefinition(
+    data: ReadableMap,
+    promise: Promise,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getVideoTrackLayerDefinition(data, promise)
   }
 
   @ReactMethod
-  fun setVideoTrackLayer(data: ReadableMap, promise: Promise?) {
+  fun setVideoTrackLayer(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.setVideoTrackLayer(data, promise)
   }
 
   @ReactMethod
-  fun captureImageAtMaxSupportedResolution(data: ReadableMap, promise: Promise?) {
+  fun captureImageAtMaxSupportedResolution(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.captureImageAtMaxSupportedResolution(data, promise)
   }
 
   @ReactMethod
-  fun setSessionMetadataForKey(data: ReadableMap, promise: Promise?) {
+  fun setSessionMetadataForKey(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.setSessionMetadataForKey(data, promise)
   }
 
   @ReactMethod
-  fun getSessionMetadataForKey(data: ReadableMap, promise: Promise?) {
+  fun getSessionMetadataForKey(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getSessionMetadataForKey(data, promise)
   }
 
   @ReactMethod
-  fun addKeyChangeListener(data: ReadableMap, promise: Promise?) {
+  fun addKeyChangeListener(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.addKeyChangeListener(data, promise)
   }
 
   @ReactMethod
-  fun removeKeyChangeListener(data: ReadableMap, promise: Promise?) {
+  fun removeKeyChangeListener(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.removeKeyChangeListener(data, promise)
   }
 
   @ReactMethod
-  fun getRoomLayout(data: ReadableMap, promise: Promise?) {
+  fun getRoomLayout(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
     val hms = HMSHelper.getHms(data, hmsCollection)
 
     hms?.getRoomLayout(data, promise)
   }
 
-  fun emitEvent(event: String, data: WritableMap) {
+  @ReactMethod
+  fun raiseLocalPeerHand(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+    hms?.raiseLocalPeerHand(data, promise)
+  }
+
+  @ReactMethod
+  fun lowerLocalPeerHand(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+    hms?.lowerLocalPeerHand(data, promise)
+  }
+
+  fun lowerRemotePeerHand(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+    hms?.lowerRemotePeerHand(data, promise)
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun getPeerListIterator(data: ReadableMap): WritableMap? {
+    val hms = HMSHelper.getHms(data, hmsCollection) ?: return null
+    return hms.getPeerListIterator(data)
+  }
+
+  @ReactMethod
+  fun peerListIteratorHasNext(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+    hms?.peerListIteratorHasNext(data, promise)
+  }
+
+  @ReactMethod
+  fun peerListIteratorNext(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+    hms?.peerListIteratorNext(data, promise)
+  }
+
+  fun emitEvent(
+    event: String,
+    data: WritableMap,
+  ) {
     reactApplicationContext
       .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
       .emit(event, data)
   }
 
-  override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
+  override fun onActivityCreated(
+    activity: Activity,
+    savedInstanceState: Bundle?,
+  ) {}
 
   override fun onActivityStarted(activity: Activity) {}
 
@@ -949,7 +1245,10 @@ class HMSManager(reactContext: ReactApplicationContext) :
 
   override fun onActivityStopped(activity: Activity) {}
 
-  override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+  override fun onActivitySaveInstanceState(
+    activity: Activity,
+    outState: Bundle,
+  ) {}
 
   override fun onActivityDestroyed(activity: Activity) {
     try {