@stepincto/expo-video 1.0.0

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

@@ -0,0 +1,367 @@
+package expo.modules.video
+
+import android.app.Activity
+import android.app.PictureInPictureParams
+import android.content.Context
+import android.content.Intent
+import android.graphics.Color
+import android.os.Build
+import android.util.Rational
+import android.view.LayoutInflater
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+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
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.uimanager.events.TouchEventCoalescingKeyHelper
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.viewevent.EventDispatcher
+import expo.modules.kotlin.views.ExpoView
+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.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.utils.applyRectHint
+import expo.modules.video.utils.calculatePiPAspectRatio
+import expo.modules.video.utils.calculateRectHint
+import expo.modules.video.utils.dispatchMotionEvent
+import java.util.UUID
+
+class SurfaceVideoView(context: Context, appContext: AppContext) : VideoView(context, appContext)
+class TextureVideoView(context: Context, appContext: AppContext) : VideoView(context, appContext, true)
+
+@androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)
+open class VideoView(context: Context, appContext: AppContext, useTextureView: Boolean = false) : ExpoView(context, appContext), VideoPlayerListener {
+  val videoViewId: String = UUID.randomUUID().toString()
+  val playerView: PlayerView = LayoutInflater.from(context.applicationContext).inflate(getPlayerViewLayoutId(useTextureView), null) as PlayerView
+  val onPictureInPictureStart by EventDispatcher<Unit>()
+  val onPictureInPictureStop by EventDispatcher<Unit>()
+  val onFullscreenEnter by EventDispatcher<Unit>()
+  val onFullscreenExit by EventDispatcher<Unit>()
+  val onFirstFrameRender by EventDispatcher<Unit>()
+
+  var willEnterPiP: Boolean = false
+
+  // In some situations we can't detect if the view will enter PiP, in that case the playback will be paused
+  // We can get an event after PiP has started, that's when we should resume playback
+  var wasAutoPaused: Boolean = false
+  var isInFullscreen: Boolean = false
+    private set
+  var showsSubtitlesButton = false
+    private set
+  var showsAudioTracksButton = false
+    private set
+
+  private val currentActivity = appContext.throwingActivity
+  private val decorView = currentActivity.window.decorView
+  private val rootView = decorView.findViewById<ViewGroup>(android.R.id.content)
+  private val touchEventCoalescingKeyHelper = TouchEventCoalescingKeyHelper()
+
+  private val rootViewChildrenOriginalVisibility: ArrayList<Int> = arrayListOf()
+  private var pictureInPictureHelperTag: String? = null
+  private var reactNativeEventDispatcher: EventDispatcher? = null
+
+  // We need to keep track of the target surface view visibility, but only apply it when `useExoShutter` is false.
+  var shouldHideSurfaceView: Boolean = true
+
+  var useExoShutter: Boolean? = null
+    set(value) {
+      if (value == true) {
+        playerView.setShutterBackgroundColor(Color.BLACK)
+      } else {
+        playerView.setShutterBackgroundColor(Color.TRANSPARENT)
+      }
+      applySurfaceViewVisibility()
+      field = value
+    }
+
+  var autoEnterPiP: Boolean by IgnoreSameSet(false) { new, _ ->
+    applyPiPParams(currentActivity, new, calculateCurrentPipAspectRatio())
+  }
+
+  var contentFit: ContentFit = ContentFit.CONTAIN
+    set(value) {
+      playerView.resizeMode = value.toResizeMode()
+      field = value
+    }
+
+  var videoPlayer: VideoPlayer? = null
+    set(newPlayer) {
+      field?.let {
+        VideoManager.onVideoPlayerDetachedFromView(it, this)
+      }
+      videoPlayer?.removeListener(this)
+      newPlayer?.addListener(this)
+      field = newPlayer
+      shouldHideSurfaceView = true
+      attachPlayer()
+      newPlayer?.let {
+        VideoManager.onVideoPlayerAttachedToView(it, this)
+      }
+    }
+
+  var useNativeControls: Boolean = true
+    set(value) {
+      playerView.useController = value
+      playerView.setShowSubtitleButton(value)
+      field = value
+    }
+
+  var allowsFullscreen: Boolean = true
+    set(value) {
+      if (value) {
+        playerView.setFullscreenButtonClickListener { enterFullscreen() }
+      } else {
+        playerView.setFullscreenButtonClickListener(null)
+        // Setting listener to null should hide the button, but judging by ExoPlayer source code
+        // there is a bug and the button isn't hidden. We need to do it manually.
+        playerView.setFullscreenButtonVisibility(false)
+      }
+      field = value
+    }
+
+  private val mLayoutRunnable = Runnable {
+    measure(
+      MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+      MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+    )
+    layout(left, top, right, bottom)
+  }
+
+  init {
+    VideoManager.registerVideoView(this)
+    playerView.setFullscreenButtonClickListener { enterFullscreen() }
+    // The prop `useNativeControls` prop is sometimes applied after the view is created, and sometimes there is a visible
+    // flash of controls event when they are set to off. Initially we set it to `false` and apply it in `onAttachedToWindow` to avoid this.
+    this.playerView.useController = false
+
+    // Start with the SurfaceView being transparent to avoid any flickers when the prop value is delivered.
+    this.playerView.setShutterBackgroundColor(Color.TRANSPARENT)
+    this.playerView.videoSurfaceView?.alpha = 0f
+    addView(
+      playerView,
+      ViewGroup.LayoutParams(
+        ViewGroup.LayoutParams.MATCH_PARENT,
+        ViewGroup.LayoutParams.MATCH_PARENT
+      )
+    )
+
+    reactNativeEventDispatcher = UIManagerHelper.getEventDispatcher(appContext.reactContext as ReactContext, id)
+  }
+
+  fun applySurfaceViewVisibility() {
+    if (useExoShutter != true && shouldHideSurfaceView) {
+      playerView.videoSurfaceView?.alpha = 0f
+    } else {
+      playerView.videoSurfaceView?.alpha = 1f
+    }
+  }
+
+  fun enterFullscreen() {
+    val intent = Intent(context, FullscreenPlayerActivity::class.java)
+    intent.putExtra(VideoManager.INTENT_PLAYER_KEY, videoViewId)
+    // Set before starting the activity to avoid entering PiP unintentionally
+    isInFullscreen = true
+    currentActivity.startActivity(intent)
+
+    // Disable the enter transition
+    if (Build.VERSION.SDK_INT >= 34) {
+      currentActivity.overrideActivityTransition(Activity.OVERRIDE_TRANSITION_OPEN, 0, 0)
+    } else {
+      @Suppress("DEPRECATION")
+      currentActivity.overridePendingTransition(0, 0)
+    }
+    onFullscreenEnter(Unit)
+    applyPiPParams(currentActivity, false, calculateCurrentPipAspectRatio())
+  }
+
+  fun attachPlayer() {
+    videoPlayer?.changePlayerView(playerView)
+  }
+
+  fun exitFullscreen() {
+    // Fullscreen uses a different PlayerView instance, because of that we need to manually update the non-fullscreen player icon after exiting
+    val fullScreenButton: ImageButton = playerView.findViewById(androidx.media3.ui.R.id.exo_fullscreen)
+    fullScreenButton.setImageResource(androidx.media3.ui.R.drawable.exo_icon_fullscreen_enter)
+    attachPlayer()
+    onFullscreenExit(Unit)
+    isInFullscreen = false
+    applyPiPParams(currentActivity, autoEnterPiP, calculateCurrentPipAspectRatio())
+  }
+
+  fun enterPictureInPicture() {
+    if (!isPictureInPictureSupported(currentActivity)) {
+      throw PictureInPictureUnsupportedException()
+    }
+
+    val player = playerView.player
+      ?: throw PictureInPictureEnterException("No player attached to the VideoView")
+    playerView.useController = false
+    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) {
+      @Suppress("DEPRECATION")
+      currentActivity.enterPictureInPictureMode()
+    }
+  }
+
+  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.
+   */
+  fun layoutForPiPEnter() {
+    playerView.useController = false
+    (playerView.parent as? ViewGroup)?.removeView(playerView)
+    for (i in 0 until rootView.childCount) {
+      if (rootView.getChildAt(i) != playerView) {
+        rootViewChildrenOriginalVisibility.add(rootView.getChildAt(i).visibility)
+        rootView.getChildAt(i).visibility = View.GONE
+      }
+    }
+    rootView.addView(playerView, FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+  }
+
+  fun layoutForPiPExit() {
+    playerView.useController = useNativeControls
+    rootView.removeView(playerView)
+    for (i in 0 until rootView.childCount) {
+      rootView.getChildAt(i).visibility = rootViewChildrenOriginalVisibility[i]
+    }
+    rootViewChildrenOriginalVisibility.clear()
+    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
+    playerView.setShowSubtitleButton(showsSubtitlesButton)
+    super.onTracksChanged(player, tracks)
+  }
+
+  override fun onRenderedFirstFrame(player: VideoPlayer) {
+    shouldHideSurfaceView = false
+    applySurfaceViewVisibility()
+    onFirstFrameRender(Unit)
+  }
+
+  override fun requestLayout() {
+    super.requestLayout()
+
+    // Code borrowed from:
+    // https://github.com/facebook/react-native/blob/d19afc73f5048f81656d0b4424232ce6d69a6368/ReactAndroid/src/main/java/com/facebook/react/views/toolbar/ReactToolbar.java#L166
+    // This fixes some layout issues with the exoplayer which caused the resizeMode to not work properly
+    post(mLayoutRunnable)
+  }
+
+  override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+    super.onLayout(changed, l, t, r, b)
+    // On every re-layout ExoPlayer resets the timeBar to be enabled.
+    // We need to disable it to keep scrubbing impossible.
+    playerView.setTimeBarInteractive(videoPlayer?.requiresLinearPlayback ?: true)
+    applyRectHint(currentActivity, calculateRectHint(playerView))
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    (currentActivity as? FragmentActivity)?.let {
+      val fragment = PictureInPictureHelperFragment(this)
+      pictureInPictureHelperTag = fragment.id
+      it.supportFragmentManager.beginTransaction()
+        .add(fragment, fragment.id)
+        .commitAllowingStateLoss()
+    }
+    applyPiPParams(currentActivity, autoEnterPiP)
+  }
+
+  override fun onDetachedFromWindow() {
+    super.onDetachedFromWindow()
+    (currentActivity as? FragmentActivity)?.let {
+      val fragment = it.supportFragmentManager.findFragmentByTag(pictureInPictureHelperTag ?: "")
+        ?: return
+      it.supportFragmentManager.beginTransaction()
+        .remove(fragment)
+        .commitAllowingStateLoss()
+    }
+    applyPiPParams(currentActivity, false)
+  }
+
+  // After adding the `PlayerView` to the hierarchy the touch events stop being emitted to the JS side.
+  // The only workaround I have found is to dispatch the touch events manually using the `EventDispatcher`.
+  // The behavior is different when the native controls are enabled and disabled.
+  override fun onTouchEvent(event: MotionEvent?): Boolean {
+    if (!useNativeControls) {
+      event?.eventTime?.let {
+        touchEventCoalescingKeyHelper.addCoalescingKey(it)
+        reactNativeEventDispatcher?.dispatchMotionEvent(this@VideoView, event, touchEventCoalescingKeyHelper)
+      }
+    }
+    if (event?.actionMasked == MotionEvent.ACTION_UP) {
+      performClick()
+    }
+    // Mark the event as handled
+    return true
+  }
+
+  override fun onInterceptTouchEvent(event: MotionEvent?): Boolean {
+    if (useNativeControls) {
+      event?.eventTime?.let {
+        touchEventCoalescingKeyHelper.addCoalescingKey(it)
+        reactNativeEventDispatcher?.dispatchMotionEvent(this@VideoView, MotionEvent.obtainNoHistory(event), touchEventCoalescingKeyHelper)
+      }
+    }
+    // Return false to receive all other events before the target `onTouchEvent`
+    return false
+  }
+
+  private fun getPlayerViewLayoutId(useTextureView: Boolean): Int {
+    return if (useTextureView) {
+      R.layout.texture_player_view
+    } else {
+      R.layout.surface_player_view
+    }
+  }
+
+  companion object {
+    fun isPictureInPictureSupported(currentActivity: Activity): Boolean {
+      return Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && currentActivity.packageManager.hasSystemFeature(
+        android.content.pm.PackageManager.FEATURE_PICTURE_IN_PICTURE
+      )
+    }
+  }
+}

