@stepincto/expo-video 2.2.2-sicto.0

package/README.md

@@ -0,0 +1,41 @@
+<p>
+  <a href="https://docs.expo.dev/versions/unversioned/sdk/video/">
+    <img
+      src="../../.github/resources/expo-video.svg"
+      alt="expo-video"
+      height="64" />
+  </a>
+</p>
+
+A cross-platform, performant video component for React Native and Expo with Web support
+
+# API documentation
+
+- [Documentation for the latest stable release](https://docs.expo.dev/versions/latest/sdk/video/)
+- [Documentation for the main branch](https://docs.expo.dev/versions/unversioned/sdk/video/)
+
+# Installation in managed Expo projects
+
+For [managed](https://docs.expo.dev/archive/managed-vs-bare/) Expo projects, please follow the installation instructions in the [API documentation for the latest stable release](#api-documentation). If you follow the link and there is no documentation available then this library is not yet usable within managed projects &mdash; it is likely to be included in an upcoming Expo SDK release.
+
+# Installation in bare React Native projects
+
+For bare React Native projects, you must ensure that you have [installed and configured the `expo` package](https://docs.expo.dev/bare/installing-expo-modules/) before continuing.
+
+### Add the package to your npm dependencies
+
+```
+npm install expo-video
+```
+
+# Contributing
+
+Contributions are very welcome! Please refer to guidelines described in the [contributing guide](https://github.com/expo/expo#contributing).
+
+
+# building with npm
+```bash
+npm run build:plugin     # should succeed now
+npm run build:once       # or run build:lib then build:plugin
+npm run pack:local
+```

package/android/build.gradle

@@ -0,0 +1,32 @@
+plugins {
+  id 'com.android.library'
+  id 'expo-module-gradle-plugin'
+}
+
+group = 'host.exp.exponent'
+version = '2.2.2'
+
+android {
+  namespace "expo.modules.video"
+  defaultConfig {
+    versionCode 1
+    versionName '2.2.2'
+  }
+}
+
+dependencies {
+  implementation 'com.facebook.react:react-android'
+
+  // Remember to keep this in sync with the version in `expo-audio`
+  def androidxMedia3Version = "1.4.0"
+  implementation "androidx.media3:media3-session:${androidxMedia3Version}"
+  implementation "androidx.media3:media3-exoplayer:${androidxMedia3Version}"
+  implementation "androidx.media3:media3-exoplayer-dash:${androidxMedia3Version}"
+  implementation "androidx.media3:media3-exoplayer-hls:${androidxMedia3Version}"
+  implementation "androidx.media3:media3-ui:${androidxMedia3Version}"
+  implementation "androidx.media3:media3-datasource-okhttp:${androidxMedia3Version}"
+
+  def fragment_version = "1.6.2"
+  implementation "androidx.fragment:fragment:$fragment_version"
+  implementation "androidx.fragment:fragment-ktx:$fragment_version"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,20 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
+
+  <application>
+    <activity android:name=".FullscreenPlayerActivity"
+      android:supportsPictureInPicture="true"
+      android:configChanges="screenSize|smallestScreenSize|screenLayout|orientation"
+      android:theme="@style/Fullscreen"/>
+    <service
+      android:name=".playbackService.ExpoVideoPlaybackService"
+      android:exported="false"
+      android:foregroundServiceType="mediaPlayback">
+      <intent-filter>
+        <action android:name="androidx.media3.session.MediaSessionService" />
+      </intent-filter>
+    </service>
+  </application>
+</manifest>

package/android/src/main/java/expo/modules/video/AudioFocusManager.kt

@@ -0,0 +1,241 @@
+package expo.modules.video
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+import android.os.Build
+import androidx.media3.common.util.UnstableApi
+import expo.modules.kotlin.AppContext
+import expo.modules.video.enums.AudioMixingMode
+import expo.modules.video.player.VideoPlayer
+import expo.modules.video.player.VideoPlayerListener
+import kotlinx.coroutines.launch
+import java.lang.ref.WeakReference
+
+@UnstableApi
+class AudioFocusManager(private val appContext: AppContext) : AudioManager.OnAudioFocusChangeListener, VideoPlayerListener {
+  private val audioManager by lazy {
+    appContext.reactContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager ?: run {
+      throw FailedToGetAudioFocusManagerException()
+    }
+  }
+
+  private var players: MutableList<WeakReference<VideoPlayer>> = mutableListOf()
+  private var currentFocusRequest: AudioFocusRequest? = null
+  private var currentMixingMode: AudioMixingMode = AudioMixingMode.MIX_WITH_OTHERS
+  private val anyPlayerRequiresFocus: Boolean
+    get() = players.toList().any {
+      playerRequiresFocus(it)
+    }
+
+  private fun requestAudioFocus() {
+    val audioMixingMode = findAudioMixingMode()
+
+    // We don't request AudioFocus if we want to mix the audio with others
+    if (audioMixingMode == AudioMixingMode.MIX_WITH_OTHERS || !anyPlayerRequiresFocus) {
+      abandonAudioFocus()
+      currentMixingMode = audioMixingMode
+      return
+    }
+    val audioFocusType = when (audioMixingMode) {
+      AudioMixingMode.DUCK_OTHERS -> AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK
+      AudioMixingMode.AUTO -> AudioManager.AUDIOFOCUS_GAIN
+      AudioMixingMode.DO_NOT_MIX -> AudioManager.AUDIOFOCUS_GAIN
+      else -> AudioManager.AUDIOFOCUS_GAIN
+    }
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      // We already have audio focus
+      currentFocusRequest?.let {
+        if (it.focusGain == audioFocusType) {
+          return
+        }
+      }
+
+      val newFocusRequest = AudioFocusRequest.Builder(audioFocusType).run {
+        setAudioAttributes(
+          AudioAttributes.Builder().run {
+            setUsage(AudioAttributes.USAGE_MEDIA)
+            setContentType(AudioAttributes.CONTENT_TYPE_MOVIE)
+            setOnAudioFocusChangeListener(this@AudioFocusManager)
+            build()
+          }
+        ).build()
+      }
+      currentFocusRequest = newFocusRequest
+      audioManager.requestAudioFocus(newFocusRequest)
+    } else {
+      @Suppress("DEPRECATION")
+      audioManager.requestAudioFocus(
+        this,
+        AudioManager.STREAM_MUSIC,
+        audioFocusType
+      )
+    }
+    currentMixingMode = audioMixingMode
+  }
+
+  private fun abandonAudioFocus() {
+    currentFocusRequest?.let {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        audioManager.abandonAudioFocusRequest(it)
+      } else {
+        @Suppress("DEPRECATION")
+        audioManager.abandonAudioFocus(this)
+      }
+    }
+    currentFocusRequest = null
+  }
+
+  fun registerPlayer(player: VideoPlayer) {
+    players.find { it.get() == player } ?: run {
+      players.add(WeakReference(player))
+    }
+    player.addListener(this)
+    updateAudioFocus()
+  }
+
+  fun unregisterPlayer(player: VideoPlayer) {
+    player.removeListener(this)
+    players.removeAll { it.get() == player }
+    updateAudioFocus()
+  }
+
+  // VideoPlayerListener
+
+  override fun onAudioMixingModeChanged(player: VideoPlayer, audioMixingMode: AudioMixingMode, oldAudioMixingMode: AudioMixingMode?) {
+    requestAudioFocus()
+    super.onAudioMixingModeChanged(player, audioMixingMode, oldAudioMixingMode)
+  }
+
+  override fun onIsPlayingChanged(player: VideoPlayer, isPlaying: Boolean, oldIsPlaying: Boolean?) {
+    // we can't use `updateAudioFocus`, because when losing focus the videos are paused sequentially,
+    // which can lead to unexpected results.
+    if (!isPlaying && !anyPlayerRequiresFocus) {
+      abandonAudioFocus()
+    } else if (isPlaying && anyPlayerRequiresFocus) {
+      requestAudioFocus()
+    }
+  }
+
+  override fun onVolumeChanged(player: VideoPlayer, volume: Float, oldVolume: Float?) {
+    updateAudioFocus()
+  }
+
+  override fun onMutedChanged(player: VideoPlayer, muted: Boolean, oldMuted: Boolean?) {
+    updateAudioFocus()
+  }
+
+  // AudioManager.OnAudioFocusChangeListener
+
+  override fun onAudioFocusChange(focusChange: Int) {
+    when (focusChange) {
+      AudioManager.AUDIOFOCUS_LOSS -> {
+        appContext.mainQueue.launch {
+          players.forEach {
+            pausePlayerIfUnmuted(it)
+          }
+          currentFocusRequest = null
+        }
+      }
+
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+        // W could pause/mix the players here individually, but we will keep the behaviour in line with iOS,
+        // find the dominant audioMixingMode and apply it to all players.
+        val audioMixingMode = findAudioMixingMode()
+        if (audioMixingMode == AudioMixingMode.MIX_WITH_OTHERS) {
+          return
+        }
+        appContext.mainQueue.launch {
+          players.forEach {
+            pausePlayerIfUnmuted(it)
+          }
+          currentFocusRequest = null
+        }
+      }
+
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+        val audioMixingMode = findAudioMixingMode()
+
+        appContext.mainQueue.launch {
+          players.forEach {
+            if (audioMixingMode == AudioMixingMode.DO_NOT_MIX) {
+              pausePlayerIfUnmuted(it)
+            } else {
+              duckPlayer(it)
+            }
+          }
+        }
+      }
+
+      AudioManager.AUDIOFOCUS_GAIN -> {
+        //  TODO: For now this behaves like iOS and doesn't resume playback automatically
+        //  In future versions we can add a prop to control this behavior.
+        appContext.mainQueue.launch {
+          players.forEach {
+            unduckPlayer(it)
+          }
+        }
+      }
+    }
+  }
+
+  // Utils
+
+  private fun playerRequiresFocus(weakPlayer: WeakReference<VideoPlayer>): Boolean {
+    val player = weakPlayer?.get() ?: return false // Return false if player is null
+    return (!player.muted && player.playing && player.volume > 0) || player.audioMixingMode == AudioMixingMode.DO_NOT_MIX
+  }
+
+  private fun pausePlayerIfUnmuted(weakPlayer: WeakReference<VideoPlayer>) {
+    weakPlayer.get()?.let { videoPlayer ->
+      if (!videoPlayer.muted) {
+        appContext.mainQueue.launch {
+          videoPlayer.player.pause()
+        }
+      }
+    }
+  }
+
+  private fun duckPlayer(weakPlayer: WeakReference<VideoPlayer>) {
+    weakPlayer.get()?.let { player ->
+      appContext.mainQueue.launch {
+        player.volume /= 2f
+      }
+    }
+  }
+
+  private fun unduckPlayer(weakPlayer: WeakReference<VideoPlayer>) {
+    weakPlayer.get()?.let { player ->
+      if (!player.muted) {
+        appContext.mainQueue.launch {
+          player.volume = player.userVolume
+        }
+      }
+    }
+  }
+
+  private fun updateAudioFocus() {
+    if (anyPlayerRequiresFocus || findAudioMixingMode() != currentMixingMode) {
+      requestAudioFocus()
+    } else {
+      abandonAudioFocus()
+    }
+  }
+
+  private fun findAudioMixingMode(): AudioMixingMode {
+    val playersSnapshot = players.toList()
+
+    val mixingModes = playersSnapshot.mapNotNull { player ->
+      player.get()?.takeIf { it.playing }?.audioMixingMode
+    }
+    if (mixingModes.isEmpty()) {
+      return AudioMixingMode.MIX_WITH_OTHERS
+    }
+
+    return mixingModes.reduce { currentAudioMixingMode, next ->
+      next.takeIf { it.priority > currentAudioMixingMode.priority } ?: currentAudioMixingMode
+    }
+  }
+}

package/android/src/main/java/expo/modules/video/FullscreenPlayerActivity.kt

@@ -0,0 +1,145 @@
+package expo.modules.video
+
+import android.app.Activity
+import android.content.res.Configuration
+import android.os.Build
+import android.os.Bundle
+import android.util.Log
+import android.view.View
+import android.view.WindowInsets
+import android.view.WindowInsetsController
+import android.widget.ImageButton
+import androidx.media3.ui.PlayerView
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.video.player.VideoPlayer
+import expo.modules.video.utils.applyPiPParams
+import expo.modules.video.utils.applyRectHint
+import expo.modules.video.utils.calculatePiPAspectRatio
+import expo.modules.video.utils.calculateRectHint
+
+@androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)
+class FullscreenPlayerActivity : Activity() {
+  private lateinit var mContentView: View
+  private lateinit var videoViewId: String
+  private var videoPlayer: VideoPlayer? = null
+  private lateinit var playerView: PlayerView
+  private lateinit var videoView: VideoView
+  private var didFinish = false
+  private var wasAutoPaused = false
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    setContentView(R.layout.fullscreen_player_activity)
+    mContentView = findViewById(R.id.enclosing_layout)
+    playerView = findViewById(R.id.player_view)
+
+    try {
+      videoViewId = intent.getStringExtra(VideoManager.INTENT_PLAYER_KEY)
+        ?: throw FullScreenVideoViewNotFoundException()
+      videoView = VideoManager.getVideoView(videoViewId)
+    } catch (e: CodedException) {
+      Log.e("ExpoVideo", "${e.message}", e)
+      finish()
+      return
+    }
+    videoPlayer = videoView.videoPlayer
+    videoPlayer?.changePlayerView(playerView)
+    VideoManager.registerFullscreenPlayerActivity(hashCode().toString(), this)
+    playerView.player?.let {
+      val aspectRatio = calculatePiPAspectRatio(it.videoSize, playerView.width, playerView.height, videoView.contentFit)
+      applyPiPParams(this, videoView.autoEnterPiP, aspectRatio)
+    }
+  }
+
+  override fun onPostCreate(savedInstanceState: Bundle?) {
+    super.onPostCreate(savedInstanceState)
+    hideStatusBar()
+    setupFullscreenButton()
+    playerView.applyRequiresLinearPlayback(videoPlayer?.requiresLinearPlayback ?: false)
+    playerView.addOnLayoutChangeListener { _, _, _, _, _, _, _, _, _ ->
+      // On every re-layout ExoPlayer makes the timeBar interactive.
+      // We need to disable it to keep scrubbing off.
+      playerView.setTimeBarInteractive(videoPlayer?.requiresLinearPlayback ?: true)
+    }
+    playerView.setShowSubtitleButton(videoView.showsSubtitlesButton)
+
+    playerView.addOnLayoutChangeListener { _, _, _, _, _, _, _, _, _ ->
+      applyRectHint(this, calculateRectHint(playerView))
+    }
+  }
+
+  override fun finish() {
+    super.finish()
+    didFinish = true
+    VideoManager.getVideoView(videoViewId).attachPlayer()
+
+    // Disable the exit transition
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+      overrideActivityTransition(OVERRIDE_TRANSITION_CLOSE, 0, 0)
+    } else {
+      @Suppress("DEPRECATION")
+      overridePendingTransition(0, 0)
+    }
+  }
+
+  override fun onResume() {
+    playerView.useController = videoView.useNativeControls
+    super.onResume()
+  }
+
+  override fun onPause() {
+    if (videoPlayer?.staysActiveInBackground != true && !didFinish) {
+      wasAutoPaused = videoPlayer?.player?.isPlaying == true
+      if (wasAutoPaused) {
+        playerView.useController = false
+        videoPlayer?.player?.pause()
+      }
+    }
+    super.onPause()
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+    videoView.exitFullscreen()
+    VideoManager.unregisterFullscreenPlayerActivity(hashCode().toString())
+  }
+
+  private fun setupFullscreenButton() {
+    playerView.setFullscreenButtonClickListener { finish() }
+
+    val fullScreenButton: ImageButton = playerView.findViewById(androidx.media3.ui.R.id.exo_fullscreen)
+    fullScreenButton.setImageResource(androidx.media3.ui.R.drawable.exo_icon_fullscreen_exit)
+  }
+
+  override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean, newConfig: Configuration?) {
+    if (!isInPictureInPictureMode) {
+      playerView.useController = videoView.useNativeControls
+    } else {
+      playerView.useController = false
+    }
+    if (wasAutoPaused && isInPictureInPictureMode) {
+      videoPlayer?.player?.play()
+    }
+    super.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig)
+  }
+
+  private fun hideStatusBar() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      val controller = mContentView.windowInsetsController
+      controller?.apply {
+        systemBarsBehavior = WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+        hide(WindowInsets.Type.statusBars() or WindowInsets.Type.navigationBars())
+      }
+    } else {
+      @Suppress("DEPRECATION")
+      mContentView.systemUiVisibility = (
+        View.SYSTEM_UI_FLAG_LOW_PROFILE
+          or View.SYSTEM_UI_FLAG_FULLSCREEN
+          or View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+          or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
+          or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+          or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+        )
+    }
+  }
+}

