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

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

@@ -8,7 +8,7 @@ import com.margelo.nitro.NitroModules
 import com.margelo.nitro.core.NullType
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.nitroplayer.core.TrackPlayerCore
-import com.margelo.nitro.nitroplayer.core.loadPlaylist
+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
@@ -109,13 +109,24 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
 
     // ── Playback control ──────────────────────────────────────────────────────
 
-    override fun loadPlaylist(playlistId: String, index: Double?): Promise<Unit> =
-        Promise.async {
-            val startIndex = index?.toInt()
-            val loaded = playlistManager.loadPlaylist(playlistId, startIndex)
-            if (!loaded) return@async
-            core.loadPlaylist(playlistId, startIndex)
+    /**
+     * Enqueued synchronously on the player looper so a `loadPlaylist()` followed by
+     * `play()` from JS cannot be reordered — see HybridTrackPlayer.enqueue.
+     */
+    override fun loadPlaylist(
+        playlistId: String,
+        index: Double?,
+    ): Promise<Unit> {
+        val startIndex = index?.toInt()
+        val promise = Promise<Unit>()
+        core.enqueue {
+            if (playlistManager.loadPlaylist(playlistId, startIndex)) {
+                core.loadPlaylistOnQueue(playlistId, startIndex)
+            }
+            promise.resolve(Unit)
         }
+        return promise
+    }
 
     override fun getCurrentPlaylistId(): Variant_NullType_String {
         val id = core.getCurrentPlaylistId()

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

@@ -7,35 +7,30 @@ 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.addToUpNext
-import com.margelo.nitro.nitroplayer.core.clearPlayNext
-import com.margelo.nitro.nitroplayer.core.clearUpNext
-import com.margelo.nitro.nitroplayer.core.configure
-import com.margelo.nitro.nitroplayer.core.getActualQueue
-import com.margelo.nitro.nitroplayer.core.getCurrentTrackIndex
-import com.margelo.nitro.nitroplayer.core.getNextTracks
-import com.margelo.nitro.nitroplayer.core.getPlayBackSpeed
-import com.margelo.nitro.nitroplayer.core.getPlayNextQueue
+import com.margelo.nitro.nitroplayer.core.addToUpNextInternal
+import com.margelo.nitro.nitroplayer.core.clearPlayNextOnQueue
+import com.margelo.nitro.nitroplayer.core.clearUpNextOnQueue
+import com.margelo.nitro.nitroplayer.core.configureOnQueue
+import com.margelo.nitro.nitroplayer.core.getActualQueueInternal
+import com.margelo.nitro.nitroplayer.core.getNextTracksInternal
 import com.margelo.nitro.nitroplayer.core.getRepeatMode
-import com.margelo.nitro.nitroplayer.core.getState
-import com.margelo.nitro.nitroplayer.core.getTracksById
-import com.margelo.nitro.nitroplayer.core.getTracksNeedingUrls
-import com.margelo.nitro.nitroplayer.core.getUpNextQueue
-import com.margelo.nitro.nitroplayer.core.pause
-import com.margelo.nitro.nitroplayer.core.play
-import com.margelo.nitro.nitroplayer.core.playNext
-import com.margelo.nitro.nitroplayer.core.playSong
-import com.margelo.nitro.nitroplayer.core.removeFromPlayNext
-import com.margelo.nitro.nitroplayer.core.removeFromUpNext
-import com.margelo.nitro.nitroplayer.core.reorderTemporaryTrack
-import com.margelo.nitro.nitroplayer.core.seek
-import com.margelo.nitro.nitroplayer.core.setPlayBackSpeed
-import com.margelo.nitro.nitroplayer.core.setRepeatMode
-import com.margelo.nitro.nitroplayer.core.setVolume
-import com.margelo.nitro.nitroplayer.core.skipToIndex
-import com.margelo.nitro.nitroplayer.core.skipToNext
-import com.margelo.nitro.nitroplayer.core.skipToPrevious
-import com.margelo.nitro.nitroplayer.core.updateTracks
+import com.margelo.nitro.nitroplayer.core.getStateInternal
+import com.margelo.nitro.nitroplayer.core.getTracksNeedingUrlsInternal
+import com.margelo.nitro.nitroplayer.core.pauseOnQueue
+import com.margelo.nitro.nitroplayer.core.playNextInternal
+import com.margelo.nitro.nitroplayer.core.playOnQueue
+import com.margelo.nitro.nitroplayer.core.playSongInternal
+import com.margelo.nitro.nitroplayer.core.removeFromPlayNextOnQueue
+import com.margelo.nitro.nitroplayer.core.removeFromUpNextOnQueue
+import com.margelo.nitro.nitroplayer.core.reorderTemporaryTrackOnQueue
+import com.margelo.nitro.nitroplayer.core.seekOnQueue
+import com.margelo.nitro.nitroplayer.core.setPlayBackSpeedOnQueue
+import com.margelo.nitro.nitroplayer.core.setRepeatModeOnQueue
+import com.margelo.nitro.nitroplayer.core.setVolumeOnQueue
+import com.margelo.nitro.nitroplayer.core.skipToIndexInternal
+import com.margelo.nitro.nitroplayer.core.skipToNextOnQueue
+import com.margelo.nitro.nitroplayer.core.skipToPreviousOnQueue
+import com.margelo.nitro.nitroplayer.core.updateTracksOnQueue
 
 @DoNotStrip
 @Keep
@@ -52,79 +47,99 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
         core = TrackPlayerCore.getInstance(context)
     }
 
+    // ── Ordered dispatch ──────────────────────────────────────────────────────
+    //
+    // `Promise.async { … }` launches an unordered coroutine, so the hop onto the player
+    // looper happened at an arbitrary later point: two calls made in order from JS could
+    // reach the player in reverse order (play-then-pause landing as pause-then-play).
+    // `core.enqueue` appends synchronously, on the JS thread at call time, so execution
+    // order equals JS call order.
+
+    private fun <T> enqueue(block: () -> T): Promise<T> {
+        val promise = Promise<T>()
+        core.enqueue {
+            try {
+                promise.resolve(block())
+            } catch (e: Throwable) {
+                promise.reject(e)
+            }
+        }
+        return promise
+    }
+
     // ── Playback ─────────────────────────────────────────────────────────────
 
-    override fun play(): Promise<Unit> = Promise.async { core.play() }
+    override fun play(): Promise<Unit> = enqueue { core.playOnQueue() }
 
-    override fun pause(): Promise<Unit> = Promise.async { core.pause() }
+    override fun pause(): Promise<Unit> = enqueue { core.pauseOnQueue() }
 
-    override fun seek(position: Double): Promise<Unit> = Promise.async { core.seek(position) }
+    override fun seek(position: Double): Promise<Unit> = enqueue { core.seekOnQueue(position) }
 
-    override fun skipToNext(): Promise<Unit> = Promise.async { core.skipToNext() }
+    override fun skipToNext(): Promise<Unit> = enqueue { core.skipToNextOnQueue() }
 
-    override fun skipToPrevious(): Promise<Unit> = Promise.async { core.skipToPrevious() }
+    override fun skipToPrevious(): Promise<Unit> = enqueue { core.skipToPreviousOnQueue() }
 
     override fun playSong(
         songId: String,
         fromPlaylist: String?,
-    ): Promise<Unit> = Promise.async { core.playSong(songId, fromPlaylist) }
+    ): Promise<Unit> = enqueue { core.playSongInternal(songId, fromPlaylist) }
 
