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

package/README.md

@@ -52,7 +52,7 @@ Command-style methods return **`Promise<void>`** (or another **`Promise`**) and
 | `skipToNext()`              | Both     | **Async**. Skips to the next track in the queue.                    |
 | `skipToPrevious()`          | Both     | **Async**. Skips to the previous track.                             |
 | `seek(position)`            | Both     | **Async**. Seeks to a specific time position in seconds.           |
-| `setPlaybackSpeed(speed)`   | Both     | **Async**. Sets playback speed (e.g. 0.5x, 1x, 1.5x, 2x).           |
+| `setPlaybackSpeed(speed)`   | Both     | **Async**. Sets playback speed; rejects non-finite and non-positive values. |
 | `getPlaybackSpeed()`        | Both     | **Async**. Gets the current playback speed.                         |
 | `setVolume(0-100)`          | Both     | **Async**. Sets playback volume (0-100).                            |
 | `setRepeatMode(mode)`       | Both     | **Async**. Sets repeat mode (`off`, `track`, `Playlist`).           |
@@ -131,9 +131,13 @@ await TrackPlayer.configure({
   androidAutoEnabled: true,
   carPlayEnabled: false,
   showInNotification: true,
+  remoteSkipForwardInterval: 15,
+  remoteSkipBackwardInterval: 15,
 })
 ```
 
+Remote skip intervals are in seconds. iOS uses them for AirPods/Control Center fixed skip buttons and exposes remote playback rates `0.5, 1.0, 1.25, 1.5, 1.75, 2.0`; Android uses them for the Media3 seek back/forward notification buttons and does not expose a playback-rate media button. Press-and-hold continuous seek is not implemented on either platform. Custom intervals apply to local playback; during a Google Cast session the receiver skips by a fixed 15 seconds.
+
 ### 2. Create Playlists
 
 ```typescript
