@pigeonmal/react-native-video 7.0.0-beta.10

package/android/src/main/java/com/twg/video/core/services/playback/CustomMediaNotificationProvider.kt

@@ -0,0 +1,151 @@
+package com.twg.video.core.services.playback
+
+import android.content.Context
+import android.app.PendingIntent
+import android.content.Intent
+import android.util.Log
+import androidx.annotation.OptIn
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.session.CommandButton
+import androidx.media3.session.DefaultMediaNotificationProvider
+import androidx.media3.session.MediaSession
+import com.google.common.collect.ImmutableList
+import androidx.core.os.bundleOf
+import android.os.Bundle
+import com.margelo.nitro.NitroModules
+import com.twg.video.core.LibraryError
+
+@OptIn(UnstableApi::class)
+class CustomMediaNotificationProvider(context: Context) : DefaultMediaNotificationProvider(context) {
+
+  init {
+    setSmallIcon(androidx.media3.session.R.drawable.media3_notification_small_icon)
+  }
+
+  fun getContext(): Context {
+    return NitroModules.applicationContext ?: run {
+      throw LibraryError.ApplicationContextNotFound
+    }
+  }
+
+  override fun getNotificationContentTitle(metadata: MediaMetadata): CharSequence? {
+    return metadata.title
+      ?: metadata.displayTitle
+      ?: metadata.subtitle
+      ?: metadata.description
+      ?: "${getAppName()} is playing"
+  }
+
+  override fun getNotificationContentText(metadata: MediaMetadata): CharSequence? {
+    return metadata.artist
+      ?: metadata.subtitle
+      ?: metadata.description
+  }
+
+  companion object {
+    private const val SEEK_INTERVAL_MS = 10000L
+    private const val TAG = "CustomMediaNotificationProvider"
+
+    enum class COMMAND(val stringValue: String) {
+      NONE("NONE"),
+      SEEK_FORWARD("COMMAND_SEEK_FORWARD"),
+      SEEK_BACKWARD("COMMAND_SEEK_BACKWARD"),
+      TOGGLE_PLAY("COMMAND_TOGGLE_PLAY"),
+      PLAY("COMMAND_PLAY"),
+      PAUSE("COMMAND_PAUSE")
+    }
+
+    fun commandFromString(value: String): COMMAND =
+      when (value) {
+        COMMAND.SEEK_FORWARD.stringValue -> COMMAND.SEEK_FORWARD
+        COMMAND.SEEK_BACKWARD.stringValue -> COMMAND.SEEK_BACKWARD
+        COMMAND.TOGGLE_PLAY.stringValue -> COMMAND.TOGGLE_PLAY
+        COMMAND.PLAY.stringValue -> COMMAND.PLAY
+        COMMAND.PAUSE.stringValue -> COMMAND.PAUSE
+        else -> COMMAND.NONE
+      }
+
+    fun handleCommand(command: COMMAND, session: MediaSession) {
+      // TODO: get somehow ControlsConfig here - for now hardcoded 10000ms
+
+      when (command) {
+        COMMAND.SEEK_BACKWARD -> session.player.seekTo(session.player.contentPosition - SEEK_INTERVAL_MS)
+        COMMAND.SEEK_FORWARD -> session.player.seekTo(session.player.contentPosition + SEEK_INTERVAL_MS)
+        COMMAND.TOGGLE_PLAY -> handleCommand(if (session.player.isPlaying) COMMAND.PAUSE else COMMAND.PLAY, session)
+        COMMAND.PLAY -> session.player.play()
+        COMMAND.PAUSE -> session.player.pause()
+        else -> Log.w(TAG, "Received COMMAND.NONE - was there an error?")
+      }
+    }
+  }
+
+  private fun getAppName(): String {
+    return try {
+      val context = getContext()
+      val applicationInfo = context.applicationInfo
+      val labelRes = applicationInfo.labelRes
+      if (labelRes != 0) {
+        context.getString(labelRes)
+      } else {
+        applicationInfo.nonLocalizedLabel?.toString() ?: context.packageManager.getApplicationLabel(applicationInfo).toString()
+      }
+    } catch (e: Exception) {
+      return "Unknown"
+    }
+  }
+
+  override fun getMediaButtons(
+    session: MediaSession,
+    playerCommands: Player.Commands,
+    mediaButtonPreferences: ImmutableList<CommandButton>,
+    showPauseButton: Boolean
+  ): ImmutableList<CommandButton> {
+    val rewind = CommandButton.Builder()
+      .setDisplayName("Rewind")
+      .setSessionCommand(androidx.media3.session.SessionCommand(
+        COMMAND.SEEK_BACKWARD.stringValue,
+        Bundle.EMPTY
+      ))
+      .setIconResId(androidx.media3.session.R.drawable.media3_icon_skip_back_10)
+      .setExtras(bundleOf(COMMAND_KEY_COMPACT_VIEW_INDEX to 0))
+      .build()
+
+    val toggle = CommandButton.Builder()
+      .setDisplayName(if (showPauseButton) "Pause" else "Play")
+      .setSessionCommand(androidx.media3.session.SessionCommand(
+        COMMAND.TOGGLE_PLAY.stringValue,
+        Bundle.EMPTY
+      ))
+      .setIconResId(
+        if (showPauseButton) androidx.media3.session.R.drawable.media3_icon_pause
+        else androidx.media3.session.R.drawable.media3_icon_play
+      )
+      .setExtras(bundleOf(COMMAND_KEY_COMPACT_VIEW_INDEX to 1))
+      .build()
+
+    val forward = CommandButton.Builder()
+      .setDisplayName("Forward")
+      .setSessionCommand(androidx.media3.session.SessionCommand(
+        COMMAND.SEEK_FORWARD.stringValue,
+        Bundle.EMPTY
+      ))
+      .setIconResId(androidx.media3.session.R.drawable.media3_icon_skip_forward_10)
+      .setExtras(bundleOf(COMMAND_KEY_COMPACT_VIEW_INDEX to 2))
+      .build()
+
+    return ImmutableList.of(rewind, toggle, forward)
+  }
+
+  override fun addNotificationActions(
+    mediaSession: MediaSession,
+    mediaButtons: ImmutableList<CommandButton>,
+    builder: androidx.core.app.NotificationCompat.Builder,
+    actionFactory: androidx.media3.session.MediaNotification.ActionFactory
+  ): IntArray {
+    // Use default behavior to add actions from our custom buttons and return compact indices
+    val compact = super.addNotificationActions(mediaSession, mediaButtons, builder, actionFactory)
+    return if (compact.isEmpty()) intArrayOf(0, 1, 2) else compact
+  }
+}