package/android/src/main/java/expo/modules/video/delegates/IgnoreSameSet.kt

@@ -0,0 +1,24 @@
+package expo.modules.video.delegates
+
+import kotlin.reflect.KProperty
+
+/**
+ * Property delegate, where the set is ignored unless the value has changed.
+ * @param T The type of the property.
+ * @param value The initial value of the property.
+ * @param propertyMapper A function that maps the new value to the property value.
+ * @param didSet A function that is called when the property value has changed.
+*/
+
+class IgnoreSameSet<T : Any?>(private var value: T, val propertyMapper: ((T) -> T) = { v -> v }, val didSet: ((new: T, old: T) -> Unit)? = null) {
+  operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
+    return value
+  }
+
+  operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
+    if (this.value == propertyMapper(value)) return
+    val oldValue = this.value
+    this.value = propertyMapper(value)
+    didSet?.invoke(this.value, oldValue)
+  }
+}

package/android/src/main/java/expo/modules/video/drawing/OutlineProvider.kt

@@ -0,0 +1,217 @@
+package expo.modules.video.drawing
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Outline
+import android.graphics.Path
+import android.graphics.RectF
+import android.os.Build
+import android.view.View
+import android.view.ViewOutlineProvider
+import com.facebook.react.modules.i18nmanager.I18nUtil
+import com.facebook.react.uimanager.FloatUtil
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.yoga.YogaConstants
+import expo.modules.video.utils.ifYogaUndefinedUse
+
+class OutlineProvider(private val mContext: Context) : ViewOutlineProvider() {
+  enum class BorderRadiusConfig {
+    ALL,
+    TOP_LEFT,
+    TOP_RIGHT,
+    BOTTOM_RIGHT,
+    BOTTOM_LEFT,
+    TOP_START,
+    TOP_END,
+    BOTTOM_START,
+    BOTTOM_END
+  }
+
+  enum class CornerRadius {
+    TOP_LEFT,
+    TOP_RIGHT,
+    BOTTOM_RIGHT,
+    BOTTOM_LEFT
+  }
+
+  private var mLayoutDirection = View.LAYOUT_DIRECTION_LTR
+  private val mBounds = RectF()
+  val borderRadiiConfig = FloatArray(9) { YogaConstants.UNDEFINED }
+  private val mCornerRadii = FloatArray(4)
+  private var mCornerRadiiInvalidated = true
+  private val mConvexPath = Path()
+  private var mConvexPathInvalidated = true
+
+  init {
+    updateCornerRadiiIfNeeded()
+  }
+
+  private fun updateCornerRadiiIfNeeded() {
+    if (!mCornerRadiiInvalidated) {
+      return
+    }
+
+    val isRTL = mLayoutDirection == View.LAYOUT_DIRECTION_RTL
+    val isRTLSwap = I18nUtil.instance.doLeftAndRightSwapInRTL(mContext)
+    updateCornerRadius(
+      CornerRadius.TOP_LEFT,
+      BorderRadiusConfig.TOP_LEFT,
+      BorderRadiusConfig.TOP_RIGHT,
+      BorderRadiusConfig.TOP_START,
+      BorderRadiusConfig.TOP_END,
+      isRTL,
+      isRTLSwap
+    )
+    updateCornerRadius(
+      CornerRadius.TOP_RIGHT,
+      BorderRadiusConfig.TOP_RIGHT,
+      BorderRadiusConfig.TOP_LEFT,
+      BorderRadiusConfig.TOP_END,
+      BorderRadiusConfig.TOP_START,
+      isRTL,
+      isRTLSwap
+    )
+    updateCornerRadius(
+      CornerRadius.BOTTOM_LEFT,
+      BorderRadiusConfig.BOTTOM_LEFT,
+      BorderRadiusConfig.BOTTOM_RIGHT,
+      BorderRadiusConfig.BOTTOM_START,
+      BorderRadiusConfig.BOTTOM_END,
+      isRTL,
+      isRTLSwap
+    )
+    updateCornerRadius(
+      CornerRadius.BOTTOM_RIGHT,
+      BorderRadiusConfig.BOTTOM_RIGHT,
+      BorderRadiusConfig.BOTTOM_LEFT,
+      BorderRadiusConfig.BOTTOM_END,
+      BorderRadiusConfig.BOTTOM_START,
+      isRTL,
+      isRTLSwap
+    )
+    mCornerRadiiInvalidated = false
+    mConvexPathInvalidated = true
+  }
+
+  private fun updateCornerRadius(
+    outputPosition: CornerRadius,
+    inputPosition: BorderRadiusConfig,
+    oppositePosition: BorderRadiusConfig,
+    startPosition: BorderRadiusConfig,
+    endPosition: BorderRadiusConfig,
+    isRTL: Boolean,
+    isRTLSwap: Boolean
+  ) {
+    var radius = borderRadiiConfig[inputPosition.ordinal]
+    if (isRTL) {
+      if (isRTLSwap) {
+        radius = borderRadiiConfig[oppositePosition.ordinal]
+      }
+      if (YogaConstants.isUndefined(radius)) {
+        radius = borderRadiiConfig[endPosition.ordinal]
+      }
+    } else {
+      if (YogaConstants.isUndefined(radius)) {
+        radius = borderRadiiConfig[startPosition.ordinal]
+      }
+    }
+    radius = radius
+      .ifYogaUndefinedUse(borderRadiiConfig[BorderRadiusConfig.ALL.ordinal])
+      .ifYogaUndefinedUse(0f)
+    mCornerRadii[outputPosition.ordinal] = PixelUtil.toPixelFromDIP(radius)
+  }
+
+  private fun updateConvexPathIfNeeded() {
+    if (!mConvexPathInvalidated) {
+      return
+    }
+    mConvexPath.reset()
+    mConvexPath.addRoundRect(
+      mBounds,
+      floatArrayOf(
+        mCornerRadii[CornerRadius.TOP_LEFT.ordinal],
+        mCornerRadii[CornerRadius.TOP_LEFT.ordinal],
+        mCornerRadii[CornerRadius.TOP_RIGHT.ordinal],
+        mCornerRadii[CornerRadius.TOP_RIGHT.ordinal],
+        mCornerRadii[CornerRadius.BOTTOM_RIGHT.ordinal],
+        mCornerRadii[CornerRadius.BOTTOM_RIGHT.ordinal],
+        mCornerRadii[CornerRadius.BOTTOM_LEFT.ordinal],
+        mCornerRadii[CornerRadius.BOTTOM_LEFT.ordinal]
+      ),
+      Path.Direction.CW
+    )
+    mConvexPathInvalidated = false
+  }
+
+  fun hasEqualCorners(): Boolean {
+    updateCornerRadiiIfNeeded()
+    val initialCornerRadius = mCornerRadii[0]
+    return mCornerRadii.all { initialCornerRadius == it }
+  }
+
+  fun setBorderRadius(radius: Float, position: Int): Boolean {
+    if (!FloatUtil.floatsEqual(borderRadiiConfig[position], radius)) {
+      borderRadiiConfig[position] = radius
+      mCornerRadiiInvalidated = true
+      return true
+    }
+    return false
+  }
+
+  private fun updateBoundsAndLayoutDirection(view: View) {
+    // Update layout direction
+    val layoutDirection = view.layoutDirection
+    if (mLayoutDirection != layoutDirection) {
+      mLayoutDirection = layoutDirection
+      mCornerRadiiInvalidated = true
+    }
+
+    // Update size
+    val left = 0
+    val top = 0
+    val right = view.width
+    val bottom = view.height
+    if (mBounds.left != left.toFloat() ||
+      mBounds.top != top.toFloat() ||
+      mBounds.right != right.toFloat() ||
+      mBounds.bottom != bottom.toFloat()
+    ) {
+      mBounds[left.toFloat(), top.toFloat(), right.toFloat()] = bottom.toFloat()
+      mCornerRadiiInvalidated = true
+    }
+  }
+
+  override fun getOutline(view: View, outline: Outline) {
+    updateBoundsAndLayoutDirection(view)
+
+    // Calculate outline
+    updateCornerRadiiIfNeeded()
+    if (hasEqualCorners()) {
+      val cornerRadius = mCornerRadii[0]
+      if (cornerRadius > 0) {
+        outline.setRoundRect(0, 0, mBounds.width().toInt(), mBounds.height().toInt(), cornerRadius)
+      } else {
+        outline.setRect(0, 0, mBounds.width().toInt(), mBounds.height().toInt())
+      }
+    } else {
+      // Clipping is not supported when using a convex path, but drawing the elevation
+      // shadow is. For the particular case, we fallback to canvas clipping in the view
+      // which is supposed to call `clipCanvasIfNeeded` in its `draw` method.
+      updateConvexPathIfNeeded()
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        outline.setPath(mConvexPath)
+      } else {
+        outline.setConvexPath(mConvexPath)
+      }
+    }
+  }
+
+  fun clipCanvasIfNeeded(canvas: Canvas, view: View) {
+    updateBoundsAndLayoutDirection(view)
+    updateCornerRadiiIfNeeded()
+    if (!hasEqualCorners()) {
+      updateConvexPathIfNeeded()
+      canvas.clipPath(mConvexPath)
+    }
+  }
+}

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

