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

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

@@ -0,0 +1,122 @@
+@file:Suppress("ktlint:standard:max-line-length")
+
+package com.margelo.nitro.nitroplayer.core
+
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import com.margelo.nitro.nitroplayer.Reason
+import com.margelo.nitro.nitroplayer.RepeatMode
+import com.margelo.nitro.nitroplayer.equalizer.EqualizerCore
+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).
+ */
+internal class TrackPlayerEventListener(
+    private val core: TrackPlayerCore,
+) : Player.Listener {
+
+    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) &&
+                previousMediaItem != null
+            ) {
+                previousMediaItem?.mediaId?.let { mediaId ->
+                    val trackId = extractTrackId(mediaId)
+                    val pnIdx = playNextStack.indexOfFirst { it.id == trackId }
+                    if (pnIdx >= 0) {
+                        playNextStack.removeAt(pnIdx)
+                    } else {
+                        val unIdx = upNextQueue.indexOfFirst { it.id == trackId }
+                        if (unIdx >= 0) upNextQueue.removeAt(unIdx)
+                    }
+                }
+            }
+
+            // Track new current item as "previous" for the next transition
+            previousMediaItem = mediaItem
+
+            // Re-determine temporary type for the new current item
+            currentTemporaryType = determineCurrentTemporaryType()
+
+            // Update currentTrackIndex when landing on an original playlist track
+            if (currentTemporaryType == TrackPlayerCore.TemporaryType.NONE && mediaItem != null) {
+                val trackId = extractTrackId(mediaItem.mediaId)
+                val newIdx = currentTracks.indexOfFirst { it.id == trackId }
+                if (newIdx >= 0 && newIdx != currentTrackIndex) currentTrackIndex = newIdx
+            }
+
+            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
+            }
+            notifyTrackChange(track, r)
+            mediaSessionManager?.onTrackChanged(track)
+            checkUpcomingTracksForUrls(lookaheadCount)
+            notifyTemporaryQueueChange()
+        }
+    }
+
+    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) {
+        val r = if (reason == Player.PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST) Reason.USER_ACTION else null
+        core.emitStateChange(r)
+    }
+
+    override fun onPlaybackStateChanged(playbackState: Int) {
+        with(core) {
+            if (playbackState == Player.STATE_ENDED && currentRepeatMode == RepeatMode.PLAYLIST) {
+                playNextStack.clear()
+                upNextQueue.clear()
+                currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
+                rebuildQueueAndPlayFromIndex(0)
+                val firstTrack = currentTracks.getOrNull(0)
+                if (firstTrack != null) notifyTrackChange(firstTrack, Reason.REPEAT)
+                return
+            }
+            emitStateChange()
+        }
+    }
+
+    override fun onIsPlayingChanged(isPlaying: Boolean) {
+        core.emitStateChange()
+    }
+
+    override fun onPositionDiscontinuity(
+        oldPosition: Player.PositionInfo,
+        newPosition: Player.PositionInfo,
+        reason: Int,
+    ) {
+        if (reason == Player.DISCONTINUITY_REASON_SEEK) {
+            core.isManuallySeeked = true
+            val pos = core.exo.currentPosition / 1000.0
+            val dur = if (core.exo.duration > 0) core.exo.duration / 1000.0 else 0.0
+            core.notifySeek(pos, dur)
+        }
+    }
+
+    override fun onAudioSessionIdChanged(audioSessionId: Int) {
+        if (audioSessionId != 0) {
+            try {
+                EqualizerCore.getInstance(core.context).initialize(audioSessionId)
+            } catch (_: Exception) {
+                // Non-critical — device may not support equalizer
+            }
+        }
+    }
+}

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