-    override fun skipToIndex(index: Double): Promise<Boolean> = Promise.async { core.skipToIndex(index.toInt()) }
+    override fun skipToIndex(index: Double): Promise<Boolean> = enqueue { core.skipToIndexInternal(index.toInt()) }
 
-    override fun setRepeatMode(mode: RepeatMode): Promise<Unit> = Promise.async { core.setRepeatMode(mode) }
+    override fun setRepeatMode(mode: RepeatMode): Promise<Unit> = enqueue { core.setRepeatModeOnQueue(mode) }
 
     override fun getRepeatMode(): RepeatMode = core.getRepeatMode()
 
-    override fun setVolume(volume: Double): Promise<Unit> = Promise.async { core.setVolume(volume) }
+    override fun setVolume(volume: Double): Promise<Unit> = enqueue { core.setVolumeOnQueue(volume) }
 
-    override fun configure(config: PlayerConfig): Promise<Unit> = Promise.async { core.configure(config) }
+    override fun configure(config: PlayerConfig): Promise<Unit> = enqueue { core.configureOnQueue(config) }
 
     // ── Queue / state reads ───────────────────────────────────────────────────
 
-    override fun getActualQueue(): Promise<Array<TrackItem>> = Promise.async { core.getActualQueue().toTypedArray() }
+    override fun getActualQueue(): Promise<Array<TrackItem>> = enqueue { core.getActualQueueInternal().toTypedArray() }
 
