react-native-nitro-player 0.7.1-alpha.1 → 0.7.1-alpha.3

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

@@ -12,20 +12,24 @@ import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 /**
  * ExoPlayer event listener — translates low-level ExoPlayer callbacks into
  * TrackPlayerCore state mutations and JS-facing listener notifications.
- * All callbacks fire on the player thread (ExoPlayerCore is built with playerThread.looper).
+ * All callbacks fire on the main looper (ExoPlayer uses the default application looper).
  */
 internal class TrackPlayerEventListener(
     private val core: TrackPlayerCore,
 ) : Player.Listener {
-
-    override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
+    override fun onMediaItemTransition(
+        mediaItem: MediaItem?,
+        reason: Int,
+    ) {
         with(core) {
             // TRACK repeat: REPEAT_MODE_ONE fires this every loop — not a real track change
             if (reason == Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT) return
 
             // Remove the track that just finished/was skipped from temp lists
-            if ((reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO ||
-                        reason == Player.MEDIA_ITEM_TRANSITION_REASON_SEEK) &&
+            if ((
+                    reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO ||
+                        reason == Player.MEDIA_ITEM_TRANSITION_REASON_SEEK
+                ) &&
                 previousMediaItem != null
             ) {
                 previousMediaItem?.mediaId?.let { mediaId ->
@@ -54,12 +58,13 @@ internal class TrackPlayerEventListener(
             }
 
             val track = getCurrentTrack() ?: return
-            val r = when (reason) {
-                Player.MEDIA_ITEM_TRANSITION_REASON_AUTO -> Reason.END
-                Player.MEDIA_ITEM_TRANSITION_REASON_SEEK -> Reason.USER_ACTION
-                Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED -> Reason.USER_ACTION
-                else -> null
-            }
+            val r =
+                when (reason) {
+                    Player.MEDIA_ITEM_TRANSITION_REASON_AUTO -> Reason.END
+                    Player.MEDIA_ITEM_TRANSITION_REASON_SEEK -> Reason.USER_ACTION
+                    Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED -> Reason.USER_ACTION
+                    else -> null
+                }
             notifyTrackChange(track, r)
             mediaSessionManager?.onTrackChanged(track)
             checkUpcomingTracksForUrls(lookaheadCount)
@@ -67,13 +72,19 @@ internal class TrackPlayerEventListener(
         }
     }
 
-    override fun onTimelineChanged(timeline: androidx.media3.common.Timeline, reason: Int) {
+    override fun onTimelineChanged(
+        timeline: androidx.media3.common.Timeline,
+        reason: Int,
+    ) {
         if (reason == Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED) {
             NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
         }
     }
 
-    override fun onPlayWhenReadyChanged(playWhenReady: Boolean, reason: Int) {
+    override fun onPlayWhenReadyChanged(
+        playWhenReady: Boolean,
+        reason: Int,
+    ) {
         val r = if (reason == Player.PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST) Reason.USER_ACTION else null
         core.emitStateChange(r)
     }

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

@@ -9,15 +9,24 @@ import com.margelo.nitro.nitroplayer.TrackPlayerState
  * All methods must be called from the player thread (already serialised).
  */
 
-internal fun TrackPlayerCore.notifyTrackChange(track: TrackItem, reason: Reason?) {
+internal fun TrackPlayerCore.notifyTrackChange(
+    track: TrackItem,
+    reason: Reason?,
+) {
     onChangeTrackListeners.forEach { it(track, reason) }
 }
 
-internal fun TrackPlayerCore.notifyPlaybackStateChange(state: TrackPlayerState, reason: Reason?) {
+internal fun TrackPlayerCore.notifyPlaybackStateChange(
+    state: TrackPlayerState,
+    reason: Reason?,
+) {
     onPlaybackStateChangeListeners.forEach { it(state, reason) }
 }
 
-internal fun TrackPlayerCore.notifySeek(position: Double, duration: Double) {
+internal fun TrackPlayerCore.notifySeek(
+    position: Double,
+    duration: Double,
+) {
     onSeekListeners.forEach { it(position, duration) }
 }
 
@@ -29,7 +38,10 @@ internal fun TrackPlayerCore.notifyPlaybackProgress(
     onProgressListeners.forEach { it(position, duration, isManuallySeeked) }
 }
 
-internal fun TrackPlayerCore.notifyTracksNeedUpdate(tracks: List<TrackItem>, lookahead: Int) {
+internal fun TrackPlayerCore.notifyTracksNeedUpdate(
+    tracks: List<TrackItem>,
+    lookahead: Int,
+) {
     onTracksNeedUpdateListeners.forEach { it(tracks, lookahead) }
 }
 

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

@@ -16,80 +16,99 @@ import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 
 suspend fun TrackPlayerCore.play() = withPlayerContext { exo.play() }
 
-
 suspend fun TrackPlayerCore.pause() = withPlayerContext { exo.pause() }
 
-suspend fun TrackPlayerCore.seek(position: Double) = withPlayerContext {
-    isManuallySeeked = true
-    exo.seekTo((position * 1000).toLong())
-}
+suspend fun TrackPlayerCore.seek(position: Double) =
+    withPlayerContext {
+        isManuallySeeked = true
+        exo.seekTo((position * 1000).toLong())
+    }
 
-suspend fun TrackPlayerCore.skipToNext() = withPlayerContext {
-    if (exo.hasNextMediaItem()) {
-        exo.seekToNext()
-        checkUpcomingTracksForUrls(lookaheadCount)
+suspend fun TrackPlayerCore.skipToNext() =
+    withPlayerContext {
+        if (exo.hasNextMediaItem()) {
+            exo.seekToNext()
+            checkUpcomingTracksForUrls(lookaheadCount)
+        }
     }
-}
 
-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)
-                    }
-                    TrackPlayerCore.TemporaryType.UP_NEXT -> {
-                        val idx = upNextQueue.indexOfFirst { it.id == trackId }
-                        if (idx >= 0) upNextQueue.removeAt(idx)
+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)
+                        }
+
+                        TrackPlayerCore.TemporaryType.UP_NEXT -> {
+                            val idx = upNextQueue.indexOfFirst { it.id == trackId }
+                            if (idx >= 0) upNextQueue.removeAt(idx)
+                        }
+
+                        else -> {}
                     }
-                    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 {
+        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 {
+        val clamped = volume.coerceIn(0.0, 100.0)
+        exo.setVolume((clamped / 100.0).toFloat())
+    }
 
-suspend fun TrackPlayerCore.configure(config: PlayerConfig) = withPlayerContext {
-    config.androidAutoEnabled?.let { NitroPlayerMediaBrowserService.isAndroidAutoEnabled = it }
-    config.lookaheadCount?.let { lookaheadCount = it.toInt() }
-    mediaSessionManager?.configure(config.androidAutoEnabled, config.carPlayEnabled, config.showInNotification)
-}
+suspend fun TrackPlayerCore.configure(config: PlayerConfig) =
+    withPlayerContext {
+        config.androidAutoEnabled?.let { NitroPlayerMediaBrowserService.isAndroidAutoEnabled = it }
+        config.lookaheadCount?.let { lookaheadCount = it.toInt() }
+        mediaSessionManager?.configure(config.androidAutoEnabled, config.carPlayEnabled, config.showInNotification)
+    }
 
-suspend fun TrackPlayerCore.playSong(songId: String, fromPlaylist: String?) = withPlayerContext {
+suspend fun TrackPlayerCore.playSong(
+    songId: String,
+    fromPlaylist: String?,
+) = withPlayerContext {
     playSongInternal(songId, fromPlaylist)
 }
 
-internal fun TrackPlayerCore.playSongInternal(songId: String, fromPlaylist: String?) {
+internal fun TrackPlayerCore.playSongInternal(
+    songId: String,
+    fromPlaylist: String?,
+) {
     playNextStack.clear()
     upNextQueue.clear()
     currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
@@ -102,7 +121,9 @@ internal fun TrackPlayerCore.playSongInternal(songId: String, fromPlaylist: Stri
         if (playlist != null) {
             songIndex = playlist.tracks.indexOfFirst { it.id == songId }
             if (songIndex >= 0) targetPlaylistId = fromPlaylist else return
-        } else return
+        } else {
+            return
+        }
     } else {
         if (currentPlaylistId != null) {
             val cp = playlistManager.getPlaylist(currentPlaylistId!!)
@@ -114,12 +135,18 @@ internal fun TrackPlayerCore.playSongInternal(songId: String, fromPlaylist: Stri
         if (songIndex == -1) {
             for (playlist in playlistManager.getAllPlaylists()) {
                 songIndex = playlist.tracks.indexOfFirst { it.id == songId }
-                if (songIndex >= 0) { targetPlaylistId = playlist.id; break }
+                if (songIndex >= 0) {
+                    targetPlaylistId = playlist.id
+                    break
+                }
             }
         }
         if (songIndex == -1) {
             val all = playlistManager.getAllPlaylists()
-            if (all.isNotEmpty()) { targetPlaylistId = all[0].id; songIndex = 0 }
+            if (all.isNotEmpty()) {
+                targetPlaylistId = all[0].id
+                songIndex = 0
+            }
         }
     }
 
@@ -137,26 +164,28 @@ internal fun TrackPlayerCore.playSongInternal(songId: String, fromPlaylist: Stri
 
 internal fun TrackPlayerCore.emitStateChange(reason: Reason? = null) {
     if (!isExoInitialized) return
-    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 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 actualReason = reason ?: if (exo.playbackState == Player.STATE_ENDED) Reason.END else null
     notifyPlaybackStateChange(state, actualReason)
     mediaSessionManager?.onPlaybackStateChanged(state == TrackPlayerState.PLAYING)
 }
 
-
 // ── 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 {
+        if (speed <= 0.0) throw IllegalArgumentException("Speed must be greater than 0")
+        if (isExoInitialized) exo.setPlaybackSpeed(speed.toFloat())
+    }
 
-suspend fun TrackPlayerCore.getPlayBackSpeed(): Double = withPlayerContext {
-    if (isExoInitialized) exo.getPlaybackSpeed().toDouble() else 1.0
-}
+suspend fun TrackPlayerCore.getPlayBackSpeed(): Double =
+    withPlayerContext {
+        if (isExoInitialized) exo.getPlaybackSpeed().toDouble() else 1.0
+    }

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,11 +76,12 @@ 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
@@ -86,7 +93,10 @@ internal fun TrackPlayerCore.getActualQueueInternal(): List<TrackItem> {
     if (currentTemporaryType == TrackPlayerCore.TemporaryType.PLAY_NEXT && currentId != null) {
         var skipped = false
         for (track in playNextStack) {
-            if (!skipped && track.id == currentId) { skipped = true; continue }
+            if (!skipped && track.id == currentId) {
+                skipped = true
+                continue
+            }
             queue.add(track)
         }
     } else if (currentTemporaryType != TrackPlayerCore.TemporaryType.PLAY_NEXT) {
@@ -97,7 +107,10 @@ internal fun TrackPlayerCore.getActualQueueInternal(): List<TrackItem> {
     if (currentTemporaryType == TrackPlayerCore.TemporaryType.UP_NEXT && currentId != null) {
         var skipped = false
         for (track in upNextQueue) {
-            if (!skipped && track.id == currentId) { skipped = true; continue }
+            if (!skipped && track.id == currentId) {
+                skipped = true
+                continue
+            }
             queue.add(track)
         }
     } else if (currentTemporaryType != TrackPlayerCore.TemporaryType.UP_NEXT) {
@@ -130,8 +143,14 @@ 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 targetTrack = actualQueue[index]
@@ -158,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()
@@ -44,12 +45,26 @@ internal fun TrackPlayerCore.rebuildQueueFromCurrentPosition() {
 
     // If current track was removed from the playlist, jump to best substitute
     val currentTrackId = exo.currentMediaItem?.mediaId?.let { extractTrackId(it) }
-    if (currentTrackId != null && currentTracks.none { it.id == currentTrackId }) {
+
+    if (
+        currentTrackId != null && 
+        currentTracks.none { it.id == currentTrackId } &&
+        currentTemporaryType == TrackPlayerCore.TemporaryType.NONE
+    ) {
         if (currentTracks.isEmpty()) return
         playFromIndexInternal(minOf(currentTrackIndex, currentTracks.size - 1))
         return
     }
 
+    // Keep the logical playlist pointer in sync after playlist mutations.
+    // Without this, getActualQueue/getState can report a stale index until the next track transition.
+    if (currentTemporaryType == TrackPlayerCore.TemporaryType.NONE && currentTrackId != null) {
+        val resolvedIndex = currentTracks.indexOfFirst { it.id == currentTrackId }
+        if (resolvedIndex >= 0) {
+            currentTrackIndex = resolvedIndex
+        }
+    }
+
     val newQueueTracks = ArrayList<TrackItem>(playNextStack.size + upNextQueue.size + currentTracks.size)
     val currentId = exo.currentMediaItem?.mediaId?.let { extractTrackId(it) }
 
@@ -57,7 +72,10 @@ internal fun TrackPlayerCore.rebuildQueueFromCurrentPosition() {
     if (currentTemporaryType == TrackPlayerCore.TemporaryType.PLAY_NEXT && currentId != null) {
         var skipped = false
         for (track in playNextStack) {
-            if (!skipped && track.id == currentId) { skipped = true; continue }
+            if (!skipped && track.id == currentId) {
+                skipped = true
+                continue
+            }
             newQueueTracks.add(track)
         }
     } else if (currentTemporaryType != TrackPlayerCore.TemporaryType.PLAY_NEXT) {
@@ -68,7 +86,10 @@ internal fun TrackPlayerCore.rebuildQueueFromCurrentPosition() {
     if (currentTemporaryType == TrackPlayerCore.TemporaryType.UP_NEXT && currentId != null) {
         var skipped = false
         for (track in upNextQueue) {
-            if (!skipped && track.id == currentId) { skipped = true; continue }
+            if (!skipped && track.id == currentId) {
+                skipped = true
+                continue
+            }
             newQueueTracks.add(track)
         }
     } else if (currentTemporaryType != TrackPlayerCore.TemporaryType.UP_NEXT) {
@@ -81,10 +102,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)
@@ -97,10 +119,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()
@@ -109,19 +132,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())
@@ -166,5 +198,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

@@ -1,18 +1,23 @@
 package com.margelo.nitro.nitroplayer.core
 
+import com.margelo.nitro.nitroplayer.equalizer.EqualizerCore
 import com.margelo.nitro.nitroplayer.media.MediaSessionManager
 import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
+import com.margelo.nitro.nitroplayer.media.NitroPlayerPlaybackService
 
 /**
- * Initialises ExoPlayer (via ExoPlayerCore) and MediaSessionManager on the player thread.
- * Called once from TrackPlayerCore.init via playerHandler.post.
+ * Initialises ExoPlayerCore wrapper and MediaSessionManager from the service binder.
+ * Called once from TrackPlayerCore's ServiceConnection.onServiceConnected via playerHandler.post.
  */
-internal fun TrackPlayerCore.initExoAndMedia() {
-    exo = ExoPlayerCore(context, playerThread)
+internal fun TrackPlayerCore.initFromService(binder: NitroPlayerPlaybackService.LocalBinder) {
+    // Wrap the service-owned ExoPlayer
+    exo = ExoPlayerCore(binder.exoPlayer)
 
-    mediaSessionManager = MediaSessionManager(context, exo.player, playlistManager).apply {
-        setTrackPlayerCore(this@initExoAndMedia)
-    }
+    // Wrap the service-owned MediaSession (no longer creates its own)
+    mediaSessionManager =
+        MediaSessionManager(context, binder.session, playlistManager).apply {
+            setTrackPlayerCore(this@initFromService)
+        }
 
     // Give MediaBrowserService access to this core and media session
     NitroPlayerMediaBrowserService.trackPlayerCore = this
@@ -23,6 +28,20 @@ internal fun TrackPlayerCore.initExoAndMedia() {
     playerListener = listener
     exo.addListener(listener)
 
-    // Start progress ticks on the player thread
+    // The audio session ID is assigned during ExoPlayer construction (in
+    // PlaybackService.onCreate), before our listener is attached.
+    // onAudioSessionIdChanged only fires on *changes*, so we'd miss the
+    // initial value. Manually feed it to the equalizer now.
+    val sessionId = binder.exoPlayer.audioSessionId
+    if (sessionId != 0) {
+        try {
+            EqualizerCore.getInstance(context).initialize(sessionId)
+        } catch (_: Exception) { }
+    }
+
+    // Start progress ticks on the main looper
     playerHandler.postDelayed(progressUpdateRunnable, 250)
+
+    // Signal that the player is ready — unblocks all withPlayerContext callers
+    completeServiceReady()
 }