How to implement Floating Window (PIP) mode in Jetpack Compose?

package com.geeksforgeeks.demo

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent

/**
 * PipReceiver listens for broadcast actions triggered from Picture-in-Picture (PiP) mode.
 * Specifically, it responds to the custom play/pause action added to the PiP controls.
 */
class PipReceiver : BroadcastReceiver() {

    /**
     * Called when the broadcast associated with the PiP action is received.
     * This triggers playback to toggle (play or pause) via the VideoController.
     */
    override fun onReceive(context: Context, intent: Intent) {
        VideoController.togglePlayPause() // Toggle video playback state
    }
}

package com.geeksforgeeks.demo

import android.widget.VideoView
import java.lang.ref.WeakReference

/**
 * VideoController is a singleton object that provides centralized control over video playback.
 * It allows external components (like the PiP Receiver) to toggle playback without direct access to the VideoView.
 */
object VideoController {

    // A weak reference to the VideoView to avoid memory leaks
    private var videoViewRef: WeakReference<VideoView>? = null

    /**
     * Registers the VideoView instance for external control.
     * Stores it as a weak reference to prevent memory leaks.
     */
    fun setVideoView(videoView: VideoView) {
        videoViewRef = WeakReference(videoView)
    }

    /**
     * Toggles the video playback state.
     * If the video is playing, it pauses it; otherwise, it starts playback.
     */
    fun togglePlayPause() {
        videoViewRef?.get()?.let { videoView ->
            if (videoView.isPlaying) {
                videoView.pause()
            } else {
                videoView.start()
            }
        }
    }
}

package com.geeksforgeeks.demo

import android.app.PendingIntent
import android.app.PictureInPictureParams
import android.app.RemoteAction
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.graphics.Rect
import android.graphics.drawable.Icon
import android.net.Uri
import android.os.Build
import android.util.Rational
import androidx.annotation.RequiresApi

/**
 * PipManager handles all Picture-in-Picture (PiP) related functionality,
 * such as entering PiP mode and setting up custom actions.
 */
class PipManager(private val context: Context) {

    // Holds the bounds of the video on the screen, used to hint PiP position
    private var videoBounds: Rect = Rect()

    companion object {
        // Static video URL used by the player
        val VIDEO_URL: Uri =
            Uri.parse("https://www.sample-videos.com/video321/mp4/720/big_buck_bunny_720p_30mb.mp4")
    }

    // Check if PiP is supported on the current device
    private val isPipSupported: Boolean
        get() = context.packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)

    /**
     * Updates the bounds of the video view. These bounds are used as a source hint
     * for positioning the PiP window when it appears.
     */
    fun updateBounds(bounds: Rect) {
        videoBounds = bounds
    }

    /**
     * Enters Picture-in-Picture mode if supported by the device and OS version.
     * Configures the PiP parameters such as aspect ratio, source rect hint,
     * and adds a custom action (play/pause button).
     */
    fun enterPipModeIfSupported() {
        // Exit early if PiP is not supported or the API level is below 26
        if (!isPipSupported || Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return

        // Cast context to Activity (required for PiP mode)
        val activity = context as? android.app.Activity ?: return

        // Build PiP parameters
        val pipParams = PictureInPictureParams.Builder()
            .setSourceRectHint(videoBounds) // Hint for initial PiP window placement
            .setAspectRatio(Rational(16, 9)) // Set fixed aspect ratio
            .setActions(listOf(buildRemoteAction())) // Add custom PiP action
            .build()

        // Request system to enter PiP mode
        activity.enterPictureInPictureMode(pipParams)
    }

    /**
     * Creates a custom RemoteAction (e.g. Play/Pause button) that appears in the PiP window.
     * The action sends a broadcast, which is received by PipReceiver to toggle playback.
     */
    @RequiresApi(Build.VERSION_CODES.O)
    private fun buildRemoteAction(): RemoteAction {
        // Create an Intent to broadcast when the PiP action is clicked
        val intent = Intent(context, PipReceiver::class.java)

        // Wrap the intent in a PendingIntent (required for RemoteAction)
        val pendingIntent = PendingIntent.getBroadcast(
            context,
            0,
            intent,
            PendingIntent.FLAG_IMMUTABLE
        )

        // Create and return the RemoteAction with an icon, title, description, and intent
        return RemoteAction(
            Icon.createWithResource(context, R.drawable.play_pause), // Icon shown in PiP
            "Play/Pause", // Title
            "Toggle playback", // Description
            pendingIntent // Action intent
        )
    }
}

package com.geeksforgeeks.demo

import android.net.Uri
import android.widget.VideoView
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.toAndroidRect
import androidx.compose.ui.layout.boundsInWindow
import androidx.compose.ui.layout.onGloballyPositioned
import androidx.compose.ui.viewinterop.AndroidView

/**
 * Composable function that displays a VideoView inside a Compose UI using AndroidView interop.
 *
 * @param videoUrl The URL of the video to be played.
 * @param onBoundsChanged Callback to report the video’s on-screen position for PiP purposes.
 */
@Composable
fun VideoPlayerScreen(
    videoUrl: Uri,
    onBoundsChanged: (android.graphics.Rect) -> Unit
) {
    AndroidView(
        factory = { context ->
            // Creates a VideoView and configures it to play the given video
            VideoView(context).apply {
                setVideoURI(videoUrl)  // Set the video source
                start()                // Start playback automatically
                VideoController.setVideoView(this)  // Register with VideoController for external control (e.g., play/pause from PiP)
            }
        },
        modifier = Modifier
            .fillMaxWidth() // Makes the video view fill the width of the parent
            .onGloballyPositioned {
                // Captures the position and size of the VideoView on the screen
                // Converts Compose Rect to Android Rect for compatibility with PiP APIs
                onBoundsChanged(it.boundsInWindow().toAndroidRect())
            }
    )
}

package com.geeksforgeeks.demo

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.material3.MaterialTheme

/**
 * MainActivity is the entry point of the app and hosts the Jetpack Compose UI.
 * It also integrates Picture-in-Picture (PiP) functionality using PipManager.
 */
class MainActivity : ComponentActivity() {

    // Manages Picture-in-Picture logic such as entering PiP mode and updating bounds
    private lateinit var pipManager: PipManager

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Initialize PipManager with the current Activity context
        pipManager = PipManager(this)

        // Set the Compose UI content
        setContent {
            MaterialTheme {
                // Display the video player and provide a callback to report its screen bounds
                VideoPlayerScreen(
                    videoUrl = PipManager.VIDEO_URL, // Static video URL
                    onBoundsChanged = { pipManager.updateBounds(it) } // Report video bounds to PipManager
                )
            }
        }
    }

    /**
     * Called when the user is about to leave the activity (e.g., pressing the Home button).
     * This is the trigger point for entering Picture-in-Picture mode.
     */
    override fun onUserLeaveHint() {
        super.onUserLeaveHint()
        pipManager.enterPipModeIfSupported() // Attempt to enter PiP mode if supported
    }
}