@stepincto/expo-video 1.0.0

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

@@ -0,0 +1,104 @@
+package expo.modules.video
+
+import android.content.Context
+import android.os.Looper
+import android.util.Log
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.database.DatabaseProvider
+import androidx.media3.database.StandaloneDatabaseProvider
+import androidx.media3.datasource.cache.LeastRecentlyUsedCacheEvictor
+import androidx.media3.datasource.cache.SimpleCache
+import expo.modules.kotlin.exception.Exceptions
+import java.io.File
+import java.lang.ref.WeakReference
+import java.util.UUID
+
+private const val SHARED_PREFERENCES_NAME = "ExpoVideoCache"
+private const val CACHE_SIZE_KEY = "cacheSize"
+private const val VIDEO_CACHE_PARENT_DIR = "ExpoVideoCache"
+private const val VIDEO_CACHE_DIR_KEY = "cacheDir"
+private const val DEFAULT_CACHE_SIZE = 1024 * 1024 * 1024L // 1GB
+
+@UnstableApi
+class VideoCache(context: Context) {
+  // We don't want a strong reference to the context, as this class is used inside of a singleton (VideoManager)
+  private val weakContext = WeakReference(context)
+  private val context: Context
+    get() {
+      return weakContext.get() ?: throw Exceptions.ReactContextLost()
+    }
+  private val databaseProvider: DatabaseProvider = StandaloneDatabaseProvider(context)
+  private val sharedPreferences = context.getSharedPreferences(SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE)
+  private var cacheEvictor = LeastRecentlyUsedCacheEvictor(getMaxCacheSize())
+  var instance = SimpleCache(getCacheDir(), cacheEvictor, databaseProvider)
+
+  // Function that gets the cache size from shared preferences
+  private fun getMaxCacheSize(): Long {
+    return sharedPreferences.getLong(CACHE_SIZE_KEY, DEFAULT_CACHE_SIZE)
+  }
+
+  fun setMaxCacheSize(size: Long) {
+    assertModificationReleaseConditions()
+    instance.release()
+    sharedPreferences.edit().putLong(CACHE_SIZE_KEY, size).apply()
+    cacheEvictor = LeastRecentlyUsedCacheEvictor(size)
+    instance = SimpleCache(getCacheDir(), cacheEvictor, databaseProvider)
+  }
+
+  fun getCurrentCacheSize(): Long {
+    return getFileSize(getCacheDir())
+  }
+
+  // We have to keep the current directory name in the shared preferences, when the cache is released, a new name will be assigned to avoid conflicts.
+  private fun getCacheDir(): File {
+    // Weird structure, because kotlin marks the result of `getString` as nullable
+    val videoCacheDirName = sharedPreferences.getString(VIDEO_CACHE_DIR_KEY, null) ?: run {
+      val newCacheDirName = generateCacheDirName()
+      sharedPreferences.edit().putString(VIDEO_CACHE_DIR_KEY, newCacheDirName).apply()
+      newCacheDirName
+    }
+    val cacheParentDir = File(context.cacheDir, VIDEO_CACHE_PARENT_DIR)
+    val cacheDir = File(cacheParentDir, videoCacheDirName)
+
+    if (!cacheDir.exists()) {
+      cacheDir.mkdirs()
+    }
+    return cacheDir
+  }
+
+  private fun generateCacheDirName(): String {
+    return UUID.randomUUID().toString()
+  }
+
+  fun clear() {
+    assertModificationReleaseConditions()
+
+    // Creates a new cache directory to avoid conflicts while removing the old cache
+    val oldCacheDirectory = getCacheDir()
+    val oldCache = instance
+    val newCacheName = generateCacheDirName()
+
+    sharedPreferences.edit().putString(VIDEO_CACHE_DIR_KEY, newCacheName).apply()
+    instance = SimpleCache(getCacheDir(), cacheEvictor, databaseProvider)
+    oldCache.release()
+    oldCacheDirectory.deleteRecursively()
+  }
+
+  private fun getFileSize(file: File): Long {
+    return file
+      .walkTopDown()
+      .filter { it.isFile }
+      .map { it.length() }
+      .sum()
+  }
+
+  private fun assertModificationReleaseConditions() {
+    if (VideoManager.hasRegisteredPlayers()) {
+      throw VideoCacheException("Cannot clear cache while there are active players")
+    }
+
+    if (Looper.myLooper() == Looper.getMainLooper()) {
+      Log.w("ExpoVideo", "Clearing cache on the main thread, this might cause performance issues")
+    }
+  }
+}

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

