@100mslive/react-native-hms 1.0.0 → 1.1.0

package/README.md

@@ -296,19 +296,32 @@ await hmsInstance?.sendDirectMessage(message, peer);
 
 ## [Role Change](https://www.100ms.live/docs/react-native/v2/features/change-role)
 
+Single Peer Role Change: Change the Role of a single peer to a specified one using the `changeRoleOfPeer` API
+
 ```js
-import { HMSRole, HMSRemotePeer } from '@100mslive/react-native-hms';
-// hms instance acquired by build method
-const roles: HMSRole[] = hmsInstance?.knownRoles;
-const newRole: HMSRole = roles[0];
+const force = false
+
+// instance acquired from build() method
+await hmsInstance.changeRoleOfPeer(peer, newRole, force) // request role change, not forced
+    .then(d => console.log('Change Role Success: ', d))
+    .catch(e => console.log('Change Role Error: ', e));
+```
+
+
+Bulk Role Change: Change the role of all peers with a certain Role, to a specified one using the `changeRoleOfPeersWithRoles` API
+
+```js
+// fetch all available Roles in the room
+const roles = await hmsInstance.getRoles();
 
-// can any remote peer
-const peer: HMSRemotePeer = hmsInstance?.remotePeers[0];
+// get the Host Role object
+const hostRole = roles.find(role => role.name === 'host');
 
-const force = false;
+// get list of Roles to be updated - in this case "Waiting" and "Guest" Roles
+const rolesToChange = roles.filter(role => role.name === 'waiting' || role.name === 'guest');
 
-await hmsInstance.changeRole(peer, newRole, force); // request role change
-await hmsInstance.changeRole(peer, newRole, !force); // force role change
+// now perform Role Change of all peers in "Waiting" and "Guest" Roles to the "Host" Role
+await hmsInstance.changeRoleOfPeersWithRoles(rolesToChange, hostRole);
 ```
 
 ## [Raise Hand & BRB](https://www.100ms.live/docs/react-native/v2/advanced-features/change-metadata)
@@ -457,32 +470,34 @@ const newName: string = 'new name';
 await hmsInstance.changeName(newName);
 ```
 
-## [Join with specific Track Settings](https://www.100ms.live/docs/react-native/v2/advanced-features/track-settings)
+## [Join with specific Track Settings](https://www.100ms.live/docs/react-native/v2/features/join#joining-room-with-muted-audio-video)
 
+Following is an example to join a Room with Muted Audio & Video:
 ```js
+// First, create the Track Settings object
+const trackSettings = getTrackSettings();
+
+// Customize Audio & Video initial states as per user discretion
 const getTrackSettings = () => {
-  let audioSettings = new HMSAudioTrackSettings({
-    maxBitrate: 32,
-    trackDescription: 'Simple Audio Track',
-  });
-  let videoSettings = new HMSVideoTrackSettings({
-    codec: HMSVideoCodec.vp8,
-    maxBitrate: 512,
-    maxFrameRate: 25,
-    cameraFacing: HMSCameraFacing.FRONT,
-    trackDescription: 'Simple Video Track',
-    resolution: new HMSVideoResolution({ height: 180, width: 320 }),
-  });
 
-  return new HMSTrackSettings({ video: videoSettings, audio: audioSettings });
-};
+    let audioSettings = new HMSAudioTrackSettings({
+        initialState: HMSTrackSettingsInitState.MUTED,
+    });
+
+    let videoSettings = new HMSVideoTrackSettings({
+        initialState: HMSTrackSettingsInitState.MUTED,
+    });
 
-const setupBuild = async () => {
-  const trackSettings = getTrackSettings();
-  const build = await HMSSDK.build({ trackSettings });
-  setInstance(build);
-  updateHms({ hmsInstance: build });
+    return new HMSTrackSettings({
+        video: videoSettings,
+        audio: audioSettings,
+    });
 };