@@ -0,0 +1,44 @@
+package com.margelo.nitro.nitroplayer.core
+
+import com.margelo.nitro.nitroplayer.Reason
+import com.margelo.nitro.nitroplayer.TrackItem
+import com.margelo.nitro.nitroplayer.TrackPlayerState
+
+/**
+ * Notification helpers — call the registered ListenerRegistry callbacks.
+ * All methods must be called from the player thread (already serialised).
+ */
+
+internal fun TrackPlayerCore.notifyTrackChange(track: TrackItem, reason: Reason?) {
+    onChangeTrackListeners.forEach { it(track, reason) }
+}
+
+internal fun TrackPlayerCore.notifyPlaybackStateChange(state: TrackPlayerState, reason: Reason?) {
+    onPlaybackStateChangeListeners.forEach { it(state, reason) }
+}
+
+internal fun TrackPlayerCore.notifySeek(position: Double, duration: Double) {
+    onSeekListeners.forEach { it(position, duration) }
+}
+
+internal fun TrackPlayerCore.notifyPlaybackProgress(
+    position: Double,
+    duration: Double,
+    isManuallySeeked: Boolean?,
+) {
+    onProgressListeners.forEach { it(position, duration, isManuallySeeked) }
+}
+
+internal fun TrackPlayerCore.notifyTracksNeedUpdate(tracks: List<TrackItem>, lookahead: Int) {
+    onTracksNeedUpdateListeners.forEach { it(tracks, lookahead) }
+}
+
+internal fun TrackPlayerCore.notifyTemporaryQueueChange() {
+    val pn = playNextStack.toList()
+    val un = upNextQueue.toList()
+    onTemporaryQueueChangeListeners.forEach { it(pn, un) }
+}
+
+internal fun TrackPlayerCore.notifyAndroidAutoConnection(connected: Boolean) {
+    onAndroidAutoConnectionListeners.forEach { it(connected) }
+}

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

@@ -0,0 +1,162 @@
+@file:Suppress("ktlint:standard:max-line-length")
+
+package com.margelo.nitro.nitroplayer.core
+
+import androidx.media3.common.Player
+import com.margelo.nitro.nitroplayer.PlayerConfig
+import com.margelo.nitro.nitroplayer.Reason
+import com.margelo.nitro.nitroplayer.RepeatMode
+import com.margelo.nitro.nitroplayer.TrackPlayerState
+import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
+
+/**
+ * Playback control — all public functions are suspend and execute on the player thread
+ * via withPlayerContext.
+ */
+
+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.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)
+                    }
+                    else -> {}
+                }
+            }
+            currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
+            playFromIndexInternal(currentTrackIndex)
+        }
+
+        currentTrackIndex > 0 -> playFromIndexInternal(currentTrackIndex - 1)
+
+        else -> exo.seekTo(0)
+    }
+    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
+        }
+    )
+}
+
+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.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 {
+    playSongInternal(songId, fromPlaylist)
+}
+
+internal fun TrackPlayerCore.playSongInternal(songId: String, fromPlaylist: String?) {
+    playNextStack.clear()
+    upNextQueue.clear()
+    currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
+
+    var targetPlaylistId: String? = null
+    var songIndex: Int = -1
+
+    if (fromPlaylist != null) {
+        val playlist = playlistManager.getPlaylist(fromPlaylist)
+        if (playlist != null) {
+            songIndex = playlist.tracks.indexOfFirst { it.id == songId }
+            if (songIndex >= 0) targetPlaylistId = fromPlaylist else return
+        } else return
+    } else {
+        if (currentPlaylistId != null) {
+            val cp = playlistManager.getPlaylist(currentPlaylistId!!)
+            if (cp != null) {
+                songIndex = cp.tracks.indexOfFirst { it.id == songId }
+                if (songIndex >= 0) targetPlaylistId = currentPlaylistId
+            }
+        }
+        if (songIndex == -1) {
+            for (playlist in playlistManager.getAllPlaylists()) {
+                songIndex = playlist.tracks.indexOfFirst { it.id == songId }
+                if (songIndex >= 0) { targetPlaylistId = playlist.id; break }
+            }
+        }
+        if (songIndex == -1) {
+            val all = playlistManager.getAllPlaylists()
+            if (all.isNotEmpty()) { targetPlaylistId = all[0].id; songIndex = 0 }
+        }
+    }
+
+    if (targetPlaylistId == null || songIndex < 0) return
+
+    if (currentPlaylistId != targetPlaylistId) {
+        val playlist = playlistManager.getPlaylist(targetPlaylistId) ?: return
+        currentPlaylistId = targetPlaylistId
+        updatePlayerQueue(playlist.tracks)
+    }
+    playFromIndexInternal(songIndex)
+}
+
+// ── State emission (called from player thread) ─────────────────────────────
+
+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 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.getPlayBackSpeed(): Double = withPlayerContext {
+    if (isExoInitialized) exo.getPlaybackSpeed().toDouble() else 1.0
+}

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