-    override fun getState(): Promise<PlayerState> = Promise.async { core.getState() }
+    override fun getState(): Promise<PlayerState> = enqueue { core.getStateInternal() }
 
-    override fun getTracksById(trackIds: Array<String>): Promise<Array<TrackItem>> = Promise.async { core.getTracksById(trackIds.toList()).toTypedArray() }
+    override fun getTracksById(trackIds: Array<String>): Promise<Array<TrackItem>> = enqueue { core.getPlaylistManager().getTracksById(trackIds.toList()).toTypedArray() }
 
-    override fun getTracksNeedingUrls(): Promise<Array<TrackItem>> = Promise.async { core.getTracksNeedingUrls().toTypedArray() }
+    override fun getTracksNeedingUrls(): Promise<Array<TrackItem>> = enqueue { core.getTracksNeedingUrlsInternal().toTypedArray() }
 
-    override fun getNextTracks(count: Double): Promise<Array<TrackItem>> = Promise.async { core.getNextTracks(count.toInt()).toTypedArray() }
+    override fun getNextTracks(count: Double): Promise<Array<TrackItem>> = enqueue { core.getNextTracksInternal(count.toInt()).toTypedArray() }
 
-    override fun getCurrentTrackIndex(): Promise<Double> = Promise.async { core.getCurrentTrackIndex().toDouble() }
+    override fun getCurrentTrackIndex(): Promise<Double> = enqueue { core.currentTrackIndex.toDouble() }
 
     // ── URL updates ───────────────────────────────────────────────────────────
 
-    override fun updateTracks(tracks: Array<TrackItem>): Promise<Unit> = Promise.async { core.updateTracks(tracks.toList()) }
+    override fun updateTracks(tracks: Array<TrackItem>): Promise<Unit> = enqueue { core.updateTracksOnQueue(tracks.toList()) }
 
     // ── Temporary queue ───────────────────────────────────────────────────────
 
-    override fun addToUpNext(trackId: String): Promise<Unit> = Promise.async { core.addToUpNext(trackId) }
+    override fun addToUpNext(trackId: String): Promise<Unit> = enqueue { core.addToUpNextInternal(trackId) }
 
-    override fun playNext(trackId: String): Promise<Unit> = Promise.async { core.playNext(trackId) }
+    override fun playNext(trackId: String): Promise<Unit> = enqueue { core.playNextInternal(trackId) }
 
-    override fun removeFromPlayNext(trackId: String): Promise<Boolean> = Promise.async { core.removeFromPlayNext(trackId) }
+    override fun removeFromPlayNext(trackId: String): Promise<Boolean> = enqueue { core.removeFromPlayNextOnQueue(trackId) }
 
-    override fun removeFromUpNext(trackId: String): Promise<Boolean> = Promise.async { core.removeFromUpNext(trackId) }
+    override fun removeFromUpNext(trackId: String): Promise<Boolean> = enqueue { core.removeFromUpNextOnQueue(trackId) }
 
-    override fun clearPlayNext(): Promise<Unit> = Promise.async { core.clearPlayNext() }
+    override fun clearPlayNext(): Promise<Unit> = enqueue { core.clearPlayNextOnQueue() }
 
