react-native-nitro-player 0.7.1-alpha.0 → 0.7.1-alpha.2

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

@@ -35,18 +35,24 @@ internal fun TrackPlayerCore.getStateInternal(): PlayerState {
     val currentTrack: Variant_NullType_TrackItem? = track?.let { Variant_NullType_TrackItem.create(it) }
     val position = exo.currentPosition / 1000.0
     val duration = if (exo.duration > 0) exo.duration / 1000.0 else 0.0
-    val state = when (exo.playbackState) {
-        Player.STATE_IDLE -> TrackPlayerState.STOPPED
-        Player.STATE_BUFFERING -> if (exo.playWhenReady) TrackPlayerState.PLAYING else TrackPlayerState.PAUSED
-        Player.STATE_READY -> if (exo.isPlaying) TrackPlayerState.PLAYING else TrackPlayerState.PAUSED
-        Player.STATE_ENDED -> TrackPlayerState.STOPPED
-        else -> TrackPlayerState.STOPPED
-    }
-    val playingType = if (track == null) CurrentPlayingType.NOT_PLAYING else when (currentTemporaryType) {
-        TrackPlayerCore.TemporaryType.NONE -> CurrentPlayingType.PLAYLIST
-        TrackPlayerCore.TemporaryType.PLAY_NEXT -> CurrentPlayingType.PLAY_NEXT
-        TrackPlayerCore.TemporaryType.UP_NEXT -> CurrentPlayingType.UP_NEXT
-    }
+    val state =
+        when (exo.playbackState) {
+            Player.STATE_IDLE -> TrackPlayerState.STOPPED
+            Player.STATE_BUFFERING -> if (exo.playWhenReady) TrackPlayerState.PLAYING else TrackPlayerState.PAUSED
+            Player.STATE_READY -> if (exo.isPlaying) TrackPlayerState.PLAYING else TrackPlayerState.PAUSED
+            Player.STATE_ENDED -> TrackPlayerState.STOPPED
+            else -> TrackPlayerState.STOPPED
+        }
+    val playingType =
+        if (track == null) {
+            CurrentPlayingType.NOT_PLAYING
+        } else {
+            when (currentTemporaryType) {
+                TrackPlayerCore.TemporaryType.NONE -> CurrentPlayingType.PLAYLIST
+                TrackPlayerCore.TemporaryType.PLAY_NEXT -> CurrentPlayingType.PLAY_NEXT
+                TrackPlayerCore.TemporaryType.UP_NEXT -> CurrentPlayingType.UP_NEXT
+            }
+        }
     return PlayerState(
         currentTrack = currentTrack,
         currentPosition = position,
@@ -70,26 +76,43 @@ internal fun TrackPlayerCore.getActualQueueInternal(): List<TrackItem> {
     val queue = ArrayList<TrackItem>(currentTracks.size + playNextStack.size + upNextQueue.size)
 
     // Tracks before current (include currentTrackIndex when a temp track is playing)
-    val beforeEnd = if (currentTemporaryType != TrackPlayerCore.TemporaryType.NONE) {
-        minOf(currentIndex + 1, currentTracks.size)
-    } else {
-        currentIndex
-    }
+    val beforeEnd =
+        if (currentTemporaryType != TrackPlayerCore.TemporaryType.NONE) {
+            minOf(currentIndex + 1, currentTracks.size)
+        } else {
+            currentIndex
+        }
     if (beforeEnd > 0) queue.addAll(currentTracks.subList(0, beforeEnd))
 
     // Current track
     getCurrentTrack()?.let { queue.add(it) }
 
-    // playNext — skip index 0 if it is the current item
-    if (currentTemporaryType == TrackPlayerCore.TemporaryType.PLAY_NEXT && playNextStack.size > 1) {
-        queue.addAll(playNextStack.subList(1, playNextStack.size))
+    val currentId = exo.currentMediaItem?.mediaId?.let { extractTrackId(it) }
+
+    // playNext — skip the currently playing track by ID (not position)
+    if (currentTemporaryType == TrackPlayerCore.TemporaryType.PLAY_NEXT && currentId != null) {
+        var skipped = false
+        for (track in playNextStack) {
+            if (!skipped && track.id == currentId) {
+                skipped = true
+                continue
+            }
+            queue.add(track)
+        }
     } else if (currentTemporaryType != TrackPlayerCore.TemporaryType.PLAY_NEXT) {
         queue.addAll(playNextStack)
     }
 
-    // upNext — skip index 0 if it is the current item
-    if (currentTemporaryType == TrackPlayerCore.TemporaryType.UP_NEXT && upNextQueue.size > 1) {
-        queue.addAll(upNextQueue.subList(1, upNextQueue.size))
+    // upNext — skip the currently playing track by ID (not position)
+    if (currentTemporaryType == TrackPlayerCore.TemporaryType.UP_NEXT && currentId != null) {
+        var skipped = false
+        for (track in upNextQueue) {
+            if (!skipped && track.id == currentId) {
+                skipped = true
+                continue
+            }
+            queue.add(track)
+        }
     } else if (currentTemporaryType != TrackPlayerCore.TemporaryType.UP_NEXT) {
         queue.addAll(upNextQueue)
     }
@@ -120,21 +143,31 @@ private fun TrackPlayerCore.skipToIndexInternal(index: Int): Boolean {
     val upNextEnd = upNextStart + effectiveUpNextSize
     val originalRemainingStart = upNextEnd
 
-    if (index < currentPos) { playFromIndexInternal(index); return true }
-    if (index == currentPos) { exo.seekTo(0); return true }
+    if (index < currentPos) {
+        playFromIndexInternal(index)
+        return true
+    }
+    if (index == currentPos) {
+        exo.seekTo(0)
+        return true
+    }
 
     if (index in playNextStart until playNextEnd) {
-        val listIndex = (index - playNextStart) + if (currentTemporaryType == TrackPlayerCore.TemporaryType.PLAY_NEXT) 1 else 0
-        if (listIndex > 0) playNextStack.subList(0, listIndex).clear()
+        val targetTrack = actualQueue[index]
+        // Remove all playNext tracks before the target (by ID lookup, not position)
+        val targetIdx = playNextStack.indexOfFirst { it.id == targetTrack.id }
+        if (targetIdx > 0) playNextStack.subList(0, targetIdx).clear()
         rebuildQueueFromCurrentPosition()
         exo.seekToNext()
         return true
     }
 
     if (index in upNextStart until upNextEnd) {
-        val listIndex = (index - upNextStart) + if (currentTemporaryType == TrackPlayerCore.TemporaryType.UP_NEXT) 1 else 0
+        val targetTrack = actualQueue[index]
         playNextStack.clear()
-        if (listIndex > 0) upNextQueue.subList(0, listIndex).clear()
+        // Remove all upNext tracks before the target (by ID lookup, not position)
+        val targetIdx = upNextQueue.indexOfFirst { it.id == targetTrack.id }
+        if (targetIdx > 0) upNextQueue.subList(0, targetIdx).clear()
         rebuildQueueFromCurrentPosition()
         exo.seekToNext()
         return true
@@ -144,7 +177,8 @@ private fun TrackPlayerCore.skipToIndexInternal(index: Int): Boolean {
         val targetTrack = actualQueue[index]
         val originalIndex = currentTracks.indexOfFirst { it.id == targetTrack.id }
         if (originalIndex == -1) return false
-        playNextStack.clear(); upNextQueue.clear()
+        playNextStack.clear()
+        upNextQueue.clear()
         currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
         rebuildQueueAndPlayFromIndex(originalIndex)
         checkUpcomingTracksForUrls(lookaheadCount)

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

@@ -22,10 +22,11 @@ internal fun TrackPlayerCore.rebuildQueueAndPlayFromIndex(index: Int) {
     if (index < 0 || index >= currentTracks.size) return
 
     val playlistId = currentPlaylistId ?: ""
-    val mediaItems = currentTracks.subList(index, currentTracks.size).map { track ->
-        val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
-        makeMediaItem(track, mediaId)
-    }
+    val mediaItems =
+        currentTracks.subList(index, currentTracks.size).map { track ->
+            val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
+            makeMediaItem(track, mediaId)
+        }
 
     currentTrackIndex = index
     exo.clearMediaItems()
@@ -51,17 +52,32 @@ internal fun TrackPlayerCore.rebuildQueueFromCurrentPosition() {
     }
 
     val newQueueTracks = ArrayList<TrackItem>(playNextStack.size + upNextQueue.size + currentTracks.size)
-
-    // playNext stack — skip index 0 if it is the currently playing item
-    if (currentTemporaryType == TrackPlayerCore.TemporaryType.PLAY_NEXT && playNextStack.size > 1) {
-        newQueueTracks.addAll(playNextStack.subList(1, playNextStack.size))
+    val currentId = exo.currentMediaItem?.mediaId?.let { extractTrackId(it) }
+
+    // playNext stack — skip the currently playing track by ID (not position)
+    if (currentTemporaryType == TrackPlayerCore.TemporaryType.PLAY_NEXT && currentId != null) {
+        var skipped = false
+        for (track in playNextStack) {
+            if (!skipped && track.id == currentId) {
+                skipped = true
+                continue
+            }
+            newQueueTracks.add(track)
+        }
     } else if (currentTemporaryType != TrackPlayerCore.TemporaryType.PLAY_NEXT) {
         newQueueTracks.addAll(playNextStack)
     }
 
-    // upNext queue — skip index 0 if it is the currently playing item
-    if (currentTemporaryType == TrackPlayerCore.TemporaryType.UP_NEXT && upNextQueue.size > 1) {
-        newQueueTracks.addAll(upNextQueue.subList(1, upNextQueue.size))
+    // upNext queue — skip the currently playing track by ID (not position)
+    if (currentTemporaryType == TrackPlayerCore.TemporaryType.UP_NEXT && currentId != null) {
+        var skipped = false
+        for (track in upNextQueue) {
+            if (!skipped && track.id == currentId) {
+                skipped = true
+                continue
+            }
+            newQueueTracks.add(track)
+        }
     } else if (currentTemporaryType != TrackPlayerCore.TemporaryType.UP_NEXT) {
         newQueueTracks.addAll(upNextQueue)
     }
@@ -72,10 +88,11 @@ internal fun TrackPlayerCore.rebuildQueueFromCurrentPosition() {
     }
 
     val playlistId = currentPlaylistId ?: ""
-    val newMediaItems = newQueueTracks.map { track ->
-        val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
-        makeMediaItem(track, mediaId)
-    }
+    val newMediaItems =
+        newQueueTracks.map { track ->
+            val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
+            makeMediaItem(track, mediaId)
+        }
 
     if (exo.mediaItemCount > currentIndex + 1) {
         exo.removeMediaItems(currentIndex + 1, exo.mediaItemCount)
@@ -88,10 +105,11 @@ internal fun TrackPlayerCore.rebuildQueueFromCurrentPosition() {
 internal fun TrackPlayerCore.updatePlayerQueue(tracks: List<TrackItem>) {
     currentTracks = tracks
     val playlistId = currentPlaylistId ?: ""
-    val mediaItems = tracks.map { track ->
-        val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
-        makeMediaItem(track, mediaId)
-    }
+    val mediaItems =
+        tracks.map { track ->
+            val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
+            makeMediaItem(track, mediaId)
+        }
     exo.setMediaItems(mediaItems, false)
     if (exo.playbackState == Player.STATE_IDLE && mediaItems.isNotEmpty()) {
         exo.prepare()
@@ -100,19 +118,28 @@ internal fun TrackPlayerCore.updatePlayerQueue(tracks: List<TrackItem>) {
 
 // ── MediaItem construction (member extension to access downloadManager) ────
 
-internal fun TrackPlayerCore.makeMediaItem(track: TrackItem, customMediaId: String? = null): MediaItem {
-    val metaBuilder = MediaMetadata.Builder()
-        .setTitle(track.title)
-        .setArtist(track.artist)
-        .setAlbumTitle(track.album)
+internal fun TrackPlayerCore.makeMediaItem(
+    track: TrackItem,
+    customMediaId: String? = null,
+): MediaItem {
+    val metaBuilder =
+        MediaMetadata
+            .Builder()
+            .setTitle(track.title)
+            .setArtist(track.artist)
+            .setAlbumTitle(track.album)
 
     track.artwork?.asSecondOrNull()?.let { artworkUrl ->
-        try { metaBuilder.setArtworkUri(Uri.parse(artworkUrl)) } catch (_: Exception) {}
+        try {
+            metaBuilder.setArtworkUri(Uri.parse(artworkUrl))
+        } catch (_: Exception) {
+        }
     }
 
     val effectiveUrl = downloadManager.getEffectiveUrl(track)
 
-    return MediaItem.Builder()
+    return MediaItem
+        .Builder()
         .setMediaId(customMediaId ?: track.id)
         .setUri(effectiveUrl)
         .setMediaMetadata(metaBuilder.build())
@@ -157,5 +184,4 @@ internal fun TrackPlayerCore.determineCurrentTemporaryType(): TrackPlayerCore.Te
     return TrackPlayerCore.TemporaryType.NONE
 }
 
-internal fun TrackPlayerCore.extractTrackId(mediaId: String): String =
-    if (mediaId.contains(':')) mediaId.substring(mediaId.indexOf(':') + 1) else mediaId
+internal fun TrackPlayerCore.extractTrackId(mediaId: String): String = if (mediaId.contains(':')) mediaId.substring(mediaId.indexOf(':') + 1) else mediaId

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

@@ -10,9 +10,10 @@ import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 internal fun TrackPlayerCore.initExoAndMedia() {
     exo = ExoPlayerCore(context, playerThread)
 
-    mediaSessionManager = MediaSessionManager(context, exo.player, playlistManager).apply {
-        setTrackPlayerCore(this@initExoAndMedia)
-    }
+    mediaSessionManager =
+        MediaSessionManager(context, exo.player, playlistManager).apply {
+            setTrackPlayerCore(this@initExoAndMedia)
+        }
 
     // Give MediaBrowserService access to this core and media session
     NitroPlayerMediaBrowserService.trackPlayerCore = this

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

@@ -11,16 +11,17 @@ import com.margelo.nitro.nitroplayer.TrackItem
 
 // ── Playlist loading ──────────────────────────────────────────────────────
 
-suspend fun TrackPlayerCore.loadPlaylist(playlistId: String) = withPlayerContext {
-    playNextStack.clear()
-    upNextQueue.clear()
-    currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
-    val playlist = playlistManager.getPlaylist(playlistId) ?: return@withPlayerContext
-    currentPlaylistId = playlistId
-    updatePlayerQueue(playlist.tracks)
-    checkUpcomingTracksForUrls(lookaheadCount)
-    notifyTemporaryQueueChange()
-}
+suspend fun TrackPlayerCore.loadPlaylist(playlistId: String) =
+    withPlayerContext {
+        playNextStack.clear()
+        upNextQueue.clear()
+        currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
+        val playlist = playlistManager.getPlaylist(playlistId) ?: return@withPlayerContext
+        currentPlaylistId = playlistId
+        updatePlayerQueue(playlist.tracks)
+        checkUpcomingTracksForUrls(lookaheadCount)
+        notifyTemporaryQueueChange()
+    }
 
 /**
  * Debounced update — coalesces rapid back-to-back mutations into one player rebuild.
@@ -37,8 +38,9 @@ fun TrackPlayerCore.updatePlaylist(playlistId: String) {
 suspend fun TrackPlayerCore.playNext(trackId: String) = withPlayerContext { playNextInternal(trackId) }
 
 internal fun TrackPlayerCore.playNextInternal(trackId: String) {
-    val track = findTrackById(trackId)
-        ?: throw IllegalArgumentException("Track $trackId not found")
+    val track =
+        findTrackById(trackId)
+            ?: throw IllegalArgumentException("Track $trackId not found")
     playNextStack.add(0, track)
     if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
     notifyTemporaryQueueChange()
@@ -49,8 +51,9 @@ internal fun TrackPlayerCore.playNextInternal(trackId: String) {
 suspend fun TrackPlayerCore.addToUpNext(trackId: String) = withPlayerContext { addToUpNextInternal(trackId) }
 
 internal fun TrackPlayerCore.addToUpNextInternal(trackId: String) {
-    val track = findTrackById(trackId)
-        ?: throw IllegalArgumentException("Track $trackId not found")
+    val track =
+        findTrackById(trackId)
+            ?: throw IllegalArgumentException("Track $trackId not found")
     upNextQueue.add(track)
     if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
     notifyTemporaryQueueChange()
@@ -58,35 +61,39 @@ internal fun TrackPlayerCore.addToUpNextInternal(trackId: String) {
 
 // ── Remove / clear ────────────────────────────────────────────────────────
 
-suspend fun TrackPlayerCore.removeFromPlayNext(trackId: String): Boolean = withPlayerContext {
-    val idx = playNextStack.indexOfFirst { it.id == trackId }
-    if (idx < 0) return@withPlayerContext false
-    playNextStack.removeAt(idx)
-    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
-    notifyTemporaryQueueChange()
-    true
-}
-
-suspend fun TrackPlayerCore.removeFromUpNext(trackId: String): Boolean = withPlayerContext {
-    val idx = upNextQueue.indexOfFirst { it.id == trackId }
-    if (idx < 0) return@withPlayerContext false
-    upNextQueue.removeAt(idx)
-    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
-    notifyTemporaryQueueChange()
-    true
-}
-
-suspend fun TrackPlayerCore.clearPlayNext() = withPlayerContext {
-    playNextStack.clear()
-    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
-    notifyTemporaryQueueChange()
-}
-
-suspend fun TrackPlayerCore.clearUpNext() = withPlayerContext {
-    upNextQueue.clear()
-    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
-    notifyTemporaryQueueChange()
-}
+suspend fun TrackPlayerCore.removeFromPlayNext(trackId: String): Boolean =
+    withPlayerContext {
+        val idx = playNextStack.indexOfFirst { it.id == trackId }
+        if (idx < 0) return@withPlayerContext false
+        playNextStack.removeAt(idx)
+        if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+        notifyTemporaryQueueChange()
+        true
+    }
+
+suspend fun TrackPlayerCore.removeFromUpNext(trackId: String): Boolean =
+    withPlayerContext {
+        val idx = upNextQueue.indexOfFirst { it.id == trackId }
+        if (idx < 0) return@withPlayerContext false
+        upNextQueue.removeAt(idx)
+        if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+        notifyTemporaryQueueChange()
+        true
+    }
+
+suspend fun TrackPlayerCore.clearPlayNext() =
+    withPlayerContext {
+        playNextStack.clear()
+        if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+        notifyTemporaryQueueChange()
+    }
+
+suspend fun TrackPlayerCore.clearUpNext() =
+    withPlayerContext {
+        upNextQueue.clear()
+        if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+        notifyTemporaryQueueChange()
+    }
 
 // ── Reorder ───────────────────────────────────────────────────────────────
 
@@ -94,25 +101,29 @@ suspend fun TrackPlayerCore.clearUpNext() = withPlayerContext {
  * Reorder within the combined virtual list [playNextStack + upNextQueue].
  * newIndex is 0-based within that combined list.
  */
-suspend fun TrackPlayerCore.reorderTemporaryTrack(trackId: String, newIndex: Int): Boolean = withPlayerContext {
-    val combined = (playNextStack + upNextQueue).toMutableList()
-    val fromIdx = combined.indexOfFirst { it.id == trackId }
-    if (fromIdx < 0) return@withPlayerContext false
-    val track = combined.removeAt(fromIdx)
-    val clampedIndex = newIndex.coerceIn(0, combined.size)
-    combined.add(clampedIndex, track)
-
-    // Split back at original playNextStack.size boundary (reduced if an item was moved out)
-    val pnSize = playNextStack.size
-    playNextStack.clear()
-    upNextQueue.clear()
-    playNextStack.addAll(combined.take(pnSize))
-    upNextQueue.addAll(combined.drop(pnSize))
-
-    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
-    notifyTemporaryQueueChange()
-    true
-}
+suspend fun TrackPlayerCore.reorderTemporaryTrack(
+    trackId: String,
+    newIndex: Int,
+): Boolean =
+    withPlayerContext {
+        val combined = (playNextStack + upNextQueue).toMutableList()
+        val fromIdx = combined.indexOfFirst { it.id == trackId }
+        if (fromIdx < 0) return@withPlayerContext false
+        val track = combined.removeAt(fromIdx)
+        val clampedIndex = newIndex.coerceIn(0, combined.size)
+        combined.add(clampedIndex, track)
+
+        // Split back at original playNextStack.size boundary (reduced if an item was moved out)
+        val pnSize = playNextStack.size
+        playNextStack.clear()
+        upNextQueue.clear()
+        playNextStack.addAll(combined.take(pnSize))
+        upNextQueue.addAll(combined.drop(pnSize))
+
+        if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+        notifyTemporaryQueueChange()
+        true
+    }
 
 // ── Read-only accessors ────────────────────────────────────────────────────
 

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

@@ -12,62 +12,65 @@ import com.margelo.nitro.nitroplayer.TrackItem
 
 // ── Track updates (URL resolution) ────────────────────────────────────────
 
-suspend fun TrackPlayerCore.updateTracks(tracks: List<TrackItem>) = withPlayerContext {
-    val currentTrack = getCurrentTrack()
-    val currentTrackId = currentTrack?.id
-    val currentTrackIsEmpty = currentTrack?.url.isNullOrEmpty()
-    val currentTrackUpdate = if (currentTrackId != null) tracks.find { it.id == currentTrackId } else null
-
-    val safeTracks = tracks.filter { track ->
-        when {
-            track.id == currentTrackId && !currentTrackIsEmpty -> false // preserve gapless
-            track.id == currentTrackId && currentTrackIsEmpty -> track.url.isNotEmpty()
-            track.url.isEmpty() -> false
-            else -> true
-        }
-    }
-    if (safeTracks.isEmpty()) return@withPlayerContext
-
-    val affectedPlaylists: Map<String, Int> = playlistManager.updateTracks(safeTracks)
-
-    // Replace current track's MediaItem if it was empty-URL and now has a URL
-    if (currentTrackUpdate != null && currentTrackIsEmpty && currentTrackUpdate.url.isNotEmpty()) {
-        val exoIndex = exo.currentMediaItemIndex
-        if (exoIndex >= 0) {
-            val playlistId = currentPlaylistId ?: ""
-            val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${currentTrackUpdate.id}" else currentTrackUpdate.id
-            exo.replaceMediaItem(exoIndex, makeMediaItem(currentTrackUpdate, mediaId))
-            if (exo.playbackState == Player.STATE_IDLE) exo.prepare()
+suspend fun TrackPlayerCore.updateTracks(tracks: List<TrackItem>) =
+    withPlayerContext {
+        val currentTrack = getCurrentTrack()
+        val currentTrackId = currentTrack?.id
+        val currentTrackIsEmpty = currentTrack?.url.isNullOrEmpty()
+        val currentTrackUpdate = if (currentTrackId != null) tracks.find { it.id == currentTrackId } else null
+
+        val safeTracks =
+            tracks.filter { track ->
+                when {
+                    track.id == currentTrackId && !currentTrackIsEmpty -> false
+
+                    // preserve gapless
+                    track.id == currentTrackId && currentTrackIsEmpty -> track.url.isNotEmpty()
+
+                    track.url.isEmpty() -> false
+
+                    else -> true
+                }
+            }
+        if (safeTracks.isEmpty()) return@withPlayerContext
+
+        val affectedPlaylists: Map<String, Int> = playlistManager.updateTracks(safeTracks)
+
+        // Replace current track's MediaItem if it was empty-URL and now has a URL
+        if (currentTrackUpdate != null && currentTrackIsEmpty && currentTrackUpdate.url.isNotEmpty()) {
+            val exoIndex = exo.currentMediaItemIndex
+            if (exoIndex >= 0) {
+                val playlistId = currentPlaylistId ?: ""
+                val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${currentTrackUpdate.id}" else currentTrackUpdate.id
+                exo.replaceMediaItem(exoIndex, makeMediaItem(currentTrackUpdate, mediaId))
+                if (exo.playbackState == Player.STATE_IDLE) exo.prepare()
+            }
         }
-    }
 
-    if (currentPlaylistId != null && affectedPlaylists.containsKey(currentPlaylistId)) {
-        val refreshedPlaylist = playlistManager.getPlaylist(currentPlaylistId!!)
-        if (refreshedPlaylist != null) {
-            currentTracks = refreshedPlaylist.tracks
-            val updatedById = currentTracks.associateBy { it.id }
-            playNextStack.forEachIndexed { i, t -> updatedById[t.id]?.let { if (it !== t) playNextStack[i] = it } }
-            upNextQueue.forEachIndexed { i, t -> updatedById[t.id]?.let { if (it !== t) upNextQueue[i] = it } }
+        if (currentPlaylistId != null && affectedPlaylists.containsKey(currentPlaylistId)) {
+            val refreshedPlaylist = playlistManager.getPlaylist(currentPlaylistId!!)
+            if (refreshedPlaylist != null) {
+                currentTracks = refreshedPlaylist.tracks
+                val updatedById = currentTracks.associateBy { it.id }
+                playNextStack.forEachIndexed { i, t -> updatedById[t.id]?.let { if (it !== t) playNextStack[i] = it } }
+                upNextQueue.forEachIndexed { i, t -> updatedById[t.id]?.let { if (it !== t) upNextQueue[i] = it } }
+            }
+            rebuildQueueFromCurrentPosition()
         }
-        rebuildQueueFromCurrentPosition()
     }
-}
 
 // ── Track queries ─────────────────────────────────────────────────────────
 
-suspend fun TrackPlayerCore.getTracksById(trackIds: List<String>): List<TrackItem> =
-    withPlayerContext { playlistManager.getTracksById(trackIds) as List<TrackItem> }
+suspend fun TrackPlayerCore.getTracksById(trackIds: List<String>): List<TrackItem> = withPlayerContext { playlistManager.getTracksById(trackIds) as List<TrackItem> }
 
-suspend fun TrackPlayerCore.getTracksNeedingUrls(): List<TrackItem> =
-    withPlayerContext { getTracksNeedingUrlsInternal() }
+suspend fun TrackPlayerCore.getTracksNeedingUrls(): List<TrackItem> = withPlayerContext { getTracksNeedingUrlsInternal() }
 
 internal fun TrackPlayerCore.getTracksNeedingUrlsInternal(): List<TrackItem> {
     val pid = currentPlaylistId ?: return emptyList()
     return playlistManager.getPlaylist(pid)?.tracks?.filter { it.url.isEmpty() } ?: emptyList()
 }
 
-suspend fun TrackPlayerCore.getNextTracks(count: Int): List<TrackItem> =
-    withPlayerContext { getNextTracksInternal(count) }
+suspend fun TrackPlayerCore.getNextTracks(count: Int): List<TrackItem> = withPlayerContext { getNextTracksInternal(count) }
 
 internal fun TrackPlayerCore.getNextTracksInternal(count: Int): List<TrackItem> {
     val actualQueue = getActualQueueInternal()
@@ -84,15 +87,15 @@ suspend fun TrackPlayerCore.getCurrentTrackIndex(): Int = withPlayerContext { cu
 // ── URL lookahead ─────────────────────────────────────────────────────────
 
 internal fun TrackPlayerCore.checkUpcomingTracksForUrls(lookahead: Int = 5) {
-    val upcomingTracks = if (currentTrackIndex < 0) {
-        currentTracks.take(lookahead)
-    } else {
-        getNextTracksInternal(lookahead)
-    }
+    val upcomingTracks =
+        if (currentTrackIndex < 0) {
+            currentTracks.take(lookahead)
+        } else {
+            getNextTracksInternal(lookahead)
+        }
     val currentTrack = getCurrentTrack()
     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)
 }
-

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

@@ -7,13 +7,13 @@ import com.margelo.nitro.nitroplayer.*
 import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
 import com.margelo.nitro.nitroplayer.storage.NitroPlayerStorage
-import org.json.JSONArray
-import org.json.JSONObject
-import java.io.File
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
 
 /**
  * Manages persistence of downloaded track metadata using file storage

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

@@ -236,9 +236,18 @@ class DownloadManagerCore private constructor(
 
         for (m in activeTasks.values) {
             when (m.state) {
-                DownloadState.PENDING -> pendingCount++
-                DownloadState.DOWNLOADING -> activeCount++
-                DownloadState.FAILED -> failedCount++
+                DownloadState.PENDING -> {
+                    pendingCount++
+                }
+
+                DownloadState.DOWNLOADING -> {
+                    activeCount++
+                }
+
+                DownloadState.FAILED -> {
+                    failedCount++
+                }
+
                 else -> {}
             }
             totalBytes += m.totalBytes ?: 0.0