@@ -0,0 +1,34 @@
+package expo.modules.video
+
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.video.enums.DRMType
+
+internal class FullScreenVideoViewNotFoundException :
+  CodedException("VideoView id wasn't passed to the activity")
+
+internal class VideoViewNotFoundException(id: String) :
+  CodedException("VideoView with id: $id not found")
+
+internal class MethodUnsupportedException(methodName: String) :
+  CodedException("Method `$methodName` is not supported on Android")
+
+internal class PictureInPictureEnterException(message: String?) :
+  CodedException("Failed to enter Picture in Picture mode${message?.let { ". $message" } ?: ""}")
+
+internal class PictureInPictureConfigurationException :
+  CodedException("Current activity does not support picture-in-picture. Make sure you have configured the `expo-video` config plugin correctly.")
+
+internal class PictureInPictureUnsupportedException :
+  CodedException("Picture in Picture mode is not supported on this device")
+
+internal class UnsupportedDRMTypeException(type: DRMType) :
+  CodedException("DRM type `$type` is not supported on Android")
+
+internal class PlaybackException(reason: String?, cause: Throwable? = null) :
+  CodedException("A playback exception has occurred: ${reason ?: "reason unknown"}", cause)
+
+internal class FailedToGetAudioFocusManagerException :
+  CodedException("Failed to get AudioFocusManager service")
+
+internal class VideoCacheException(message: String?, cause: Throwable? = null) :
+  CodedException(message ?: "Unexpected expo-video cache error", cause)

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