+
+// Pass the Track Settings object to the build function 
+const hmsInstance = await HMSSDK.build({
+    trackSettings
+});
 ```
 
 

package/android/build.gradle

@@ -1,3 +1,7 @@
+import groovy.json.JsonSlurper
+
+def sdkVersionsJson = new JsonSlurper().parse file("$rootDir/../../sdk-versions.json")
+
 buildscript {
     ext.kotlin_version = '1.5.30-RC'
     if (project == rootProject) {
@@ -65,7 +69,7 @@ dependencies {
     //noinspection GradleDynamicVersion
     implementation "com.facebook.react:react-native:+"
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"  // From node_modules
-    implementation 'live.100ms:android-sdk:2.5.1'
+    implementation "live.100ms:android-sdk:${sdkVersionsJson["android"]}"
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.0'
     implementation 'androidx.constraintlayout:constraintlayout:2.1.3'
     implementation 'androidx.appcompat:appcompat:1.3.1'

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

@@ -23,16 +23,16 @@ object HMSDecoder {
       room.putString("metaData", null)
       room.putString("startedAt", hmsRoom.startedAt.toString())
       room.putMap(
-          "browserRecordingState",
-          this.getHMSBrowserRecordingState(hmsRoom.browserRecordingState)
+        "browserRecordingState",
+        this.getHMSBrowserRecordingState(hmsRoom.browserRecordingState)
       )
       room.putMap(
-          "rtmpHMSRtmpStreamingState",
-          this.getHMSRtmpStreamingState(hmsRoom.rtmpHMSRtmpStreamingState)
+        "rtmpHMSRtmpStreamingState",
+        this.getHMSRtmpStreamingState(hmsRoom.rtmpHMSRtmpStreamingState)
       )
       room.putMap(
-          "serverRecordingState",
-          this.getHMSServerRecordingState(hmsRoom.serverRecordingState)
+        "serverRecordingState",
+        this.getHMSServerRecordingState(hmsRoom.serverRecordingState)
       )
       room.putMap("hlsStreamingState", this.getHMSHlsStreamingState(hmsRoom.hlsStreamingState))
       room.putMap("hlsRecordingState", this.getHMSHlsRecordingState(hmsRoom.hlsRecordingState))
@@ -230,8 +230,8 @@ object HMSDecoder {
     val settings: WritableMap = Arguments.createMap()
     if (hmsAudioTrackSettings != null) {
       settings.putBoolean(
-          "useHardwareAcousticEchoCanceler",
-          hmsAudioTrackSettings.useHardwareAcousticEchoCanceler
+        "useHardwareAcousticEchoCanceler",
+        hmsAudioTrackSettings.useHardwareAcousticEchoCanceler
       )
       settings.putString("initialState", hmsAudioTrackSettings.initialState.name)
     }
@@ -437,33 +437,33 @@ object HMSDecoder {
     if (hmsSubscribeSettings != null) {
       subscribeSettings.putInt("maxSubsBitRate", hmsSubscribeSettings.maxSubsBitRate)
       subscribeSettings.putMap(
-          "subscribeDegradationParam",
-          this.getHmsSubscribeDegradationSettings(hmsSubscribeSettings.subscribeDegradationParam)
+        "subscribeDegradationParam",
+        this.getHmsSubscribeDegradationSettings(hmsSubscribeSettings.subscribeDegradationParam)
       )
       subscribeSettings.putArray(
-          "subscribeTo",
-          this.getWriteableArray(hmsSubscribeSettings.subscribeTo)
+        "subscribeTo",
+        this.getWriteableArray(hmsSubscribeSettings.subscribeTo)
       )
     }
     return subscribeSettings
   }
 
   private fun getHmsSubscribeDegradationSettings(
-      hmsSubscribeDegradationParams: SubscribeDegradationParams?
+    hmsSubscribeDegradationParams: SubscribeDegradationParams?
   ): WritableMap {
     val subscribeDegradationParams: WritableMap = Arguments.createMap()
     if (hmsSubscribeDegradationParams != null) {
       subscribeDegradationParams.putString(
-          "degradeGracePeriodSeconds",
-          hmsSubscribeDegradationParams.degradeGracePeriodSeconds.toString()
+        "degradeGracePeriodSeconds",
+        hmsSubscribeDegradationParams.degradeGracePeriodSeconds.toString()
       )
       subscribeDegradationParams.putString(
-          "packetLossThreshold",
-          hmsSubscribeDegradationParams.packetLossThreshold.toString()
+        "packetLossThreshold",
+        hmsSubscribeDegradationParams.packetLossThreshold.toString()
       )
       subscribeDegradationParams.putString(
-          "recoverGracePeriodSeconds",
-          hmsSubscribeDegradationParams.recoverGracePeriodSeconds.toString()
+        "recoverGracePeriodSeconds",
+        hmsSubscribeDegradationParams.recoverGracePeriodSeconds.toString()
       )
     }
     return subscribeDegradationParams
@@ -538,8 +538,8 @@ object HMSDecoder {
     if (hmsLocalVideoStats != null) {
       localVideoStats.putString("bytesSent", hmsLocalVideoStats.bytesSent.toString())
       localVideoStats.putMap(
-          "resolution",
-          hmsLocalVideoStats.resolution?.let { this.getHmsVideoTrackResolution(it) }
+        "resolution",
+        hmsLocalVideoStats.resolution?.let { this.getHmsVideoTrackResolution(it) }
       )
       hmsLocalVideoStats.bitrate?.let { localVideoStats.putDouble("bitrate", it) }
       hmsLocalVideoStats.roundTripTime?.let { localVideoStats.putDouble("roundTripTime", it) }
@@ -567,8 +567,8 @@ object HMSDecoder {
       remoteVideoStats.putString("packetsReceived", hmsRemoteVideoStats.packetsReceived.toString())
       hmsRemoteVideoStats.bitrate?.let { remoteVideoStats.putDouble("bitrate", it) }
       remoteVideoStats.putMap(
-          "resolution",
-          hmsRemoteVideoStats.resolution?.let { this.getHmsVideoTrackResolution(it) }
+        "resolution",
+        hmsRemoteVideoStats.resolution?.let { this.getHmsVideoTrackResolution(it) }
       )
       hmsRemoteVideoStats.frameRate?.let { remoteVideoStats.putDouble("frameRate", it) }
       hmsRemoteVideoStats.jitter?.let { remoteVideoStats.putDouble("jitter", it) }

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

@@ -2,8 +2,12 @@ package com.reactnativehmssdk
 
 import android.app.Activity
 import android.app.Application
+import android.app.PendingIntent
 import android.app.PictureInPictureParams
+import android.app.RemoteAction
+import android.content.Intent
 import android.content.pm.PackageManager
+import android.graphics.drawable.Icon
 import android.os.Build
 import android.os.Bundle
 import android.util.Rational
@@ -16,11 +20,12 @@ import java.util.UUID
 
 @ReactModule(name = REACT_CLASS)
 class HMSManager(reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext), Application.ActivityLifecycleCallbacks {
+  ReactContextBaseJavaModule(reactContext), Application.ActivityLifecycleCallbacks {
   companion object {
     const val REACT_CLASS = "HMSManager"
     var hmsCollection = mutableMapOf<String, HMSRNSDK>()
   }
+
   override fun getName(): String {
     return "HMSManager"
   }
@@ -115,6 +120,7 @@ class HMSManager(reactContext: ReactApplicationContext) :
     hms?.sendDirectMessage(data, callback)
   }
 
+  @kotlin.Deprecated("Use #Function changeRoleOfPeer instead")
   @ReactMethod
   fun changeRole(data: ReadableMap, callback: Promise?) {
     val hms = HMSHelper.getHms(data, hmsCollection)
@@ -122,6 +128,20 @@ class HMSManager(reactContext: ReactApplicationContext) :
     hms?.changeRole(data, callback)
   }
 
+  @ReactMethod
+  fun changeRoleOfPeer(data: ReadableMap, promise: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.changeRoleOfPeer(data, promise)
+  }
+
+  @ReactMethod
+  fun changeRoleOfPeersWithRoles(data: ReadableMap, promise: Promise?) {
+    val hms = HMSHelper.getHms(data, hmsCollection)
+
+    hms?.changeRoleOfPeersWithRoles(data, promise)
+  }
+
   @ReactMethod
   fun changeTrackState(data: ReadableMap, callback: Promise?) {
     val hms = HMSHelper.getHms(data, hmsCollection)
@@ -430,17 +450,141 @@ class HMSManager(reactContext: ReactApplicationContext) :
     hms?.getSessionMetaData(callback)
   }
 
-  data class PipParamConfig(val aspectRatio: Pair<Int, Int>?)
+  // region Person-In-Person Mode Action handing
+  private val pipReceiver by lazy {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      PipActionReceiver(
+        toggleLocalAudio = {
+          toggleLocalAudio()
+          updatePIPRemoteActions(PipActionReceiver.PIPActions.localAudio.requestCode)
+        },
+        toggleLocalVideo = {
+          toggleLocalVideo()
+          updatePIPRemoteActions(PipActionReceiver.PIPActions.localVideo.requestCode)
+        },
+        endMeeting = {
+          endMeeting()
+        }
+      )
+    } else {
+      null
+    }
+  }
+
+  private var pipRemoteActionsList: MutableList<RemoteAction> = mutableListOf()
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun toggleLocalAudio() {
+    val hmssdk = getHmsInstance()[PipActionReceiver.sdkIdForPIP!!]?.hmsSDK
+
+    val localAudioTrack = hmssdk?.getLocalPeer()?.audioTrack
+    val isMuted = localAudioTrack?.isMute
+
+    if (isMuted !== null) {
+      localAudioTrack?.setMute(!isMuted)
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun toggleLocalVideo() {
+    val hmssdk = getHmsInstance()[PipActionReceiver.sdkIdForPIP!!]?.hmsSDK
+
+    val localVideoTrack = hmssdk?.getLocalPeer()?.videoTrack
+    val isMuted = localVideoTrack?.isMute
+
+    if (isMuted !== null) {
+      localVideoTrack?.setMute(!isMuted)
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun endMeeting() {
+    val hms = getHmsInstance()[PipActionReceiver.sdkIdForPIP!!]
+
+    hms?.leave(callback = null, fromPIP = true)
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun updatePIPRemoteActions(code: Int) {
+    val activity = currentActivity
+
+    if (activity !== null) {
+      val hmssdk = getHmsInstance()[PipActionReceiver.sdkIdForPIP!!]?.hmsSDK
+
+      when (code) {
+        PipActionReceiver.PIPActions.localAudio.requestCode -> {
+          val audioActionIdx = pipRemoteActionsList.indexOfFirst { it.title == PipActionReceiver.PIPActions.localAudio.title }
+          if (audioActionIdx >= 0) {
+            pipRemoteActionsList[audioActionIdx] = RemoteAction(
+              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.title == PipActionReceiver.PIPActions.localVideo.title }
+          if (videoActionIdx >= 0) {
+            pipRemoteActionsList[videoActionIdx] = RemoteAction(
+              Icon.createWithResource(
+                reactApplicationContext,
+                if (hmssdk?.getLocalPeer()?.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
+              )
+            )
+          }
+        }
+      }
+
+      val pipParams = PictureInPictureParams.Builder().let {
+        it.setActions(pipRemoteActionsList)
+        it.build()
+      }
+
+      activity.setPictureInPictureParams(pipParams)
+    }
+  }
+  // endregion
+
+  private data class PipParamConfig(
+    val aspectRatio: Pair<Int, Int>?,
+    val showEndButton: Boolean,
+    val showVideoButton: Boolean,
+    val showAudioButton: Boolean
+  )
 
   @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
     }
 
+    if (!data.hasKey("id")) {
+      promise?.reject(Throwable("HMS Instance Id is required!"))
+      return
+    }
+
     try {
-      when(action) {
+      PipActionReceiver.sdkIdForPIP = data.getString("id")
+
+      when (action) {
         "isPipModeSupported" -> {
           val result = isPipModeSupported()
           promise?.resolve(result)
@@ -459,18 +603,89 @@ class HMSManager(reactContext: ReactApplicationContext) :
     }
   }
 
-  /**
-   * Builds and returns PictureInPictureParams as per given config
-   * Currently we are supporting only "aspectRatio" in config
-   */
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun getPIPRemoteActions(endAction: Boolean = false, audioAction: Boolean = false, videoAction: Boolean = false): MutableList<RemoteAction> {
+    val hmssdk = getHmsInstance()[PipActionReceiver.sdkIdForPIP!!]?.hmsSDK
+
+    pipRemoteActionsList.clear()
+
+    val localPeer = hmssdk?.getLocalPeer()
+    val allowedPublishing = localPeer?.hmsRole?.publishParams?.allowed
+
+    if (audioAction && allowedPublishing?.contains("audio") === true) {
+      pipRemoteActionsList.add(
+        RemoteAction(
+          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 (endAction) {
+      pipRemoteActionsList.add(
+        RemoteAction(
+          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
+          )
+        )
+      )
+    }
+
+    if (videoAction && allowedPublishing?.contains("video") === true) {
+      pipRemoteActionsList.add(
+        RemoteAction(
+          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
+          )
+        )
+      )
+    }
+
+    return pipRemoteActionsList
+  }
+
+  // Builds and returns PictureInPictureParams as per given config
   @RequiresApi(Build.VERSION_CODES.O)
   private fun buildPipParams(config: PipParamConfig): PictureInPictureParams {
     val pipParams = PictureInPictureParams.Builder().let {
       if (config.aspectRatio !== null) {
-        it.setAspectRatio(Rational(
-          config.aspectRatio.first,
-          config.aspectRatio.second
-        ))
+        it.setAspectRatio(
+          Rational(
+            config.aspectRatio.first,
+            config.aspectRatio.second
+          )
+        )
       }
 
 //      TODO:= We need compileSdkVersion >= 31 for autoEnterEnabled
@@ -478,6 +693,14 @@ class HMSManager(reactContext: ReactApplicationContext) :
 //        it.setAutoEnterEnabled(config.autoEnterEnabled)
 //      }
 
+      it.setActions(
+        getPIPRemoteActions(
+          endAction = config.showEndButton,
+          audioAction = config.showAudioButton,
+          videoAction = config.showVideoButton
+        )
+      )
+
       it.build()
     }
 
@@ -486,7 +709,11 @@ class HMSManager(reactContext: ReactApplicationContext) :
 
   @RequiresApi(Build.VERSION_CODES.O)
   private fun readableMapToPipParamConfig(data: ReadableMap?): PipParamConfig {
-    var aspectRatio: Pair<Int, Int>? = null;
+    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;
 
@@ -513,6 +740,18 @@ class HMSManager(reactContext: ReactApplicationContext) :
         }
       }
 
+      if (data.hasKey("endButton")) {
+        showEndButton = data.getBoolean("endButton")
+      }
+
+      if (data.hasKey("audioButton")) {
+        showAudioButton = data.getBoolean("audioButton")
+      }
+
+      if (data.hasKey("videoButton")) {
+        showVideoButton = data.getBoolean("videoButton")
+      }
+
 //      TODO:= We need compileSdkVersion >= 31 for autoEnterEnabled
 //      if (data.hasKey("autoEnterEnabled")) {
 //        val autoEnterEnabledType = data.getType("autoEnterEnabled")
@@ -523,26 +762,35 @@ class HMSManager(reactContext: ReactApplicationContext) :
 //      }
     }
 
-    return PipParamConfig(aspectRatio)
+    return PipParamConfig(
+      aspectRatio = aspectRatio,
+      showEndButton = showEndButton,
+      showAudioButton = showAudioButton,
+      showVideoButton = showVideoButton
+    )
   }
 
   @RequiresApi(Build.VERSION_CODES.O)
-  private fun setPictureInPictureParams(data: ReadableMap?): Boolean {
-    if (!isPipModeSupported()) {
-      throw Throwable(message = "PIP Mode is not supported!")
-    }
+  private fun setPictureInPictureParams(data: ReadableMap): Boolean {
+    try {
+      if (!isPipModeSupported()) {
+        throw Throwable(message = "PIP Mode is not supported!")
+      }
 
-    val activity = currentActivity;
+      val activity = currentActivity
 
-    if (activity !== null) {
-      val pipParamConfig = readableMapToPipParamConfig(data)
-      val pipParams = buildPipParams(pipParamConfig)
+      if (activity !== null) {
+        val pipParamConfig = readableMapToPipParamConfig(data)
+        val pipParams = buildPipParams(pipParamConfig)
 
-      activity.setPictureInPictureParams(pipParams)
-      return true
-    }
+        activity.setPictureInPictureParams(pipParams)
+        return true
+      }
 
-    return false
+      return false
+    } catch (e: Exception) {
+      throw e
+    }
   }
 
   @RequiresApi(Build.VERSION_CODES.O)
@@ -551,22 +799,27 @@ class HMSManager(reactContext: ReactApplicationContext) :
   }
 
   @RequiresApi(Build.VERSION_CODES.O)
-  private fun enablePipMode(data: ReadableMap?): Boolean {
+  private fun enablePipMode(data: ReadableMap): Boolean {
     try {
       if (!isPipModeSupported()) {
         throw Throwable(message = "PIP Mode is not supported!")
       }
 
-      val activity = currentActivity;
+      val activity = currentActivity
 
       if (activity !== null) {
         val pipParamConfig = readableMapToPipParamConfig(data)
         val pipParams = buildPipParams(pipParamConfig)
 
-        return activity.enterPictureInPictureMode(pipParams)
+        pipReceiver?.register(activity)
+        val entered = activity.enterPictureInPictureMode(pipParams)
+        if (entered === false) {
+          pipReceiver?.unregister(activity)
+        }
+        return entered
       }
 
-      return false;
+      return false
     } catch (e: Exception) {
       throw e
     }
@@ -574,8 +827,8 @@ class HMSManager(reactContext: ReactApplicationContext) :
 
   fun emitEvent(event: String, data: WritableMap) {
     reactApplicationContext
-        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-        .emit(event, data)
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(event, data)
   }
 
   override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
@@ -601,6 +854,10 @@ class HMSManager(reactContext: ReactApplicationContext) :
         }
         currentActivity?.application?.unregisterActivityLifecycleCallbacks(this)
         hmsCollection = mutableMapOf()
+        // unregistering pip actions on activity destroy.
+        if (pipReceiver !== null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+          pipReceiver?.unregister(activity)
+        }
       }
     } catch (e: Exception) {
       //      Log.d("error", e.message)