react-native-audio-browser 0.1.1 → 0.2.0-next.10

package/android/src/main/java/com/audiobrowser/player/CapabilityControls.kt

@@ -0,0 +1,172 @@
+package com.audiobrowser.player
+
+import com.margelo.nitro.audiobrowser.PlayerCapabilities
+import com.margelo.nitro.audiobrowser.RemoteButton
+import com.margelo.nitro.audiobrowser.RemoteButtonLayout
+
+/**
+ * The pure decision core for Capabilities: one rule for whether a Capability is enabled
+ * ([isEnabled]) and one derivation of the button layout ([deriveButtonSlots]).
+ * MediaSessionCommandManager's Media3 assemblies all consume these decisions — previously each
+ * re-implemented them, and the copies had drifted.
+ */
+
+/**
+ * A control that a Capability gates. Mirrors the [PlayerCapabilities] flags Android acts on —
+ * `shuffleMode`, `repeatMode` and `playbackRate` exist on the struct but only drive CarPlay, so
+ * they have no entry here.
+ */
+enum class Capability {
+  PLAY_PAUSE,
+  STOP,
+  SEEK_TO,
+  SKIP_TO_NEXT,
+  SKIP_TO_PREVIOUS,
+  JUMP_FORWARD,
+  JUMP_BACKWARD,
+  FAVORITE,
+}
+
+/**
+ * Whether a Capability is enabled. Everything is enabled by default and only an explicit `false`
+ * disables — except FAVORITE, which is opt-in, and PLAY_PAUSE, which is one control on every
+ * surface and only goes away when both halves are disabled.
+ */
+fun PlayerCapabilities.isEnabled(capability: Capability): Boolean =
+  when (capability) {
+    Capability.PLAY_PAUSE -> !(play == false && pause == false)
+    Capability.STOP -> stop != false
+    Capability.SEEK_TO -> seekTo != false
+    Capability.SKIP_TO_NEXT -> skipToNext != false
+    Capability.SKIP_TO_PREVIOUS -> skipToPrevious != false
+    Capability.JUMP_FORWARD -> jumpForward != false
+    Capability.JUMP_BACKWARD -> jumpBackward != false
+    Capability.FAVORITE -> favoriteEnabled
+  }
+
+/**
+ * The three positions Android actually offers, mapped to `CommandButton.SLOT_*` at Media3 assembly
+ * time. There is no secondary pair: every system surface flattens the layout to back, forward and
+ * overflow, so a fourth or fifth position would have nowhere to render.
+ *
+ * Media3 does define SLOT_BACK_SECONDARY and SLOT_FORWARD_SECONDARY, but `DisplayConstraints`
+ * defaults both to **0 buttons** — only a controller that opts in with `setMaxButtonsForSlot` shows
+ * them, which no system surface does.
+ */
+enum class ButtonSlot {
+  BACK,
+  FORWARD,
+  OVERFLOW,
+}
+
+data class SlottedButton(val button: RemoteButton, val slot: ButtonSlot)
+
+/** The Capability gating a button. */
+private val RemoteButton.capability: Capability
+  get() =
+    when (this) {
+      RemoteButton.SKIP_TO_PREVIOUS -> Capability.SKIP_TO_PREVIOUS
+      RemoteButton.SKIP_TO_NEXT -> Capability.SKIP_TO_NEXT
+      RemoteButton.JUMP_BACKWARD -> Capability.JUMP_BACKWARD
+      RemoteButton.JUMP_FORWARD -> Capability.JUMP_FORWARD
+      RemoteButton.FAVORITE -> Capability.FAVORITE
+    }
+
+/** Whether [button]'s gating Capability allows it. */
+fun PlayerCapabilities.allows(button: RemoteButton): Boolean = isEnabled(button.capability)
+
+/**
+ * Whether two layouts describe the same arrangement.
+ *
+ * [RemoteButtonLayout] is a generated data class whose `overflow` is an `Array`, and Kotlin
+ * data-class equality compares arrays by *reference*. Plain `==` therefore reports "changed" for
+ * two identical layouts whenever overflow is set, because every options update carries a fresh
+ * array across the bridge — which would republish the layout to Android Auto on every unrelated
+ * `updateOptions` call.
+ */
+internal fun RemoteButtonLayout?.sameAs(other: RemoteButtonLayout?): Boolean =
+  if (this == null || other == null) {
+    this == null && other == null
+  } else {
+    back == other.back && forward == other.forward && overflow.contentEquals(other.overflow)
+  }
+
+/**
+ * The single derivation of the button layout.
+ *
+ * The two parameters answer different questions, and only one of them is authoritative:
+ * - [capabilities] — *may* this button exist? Admission.
+ * - [layout] — *where* does it go? Arrangement.
+ *
+ * **A layout can rearrange buttons but never add one.** Every entry is filtered through [allows]
+ * regardless of its position, so naming a button whose Capability is disabled does nothing —
+ * listing `FAVORITE` while `capabilities.favorite` is off leaves it off. This is the usual
+ * surprise, because JUMP_FORWARD and JUMP_BACKWARD default to disabled: a layout full of jump
+ * buttons silently produces none until those capabilities are turned on.
+ *
+ * With no [layout], [capabilities] does both jobs — it decides membership *and* infers positions:
+ * skip takes the primary positions, jump falls back into a primary position when its skip is
+ * disabled and otherwise sits in overflow, favorite in overflow.
+ *
+ * With a [layout], each field maps to its position — `back` to BACK, `forward` to FORWARD, every
+ * `overflow` entry to OVERFLOW in order — and disabled entries drop out. A dropped entry leaves its
+ * position empty rather than promoting anything into it: turning off one capability must not
+ * silently rearrange the row.
+ *
+ * A [layout] is all-or-nothing: every field is required, so it fully describes the arrangement and
+ * nothing is merged with the capability defaults. The bridge could not support a per-field merge
+ * anyway — Nitro maps both an omitted and a null enum field to Kotlin `null`, so native cannot tell
+ * "leave this empty" from "derive this one".
+ *
+ * [capabilities] has a second job outside this function: it also drives the player and session
+ * commands, which govern what a Bluetooth remote or headset can trigger. That is why placement is
+ * purely cosmetic here — a button left out of the layout disappears from every screen while still
+ * responding to a headset.
+ *
+ * @param capabilities What the player is allowed to do. Gates every button, in both modes.
+ * @param layout Explicit placement, or null to infer placement from [capabilities].
+ */
+fun deriveButtonSlots(
+  capabilities: PlayerCapabilities,
+  layout: RemoteButtonLayout?,
+): List<SlottedButton> {
+  if (layout != null) {
+    return buildList {
+        layout.back?.let { add(SlottedButton(it, ButtonSlot.BACK)) }
+        layout.forward?.let { add(SlottedButton(it, ButtonSlot.FORWARD)) }
+        layout.overflow.forEach { add(SlottedButton(it, ButtonSlot.OVERFLOW)) }
+      }
+      .filter { capabilities.allows(it.button) }
+  }
+
+  return buildList {
+    val skipPrevious = capabilities.isEnabled(Capability.SKIP_TO_PREVIOUS)
+    val skipNext = capabilities.isEnabled(Capability.SKIP_TO_NEXT)
+    val jumpBackward = capabilities.isEnabled(Capability.JUMP_BACKWARD)
+    val jumpForward = capabilities.isEnabled(Capability.JUMP_FORWARD)
+
+    // Primary positions: skip, with jump falling back when its skip is disabled.
+    if (skipPrevious) {
+      add(SlottedButton(RemoteButton.SKIP_TO_PREVIOUS, ButtonSlot.BACK))
+    } else if (jumpBackward) {
+      add(SlottedButton(RemoteButton.JUMP_BACKWARD, ButtonSlot.BACK))
+    }
+    if (skipNext) {
+      add(SlottedButton(RemoteButton.SKIP_TO_NEXT, ButtonSlot.FORWARD))
+    } else if (jumpForward) {
+      add(SlottedButton(RemoteButton.JUMP_FORWARD, ButtonSlot.FORWARD))
+    }
+
+    // Jump moves to overflow when skip holds the primary position.
+    if (skipPrevious && jumpBackward) {
+      add(SlottedButton(RemoteButton.JUMP_BACKWARD, ButtonSlot.OVERFLOW))
+    }
+    if (skipNext && jumpForward) {
+      add(SlottedButton(RemoteButton.JUMP_FORWARD, ButtonSlot.OVERFLOW))
+    }
+
+    if (capabilities.isEnabled(Capability.FAVORITE)) {
+      add(SlottedButton(RemoteButton.FAVORITE, ButtonSlot.OVERFLOW))
+    }
+  }
+}

