react-native-nitro-player 1.5.0 → 1.6.0-alpha.0

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

@@ -15,90 +15,103 @@ import com.margelo.nitro.nitroplayer.media.NitroPlayerPlaybackService
  * via withPlayerContext.
  */
 
-suspend fun TrackPlayerCore.play() = withPlayerContext { exo.play() }
+suspend fun TrackPlayerCore.play() = withPlayerContext { playOnQueue() }
 
-suspend fun TrackPlayerCore.pause() = withPlayerContext { exo.pause() }
+internal fun TrackPlayerCore.playOnQueue() = exo.play()
 
-suspend fun TrackPlayerCore.seek(position: Double) =
-    withPlayerContext {
-        isManuallySeeked = true
-        exo.seekTo((position * 1000).toLong())
+suspend fun TrackPlayerCore.pause() = withPlayerContext { pauseOnQueue() }
+
+internal fun TrackPlayerCore.pauseOnQueue() = exo.pause()
+
+suspend fun TrackPlayerCore.seek(position: Double) = withPlayerContext { seekOnQueue(position) }
+
+internal fun TrackPlayerCore.seekOnQueue(position: Double) {
+    isManuallySeeked = true
+    exo.seekTo((position * 1000).toLong())
+}
+
+suspend fun TrackPlayerCore.skipToNext() = withPlayerContext { skipToNextOnQueue() }
+
+internal fun TrackPlayerCore.skipToNextOnQueue() {
+    // The timeline is windowed, so hasNextMediaItem() is not the logical answer —
+    // top up first when more tracks remain in currentTracks / the temp queues.
+    if (!exo.hasNextMediaItem()) rebuildQueueFromCurrentPosition()
+    if (exo.hasNextMediaItem()) {
+        exo.seekToNext()
+        checkUpcomingTracksForUrls(lookaheadCount)
     }
+}
 
-suspend fun TrackPlayerCore.skipToNext() =
-    withPlayerContext {
-        if (exo.hasNextMediaItem()) {
-            exo.seekToNext()
-            checkUpcomingTracksForUrls(lookaheadCount)
+suspend fun TrackPlayerCore.skipToPrevious() = withPlayerContext { skipToPreviousOnQueue() }
+
+internal fun TrackPlayerCore.skipToPreviousOnQueue() {
+    val currentPosition = exo.currentPosition
+    when {
+        currentPosition > 2000 -> {
+            exo.seekTo(0)
         }
-    }
 
-suspend fun TrackPlayerCore.skipToPrevious() =
-    withPlayerContext {
-        val currentPosition = exo.currentPosition
-        when {
-            currentPosition > 2000 -> {
-                exo.seekTo(0)
-            }
+        currentTemporaryType != TrackPlayerCore.TemporaryType.NONE -> {
+            val trackId = exo.currentMediaItem?.mediaId?.let { extractTrackId(it) }
+            if (trackId != null) {
+                when (currentTemporaryType) {
+                    TrackPlayerCore.TemporaryType.PLAY_NEXT -> {
+                        val idx = playNextStack.indexOfFirst { it.id == trackId }
+                        if (idx >= 0) playNextStack.removeAt(idx)
+                    }
 
-            currentTemporaryType != TrackPlayerCore.TemporaryType.NONE -> {
-                val trackId = exo.currentMediaItem?.mediaId?.let { extractTrackId(it) }
-                if (trackId != null) {
-                    when (currentTemporaryType) {
-                        TrackPlayerCore.TemporaryType.PLAY_NEXT -> {
-                            val idx = playNextStack.indexOfFirst { it.id == trackId }
-                            if (idx >= 0) playNextStack.removeAt(idx)
-                        }
-
-                        TrackPlayerCore.TemporaryType.UP_NEXT -> {
-                            val idx = upNextQueue.indexOfFirst { it.id == trackId }
-                            if (idx >= 0) upNextQueue.removeAt(idx)
-                        }
-
-                        else -> {}
+                    TrackPlayerCore.TemporaryType.UP_NEXT -> {
+                        val idx = upNextQueue.indexOfFirst { it.id == trackId }
+                        if (idx >= 0) upNextQueue.removeAt(idx)
                     }
+
+                    else -> {}
                 }
-                currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
-                playFromIndexInternal(currentTrackIndex)
             }
+            currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
+            playFromIndexInternal(currentTrackIndex)
+        }
 
-            currentTrackIndex > 0 -> {
-                playFromIndexInternal(currentTrackIndex - 1)
-            }
+        currentTrackIndex > 0 -> {
+            playFromIndexInternal(currentTrackIndex - 1)
+        }
 
-            else -> {
-                exo.seekTo(0)
-            }
+        else -> {
+            exo.seekTo(0)
         }
-        checkUpcomingTracksForUrls(lookaheadCount)
     }
+    checkUpcomingTracksForUrls(lookaheadCount)
+}
 
-suspend fun TrackPlayerCore.setRepeatMode(mode: RepeatMode) =
-    withPlayerContext {
-        currentRepeatMode = mode
-        exo.setRepeatMode(
-            when (mode) {
-                RepeatMode.TRACK -> Player.REPEAT_MODE_ONE
-                else -> Player.REPEAT_MODE_OFF
-            },
-        )
-    }
+suspend fun TrackPlayerCore.setRepeatMode(mode: RepeatMode) = withPlayerContext { setRepeatModeOnQueue(mode) }
+
+internal fun TrackPlayerCore.setRepeatModeOnQueue(mode: RepeatMode) {
+    currentRepeatMode = mode
+    exo.setRepeatMode(
+        when (mode) {
+            RepeatMode.TRACK -> Player.REPEAT_MODE_ONE
+            else -> Player.REPEAT_MODE_OFF
+        },
+    )
+}
 
 fun TrackPlayerCore.getRepeatMode(): RepeatMode = currentRepeatMode
 
-suspend fun TrackPlayerCore.setVolume(volume: Double) =
-    withPlayerContext {
-        val clamped = volume.coerceIn(0.0, 100.0)
-        exo.setVolume((clamped / 100.0).toFloat())
-    }
+suspend fun TrackPlayerCore.setVolume(volume: Double) = withPlayerContext { setVolumeOnQueue(volume) }
 
-suspend fun TrackPlayerCore.configure(config: PlayerConfig) =
-    withPlayerContext {
-        config.androidAutoEnabled?.let { NitroPlayerMediaBrowserService.isAndroidAutoEnabled = it }
-        config.lookaheadCount?.let { lookaheadCount = it.toInt() }
-        config.androidNotificationIcon?.let { NitroPlayerPlaybackService.notificationSmallIconResName = it }
-        mediaSessionManager?.configure(config.androidAutoEnabled, config.carPlayEnabled, config.showInNotification)
-    }
+internal fun TrackPlayerCore.setVolumeOnQueue(volume: Double) {
+    val clamped = volume.coerceIn(0.0, 100.0)
+    exo.setVolume((clamped / 100.0).toFloat())
+}
+
+suspend fun TrackPlayerCore.configure(config: PlayerConfig) = withPlayerContext { configureOnQueue(config) }
+
+internal fun TrackPlayerCore.configureOnQueue(config: PlayerConfig) {
+    config.androidAutoEnabled?.let { NitroPlayerMediaBrowserService.isAndroidAutoEnabled = it }
+    config.lookaheadCount?.let { lookaheadCount = it.toInt() }
+    config.androidNotificationIcon?.let { NitroPlayerPlaybackService.notificationSmallIconResName = it }
+    mediaSessionManager?.configure(config.androidAutoEnabled, config.carPlayEnabled, config.showInNotification)
+}
 
 suspend fun TrackPlayerCore.playSong(
     songId: String,
@@ -181,11 +194,12 @@ internal fun TrackPlayerCore.emitStateChange(reason: Reason? = null) {
 
 // ── Playback speed ────────────────────────────────────────────────────────
 
-suspend fun TrackPlayerCore.setPlayBackSpeed(speed: Double) =
-    withPlayerContext {
-        if (speed <= 0.0) throw IllegalArgumentException("Speed must be greater than 0")
-        if (isExoInitialized) exo.setPlaybackSpeed(speed.toFloat())
-    }
+suspend fun TrackPlayerCore.setPlayBackSpeed(speed: Double) = withPlayerContext { setPlayBackSpeedOnQueue(speed) }
+
+internal fun TrackPlayerCore.setPlayBackSpeedOnQueue(speed: Double) {
+    if (speed <= 0.0) throw IllegalArgumentException("Speed must be greater than 0")
+    if (isExoInitialized) exo.setPlaybackSpeed(speed.toFloat())
+}
 
 suspend fun TrackPlayerCore.getPlayBackSpeed(): Double =
     withPlayerContext {

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

@@ -59,7 +59,9 @@ internal fun TrackPlayerCore.getStateInternal(): PlayerState {
         totalDuration = duration,
         currentState = state,
         currentPlaylistId = currentPlaylistId?.let { Variant_NullType_String.create(it) },
-        currentIndex = if (exo.currentMediaItemIndex >= 0) exo.currentMediaItemIndex.toDouble() else -1.0,
+        // Playlist index, not the index inside ExoPlayer's (windowed, rebuilt-from-N)
+        // timeline — that reads 0 after any jump. Matches iOS and the documented contract.
+        currentIndex = if (currentTrackIndex >= 0) currentTrackIndex.toDouble() else -1.0,
         currentPlayingType = playingType,
     )
 }
@@ -128,7 +130,7 @@ internal fun TrackPlayerCore.getActualQueueInternal(): List<TrackItem> {
 
 suspend fun TrackPlayerCore.skipToIndex(index: Int): Boolean = withPlayerContext { skipToIndexInternal(index) }
 
-private fun TrackPlayerCore.skipToIndexInternal(index: Int): Boolean {
+internal fun TrackPlayerCore.skipToIndexInternal(index: Int): Boolean {
     if (!isExoInitialized) return false
     val actualQueue = getActualQueueInternal()
     if (index < 0 || index >= actualQueue.size) return false

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

@@ -37,6 +37,14 @@ internal fun TrackPlayerCore.castableUpcoming(tracks: List<TrackItem>): List<Tra
     return result
 }
 
+/**
+ * Upcoming MediaItems kept materialized behind the current one. The logical queue
+ * (currentTracks + temp lists) stays complete; only ExoPlayer's timeline is windowed,
+ * and it is topped up on every item transition. Building a MediaItem is not free —
+ * each one resolves the effective URL, which used to stat() the download record.
+ */
+internal const val QUEUE_WINDOW_SIZE = 4
+
 internal fun TrackPlayerCore.mediaIdFor(track: TrackItem): String {
     val playlistId = currentPlaylistId ?: ""
     return if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
@@ -70,8 +78,9 @@ internal fun TrackPlayerCore.rebuildQueueAndPlayFromIndex(index: Int) {
         return
     }
 
+    val windowEnd = minOf(index + 1 + QUEUE_WINDOW_SIZE, currentTracks.size)
     val mediaItems =
-        currentTracks.subList(index, currentTracks.size).map { track ->
+        currentTracks.subList(index, windowEnd).map { track ->
             makeMediaItem(track, mediaIdFor(track))
         }
 
@@ -92,7 +101,7 @@ internal fun TrackPlayerCore.rebuildQueueFromCurrentPosition() {
     val currentTrackId = exo.currentMediaItem?.mediaId?.let { extractTrackId(it) }
 
     if (
-        currentTrackId != null && 
+        currentTrackId != null &&
         currentTracks.none { it.id == currentTrackId } &&
         currentTemporaryType == TrackPlayerCore.TemporaryType.NONE
     ) {
@@ -131,12 +140,32 @@ internal fun TrackPlayerCore.rebuildQueueFromCurrentPosition() {
         }
     }
 
-    val newMediaItems = newQueueTracks.map { makeMediaItem(it, mediaIdFor(it)) }
+    // Window the materialized timeline; onMediaItemTransition tops it back up.
+    // NOT while casting: the receiver holds the whole queue (rebuildQueueAndPlayFromIndex
+    // loads it unwindowed), so truncating here would cut it down to the window size.
+    if (!isCastingField && newQueueTracks.size > QUEUE_WINDOW_SIZE) {
+        newQueueTracks = newQueueTracks.subList(0, QUEUE_WINDOW_SIZE)
+    }
+
+    // Keep the longest matching prefix of already-buffered items and rebuild only from
+    // the first divergence. A pure append (the common window top-up) touches nothing
+    // ExoPlayer has already prepared, so gapless transitions survive.
+    val existingCount = exo.mediaItemCount - currentIndex - 1
+    var commonPrefix = 0
+    while (commonPrefix < existingCount && commonPrefix < newQueueTracks.size &&
+        extractTrackId(exo.getMediaItemAt(currentIndex + 1 + commonPrefix).mediaId) == newQueueTracks[commonPrefix].id
+    ) {
+        commonPrefix++
+    }
 
-    if (exo.mediaItemCount > currentIndex + 1) {
-        exo.removeMediaItems(currentIndex + 1, exo.mediaItemCount)
+    if (exo.mediaItemCount > currentIndex + 1 + commonPrefix) {
+        exo.removeMediaItems(currentIndex + 1 + commonPrefix, exo.mediaItemCount)
+    }
+    if (commonPrefix < newQueueTracks.size) {
+        exo.addMediaItems(
+            newQueueTracks.subList(commonPrefix, newQueueTracks.size).map { makeMediaItem(it, mediaIdFor(it)) },
+        )
     }
-    exo.addMediaItems(newMediaItems)
 }
 
 /** Desired upcoming list after the current track: playNext + upNext + remaining originals, with the playing temp track ([currentId]) skipped. */
@@ -203,7 +232,8 @@ internal fun TrackPlayerCore.updatePlayerQueue(tracks: List<TrackItem>) {
         return
     }
 
-    val mediaItems = tracks.map { makeMediaItem(it, mediaIdFor(it)) }
+    currentTrackIndex = 0
+    val mediaItems = tracks.take(1 + QUEUE_WINDOW_SIZE).map { makeMediaItem(it, mediaIdFor(it)) }
     exo.setMediaItems(mediaItems, true)
     if (exo.playbackState == Player.STATE_IDLE && mediaItems.isNotEmpty()) {
         exo.prepare()
@@ -239,15 +269,17 @@ internal fun TrackPlayerCore.makeMediaItem(
         try {
             val headersRaw = payload.toHashMap()["headers"]
             if (headersRaw is Map<*, *>) {
-                val headers = headersRaw
-                    .mapNotNull { (k, v) -> if (k is String && v is String) k to v else null }
-                    .toMap()
+                val headers =
+                    headersRaw
+                        .mapNotNull { (k, v) -> if (k is String && v is String) k to v else null }
+                        .toMap()
                 if (headers.isNotEmpty()) {
                     com.margelo.nitro.nitroplayer.media.AuthAwareHttpDataSourceFactory
                         .setHeadersForUrl(effectiveUrl, headers)
                 }
             }
-        } catch (_: Exception) {}
+        } catch (_: Exception) {
+        }
     }
 
     return MediaItem

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

@@ -43,12 +43,16 @@ internal fun TrackPlayerCore.initFromService(binder: NitroPlayerPlaybackService.
     if (sessionId != 0) {
         try {
             EqualizerCore.getInstance(context).initialize(sessionId)
-        } catch (_: Exception) { }
+        } catch (_: Exception) {
+        }
     }
 
     // Start progress ticks on the main looper
-    playerHandler.postDelayed(progressUpdateRunnable, 250)
+    playerHandler.postDelayed(progressUpdateRunnable, TrackPlayerCore.PROGRESS_INTERVAL_MS)
 
     // Signal that the player is ready — unblocks all withPlayerContext callers
     completeServiceReady()
+
+    // Flush any commands JS issued before the service bound, in their original order
+    startCommandDraining()
 }

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

@@ -14,16 +14,21 @@ import com.margelo.nitro.nitroplayer.TrackItem
 suspend fun TrackPlayerCore.loadPlaylist(
     playlistId: String,
     startIndex: Int? = null,
-) =
-    withPlayerContext {
+) = withPlayerContext { loadPlaylistOnQueue(playlistId, startIndex) }
+
+internal fun TrackPlayerCore.loadPlaylistOnQueue(
+    playlistId: String,
+    startIndex: Int? = null,
+) {
+    run {
         playNextStack.clear()
         upNextQueue.clear()
         currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
-        val playlist = playlistManager.getPlaylist(playlistId) ?: return@withPlayerContext
+        val playlist = playlistManager.getPlaylist(playlistId) ?: return@run
 
         val targetIndex =
             if (startIndex != null) {
-                if (startIndex < 0 || startIndex >= playlist.tracks.size) return@withPlayerContext
+                if (startIndex < 0 || startIndex >= playlist.tracks.size) return@run
                 startIndex
             } else {
                 0
@@ -41,6 +46,7 @@ suspend fun TrackPlayerCore.loadPlaylist(
         checkUpcomingTracksForUrls(lookaheadCount)
         notifyTemporaryQueueChange()
     }
+}
 
 /**
  * Debounced update — coalesces rapid back-to-back mutations into one player rebuild.
@@ -80,39 +86,43 @@ 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.removeFromPlayNext(trackId: String): Boolean = withPlayerContext { removeFromPlayNextOnQueue(trackId) }
 
-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
-    }
+internal fun TrackPlayerCore.removeFromPlayNextOnQueue(trackId: String): Boolean {
+    val idx = playNextStack.indexOfFirst { it.id == trackId }
+    if (idx < 0) return false
+    playNextStack.removeAt(idx)
+    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+    notifyTemporaryQueueChange()
+    return true
+}
 
-suspend fun TrackPlayerCore.clearPlayNext() =
-    withPlayerContext {
-        playNextStack.clear()
-        if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
-        notifyTemporaryQueueChange()
-    }
+suspend fun TrackPlayerCore.removeFromUpNext(trackId: String): Boolean = withPlayerContext { removeFromUpNextOnQueue(trackId) }
 
-suspend fun TrackPlayerCore.clearUpNext() =
-    withPlayerContext {
-        upNextQueue.clear()
-        if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
-        notifyTemporaryQueueChange()
-    }
+internal fun TrackPlayerCore.removeFromUpNextOnQueue(trackId: String): Boolean {
+    val idx = upNextQueue.indexOfFirst { it.id == trackId }
+    if (idx < 0) return false
+    upNextQueue.removeAt(idx)
+    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+    notifyTemporaryQueueChange()
+    return true
+}
+
+suspend fun TrackPlayerCore.clearPlayNext() = withPlayerContext { clearPlayNextOnQueue() }
+
+internal fun TrackPlayerCore.clearPlayNextOnQueue() {
+    playNextStack.clear()
+    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+    notifyTemporaryQueueChange()
+}
+
+suspend fun TrackPlayerCore.clearUpNext() = withPlayerContext { clearUpNextOnQueue() }
+
+internal fun TrackPlayerCore.clearUpNextOnQueue() {
+    upNextQueue.clear()
+    if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
+    notifyTemporaryQueueChange()
+}
 
 // ── Reorder ───────────────────────────────────────────────────────────────
 
@@ -123,26 +133,30 @@ suspend fun TrackPlayerCore.clearUpNext() =
 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))
+): Boolean = withPlayerContext { reorderTemporaryTrackOnQueue(trackId, newIndex) }
 
-        if (isExoInitialized && exo.currentMediaItem != null) rebuildQueueFromCurrentPosition()
-        notifyTemporaryQueueChange()
-        true
-    }
+internal fun TrackPlayerCore.reorderTemporaryTrackOnQueue(
+    trackId: String,
+    newIndex: Int,
+): Boolean {
+    val combined = (playNextStack + upNextQueue).toMutableList()
+    val fromIdx = combined.indexOfFirst { it.id == trackId }
+    if (fromIdx < 0) return 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()
+    return true
+}
 
 // ── Read-only accessors ────────────────────────────────────────────────────
 

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

@@ -12,8 +12,10 @@ import com.margelo.nitro.nitroplayer.TrackItem
 
 // ── Track updates (URL resolution) ────────────────────────────────────────
 
-suspend fun TrackPlayerCore.updateTracks(tracks: List<TrackItem>) =
-    withPlayerContext {
+suspend fun TrackPlayerCore.updateTracks(tracks: List<TrackItem>) = withPlayerContext { updateTracksOnQueue(tracks) }
+
+internal fun TrackPlayerCore.updateTracksOnQueue(tracks: List<TrackItem>) {
+    run {
         val currentTrack = getCurrentTrack()
         val currentTrackId = currentTrack?.id
         val currentTrackIsEmpty = currentTrack?.url.isNullOrEmpty()
@@ -32,7 +34,7 @@ suspend fun TrackPlayerCore.updateTracks(tracks: List<TrackItem>) =
                     else -> true
                 }
             }
-        if (safeTracks.isEmpty()) return@withPlayerContext
+        if (safeTracks.isEmpty()) return@run
 
         val affectedPlaylists: Map<String, Int> = playlistManager.updateTracks(safeTracks)
 
@@ -64,12 +66,13 @@ suspend fun TrackPlayerCore.updateTracks(tracks: List<TrackItem>) =
                 } else {
                     rebuildQueueFromCurrentPosition()
                 }
-                return@withPlayerContext
+                return@run
             }
 
             rebuildQueueFromCurrentPosition()
         }
     }
+}
 
 // ── Track queries ─────────────────────────────────────────────────────────
 
@@ -84,14 +87,42 @@ internal fun TrackPlayerCore.getTracksNeedingUrlsInternal(): List<TrackItem> {
 
 suspend fun TrackPlayerCore.getNextTracks(count: Int): List<TrackItem> = withPlayerContext { getNextTracksInternal(count) }
 
+/**
+ * Walks the queue structure directly instead of materializing the whole queue — this
+ * runs on every skip and every progress tick, so it must not be O(playlist) just to
+ * read the next few tracks.
+ */
 internal fun TrackPlayerCore.getNextTracksInternal(count: Int): List<TrackItem> {
-    val actualQueue = getActualQueueInternal()
-    if (actualQueue.isEmpty()) return emptyList()
-    val currentIdx = actualQueue.indexOfFirst { it.id == getCurrentTrack()?.id }
-    if (currentIdx == -1) return emptyList()
-    val start = currentIdx + 1
-    val end = minOf(start + count, actualQueue.size)
-    return if (start < actualQueue.size) actualQueue.subList(start, end) else emptyList()
+    if (count <= 0) return emptyList()
+    val out = ArrayList<TrackItem>(count)
+    val currentId = if (isExoInitialized) exo.currentMediaItem?.mediaId?.let { extractTrackId(it) } else null
+
+    var skippedPlayNext = currentTemporaryType != TrackPlayerCore.TemporaryType.PLAY_NEXT
+    for (track in playNextStack) {
+        if (!skippedPlayNext && track.id == currentId) {
+            skippedPlayNext = true
+            continue
+        }
+        out.add(track)
+        if (out.size == count) return out
+    }
+
+    var skippedUpNext = currentTemporaryType != TrackPlayerCore.TemporaryType.UP_NEXT
+    for (track in upNextQueue) {
+        if (!skippedUpNext && track.id == currentId) {
+            skippedUpNext = true
+            continue
+        }
+        out.add(track)
+        if (out.size == count) return out
+    }
+
+    var index = currentTrackIndex + 1
+    while (index < currentTracks.size && out.size < count) {
+        out.add(currentTracks[index])
+        index++
+    }
+    return out
 }
 
 suspend fun TrackPlayerCore.getCurrentTrackIndex(): Int = withPlayerContext { currentTrackIndex }

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

@@ -39,6 +39,15 @@ class DownloadDatabase private constructor(
     }
 
     private val downloadedTracks = mutableMapOf<String, DownloadedTrackRecord>()
+
+    /**
+     * Memoized `File.exists()` verdicts, keyed by track ID.
+     *
+     * Queue building asks "is this downloaded?" once per track, and each answer used to
+     * cost a stat() — O(playlist) syscalls per rebuild, on the main looper. Records only
+     * change through this class, so the verdict is cached and dropped in [saveToDisk].
+     */
+    private val existenceCache = mutableMapOf<String, Boolean>()
     private val playlistTracks = mutableMapOf<String, MutableSet<String>>()
     private val fileManager = DownloadFileManager.getInstance(context)
     private val ioScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
@@ -82,11 +91,21 @@ class DownloadDatabase private constructor(
     fun isTrackDownloaded(trackId: String): Boolean {
         synchronized(this) {
             val record = downloadedTracks[trackId] ?: return false
-            // Verify file still exists
-            return File(record.localPath).exists()
+            return cachedFileExists(trackId, record.localPath)
         }
     }
 
+    /** Caller must hold the monitor. */
+    private fun cachedFileExists(
+        trackId: String,
+        path: String,
+    ): Boolean = existenceCache.getOrPut(trackId) { File(path).exists() }
+
+    /** Drops every memoized verdict — files may have changed outside the app. */
+    fun invalidateExistenceCache() {
+        synchronized(this) { existenceCache.clear() }
+    }
+
     fun isPlaylistDownloaded(playlistId: String): Boolean {
         synchronized(this) {
             val trackIds = playlistTracks[playlistId] ?: return false
@@ -118,8 +137,8 @@ class DownloadDatabase private constructor(
         synchronized(this) {
             val record = downloadedTracks[trackId] ?: return null
 
-            // Verify file still exists
-            if (!File(record.localPath).exists()) {
+            // Verify file still exists (memoized)
+            if (!cachedFileExists(trackId, record.localPath)) {
                 // File was deleted externally, clean up record
                 downloadedTracks.remove(trackId)
                 saveToDisk()
@@ -302,6 +321,9 @@ class DownloadDatabase private constructor(
 
     // Persistence — called while holding synchronized(this); snapshots data then writes on IO.
     private fun saveToDisk() {
+        // Every record mutation funnels through here, so this is the one place that has
+        // to drop memoized File.exists() verdicts.
+        existenceCache.clear()
         val trackSnapshot = downloadedTracks.toMap()
         val playlistSnapshot = playlistTracks.mapValues { it.value.toSet() }
         ioScope.launch {