package/android/src/main/java/expo/modules/video/IntervalUpdateClock.kt

@@ -0,0 +1,54 @@
+package expo.modules.video
+
+import android.os.Handler
+import android.os.Looper
+import expo.modules.video.delegates.IgnoreSameSet
+import java.lang.ref.WeakReference
+
+fun interface IntervalUpdateEmitter {
+  fun emitTimeUpdate()
+}
+
+class IntervalUpdateClock(emitter: IntervalUpdateEmitter) {
+  private val emitter: WeakReference<IntervalUpdateEmitter> = WeakReference(emitter)
+  private var handler: Handler = Handler(Looper.getMainLooper())
+
+  // TODO: @behenate - Once the Player instance is available in OnStartObserving we can automatically start/stop the clock.
+  var interval by IgnoreSameSet(0L) { new: Long, _: Long? ->
+    if (new <= 0) {
+      stop()
+    } else {
+      startOrUpdate()
+    }
+  }
+
+  private var isRunning: Boolean = false
+
+  private fun stop() {
+    handler.removeCallbacksAndMessages(null)
+    isRunning = false
+  }
+
+  private fun startOrUpdate() {
+    if (!isRunning) {
+      emitter.get()?.emitTimeUpdate()
+    } else {
+      handler.removeCallbacksAndMessages(null)
+    }
+    isRunning = true
+    scheduleNextUpdate()
+  }
+
+  private fun scheduleNextUpdate() {
+    if (interval <= 0L) {
+      return
+    }
+
+    val update = {
+      emitter.get()?.emitTimeUpdate()
+      scheduleNextUpdate()
+    }
+
+    handler.postDelayed(update, interval)
+  }
+}