@@ -0,0 +1,133 @@
+package expo.modules.video
+
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.video.player.VideoPlayer
+import java.lang.ref.WeakReference
+
+// Helper class used to keep track of all existing VideoViews and VideoPlayers
+@OptIn(UnstableApi::class)
+object VideoManager {
+  const val INTENT_PLAYER_KEY = "player_uuid"
+
+  // Used for sharing videoViews between VideoView and FullscreenPlayerActivity
+  private var videoViews = mutableMapOf<String, VideoView>()
+  private var fullscreenPlayerActivities = mutableMapOf<String, WeakReference<FullscreenPlayerActivity>>()
+
+  // Keeps track of all existing VideoPlayers, and whether they are attached to a VideoView
+  private var videoPlayersToVideoViews = mutableMapOf<VideoPlayer, MutableList<VideoView>>()
+
+  private lateinit var audioFocusManager: AudioFocusManager
+  lateinit var cache: VideoCache
+
+  fun onModuleCreated(appContext: AppContext) {
+    val context = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+
+    if (!this::audioFocusManager.isInitialized) {
+      audioFocusManager = AudioFocusManager(appContext)
+    }
+    if (!this::cache.isInitialized) {
+      cache = VideoCache(context)
+    }
+  }
+
+  fun registerVideoView(videoView: VideoView) {
+    videoViews[videoView.videoViewId] = videoView
+  }
+
+  fun getVideoView(id: String): VideoView {
+    return videoViews[id] ?: throw VideoViewNotFoundException(id)
+  }
+
+  fun unregisterVideoView(videoView: VideoView) {
+    videoViews.remove(videoView.videoViewId)
+  }
+
+  fun registerVideoPlayer(videoPlayer: VideoPlayer) {
+    videoPlayersToVideoViews[videoPlayer] = videoPlayersToVideoViews[videoPlayer] ?: mutableListOf()
+    audioFocusManager.registerPlayer(videoPlayer)
+  }
+
+  fun unregisterVideoPlayer(videoPlayer: VideoPlayer) {
+    videoPlayersToVideoViews.remove(videoPlayer)
+    audioFocusManager.unregisterPlayer(videoPlayer)
+  }
+
+  fun registerFullscreenPlayerActivity(id: String, fullscreenActivity: FullscreenPlayerActivity) {
+    fullscreenPlayerActivities[id] = WeakReference(fullscreenActivity)
+  }
+
+  fun unregisterFullscreenPlayerActivity(id: String) {
+    fullscreenPlayerActivities.remove(id)
+  }
+
+  fun onVideoPlayerAttachedToView(videoPlayer: VideoPlayer, videoView: VideoView) {
+    if (videoPlayersToVideoViews[videoPlayer]?.contains(videoView) == true) {
+      return
+    }
+    videoPlayersToVideoViews[videoPlayer]?.add(videoView) ?: run {
+      videoPlayersToVideoViews[videoPlayer] = arrayListOf(videoView)
+    }
+
+    if (videoPlayersToVideoViews[videoPlayer]?.size == 1) {
+      videoPlayer.serviceConnection.playbackServiceBinder?.service?.registerPlayer(videoPlayer)
+    }
+  }
+
+  fun onVideoPlayerDetachedFromView(videoPlayer: VideoPlayer, videoView: VideoView) {
+    videoPlayersToVideoViews[videoPlayer]?.remove(videoView)
+
+    // Unregister disconnected VideoPlayers from the playback service
+    if (videoPlayersToVideoViews[videoPlayer] == null || videoPlayersToVideoViews[videoPlayer]?.size == 0) {
+      videoPlayer.serviceConnection.playbackServiceBinder?.service?.unregisterPlayer(videoPlayer.player)
+    }
+  }
+
+  fun isVideoPlayerAttachedToView(videoPlayer: VideoPlayer): Boolean {
+    return videoPlayersToVideoViews[videoPlayer]?.isNotEmpty() ?: false
+  }
+
+  fun hasRegisteredPlayers(): Boolean {
+    return videoPlayersToVideoViews.isNotEmpty()
+  }
+
+  fun onAppForegrounded() {
+    for (videoView in videoViews.values) {
+      videoView.playerView.useController = videoView.useNativeControls
+    }
+
+    // Pressing the app icon will bring up the mainActivity instead of the fullscreen activity (at least for BareExpo)
+    // In this case we have to manually finish the fullscreen activity
+    for (fullscreenActivity in fullscreenPlayerActivities.values) {
+      fullscreenActivity.get()?.finish()
+    }
+  }
+
+  fun onAppBackgrounded() {
+    for (videoView in videoViews.values) {
+      if (shouldPauseVideo(videoView)) {
+        handleVideoPause(videoView)
+      } else {
+        videoView.wasAutoPaused = false
+      }
+    }
+  }
+
+  private fun shouldPauseVideo(videoView: VideoView): Boolean {
+    return videoView.videoPlayer?.staysActiveInBackground == false &&
+      !videoView.willEnterPiP &&
+      !videoView.isInFullscreen
+  }
+
+  private fun handleVideoPause(videoView: VideoView) {
+    videoView.playerView.useController = false
+    videoView.videoPlayer?.player?.let { player ->
+      if (player.isPlaying) {
+        player.pause()
+        videoView.wasAutoPaused = true
+      }
+    }
+  }
+}

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

