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

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