react-native-audio-browser 0.2.0-next.8 → 0.2.0

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

@@ -1,7 +1,5 @@
 package com.audiobrowser.player
 
-import android.os.Handler
-import android.os.Looper
 import androidx.media3.common.MediaItem
 import androidx.media3.common.MediaMetadata
 import androidx.media3.common.Metadata
@@ -9,47 +7,19 @@ import androidx.media3.common.PlaybackException
 import androidx.media3.common.PlaybackParameters
 import androidx.media3.common.Player as MediaPlayer
 import androidx.media3.common.Timeline
-import androidx.media3.common.util.StuckPlayerException
 import com.audiobrowser.extension.NumberExt.Companion.toSeconds
 import com.audiobrowser.model.PlaybackMetadata
 import com.audiobrowser.util.MetadataAdapter
+import com.audiobrowser.util.PlayingStateFactory
 import com.audiobrowser.util.RepeatModeFactory
 import com.margelo.nitro.audiobrowser.PlaybackActiveTrackChangedEvent
 import com.margelo.nitro.audiobrowser.PlaybackError
-import com.margelo.nitro.audiobrowser.PlaybackErrorKind
+import com.margelo.nitro.audiobrowser.PlaybackPlayWhenReadyChangedEvent
 import com.margelo.nitro.audiobrowser.PlaybackState
 import java.util.Locale
 import timber.log.Timber
 