@@ -0,0 +1,20 @@
+package expo.modules.video.enums
+
+import expo.modules.kotlin.types.Enumerable
+
+enum class AudioMixingMode(val value: String) : Enumerable {
+  MIX_WITH_OTHERS("mixWithOthers"),
+  DUCK_OTHERS("duckOthers"),
+  AUTO("auto"),
+  DO_NOT_MIX("doNotMix");
+
+  val priority: Int
+    get() {
+      return when (this) {
+        DO_NOT_MIX -> 3
+        AUTO -> 2
+        DUCK_OTHERS -> 1
+        MIX_WITH_OTHERS -> 0
+      }
+    }
+}

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

@@ -0,0 +1,19 @@
+package expo.modules.video.enums
+
+import androidx.media3.ui.AspectRatioFrameLayout
+import expo.modules.kotlin.types.Enumerable
+
+@androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)
+enum class ContentFit(val value: String) : Enumerable {
+  CONTAIN("contain"),
+  FILL("fill"),
+  COVER("cover");
+
+  fun toResizeMode(): Int {
+    return when (this) {
+      CONTAIN -> AspectRatioFrameLayout.RESIZE_MODE_FIT
+      FILL -> AspectRatioFrameLayout.RESIZE_MODE_FILL
+      COVER -> AspectRatioFrameLayout.RESIZE_MODE_ZOOM
+    }
+  }
+}

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

