expo-video 2.0.0-preview.0 → 2.0.0-preview.2

package/CHANGELOG.md

@@ -10,6 +10,23 @@
 
 ### 💡 Others
 
+## 2.0.0-preview.2 — 2024-11-07
+
+### 🎉 New features
+
+- [Android][iOS] Add support for listing and selecting closed captions. ([#32582](https://github.com/expo/expo/pull/32582) by [@behenate](https://github.com/behenate))
+
+## 2.0.0-preview.1 — 2024-11-05
+
+### 🎉 New features
+
+- [Android][iOS] Add `audioMixingMode` property to control how the player interacts with other audio in the system. ([#32428](https://github.com/expo/expo/pull/32428) by [@behenate](https://github.com/behenate))
+- Add support for creating a direct instance of `VideoPlayer`. ([#32228](https://github.com/expo/expo/pull/32228) by [@behenate](https://github.com/behenate))
+
+### 🐛 Bug fixes
+
+- [Android] Fix errors when passing a source with an `undefined` `uri` field. ([#32585](https://github.com/expo/expo/pull/32585) by [@behenate](https://github.com/behenate))
+
 ## 2.0.0-preview.0 — 2024-10-22
 
 ### 🛠 Breaking changes

package/android/build.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'com.android.library'
 
 group = 'host.exp.exponent'
-version = '2.0.0-preview.0'
+version = '2.0.0-preview.2'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 apply from: expoModulesCorePlugin
@@ -14,7 +14,7 @@ android {
   namespace "expo.modules.video"
   defaultConfig {
     versionCode 1
-    versionName '2.0.0-preview.0'
+    versionName '2.0.0-preview.2'
   }
 }
 

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

@@ -7,6 +7,7 @@ import android.media.AudioManager
 import android.os.Build
 import androidx.media3.common.util.UnstableApi
 import expo.modules.kotlin.AppContext
+import expo.modules.video.enums.AudioMixingMode
 import expo.modules.video.player.VideoPlayer
 import expo.modules.video.player.VideoPlayerListener
 import kotlinx.coroutines.launch
@@ -22,19 +23,37 @@ class AudioFocusManager(private val appContext: AppContext) : AudioManager.OnAud
 
   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.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
-      if (currentFocusRequest != null) {
-        return
+      currentFocusRequest?.let {
+        if (it.focusGain == audioFocusType) {
+          return
+        }
       }
 
-      val newFocusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN).run {
+      val newFocusRequest = AudioFocusRequest.Builder(audioFocusType).run {
         setAudioAttributes(
           AudioAttributes.Builder().run {
             setUsage(AudioAttributes.USAGE_MEDIA)
@@ -44,16 +63,17 @@ class AudioFocusManager(private val appContext: AppContext) : AudioManager.OnAud
           }
         ).build()
       }
-      this.currentFocusRequest = newFocusRequest
+      currentFocusRequest = newFocusRequest
       audioManager.requestAudioFocus(newFocusRequest)
     } else {
       @Suppress("DEPRECATION")
       audioManager.requestAudioFocus(
         this,
         AudioManager.STREAM_MUSIC,
-        AudioManager.AUDIOFOCUS_GAIN
+        audioFocusType
       )
     }
+    currentMixingMode = audioMixingMode
   }
 
   private fun abandonAudioFocus() {
@@ -84,6 +104,11 @@ class AudioFocusManager(private val appContext: AppContext) : AudioManager.OnAud
 
   // 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.
@@ -116,6 +141,12 @@ class AudioFocusManager(private val appContext: AppContext) : AudioManager.OnAud
       }
 
       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)
@@ -125,9 +156,15 @@ class AudioFocusManager(private val appContext: AppContext) : AudioManager.OnAud
       }
 
       AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+        val audioMixingMode = findAudioMixingMode()
+
         appContext.mainQueue.launch {
           players.forEach {
-            duckPlayer(it)
+            if (audioMixingMode == AudioMixingMode.DO_NOT_MIX) {
+              pausePlayerIfUnmuted(it)
+            } else {
+              duckPlayer(it)
+            }
           }
         }
       }
@@ -148,10 +185,8 @@ class AudioFocusManager(private val appContext: AppContext) : AudioManager.OnAud
 
   private fun playerRequiresFocus(weakPlayer: WeakReference<VideoPlayer>): Boolean {
     return weakPlayer.get()?.let {
-      !it.muted && it.playing && it.volume > 0
-    } ?: run {
-      false
-    }
+      (!it.muted && it.playing && it.volume > 0) || it.audioMixingMode == AudioMixingMode.DO_NOT_MIX
+    } ?: false
   }
 
   private fun pausePlayerIfUnmuted(weakPlayer: WeakReference<VideoPlayer>) {
@@ -183,10 +218,23 @@ class AudioFocusManager(private val appContext: AppContext) : AudioManager.OnAud
   }
 
   private fun updateAudioFocus() {
-    if (anyPlayerRequiresFocus) {
+    if (anyPlayerRequiresFocus || findAudioMixingMode() != currentMixingMode) {
       requestAudioFocus()
     } else {
       abandonAudioFocus()
     }
   }
+
+  private fun findAudioMixingMode(): AudioMixingMode {
+    val mixingModes = players.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
+    }
+  }
 }

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

@@ -16,9 +16,11 @@ import expo.modules.kotlin.functions.Coroutine
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 import expo.modules.kotlin.types.Either
+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.VideoSource
 import expo.modules.video.utils.ifYogaDefinedUse
 import expo.modules.video.utils.makeYogaUndefinedIfNegative
@@ -207,6 +209,21 @@ class VideoModule : Module() {
           }
         }
 
+      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("currentOffsetFromLive")
         .get { ref: VideoPlayer ->
           runBlocking(appContext.mainQueue.coroutineContext) {
@@ -318,6 +335,16 @@ class VideoModule : Module() {
           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>? ->
         val videoSource = source?.let {
           if (it.`is`(VideoSource::class)) {

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

@@ -12,8 +12,6 @@ import android.view.ViewGroup
 import android.widget.FrameLayout
 import android.widget.ImageButton
 import androidx.fragment.app.FragmentActivity
-import androidx.media3.common.Format
-import androidx.media3.common.MimeTypes
 import androidx.media3.common.Tracks
 import androidx.media3.ui.PlayerView
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
@@ -254,24 +252,11 @@ class VideoView(context: Context, appContext: AppContext) : ExpoView(context, ap
   }
 
   override fun onTracksChanged(player: VideoPlayer, tracks: Tracks) {
-    showsSubtitlesButton = hasSubtitles(tracks)
+    showsSubtitlesButton = player.subtitles.availableSubtitleTracks.isNotEmpty()
     playerView.setShowSubtitleButton(showsSubtitlesButton)
     super.onTracksChanged(player, tracks)
   }
 
-  private fun hasSubtitles(tracks: Tracks): Boolean {
-    for (group in tracks.groups) {
-      for (i in 0..<group.length) {
-        val format: Format = group.getTrackFormat(i)
-
-        if (MimeTypes.isText(format.sampleMimeType)) {
-          return true
-        }
-      }
-    }
-    return false
-  }
-
   override fun requestLayout() {
     super.requestLayout()
 

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/player/PlayerEvent.kt

@@ -1,15 +1,20 @@
 package expo.modules.video.player
 
 import androidx.annotation.OptIn
+import androidx.media3.common.TrackSelectionParameters
 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.AvailableSubtitleTracksChangedEventPayload
 import expo.modules.video.records.IsPlayingEventPayload
 import expo.modules.video.records.MutedChangedEventPayload
 import expo.modules.video.records.PlaybackError
 import expo.modules.video.records.PlaybackRateChangedEventPayload
 import expo.modules.video.records.SourceChangedEventPayload
 import expo.modules.video.records.StatusChangedEventPayload
+import expo.modules.video.records.SubtitleTrack
+import expo.modules.video.records.SubtitleTrackChangedEventPayload
 import expo.modules.video.records.TimeUpdate
 import expo.modules.video.records.VideoEventPayload
 import expo.modules.video.records.VideoSource
@@ -56,11 +61,34 @@ sealed class PlayerEvent {
     override val emitToJS = false
   }
 
+  data class TrackSelectionParametersChanged(val trackSelectionParameters: TrackSelectionParameters) : PlayerEvent() {
+    override val name = "trackSelectionParametersChange"
+    override val emitToJS = false
+  }
+
+  data class SubtitleTrackChanged(val subtitleTrack: SubtitleTrack?, val oldSubtitleTrack: SubtitleTrack?) : PlayerEvent() {
+    override val name = "subtitleTrackChange"
+    override val jsEventPayload = SubtitleTrackChangedEventPayload(subtitleTrack, oldSubtitleTrack)
+  }
+
+  data class AvailableSubtitleTracksChanged(
+    val availableSubtitleTracks: List<SubtitleTrack>,
+    val oldAvailableSubtitleTracks: List<SubtitleTrack>
+  ) : PlayerEvent() {
+    override val name = "availableSubtitleTracksChange"
+    override val jsEventPayload = AvailableSubtitleTracksChangedEventPayload(availableSubtitleTracks, oldAvailableSubtitleTracks)
+  }
+
   data class TimeUpdated(val timeUpdate: TimeUpdate) : PlayerEvent() {
     override val name = "timeUpdate"
     override val jsEventPayload = timeUpdate
   }
 
+  data class AudioMixingModeChanged(val audioMixingMode: AudioMixingMode, val oldAudioMixingMode: AudioMixingMode?) : PlayerEvent() {
+    override val name = "audioMixingModeChange"
+    override val emitToJS = false
+  }
+
   class PlayedToEnd : PlayerEvent() {
     override val name = "playToEnd"
   }
@@ -73,9 +101,13 @@ sealed class PlayerEvent {
       is SourceChanged -> listeners.forEach { it.onSourceChanged(player, source, oldSource) }
       is PlaybackRateChanged -> listeners.forEach { it.onPlaybackRateChanged(player, rate, oldRate) }
       is TracksChanged -> listeners.forEach { it.onTracksChanged(player, tracks) }
+      is TrackSelectionParametersChanged -> listeners.forEach { it.onTrackSelectionParametersChanged(player, trackSelectionParameters) }
       is TimeUpdated -> listeners.forEach { it.onTimeUpdate(player, timeUpdate) }
       is PlayedToEnd -> listeners.forEach { it.onPlayedToEnd(player) }
       is MutedChanged -> listeners.forEach { it.onMutedChanged(player, muted, oldMuted) }
+      is AudioMixingModeChanged -> listeners.forEach { it.onAudioMixingModeChanged(player, audioMixingMode, oldAudioMixingMode) }
+      // JS-only events
+      else -> Unit
     }
   }
 }

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

@@ -11,10 +11,12 @@ import androidx.media3.common.PlaybackParameters
 import androidx.media3.common.Player
 import androidx.media3.common.Player.STATE_BUFFERING
 import androidx.media3.common.Timeline
+import androidx.media3.common.TrackSelectionParameters
 import androidx.media3.common.Tracks
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.exoplayer.DefaultRenderersFactory
 import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.trackselection.DefaultTrackSelector
 import androidx.media3.ui.PlayerView
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.sharedobjects.SharedObject
@@ -22,6 +24,7 @@ import expo.modules.video.IntervalUpdateClock
 import expo.modules.video.IntervalUpdateEmitter
 import expo.modules.video.VideoManager
 import expo.modules.video.delegates.IgnoreSameSet
+import expo.modules.video.enums.AudioMixingMode
 import expo.modules.video.enums.PlayerStatus
 import expo.modules.video.enums.PlayerStatus.*
 import expo.modules.video.playbackService.ExpoVideoPlaybackService
@@ -43,6 +46,8 @@ class VideoPlayer(val context: Context, appContext: AppContext, source: VideoSou
     .setEnableDecoderFallback(true)
   private var listeners: MutableList<WeakReference<VideoPlayerListener>> = mutableListOf()
   val loadControl: VideoPlayerLoadControl = VideoPlayerLoadControl.Builder().build()
+  val subtitles: VideoPlayerSubtitles = VideoPlayerSubtitles(this)
+  val trackSelector = DefaultTrackSelector(context)
 
   val player = ExoPlayer
     .Builder(context, renderersFactory)
@@ -140,22 +145,51 @@ class VideoPlayer(val context: Context, appContext: AppContext, source: VideoSou
       return player.bufferedPosition / 1000.0
     }
 
+  var audioMixingMode: AudioMixingMode = AudioMixingMode.AUTO
+    set(value) {
+      val old = field
+      field = value
+      sendEvent(PlayerEvent.AudioMixingModeChanged(value, old))
+    }
+
   private val playerListener = object : Player.Listener {
     override fun onIsPlayingChanged(isPlaying: Boolean) {
       this@VideoPlayer.playing = isPlaying
     }
 
     override fun onTracksChanged(tracks: Tracks) {
+      val oldSubtitleTracks = ArrayList(subtitles.availableSubtitleTracks)
+      val oldCurrentTrack = subtitles.currentSubtitleTrack
       sendEvent(PlayerEvent.TracksChanged(tracks))
+
+      val newSubtitleTracks = subtitles.availableSubtitleTracks
+      val newCurrentSubtitleTrack = subtitles.currentSubtitleTrack
+
+      if (!oldSubtitleTracks.toArray().contentEquals(newSubtitleTracks.toArray())) {
+        sendEvent(PlayerEvent.AvailableSubtitleTracksChanged(newSubtitleTracks, oldSubtitleTracks))
+      }
+      if (oldCurrentTrack != newCurrentSubtitleTrack) {
+        sendEvent(PlayerEvent.SubtitleTrackChanged(newCurrentSubtitleTrack, oldCurrentTrack))
+      }
       super.onTracksChanged(tracks)
     }
 
+    override fun onTrackSelectionParametersChanged(parameters: TrackSelectionParameters) {
+      val oldTrack = subtitles.currentSubtitleTrack
+      sendEvent(PlayerEvent.TrackSelectionParametersChanged(parameters))
+
+      val newTrack = subtitles.currentSubtitleTrack
+      sendEvent(PlayerEvent.SubtitleTrackChanged(newTrack, oldTrack))
+      super.onTrackSelectionParametersChanged(parameters)
+    }
+
     override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
       this@VideoPlayer.duration = 0f
       this@VideoPlayer.isLive = false
       if (reason == Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT) {
         sendEvent(PlayerEvent.PlayedToEnd())
       }
+      subtitles.setSubtitlesEnabled(false)
       super.onMediaItemTransition(mediaItem, reason)
     }
 
@@ -199,6 +233,11 @@ class VideoPlayer(val context: Context, appContext: AppContext, source: VideoSou
     ExpoVideoPlaybackService.startService(appContext, context, serviceConnection)
     player.addListener(playerListener)
     VideoManager.registerVideoPlayer(this)
+
+    // ExoPlayer will enable subtitles automatically at the start, we want them disabled by default
+    appContext.mainQueue.launch {
+      subtitles.setSubtitlesEnabled(false)
+    }
   }
 
   override fun close() {
@@ -226,11 +265,12 @@ class VideoPlayer(val context: Context, appContext: AppContext, source: VideoSou
   }
 
   fun prepare() {
-    uncommittedSource?.let { videoSource ->
-      val mediaSource = videoSource.toMediaSource(context)
-      player.setMediaSource(mediaSource)
+    val newSource = uncommittedSource
+    val mediaSource = newSource?.toMediaSource(context)
+    mediaSource?.let {
+      player.setMediaSource(it)
       player.prepare()
-      lastLoadedSource = videoSource
+      lastLoadedSource = newSource
       uncommittedSource = null
     } ?: run {
       player.clearMediaItems()

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

@@ -1,8 +1,10 @@
 package expo.modules.video.player
 
 import androidx.annotation.OptIn
+import androidx.media3.common.TrackSelectionParameters
 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.PlaybackError
 import expo.modules.video.records.VideoSource
@@ -17,6 +19,8 @@ interface VideoPlayerListener {
   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?) {}
 }

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

@@ -0,0 +1,125 @@
+package expo.modules.video.player
+
+import androidx.annotation.OptIn
+import androidx.media3.common.C
+import androidx.media3.common.Format
+import androidx.media3.common.MimeTypes
+import androidx.media3.common.TrackGroup
+import androidx.media3.common.TrackSelectionOverride
+import androidx.media3.common.TrackSelectionParameters
+import androidx.media3.common.Tracks
+import androidx.media3.common.util.UnstableApi
+import expo.modules.video.records.SubtitleTrack
+import java.lang.ref.WeakReference
+
+@OptIn(UnstableApi::class)
+class VideoPlayerSubtitles(owner: VideoPlayer) : VideoPlayerListener {
+  private val owner = WeakReference(owner)
+  private val videoPlayer: VideoPlayer?
+    get() {
+      return owner.get()
+    }
+  private val formatsToGroups = mutableMapOf<Format, Pair<TrackGroup, Int>>()
+  private var currentSubtitleFormat: Format? = null
+  private var currentOverride: TrackSelectionOverride? = null
+
+  var currentSubtitleTrack: SubtitleTrack?
+    get() {
+      return SubtitleTrack.fromFormat(currentSubtitleFormat)
+    }
+    set(value) {
+      applySubtitleTrack(value)
+    }
+  val availableSubtitleTracks = arrayListOf<SubtitleTrack>()
+
+  init {
+    owner.addListener(this)
+  }
+
+  fun setSubtitlesEnabled(enabled: Boolean) {
+    val currentParams = videoPlayer?.player?.trackSelectionParameters ?: return
+    var params = currentParams.buildUpon().setTrackTypeDisabled(C.TRACK_TYPE_TEXT, !enabled).build()
+    if (!enabled) {
+      params = params.buildUpon().clearOverridesOfType(C.TRACK_TYPE_TEXT).build()
+    }
+    videoPlayer?.player?.trackSelectionParameters = params
+  }
+
+  // VideoPlayerListener
+  override fun onTrackSelectionParametersChanged(player: VideoPlayer, trackSelectionParameters: TrackSelectionParameters) {
+    currentSubtitleFormat = findSelectedSubtitleFormat()
+    super.onTrackSelectionParametersChanged(player, trackSelectionParameters)
+  }
+
+  override fun onTracksChanged(player: VideoPlayer, tracks: Tracks) {
+    formatsToGroups.clear()
+    availableSubtitleTracks.clear()
+    for (group in tracks.groups) {
+      for (i in 0..<group.length) {
+        val format: Format = group.getTrackFormat(i)
+
+        if (MimeTypes.isText(format.sampleMimeType)) {
+          formatsToGroups[format] = Pair(group.mediaTrackGroup, i)
+          val track = SubtitleTrack.fromFormat(format) ?: continue
+          availableSubtitleTracks.add(track)
+        }
+      }
+    }
+    currentSubtitleFormat = findSelectedSubtitleFormat()
+    super.onTracksChanged(player, tracks)
+  }
+
+  // Private methods
+  private fun applySubtitleTrack(subtitleTrack: SubtitleTrack?) {
+    val player = videoPlayer?.player ?: return
+    var newParameters: TrackSelectionParameters = player.trackSelectionParameters
+    currentOverride?.let { override ->
+      newParameters = newParameters.buildUpon().clearOverridesOfType(C.TRACK_TYPE_TEXT).build()
+    }
+    if (subtitleTrack == null) {
+      player.trackSelectionParameters = newParameters
+      setSubtitlesEnabled(false)
+      currentOverride = null
+      return
+    }
+    val format = formatsToGroups.keys.firstOrNull {
+      it.id == subtitleTrack.id
+    }
+    format?.let {
+      formatsToGroups[it]?.let { subtitlePair ->
+        val override = TrackSelectionOverride(subtitlePair.first, subtitlePair.second)
+        newParameters = newParameters.buildUpon().addOverride(override).build()
+        player.trackSelectionParameters = newParameters
+        setSubtitlesEnabled(true)
+        currentOverride = override
+      }
+    }
+  }
+
+  private fun findSelectedSubtitleFormat(): Format? {
+    val trackSelectionParameters = videoPlayer?.player?.trackSelectionParameters
+    val preferredTextLanguages = trackSelectionParameters?.preferredTextLanguages
+    val overriddenFormat: Format? = trackSelectionParameters?.overrides?.let {
+      for ((group, override) in it) {
+        if (group.type == C.TRACK_TYPE_TEXT) {
+          // For subtitles only one index will be replaced
+          return@let override.trackIndices.firstOrNull()?.let { index ->
+            group.getFormat(index)
+          }
+        }
+      }
+      return@let null
+    }
+
+    val preferredFormat: Format? = preferredTextLanguages?.let { preferredTextLanguages ->
+      for (preferredLanguage in preferredTextLanguages) {
+        return@let formatsToGroups.keys.firstOrNull {
+          it.language == preferredLanguage
+        }
+      }
+      return@let null
+    }
+
+    return overriddenFormat ?: preferredFormat
+  }
+}

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

@@ -0,0 +1,28 @@
+package expo.modules.video.records
+
+import androidx.media3.common.Format
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+import java.io.Serializable
+import java.util.Locale
+
+class SubtitleTrack(
+  @Field var id: String,
+  @Field var language: String?,
+  @Field var label: String?
+) : Record, Serializable {
+  companion object {
+    fun fromFormat(format: Format?): SubtitleTrack? {
+      format ?: return null
+      val id = format.id ?: return null
+      val language = format.language ?: return null
+      val label = Locale(language).displayLanguage
+
+      return SubtitleTrack(
+        id = id,
+        language = language,
+        label = label
+      )
+    }
+  }
+}

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

@@ -44,3 +44,13 @@ class TimeUpdate(
   @Field var currentLiveTimestamp: Long?,
   @Field var bufferedPosition: Double = .0
 ) : VideoEventPayload
+
+class SubtitleTrackChangedEventPayload(
+  @Field val subtitleTrack: SubtitleTrack?,
+  @Field val oldSubtitleTrack: SubtitleTrack?
+) : VideoEventPayload
+
+class AvailableSubtitleTracksChangedEventPayload(
+  @Field val availableSubtitleTracks: List<SubtitleTrack>,
+  @Field val oldAvailableSubtitleTracks: List<SubtitleTrack>
+) : VideoEventPayload

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

@@ -38,7 +38,8 @@ class VideoSource(
       "NotificationDataArtwork:${this.metadata?.artwork?.path}"
   }
 
-  fun toMediaSource(context: Context): MediaSource {
+  fun toMediaSource(context: Context): MediaSource? {
+    this.uri ?: return null
     return buildMediaSourceWithHeaders(context, this)
   }