-    override fun clearUpNext(): Promise<Unit> = Promise.async { core.clearUpNext() }
+    override fun clearUpNext(): Promise<Unit> = enqueue { core.clearUpNextOnQueue() }
 
     override fun reorderTemporaryTrack(
         trackId: String,
         newIndex: Double,
-    ): Promise<Boolean> = Promise.async { core.reorderTemporaryTrack(trackId, newIndex.toInt()) }
+    ): Promise<Boolean> = enqueue { core.reorderTemporaryTrackOnQueue(trackId, newIndex.toInt()) }
 
-    override fun getPlayNextQueue(): Promise<Array<TrackItem>> = Promise.async { core.getPlayNextQueue().toTypedArray() }
+    override fun getPlayNextQueue(): Promise<Array<TrackItem>> = enqueue { core.playNextStack.toTypedArray() }
 
-    override fun getUpNextQueue(): Promise<Array<TrackItem>> = Promise.async { core.getUpNextQueue().toTypedArray() }
+    override fun getUpNextQueue(): Promise<Array<TrackItem>> = enqueue { core.upNextQueue.toTypedArray() }
 
     // ── Playback speed ────────────────────────────────────────────────────────
 
-    override fun setPlaybackSpeed(speed: Double): Promise<Unit> = Promise.async { core.setPlayBackSpeed(speed) }
+    override fun setPlaybackSpeed(speed: Double): Promise<Unit> = enqueue { core.setPlayBackSpeedOnQueue(speed) }
 
-    override fun getPlaybackSpeed(): Promise<Double> = Promise.async { core.getPlayBackSpeed() }
+    override fun getPlaybackSpeed(): Promise<Double> = enqueue { if (core.isExoInitialized) core.exo.getPlaybackSpeed().toDouble() else 1.0 }
 
     // ── Android Auto ──────────────────────────────────────────────────────────
 

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

