expo-video 2.2.1 → 2.3.0-canary-20250713-8f814f8

package/CHANGELOG.md

@@ -6,15 +6,29 @@
 
 ### 🎉 New features
 
+- [iOS] Add complete support for AirPlay streaming. Add a device selection button and `VideoPlayer.isExternalPlaybackActive` property and appropriate listeners. ([#37207](https://github.com/expo/expo/pull/37207) by [@behenate](https://github.com/behenate))
+- Add fullscreen orientation and auto-exit functionality. ([#36910](https://github.com/expo/expo/pull/36910) by [@behenate](https://github.com/behenate))
+
 ### 🐛 Bug fixes
 
+- [Android] Fix accessing player.loop causes app to crash. ([#37928](https://github.com/expo/expo/pull/37928) by [@Wenszel](https://github.com/Wenszel))
+- [iOS] Setting `player.currentTime` doesn't seek to the correct time on some videos. ([#37672](https://github.com/expo/expo/pull/37300) by [@petrkonecny2](https://github.com/petrkonecny2))
+
 ### 💡 Others
 
-## 2.2.1 — 2025-06-10
+- Export types using the `export type` syntax. ([#37396](https://github.com/expo/expo/pull/37396) by [@behenate](https://github.com/behenate))
+
+## 2.2.2 - 2025-06-18
+
+### 🐛 Bug fixes
+
+- [Android] Fix aspect ratio of the Picture in Picture window when auto-entering for sources with ratio different from 16:9. ([#37225](https://github.com/expo/expo/pull/37225) by [@behenate](https://github.com/behenate))
+
+## 2.2.1 - 2025-06-10
 
 _This version does not introduce any user-facing changes._
 
-## 2.2.0 — 2025-06-04
+## 2.2.0 - 2025-06-04
 
 ### 🎉 New features
 

package/android/build.gradle

@@ -4,13 +4,13 @@ plugins {
 }
 
 group = 'host.exp.exponent'
-version = '2.2.1'
+version = '2.3.0-canary-20250713-8f814f8'
 
 android {
   namespace "expo.modules.video"
   defaultConfig {
     versionCode 1
-    versionName '2.2.1'
+    versionName '2.3.0-canary-20250713-8f814f8'
   }
 }
 

package/android/src/main/AndroidManifest.xml

@@ -6,8 +6,8 @@
   <application>
     <activity android:name=".FullscreenPlayerActivity"
       android:supportsPictureInPicture="true"
-      android:configChanges="screenSize|smallestScreenSize|screenLayout|orientation"
-      android:theme="@style/Fullscreen"/>
+      android:configChanges="screenSize|smallestScreenSize|screenLayout|orientation|navigation"
+      android:theme="@style/Fullscreen" />
     <service
       android:name=".playbackService.ExpoVideoPlaybackService"
       android:exported="false"

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

@@ -1,6 +1,7 @@
 package expo.modules.video
 
 import android.app.Activity
+import android.content.pm.ActivityInfo
 import android.content.res.Configuration
 import android.os.Build
 import android.os.Bundle
@@ -12,8 +13,11 @@ 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.applyAutoEnterPiP
+import expo.modules.video.records.FullscreenOptions
+import expo.modules.video.utils.FullscreenActivityOrientationHelper
+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)
@@ -25,26 +29,56 @@ class FullscreenPlayerActivity : Activity() {
   private lateinit var videoView: VideoView
   private var didFinish = false
   private var wasAutoPaused = false
+  private lateinit var options: FullscreenOptions
+  private lateinit var orientationHelper: FullscreenActivityOrientationHelper
 
   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()
+
+      options = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        intent.getSerializableExtra(INTENT_FULLSCREEN_OPTIONS_KEY, FullscreenOptions::class.java)
+          ?: throw FullScreenOptionsNotFoundException()
+      } else {
+        @Suppress("DEPRECATION")
+        intent.getSerializableExtra(INTENT_FULLSCREEN_OPTIONS_KEY) as? FullscreenOptions
+          ?: throw FullScreenOptionsNotFoundException()
+      }
+
       videoView = VideoManager.getVideoView(videoViewId)
+
+      orientationHelper = FullscreenActivityOrientationHelper(
+        this,
+        options,
+        onShouldAutoExit = {
+          finish()
+        },
+        onShouldReleaseOrientation = {
+          requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+        }
+      )
+      orientationHelper.startOrientationEventListener()
     } catch (e: CodedException) {
       Log.e("ExpoVideo", "${e.message}", e)
       finish()
       return
     }
+
+    setContentView(R.layout.fullscreen_player_activity)
+    mContentView = findViewById(R.id.enclosing_layout)
+    playerView = findViewById(R.id.player_view)
+    requestedOrientation = options.orientation.toActivityOrientation()
+
     videoPlayer = videoView.videoPlayer
     videoPlayer?.changePlayerView(playerView)
     VideoManager.registerFullscreenPlayerActivity(hashCode().toString(), this)
-    applyAutoEnterPiP(this, videoView.autoEnterPiP)
+    playerView.player?.let {
+      val aspectRatio = calculatePiPAspectRatio(it.videoSize, playerView.width, playerView.height, videoView.contentFit)
+      applyPiPParams(this, videoView.autoEnterPiP, aspectRatio)
+    }
   }
 
   override fun onPostCreate(savedInstanceState: Bundle?) {
@@ -79,6 +113,7 @@ class FullscreenPlayerActivity : Activity() {
   }
 
   override fun onResume() {
+    orientationHelper.startOrientationEventListener()
     playerView.useController = videoView.useNativeControls
     super.onResume()
   }
@@ -91,6 +126,7 @@ class FullscreenPlayerActivity : Activity() {
         videoPlayer?.player?.pause()
       }
     }
+    orientationHelper.stopOrientationEventListener()
     super.onPause()
   }
 
@@ -98,6 +134,7 @@ class FullscreenPlayerActivity : Activity() {
     super.onDestroy()
     videoView.exitFullscreen()
     VideoManager.unregisterFullscreenPlayerActivity(hashCode().toString())
+    orientationHelper.stopOrientationEventListener()
   }
 
   private fun setupFullscreenButton() {
@@ -138,4 +175,13 @@ class FullscreenPlayerActivity : Activity() {
         )
     }
   }
+
+  override fun onConfigurationChanged(newConfig: Configuration) {
+    super.onConfigurationChanged(newConfig)
+    orientationHelper.onConfigurationChanged(newConfig)
+  }
+
+  companion object {
+    const val INTENT_FULLSCREEN_OPTIONS_KEY = "fullscreen_options"
+  }
 }

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

@@ -6,6 +6,9 @@ import expo.modules.video.enums.DRMType
 internal class FullScreenVideoViewNotFoundException :
   CodedException("VideoView id wasn't passed to the activity")
 
+internal class FullScreenOptionsNotFoundException :
+  CodedException("Fullscreen options were not passed to the activity")
+
 internal class VideoViewNotFoundException(id: String) :
   CodedException("VideoView with id: $id not found")
 

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

@@ -20,6 +20,7 @@ import expo.modules.video.enums.AudioMixingMode
 import expo.modules.video.enums.ContentFit
 import expo.modules.video.player.VideoPlayer
 import expo.modules.video.records.BufferOptions
+import expo.modules.video.records.FullscreenOptions
 import expo.modules.video.records.SubtitleTrack
 import expo.modules.video.records.AudioTrack
 import expo.modules.video.records.VideoSource
@@ -225,7 +226,9 @@ class VideoModule : Module() {
 
       Property("loop")
         .get { ref: VideoPlayer ->
-          ref.player.repeatMode == REPEAT_MODE_ONE
+          runBlocking(appContext.mainQueue.coroutineContext) {
+            ref.player.repeatMode == REPEAT_MODE_ONE
+          }
         }
         .set { ref: VideoPlayer, loop: Boolean ->
           appContext.mainQueue.launch {
@@ -253,6 +256,12 @@ class VideoModule : Module() {
           ref.bufferOptions = bufferOptions
         }
 
+      Property("isExternalPlaybackActive")
+        .get { ref: VideoPlayer ->
+          // isExternalPlaybackActive is not supported on Android as of now. Return false.
+          false
+        }
+
       Function("play") { ref: VideoPlayer ->
         appContext.mainQueue.launch {
           ref.player.play()
@@ -381,6 +390,11 @@ private inline fun <reified T : VideoView> ViewDefinitionBuilder<T>.VideoViewCom
   Prop("allowsFullscreen") { view: T, allowsFullscreen: Boolean? ->
     view.allowsFullscreen = allowsFullscreen ?: true
   }
+  Prop("fullscreenOptions") { view: T, fullscreenOptions: FullscreenOptions? ->
+    if (fullscreenOptions != null) {
+      view.fullscreenOptions = fullscreenOptions
+    }
+  }
   Prop("requiresLinearPlayback") { view: T, requiresLinearPlayback: Boolean? ->
     val linearPlayback = requiresLinearPlayback ?: false
     view.playerView.applyRequiresLinearPlayback(linearPlayback)

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

@@ -15,6 +15,7 @@ import android.widget.FrameLayout
 import android.widget.ImageButton
 import androidx.fragment.app.FragmentActivity
 import androidx.media3.common.Tracks
+import androidx.media3.common.VideoSize
 import androidx.media3.ui.PlayerView
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.UIManagerHelper
@@ -27,8 +28,14 @@ import expo.modules.video.delegates.IgnoreSameSet
 import expo.modules.video.enums.ContentFit
 import expo.modules.video.player.VideoPlayer
 import expo.modules.video.player.VideoPlayerListener
-import expo.modules.video.utils.applyAutoEnterPiP
+import expo.modules.video.records.AudioTrack
+import expo.modules.video.records.SubtitleTrack
+import expo.modules.video.records.VideoSource
+import expo.modules.video.records.VideoTrack
+import expo.modules.video.utils.applyPiPParams
+import expo.modules.video.records.FullscreenOptions
 import expo.modules.video.utils.applyRectHint
+import expo.modules.video.utils.calculatePiPAspectRatio
 import expo.modules.video.utils.calculateRectHint
 import expo.modules.video.utils.dispatchMotionEvent
 import java.util.UUID
@@ -82,7 +89,7 @@ open class VideoView(context: Context, appContext: AppContext, useTextureView: B
     }
 
   var autoEnterPiP: Boolean by IgnoreSameSet(false) { new, _ ->
-    applyAutoEnterPiP(currentActivity, new)
+    applyPiPParams(currentActivity, new, calculateCurrentPipAspectRatio())
   }
 
   var contentFit: ContentFit = ContentFit.CONTAIN
@@ -126,6 +133,17 @@ open class VideoView(context: Context, appContext: AppContext, useTextureView: B
       field = value
     }
 
+  var fullscreenOptions: FullscreenOptions = FullscreenOptions()
+    set(value) {
+      field = value
+      if (value.enable) {
+        playerView.setFullscreenButtonClickListener { enterFullscreen() }
+      } else {
+        playerView.setFullscreenButtonClickListener(null)
+        playerView.setFullscreenButtonVisibility(false)
+      }
+    }
+
   private val mLayoutRunnable = Runnable {
     measure(
       MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
@@ -166,6 +184,7 @@ open class VideoView(context: Context, appContext: AppContext, useTextureView: B
   fun enterFullscreen() {
     val intent = Intent(context, FullscreenPlayerActivity::class.java)
     intent.putExtra(VideoManager.INTENT_PLAYER_KEY, videoViewId)
+    intent.putExtra(FullscreenPlayerActivity.INTENT_FULLSCREEN_OPTIONS_KEY, fullscreenOptions)
     // Set before starting the activity to avoid entering PiP unintentionally
     isInFullscreen = true
     currentActivity.startActivity(intent)
@@ -178,7 +197,7 @@ open class VideoView(context: Context, appContext: AppContext, useTextureView: B
       currentActivity.overridePendingTransition(0, 0)
     }
     onFullscreenEnter(Unit)
-    applyAutoEnterPiP(currentActivity, false)
+    applyPiPParams(currentActivity, false, calculateCurrentPipAspectRatio())
   }
 
   fun attachPlayer() {
@@ -192,7 +211,7 @@ open class VideoView(context: Context, appContext: AppContext, useTextureView: B
     attachPlayer()
     onFullscreenExit(Unit)
     isInFullscreen = false
-    applyAutoEnterPiP(currentActivity, autoEnterPiP)
+    applyPiPParams(currentActivity, autoEnterPiP, calculateCurrentPipAspectRatio())
   }
 
   fun enterPictureInPicture() {
@@ -203,32 +222,9 @@ open class VideoView(context: Context, appContext: AppContext, useTextureView: B
     val player = playerView.player
       ?: throw PictureInPictureEnterException("No player attached to the VideoView")
     playerView.useController = false
-
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      var aspectRatio = if (contentFit == ContentFit.CONTAIN) {
-        Rational(player.videoSize.width, player.videoSize.height)
-      } else {
-        Rational(width, height)
-      }
-      // AspectRatio for the activity in picture-in-picture, must be between 2.39:1 and 1:2.39 (inclusive).
-      // https://developer.android.com/reference/android/app/PictureInPictureParams.Builder#setAspectRatio(android.util.Rational)
-      val maximumRatio = Rational(239, 100)
-      val minimumRatio = Rational(100, 239)
-      if (aspectRatio.toFloat() > maximumRatio.toFloat()) {
-        aspectRatio = maximumRatio
-      } else if (aspectRatio.toFloat() < minimumRatio.toFloat()) {
-        aspectRatio = minimumRatio
-      }
-
-      currentActivity.setPictureInPictureParams(
-        PictureInPictureParams
-          .Builder()
-          .setAspectRatio(aspectRatio)
-          .build()
-      )
-    }
-
+    applyPiPParams(currentActivity, autoEnterPiP, calculateCurrentPipAspectRatio())
     willEnterPiP = true
+
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
       currentActivity.enterPictureInPictureMode(PictureInPictureParams.Builder().build())
     } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
@@ -237,6 +233,11 @@ open class VideoView(context: Context, appContext: AppContext, useTextureView: B
     }
   }
 
+  private fun calculateCurrentPipAspectRatio(): Rational? {
+    val player = videoPlayer?.player ?: return null
+    return calculatePiPAspectRatio(player.videoSize, this.width, this.height, contentFit)
+  }
+
   /**
    * For optimal picture in picture experience it's best to only have one view. This method
    * hides all children of the root view and makes the player the only visible child of the rootView.
@@ -263,6 +264,22 @@ open class VideoView(context: Context, appContext: AppContext, useTextureView: B
     this.addView(playerView)
   }
 
+  override fun onVideoSourceLoaded(
+    player: VideoPlayer,
+    videoSource: VideoSource?,
+    duration: Double?,
+    availableVideoTracks: List<VideoTrack>,
+    availableSubtitleTracks: List<SubtitleTrack>,
+    availableAudioTracks: List<AudioTrack>
+  ) {
+    availableVideoTracks.firstOrNull()?.let {
+      val videoSize = VideoSize(it.size.width, it.size.height)
+      val aspectRatio = calculatePiPAspectRatio(videoSize, this.width, this.height, contentFit)
+      applyPiPParams(currentActivity, autoEnterPiP, aspectRatio)
+    }
+    super.onVideoSourceLoaded(player, videoSource, duration, availableVideoTracks, availableSubtitleTracks, availableAudioTracks)
+  }
+
   override fun onTracksChanged(player: VideoPlayer, tracks: Tracks) {
     showsSubtitlesButton = player.subtitles.availableSubtitleTracks.isNotEmpty()
     showsAudioTracksButton = player.audioTracks.availableAudioTracks.size > 1
@@ -302,7 +319,7 @@ open class VideoView(context: Context, appContext: AppContext, useTextureView: B
         .add(fragment, fragment.id)
         .commitAllowingStateLoss()
     }
-    applyAutoEnterPiP(currentActivity, autoEnterPiP)
+    applyPiPParams(currentActivity, autoEnterPiP)
   }
 
   override fun onDetachedFromWindow() {
@@ -314,7 +331,7 @@ open class VideoView(context: Context, appContext: AppContext, useTextureView: B
         .remove(fragment)
         .commitAllowingStateLoss()
     }
-    applyAutoEnterPiP(currentActivity, false)
+    applyPiPParams(currentActivity, false)
   }
 
   // After adding the `PlayerView` to the hierarchy the touch events stop being emitted to the JS side.

package/android/src/main/java/expo/modules/video/enums/FullscreenOrientation.kt

@@ -0,0 +1,25 @@
+package expo.modules.video.enums
+import expo.modules.kotlin.types.Enumerable
+import android.content.pm.ActivityInfo
+
+enum class FullscreenOrientation(val value: String) : Enumerable {
+  LANDSCAPE("landscape"),
+  PORTRAIT("portrait"),
+  LANDSCAPE_LEFT("landscapeLeft"),
+  LANDSCAPE_RIGHT("landscapeRight"),
+  PORTRAIT_UP("portraitUp"),
+  PORTRAIT_DOWN("portraitDown"),
+  DEFAULT("default");
+
+  fun toActivityOrientation(): Int {
+    return when (this) {
+      LANDSCAPE -> ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE
+      PORTRAIT -> ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT
+      LANDSCAPE_LEFT -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
+      LANDSCAPE_RIGHT -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
+      PORTRAIT_UP -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+      PORTRAIT_DOWN -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
+      DEFAULT -> ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+    }
+  }
+}

package/android/src/main/java/expo/modules/video/player/PlayerEvent.kt

@@ -156,7 +156,8 @@ sealed class PlayerEvent {
       is AudioMixingModeChanged -> listeners.forEach { it.onAudioMixingModeChanged(player, audioMixingMode, oldAudioMixingMode) }
       is VideoTrackChanged -> listeners.forEach { it.onVideoTrackChanged(player, videoTrack, oldVideoTrack) }
       is RenderedFirstFrame -> listeners.forEach { it.onRenderedFirstFrame(player) }
-      // JS-only events - VideoSourceLoaded, SubtitleTrackChanged - In the native events the TracksChanged can be used instead
+      is VideoSourceLoaded -> listeners.forEach { it.onVideoSourceLoaded(player, videoSource, duration, availableVideoTracks, availableSubtitleTracks, availableAudioTracks) }
+      // JS-only events - SubtitleTrackChanged - In the native events the TracksChanged can be used instead
       else -> Unit
     }
   }

package/android/src/main/java/expo/modules/video/player/VideoPlayerListener.kt

@@ -6,7 +6,9 @@ import androidx.media3.common.Tracks
 import androidx.media3.common.util.UnstableApi
 import expo.modules.video.enums.AudioMixingMode
 import expo.modules.video.enums.PlayerStatus
+import expo.modules.video.records.AudioTrack
 import expo.modules.video.records.PlaybackError
+import expo.modules.video.records.SubtitleTrack
 import expo.modules.video.records.VideoSource
 import expo.modules.video.records.TimeUpdate
 import expo.modules.video.records.VideoTrack
@@ -25,5 +27,6 @@ interface VideoPlayerListener {
   fun onPlayedToEnd(player: VideoPlayer) {}
   fun onAudioMixingModeChanged(player: VideoPlayer, audioMixingMode: AudioMixingMode, oldAudioMixingMode: AudioMixingMode?) {}
   fun onVideoTrackChanged(player: VideoPlayer, videoTrack: VideoTrack?, oldVideoTrack: VideoTrack?) {}
+  fun onVideoSourceLoaded(player: VideoPlayer, videoSource: VideoSource?, duration: Double?, availableVideoTracks: List<VideoTrack>, availableSubtitleTracks: List<SubtitleTrack>, availableAudioTracks: List<AudioTrack>) {}
   fun onRenderedFirstFrame(player: VideoPlayer) {}
 }

package/android/src/main/java/expo/modules/video/records/FullscreenOptions.kt

@@ -0,0 +1,12 @@
+package expo.modules.video.records
+
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+import expo.modules.video.enums.FullscreenOrientation
+import java.io.Serializable
+
+data class FullscreenOptions(
+  @Field val enable: Boolean = true,
+  @Field val orientation: FullscreenOrientation = FullscreenOrientation.DEFAULT,
+  @Field val autoExitOnRotate: Boolean = false
+) : Record, Serializable

package/android/src/main/java/expo/modules/video/utils/FullscreenActivityOrientationHelper.kt

@@ -0,0 +1,120 @@
+package expo.modules.video.utils
+
+import android.content.Context
+import android.content.res.Configuration
+import android.hardware.SensorManager
+import android.provider.Settings
+import android.view.OrientationEventListener
+import expo.modules.video.enums.FullscreenOrientation
+import expo.modules.video.records.FullscreenOptions
+
+/**
+ * Helper for the auto-exit fullscreen functionality. Once the user has rotated the phone to the desired orientation, the orientation lock should be released, so that once rotation to a perpendicular orientation is detected, the fullscreen can be exited.
+ */
+class FullscreenActivityOrientationHelper(val context: Context, val options: FullscreenOptions, val onShouldAutoExit: (() -> Unit), val onShouldReleaseOrientation: (() -> Unit)) {
+  private var userHasRotatedToVideoOrientation = false
+  private val isLockedToLandscape = options.orientation == FullscreenOrientation.LANDSCAPE ||
+    options.orientation == FullscreenOrientation.LANDSCAPE_LEFT ||
+    options.orientation == FullscreenOrientation.LANDSCAPE_RIGHT
+
+  private val isLockedToPortrait = options.orientation == FullscreenOrientation.PORTRAIT ||
+    options.orientation == FullscreenOrientation.PORTRAIT_UP ||
+    options.orientation == FullscreenOrientation.PORTRAIT_DOWN
+
+  /**
+   * Checks if the system's auto-rotation setting is currently enabled.
+   * Returns true if auto-rotation is unlocked (enabled), false otherwise (locked or error).
+   */
+  val isAutoRotationEnabled: Boolean
+    get() {
+      return try {
+        val rotationStatus = Settings.System.getInt(
+          context.contentResolver,
+          Settings.System.ACCELEROMETER_ROTATION,
+          0
+        )
+        rotationStatus == 1
+      } catch (e: Exception) {
+        false
+      }
+    }
+
+  /* Orientation listener running while the activity orientation is locked. The goal of the listener is to detect if the user has rotated the phone to the desired orientation.
+  Once they have done that auto-exit can be activated. That's when we can disable the lock and wait for the device to be rotated to portrait.
+  When the screen starts rotating we receive a configuration change and can send a signal to exit fullscreen.
+  It's better to unlock and wait for config change instead of trying to detect orientation based on angles, because the angles update faster than the phone rotation.
+   */
+  private val orientationEventListener by lazy {
+    object : OrientationEventListener(context, SensorManager.SENSOR_DELAY_NORMAL) {
+      override fun onOrientationChanged(orientation: Int) {
+        // Use narrower ranges to determine the orientation. Using a 90 degree range is too sensitive to small tilts.
+        val newPhysicalOrientation = when {
+          (orientation >= 0 && orientation <= 10) || (orientation >= 350 && orientation < 360) -> {
+            Configuration.ORIENTATION_PORTRAIT
+          }
+
+          (orientation >= 80 && orientation <= 100) -> {
+            Configuration.ORIENTATION_LANDSCAPE
+          }
+
+          (orientation >= 170 && orientation <= 190) -> {
+            Configuration.ORIENTATION_PORTRAIT
+          }
+
+          (orientation >= 260 && orientation <= 280) -> {
+            Configuration.ORIENTATION_LANDSCAPE
+          }
+
+          else -> {
+            Configuration.ORIENTATION_UNDEFINED
+          }
+        }
+
+        if (!options.autoExitOnRotate) {
+          return
+        }
+
+        val canReleaseFromLandscape = newPhysicalOrientation == Configuration.ORIENTATION_PORTRAIT && isLockedToLandscape && userHasRotatedToVideoOrientation
+        val canReleaseFromPortrait = newPhysicalOrientation == Configuration.ORIENTATION_LANDSCAPE && isLockedToPortrait && userHasRotatedToVideoOrientation
+
+        if (canReleaseFromPortrait || canReleaseFromLandscape) {
+          if (!isAutoRotationEnabled) {
+            return
+          }
+          onShouldReleaseOrientation()
+          this@FullscreenActivityOrientationHelper.stopOrientationEventListener()
+        }
+
+        val hasRotatedToVideoOrientationPortrait = newPhysicalOrientation == Configuration.ORIENTATION_PORTRAIT && isLockedToPortrait && !userHasRotatedToVideoOrientation
+        val hasRotatedToVideoOrientationLandscape = newPhysicalOrientation == Configuration.ORIENTATION_LANDSCAPE && isLockedToLandscape && !userHasRotatedToVideoOrientation
+
+        if (hasRotatedToVideoOrientationPortrait || hasRotatedToVideoOrientationLandscape) {
+          userHasRotatedToVideoOrientation = true
+        }
+      }
+    }
+  }
+
+  fun onConfigurationChanged(newConfig: Configuration) {
+    val orientation = newConfig.orientation
+    if (!options.autoExitOnRotate) {
+      return
+    }
+
+    if (isLockedToPortrait && orientation == Configuration.ORIENTATION_LANDSCAPE) {
+      onShouldAutoExit()
+    } else if (isLockedToLandscape && orientation == Configuration.ORIENTATION_PORTRAIT) {
+      onShouldAutoExit()
+    }
+  }
+
+  fun startOrientationEventListener() {
+    if (orientationEventListener.canDetectOrientation()) {
+      orientationEventListener.enable()
+    }
+  }
+
+  fun stopOrientationEventListener() {
+    orientationEventListener.disable()
+  }
+}

package/android/src/main/java/expo/modules/video/utils/PictureInPictureUtils.kt

@@ -5,11 +5,14 @@ import android.app.PictureInPictureParams
 import android.graphics.Rect
 import android.os.Build
 import android.util.Log
+import android.util.Rational
 import androidx.annotation.OptIn
+import androidx.media3.common.VideoSize
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.ui.PlayerView
 import expo.modules.video.PictureInPictureConfigurationException
 import expo.modules.video.VideoView.Companion.isPictureInPictureSupported
+import expo.modules.video.enums.ContentFit
 
 @OptIn(UnstableApi::class)
 internal fun calculateRectHint(playerView: PlayerView): Rect {
@@ -34,6 +37,25 @@ internal fun calculateRectHint(playerView: PlayerView): Rect {
   return hint
 }
 
+internal fun calculatePiPAspectRatio(videoSize: VideoSize, viewWidth: Int, viewHeight: Int, contentFit: ContentFit): Rational {
+  var aspectRatio = if (contentFit == ContentFit.CONTAIN) {
+    Rational(videoSize.width, videoSize.height)
+  } else {
+    Rational(viewWidth, viewHeight)
+  }
+  // AspectRatio for the activity in picture-in-picture, must be between 2.39:1 and 1:2.39 (inclusive).
+  // https://developer.android.com/reference/android/app/PictureInPictureParams.Builder#setAspectRatio(android.util.Rational)
+  val maximumRatio = Rational(239, 100)
+  val minimumRatio = Rational(100, 239)
+
+  if (aspectRatio.toFloat() > maximumRatio.toFloat()) {
+    aspectRatio = maximumRatio
+  } else if (aspectRatio.toFloat() < minimumRatio.toFloat()) {
+    aspectRatio = minimumRatio
+  }
+  return aspectRatio
+}
+
 internal fun applyRectHint(activity: Activity, rectHint: Rect) {
   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && isPictureInPictureSupported(activity)) {
     runWithPiPMisconfigurationSoftHandling {
@@ -54,10 +76,21 @@ internal fun runWithPiPMisconfigurationSoftHandling(shouldThrow: Boolean = false
   }
 }
 
-internal fun applyAutoEnterPiP(activity: Activity, autoEnterPiP: Boolean) {
-  if (Build.VERSION.SDK_INT >= 31 && isPictureInPictureSupported(activity)) {
+internal fun applyPiPParams(activity: Activity, autoEnterPiP: Boolean, aspectRatio: Rational? = null) {
+  // If the aspect ratio exceeds the limits, the app will crash
+  val safeAspectRatio = aspectRatio?.takeIf { it.toFloat() in 0.41841..2.39 }
+
+  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && isPictureInPictureSupported(activity)) {
+    val paramsBuilder = PictureInPictureParams.Builder()
+
+    safeAspectRatio?.let {
+      paramsBuilder.setAspectRatio(it)
+    }
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      paramsBuilder.setAutoEnterEnabled(autoEnterPiP)
+    }
     runWithPiPMisconfigurationSoftHandling {
-      activity.setPictureInPictureParams(PictureInPictureParams.Builder().setAutoEnterEnabled(autoEnterPiP).build())
+      activity.setPictureInPictureParams(paramsBuilder.build())
     }
   }
 }

package/android/src/main/res/layout/fullscreen_player_activity.xml

@@ -11,6 +11,7 @@
   <androidx.media3.ui.PlayerView
     android:id="@+id/player_view"
     android:layout_width="match_parent"
-    android:layout_height="match_parent" />
+    android:layout_height="match_parent"
+    android:background="@android:color/black"/>
 
 </FrameLayout>

package/build/NativeVideoAirPlayButtonView.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("react").ComponentType<any>;
+export default _default;
+//# sourceMappingURL=NativeVideoAirPlayButtonView.d.ts.map

package/build/NativeVideoAirPlayButtonView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeVideoAirPlayButtonView.d.ts","sourceRoot":"","sources":["../src/NativeVideoAirPlayButtonView.ts"],"names":[],"mappings":";AAEA,wBAAwE"}