@@ -0,0 +1,22 @@
+package expo.modules.video.enums
+
+import androidx.media3.common.MimeTypes
+import expo.modules.kotlin.types.Enumerable
+
+enum class ContentType(val value: String) : Enumerable {
+  AUTO("auto"),
+  PROGRESSIVE("progressive"),
+  HLS("hls"),
+  DASH("dash"),
+  SMOOTH_STREAMING("smoothStreaming");
+
+  fun toMimeTypeString(): String? {
+    return when (this) {
+      AUTO -> null
+      PROGRESSIVE -> null
+      HLS -> MimeTypes.APPLICATION_M3U8
+      DASH -> MimeTypes.APPLICATION_MPD
+      SMOOTH_STREAMING -> MimeTypes.APPLICATION_SS
+    }
+  }
+}

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

@@ -0,0 +1,26 @@
+package expo.modules.video.enums
+
+import androidx.media3.common.C
+import expo.modules.kotlin.types.Enumerable
+import expo.modules.video.UnsupportedDRMTypeException
+import java.util.UUID
+
+enum class DRMType(val value: String) : Enumerable {
+  CLEARKEY("clearkey"),
+  FAIRPLAY("fairplay"),
+  PLAYREADY("playready"),
+  WIDEVINE("widevine");
+
+  fun isSupported(): Boolean {
+    return this != FAIRPLAY
+  }
+
+  fun toUUID(): UUID {
+    return when (this) {
+      CLEARKEY -> C.CLEARKEY_UUID
+      FAIRPLAY -> throw UnsupportedDRMTypeException(this)
+      PLAYREADY -> C.PLAYREADY_UUID
+      WIDEVINE -> C.WIDEVINE_UUID
+    }
+  }
+}