package/android/src/main/java/com/audiobrowser/player/DynamicLoadControl.kt

@@ -3,6 +3,7 @@ package com.audiobrowser.player
 import androidx.media3.common.C
 import androidx.media3.exoplayer.DefaultLoadControl
 import androidx.media3.exoplayer.LoadControl
+import androidx.media3.exoplayer.analytics.PlayerId
 import androidx.media3.exoplayer.source.TrackGroupArray
 import androidx.media3.exoplayer.trackselection.ExoTrackSelection
 import androidx.media3.exoplayer.upstream.Allocator
@@ -47,6 +48,15 @@ class DynamicLoadControl(initialConfig: BufferConfig = BufferConfig()) : LoadCon
   @Volatile private var prepareStartTimeMs: Long = 0
   @Volatile private var playbackStarted: Boolean = false
 
+  // ExoPlayer's own rebuffering signal (buffer depletion mid-playback, as opposed to an initial
+  // connect, a seek, or a track transition). Mirrored from LoadControl.Parameters so consumers
+  // (e.g. the now-playing "Buffering…" subtitle) can tell a rebuffer apart from an initial connect.
+  @Volatile private var rebuffering: Boolean = false
+
+  /** Whether playback is currently rebuffering due to buffer depletion (not initial start/seek). */
+  val isRebuffering: Boolean
+    get() = rebuffering
+
   // Mutable buffer thresholds - can be updated at runtime
   @Volatile private var minBufferUs: Long = initialConfig.minBufferMs * 1000L
 