@@ -0,0 +1,165 @@
+@file:Suppress("ktlint:standard:max-line-length")
+
+package com.margelo.nitro.nitroplayer.core
+
+import androidx.media3.common.Player
+import com.margelo.nitro.nitroplayer.CurrentPlayingType
+import com.margelo.nitro.nitroplayer.PlayerState
+import com.margelo.nitro.nitroplayer.TrackItem
+import com.margelo.nitro.nitroplayer.TrackPlayerState
+import com.margelo.nitro.nitroplayer.Variant_NullType_String
+import com.margelo.nitro.nitroplayer.Variant_NullType_TrackItem
+
+/**
+ * State read + index-navigation — all public functions are suspend and run on the
+ * player thread via withPlayerContext.
+ */
+
+// ── Player state ──────────────────────────────────────────────────────────
+
+suspend fun TrackPlayerCore.getState(): PlayerState = withPlayerContext { getStateInternal() }
+
+internal fun TrackPlayerCore.getStateInternal(): PlayerState {
+    if (!isExoInitialized) {
+        return PlayerState(
+            currentTrack = null,
+            currentPosition = 0.0,
+            totalDuration = 0.0,
+            currentState = TrackPlayerState.STOPPED,
+            currentPlaylistId = currentPlaylistId?.let { Variant_NullType_String.create(it) },
+            currentIndex = -1.0,
+            currentPlayingType = CurrentPlayingType.NOT_PLAYING,
+        )
+    }
+    val track = getCurrentTrack()
+    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
+    }
+    return PlayerState(
+        currentTrack = currentTrack,
+        currentPosition = position,
+        totalDuration = duration,
+        currentState = state,
+        currentPlaylistId = currentPlaylistId?.let { Variant_NullType_String.create(it) },
+        currentIndex = if (exo.currentMediaItemIndex >= 0) exo.currentMediaItemIndex.toDouble() else -1.0,
+        currentPlayingType = playingType,
+    )
+}
+
+// ── Actual queue ──────────────────────────────────────────────────────────
+
+suspend fun TrackPlayerCore.getActualQueue(): List<TrackItem> = withPlayerContext { getActualQueueInternal() }
+
+internal fun TrackPlayerCore.getActualQueueInternal(): List<TrackItem> {
+    if (!isExoInitialized) return emptyList()
+    val currentIndex = currentTrackIndex
+    if (currentIndex < 0) return emptyList()
+
+    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
+    }
+    if (beforeEnd > 0) queue.addAll(currentTracks.subList(0, beforeEnd))
+
+    // Current track
+    getCurrentTrack()?.let { queue.add(it) }
+
+    // playNext — skip index 0 if it is the current item
+    if (currentTemporaryType == TrackPlayerCore.TemporaryType.PLAY_NEXT && playNextStack.size > 1) {
+        queue.addAll(playNextStack.subList(1, playNextStack.size))
+    } else if (currentTemporaryType != TrackPlayerCore.TemporaryType.PLAY_NEXT) {
+        queue.addAll(playNextStack)
+    }
+
+    // upNext — skip index 0 if it is the current item
+    if (currentTemporaryType == TrackPlayerCore.TemporaryType.UP_NEXT && upNextQueue.size > 1) {
+        queue.addAll(upNextQueue.subList(1, upNextQueue.size))
+    } else if (currentTemporaryType != TrackPlayerCore.TemporaryType.UP_NEXT) {
+        queue.addAll(upNextQueue)
+    }
+
+    // Remaining original tracks
+    if (currentIndex + 1 < currentTracks.size) {
+        queue.addAll(currentTracks.subList(currentIndex + 1, currentTracks.size))
+    }
+    return queue
+}
+
+// ── Index navigation ──────────────────────────────────────────────────────
+
+suspend fun TrackPlayerCore.skipToIndex(index: Int): Boolean = withPlayerContext { skipToIndexInternal(index) }
+
+private fun TrackPlayerCore.skipToIndexInternal(index: Int): Boolean {
+    if (!isExoInitialized) return false
+    val actualQueue = getActualQueueInternal()
+    if (index < 0 || index >= actualQueue.size) return false
+
+    val currentPos = if (currentTemporaryType != TrackPlayerCore.TemporaryType.NONE) currentTrackIndex + 1 else currentTrackIndex
+    val effectivePlayNextSize = if (currentTemporaryType == TrackPlayerCore.TemporaryType.PLAY_NEXT) maxOf(0, playNextStack.size - 1) else playNextStack.size
+    val effectiveUpNextSize = if (currentTemporaryType == TrackPlayerCore.TemporaryType.UP_NEXT) maxOf(0, upNextQueue.size - 1) else upNextQueue.size
+
+    val playNextStart = currentPos + 1
+    val playNextEnd = playNextStart + effectivePlayNextSize
+    val upNextStart = playNextEnd
+    val upNextEnd = upNextStart + effectiveUpNextSize
+    val originalRemainingStart = upNextEnd
+
+    if (index < currentPos) { playFromIndexInternal(index); return true }
+    if (index == currentPos) { exo.seekTo(0); return true }
+
+    if (index in playNextStart until playNextEnd) {
+        val listIndex = (index - playNextStart) + if (currentTemporaryType == TrackPlayerCore.TemporaryType.PLAY_NEXT) 1 else 0
+        if (listIndex > 0) playNextStack.subList(0, listIndex).clear()
+        rebuildQueueFromCurrentPosition()
+        exo.seekToNext()
+        return true
+    }
+
+    if (index in upNextStart until upNextEnd) {
+        val listIndex = (index - upNextStart) + if (currentTemporaryType == TrackPlayerCore.TemporaryType.UP_NEXT) 1 else 0
+        playNextStack.clear()
+        if (listIndex > 0) upNextQueue.subList(0, listIndex).clear()
+        rebuildQueueFromCurrentPosition()
+        exo.seekToNext()
+        return true
+    }
+
+    if (index >= originalRemainingStart) {
+        val targetTrack = actualQueue[index]
+        val originalIndex = currentTracks.indexOfFirst { it.id == targetTrack.id }
+        if (originalIndex == -1) return false
+        playNextStack.clear(); upNextQueue.clear()
+        currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
+        rebuildQueueAndPlayFromIndex(originalIndex)
+        checkUpcomingTracksForUrls(lookaheadCount)
+        return true
+    }
+
+    checkUpcomingTracksForUrls(lookaheadCount)
+    return false
+}
+
+suspend fun TrackPlayerCore.playFromIndex(index: Int) = withPlayerContext { playFromIndexInternal(index) }
+
+internal fun TrackPlayerCore.playFromIndexInternal(index: Int) {
+    playNextStack.clear()
+    upNextQueue.clear()
+    currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
+    rebuildQueueAndPlayFromIndex(index)
+}

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