@@ -1227,6 +1231,7 @@ AndroidAutoMediaLibraryHelper.set({
 
 - ✅ **Playlist Management**: Create, update, and manage multiple playlists
 - ✅ **Playback Controls**: Play, pause, seek, skip tracks
+- ✅ **Remote Controls**: AirPods, lock screen, and notification skip controls
 - ✅ **Volume Control**: Adjust playback volume (0-100)
 - ✅ **React Hooks**: Built-in hooks for reactive state management
 - ✅ **Event Listeners**: Listen to track changes, state changes, and more

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

@@ -67,11 +67,19 @@ class HybridAudioDevices : HybridAudioDevicesSpec() {
                     audioManager.setCommunicationDevice(device)
                 } else {
                     when (device.type) {
-                        AudioDeviceInfo.TYPE_BLUETOOTH_SCO, AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> {
+                        AudioDeviceInfo.TYPE_BLUETOOTH_SCO -> {
                             audioManager.startBluetoothSco()
                             audioManager.isBluetoothScoOn = true
                         }
 
+                        // A2DP is the default media route — routing it through SCO
+                        // would drop music to narrowband call quality
+                        AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> {
+                            audioManager.stopBluetoothSco()
+                            audioManager.isBluetoothScoOn = false
+                            audioManager.isSpeakerphoneOn = false
+                        }
+
                         AudioDeviceInfo.TYPE_BUILTIN_SPEAKER -> {
                             audioManager.isSpeakerphoneOn = true
                         }

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

@@ -129,9 +129,29 @@ class HybridDownloadManager : HybridDownloadManagerSpec() {
     override fun getPlaybackSourcePreference(): PlaybackSource = core.getPlaybackSourcePreference()
 
     // ── Events ────────────────────────────────────────────────────────────────
-    override fun onDownloadProgress(callback: (progress: DownloadProgress) -> Unit) = core.addProgressCallback(callback)
+    private val listenerIds = java.util.concurrent.CopyOnWriteArrayList<Pair<String, Long>>()
 
-    override fun onDownloadStateChange(callback: (downloadId: String, trackId: String, state: DownloadState, error: DownloadError?) -> Unit) = core.addStateChangeCallback(callback)
+    override fun onDownloadProgress(callback: (progress: DownloadProgress) -> Unit) {
+        listenerIds.add("progress" to core.addProgressCallback(callback))
+    }
+
+    override fun onDownloadStateChange(callback: (downloadId: String, trackId: String, state: DownloadState, error: DownloadError?) -> Unit) {
+        listenerIds.add("state" to core.addStateChangeCallback(callback))
+    }
+
+    override fun onDownloadComplete(callback: (downloadedTrack: DownloadedTrack) -> Unit) {
+        listenerIds.add("complete" to core.addCompleteCallback(callback))
+    }
 
-    override fun onDownloadComplete(callback: (downloadedTrack: DownloadedTrack) -> Unit) = core.addCompleteCallback(callback)
+    override fun dispose() {
+        super.dispose()
+        listenerIds.forEach { (type, id) ->
+            when (type) {
+                "progress" -> core.removeProgressCallback(id)
+                "state" -> core.removeStateChangeCallback(id)
+                "complete" -> core.removeCompleteCallback(id)
+            }
+        }
+        listenerIds.clear()
+    }
 }

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

@@ -63,9 +63,29 @@ class HybridEqualizer : HybridEqualizerSpec() {
     override fun reset(): Promise<Unit> = Promise.async { core.reset() }
 
     // ── Events ────────────────────────────────────────────────────────────────
-    override fun onEnabledChange(callback: (enabled: Boolean) -> Unit) = core.addOnEnabledChangeListener(callback)
+    private val listenerIds = java.util.concurrent.CopyOnWriteArrayList<Pair<String, Long>>()
 
-    override fun onBandChange(callback: (bands: Array<EqualizerBand>) -> Unit) = core.addOnBandChangeListener(callback)
+    override fun onEnabledChange(callback: (enabled: Boolean) -> Unit) {
+        listenerIds.add("enabled" to core.addOnEnabledChangeListener(callback))
+    }
+
+    override fun onBandChange(callback: (bands: Array<EqualizerBand>) -> Unit) {
+        listenerIds.add("band" to core.addOnBandChangeListener(callback))
+    }
 
-    override fun onPresetChange(callback: (presetName: Variant_NullType_String?) -> Unit) = core.addOnPresetChangeListener(callback)
+    override fun onPresetChange(callback: (presetName: Variant_NullType_String?) -> Unit) {
+        listenerIds.add("preset" to core.addOnPresetChangeListener(callback))
+    }
+
+    override fun dispose() {
+        super.dispose()
+        listenerIds.forEach { (type, id) ->
+            when (type) {
+                "enabled" -> core.removeOnEnabledChangeListener(id)
+                "band" -> core.removeOnBandChangeListener(id)
+                "preset" -> core.removeOnPresetChangeListener(id)
+            }
+        }
+        listenerIds.clear()
+    }
 }

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

@@ -11,7 +11,6 @@ import com.margelo.nitro.nitroplayer.core.TrackPlayerCore
 import com.margelo.nitro.nitroplayer.core.loadPlaylistOnQueue
 import com.margelo.nitro.nitroplayer.core.updatePlaylist
 import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
-import java.util.UUID
 import com.margelo.nitro.nitroplayer.playlist.Playlist as InternalPlaylist
 
 @DoNotStrip
@@ -29,7 +28,6 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
     }
 
     private val playlistsChangeListeners = java.util.concurrent.CopyOnWriteArrayList<() -> Unit>()
-    private val playlistChangeListeners = java.util.concurrent.ConcurrentHashMap<String, () -> Unit>()
 
     // ── Playlist CRUD ─────────────────────────────────────────────────────────
 
@@ -41,7 +39,9 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
 
     override fun deletePlaylist(playlistId: String): Promise<Unit> =
         Promise.async {
-            playlistManager.deletePlaylist(playlistId)
+            if (!playlistManager.deletePlaylist(playlistId)) {
+                throw IllegalArgumentException("Playlist not found: $playlistId")
+            }
         }
 
     override fun updatePlaylist(
@@ -51,7 +51,9 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
         artwork: String?,
     ): Promise<Unit> =
         Promise.async {
-            playlistManager.updatePlaylist(playlistId, name, description, artwork)
+            if (!playlistManager.updatePlaylist(playlistId, name, description, artwork)) {
+                throw IllegalArgumentException("Playlist not found: $playlistId")
+            }
             core.updatePlaylist(playlistId)
         }
 
@@ -74,7 +76,9 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
         index: Double?,
     ): Promise<Unit> =
         Promise.async {
-            playlistManager.addTrackToPlaylist(playlistId, track, index?.toInt())
+            if (!playlistManager.addTrackToPlaylist(playlistId, track, index?.toInt())) {
+                throw IllegalArgumentException("Playlist not found: $playlistId")
+            }
             core.updatePlaylist(playlistId)
         }
 
@@ -84,7 +88,9 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
         index: Double?,
     ): Promise<Unit> =
         Promise.async {
-            playlistManager.addTracksToPlaylist(playlistId, tracks.toList(), index?.toInt())
+            if (!playlistManager.addTracksToPlaylist(playlistId, tracks.toList(), index?.toInt())) {
+                throw IllegalArgumentException("Playlist not found: $playlistId")
+            }
             core.updatePlaylist(playlistId)
         }
 
@@ -93,7 +99,9 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
         trackId: String,
     ): Promise<Unit> =
         Promise.async {
-            playlistManager.removeTrackFromPlaylist(playlistId, trackId)
+            if (!playlistManager.removeTrackFromPlaylist(playlistId, trackId)) {
+                throw IllegalArgumentException("Track $trackId not found in playlist $playlistId")
+            }
             core.updatePlaylist(playlistId)
         }
 
@@ -103,7 +111,9 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
         newIndex: Double,
     ): Promise<Unit> =
         Promise.async {
-            playlistManager.reorderTrackInPlaylist(playlistId, trackId, newIndex.toInt())
+            if (!playlistManager.reorderTrackInPlaylist(playlistId, trackId, newIndex.toInt())) {
+                throw IllegalArgumentException("Invalid reorder for track $trackId in playlist $playlistId")
+            }
             core.updatePlaylist(playlistId)
         }
 