package/android/src/main/java/expo/modules/video/MediaMetadataRetriever.kt

@@ -0,0 +1,89 @@
+package expo.modules.video
+
+import android.graphics.Bitmap
+import android.media.MediaMetadataRetriever
+import android.os.Build
+import expo.modules.video.records.VideoThumbnailOptions
+import kotlin.math.max
+import kotlin.math.roundToLong
+import kotlin.time.Duration
+import kotlin.time.DurationUnit
+import kotlin.time.toDuration
+
+suspend fun <T> MediaMetadataRetriever.safeUse(block: suspend MediaMetadataRetriever.() -> T): T {
+  try {
+    return block()
+  } finally {
+    try {
+      this.close()
+    } finally {
+      // ignore
+    }
+  }
+}
+
+fun MediaMetadataRetriever.generateThumbnailAtTime(
+  requestedTime: Duration,
+  options: VideoThumbnailOptions? = null
+): VideoThumbnail {
+  val sizeLimit = options?.toNativeSizeLimit()
+
+  val bitmap = if (sizeLimit != null) {
+    val (maxWidth, maxHeight) = sizeLimit
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+      getScaledFrameAtTime(
+        requestedTime.inWholeMicroseconds,
+        MediaMetadataRetriever.OPTION_CLOSEST,
+        maxWidth,
+        maxHeight
+      )
+    } else {
+      getFrameAtTime(requestedTime.inWholeMicroseconds, MediaMetadataRetriever.OPTION_CLOSEST)
+        ?.constrainToDimensions(maxWidth, maxHeight)
+    }
+  } else {
+    getFrameAtTime(requestedTime.inWholeMicroseconds, MediaMetadataRetriever.OPTION_CLOSEST)
+  } ?: throw IllegalStateException("Failed to generate thumbnail")
+
+  val actualTime = calculateActualFrameTime(this, requestedTime)
+  return VideoThumbnail(bitmap, requestedTime, actualTime)
+}
+
+private fun calculateActualFrameTime(mediaMetadataRetriever: MediaMetadataRetriever, time: Duration): Duration {
+  // if we can't get the frame rate, we are returning the requested time
+  val frameTime = mediaMetadataRetriever.frameTime() ?: return time
+
+  // calculate closest frame index
+  val frameIndex = (time.inWholeMicroseconds.toDouble() / frameTime).roundToLong()
+
+  return (frameIndex * frameTime).toDuration(DurationUnit.MICROSECONDS)
+}
+
+private fun MediaMetadataRetriever.frameTime(): Double? {
+  // frame count is not available on Android SDK < 28
+  if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.P) {
+    return null
+  }
+
+  val duration = this.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)?.toDouble()
+    ?: return null
+  val frameCount = this.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_FRAME_COUNT)?.toDouble()
+    ?: return null
+
+  return (duration * 1000) / frameCount
+}
+
+private fun Bitmap.constrainToDimensions(maxWidth: Int, maxHeight: Int): Bitmap {
+  val width = this.width
+  val height = this.height
+
+  val ratio = max(width / maxWidth.toFloat(), height / maxHeight.toFloat())
+  if (ratio <= 1) {
+    return this
+  }
+
+  val newWidth = (width / ratio).toInt()
+  val newHeight = (height / ratio).toInt()
+
+  return Bitmap.createScaledBitmap(this, newWidth, newHeight, true)
+}