@@ -0,0 +1,414 @@
+@file:OptIn(EitherType::class)
+
+package expo.modules.video
+
+import android.net.Uri
+import androidx.media3.common.PlaybackParameters
+import androidx.media3.common.Player.REPEAT_MODE_OFF
+import androidx.media3.common.Player.REPEAT_MODE_ONE
+import androidx.media3.common.util.UnstableApi
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.apifeatures.EitherType
+import expo.modules.kotlin.functions.Coroutine
+import expo.modules.kotlin.functions.Queues
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.types.Either
+import expo.modules.kotlin.views.ViewDefinitionBuilder
+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.SubtitleTrack
+import expo.modules.video.records.AudioTrack
+import expo.modules.video.records.VideoSource
+import expo.modules.video.records.VideoThumbnailOptions
+import expo.modules.video.utils.runWithPiPMisconfigurationSoftHandling
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlin.time.Duration
+
+// https://developer.android.com/guide/topics/media/media3/getting-started/migration-guide#improvements_in_media3
+@UnstableReactNativeAPI
+@androidx.annotation.OptIn(UnstableApi::class)
+class VideoModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("ExpoVideo")
+
+    OnCreate {
+      VideoManager.onModuleCreated(appContext)
+    }
+
+    Function("isPictureInPictureSupported") {
+      VideoView.isPictureInPictureSupported(appContext.throwingActivity)
+    }
+
+    Function("getCurrentVideoCacheSize") {
+      VideoManager.cache.getCurrentCacheSize()
+    }
+
+    AsyncFunction("setVideoCacheSizeAsync") { size: Long ->
+      VideoManager.cache.setMaxCacheSize(size)
+    }
+
+    AsyncFunction("clearVideoCacheAsync") {
+      VideoManager.cache.clear()
+    }
+
+    View(SurfaceVideoView::class) {
+      VideoViewComponent<SurfaceVideoView>()
+    }
+    View(TextureVideoView::class) {
+      VideoViewComponent<TextureVideoView>()
+    }
+
+    Class(VideoPlayer::class) {
+      Constructor { source: VideoSource? ->
+        val player = VideoPlayer(appContext.throwingActivity.applicationContext, appContext, source)
+        appContext.mainQueue.launch {
+          player.prepare()
+        }
+        return@Constructor player
+      }
+
+      Property("playing")
+        .get { ref: VideoPlayer ->
+          ref.playing
+        }
+
+      Property("muted")
+        .get { ref: VideoPlayer ->
+          ref.muted
+        }
+        .set { ref: VideoPlayer, muted: Boolean ->
+          appContext.mainQueue.launch {
+            ref.muted = muted
+          }
+        }
+
+      Property("volume")
+        .get { ref: VideoPlayer ->
+          ref.volume
+        }
+        .set { ref: VideoPlayer, volume: Float ->
+          appContext.mainQueue.launch {
+            ref.userVolume = volume
+            ref.volume = volume
+          }
+        }
+
+      Property("currentTime")
+        .get { ref: VideoPlayer ->
+          // TODO: we shouldn't block the thread, but there are no events for the player position change,
+          //  so we can't update the currentTime in a non-blocking way like the other properties.
+          //  Until we think of something better we can temporarily do it this way
+          runBlocking(appContext.mainQueue.coroutineContext) {
+            ref.player.currentPosition / 1000f
+          }
+        }
+        .set { ref: VideoPlayer, currentTime: Double ->
+          appContext.mainQueue.launch {
+            ref.player.seekTo((currentTime * 1000).toLong())
+          }
+        }
+
+      Property("currentLiveTimestamp")
+        .get { ref: VideoPlayer ->
+          runBlocking(appContext.mainQueue.coroutineContext) {
+            ref.currentLiveTimestamp
+          }
+        }
+
+      Property("availableVideoTracks")
+        .get { ref: VideoPlayer ->
+          ref.availableVideoTracks
+        }
+
+      Property("videoTrack")
+        .get { ref: VideoPlayer ->
+          ref.currentVideoTrack
+        }
+
+      Property("availableSubtitleTracks")
+        .get { ref: VideoPlayer ->
+          ref.subtitles.availableSubtitleTracks
+        }
+
+      Property("subtitleTrack")
+        .get { ref: VideoPlayer ->
+          ref.subtitles.currentSubtitleTrack
+        }
+        .set { ref: VideoPlayer, subtitleTrack: SubtitleTrack? ->
+          appContext.mainQueue.launch {
+            ref.subtitles.currentSubtitleTrack = subtitleTrack
+          }
+        }
+
+      Property("availableAudioTracks")
+        .get { ref: VideoPlayer ->
+          ref.audioTracks.availableAudioTracks
+        }
+
+      Property("audioTrack")
+        .get { ref: VideoPlayer ->
+          ref.audioTracks.currentAudioTrack
+        }
+        .set { ref: VideoPlayer, audioTrack: AudioTrack? ->
+          appContext.mainQueue.launch {
+            ref.audioTracks.currentAudioTrack = audioTrack
+          }
+        }
+
+      Property("currentOffsetFromLive")
+        .get { ref: VideoPlayer ->
+          runBlocking(appContext.mainQueue.coroutineContext) {
+            ref.currentOffsetFromLive
+          }
+        }
+
+      Property("duration")
+        .get { ref: VideoPlayer ->
+          ref.duration
+        }
+
+      Property("playbackRate")
+        .get { ref: VideoPlayer ->
+          ref.playbackParameters.speed
+        }
+        .set { ref: VideoPlayer, playbackRate: Float ->
+          appContext.mainQueue.launch {
+            val pitch = if (ref.preservesPitch) 1f else playbackRate
+            ref.playbackParameters = PlaybackParameters(playbackRate, pitch)
+          }
+        }
+
+      Property("isLive")
+        .get { ref: VideoPlayer ->
+          ref.isLive
+        }
+
+      Property("preservesPitch")
+        .get { ref: VideoPlayer ->
+          ref.preservesPitch
+        }
+        .set { ref: VideoPlayer, preservesPitch: Boolean ->
+          appContext.mainQueue.launch {
+            ref.preservesPitch = preservesPitch
+          }
+        }
+
+      Property("showNowPlayingNotification")
+        .get { ref: VideoPlayer ->
+          ref.showNowPlayingNotification
+        }
+        .set { ref: VideoPlayer, showNotification: Boolean ->
+          appContext.mainQueue.launch {
+            ref.showNowPlayingNotification = showNotification
+          }
+        }
+
+      Property("status")
+        .get { ref: VideoPlayer ->
+          ref.status
+        }
+
+      Property("staysActiveInBackground")
+        .get { ref: VideoPlayer ->
+          ref.staysActiveInBackground
+        }
+        .set { ref: VideoPlayer, staysActive: Boolean ->
+          ref.staysActiveInBackground = staysActive
+        }
+
+      Property("loop")
+        .get { ref: VideoPlayer ->
+          ref.player.repeatMode == REPEAT_MODE_ONE
+        }
+        .set { ref: VideoPlayer, loop: Boolean ->
+          appContext.mainQueue.launch {
+            ref.player.repeatMode = if (loop) {
+              REPEAT_MODE_ONE
+            } else {
+              REPEAT_MODE_OFF
+            }
+          }
+        }
+
+      Property("bufferedPosition")
+        .get { ref: VideoPlayer ->
+          // Same as currentTime
+          runBlocking(appContext.mainQueue.coroutineContext) {
+            ref.bufferedPosition
+          }
+        }
+
+      Property("bufferOptions")
+        .get { ref: VideoPlayer ->
+          ref.bufferOptions
+        }
+        .set { ref: VideoPlayer, bufferOptions: BufferOptions ->
+          ref.bufferOptions = bufferOptions
+        }
+
+      Function("play") { ref: VideoPlayer ->
+        appContext.mainQueue.launch {
+          ref.player.play()
+        }
+      }
+
+      Function("pause") { ref: VideoPlayer ->
+        appContext.mainQueue.launch {
+          ref.player.pause()
+        }
+      }
+
+      Property("timeUpdateEventInterval")
+        .get { ref: VideoPlayer ->
+          ref.intervalUpdateClock.interval / 1000.0
+        }
+        .set { ref: VideoPlayer, intervalSeconds: Float ->
+          ref.intervalUpdateClock.interval = (intervalSeconds * 1000).toLong()
+        }
+
+      Property("audioMixingMode")
+        .get { ref: VideoPlayer ->
+          ref.audioMixingMode
+        }
+        .set { ref: VideoPlayer, audioMixingMode: AudioMixingMode ->
+          appContext.mainQueue.launch {
+            ref.audioMixingMode = audioMixingMode
+          }
+        }
+
+      Function("replace") { ref: VideoPlayer, source: Either<Uri, VideoSource>? ->
+        replaceImpl(ref, source)
+      }
+
+      // ExoPlayer automatically offloads loading of the asset onto a different thread so we can keep the same
+      // implementation until `replace` is deprecated and removed.
+      // TODO: @behenate see if we can further reduce load on the main thread
+      AsyncFunction("replaceAsync") { ref: VideoPlayer, source: Either<Uri, VideoSource>?, promise: Promise ->
+        replaceImpl(ref, source, promise)
+      }
+
+      Function("seekBy") { ref: VideoPlayer, seekTime: Double ->
+        appContext.mainQueue.launch {
+          val seekPos = ref.player.currentPosition + (seekTime * 1000).toLong()
+          ref.player.seekTo(seekPos)
+        }
+      }
+
+      Function("replay") { ref: VideoPlayer ->
+        appContext.mainQueue.launch {
+          ref.player.seekTo(0)
+          ref.player.play()
+        }
+      }
+
+      AsyncFunction("generateThumbnailsAsync") Coroutine { ref: VideoPlayer, times: List<Duration>, options: VideoThumbnailOptions? ->
+        return@Coroutine ref.toMetadataRetriever().safeUse {
+          val bitmaps = times.map { time ->
+            appContext.backgroundCoroutineScope.async {
+              generateThumbnailAtTime(time, options)
+            }
+          }
+
+          bitmaps.awaitAll()
+        }
+      }
+
+      Class<VideoThumbnail> {
+        Property("width") { ref -> ref.width }
+        Property("height") { ref -> ref.height }
+        Property("requestedTime") { ref -> ref.requestedTime }
+        Property("actualTime") { ref -> ref.actualTime }
+      }
+    }
+
+    OnActivityEntersForeground {
+      VideoManager.onAppForegrounded()
+    }
+
+    OnActivityEntersBackground {
+      VideoManager.onAppBackgrounded()
+    }
+  }
+  private fun replaceImpl(
+    ref: VideoPlayer,
+    source: Either<Uri, VideoSource>?,
+    promise: Promise? = null
+  ) {
+    val videoSource = source?.let {
+      if (it.`is`(VideoSource::class)) {
+        it.get(VideoSource::class)
+      } else {
+        VideoSource(it.get(Uri::class))
+      }
+    }
+
+    appContext.mainQueue.launch {
+      ref.uncommittedSource = videoSource
+      ref.prepare()
+      promise?.resolve()
+    }
+  }
+}
+
+@androidx.annotation.OptIn(UnstableApi::class)
+private inline fun <reified T : VideoView> ViewDefinitionBuilder<T>.VideoViewComponent() {
+  Events(
+    "onPictureInPictureStart",
+    "onPictureInPictureStop",
+    "onFullscreenEnter",
+    "onFullscreenExit",
+    "onFirstFrameRender"
+  )
+  Prop("player") { view: T, player: VideoPlayer ->
+    view.videoPlayer = player
+  }
+  Prop("nativeControls") { view: T, useNativeControls: Boolean ->
+    view.useNativeControls = useNativeControls
+  }
+  Prop("contentFit") { view: T, contentFit: ContentFit ->
+    view.contentFit = contentFit
+  }
+  Prop("startsPictureInPictureAutomatically") { view: T, autoEnterPiP: Boolean ->
+    view.autoEnterPiP = autoEnterPiP
+  }
+  Prop("allowsFullscreen") { view: T, allowsFullscreen: Boolean? ->
+    view.allowsFullscreen = allowsFullscreen ?: true
+  }
+  Prop("requiresLinearPlayback") { view: T, requiresLinearPlayback: Boolean? ->
+    val linearPlayback = requiresLinearPlayback ?: false
+    view.playerView.applyRequiresLinearPlayback(linearPlayback)
+    view.videoPlayer?.requiresLinearPlayback = linearPlayback
+  }
+  Prop("useExoShutter") { view: T, useExoShutter: Boolean? ->
+    view.useExoShutter = useExoShutter
+  }
+  AsyncFunction("enterFullscreen") { view: T ->
+    view.enterFullscreen()
+  }.runOnQueue(Queues.MAIN)
+  AsyncFunction("exitFullscreen") {
+    throw MethodUnsupportedException("exitFullscreen")
+  }
+  AsyncFunction("startPictureInPicture") { view: T ->
+    runWithPiPMisconfigurationSoftHandling(true) {
+      view.enterPictureInPicture()
+    }
+  }
+  AsyncFunction("stopPictureInPicture") {
+    throw MethodUnsupportedException("stopPictureInPicture")
+  }
+  OnViewDestroys {
+    VideoManager.unregisterVideoView(it)
+  }
+  OnViewDidUpdateProps { view ->
+    if (view.playerView.useController != view.useNativeControls) {
+      view.playerView.useController = view.useNativeControls
+    }
+  }
+}

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

@@ -0,0 +1,20 @@
+package expo.modules.video
+
+import android.graphics.Bitmap
+import expo.modules.kotlin.sharedobjects.SharedRef
+import kotlin.time.Duration
+
+class VideoThumbnail(
+  ref: Bitmap,
+  val requestedTime: Duration,
+  val actualTime: Duration
+) : SharedRef<Bitmap>(ref) {
+  val width = ref.width
+  val height = ref.height
+
+  override val nativeRefType: String = "image"
+
+  override fun getAdditionalMemoryPressure(): Int {
+    return ref.byteCount
+  }
+}