@@ -122,8 +132,10 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
         core.enqueue {
             if (playlistManager.loadPlaylist(playlistId, startIndex)) {
                 core.loadPlaylistOnQueue(playlistId, startIndex)
+                promise.resolve(Unit)
+            } else {
+                promise.reject(IllegalArgumentException("Invalid playlist or index: $playlistId"))
             }
-            promise.resolve(Unit)
         }
         return promise
     }
@@ -148,14 +160,19 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
     }
 
     override fun onPlaylistChanged(callback: (playlistId: String, playlist: Playlist, operation: QueueOperation?) -> Unit) {
-        val listenerId = UUID.randomUUID().toString()
-        playlistManager.getAllPlaylists().forEach { internalPlaylist ->
-            val removeListener =
-                playlistManager.addPlaylistChangeListener(internalPlaylist.id) { playlist, operation ->
-                    callback(playlist.id, playlist.toPlaylist(), operation)
-                }
-            playlistChangeListeners[listenerId] = removeListener
-        }
+        // Manager-level listener: covers playlists created after registration,
+        // and one remover per callback instead of one per playlist
+        val removeListener =
+            playlistManager.addAnyPlaylistChangeListener { playlist, operation ->
+                callback(playlist.id, playlist.toPlaylist(), operation)
+            }
+        playlistsChangeListeners.add(removeListener)
+    }
+
+    override fun dispose() {
+        super.dispose()
+        playlistsChangeListeners.forEach { it() }
+        playlistsChangeListeners.clear()
     }
 
     // ── Helper ────────────────────────────────────────────────────────────────

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

@@ -144,29 +144,29 @@ class AndroidAutoConnectionDetector(
                 return
             }
 
-            val carConnectionTypeColumn = response.getColumnIndex(CAR_CONNECTION_STATE)
-            if (carConnectionTypeColumn < 0) {
-                NitroPlayerLogger.log("AndroidAutoConnection", "⚠️ Connection type column missing, treating as disconnected")
-                notifyCarDisconnected()
-                return
-            }
-
-            if (!response.moveToNext()) {
-                NitroPlayerLogger.log("AndroidAutoConnection", "⚠️ Empty response, treating as disconnected")
-                notifyCarDisconnected()
-                return
+            response.use { cursor ->
+                val carConnectionTypeColumn = cursor.getColumnIndex(CAR_CONNECTION_STATE)
+                if (carConnectionTypeColumn < 0) {
+                    NitroPlayerLogger.log("AndroidAutoConnection", "⚠️ Connection type column missing, treating as disconnected")
+                    notifyCarDisconnected()
+                    return
+                }
+
+                if (!cursor.moveToNext()) {
+                    NitroPlayerLogger.log("AndroidAutoConnection", "⚠️ Empty response, treating as disconnected")
+                    notifyCarDisconnected()
+                    return
+                }
+
+                val connectionState = cursor.getInt(carConnectionTypeColumn)
+                NitroPlayerLogger.log("AndroidAutoConnection", "📊 Connection state queried: $connectionState")
+
+                if (connectionState == CONNECTION_TYPE_NOT_CONNECTED) {
+                    notifyCarDisconnected()
+                } else {
+                    notifyCarConnected(connectionState)
+                }
             }
-
-            val connectionState = response.getInt(carConnectionTypeColumn)
-            NitroPlayerLogger.log("AndroidAutoConnection", "📊 Connection state queried: $connectionState")
-
-            if (connectionState == CONNECTION_TYPE_NOT_CONNECTED) {
-                notifyCarDisconnected()
-            } else {
-                notifyCarConnected(connectionState)
-            }
-
-            response.close()
         }
     }
 }

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

