expo-video-subtitle 0.1.0

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
+    }
+  }
+}

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/enums/PlayerStatus.kt

@@ -0,0 +1,10 @@
+package expo.modules.video.enums
+
+import expo.modules.kotlin.types.Enumerable
+
+enum class PlayerStatus(val value: String) : Enumerable {
+  IDLE("idle"),
+  LOADING("loading"),
+  READY_TO_PLAY("readyToPlay"),
+  ERROR("error")
+}

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

@@ -0,0 +1,27 @@
+package expo.modules.video.records
+
+import androidx.annotation.OptIn
+import androidx.media3.common.C
+import androidx.media3.common.C.COLOR_TRANSFER_HLG
+import androidx.media3.common.C.COLOR_TRANSFER_ST2084
+import androidx.media3.common.util.UnstableApi
+import expo.modules.kotlin.types.Enumerable
+
+enum class VideoRange(val value: String) : Enumerable {
+  SDR("sdr"),
+  HLG("hlg"),
+  PQ("PQ");
+
+  companion object {
+    @OptIn(UnstableApi::class)
+    fun fromCColorTransfer(colorTransfer: @C.ColorTransfer Int?): VideoRange {
+      colorTransfer ?: return SDR
+
+      return when (colorTransfer) {
+        COLOR_TRANSFER_ST2084 -> PQ
+        COLOR_TRANSFER_HLG -> HLG
+        else -> SDR
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/video/listeners/VideoManagerListener.kt

@@ -0,0 +1,10 @@
+package expo.modules.video.listeners
+
+import expo.modules.video.VideoView
+
+interface VideoManagerListener {
+  fun onVideoViewRegistered(videoView: VideoView, allVideoViews: Collection<VideoView>) {}
+  fun onVideoViewUnregistered(videoView: VideoView, allVideoViews: Collection<VideoView>) {}
+  fun onAppBackgrounded() {}
+  fun onAppForegrounded() {}
+}

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

@@ -0,0 +1,35 @@
+package expo.modules.video.listeners
+
+import androidx.annotation.OptIn
+import androidx.media3.common.TrackSelectionParameters
+import androidx.media3.common.Tracks
+import androidx.media3.common.util.UnstableApi
+import expo.modules.video.VideoView
+import expo.modules.video.enums.AudioMixingMode
+import expo.modules.video.enums.PlayerStatus
+import expo.modules.video.player.VideoPlayer
+import expo.modules.video.records.AudioTrack
+import expo.modules.video.records.PlaybackError
+import expo.modules.video.records.SubtitleTrack
+import expo.modules.video.records.TimeUpdate
+import expo.modules.video.records.VideoSource
+import expo.modules.video.records.VideoTrack
+
+@OptIn(UnstableApi::class)
+interface VideoPlayerListener {
+  fun onStatusChanged(player: VideoPlayer, status: PlayerStatus, oldStatus: PlayerStatus?, error: PlaybackError?) {}
+  fun onIsPlayingChanged(player: VideoPlayer, isPlaying: Boolean, oldIsPlaying: Boolean?) {}
+  fun onVolumeChanged(player: VideoPlayer, volume: Float, oldVolume: Float?) {}
+  fun onMutedChanged(player: VideoPlayer, muted: Boolean, oldMuted: Boolean?) {}
+  fun onSourceChanged(player: VideoPlayer, source: VideoSource?, oldSource: VideoSource?) {}
+  fun onPlaybackRateChanged(player: VideoPlayer, rate: Float, oldRate: Float?) {}
+  fun onTracksChanged(player: VideoPlayer, tracks: Tracks) {}
+  fun onTrackSelectionParametersChanged(player: VideoPlayer, trackSelectionParameters: TrackSelectionParameters) {}
+  fun onTimeUpdate(player: VideoPlayer, timeUpdate: TimeUpdate) {}
+  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 onTargetViewChanged(player: VideoPlayer, newTargetView: VideoView?, oldTargetView: VideoView?) {}
+  fun onRenderedFirstFrame(player: VideoPlayer) {}
+}

package/android/src/main/java/expo/modules/video/listeners/VideoViewListener.kt

@@ -0,0 +1,13 @@
+package expo.modules.video.listeners
+
+import expo.modules.video.VideoView
+import expo.modules.video.records.PiPParams
+
+interface VideoViewListener {
+  /**
+   * Called when the ability of the view to autoEnterPip has changed.
+   * Note: This can be called when `autoEnterPiP` doesn't change, but other factors
+   * influence the view's ability to enter PiP.
+   */
+  fun onPiPParamsChanged(videoView: VideoView, oldPiPParams: PiPParams, newPiPParams: PiPParams) = Unit
+}

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

@@ -0,0 +1,242 @@
+package expo.modules.video.managers
+
+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.FailedToGetAudioFocusManagerException
+import expo.modules.video.enums.AudioMixingMode
+import expo.modules.video.player.VideoPlayer
+import expo.modules.video.listeners.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
+    }
+  }
+}