package/android/src/main/java/expo/modules/video/PictureInPictureHelperFragment.kt

@@ -0,0 +1,26 @@
+package expo.modules.video
+
+import androidx.fragment.app.Fragment
+import java.util.UUID
+
+class PictureInPictureHelperFragment(private val videoView: VideoView) : Fragment() {
+  val id = "${PictureInPictureHelperFragment::class.java.simpleName}_${UUID.randomUUID()}"
+
+  override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean) {
+    super.onPictureInPictureModeChanged(isInPictureInPictureMode)
+
+    if (isInPictureInPictureMode) {
+      // We can't reliably detect when the PiP transition starts (while keeping the transition smooth 🙄), so we have to
+      // unpause the playback after the onPause event, is called right after onPause. So the pause is not noticeable
+      if (videoView.wasAutoPaused) {
+        videoView.playerView.player?.play()
+      }
+      videoView.layoutForPiPEnter()
+      videoView.onPictureInPictureStart(Unit)
+    } else {
+      videoView.willEnterPiP = false
+      videoView.layoutForPiPExit()
+      videoView.onPictureInPictureStop(Unit)
+    }
+  }
+}

package/android/src/main/java/expo/modules/video/PlayerViewExtension.kt

@@ -0,0 +1,36 @@
+package expo.modules.video
+
+import android.graphics.Color
+import androidx.media3.ui.DefaultTimeBar
+import androidx.media3.ui.PlayerView
+
+@androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)
+internal fun PlayerView.applyRequiresLinearPlayback(requireLinearPlayback: Boolean) {
+  setShowFastForwardButton(!requireLinearPlayback)
+  setShowRewindButton(!requireLinearPlayback)
+  setShowPreviousButton(!requireLinearPlayback)
+  setShowNextButton(!requireLinearPlayback)
+  setTimeBarInteractive(requireLinearPlayback)
+}
+
+@androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)
+internal fun PlayerView.setTimeBarInteractive(interactive: Boolean) {
+  val timeBar = findViewById<DefaultTimeBar>(androidx.media3.ui.R.id.exo_progress)
+  if (interactive) {
+    timeBar?.setScrubberColor(Color.TRANSPARENT)
+    timeBar?.isEnabled = false
+  } else {
+    timeBar?.setScrubberColor(Color.WHITE)
+    timeBar?.isEnabled = true
+  }
+}
+
+@androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)
+internal fun PlayerView.setFullscreenButtonVisibility(visible: Boolean) {
+  val fullscreenButton = findViewById<android.widget.ImageButton>(androidx.media3.ui.R.id.exo_fullscreen)
+  fullscreenButton?.visibility = if (visible) {
+    android.view.View.VISIBLE
+  } else {
+    android.view.View.GONE
+  }
+}