package/android/src/main/java/com/twg/video/core/services/playback/VideoPlaybackCallback.kt

@@ -0,0 +1,96 @@
+package com.twg.video.core.services.playback
+
+import android.os.Bundle
+import androidx.annotation.OptIn
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.session.CommandButton
+import androidx.media3.session.MediaSession
+import androidx.media3.session.SessionCommand
+import androidx.media3.session.SessionResult
+import com.google.common.util.concurrent.ListenableFuture
+import com.google.common.collect.ImmutableList
+
+@OptIn(UnstableApi::class)
+class VideoPlaybackCallback : MediaSession.Callback {
+  // For Android 13+
+  private fun buildCustomButtons(): ImmutableList<CommandButton> {
+    val rewind = CommandButton.Builder()
+      .setDisplayName("Rewind")
+      .setSessionCommand(
+        SessionCommand(
+          CustomMediaNotificationProvider.Companion.COMMAND.SEEK_BACKWARD.stringValue,
+          Bundle.EMPTY
+        )
+      )
+      .setIconResId(androidx.media3.session.R.drawable.media3_icon_skip_back_10)
+      .build()
+
+    val forward = CommandButton.Builder()
+      .setDisplayName("Forward")
+      .setSessionCommand(
+        SessionCommand(
+          CustomMediaNotificationProvider.Companion.COMMAND.SEEK_FORWARD.stringValue,
+          Bundle.EMPTY
+        )
+      )
+      .setIconResId(androidx.media3.session.R.drawable.media3_icon_skip_forward_10)
+      .build()
+
+    return ImmutableList.of(rewind, forward)
+  }
+
+  override fun onConnect(session: MediaSession, controller: MediaSession.ControllerInfo): MediaSession.ConnectionResult {
+    try {
+      return MediaSession.ConnectionResult.AcceptedResultBuilder(session)
+        .setAvailablePlayerCommands(
+          MediaSession.ConnectionResult.DEFAULT_PLAYER_COMMANDS.buildUpon()
+            .add(Player.COMMAND_SEEK_FORWARD)
+            .add(Player.COMMAND_SEEK_BACK)
+            .build()
+        ).setAvailableSessionCommands(
+          MediaSession.ConnectionResult.DEFAULT_SESSION_COMMANDS.buildUpon()
+            .add(
+              SessionCommand(
+                CustomMediaNotificationProvider.Companion.COMMAND.SEEK_FORWARD.stringValue,
+                Bundle.EMPTY
+              )
+            )
+            .add(
+                SessionCommand(
+                  CustomMediaNotificationProvider.Companion.COMMAND.SEEK_BACKWARD.stringValue,
+                  Bundle.EMPTY
+                )
+            )
+            .add(
+              SessionCommand(
+                CustomMediaNotificationProvider.Companion.COMMAND.TOGGLE_PLAY.stringValue,
+                Bundle.EMPTY
+              )
+            ).build()
+        ).build()
+    } catch (e: Exception) {
+      return MediaSession.ConnectionResult.reject()
+    }
+  }
+
+  override fun onPostConnect(session: MediaSession, controller: MediaSession.ControllerInfo) {
+    session.setCustomLayout(buildCustomButtons())
+    super.onPostConnect(session, controller)
+  }
+
+  override fun onCustomCommand(
+      session: MediaSession,
+      controller: MediaSession.ControllerInfo,
+      customCommand: SessionCommand,
+      args: Bundle
+  ): ListenableFuture<SessionResult> {
+    CustomMediaNotificationProvider.Companion.handleCommand(
+      CustomMediaNotificationProvider.Companion.commandFromString(
+          customCommand.customAction
+        ), session
+      )
+
+    return super.onCustomCommand(session, controller, customCommand, args)
+  }
+}