@@ -97,17 +107,23 @@ class DynamicLoadControl(initialConfig: BufferConfig = BufferConfig()) : LoadCon
     updateBufferConfig(BufferConfig())
   }
 
-  override fun getAllocator(): Allocator = allocator
+  // media3 1.10 added a PlayerId parameter for multi-player allocator sharing. This LoadControl is
+  // only ever attached to a single ExoPlayer, so we return the same allocator regardless of player.
+  override fun getAllocator(playerId: PlayerId): Allocator = allocator
 
   override fun getBackBufferDurationUs(): Long = backBufferUs
 
   override fun retainBackBufferFromKeyframe(): Boolean = false
 
   override fun shouldContinueLoading(parameters: LoadControl.Parameters): Boolean {
+    // Refreshed on every load-control poll (all playback states) so the flag clears once a
+    // rebuffer recovers, not just while buffering.
+    rebuffering = parameters.rebuffering
     return parameters.bufferedDurationUs < maxBufferUs
   }
 
   override fun shouldStartPlayback(parameters: LoadControl.Parameters): Boolean {
+    rebuffering = parameters.rebuffering
     val bufferedDurationUs = parameters.bufferedDurationUs
     val targetUs =
       adjustForPlaybackSpeed(
@@ -141,6 +157,7 @@ class DynamicLoadControl(initialConfig: BufferConfig = BufferConfig()) : LoadCon
     allocator.reset()
     prepareStartTimeMs = System.currentTimeMillis()
     playbackStarted = false
+    rebuffering = false
   }
 
   override fun onTracksSelected(

package/android/src/main/java/com/audiobrowser/player/EqualizerController.kt

@@ -0,0 +1,153 @@
+package com.audiobrowser.player
+
+import androidx.media3.common.C
+import com.audiobrowser.util.EqualizerManager
+import com.margelo.nitro.audiobrowser.EqualizerSettings
+import timber.log.Timber
+
+/** The equalizer operations [EqualizerController] drives, so tests can stand in for the effect. */
+internal interface EqualizerEffect {
+  val audioSessionId: Int
+
+  fun getSettings(): EqualizerSettings?
+
+  fun setOnSettingsChanged(callback: (EqualizerSettings) -> Unit)
+
+  fun setEnabled(enabled: Boolean)
+
+  fun setPreset(presetName: String)
+
+  fun setLevels(levels: DoubleArray)
+
+  fun release()
+}
+
+/**
+ * Owns the equalizer's lifecycle across audio sessions. Android's Equalizer effect binds to a
+ * single audioSessionId, so there are stretches with no effect at all: startup has no session until
+ * the first audio output, and a session change (new ExoPlayer instance) needs a fresh one. Callers
+ * see none of that — settings requested during a gap land on whichever effect comes next, and every
+ * new effect announces itself through [onSettingsChanged].
+ */
+internal class EqualizerController(
+  private val onSettingsChanged: (EqualizerSettings) -> Unit,
+  private val createEffect: (Int) -> EqualizerEffect = { EqualizerManager(it) },
+) {
+
+  private var effect: EqualizerEffect? = null
+
+  // Settings to apply to the next effect: what the caller asked for during a gap, or what the
+  // outgoing effect held across a session change. A preset and custom levels are exclusive — the
+  // last one asked for wins, matching how the two setters behave on a live effect.
+  private var pendingPreset: String? = null
+  private var pendingLevels: DoubleArray? = null
+  private var pendingEnabled: Boolean? = null
+
+  /** Initializes for [audioSessionId]; deferred when the session is still unset. */
+  fun initialize(audioSessionId: Int) {
+    if (audioSessionId == C.AUDIO_SESSION_ID_UNSET) {
+      Timber.d("Skipping equalizer init - no audio session yet, will init on first playback")
+      return
+    }
+    install(audioSessionId)
+  }
+
+  /**
+   * Reacts to an audio session change: a no-op for the same session, otherwise a fresh effect that
+   * picks up the outgoing one's settings.
+   */
+  fun onAudioSessionChanged(newAudioSessionId: Int) {
+    val old = effect
+    if (old != null && old.audioSessionId == newAudioSessionId) return
+
+    old?.let {
+      it.getSettings()?.let(::remember)
+      it.release()
+      effect = null
+    }
+    install(newAudioSessionId)
+  }
+
+  fun release() {
+    effect?.release()
+    effect = null
+  }
+
+  fun getSettings(): EqualizerSettings? = effect?.getSettings()
+
+  fun setEnabled(enabled: Boolean) {
+    val effect = effect
+    if (effect == null) {
+      pendingEnabled = enabled
+      return
+    }
+    effect.setEnabled(enabled)
+  }
+
+  fun setPreset(preset: String) {
+    val effect = effect
+    if (effect == null) {
+      rememberPreset(preset)
+      return
+    }
+    effect.setPreset(preset)
+  }
+
+  fun setLevels(levels: DoubleArray) {
+    val effect = effect
+    if (effect == null) {
+      rememberLevels(levels)
+      return
+    }
+    effect.setLevels(levels)
+  }
+
+  /**
+   * Creates the effect for [audioSessionId] and hands it the pending settings before wiring the
+   * callback, so the restore stays silent and the caller gets one event describing the result. A
+   * failed create keeps the pending settings for the next attempt.
+   */
+  private fun install(audioSessionId: Int) {
+    val created =
+      try {
+        createEffect(audioSessionId)
+      } catch (e: Exception) {
+        Timber.e(e, "Failed to initialize equalizer")
+        return
+      }
+    effect = created
+    Timber.d("Equalizer initialized with session ID: $audioSessionId")
+
+    pendingPreset?.let(created::setPreset)
+    pendingLevels?.let(created::setLevels)
+    pendingEnabled?.let(created::setEnabled)
+    pendingPreset = null
+    pendingLevels = null
+    pendingEnabled = null
+
+    created.setOnSettingsChanged(onSettingsChanged)
+    // Announce unconditionally. The caller reads the settings once at startup, which is exactly
+    // when there may be no effect yet, and nothing else would tell it the equalizer now exists.
+    created.getSettings()?.let(onSettingsChanged)
+  }
+
+  private fun remember(settings: EqualizerSettings) {
+    val preset = settings.activePreset
+    if (preset != null) {
+      rememberPreset(preset)
+    } else {
+      rememberLevels(settings.bandLevels)
+    }
+    pendingEnabled = settings.enabled
+  }
+
+  private fun rememberPreset(preset: String) {
+    pendingPreset = preset
+    pendingLevels = null
+  }
+
+  private fun rememberLevels(levels: DoubleArray) {
+    pendingLevels = levels
+    pendingPreset = null
+  }
+}

package/android/src/main/java/com/audiobrowser/player/InterceptingPlayer.kt

@@ -0,0 +1,141 @@
+package com.audiobrowser.player
+
+import androidx.media3.common.ForwardingPlayer
+import androidx.media3.common.Player as MediaPlayer
+import com.audiobrowser.Callbacks
+import com.audiobrowser.model.PlayerUpdateOptions
+import com.margelo.nitro.audiobrowser.RemoteJumpBackwardEvent
+import com.margelo.nitro.audiobrowser.RemoteJumpForwardEvent
+import com.margelo.nitro.audiobrowser.RemoteSeekEvent
+
+/**
+ * The session-error masking rules, pure so their truth table is testable: with
+ * `keepSessionAliveOnError`, a terminal load error (ExoPlayer idle + error present) is reported to
+ * the platform session as paused-but-ready instead of STATE_NONE — Android Auto reads STATE_NONE as
+ * "nothing playing" and tears down the now-playing screen, losing the next/previous buttons.
+ */
+internal object SessionErrorMask {
+  fun playbackState(state: Int, hasError: Boolean, keepAlive: Boolean): Int =
+    if (keepAlive && state == MediaPlayer.STATE_IDLE && hasError) MediaPlayer.STATE_READY else state
+
+  fun playWhenReady(raw: Boolean, state: Int, hasError: Boolean, keepAlive: Boolean): Boolean =
+    if (keepAlive && state == MediaPlayer.STATE_IDLE && hasError) false else raw
+}
+
+/**
+ * The Remote-command seam: intercepts transport controls arriving from External surfaces (lock
+ * screen, notification, Bluetooth, Android Auto — all via the MediaSession) and offers each to the
+ * app's `handleRemote*` callback first; a callback returning true consumes the command, anything
+ * else falls through to the default behavior. Also masks a terminal playback error from the
+ * platform session (see [SessionErrorMask]) so the session stays alive and skippable; the error
+ * still surfaces via `onPlaybackError` and `playbackState`.
+ */
+internal class InterceptingPlayer(
+  player: MediaPlayer,
+  private val callbacksProvider: () -> Callbacks?,
+  private val optionsProvider: () -> PlayerUpdateOptions,
+  private val keepSessionAliveOnError: Boolean,
+) : ForwardingPlayer(player) {
+
+  // Hide playback errors from the platform session. Media3 builds the legacy PlaybackStateCompat
+  // from player.getPlayerError() (-> STATE_ERROR), which Android Auto and the notification render
+  // as a disruptive error. The error still surfaces via the onPlaybackError JS callback and
+  // `playbackState`, so a now-playing formatter can render it; playback context is preserved.
+  override fun getPlayerError(): androidx.media3.common.PlaybackException? = null
+
+  // Both masks read the real underlying error (super.getPlayerError()) so they're race-free with
+  // state-change listeners.
+  override fun getPlaybackState(): Int =
+    SessionErrorMask.playbackState(
+      super.getPlaybackState(),
+      hasError = super.getPlayerError() != null,
+      keepAlive = keepSessionAliveOnError,
+    )
+
+  override fun getPlayWhenReady(): Boolean =
+    SessionErrorMask.playWhenReady(
+      super.getPlayWhenReady(),
+      super.getPlaybackState(),
+      hasError = super.getPlayerError() != null,
+      keepAlive = keepSessionAliveOnError,
+    )
+
+  /**
+   * A terminal error leaves ExoPlayer idle; the default transport controls (super.play() /
+   * super.seekToNext()) then flip playWhenReady or move the queue index but never restart a stopped
+   * player. prepare() recovers it (and early-returns when not idle, so it's a no-op during normal
+   * playback) — so next/previous/play resume on the selected station from the masked error state
+   * instead of doing nothing.
+   */
+  private fun recoverFromErrorIfNeeded() {
+    if (keepSessionAliveOnError && super.getPlayerError() != null) {
+      // Through the forwarding chain (no override exists), reaching the wrapped player.
+      prepare()
+    }
+  }
+
+  /**
+   * One definition of the dispatch: offer the command to the app's handler; true consumes it,
+   * anything else runs the default (and, for the resuming commands, the idle-error recovery).
+   */
+  private inline fun intercept(
+    handler: (Callbacks) -> Boolean,
+    recover: Boolean = false,
+    fallback: () -> Unit,
+  ) {
+    if (callbacksProvider()?.let(handler) == true) return
+    fallback()
+    if (recover) recoverFromErrorIfNeeded()
+  }
+
+  override fun play() = intercept({ it.handleRemotePlay() }, recover = true) { super.play() }
+
+  override fun pause() = intercept({ it.handleRemotePause() }) { super.pause() }
+
+  // Media3 controllers may drive transport via setPlayWhenReady instead of play()/pause()
+  // (the documented ForwardingPlayer hazard); route it through the same interception so the
+  // remote handlers and the idle-error recovery aren't bypassed.
+  override fun setPlayWhenReady(playWhenReady: Boolean) = if (playWhenReady) play() else pause()
+
+  override fun stop() = intercept({ it.handleRemoteStop() }) { super.stop() }
+
+  override fun seekToNext() =
+    intercept({ it.handleRemoteNext() }, recover = true) { super.seekToNext() }
+
+  override fun seekToNextMediaItem() =
+    intercept({ it.handleRemoteNext() }, recover = true) { super.seekToNextMediaItem() }
+
+  override fun seekToPrevious() =
+    intercept({ it.handleRemotePrevious() }, recover = true) { super.seekToPrevious() }
+
+  override fun seekToPreviousMediaItem() =
+    intercept({ it.handleRemotePrevious() }, recover = true) { super.seekToPreviousMediaItem() }
+
+  override fun seekForward() =
+    intercept({
+      it.handleRemoteJumpForward(
+        RemoteJumpForwardEvent(interval = optionsProvider().forwardJumpInterval)
+      )
+    }) {
+      super.seekForward()
+    }
+
+  override fun seekBack() =
+    intercept({
+      it.handleRemoteJumpBackward(
+        RemoteJumpBackwardEvent(interval = optionsProvider().backwardJumpInterval)
+      )
+    }) {
+      super.seekBack()
+    }
+
+  override fun seekTo(mediaItemIndex: Int, positionMs: Long) =
+    intercept({ it.handleRemoteSeek(RemoteSeekEvent(position = positionMs.toDouble() / 1000.0)) }) {
+      super.seekTo(mediaItemIndex, positionMs)
+    }
+
+  override fun seekTo(positionMs: Long) =
+    intercept({ it.handleRemoteSeek(RemoteSeekEvent(position = positionMs.toDouble() / 1000.0)) }) {
+      super.seekTo(positionMs)
+    }
+}

package/android/src/main/java/com/audiobrowser/player/MediaFactory.kt

@@ -15,7 +15,7 @@ import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
 import androidx.media3.extractor.DefaultExtractorsFactory
 import com.audiobrowser.model.RetryPolicy
 import com.margelo.nitro.audiobrowser.MediaRequestConfig
-import timber.log.Timber
+import java.io.IOException
 
 class MediaFactory(
   private val context: Context,
@@ -23,7 +23,8 @@ class MediaFactory(
   private val retryPolicy: RetryPolicy,
   private val shouldRetry: () -> Boolean,
   private val isOnline: () -> Boolean = { true },
-  private val onRetryPending: ((isNetworkError: Boolean) -> Unit)? = null,
+  private val hasPlayed: () -> Boolean = { false },
+  private val onRetryPending: ((exception: IOException, isNetworkError: Boolean) -> Unit)? = null,
   private val transferListener: TransferListener? = null,
   private val getRequestConfig: (originalUrl: String) -> MediaRequestConfig?,
 ) : MediaSource.Factory {
@@ -45,16 +46,20 @@ class MediaFactory(
         RetryLoadErrorHandlingPolicy(
           maxRetries = null,
           maxRetryDurationMs = retryPolicy.maxRetryDurationMs,
+          firstConnectMaxRetryDurationMs = retryPolicy.firstConnectMaxRetryDurationMs,
           shouldRetry = shouldRetry,
           isOnline = isOnline,
+          hasPlayed = hasPlayed,
           onRetryPending = onRetryPending,
         )
       is RetryPolicy.Limited ->
         RetryLoadErrorHandlingPolicy(
           maxRetries = retryPolicy.maxRetries,
           maxRetryDurationMs = retryPolicy.maxRetryDurationMs,
+          firstConnectMaxRetryDurationMs = retryPolicy.firstConnectMaxRetryDurationMs,
           shouldRetry = shouldRetry,
           isOnline = isOnline,
+          hasPlayed = hasPlayed,
           onRetryPending = onRetryPending,
         )
     }
@@ -92,7 +97,14 @@ class MediaFactory(
     // JS thread to resolve.
     val httpFactory =
       DefaultHttpDataSource.Factory().apply {
-        setUserAgent(DEFAULT_USER_AGENT)
+        // Deliberately NOT setUserAgent(): DefaultHttpDataSource applies the factory
+        // user-agent as a FINAL setRequestProperty("User-Agent", …) that runs after —
+        // and overrides — the per-request DataSpec headers. That would clobber the
+        // User-Agent TransformingDataSource sets per request (the whole point of the
+        // per-request userAgent override). Supplying the same value as a default
+        // request property keeps the default for un-overridden requests while letting
+        // the per-request DataSpec header win.
+        setDefaultRequestProperties(mapOf("User-Agent" to DEFAULT_USER_AGENT))
         setAllowCrossProtocolRedirects(true)
         // Connect transfer listener for bandwidth measurement
         transferListener?.let { setTransferListener(it) }