@@ -12,7 +12,7 @@ import android.os.Bundle
 import android.os.Handler
 import android.os.IBinder
 import android.os.Looper
-import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.NitroModules
 import com.margelo.nitro.nitroplayer.Reason
 import com.margelo.nitro.nitroplayer.RepeatMode
 import com.margelo.nitro.nitroplayer.TimedMetadata
@@ -20,6 +20,7 @@ import com.margelo.nitro.nitroplayer.TrackItem
 import com.margelo.nitro.nitroplayer.TrackPlayerState
 import com.margelo.nitro.nitroplayer.connection.AndroidAutoConnectionDetector
 import com.margelo.nitro.nitroplayer.download.DownloadManagerCore
+import com.margelo.nitro.nitroplayer.media.ExoPlayerBuilder
 import com.margelo.nitro.nitroplayer.media.MediaLibraryManager
 import com.margelo.nitro.nitroplayer.media.MediaSessionManager
 import com.margelo.nitro.nitroplayer.media.NitroPlayerPlaybackService
@@ -69,6 +70,9 @@ class TrackPlayerCore private constructor(
 
     @Volatile internal var currentRepeatMode: RepeatMode = RepeatMode.OFF
     internal var lookaheadCount: Int = 5
+
+    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
 
     // ── Temporary queue ────────────────────────────────────────────────────
@@ -124,16 +128,22 @@ class TrackPlayerCore private constructor(
     internal val progressUpdateRunnable =
         object : Runnable {
             override fun run() {
-                if (::exo.isInitialized && exo.isPlaying) {
-                    val pos = exo.currentPosition / 1000.0
-                    val dur = if (exo.duration > 0) exo.duration / 1000.0 else 0.0
-                    notifyPlaybackProgress(pos, dur, if (isManuallySeeked) true else null)
-                    isManuallySeeked = false
-                }
+                // Stop ticking while paused/idle — onIsPlayingChanged restarts it,
+                // so the main looper isn't woken every second for the process lifetime
+                if (!::exo.isInitialized || !exo.isPlaying) return
+                val pos = exo.currentPosition / 1000.0
+                val dur = if (exo.duration > 0) exo.duration / 1000.0 else 0.0
+                notifyPlaybackProgress(pos, dur, if (isManuallySeeked) true else null)
+                isManuallySeeked = false
                 playerHandler.postDelayed(this, PROGRESS_INTERVAL_MS)
             }
         }
 
+    internal fun startProgressTicks() {
+        playerHandler.removeCallbacks(progressUpdateRunnable)
+        playerHandler.postDelayed(progressUpdateRunnable, PROGRESS_INTERVAL_MS)
+    }
+
     internal val updateCurrentPlaylistRunnable =
         Runnable {
             val id = currentPlaylistId ?: return@Runnable
@@ -214,9 +224,11 @@ class TrackPlayerCore private constructor(
         @Suppress("ktlint:standard:property-naming")
         private var INSTANCE: TrackPlayerCore? = null
 
+        // applicationContext: the process-lifetime singleton must not pin the
+        // ReactApplicationContext (and its whole JS runtime) across reloads
         fun getInstance(context: Context): TrackPlayerCore =
             INSTANCE ?: synchronized(this) {
-                INSTANCE ?: TrackPlayerCore(context).also { INSTANCE = it }
+                INSTANCE ?: TrackPlayerCore(context.applicationContext).also { INSTANCE = it }
             }
     }
 
@@ -405,7 +417,7 @@ class TrackPlayerCore private constructor(
         val id = onNotificationLaunchListeners.add(cb)
         handler.post {
             registerNotificationLaunchDetection()
-            checkNotificationLaunch((context as? ReactApplicationContext)?.currentActivity)
+            checkNotificationLaunch(NitroModules.applicationContext?.currentActivity)
         }
         return id
     }

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

@@ -5,12 +5,14 @@ package com.margelo.nitro.nitroplayer.core
 import androidx.media3.common.MediaItem
 import androidx.media3.common.MediaMetadata
 import androidx.media3.common.Metadata
+import androidx.media3.common.PlaybackException
 import androidx.media3.common.Player
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.extractor.metadata.icy.IcyInfo
 import com.margelo.nitro.nitroplayer.Reason
 import com.margelo.nitro.nitroplayer.RepeatMode
 import com.margelo.nitro.nitroplayer.TimedMetadata
+import com.margelo.nitro.nitroplayer.TrackPlayerState
 import com.margelo.nitro.nitroplayer.equalizer.EqualizerCore
 import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 
@@ -147,6 +149,7 @@ internal class TrackPlayerEventListener(
     }
 
     override fun onIsPlayingChanged(isPlaying: Boolean) {
+        if (isPlaying) core.startProgressTicks()
         core.emitStateChange()
     }
 
@@ -163,6 +166,22 @@ 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.seekToNextMediaItem()
+                exo.prepare()
+            }
+        }
+    }
+
     override fun onAudioSessionIdChanged(audioSessionId: Int) {
         if (audioSessionId != 0) {
             try {

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

@@ -2,7 +2,10 @@
 
 package com.margelo.nitro.nitroplayer.core
 
+import androidx.annotation.OptIn
 import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.ExoPlayer
 import com.margelo.nitro.nitroplayer.PlayerConfig
 import com.margelo.nitro.nitroplayer.Reason
 import com.margelo.nitro.nitroplayer.RepeatMode
@@ -52,23 +55,8 @@ internal fun TrackPlayerCore.skipToPreviousOnQueue() {
         }
 
         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 -> {}
-                }
-            }
-            currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
+            // playFromIndexInternal clears both temp lists (matching iOS behavior),
+            // so no per-track removal is needed here
             playFromIndexInternal(currentTrackIndex)
         }
 