@@ -94,6 +94,7 @@ class TrackPlayerCore private constructor(
         ListenerRegistry<(com.margelo.nitro.nitroplayer.CastState, String?) -> Unit>()
 
     // ── Google Cast ──────────────────────────────────────────────────────────
+
     /** Set once the playback service has a usable CastContext; null when Cast is unavailable. */
     internal var castSessionController: com.margelo.nitro.nitroplayer.media.CastSessionController? = null
 
@@ -104,18 +105,23 @@ class TrackPlayerCore private constructor(
     internal var lastCastWaitTrackId: String? = null
 
     // ── Progress & playlist-update runnables ───────────────────────────────
+
+    /**
+     * Emits progress once per second while actually playing (matching iOS), instead of
+     * four times a second regardless of state. A paused player has nothing to report,
+     * and every tick is a JS callback that re-renders every `useNowPlaying` consumer.
+     * A seek still reports immediately via `onPositionDiscontinuity`.
+     */
     internal val progressUpdateRunnable =
         object : Runnable {
             override fun run() {
-                if (::exo.isInitialized &&
-                    exo.playbackState != androidx.media3.common.Player.STATE_IDLE
-                ) {
+                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
                 }
-                playerHandler.postDelayed(this, 250)
+                playerHandler.postDelayed(this, PROGRESS_INTERVAL_MS)
             }
         }
 
@@ -155,7 +161,8 @@ class TrackPlayerCore private constructor(
                     }
                     try {
                         context.unbindService(this)
-                    } catch (_: Exception) {}
+                    } catch (_: Exception) {
+                    }
                     serviceBound = false
                     if (rebindAttempts < 3) {
                         rebindAttempts++
@@ -192,6 +199,8 @@ class TrackPlayerCore private constructor(
 
     // ── Singleton ──────────────────────────────────────────────────────────
     companion object {
+        internal const val PROGRESS_INTERVAL_MS = 1000L
+
         @Volatile
         @Suppress("ktlint:standard:property-naming")
         private var INSTANCE: TrackPlayerCore? = null
@@ -206,8 +215,18 @@ class TrackPlayerCore private constructor(
         // Defer service start/bind to the main thread so it doesn't run
         // synchronously on the JNI thread during HybridObject creation.
         handler.post {
-            val intent = Intent(context, NitroPlayerPlaybackService::class.java)
-            context.startService(intent)
+            // startService throws BackgroundServiceStartNotAllowedException on Android 12+
+            // when the process is in the background — which is exactly what happens when JS
+            // loads the module from a headless/backgrounded start. It is only here to keep
+            // the service alive across unbind; BIND_AUTO_CREATE below already creates it,
+            // and the service promotes itself to foreground once playback starts.
+            try {
+                context.startService(Intent(context, NitroPlayerPlaybackService::class.java))
+            } catch (e: Exception) {
+                NitroPlayerLogger.log("TrackPlayerCore") {
+                    "startService skipped (app in background): ${e.message}"
+                }
+            }
 
             val bindIntent =
                 Intent(context, NitroPlayerPlaybackService::class.java).apply {
@@ -219,6 +238,58 @@ class TrackPlayerCore private constructor(
 
     // ── Coroutine bridge to player looper (main thread) ────────────────────
 
+    // ── Ordered command dispatch ───────────────────────────────────────────
+    //
+    // `Promise.async { … }` launches an unordered coroutine, so the hop onto the
+    // player looper used to happen at an arbitrary later point: two calls made in
+    // order from JS could reach the player in reverse order (play-then-pause landing
+    // as pause-then-play). `enqueue` appends to a queue synchronously, on the JS
+    // thread at call time, so execution order equals JS call order — including for
+    // commands issued before the playback service has bound.
+
+    private val pendingCommands = ArrayDeque<() -> Unit>()
+    private var commandsDraining = false
+
+    /**
+     * Runs [block] on the player looper, preserving the order in which callers
+     * enqueued. Safe to call before the service binds — commands buffer until then.
+     */
+    internal fun enqueue(block: () -> Unit) {
+        synchronized(pendingCommands) {
+            pendingCommands.addLast(block)
+            if (commandsDraining) return
+            if (!::playerHandler.isInitialized) return
+            commandsDraining = true
+        }
+        playerHandler.post { drainCommands() }
+    }
+
+    private fun drainCommands() {
+        while (true) {
+            val next =
+                synchronized(pendingCommands) {
+                    val head = pendingCommands.removeFirstOrNull()
+                    if (head == null) commandsDraining = false
+                    head
+                } ?: return
+            next()
+        }
+    }
+
+    /** Called once the player looper exists — flushes anything queued before binding. */
+    internal fun startCommandDraining() {
+        val shouldPost =
+            synchronized(pendingCommands) {
+                if (commandsDraining || pendingCommands.isEmpty()) {
+                    false
+                } else {
+                    commandsDraining = true
+                    true
+                }
+            }
+        if (shouldPost) playerHandler.post { drainCommands() }
+    }
+
     internal suspend fun <T> withPlayerContext(block: () -> T): T {
         // Wait until the service is bound and player is initialized
         serviceReady.await()
@@ -256,13 +327,15 @@ class TrackPlayerCore private constructor(
             }
         }
         scope.cancel()
-        com.margelo.nitro.nitroplayer.media.AuthAwareHttpDataSourceFactory.clear()
+        com.margelo.nitro.nitroplayer.media.AuthAwareHttpDataSourceFactory
+            .clear()
         // Do NOT stop the service — it owns the player.
         // Unbind so Android can clean up if needed.
         if (serviceBound) {
             try {
                 context.unbindService(serviceConnection)
-            } catch (_: Exception) {}
+            } catch (_: Exception) {
+            }
             serviceBound = false
         }
     }

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

@@ -57,6 +57,16 @@ internal class TrackPlayerEventListener(
                 if (newIdx >= 0 && newIdx != currentTrackIndex) currentTrackIndex = newIdx
             }
 
+            // Top up the windowed timeline — the item we just left freed a slot.
+            // Only when it is actually short: rebuildQueueFromCurrentPosition can fall
+            // into the substitute-jump path (setMediaItems), which re-enters this very
+            // callback. The length check makes any such re-entry a no-op and terminate.
+            if (mediaItem != null &&
+                exo.mediaItemCount - exo.currentMediaItemIndex - 1 < QUEUE_WINDOW_SIZE
+            ) {
+                rebuildQueueFromCurrentPosition()
+            }
+
             val track = getCurrentTrack() ?: return
             val r =
                 when (reason) {

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