react-native-nitro-player 1.7.0-alpha.4 → 1.7.0-alpha.5

package/android/src/main/AndroidManifest.xml

@@ -18,6 +18,14 @@
         android:name="android.hardware.audio.output"
         android:required="false" />
 
+    <!-- Visibility of Android Auto's connection-state provider; without it the car never reads as connected -->
+    <queries>
+        <provider
+            android:name="androidx.car.app.connection.provider"
+            android:authorities="androidx.car.app.connection"
+            tools:ignore="MissingClass" />
+    </queries>
+
     <application>
         <!-- Google Cast: supplies CastOptions (receiver app ID) to the Cast SDK.
              Apps shipping their own OptionsProvider must override with tools:replace. -->

package/android/src/main/java/com/margelo/nitro/nitroplayer/HybridAndroidAutoMediaLibrary.kt

@@ -1,15 +1,21 @@
 package com.margelo.nitro.nitroplayer
 
 import androidx.annotation.Keep
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.session.CommandButton
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.NitroModules
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.nitroplayer.core.TrackPlayerCore
 import com.margelo.nitro.nitroplayer.core.clearAndroidAutoMediaLibrary
 import com.margelo.nitro.nitroplayer.core.setAndroidAutoMediaLibrary
+import com.margelo.nitro.nitroplayer.media.MediaSessionManager
+import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
+import org.json.JSONArray
 
 @DoNotStrip
 @Keep