@@ -0,0 +1,161 @@
+@file:Suppress("ktlint:standard:max-line-length")
+
+package com.margelo.nitro.nitroplayer.core
+
+import android.net.Uri
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.Player
+import com.margelo.nitro.nitroplayer.TrackItem
+
+/**
+ * Queue-building helpers — called exclusively on the player thread.
+ * Surgical rebuild (removeMediaItems + addMediaItems) preserves the current item
+ * for gapless playback; full rebuild (clearMediaItems + setMediaItems) is used only
+ * when jumping to a specific index.
+ */
+
+// ── Full rebuild (jump to index) ───────────────────────────────────────────
+
+internal fun TrackPlayerCore.rebuildQueueAndPlayFromIndex(index: Int) {
+    if (!isExoInitialized) return
+    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)
+    }
+
+    currentTrackIndex = index
+    exo.clearMediaItems()
+    exo.setMediaItems(mediaItems)
+    exo.seekToDefaultPosition(0)
+    exo.playWhenReady = true
+    exo.prepare()
+}
+
+// ── Surgical rebuild (preserve current item) ──────────────────────────────
+
+internal fun TrackPlayerCore.rebuildQueueFromCurrentPosition() {
+    if (!isExoInitialized) return
+    val currentIndex = exo.currentMediaItemIndex
+    if (currentIndex < 0) return
+
+    // 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 (currentTracks.isEmpty()) return
+        playFromIndexInternal(minOf(currentTrackIndex, currentTracks.size - 1))
+        return
+    }
+
+    val newQueueTracks = ArrayList<TrackItem>(playNextStack.size + upNextQueue.size + currentTracks.size)
+
+    // playNext stack — skip index 0 if it is the currently playing item
+    if (currentTemporaryType == TrackPlayerCore.TemporaryType.PLAY_NEXT && playNextStack.size > 1) {
+        newQueueTracks.addAll(playNextStack.subList(1, playNextStack.size))
+    } else if (currentTemporaryType != TrackPlayerCore.TemporaryType.PLAY_NEXT) {
+        newQueueTracks.addAll(playNextStack)
+    }
+
+    // upNext queue — skip index 0 if it is the currently playing item
+    if (currentTemporaryType == TrackPlayerCore.TemporaryType.UP_NEXT && upNextQueue.size > 1) {
+        newQueueTracks.addAll(upNextQueue.subList(1, upNextQueue.size))
+    } else if (currentTemporaryType != TrackPlayerCore.TemporaryType.UP_NEXT) {
+        newQueueTracks.addAll(upNextQueue)
+    }
+
+    // Remaining original tracks (after currentTrackIndex, not after ExoPlayer's currentIndex)
+    if (currentTrackIndex + 1 < currentTracks.size) {
+        newQueueTracks.addAll(currentTracks.subList(currentTrackIndex + 1, currentTracks.size))
+    }
+
+    val playlistId = currentPlaylistId ?: ""
+    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)
+    }
+    exo.addMediaItems(newMediaItems)
+}
+
+// ── Full queue set (initial load or no active item) ───────────────────────
+
+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)
+    }
+    exo.setMediaItems(mediaItems, false)
+    if (exo.playbackState == Player.STATE_IDLE && mediaItems.isNotEmpty()) {
+        exo.prepare()
+    }
+}
+
+// ── 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)
+
+    track.artwork?.asSecondOrNull()?.let { artworkUrl ->
+        try { metaBuilder.setArtworkUri(Uri.parse(artworkUrl)) } catch (_: Exception) {}
+    }
+
+    val effectiveUrl = downloadManager.getEffectiveUrl(track)
+
+    return MediaItem.Builder()
+        .setMediaId(customMediaId ?: track.id)
+        .setUri(effectiveUrl)
+        .setMediaMetadata(metaBuilder.build())
+        .build()
+}
+
+// ── Track lookup helpers ───────────────────────────────────────────────────
+
+internal fun TrackPlayerCore.findTrack(mediaItem: MediaItem?): TrackItem? {
+    if (mediaItem == null) return null
+    val trackId = extractTrackId(mediaItem.mediaId)
+    return currentTracks.find { it.id == trackId }
+}
+
+internal fun TrackPlayerCore.findTrackById(trackId: String): TrackItem? {
+    currentTracks.find { it.id == trackId }?.let { return it }
+    for (playlist in playlistManager.getAllPlaylists()) {
+        playlist.tracks.find { it.id == trackId }?.let { return it }
+    }
+    return null
+}
+
+internal fun TrackPlayerCore.getCurrentTrack(): TrackItem? {
+    if (!isExoInitialized) return null
+    val currentMediaItem = exo.currentMediaItem ?: return null
+    if (currentTemporaryType != TrackPlayerCore.TemporaryType.NONE) {
+        val trackId = extractTrackId(currentMediaItem.mediaId)
+        return when (currentTemporaryType) {
+            TrackPlayerCore.TemporaryType.PLAY_NEXT -> playNextStack.firstOrNull { it.id == trackId }
+            TrackPlayerCore.TemporaryType.UP_NEXT -> upNextQueue.firstOrNull { it.id == trackId }
+            else -> null
+        }
+    }
+    return findTrack(currentMediaItem)
+}
+
+internal fun TrackPlayerCore.determineCurrentTemporaryType(): TrackPlayerCore.TemporaryType {
+    val currentItem = exo.currentMediaItem ?: return TrackPlayerCore.TemporaryType.NONE
+    val trackId = extractTrackId(currentItem.mediaId)
+    if (playNextStack.any { it.id == trackId }) return TrackPlayerCore.TemporaryType.PLAY_NEXT
+    if (upNextQueue.any { it.id == trackId }) return TrackPlayerCore.TemporaryType.UP_NEXT
+    return TrackPlayerCore.TemporaryType.NONE
+}
+
+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

@@ -0,0 +1,28 @@
+package com.margelo.nitro.nitroplayer.core
+
+import com.margelo.nitro.nitroplayer.media.MediaSessionManager
+import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
+
+/**
+ * Initialises ExoPlayer (via ExoPlayerCore) and MediaSessionManager on the player thread.
+ * Called once from TrackPlayerCore.init via playerHandler.post.
+ */
+internal fun TrackPlayerCore.initExoAndMedia() {
+    exo = ExoPlayerCore(context, playerThread)
+
+    mediaSessionManager = MediaSessionManager(context, exo.player, playlistManager).apply {
+        setTrackPlayerCore(this@initExoAndMedia)
+    }
+
+    // Give MediaBrowserService access to this core and media session
+    NitroPlayerMediaBrowserService.trackPlayerCore = this
+    NitroPlayerMediaBrowserService.mediaSessionManager = mediaSessionManager
+
+    // Attach player listener
+    val listener = TrackPlayerEventListener(this)
+    playerListener = listener
+    exo.addListener(listener)
+
+    // Start progress ticks on the player thread
+    playerHandler.postDelayed(progressUpdateRunnable, 250)
+}