package/android/src/main/java/com/twg/video/core/services/playback/VideoPlaybackService.kt

@@ -0,0 +1,219 @@
+package com.twg.video.core.services.playback
+
+import android.app.Activity
+import android.app.PendingIntent
+import android.content.Intent
+import android.os.Binder
+import android.os.IBinder
+import android.util.Log
+import androidx.annotation.OptIn
+import androidx.media3.common.util.BitmapLoader
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.session.DefaultMediaNotificationProvider
+import androidx.media3.session.SimpleBitmapLoader
+import androidx.media3.session.MediaSession
+import androidx.media3.session.MediaSessionService
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.video.HybridVideoPlayer
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+
+class VideoPlaybackServiceBinder(val service: VideoPlaybackService): Binder()
+
+@OptIn(UnstableApi::class)
+class VideoPlaybackService : MediaSessionService() {
+  private var mediaSessionsList = mutableMapOf<HybridVideoPlayer, MediaSession>()
+  private var binder = VideoPlaybackServiceBinder(this)
+  private var sourceActivity: Class<Activity>? = null // retained for future deep-links; currently unused
+  private var isForeground = false
+  private var cachedLaunchIntent: Intent? = null
+
+  override fun onCreate() {
+    super.onCreate()
+    setMediaNotificationProvider(CustomMediaNotificationProvider(this))
+  }
+
+  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    // Ensure we call startForeground quickly on newer Android versions to avoid
+    // ForegroundServiceDidNotStartInTimeException when startForegroundService(...) was used.
+    try {
+      if (!isForeground && Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        startForeground(PLACEHOLDER_NOTIFICATION_ID, createPlaceholderNotification())
+        isForeground = true
+      }
+    } catch (_: Exception) {
+      Log.e(TAG, "Failed to start foreground service!")
+    }
+
+    return super.onStartCommand(intent, flags, startId)
+  }
+
+  // Player Registry
+  fun registerPlayer(player: HybridVideoPlayer, from: Class<Activity>) {
+    if (mediaSessionsList.containsKey(player)) {
+      return
+    }
+    sourceActivity = from
+
+    val builder = MediaSession.Builder(this, player.player)
+      .setId("RNVideoPlaybackService_" + player.hashCode())
+      .setCallback(VideoPlaybackCallback())
+
+    // Ensure tapping the notification opens the app via sessionActivity
+    try {
+      var launchIntent = cachedLaunchIntent
+      if (launchIntent == null) {
+        launchIntent = packageManager.getLaunchIntentForPackage(packageName)
+        cachedLaunchIntent = launchIntent
+      }
+
+      if (launchIntent != null) {
+        // Clone the intent before modifying it to avoid mutating the cached instance
+        val intentToUse = launchIntent.clone() as Intent
+        intentToUse.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+        val contentIntent = PendingIntent.getActivity(
+          this,
+          0,
+          intentToUse,
+          PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+        builder.setSessionActivity(contentIntent)
+      }
+    } catch (_: Exception) {}
+
+
+    val mediaSession = builder.build()
+
+    mediaSessionsList[player] = mediaSession
+    addSession(mediaSession)
+  }
+
+  fun unregisterPlayer(player: HybridVideoPlayer) {
+    val session = mediaSessionsList.remove(player)
+    session?.release()
+    stopIfNoPlayers()
+  }
+
+  fun updatePlayerPreferences(player: HybridVideoPlayer) {
+    val session = mediaSessionsList[player]
+    if (session == null) {
+      // If not registered but now needs it, register
+      if (player.playInBackground || player.showNotificationControls) {
+        val activity = try { NitroModules.applicationContext?.currentActivity } catch (_: Exception) { null }
+        if (activity != null) registerPlayer(player, activity.javaClass)
+      }
+      return
+    }
+
+    // If no longer needs registration, unregister and possibly stop service
+    if (!player.playInBackground && !player.showNotificationControls) {
+      unregisterPlayer(player)
+      stopIfNoPlayers()
+      return
+    }
+  }
+
+  // Callbacks
+
+  override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaSession? = null
+
+  override fun onBind(intent: Intent?): IBinder {
+    super.onBind(intent)
+    return binder
+  }
+
+  override fun onTaskRemoved(rootIntent: Intent?) {
+    stopForegroundSafely()
+    cleanup()
+    stopSelf()
+  }
+
+  override fun onDestroy() {
+    stopForegroundSafely()
+    cleanup()
+    super.onDestroy()
+  }
+
+  private fun stopForegroundSafely() {
+    try {
+      stopForeground(STOP_FOREGROUND_REMOVE)
+    } catch (_: Exception) {
+      Log.e(TAG, "Failed to stop foreground service!")
+    }
+  }
+
+  private fun cleanup() {
+    stopForegroundSafely()
+    stopSelf()
+    mediaSessionsList.forEach { (_, session) ->
+      session.release()
+    }
+    mediaSessionsList.clear()
+  }
+
+  // Stop the service if there are no active media sessions (no players need it)
+  fun stopIfNoPlayers() {
+    if (mediaSessionsList.isEmpty()) {
+      // Remove placeholder notification and stop the service when no active players exist
+      try {
+        if (isForeground) {
+          stopForegroundSafely()
+          isForeground = false
+        }
+      } catch (_: Exception) {
+        Log.e(TAG, "Failed to stop foreground service!")
+      }
+      cleanup()
+    }
+  }
+
+  companion object {
+    const val TAG = "VideoPlaybackService"
+    const val VIDEO_PLAYBACK_SERVICE_INTERFACE = SERVICE_INTERFACE
+    private const val PLACEHOLDER_NOTIFICATION_ID = 1729
+    private const val NOTIFICATION_CHANNEL_ID = "twg_video_playback"
+  }
+
+  private fun createPlaceholderNotification(): Notification {
+    val nm = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      try {
+        if (nm.getNotificationChannel(NOTIFICATION_CHANNEL_ID) == null) {
+          val channel = NotificationChannel(
+            NOTIFICATION_CHANNEL_ID,
+            "Media playback",
+            NotificationManager.IMPORTANCE_LOW
+          )
+          channel.setShowBadge(false)
+          nm.createNotificationChannel(channel)
+        }
+      } catch (_: Exception) {
+        Log.e(TAG, "Failed to create notification channel!")
+      }
+    }
+
+    val appName = try {
+      val labelRes = applicationInfo.labelRes
+      if (labelRes != 0) {
+        getString(labelRes)
+      } else {
+        applicationInfo.nonLocalizedLabel?.toString() ?: applicationInfo.loadLabel(packageManager).toString()
+      }
+    } catch (_: Exception) {
+      "Media Playback"
+    }
+
+    return NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)
+      .setSmallIcon(android.R.drawable.ic_media_play)
+      .setContentTitle(appName)
+      .setContentText("")
+      .setOngoing(true)
+      .setCategory(Notification.CATEGORY_SERVICE)
+      .build()
+  }
+}