-// Continuous playback required to refill the stuck-recovery budget. Long enough that a stream which
-// keeps re-stalling can't "prove liveness" between stalls, short enough to forgive a single hiccup.
-private const val HEALTHY_PLAYBACK_MS = 20_000L
-
 class PlayerListener(private val player: Player) : MediaPlayer.Listener {
-  // Caps auto-recovery from media3 stuck-player detection before surfacing a terminal error.
-  private val stuckRecoveryPolicy = StuckRecoveryPolicy()
-
-  // Proof-of-life timer: the recovery budget refills only after the player sustains continuous
-  // playback for HEALTHY_PLAYBACK_MS, proving the stream actually delivered audio (not a brief blip
-  // before re-stalling). Mirrors AutomaticBufferManager's Handler usage. Runs on the main thread,
-  // where Player.Listener callbacks are delivered.
-  private val healthyPlaybackHandler = Handler(Looper.getMainLooper())
-  private val healthyPlaybackRunnable =
-    object : Runnable {
-      override fun run() {
-        stuckRecoveryPolicy.reset()
-        // Refill the load-error retry window too — it otherwise resets only
-        // on track change, so a second outage >2min after the first got zero
-        // retries (instant terminal error) on a long-lived stream.
-        player.resetRetryTimer()
-        // Re-post while playing: errors the buffer absorbs never flip
-        // isPlaying, so a one-shot refill left the window stale again.
-        if (player.isPlaying) {
-          healthyPlaybackHandler.postDelayed(this, HEALTHY_PLAYBACK_MS)
-        }
-      }
-    }
-
   /** Called when there is metadata associated with the current playback time. */
   override fun onMetadata(metadata: Metadata) {
     // Extract and emit chapter metadata if present
@@ -59,11 +29,7 @@ class PlayerListener(private val player: Player) : MediaPlayer.Listener {
     }
 
     // Extract and emit timed metadata (ICY, ID3, etc.)
-    PlaybackMetadata.from(metadata)?.let {
-      val timed = it.toNitro()
-      player.callbacks?.onTimedMetadata(timed)
-      player.nowPlaying.onTimedMetadataReceived(timed)
-    }
+    PlaybackMetadata.from(metadata)?.let { player.callbacks?.onTimedMetadata(it.toNitro()) }
   }
 
   override fun onMediaMetadataChanged(mediaMetadata: MediaMetadata) {
@@ -107,7 +73,7 @@ class PlayerListener(private val player: Player) : MediaPlayer.Listener {
 
     // Check if sleep timer should trigger on track end
     if (reason == MediaPlayer.MEDIA_ITEM_TRANSITION_REASON_AUTO) {
-      player.sleepTimer.onTrackEnd()
+      player.checkSleepTimerOnTrackEnd()
     }
 
     // Update last track info for next transition
@@ -118,66 +84,30 @@ class PlayerListener(private val player: Player) : MediaPlayer.Listener {
     player.updateFavoriteButtonState(player.currentTrack?.favorited)
 
     // Clear now playing override when track changes (new track = clean slate)
-    player.nowPlaying.clearOverride()
-
-    // Re-stamp the now-playing metadata for the new track. The browse-list
-    // MediaItem carries `artist = subtitle` (the per-context list line), but the
-    // now-playing screen / lock screen / Bluetooth should show the canonical
-    // `artist` (location). Android Auto derives both from the same MediaItem's
-    // `artist`, so we overwrite the playing item's metadata here (the same
-    // mechanism ICY song updates already use) to diverge it from the list items.
-    // This also fires onNowPlayingChanged, so we don't emit it separately below.
-    player.nowPlaying.render()
+    player.clearNowPlayingOverride()
 
-    // Reset retry timer so the new track gets fresh duration budgets, and mark
-    // the new load unproven — its failures get the short first-connect budget
-    // until it renders audio.
+    // Reset retry timer so new track gets fresh 2-minute window
     player.resetRetryTimer()
-    player.hasPlayedCache = false
-
-    // A retrying error belongs to the outgoing track; drop it (with its own emit —
-    // the incoming track may hold the state on LOADING/BUFFERING, emitting nothing).
-    player.clearRetryingError()
 
-    // A new station starts with a clean stuck-recovery budget, mirroring the retry timer reset.
-    healthyPlaybackHandler.removeCallbacks(healthyPlaybackRunnable)
-    stuckRecoveryPolicy.reset()
+    // Notify JS of the now playing metadata for the new track
+    player.getNowPlaying()?.let { player.callbacks?.onNowPlayingChanged(it) }
 
     player.playbackStateStore.save()
     player.playbackStateStore.resetPeriodicSave()
   }
 
-  /**
-   * Schedules a stuck-recovery budget refill once the player has been continuously playing for
-   * [HEALTHY_PLAYBACK_MS], and cancels it the moment playback stops (pause, rebuffer, stall,
-   * error). Sustained real playback is our proof the stream is alive and the budget can be trusted
-   * again.
-   */
-  override fun onIsPlayingChanged(isPlaying: Boolean) {
-    healthyPlaybackHandler.removeCallbacks(healthyPlaybackRunnable)
-    if (isPlaying) {
-      healthyPlaybackHandler.postDelayed(healthyPlaybackRunnable, HEALTHY_PLAYBACK_MS)
-    }
-  }
-
   /** Called when the value returned from Player.getPlayWhenReady() changes. */
   override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) {
-    // An explicit pause during the sleep fade is the timer's goal arriving early: clear the
-    // timer (restores the pre-fade volume). The timer's own completion cancels the fader
-    // before pausing, so it never re-enters here.
-    if (!playWhenReady && player.volumeFader.isActive) {
-      player.sleepTimer.clear()
-    }
-
-    // Update thread-safe cache for access from non-main threads (e.g., retry policy).
-    // Deliberately the second writer: Player.playWhenReady's setter writes eagerly so
-    // non-main readers see the new intent before ExoPlayer round-trips; this event is
-    // the authoritative sync for changes ExoPlayer makes on its own (e.g. audio focus).
+    // Update thread-safe cache for access from non-main threads (e.g., retry policy)
     player.playWhenReadyCache = playWhenReady
-    // Through the dedupe guard: the ENDED clear in setPlaybackState already
-    // emitted this change synchronously (ordered before queue-ended).
-    player.emitPlayWhenReadyChanged(playWhenReady)
-    player.refreshPlayingState()
+    player.callbacks?.onPlaybackPlayWhenReadyChanged(
+      PlaybackPlayWhenReadyChangedEvent(playWhenReady)
+    )
+    val newPlayingState = PlayingStateFactory.derive(playWhenReady, player.playbackState)
+    if (newPlayingState != player.playingState) {
+      player.playingState = newPlayingState
+      player.callbacks?.onPlaybackPlayingState(player.playingState)
+    }
 
     if (playWhenReady) {
       player.playbackStateStore.startPeriodicSave()
@@ -195,44 +125,56 @@ class PlayerListener(private val player: Player) : MediaPlayer.Listener {
     // Note that it is necessary to set `playerState` in order, since each mutation fires an
     // event.
     for (i in 0 until events.size()) {
-      // A new item clears any prior error even when no state transition follows (e.g. the queue
-      // was emptied) — silently, matching the pre-state-machine behavior. Kept out of the event
-      // mapping below so that stays pure; ordering within the batch is unchanged.
-      if (events[i] == MediaPlayer.EVENT_MEDIA_ITEM_TRANSITION) {
-        player.playbackError = null
-      }
-
-      val event =
-        when (events[i]) {
-          MediaPlayer.EVENT_PLAYBACK_STATE_CHANGED ->
-            // Read the real ExoPlayer state, not the forwarding player's — the InterceptingPlayer
-            // masks STATE_IDLE→READY on a terminal error, and that mask must not feed back into
-            // our own state machine (it would clear the ERROR state/subtitle).
-            PlaybackEvent.ExoPlaybackStateChanged(
-              player.exoPlayer.playbackState,
-              media3Player.mediaItemCount,
-              player.exoPlayer.playWhenReady,
-            )
-          MediaPlayer.EVENT_MEDIA_ITEM_TRANSITION ->
-            PlaybackEvent.MediaItemTransition(player.currentTrack != null, player.isPlaying)
-          MediaPlayer.EVENT_PLAY_WHEN_READY_CHANGED ->
-            PlaybackEvent.PlayWhenReadyChanged(player.playWhenReady)
-          MediaPlayer.EVENT_IS_PLAYING_CHANGED -> PlaybackEvent.IsPlayingChanged(player.isPlaying)
-          else -> null
-        } ?: continue
-
-      for (state in PlaybackStateMachine.transitions(player.playbackState, event)) {
-        player.setPlaybackState(state)
+      when (events[i]) {
+        MediaPlayer.EVENT_PLAYBACK_STATE_CHANGED -> {
+          val state =
+            when (media3Player.playbackState) {
+              MediaPlayer.STATE_BUFFERING -> PlaybackState.BUFFERING
+              MediaPlayer.STATE_READY -> PlaybackState.READY
+              MediaPlayer.STATE_IDLE ->
+                // Avoid transitioning to idle from error or stopped
+                if (
+                  player.playbackState == PlaybackState.ERROR ||
+                    player.playbackState == PlaybackState.STOPPED
+                )
+                  null
+                else PlaybackState.NONE
+              MediaPlayer.STATE_ENDED ->
+                if (media3Player.mediaItemCount > 0) PlaybackState.ENDED else PlaybackState.NONE
+              else -> null // noop
+            }
+          if (state != null && state != player.playbackState) {
+            // Clear error when recovering from ERROR state to a successful state
+            if (player.playbackState == PlaybackState.ERROR) {
+              player.playbackError = null
+            }
+            player.setPlaybackState(state)
+          }
+        }
+        MediaPlayer.EVENT_MEDIA_ITEM_TRANSITION -> {
+          player.playbackError = null
+          if (player.currentTrack != null) {
+            player.setPlaybackState(PlaybackState.LOADING)
+            if (player.isPlaying) {
+              player.setPlaybackState(PlaybackState.READY)
+              player.setPlaybackState(PlaybackState.PLAYING)
+            }
+          }
+        }
+        MediaPlayer.EVENT_PLAY_WHEN_READY_CHANGED -> {
+          if (!player.playWhenReady && player.playbackState != PlaybackState.STOPPED) {
+            player.setPlaybackState(PlaybackState.PAUSED)
+          }
+        }
+        MediaPlayer.EVENT_IS_PLAYING_CHANGED -> {
+          if (player.isPlaying) {
+            player.setPlaybackState(PlaybackState.PLAYING)
+          }
+        }
       }
     }
   }
 
-  override fun onPlayerErrorChanged(error: PlaybackException?) {
-    // The error clearing means a recovery path ran prepare() — a restart from
-    // terminal error, which begins a new load (see Player.resetForNewLoad).
-    if (error == null) player.resetForNewLoad()
-  }
-
   override fun onPlayerError(error: PlaybackException) {
     // Handle live stream recovery when playback position falls behind the live window
     if (error.errorCode == PlaybackException.ERROR_CODE_BEHIND_LIVE_WINDOW) {
@@ -242,84 +184,19 @@ class PlayerListener(private val player: Player) : MediaPlayer.Listener {
       return
     }
 
-    // media3 1.9.0+ stuck-player detection arrives here wrapped in a PlaybackException: the actual
-    // StuckPlayerException (an IllegalStateException, not a PlaybackException) sits in the cause
-    // chain, and the wrapper's errorCode varies by stuck type — so we detect by cause, not code.
-    // For a live-radio app a transient stall should reconnect, not stop playback.
-    val stuck =
-      generateSequence(error.cause) { it.cause }
-        .filterIsInstance<StuckPlayerException>()
-        .firstOrNull()
-    if (stuck != null) {
-      handleStuckPlayer(stuck)
-      return
-    }
-
-    val online = player.networkMonitor.getOnline()
-    // `code` stays the raw ExoPlayer name for telemetry; `kind` is the normalized classification
-    // consumers branch on. Offline is the one distinction ExoPlayer's codes cannot make on their
-    // own, so it overrides the code name too.
-    val code =
-      if (!online) {
-        "not-connected-to-internet"
-      } else {
+    val playbackError =
+      PlaybackError(
         error.errorCodeName
           .replace("ERROR_CODE_", "")
           .lowercase(Locale.getDefault())
-          .replace("_", "-")
-      }
-    val playbackError =
-      PlaybackError(
-        PlaybackErrorClassifier.classify(error, online),
-        code,
+          .replace("_", "-"),
         error.message ?: "An unknown error occurred",
-        PlaybackErrorClassifier.responseCode(error)?.toDouble(),
-        retrying = null,
       )
     player.callbacks?.onPlaybackError(playbackError)
     player.playbackError = playbackError
     player.setPlaybackState(PlaybackState.ERROR)
   }
 
-  /**
-   * Recovers from a media3 stuck-player detection or, once the recovery budget is exhausted,
-   * surfaces a distinct terminal error. Live items rejoin the live edge (a stale buffered live
-   * window is the common stuck cause); on-demand items re-prepare in place so the saved position is
-   * preserved.
-   */
-  private fun handleStuckPlayer(error: StuckPlayerException) {
-    // Defensive: media3 only fires stuck detection while playWhenReady is true, but never do
-    // recovery work for a deliberately-paused player (matches RetryLoadErrorHandlingPolicy).
-    if (!player.playWhenReady) return
-
-    when (stuckRecoveryPolicy.onStuck()) {
-      StuckRecoveryPolicy.Decision.RECOVER -> {
-        Timber.w(
-          "Stuck player recovery: type=${error.stuckType} timeoutMs=${error.timeoutMs} " +
-            "live=${player.isCurrentItemLive}"
-        )
-        if (player.isCurrentItemLive) {
-          player.exoPlayer.seekToDefaultPosition()
-        }
-        player.exoPlayer.prepare()
-      }
-      StuckRecoveryPolicy.Decision.GIVE_UP -> {
-        Timber.w("Stuck player recovery exhausted (type=${error.stuckType}), surfacing error")
-        val playbackError =
-          PlaybackError(
-            PlaybackErrorKind.STALLED,
-            "playback-stalled",
-            error.message ?: "Playback stalled",
-            null,
-            retrying = null,
-          )
-        player.callbacks?.onPlaybackError(playbackError)
-        player.playbackError = playbackError
-        player.setPlaybackState(PlaybackState.ERROR)
-      }
-    }
-  }
-
   override fun onRepeatModeChanged(repeatMode: Int) {
     val mode = RepeatModeFactory.fromMedia3(repeatMode)
     player.callbacks?.onPlaybackRepeatModeChanged(mode)
@@ -348,6 +225,6 @@ class PlayerListener(private val player: Player) : MediaPlayer.Listener {
 
   override fun onAudioSessionIdChanged(audioSessionId: Int) {
     Timber.d("Audio session ID changed to: $audioSessionId")
-    player.equalizer.onAudioSessionChanged(audioSessionId)
+    player.reinitializeEqualizer(audioSessionId)
   }
 }

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

@@ -1,14 +1,10 @@
 package com.audiobrowser.player
 
 import androidx.media3.common.C
-import androidx.media3.common.ParserException
-import androidx.media3.datasource.DataSourceException
+import androidx.media3.common.PlaybackException
 import androidx.media3.datasource.HttpDataSource
 import androidx.media3.exoplayer.upstream.DefaultLoadErrorHandlingPolicy
 import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
-import androidx.media3.exoplayer.upstream.Loader
-import java.io.FileNotFoundException
-import java.io.IOException
 import kotlin.math.min
 import kotlin.math.pow
 import timber.log.Timber
@@ -20,37 +16,19 @@ import timber.log.Timber
  * will use a shorter retry delay and the network restoration callback can trigger an immediate
  * retry when connectivity is restored.
  *
- * Two duration budgets apply, chosen by whether the current load has ever produced audio
- * ([hasPlayed]): a short first-connect budget — a stream that fails before ever playing is usually
- * dead, and the listener is actively waiting for a verdict — and the full recovery budget for a
- * stream that played and then dropped (tunnels, handovers, encoder restarts). The short budget
- * counts only online time, so a station tapped in a tunnel still gets its online seconds once
- * connectivity returns. Both budgets are enforced here at the policy level, never via ExoPlayer's
- * [LoadErrorHandlingPolicy.LoadErrorInfo.errorCount] — that counts per *loadable* (an HLS stream
- * has playlist and segment loadables, each with its own count), so it cannot express a per-load
- * promise.
- *
  * @param maxRetries Maximum number of retries, or null for infinite retries
- * @param maxRetryDurationMs Maximum duration to keep retrying before giving up, or null for default
- *   (2 minutes)
- * @param firstConnectMaxRetryDurationMs Maximum duration to keep retrying a load that has never
- *   produced audio, while online, or null for default (12 seconds)
+ * @param maxRetryDurationMs Maximum duration to keep retrying before giving up, or null for default (2 minutes)
  * @param shouldRetry Optional callback to check if retry should proceed (e.g., check playWhenReady)
  * @param isOnline Optional callback to check current network state
- * @param hasPlayed Optional callback: whether the current load has produced audio. Must be safe to
- *   call from ExoPlayer's loader thread (e.g. backed by a volatile cache).
- * @param onRetryPending Optional callback invoked when a retry is pending, with the load error
- *   being retried (for surfacing it while the retry runs, and for network restoration
- *   acceleration). Invoked on ExoPlayer's loader thread.
+ * @param onRetryPending Optional callback invoked when a retry is pending (for network restoration
+ *   acceleration)
  */
 class RetryLoadErrorHandlingPolicy(
   private val maxRetries: Int? = null,
   maxRetryDurationMs: Long? = null,
-  firstConnectMaxRetryDurationMs: Long? = null,
   private val shouldRetry: () -> Boolean = { true },
   private val isOnline: () -> Boolean = { true },
-  private val hasPlayed: () -> Boolean = { false },
-  private val onRetryPending: ((exception: IOException, isNetworkError: Boolean) -> Unit)? = null,
+  private val onRetryPending: ((isNetworkError: Boolean) -> Unit)? = null,
 ) : DefaultLoadErrorHandlingPolicy() {
 
   companion object {
@@ -64,8 +42,6 @@ class RetryLoadErrorHandlingPolicy(
     private const val OFFLINE_RETRY_DELAY_MS = 1000L
     // Default maximum duration to keep retrying before giving up (in milliseconds).
     private const val DEFAULT_MAX_RETRY_DURATION_MS = 120_000L // 2 minutes
-    // Default maximum duration for a load that has never produced audio, while online.
-    private const val DEFAULT_FIRST_CONNECT_MAX_RETRY_DURATION_MS = 12_000L
 
     // HTTP status codes that are worth retrying
     private val RETRYABLE_HTTP_STATUS_CODES =
@@ -83,41 +59,13 @@ class RetryLoadErrorHandlingPolicy(
   // This prevents surprising playback resumption after long periods offline.
   private val maxRetryDurationMs: Long = maxRetryDurationMs ?: DEFAULT_MAX_RETRY_DURATION_MS
 
-  private val firstConnectMaxRetryDurationMs: Long =
-    firstConnectMaxRetryDurationMs ?: DEFAULT_FIRST_CONNECT_MAX_RETRY_DURATION_MS
-
   // Track when we started retrying to enforce max duration
-  @Volatile private var firstErrorTime: Long? = null
-
-  // First error observed while online — the first-connect budget's clock. Never set while
-  // offline, and wiped by any offline observation, so an offline stretch cannot burn the short
-  // budget: the clock restarts at the next error observed online.
-  @Volatile private var firstOnlineErrorTime: Long? = null
+  @Volatile
+  private var firstErrorTime: Long? = null
 
   /** Resets the retry timer. Call when track changes. */
   fun reset() {
     firstErrorTime = null
-    firstOnlineErrorTime = null
-  }
-
-  /**
-   * The name of the exhausted budget, or null while budget remains. The recovery duration bounds
-   * everything (including offline waits); the first-connect duration additionally bounds
-   * never-played loads, online only.
-   */
-  private fun exhaustedBudget(currentTime: Long): String? {
-    firstErrorTime?.let { start ->
-      if (currentTime - start >= maxRetryDurationMs)
-        return "max retry duration ($maxRetryDurationMs ms)"
-    }
-    if (!hasPlayed() && isOnline()) {
-      firstOnlineErrorTime?.let { start ->
-        if (currentTime - start >= firstConnectMaxRetryDurationMs) {
-          return "first-connect retry duration ($firstConnectMaxRetryDurationMs ms)"
-        }
-      }
-    }
-    return null
   }
 
   /** Calculates exponential backoff delay: 1s -> 1.5s -> 2.3s -> 3.4s -> 5s (capped) */
@@ -128,6 +76,22 @@ class RetryLoadErrorHandlingPolicy(
     return min(exponentialDelay.toLong(), MAX_RETRY_DELAY_MS)
   }
 
+  /**
+   * Checks if an HTTP error is worth retrying based on status code. Only server errors (5xx) and
+   * specific client errors (408, 429) are retryable.
+   */
+  private fun isRetryableHttpError(exception: Throwable): Boolean {
+    // Check the exception chain for HttpDataSource.InvalidResponseCodeException
+    var current: Throwable? = exception
+    while (current != null) {
+      if (current is HttpDataSource.InvalidResponseCodeException) {
+        return current.responseCode in RETRYABLE_HTTP_STATUS_CODES
+      }
+      current = current.cause
+    }
+    return false
+  }
+
   override fun getRetryDelayMsFor(loadErrorInfo: LoadErrorHandlingPolicy.LoadErrorInfo): Long {
     val exception = loadErrorInfo.exception
     val errorCount = loadErrorInfo.errorCount
@@ -149,20 +113,15 @@ class RetryLoadErrorHandlingPolicy(
     if (firstErrorTime == null) {
       firstErrorTime = currentTime
     }
-    if (isOnline()) {
-      if (firstOnlineErrorTime == null) firstOnlineErrorTime = currentTime
-    } else {
-      // Seeing the device offline restarts the first-connect clock: a station that lost
-      // connectivity mid-budget gets its full online seconds again after restoration,
-      // instead of the offline gap counting against it.
-      firstOnlineErrorTime = null
-    }
 
-    // Check if we've been retrying too long (prevents surprising resumption after long
-    // offline periods, and grants dead-on-arrival streams a fast verdict)
-    exhaustedBudget(currentTime)?.let { budget ->
-      Timber.d("$budget exceeded, giving up")
-      return C.TIME_UNSET
+    // Check if we've been retrying too long (prevents surprising resumption after long offline)
+    val startTime = firstErrorTime
+    if (startTime != null) {
+      val elapsed = currentTime - startTime
+      if (elapsed >= maxRetryDurationMs) {
+        Timber.d("Max retry duration (${maxRetryDurationMs}ms) exceeded after ${elapsed}ms, giving up")
+        return C.TIME_UNSET
+      }
     }
 
     // Classify the error
@@ -189,64 +148,40 @@ class RetryLoadErrorHandlingPolicy(
       )
 
       // Notify that a retry is pending (for network restoration acceleration)
-      onRetryPending?.invoke(exception, isNetworkError)
+      onRetryPending?.invoke(isNetworkError)
 
       delay
     } else {
-      // Non-recoverable error: stop now. We can't delegate to super here —
-      // DefaultLoadErrorHandlingPolicy still schedules a backoff retry for some errors it doesn't
-      // consider fatal (e.g. a 404 InvalidResponseCodeException), which combined with our infinite
-      // getMinimumLoadableRetryCount would retry a dead URL until the max-retry-duration timeout.
-      C.TIME_UNSET
+      // For non-recoverable errors, use default behavior (no retry)
+      super.getRetryDelayMsFor(loadErrorInfo)
     }
   }
 
   /** Classification result for an error */
   private data class ErrorClassification(val isRecoverable: Boolean, val isNetworkError: Boolean)
 
-  /**
-   * Classifies whether an error is recoverable and whether it's network-related.
-   *
-   * Load errors are delivered as a raw [IOException] (e.g.
-   * [HttpDataSource.HttpDataSourceException], `UnknownHostException`, `SocketTimeoutException`) —
-   * never as a `PlaybackException`, which is only surfaced at the player level *after* retries are
-   * exhausted. So we classify by walking the IOException cause chain. This is essential: a plain
-   * Wi-Fi drop surfaces as a socket/DNS IOException, and unless we flag it as a network error the
-   * connectivity-restoration path can't fire an immediate retry, leaving playback stuck buffering
-   * until it returns.
-   */
-  private fun classifyError(exception: IOException): ErrorClassification {
-    val nonRecoverable = ErrorClassification(isRecoverable = false, isNetworkError = false)
-
-    var current: Throwable? = exception
-    while (current != null) {
-      when (current) {
-        // HTTP responses: only retry server errors (5xx) and specific client errors (408, 429).
-        // Other status codes (e.g. 403/404) will never succeed on retry.
-        is HttpDataSource.InvalidResponseCodeException -> {
-          val retryable = current.responseCode in RETRYABLE_HTTP_STATUS_CODES
-          return ErrorClassification(isRecoverable = retryable, isNetworkError = retryable)
+  /** Classifies whether an error is recoverable and whether it's network-related */
+  private fun classifyError(exception: Throwable): ErrorClassification {
+    return when {
+      exception is PlaybackException -> {
+        when (exception.errorCode) {
+          // Clearly transient network errors
+          PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED,
+          PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_TIMEOUT ->
+            ErrorClassification(isRecoverable = true, isNetworkError = true)
+          // HTTP errors - retry on server errors and specific client errors
+          PlaybackException.ERROR_CODE_IO_BAD_HTTP_STATUS -> {
+            val isRetryable = isRetryableHttpError(exception)
+            ErrorClassification(isRecoverable = isRetryable, isNetworkError = isRetryable)
+          }
+          else -> ErrorClassification(isRecoverable = false, isNetworkError = false)
         }
-        // Errors that retrying cannot fix — mirror DefaultLoadErrorHandlingPolicy's
-        // non-retryable set so we don't spin until the max-retry-duration timeout.
-        is HttpDataSource.CleartextNotPermittedException,
-        is ParserException,
-        is FileNotFoundException,
-        is Loader.UnexpectedLoaderException -> return nonRecoverable
       }
-      current = current.cause
-    }
-
-    // A read at a position the source can no longer provide (e.g. behind a live window) won't
-    // recover via an in-place loader retry.
-    if (DataSourceException.isCausedByPositionOutOfRange(exception)) {
-      return nonRecoverable
+      // HTTP errors outside PlaybackException wrapper
+      isRetryableHttpError(exception) ->
+        ErrorClassification(isRecoverable = true, isNetworkError = true)
+      else -> ErrorClassification(isRecoverable = false, isNetworkError = false)
     }
-
-    // Any other IOException is a transient network/transport failure (connection reset, DNS
-    // failure, socket timeout, network interface lost, ...): recoverable, and flagged as a network
-    // error so connectivity restoration can trigger an immediate retry.
-    return ErrorClassification(isRecoverable = true, isNetworkError = true)
   }
 
   override fun getMinimumLoadableRetryCount(dataType: Int): Int {