expo-video-subtitle 0.1.0

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/PlayerViewExtension.kt

@@ -0,0 +1,87 @@
+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
+  }
+}
+
+@androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)
+internal fun PlayerView.setSettingsButtonVisibility(visible: Boolean) {
+  val settingsButton = findViewById<android.widget.ImageButton>(androidx.media3.ui.R.id.exo_settings)
+  settingsButton?.visibility = if (visible) {
+    android.view.View.VISIBLE
+  } else {
+    android.view.View.GONE
+  }
+}
+
+@androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)
+internal fun PlayerView.setPlayPauseButtonVisibility(visible: Boolean) {
+  val playPauseButton = findViewById<android.widget.ImageButton>(androidx.media3.ui.R.id.exo_play_pause)
+  playPauseButton?.visibility = if (visible) {
+    android.view.View.VISIBLE
+  } else {
+    android.view.View.GONE
+  }
+}
+
+@androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)
+internal fun PlayerView.setBottomBarVisibility(visible: Boolean) {
+  val bottomBar = findViewById<android.view.ViewGroup>(androidx.media3.ui.R.id.exo_bottom_bar)
+  bottomBar?.visibility = if (visible) {
+    android.view.View.VISIBLE
+  } else {
+    android.view.View.GONE
+  }
+
+  val progressBar = findViewById<DefaultTimeBar>(androidx.media3.ui.R.id.exo_progress)
+  progressBar?.visibility = if (visible) {
+    android.view.View.VISIBLE
+  } else {
+    android.view.View.GONE
+  }
+}
+
+@androidx.annotation.OptIn(androidx.media3.common.util.UnstableApi::class)
+internal fun PlayerView.applyButtonOptions(
+  config: expo.modules.video.records.ButtonOptions,
+  requiresLinearPlayback: Boolean = false
+) {
+  setShowFastForwardButton(!requiresLinearPlayback && config.showSeekForward)
+  setShowRewindButton(!requiresLinearPlayback && config.showSeekBackward)
+  setShowPreviousButton(!requiresLinearPlayback && config.showPrevious)
+  setShowNextButton(!requiresLinearPlayback && config.showNext)
+  setSettingsButtonVisibility(config.showSettings)
+  setPlayPauseButtonVisibility(config.showPlayPause)
+  setBottomBarVisibility(config.showBottomBar)
+}

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

@@ -0,0 +1,109 @@
+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 expo.modules.video.managers.VideoManager
+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 release() {
+    instance.release()
+  }
+
+  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).commit()
+      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,45 @@
+package expo.modules.video
+
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.video.enums.DRMType
+
+private const val defaultServiceBindingTip = "Make sure that the expo-video config plugin is properly configured to avoid issues with displaying the now playing notification and sustaining background playback."
+
+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")
+
+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)
+
+internal class NowPlayingException(message: String?, cause: Throwable? = null) :
+  CodedException(message ?: "Unexpected expo-video now playing exception", cause)
+
+internal fun getPlaybackServiceErrorMessage(message: String?, tip: String = defaultServiceBindingTip) =
+  (message ?: "Expo-video playback service binder error") + ". $tip"