package/android/src/main/java/com/twg/video/core/services/playback/VideoPlaybackServiceConnection.kt

@@ -0,0 +1,59 @@
+package com.twg.video.core.services.playback
+
+import android.content.ComponentName
+import android.content.ServiceConnection
+import android.os.IBinder
+import android.util.Log
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.video.HybridVideoPlayer
+import java.lang.ref.WeakReference
+
+@OptIn(UnstableApi::class)
+class VideoPlaybackServiceConnection (private val player: WeakReference<HybridVideoPlayer>) :
+    ServiceConnection {
+  var serviceBinder: VideoPlaybackServiceBinder? = null
+
+  override fun onServiceConnected(componentName: ComponentName?, binder: IBinder?) {
+    val player = player.get() ?: return
+
+    try {
+      val activity = NitroModules.Companion.applicationContext?.currentActivity ?: run {
+        Log.e("VideoPlaybackServiceConnection", "Activity is null")
+        return
+      }
+
+      serviceBinder = binder as? VideoPlaybackServiceBinder
+      // Only register when the player actually needs background service/notification
+      if (player.playInBackground || player.showNotificationControls) {
+        serviceBinder?.service?.registerPlayer(player, activity.javaClass)
+      }
+    } catch (err: Exception) {
+      Log.e("VideoPlaybackServiceConnection", "Could not bind to playback service", err)
+    }
+  }
+
+  override fun onServiceDisconnected(componentName: ComponentName?) {
+    player.get()?.let {
+      unregisterPlayer(it)
+    }
+    serviceBinder = null
+  }
+
+  override fun onNullBinding(componentName: ComponentName?) {
+    Log.e(
+      "VideoPlaybackServiceConnection",
+      "Could not bind to playback service - there can be issues with background playback" +
+        "and notification controls"
+    )
+  }
+
+  fun unregisterPlayer(player: HybridVideoPlayer) {
+    try {
+      if (serviceBinder?.service != null) {
+        serviceBinder?.service?.unregisterPlayer(player)
+      }
+    } catch (_: Exception) {}
+  }
+}