@@ -110,7 +98,31 @@ 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)
+    remoteSkipIntervalMs(config.remoteSkipForwardInterval)?.let { remoteSkipForwardIntervalMs = it }
+    remoteSkipIntervalMs(config.remoteSkipBackwardInterval)?.let { remoteSkipBackwardIntervalMs = it }
+    applyRemoteSkipIntervals()
+    mediaSessionManager?.configure(
+        config.androidAutoEnabled,
+        config.carPlayEnabled,
+        config.showInNotification,
+        remoteSkipForwardIntervalMs,
+        remoteSkipBackwardIntervalMs,
+    )
+}
+
+// Resolved from the cast controller: mid-cast `exo` is the CastPlayer, whose increments are fixed
+@OptIn(UnstableApi::class)
+internal fun TrackPlayerCore.applyRemoteSkipIntervals() {
+    val local = castSessionController?.localPlayer ?: if (isExoInitialized) exo.player else null
+    (local as? ExoPlayer)?.let {
+        it.setSeekBackIncrementMs(remoteSkipBackwardIntervalMs)
+        it.setSeekForwardIncrementMs(remoteSkipForwardIntervalMs)
+    }
+}
+
+private fun remoteSkipIntervalMs(intervalSeconds: Double?): Long? {
+    if (intervalSeconds == null || !intervalSeconds.isFinite() || intervalSeconds <= 0.0) return null
+    return (intervalSeconds * 1000.0).toLong().coerceAtLeast(1L)
 }
 
 suspend fun TrackPlayerCore.playSong(
@@ -197,7 +209,9 @@ internal fun TrackPlayerCore.emitStateChange(reason: Reason? = null) {
 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 (!speed.isFinite() || speed <= 0.0) {
+        throw IllegalArgumentException("Speed must be finite and greater than 0")
+    }
     if (isExoInitialized) exo.setPlaybackSpeed(speed.toFloat())
 }
 

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

@@ -85,7 +85,6 @@ internal fun TrackPlayerCore.rebuildQueueAndPlayFromIndex(index: Int) {
         }
 
     currentTrackIndex = index
-    exo.clearMediaItems()
     exo.setMediaItems(mediaItems, true)
     exo.prepare()
 }

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

@@ -8,6 +8,7 @@ import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
 import com.margelo.nitro.nitroplayer.storage.NitroPlayerStorage
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
@@ -50,7 +51,9 @@ class DownloadDatabase private constructor(
     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())
+    // Single-threaded so rapid saves cannot land out of order and persist a stale snapshot
+    @OptIn(ExperimentalCoroutinesApi::class)
+    private val ioScope = CoroutineScope(Dispatchers.IO.limitedParallelism(1) + SupervisorJob())
 
     init {
         loadFromDisk()
@@ -101,10 +104,11 @@ class DownloadDatabase private constructor(
         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() }
-    }
+    /** Count via the memoized existence cache — no per-record stat() on the caller's thread. */
+    fun countDownloadedTracks(): Int =
+        synchronized(this) {
+            downloadedTracks.count { (trackId, record) -> cachedFileExists(trackId, record.localPath) }
+        }
 
     fun isPlaylistDownloaded(playlistId: String): Boolean {
         synchronized(this) {