+@UnstableApi
 class HybridAndroidAutoMediaLibrary : HybridAndroidAutoMediaLibrarySpec() {
     private val core: TrackPlayerCore
 
@@ -23,4 +29,49 @@ class HybridAndroidAutoMediaLibrary : HybridAndroidAutoMediaLibrarySpec() {
     override fun setMediaLibrary(libraryJson: String): Promise<Unit> = Promise.async { core.setAndroidAutoMediaLibrary(libraryJson) }
 
     override fun clearMediaLibrary(): Promise<Unit> = Promise.async { core.clearAndroidAutoMediaLibrary() }
+
+    override fun onLoadChildren(callback: (requestId: String, parentId: String) -> Unit) {
+        core.mediaLibraryManager.childrenRequester = callback
+    }
+
+    override fun onSearch(callback: (requestId: String, query: String) -> Unit) {
+        core.mediaLibraryManager.searchRequester = callback
+        NitroPlayerMediaBrowserService.setSearchSupported(core.context, true)
+    }
+
+    override fun resolveRequest(
+        requestId: String,
+        itemsJson: String,
+    ) = core.mediaLibraryManager.resolve(requestId, itemsJson)
+
+    override fun setSessionButtons(buttonsJson: String) {
+        val array = JSONArray(buttonsJson)
+        val buttons =
+            (0 until array.length()).mapNotNull { i ->
+                val button = array.getJSONObject(i)
+                val icon = ICONS[button.optString("icon")] ?: return@mapNotNull null
+                MediaSessionManager.SessionButton(button.getString("action"), button.optString("title"), icon)
+            }
+        core.enqueue { core.mediaSessionManager?.setSessionButtons(buttons) }
+    }
+
+    override fun onSessionButtonPress(callback: (action: String) -> Unit) {
+        core.enqueue { core.mediaSessionManager?.onSessionButtonPress = callback }
+    }
+
+    override fun onPlaybackResumption(callback: () -> Unit) = core.mediaLibraryManager.setResumptionRequester(callback)
+
+    private companion object {
+        val ICONS =
+            mapOf(
+                "heart" to CommandButton.ICON_HEART_UNFILLED,
+                "heart_filled" to CommandButton.ICON_HEART_FILLED,
+                "star" to CommandButton.ICON_STAR_UNFILLED,
+                "star_filled" to CommandButton.ICON_STAR_FILLED,
+                "thumb_up" to CommandButton.ICON_THUMB_UP_UNFILLED,
+                "thumb_up_filled" to CommandButton.ICON_THUMB_UP_FILLED,
+                "plus" to CommandButton.ICON_PLUS,
+                "check" to CommandButton.ICON_CHECK_CIRCLE_FILLED,
+            )
+    }
 }

package/android/src/main/java/com/margelo/nitro/nitroplayer/connection/AndroidAutoConnectionDetector.kt

@@ -59,9 +59,9 @@ class AndroidAutoConnectionDetector(
         try {
             val filter = IntentFilter(ACTION_CAR_CONNECTION_UPDATED)
 
-            // For Android 14+ (API 34+), we need to specify the receiver flags
+            // Exported: the broadcast comes from the Android Auto app, a NOT_EXPORTED receiver never gets it
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-                context.registerReceiver(carConnectionReceiver, filter, Context.RECEIVER_NOT_EXPORTED)
+                context.registerReceiver(carConnectionReceiver, filter, Context.RECEIVER_EXPORTED)
             } else {
                 context.registerReceiver(carConnectionReceiver, filter)
             }

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/ExoPlayerCore.kt

@@ -1,5 +1,6 @@
 package com.margelo.nitro.nitroplayer.core
 
+import android.net.Uri
 import androidx.media3.common.MediaItem
 import androidx.media3.common.Player
 
@@ -42,7 +43,18 @@ class ExoPlayerCore(
     fun getPlaybackSpeed(): Float = player.playbackParameters.speed
 
     // ── Queue mutations ────────────────────────────────────────────────────
-    fun prepare() = player.prepare()
+    // A lazy track's empty URI fails as "Source error"; stay idle until updateTracks supplies it
+    fun prepare() {
+        if (isLazyCurrent()) return
+        player.prepare()
+    }
+
+    // A prepared player loads a new current item by itself, so idle it while that item still has no URI
+    fun holdLazyCurrent() {
+        if (isLazyCurrent() && player.playbackState != Player.STATE_IDLE) player.stop()
+    }
+
+    private fun isLazyCurrent(): Boolean = player.currentMediaItem?.localConfiguration?.uri == Uri.EMPTY
 
     fun seekToDefaultPosition(windowIndex: Int) = player.seekToDefaultPosition(windowIndex)
 
@@ -51,7 +63,10 @@ class ExoPlayerCore(
     fun setMediaItems(
         items: List<MediaItem>,
         resetPosition: Boolean = false,
-    ) = player.setMediaItems(items, resetPosition)
+    ) {
+        player.setMediaItems(items, resetPosition)
+        holdLazyCurrent()
+    }
 
     fun addMediaItems(items: List<MediaItem>) = player.addMediaItems(items)
 

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/NitroPlayerLogger.kt

@@ -4,8 +4,8 @@ import android.util.Log
 import com.margelo.nitro.nitroplayer.BuildConfig
 
 object NitroPlayerLogger {
-    // Determine if logging is enabled based on build config
-    val isEnabled: Boolean = BuildConfig.DEBUG
+    // Release builds log after `adb shell setprop log.tag.NitroPlayer DEBUG` and an app restart
+    val isEnabled: Boolean = BuildConfig.DEBUG || Log.isLoggable("NitroPlayer", Log.DEBUG)
 
     /**
      * Preferred overload: message lambda is only evaluated when logging is enabled.

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerAndroidAuto.kt

@@ -3,7 +3,9 @@
 package com.margelo.nitro.nitroplayer.core
 
 import com.margelo.nitro.nitroplayer.connection.AndroidAutoConnectionDetector
+import com.margelo.nitro.nitroplayer.media.MediaItem
 import com.margelo.nitro.nitroplayer.media.MediaLibraryParser
+import com.margelo.nitro.nitroplayer.media.MediaType
 import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 
 /**
@@ -13,56 +15,64 @@ import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 
 /** Called on the main thread from TrackPlayerCore.init via handler.post. */
 internal fun TrackPlayerCore.setupAndroidAutoDetector() {
+    // The car may have bound the browser before this core existed (cold start from the car)
+    if (NitroPlayerMediaBrowserService.isAndroidAutoConnected) setAndroidAutoConnected(true)
     androidAutoConnectionDetector =
         AndroidAutoConnectionDetector(context).apply {
             onConnectionChanged = { connected, _ ->
-                handler.post {
-                    isAndroidAutoConnectedField = connected
-                    NitroPlayerMediaBrowserService.isAndroidAutoConnected = connected
-                    notifyAndroidAutoConnection(connected)
-                }
+                handler.post { setAndroidAutoConnected(connected) }
             }
             registerCarConnectionReceiver()
         }
 }
 
-/** Called by MediaBrowserService when the user picks a track in Android Auto. */
-suspend fun TrackPlayerCore.playFromPlaylistTrack(mediaId: String) =
-    withPlayerContext {
-        try {
-            val colonIndex = mediaId.indexOf(':')
-            if (colonIndex <= 0 || colonIndex >= mediaId.length - 1) return@withPlayerContext
-            val playlistId = mediaId.substring(0, colonIndex)
-            val trackId = mediaId.substring(colonIndex + 1)
-            val playlist = playlistManager.getPlaylist(playlistId) ?: return@withPlayerContext
-            val trackIndex = playlist.tracks.indexOfFirst { it.id == trackId }
-            if (trackIndex < 0) return@withPlayerContext
-            if (currentPlaylistId != playlistId) {
-                loadPlaylistInternal(playlistId)
-            }
-            playFromIndexInternal(trackIndex)
-        } catch (_: Exception) {
+/** Android Auto binding the browser is proof of a connection, whatever the provider query said. */
+internal fun TrackPlayerCore.onAndroidAutoBrowserConnected() {
+    handler.post { setAndroidAutoConnected(true) }
+}
+
+private fun TrackPlayerCore.setAndroidAutoConnected(connected: Boolean) {
+    NitroPlayerMediaBrowserService.isAndroidAutoConnected = connected
+    if (isAndroidAutoConnectedField == connected) return
+    isAndroidAutoConnectedField = connected
+    updateJsKeepAlive()
+    notifyAndroidAutoConnection(connected)
+}
+
+/** Routes a controller's "playlistId:trackId" pick through the logical queue (window + lazy URLs); false for unknown ids. */
+internal fun TrackPlayerCore.playFromMediaId(mediaId: String): Boolean {
+    val colonIndex = mediaId.indexOf(':')
+    if (colonIndex <= 0) return false
+    val playlistId = mediaId.substring(0, colonIndex)
+    val trackRef = mediaId.substring(colonIndex + 1)
+    if (playlistManager.indexOfTrackRef(playlistId, trackRef) < 0) return false
+    startJsRuntimeIfNeeded()
+    enqueue {
+        val index = playlistManager.indexOfTrackRef(playlistId, trackRef)
+        // Resuming what is already loaded keeps its position; a failed item is reloaded instead
+        if (currentPlaylistId == playlistId && currentTrackIndex == index && exo.player.playerError == null) {
+            // Tapping a song still waiting for its URL asks the app for it again
+            if (getCurrentTrack()?.url.isNullOrEmpty()) checkUpcomingTracksForUrls(lookaheadCount, force = true)
+            return@enqueue
         }
+        if (index >= 0 && playlistManager.loadPlaylist(playlistId, index)) loadPlaylistOnQueue(playlistId, index)
     }
-
-private fun TrackPlayerCore.loadPlaylistInternal(playlistId: String) {
-    playNextStack.clear()
-    upNextQueue.clear()
-    currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
-    val playlist = playlistManager.getPlaylist(playlistId) ?: return
-    currentPlaylistId = playlistId
-    updatePlayerQueue(playlist.tracks)
+    return true
 }
 
+private fun folderIds(items: List<MediaItem>?): List<String> = items.orEmpty().filter { it.mediaType == MediaType.FOLDER }.flatMap { listOf(it.id) + folderIds(it.children) }
+
 suspend fun TrackPlayerCore.setAndroidAutoMediaLibrary(libraryJson: String) =
     withPlayerContext {
         val library = MediaLibraryParser.fromJson(libraryJson)
+        val previous = folderIds(mediaLibraryManager.getMediaLibrary()?.rootItems)
         mediaLibraryManager.setMediaLibrary(library)
-        NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
+        NitroPlayerMediaBrowserService.getInstance()?.onLibraryUpdated(previous + folderIds(library.rootItems) + mediaLibraryManager.loadedFolderIds)
     }
 
 suspend fun TrackPlayerCore.clearAndroidAutoMediaLibrary() =
     withPlayerContext {
+        val previous = folderIds(mediaLibraryManager.getMediaLibrary()?.rootItems)
         mediaLibraryManager.clear()
-        NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
+        NitroPlayerMediaBrowserService.getInstance()?.onLibraryUpdated(previous + mediaLibraryManager.loadedFolderIds)
     }

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerCast.kt

@@ -88,7 +88,7 @@ internal fun TrackPlayerCore.switchToLocalPlayer() {
     lastCastWaitTrackId = null
     exo = ExoPlayerCore(controller.localPlayer)
     playerListener?.let { controller.localPlayer.addListener(it) }
-    setMediaSessionPlayer(controller.localPlayer)
+    setMediaSessionPlayer(controller.localSessionPlayer)
 
     val localList = ArrayList<TrackItem>()
     currentTrack?.let { localList.add(it) }

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerCore.kt

@@ -12,6 +12,11 @@ import android.os.Bundle
 import android.os.Handler
 import android.os.IBinder
 import android.os.Looper
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.jstasks.HeadlessJsTaskConfig
+import com.facebook.react.jstasks.HeadlessJsTaskContext
 import com.margelo.nitro.NitroModules
 import com.margelo.nitro.nitroplayer.Reason
 import com.margelo.nitro.nitroplayer.RepeatMode
@@ -83,6 +88,9 @@ class TrackPlayerCore private constructor(
     internal var remoteSkipForwardIntervalMs: Long = ExoPlayerBuilder.DEFAULT_REMOTE_SKIP_INTERVAL_MS
     internal var remoteSkipBackwardIntervalMs: Long = ExoPlayerBuilder.DEFAULT_REMOTE_SKIP_INTERVAL_MS
     internal var playerListener: androidx.media3.common.Player.Listener? = null
+    internal var consecutiveSourceErrors = 0
+    internal val urlRequestedAt = HashMap<String, Long>()
+    internal var networkRetryCallback: android.net.ConnectivityManager.NetworkCallback? = null
 
     // ── Temporary queue ────────────────────────────────────────────────────
     internal var playNextStack: MutableList<TrackItem> = mutableListOf()
@@ -161,7 +169,10 @@ class TrackPlayerCore private constructor(
         val anchor = old.getOrNull(currentTrackIndex)
         currentTracks = next
         if (anchor == null) return AnchorOutcome.NONE
-        val newIndex = next.indexOfFirst { it.id == anchor.id }
+        // A repeated track keeps its rank among the occurrences, so editing elsewhere does not jump to another copy
+        val rank = old.subList(0, currentTrackIndex).count { it.id == anchor.id }
+        val occurrences = next.indices.filter { next[it].id == anchor.id }
+        val newIndex = occurrences.getOrElse(rank) { occurrences.lastOrNull() ?: -1 }
         if (newIndex >= 0) {
             currentTrackIndex = newIndex
             return AnchorOutcome.KEPT
@@ -251,6 +262,7 @@ class TrackPlayerCore private constructor(
     // ── Singleton ──────────────────────────────────────────────────────────
     companion object {
         internal const val PROGRESS_INTERVAL_MS = 1000L
+        private const val KEEP_ALIVE_TASK = "NitroPlayerKeepAlive"
 
         @Volatile
         @Suppress("ktlint:standard:property-naming")
@@ -393,6 +405,34 @@ class TrackPlayerCore private constructor(
         }
     }
 
+    /** Lazy URLs come from JS; a process started by the car or a controller has no runtime until started. */
+    internal fun startJsRuntimeIfNeeded() {
+        val host = (context as? ReactApplication)?.reactHost ?: return
+        if (host.currentReactContext == null) host.start()
+    }
+
+    private var keepAliveTask: Pair<ReactContext, Int>? = null
+
+    /** Without a resumed activity (car, screen off) RN pauses JS timers; a headless task keeps them running while JS may be needed. */
+    internal fun updateJsKeepAlive() {
+        val wanted = isAndroidAutoConnectedField || (isExoInitialized && exo.playWhenReady)
+        val reactContext = (context as? ReactApplication)?.reactHost?.currentReactContext
+        keepAliveTask?.let { (taskContext, taskId) ->
+            val tasks = HeadlessJsTaskContext.getInstance(taskContext)
+            if (wanted && taskContext === reactContext && tasks.isTaskRunning(taskId)) return
+            if (tasks.isTaskRunning(taskId)) tasks.finishTask(taskId)
+            keepAliveTask = null
+        }
+        if (!wanted || reactContext == null || !reactContext.hasActiveReactInstance()) return
+        try {
+            val config = HeadlessJsTaskConfig(KEEP_ALIVE_TASK, Arguments.createMap(), 0, true)
+            keepAliveTask = reactContext to HeadlessJsTaskContext.getInstance(reactContext).startTask(config)
+            NitroPlayerLogger.log("TrackPlayerCore") { "keep-alive task started: ${keepAliveTask?.second}" }
+        } catch (e: Exception) {
+            NitroPlayerLogger.log("TrackPlayerCore") { "keep-alive task not started: ${e.message}" }
+        }
+    }
+
     // ── Simple read-only accessors ─────────────────────────────────────────
 
     fun isAndroidAutoConnected(): Boolean = isAndroidAutoConnectedField
@@ -421,7 +461,12 @@ class TrackPlayerCore private constructor(
 
     fun removeOnPlaybackProgressChangeListener(id: Long): Boolean = onProgressListeners.remove(id)
 
-    fun addOnTracksNeedUpdateListener(cb: (List<TrackItem>, Int) -> Unit): Long = onTracksNeedUpdateListeners.add(cb)
+    fun addOnTracksNeedUpdateListener(cb: (List<TrackItem>, Int) -> Unit): Long {
+        val id = onTracksNeedUpdateListeners.add(cb)
+        // Requests raised before JS was listening (headless start) are otherwise lost
+        enqueue { checkUpcomingTracksForUrls(lookaheadCount, force = true) }
+        return id
+    }
 
     fun removeOnTracksNeedUpdateListener(id: Long): Boolean = onTracksNeedUpdateListeners.remove(id)
 

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerListener.kt

@@ -31,6 +31,7 @@ internal class TrackPlayerEventListener(
         with(core) {
             // TRACK repeat: REPEAT_MODE_ONE fires this every loop — not a real track change
             if (reason == Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT) return
+            exo.holdLazyCurrent()
 
             // Remove the track that just finished/was skipped from temp lists
             if ((
@@ -61,7 +62,9 @@ internal class TrackPlayerEventListener(
             val previousTrackIndex = currentTrackIndex
             if (currentTemporaryType == TrackPlayerCore.TemporaryType.NONE && mediaItem != null) {
                 val trackId = extractTrackId(mediaItem.mediaId)
-                val newIdx = currentTracks.indexOfFirst { it.id == trackId }
+                // Moving through the timeline lands on the next occurrence of a repeated track, not its first
+                val advancing = reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO || reason == Player.MEDIA_ITEM_TRANSITION_REASON_SEEK
+                val newIdx = currentTrackIndexOf(trackId, if (advancing) currentTrackIndex + 1 else currentTrackIndex)
                 if (newIdx >= 0 && newIdx != currentTrackIndex) currentTrackIndex = newIdx
             }
             // A transient play-out ends here: restore the user's repeat mode.
@@ -137,6 +140,7 @@ internal class TrackPlayerEventListener(
         reason: Int,
     ) {
         val r = if (reason == Player.PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST) Reason.USER_ACTION else null
+        core.updateJsKeepAlive()
         core.emitStateChange(r)
     }
 
@@ -156,7 +160,10 @@ internal class TrackPlayerEventListener(
     }
 
     override fun onIsPlayingChanged(isPlaying: Boolean) {
-        if (isPlaying) core.startProgressTicks()
+        if (isPlaying) {
+            core.startProgressTicks()
+            core.onPlaybackHealthy()
+        }
         core.emitStateChange()
     }
 
@@ -173,21 +180,7 @@ internal class TrackPlayerEventListener(
         }
     }
 
-    override fun onPlayerError(error: PlaybackException) {
-        with(core) {
-            NitroPlayerLogger.log(
-                "TrackPlayer",
-                "Player error: ${error.errorCodeName} - ${error.message}",
-            )
-            notifyPlaybackStateChange(TrackPlayerState.STOPPED, Reason.ERROR)
-            // A source error leaves ExoPlayer in IDLE; skip the dead item and
-            // re-prepare so the rest of the queue keeps playing.
-            if (exo.hasNextMediaItem()) {
-                exo.seekToNext()
-                exo.prepare()
-            }
-        }
-    }
+    override fun onPlayerError(error: PlaybackException) = core.handlePlayerError(error)
 
     override fun onAudioSessionIdChanged(audioSessionId: Int) {
         if (audioSessionId != 0) {

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerNotify.kt

@@ -43,7 +43,12 @@ internal fun TrackPlayerCore.notifyTracksNeedUpdate(
     tracks: List<TrackItem>,
     lookahead: Int,
 ) {
+    NitroPlayerLogger.log("TrackPlayer") { "tracksNeedUpdate: ${tracks.size} track(s), listening=${!onTracksNeedUpdateListeners.isEmpty}" }
+    startJsRuntimeIfNeeded()
+    updateJsKeepAlive()
     onTracksNeedUpdateListeners.forEach { it(tracks, lookahead) }
+    // A lookup that hits a dead network usually fails in the app; ask again once it is back
+    awaitNetworkThenRetry(afterLoss = isNetworkValidated())
 }
 
 internal fun TrackPlayerCore.notifyTimedMetadata(metadata: TimedMetadata) {

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerPlayback.kt

@@ -123,8 +123,10 @@ internal fun TrackPlayerCore.setVolumeOnQueue(volume: Double) {
 suspend fun TrackPlayerCore.configure(config: PlayerConfig) = withPlayerContext { configureOnQueue(config) }
 
 internal fun TrackPlayerCore.configureOnQueue(config: PlayerConfig) {
+    // JS is calling, so the keep-alive task is registered: start it now if a headless start needs it
+    updateJsKeepAlive()
     config.androidAudioFocus?.let { applyAudioFocusMode(it) }
-    config.androidAutoEnabled?.let { NitroPlayerMediaBrowserService.isAndroidAutoEnabled = it }
+    config.androidAutoEnabled?.let { NitroPlayerMediaBrowserService.setAndroidAutoEnabled(context, it) }
     config.lookaheadCount?.let { lookaheadCount = it.toInt() }
     config.androidNotificationIcon?.let { NitroPlayerPlaybackService.notificationSmallIconResName = it }
     remoteSkipIntervalMs(config.remoteSkipForwardInterval)?.let { remoteSkipForwardIntervalMs = it }

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerQueueBuild.kt

@@ -46,6 +46,20 @@ internal fun TrackPlayerCore.castableUpcoming(tracks: List<TrackItem>): List<Tra
  */
 internal const val QUEUE_WINDOW_SIZE = 4
 
+/** Index of [trackId] in currentTracks; a repeated track resolves to its first occurrence at or after [from], wrapping. */
+internal fun TrackPlayerCore.currentTrackIndexOf(
+    trackId: String,
+    from: Int,
+): Int {
+    val size = currentTracks.size
+    val start = if (from in 0 until size) from else 0
+    for (k in 0 until size) {
+        val i = (start + k) % size
+        if (currentTracks[i].id == trackId) return i
+    }
+    return -1
+}
+
 internal fun TrackPlayerCore.mediaIdFor(track: TrackItem): String {
     val playlistId = currentPlaylistId ?: ""
     return if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
@@ -118,7 +132,7 @@ internal fun TrackPlayerCore.rebuildQueueFromCurrentPosition() {
     // Keep the logical playlist pointer in sync after playlist mutations.
     // Without this, getActualQueue/getState can report a stale index until the next track transition.
     if (currentTemporaryType == TrackPlayerCore.TemporaryType.NONE && currentTrackId != null) {
-        val resolvedIndex = currentTracks.indexOfFirst { it.id == currentTrackId }
+        val resolvedIndex = currentTrackIndexOf(currentTrackId, currentTrackIndex)
         if (resolvedIndex >= 0) {
             currentTrackIndex = resolvedIndex
         }
@@ -268,6 +282,7 @@ internal fun TrackPlayerCore.makeMediaItem(
             .setTitle(track.title)
             .setArtist(track.artist)
             .setAlbumTitle(track.album)
+    if (track.duration > 0) metaBuilder.setDurationMs((track.duration * 1000).toLong())
 
     track.artwork?.asSecondOrNull()?.let { artworkUrl ->
         try {

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerRecovery.kt

@@ -0,0 +1,97 @@
+@file:Suppress("ktlint:standard:max-line-length")
+
+package com.margelo.nitro.nitroplayer.core
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import androidx.media3.common.PlaybackException
+import androidx.media3.common.Player
+import com.margelo.nitro.nitroplayer.Reason
+import com.margelo.nitro.nitroplayer.TrackPlayerState
+
+// Lost network waits for connectivity and retries the same item; bad sources skip, capped so an unplayable queue stops
+
+internal const val MAX_CONSECUTIVE_SOURCE_ERRORS = 3
+
+internal fun TrackPlayerCore.handlePlayerError(error: PlaybackException) {
+    NitroPlayerLogger.log("TrackPlayer") { "Player error: ${error.errorCodeName} - ${error.message}" }
+    // Still waiting for its URL: updateTracks re-prepares it, skipping would cascade through the window
+    if (getCurrentTrack()?.url?.isEmpty() == true) {
+        checkUpcomingTracksForUrls(lookaheadCount, force = true)
+        return
+    }
+    notifyPlaybackStateChange(TrackPlayerState.STOPPED, Reason.ERROR)
+    if (error.isConnectivityError() && !isNetworkValidated()) {
+        awaitNetworkThenRetry()
+        return
+    }
+    consecutiveSourceErrors++
+    if (consecutiveSourceErrors >= MAX_CONSECUTIVE_SOURCE_ERRORS) return
+    // A source error leaves ExoPlayer in IDLE; skip the dead item and re-prepare so the rest of the queue keeps playing
+    if (!exo.hasNextMediaItem()) rebuildQueueFromCurrentPosition()
+    if (exo.hasNextMediaItem()) {
+        exo.seekToNext()
+        exo.prepare()
+    }
+}
+
+/** Called when playback actually starts, so earlier failures stop counting against the queue. */
+internal fun TrackPlayerCore.onPlaybackHealthy() {
+    consecutiveSourceErrors = 0
+}
+
+private fun PlaybackException.isConnectivityError(): Boolean =
+    errorCode == PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED ||
+        errorCode == PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_TIMEOUT
+
+private fun TrackPlayerCore.connectivity(): ConnectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+
+internal fun TrackPlayerCore.isNetworkValidated(): Boolean {
+    val manager = connectivity()
+    val capabilities = manager.getNetworkCapabilities(manager.activeNetwork) ?: return false
+    return capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+}
+
+/** Retries once the network is back; [afterLoss] first waits for it to drop, for work started while it was up. */
+internal fun TrackPlayerCore.awaitNetworkThenRetry(afterLoss: Boolean = false) {
+    if (networkRetryCallback != null) return
+    val callback =
+        object : ConnectivityManager.NetworkCallback() {
+            private var lost = !afterLoss
+            private var seen: Network? = null
+
+            override fun onLost(network: Network) {
+                lost = true
+            }
+
+            override fun onCapabilitiesChanged(
+                network: Network,
+                capabilities: NetworkCapabilities,
+            ) {
+                // Switching networks (Wi-Fi to mobile) breaks requests in flight just like a drop
+                if (seen != null && seen != network) lost = true
+                seen = network
+                if (!capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)) {
+                    lost = true
+                } else if (lost) {
+                    enqueue { retryAfterNetwork(this) }
+                }
+            }
+        }
+    networkRetryCallback = callback
+    connectivity().registerDefaultNetworkCallback(callback)
+}
+
+private fun TrackPlayerCore.retryAfterNetwork(callback: ConnectivityManager.NetworkCallback) {
+    if (networkRetryCallback !== callback) return
+    networkRetryCallback = null
+    try {
+        connectivity().unregisterNetworkCallback(callback)
+    } catch (_: IllegalArgumentException) {
+    }
+    // URLs the app could not fetch offline are asked for again; a failed item is retried only if nothing replaced it
+    checkUpcomingTracksForUrls(lookaheadCount, force = true)
+    if (exo.playbackState == Player.STATE_IDLE && exo.player.playerError != null) exo.prepare()
+}

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerSetup.kt

@@ -2,7 +2,6 @@ package com.margelo.nitro.nitroplayer.core
 
 import com.margelo.nitro.nitroplayer.equalizer.EqualizerCore
 import com.margelo.nitro.nitroplayer.media.MediaSessionManager
-import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 import com.margelo.nitro.nitroplayer.media.NitroPlayerPlaybackService
 
 /**
@@ -19,10 +18,6 @@ internal fun TrackPlayerCore.initFromService(binder: NitroPlayerPlaybackService.
             setTrackPlayerCore(this@initFromService)
         }
 
-    // Give MediaBrowserService access to this core and media session
-    NitroPlayerMediaBrowserService.trackPlayerCore = this
-    NitroPlayerMediaBrowserService.mediaSessionManager = mediaSessionManager
-
     // Attach player listener
     val listener = TrackPlayerEventListener(this)
     playerListener = listener

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerUrlLoader.kt

@@ -2,6 +2,7 @@
 
 package com.margelo.nitro.nitroplayer.core
 
+import android.os.SystemClock
 import androidx.media3.common.Player
 import com.margelo.nitro.nitroplayer.TrackItem
 
@@ -37,6 +38,7 @@ internal fun TrackPlayerCore.updateTracksOnQueue(tracks: List<TrackItem>) {
                 }
             }
         if (safeTracks.isEmpty()) return@run
+        safeTracks.forEach { urlRequestedAt.remove(it.id) }
 
         val affectedPlaylists: Map<String, Int> = playlistManager.updateTracks(safeTracks)
 
@@ -133,7 +135,13 @@ suspend fun TrackPlayerCore.getCurrentTrackIndex(): Int = withPlayerContext { cu
 
 // ── URL lookahead ─────────────────────────────────────────────────────────
 
-internal fun TrackPlayerCore.checkUpcomingTracksForUrls(lookahead: Int = 5) {
+// One pick fires several queue events within a few hundred ms; the app is asked once for that burst
+private const val URL_REQUEST_COALESCE_MS = 500L
+
+internal fun TrackPlayerCore.checkUpcomingTracksForUrls(
+    lookahead: Int = 5,
+    force: Boolean = false,
+) {
     val upcomingTracks =
         if (currentTrackIndex < 0) {
             currentTracks.take(lookahead)
@@ -144,5 +152,10 @@ internal fun TrackPlayerCore.checkUpcomingTracksForUrls(lookahead: Int = 5) {
     val currentNeedsUrl = currentTrack != null && currentTrack.url.isEmpty()
     val candidates = if (currentNeedsUrl) listOf(currentTrack!!) + upcomingTracks else upcomingTracks
     val needUrls = candidates.filter { it.url.isEmpty() }
-    if (needUrls.isNotEmpty()) notifyTracksNeedUpdate(needUrls, lookahead)
+    val now = SystemClock.elapsedRealtime()
+    val ask = if (force) needUrls else needUrls.filter { track -> urlRequestedAt[track.id]?.let { now - it < URL_REQUEST_COALESCE_MS } != true }
+    if (ask.isEmpty()) return
+    if (urlRequestedAt.size > 1000) urlRequestedAt.clear()
+    ask.forEach { urlRequestedAt[it.id] = now }
+    notifyTracksNeedUpdate(ask, lookahead)
 }