package/android/src/main/java/com/twg/video/core/utils/PictureInPictureUtils.kt

@@ -0,0 +1,153 @@
+package com.twg.video.core.utils
+
+import android.app.PictureInPictureParams
+import android.content.pm.PackageManager
+import android.graphics.Rect
+import android.os.Build
+import android.util.Log
+import android.util.Rational
+import android.view.View
+import androidx.annotation.OptIn
+import androidx.annotation.RequiresApi
+import androidx.media3.common.util.UnstableApi
+import com.margelo.nitro.NitroModules
+import com.twg.video.view.VideoView
+
+@OptIn(UnstableApi::class)
+object PictureInPictureUtils {
+  private const val TAG = "PictureInPictureUtils"
+
+  fun canEnterPictureInPicture(): Boolean {
+    val applicationContent = NitroModules.applicationContext
+    val currentActivity = applicationContent?.currentActivity
+    return currentActivity?.packageManager?.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE) == true
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  fun createPictureInPictureParams(videoView: VideoView): PictureInPictureParams {
+    val builder = PictureInPictureParams.Builder()
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && videoView.autoEnterPictureInPicture) {
+      builder.setAutoEnterEnabled(videoView.autoEnterPictureInPicture)
+    }
+
+    return builder
+      .setAspectRatio(calculateAspectRatio(videoView))
+      .setSourceRectHint(calculateSourceRectHint(videoView.playerView))
+      .build()
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  fun createDisabledPictureInPictureParams(videoView: VideoView): PictureInPictureParams {
+    val defaultParams = PictureInPictureParams.Builder()
+      .setAspectRatio(null) // Clear aspect ratio
+      .setSourceRectHint(null) // Clear source rect hint
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      defaultParams.setAutoEnterEnabled(false)
+    }
+
+    return defaultParams.build()
+  }
+
+  fun calculateAspectRatio(videoView: VideoView): Rational {
+    // AspectRatio for PIP must be between 2.39:1 and 1:2.39
+    // see: https://developer.android.com/reference/android/app/PictureInPictureParams.Builder#setAspectRatio(android.util.Rational)
+
+    val maximumAspectRatio = Rational(239, 100)
+    val minimumAspectRatio = Rational(100, 239)
+
+    val player = videoView.hybridPlayer?.player
+    val videoFormat = player?.videoFormat
+    
+    var width: Int
+    var height: Int
+    
+    if (videoFormat != null && videoFormat.width > 0 && videoFormat.height > 0) {
+      width = videoFormat.width
+      height = videoFormat.height
+      
+      val rotationDegrees = videoFormat.rotationDegrees
+      if (rotationDegrees == 90 || rotationDegrees == 270) {
+        val temp = width
+        width = height
+        height = temp
+      }
+      
+      Log.d(TAG, "Using video format dimensions for PiP: ${width}x${height} (rotation: ${rotationDegrees}°)")
+    } else {
+      width = videoView.playerView.width
+      height = videoView.playerView.height
+      Log.d(TAG, "Using view dimensions for PiP: ${width}x${height}")
+    }
+
+    val currentAspectRatio = Rational(width, height)
+
+    return when {
+      currentAspectRatio > maximumAspectRatio -> maximumAspectRatio
+      currentAspectRatio < minimumAspectRatio -> minimumAspectRatio
+      else -> currentAspectRatio
+    }
+  }
+
+  fun calculateSourceRectHint(view: View): Rect {
+    // Get the visible rectangle of view in screen coordinates
+    val visibleRect = Rect()
+    view.getGlobalVisibleRect(visibleRect)
+
+    // Get the Y position of view on the screen
+    val locationOnScreen = IntArray(2)
+    view.getLocationOnScreen(locationOnScreen)
+    val yOnScreen = locationOnScreen[1]
+
+    // Preserve the original height
+    val height = visibleRect.height()
+
+    // Set the new top and bottom based on the view's screen position
+    visibleRect.top = yOnScreen
+    visibleRect.bottom = yOnScreen + height
+
+    return visibleRect
+  }
+
+  fun safeSetPictureInPictureParams(params: PictureInPictureParams) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      try {
+        val currentActivity = NitroModules.applicationContext?.currentActivity
+        currentActivity?.setPictureInPictureParams(params)
+        Log.d(TAG, "Successfully set PiP params")
+      } catch (e: Exception) {
+        Log.w(TAG, "Failed to set PiP params - PiP may not be enabled in manifest", e)
+        // Ignore: We cannot check if user has added support for PIP in manifest
+        // so we need to catch error if he did not add it.
+      }
+    }
+  }
+  
+  @RequiresApi(Build.VERSION_CODES.O)
+  fun safeEnterPictureInPictureMode(params: PictureInPictureParams): Boolean {
+    return try {
+      val currentActivity = NitroModules.applicationContext?.currentActivity
+      val result = currentActivity?.enterPictureInPictureMode(params) ?: false
+      Log.d(TAG, "PiP enter result: $result")
+      result
+    } catch (e: Exception) {
+      Log.e(TAG, "Failed to enter PiP mode", e)
+      false
+    }
+  }
+  
+  fun isCurrentlyInPictureInPictureMode(): Boolean {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      try {
+        val currentActivity = NitroModules.applicationContext?.currentActivity
+        currentActivity?.isInPictureInPictureMode == true
+      } catch (e: Exception) {
+        Log.w(TAG, "Failed to check PiP mode status", e)
+        false
+      }
+    } else {
+      false
+    }
+  }
+}