react-native-nitro-player 0.3.0-alpha.9 → 0.4.0

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

@@ -12,6 +12,7 @@ import androidx.media3.common.Player
 import androidx.media3.exoplayer.DefaultLoadControl
 import androidx.media3.exoplayer.ExoPlayer
 import com.margelo.nitro.core.NullType
+import com.margelo.nitro.nitroplayer.CurrentPlayingType
 import com.margelo.nitro.nitroplayer.NitroPlayerPackage
 import com.margelo.nitro.nitroplayer.PlayerState
 import com.margelo.nitro.nitroplayer.Reason
@@ -21,12 +22,16 @@ import com.margelo.nitro.nitroplayer.TrackPlayerState
 import com.margelo.nitro.nitroplayer.Variant_NullType_String
 import com.margelo.nitro.nitroplayer.Variant_NullType_TrackItem
 import com.margelo.nitro.nitroplayer.connection.AndroidAutoConnectionDetector
+import com.margelo.nitro.nitroplayer.download.DownloadManagerCore
+import com.margelo.nitro.nitroplayer.equalizer.EqualizerCore
 import com.margelo.nitro.nitroplayer.media.MediaLibrary
 import com.margelo.nitro.nitroplayer.media.MediaLibraryManager
 import com.margelo.nitro.nitroplayer.media.MediaLibraryParser
 import com.margelo.nitro.nitroplayer.media.MediaSessionManager
 import com.margelo.nitro.nitroplayer.media.NitroPlayerMediaBrowserService
 import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
+import java.lang.ref.WeakReference
+import java.util.Collections
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 
@@ -36,6 +41,7 @@ class TrackPlayerCore private constructor(
     private val handler = android.os.Handler(android.os.Looper.getMainLooper())
     private lateinit var player: ExoPlayer
     private val playlistManager = PlaylistManager.getInstance(context)
+    private val downloadManager = DownloadManagerCore.getInstance(context)
     private val mediaLibraryManager = MediaLibraryManager.getInstance(context)
     private var mediaSessionManager: MediaSessionManager? = null
     private var currentPlaylistId: String? = null
@@ -43,23 +49,52 @@ class TrackPlayerCore private constructor(
     private var isAndroidAutoConnected: Boolean = false
     private var androidAutoConnectionDetector: AndroidAutoConnectionDetector? = null
     var onAndroidAutoConnectionChange: ((Boolean) -> Unit)? = null
+    private var previousMediaItem: MediaItem? = null
+
     private val progressUpdateRunnable =
         object : Runnable {
             override fun run() {
                 if (::player.isInitialized && player.playbackState != Player.STATE_IDLE) {
                     val position = player.currentPosition / 1000.0
                     val duration = if (player.duration > 0) player.duration / 1000.0 else 0.0
-                    onPlaybackProgressChange?.invoke(position, duration, if (isManuallySeeked) true else null)
+                    notifyPlaybackProgress(position, duration, if (isManuallySeeked) true else null)
                     isManuallySeeked = false
                 }
                 handler.postDelayed(this, 250) // Update every 250ms
             }
         }
 
-    var onChangeTrack: ((TrackItem, Reason?) -> Unit)? = null
-    var onPlaybackStateChange: ((TrackPlayerState, Reason?) -> Unit)? = null
-    var onSeek: ((Double, Double) -> Unit)? = null
-    var onPlaybackProgressChange: ((Double, Double, Boolean?) -> Unit)? = null
+    // Weak callback wrapper for auto-cleanup
+    private data class WeakCallbackBox<T>(
+        private val ownerRef: WeakReference<Any>,
+        val callback: T,
+    ) {
+        val isAlive: Boolean get() = ownerRef.get() != null
+    }
+
+    // Event listeners - support multiple listeners with auto-cleanup
+    private val onChangeTrackListeners =
+        Collections.synchronizedList(mutableListOf<WeakCallbackBox<(TrackItem, Reason?) -> Unit>>())
+    private val onPlaybackStateChangeListeners =
+        Collections.synchronizedList(mutableListOf<WeakCallbackBox<(TrackPlayerState, Reason?) -> Unit>>())
+    private val onSeekListeners =
+        Collections.synchronizedList(mutableListOf<WeakCallbackBox<(Double, Double) -> Unit>>())
+    private val onPlaybackProgressChangeListeners =
+        Collections.synchronizedList(mutableListOf<WeakCallbackBox<(Double, Double, Boolean?) -> Unit>>())
+
+    // Temporary tracks for addToUpNext and playNext
+    private var playNextStack: MutableList<TrackItem> = mutableListOf() // LIFO - last added plays first
+    private var upNextQueue: MutableList<TrackItem> = mutableListOf() // FIFO - first added plays first
+    private var currentTemporaryType: TemporaryType = TemporaryType.NONE
+    private var currentTracks: List<TrackItem> = emptyList()
+    private var currentTrackIndex: Int = -1 // Index in the original playlist (currentTracks)
+
+    // Enum to track what type of track is currently playing
+    private enum class TemporaryType {
+        NONE, // Playing from original playlist
+        PLAY_NEXT, // Currently in playNextStack
+        UP_NEXT, // Currently in upNextQueue
+    }
 
     companion object {
         @Volatile
@@ -73,154 +108,238 @@ class TrackPlayerCore private constructor(
     }
 
     init {
-        handler.post {
-            // ============================================================
-            // GAPLESS PLAYBACK CONFIGURATION
-            // ============================================================
-            // Configure LoadControl for maximum gapless playback
-            // Large buffers ensure next track is fully ready before current ends
-            val loadControl =
-                DefaultLoadControl
-                    .Builder()
-                    .setBufferDurationsMs(
-                        30_000, // MIN_BUFFER_MS: 30 seconds minimum buffer
-                        120_000, // MAX_BUFFER_MS: 2 minutes maximum buffer (enables preloading next tracks)
-                        2_500, // BUFFER_FOR_PLAYBACK_MS: 2.5s before playback starts
-                        5_000, // BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS: 5s after rebuffer
-                    ).setBackBuffer(30_000, true) // Keep 30s back buffer for seamless seek-back
-                    .setTargetBufferBytes(C.LENGTH_UNSET) // No size limit - prioritize time
-                    .setPrioritizeTimeOverSizeThresholds(true) // Prioritize time-based buffering
-                    .build()
-
-            // Configure audio attributes for optimal music playback
-            // This enables gapless audio processing in the audio pipeline
-            val audioAttributes =
-                AudioAttributes
-                    .Builder()
-                    .setUsage(C.USAGE_MEDIA)
-                    .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
-                    .build()
-
-            player =
-                ExoPlayer
-                    .Builder(context)
-                    .setLoadControl(loadControl)
-                    .setAudioAttributes(audioAttributes, true) // handleAudioFocus = true for gapless
-                    .setHandleAudioBecomingNoisy(true) // Pause when headphones disconnected
-                    .setPauseAtEndOfMediaItems(false) // Don't pause between items - key for gapless!
-                    .build()
-
-            println("🎵 TrackPlayerCore: Gapless playback configured - 120s buffer, audio focus handling enabled")
-            mediaSessionManager =
-                MediaSessionManager(context, player, playlistManager).apply {
-                    setTrackPlayerCore(this@TrackPlayerCore)
-                }
+        // Run synchronously on main thread to avoid deadlock
+        // when awaitInitialization is called from main thread
+        val initRunnable =
+            Runnable {
+                // ============================================================
+                // GAPLESS PLAYBACK CONFIGURATION
+                // ============================================================
+                // Configure LoadControl for maximum gapless playback
+                // Large buffers ensure next track is fully ready before current ends
+                val loadControl =
+                    DefaultLoadControl
+                        .Builder()
+                        .setBufferDurationsMs(
+                            30_000, // MIN_BUFFER_MS: 30 seconds minimum buffer
+                            120_000, // MAX_BUFFER_MS: 2 minutes maximum buffer (enables preloading next tracks)
+                            2_500, // BUFFER_FOR_PLAYBACK_MS: 2.5s before playback starts
+                            5_000, // BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS: 5s after rebuffer
+                        ).setBackBuffer(30_000, true) // Keep 30s back buffer for seamless seek-back
+                        .setTargetBufferBytes(C.LENGTH_UNSET) // No size limit - prioritize time
+                        .setPrioritizeTimeOverSizeThresholds(true) // Prioritize time-based buffering
+                        .build()
+
+                // Configure audio attributes for optimal music playback
+                // This enables gapless audio processing in the audio pipeline
+                val audioAttributes =
+                    AudioAttributes
+                        .Builder()
+                        .setUsage(C.USAGE_MEDIA)
+                        .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
+                        .build()
+
+                player =
+                    ExoPlayer
+                        .Builder(context)
+                        .setLoadControl(loadControl)
+                        .setAudioAttributes(audioAttributes, true) // handleAudioFocus = true for gapless
+                        .setHandleAudioBecomingNoisy(true) // Pause when headphones disconnected
+                        .setPauseAtEndOfMediaItems(false) // Don't pause between items - key for gapless!
+                        .build()
+
+                mediaSessionManager =
+                    MediaSessionManager(context, player, playlistManager).apply {
+                        setTrackPlayerCore(this@TrackPlayerCore)
+                    }
 
-            // Set references for MediaBrowserService
-            NitroPlayerMediaBrowserService.trackPlayerCore = this
-            NitroPlayerMediaBrowserService.mediaSessionManager = mediaSessionManager
+                // Set references for MediaBrowserService
+                NitroPlayerMediaBrowserService.trackPlayerCore = this
+                NitroPlayerMediaBrowserService.mediaSessionManager = mediaSessionManager
 
-            // Initialize Android Auto connection detector
-            androidAutoConnectionDetector =
-                AndroidAutoConnectionDetector(context).apply {
-                    onConnectionChanged = { connected, connectionType ->
-                        handler.post {
-                            isAndroidAutoConnected = connected
-                            NitroPlayerMediaBrowserService.isAndroidAutoConnected = connected
+                // Initialize Android Auto connection detector
+                androidAutoConnectionDetector =
+                    AndroidAutoConnectionDetector(context).apply {
+                        onConnectionChanged = { connected, connectionType ->
+                            handler.post {
+                                isAndroidAutoConnected = connected
+                                NitroPlayerMediaBrowserService.isAndroidAutoConnected = connected
 
-                            // Notify JavaScript
-                            onAndroidAutoConnectionChange?.invoke(connected)
+                                // Notify JavaScript
+                                onAndroidAutoConnectionChange?.invoke(connected)
 
-                            println("🚗 Android Auto connection changed: connected=$connected, type=$connectionType")
+                                println("🚗 Android Auto connection changed: connected=$connected, type=$connectionType")
+                            }
                         }
+                        registerCarConnectionReceiver()
                     }
-                    registerCarConnectionReceiver()
-                }
 
-            player.addListener(
-                object : Player.Listener {
-                    override fun onMediaItemTransition(
-                        mediaItem: MediaItem?,
-                        reason: Int,
-                    ) {
-                        // Handle playlist switching if needed
-                        mediaItem?.mediaId?.let { mediaId ->
-                            if (mediaId.contains(':')) {
-                                val colonIndex = mediaId.indexOf(':')
-                                val playlistId = mediaId.substring(0, colonIndex)
-                                if (playlistId != currentPlaylistId) {
-                                    // Track from different playlist - ensure playlist is loaded
-                                    val playlist = playlistManager.getPlaylist(playlistId)
-                                    if (playlist != null && currentPlaylistId != playlistId) {
-                                        // This shouldn't happen if playlists are loaded correctly,
-                                        // but handle it as a safety measure
-                                        println(
-                                            "⚠️ TrackPlayerCore: Detected track from different playlist, updating...",
-                                        )
+                player.addListener(
+                    object : Player.Listener {
+                        override fun onMediaItemTransition(
+                            mediaItem: MediaItem?,
+                            reason: Int,
+                        ) {
+                            println("\n🔄 onMediaItemTransition called")
+                            println(
+                                "   reason: ${when (reason) {
+                                    Player.MEDIA_ITEM_TRANSITION_REASON_AUTO -> "AUTO (track ended)"
+                                    Player.MEDIA_ITEM_TRANSITION_REASON_SEEK -> "SEEK"
+                                    Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED -> "PLAYLIST_CHANGED"
+                                    Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT -> "REPEAT"
+                                    else -> "UNKNOWN($reason)"
+                                }}",
+                            )
+                            println("   previousMediaItem: ${previousMediaItem?.mediaId}")
+                            println("   new mediaItem: ${mediaItem?.mediaId}")
+                            println("   playNextStack: ${playNextStack.map { it.id }}")
+                            println("   upNextQueue: ${upNextQueue.map { it.id }}")
+
+                            // Remove finished track from temporary lists
+                            // Handle AUTO (natural end) and SEEK (skip next) transitions
+                            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)
+                                    println("🏁 Track finished/skipped, checking for removal: $trackId")
+
+                                    // Find and remove from playNext stack (like iOS does)
+                                    val playNextIndex = playNextStack.indexOfFirst { it.id == trackId }
+                                    if (playNextIndex >= 0) {
+                                        val track = playNextStack.removeAt(playNextIndex)
+                                        println("   ✅ Removed from playNext stack: ${track.title}")
+                                    } else {
+                                        // Find and remove from upNext queue
+                                        val upNextIndex = upNextQueue.indexOfFirst { it.id == trackId }
+                                        if (upNextIndex >= 0) {
+                                            val track = upNextQueue.removeAt(upNextIndex)
+                                            println("   ✅ Removed from upNext queue: ${track.title}")
+                                        } else {
+                                            println("   ℹ️  Was an original playlist track")
+                                        }
+                                    }
+                                }
+                            } else {
+                                println("   ⏭️  Skipping removal (reason=$reason, prev=${previousMediaItem != null})")
+                            }
+
+                            // Store current item as previous for next transition
+                            previousMediaItem = mediaItem
+
+                            // Update temporary type for current track
+                            currentTemporaryType = determineCurrentTemporaryType()
+                            println("   Updated currentTemporaryType: $currentTemporaryType")
+
+                            // Update currentTrackIndex when we land on an original playlist track
+                            if (currentTemporaryType == TemporaryType.NONE && mediaItem != null) {
+                                val trackId = extractTrackId(mediaItem.mediaId)
+                                val newIndex = currentTracks.indexOfFirst { it.id == trackId }
+                                if (newIndex >= 0 && newIndex != currentTrackIndex) {
+                                    println("   📍 Updating currentTrackIndex from $currentTrackIndex to $newIndex")
+                                    currentTrackIndex = newIndex
+                                }
+                            }
+
+                            // Handle playlist switching if needed
+                            mediaItem?.mediaId?.let { mediaId ->
+                                if (mediaId.contains(':')) {
+                                    val colonIndex = mediaId.indexOf(':')
+                                    val playlistId = mediaId.substring(0, colonIndex)
+                                    if (playlistId != currentPlaylistId) {
+                                        // Track from different playlist - ensure playlist is loaded
+                                        val playlist = playlistManager.getPlaylist(playlistId)
+                                        if (playlist != null && currentPlaylistId != playlistId) {
+                                            // This shouldn't happen if playlists are loaded correctly,
+                                            // but handle it as a safety measure
+                                            println(
+                                                "⚠️ TrackPlayerCore: Detected track from different playlist, updating...",
+                                            )
+                                        }
                                     }
                                 }
                             }
+
+                            // Use getCurrentTrack() which handles temporary tracks properly
+                            val track = getCurrentTrack()
+                            if (track != 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()
+                            }
+                        }
+
+                        override fun onTimelineChanged(
+                            timeline: androidx.media3.common.Timeline,
+                            reason: Int,
+                        ) {
+                            if (reason == Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED) {
+                                // Playlist changed - update MediaBrowserService
+                                NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
+                            }
                         }
 
-                        val track = findTrack(mediaItem)
-                        if (track != null) {
+                        override fun onPlayWhenReadyChanged(
+                            playWhenReady: Boolean,
+                            reason: Int,
+                        ) {
                             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
+                                    Player.PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST -> Reason.USER_ACTION
                                     else -> null
                                 }
-                            onChangeTrack?.invoke(track, r)
-                            mediaSessionManager?.onTrackChanged()
+                            emitStateChange(r)
                         }
-                    }
 
-                    override fun onTimelineChanged(
-                        timeline: androidx.media3.common.Timeline,
-                        reason: Int,
-                    ) {
-                        if (reason == Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED) {
-                            // Playlist changed - update MediaBrowserService
-                            NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
+                        override fun onPlaybackStateChanged(playbackState: Int) {
+                            emitStateChange()
                         }
-                    }
-
-                    override fun onPlayWhenReadyChanged(
-                        playWhenReady: Boolean,
-                        reason: Int,
-                    ) {
-                        val r =
-                            when (reason) {
-                                Player.PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST -> Reason.USER_ACTION
-                                else -> null
-                            }
-                        emitStateChange(r)
-                    }
 
-                    override fun onPlaybackStateChanged(playbackState: Int) {
-                        emitStateChange()
-                    }
+                        override fun onIsPlayingChanged(isPlaying: Boolean) {
+                            emitStateChange()
+                        }
 
-                    override fun onIsPlayingChanged(isPlaying: Boolean) {
-                        emitStateChange()
-                    }
+                        override fun onPositionDiscontinuity(
+                            oldPosition: Player.PositionInfo,
+                            newPosition: Player.PositionInfo,
+                            reason: Int,
+                        ) {
+                            if (reason == Player.DISCONTINUITY_REASON_SEEK) {
+                                isManuallySeeked = true
+                                notifySeek(newPosition.positionMs / 1000.0, player.duration / 1000.0)
+                            }
+                        }
 
-                    override fun onPositionDiscontinuity(
-                        oldPosition: Player.PositionInfo,
-                        newPosition: Player.PositionInfo,
-                        reason: Int,
-                    ) {
-                        if (reason == Player.DISCONTINUITY_REASON_SEEK) {
-                            isManuallySeeked = true
-                            onSeek?.invoke(newPosition.positionMs / 1000.0, player.duration / 1000.0)
+                        override fun onAudioSessionIdChanged(audioSessionId: Int) {
+                            if (audioSessionId != 0) {
+                                try {
+                                    EqualizerCore.getInstance(context).initialize(audioSessionId)
+                                } catch (e: Exception) {
+                                    // Equalizer initialization failed - non-critical
+                                }
+                            }
                         }
-                    }
-                },
-            )
+                    },
+                )
 
-            // Start progress updates
-            handler.post(progressUpdateRunnable)
+                // Start progress updates
+                handler.post(progressUpdateRunnable)
+            }
+
+        // Execute on main thread: if already on main thread, run synchronously to avoid deadlock
+        if (android.os.Looper.myLooper() == android.os.Looper.getMainLooper()) {
+            initRunnable.run()
+        } else {
+            handler.post(initRunnable)
         }
     }
 
@@ -230,6 +349,12 @@ class TrackPlayerCore private constructor(
      */
     fun loadPlaylist(playlistId: String) {
         handler.post {
+            // Clear temporary tracks when loading new playlist
+            playNextStack.clear()
+            upNextQueue.clear()
+            currentTemporaryType = TemporaryType.NONE
+            println("   🧹 Cleared temporary tracks")
+
             val playlist = playlistManager.getPlaylist(playlistId)
             if (playlist != null) {
                 currentPlaylistId = playlistId
@@ -311,11 +436,14 @@ class TrackPlayerCore private constructor(
             }
 
         val actualReason = reason ?: if (player.playbackState == Player.STATE_ENDED) Reason.END else null
-        onPlaybackStateChange?.invoke(state, actualReason)
+        notifyPlaybackStateChange(state, actualReason)
         mediaSessionManager?.onPlaybackStateChanged()
     }
 
     private fun updatePlayerQueue(tracks: List<TrackItem>) {
+        // Store the original tracks
+        currentTracks = tracks
+
         // Create MediaItems with playlist info in mediaId for Android Auto
         val mediaItems =
             tracks.mapIndexed { index, track ->
@@ -347,10 +475,13 @@ class TrackPlayerCore private constructor(
             }
         }
 
+        // Use downloadManager.getEffectiveUrl to automatically get local path if downloaded
+        val effectiveUrl = downloadManager.getEffectiveUrl(this)
+
         return MediaItem
             .Builder()
             .setMediaId(customMediaId ?: id)
-            .setUri(url)
+            .setUri(effectiveUrl)
             .setMediaMetadata(metadataBuilder.build())
             .build()
     }
@@ -383,94 +514,104 @@ class TrackPlayerCore private constructor(
         songId: String,
         fromPlaylist: String?,
     ) {
-        println("🎵 TrackPlayerCore: playSong() called - songId: $songId, fromPlaylist: $fromPlaylist")
-
         handler.post {
-            var targetPlaylistId: String? = null
-            var songIndex: Int = -1
+            playSongInternal(songId, fromPlaylist)
+        }
+    }
 
-            // Case 1: If fromPlaylist is provided, use that playlist
-            if (fromPlaylist != null) {
-                println("🎵 TrackPlayerCore: Looking for song in specified playlist: $fromPlaylist")
-                val playlist = playlistManager.getPlaylist(fromPlaylist)
-                if (playlist != null) {
-                    songIndex = playlist.tracks.indexOfFirst { it.id == songId }
-                    if (songIndex >= 0) {
-                        targetPlaylistId = fromPlaylist
-                        println("✅ Found song at index $songIndex in playlist $fromPlaylist")
-                    } else {
-                        println("⚠️ Song $songId not found in specified playlist $fromPlaylist")
-                        return@post
-                    }
+    private fun playSongInternal(
+        songId: String,
+        fromPlaylist: String?,
+    ) {
+        // Clear temporary tracks when directly playing a song
+        playNextStack.clear()
+        upNextQueue.clear()
+        currentTemporaryType = TemporaryType.NONE
+        println("   🧹 Cleared temporary tracks")
+
+        var targetPlaylistId: String? = null
+        var songIndex: Int = -1
+
+        // Case 1: If fromPlaylist is provided, use that playlist
+        if (fromPlaylist != null) {
+            println("🎵 TrackPlayerCore: Looking for song in specified playlist: $fromPlaylist")
+            val playlist = playlistManager.getPlaylist(fromPlaylist)
+            if (playlist != null) {
+                songIndex = playlist.tracks.indexOfFirst { it.id == songId }
+                if (songIndex >= 0) {
+                    targetPlaylistId = fromPlaylist
+                    println("✅ Found song at index $songIndex in playlist $fromPlaylist")
                 } else {
-                    println("⚠️ Playlist $fromPlaylist not found")
-                    return@post
+                    println("⚠️ Song $songId not found in specified playlist $fromPlaylist")
+                    return
                 }
+            } else {
+                println("⚠️ Playlist $fromPlaylist not found")
+                return
             }
-            // Case 2: If fromPlaylist is not provided, search in current/loaded playlist first
-            else {
-                println("🎵 TrackPlayerCore: No playlist specified, checking current playlist")
-
-                // Check if song exists in currently loaded playlist
-                if (currentPlaylistId != null) {
-                    val currentPlaylist = playlistManager.getPlaylist(currentPlaylistId!!)
-                    if (currentPlaylist != null) {
-                        songIndex = currentPlaylist.tracks.indexOfFirst { it.id == songId }
-                        if (songIndex >= 0) {
-                            targetPlaylistId = currentPlaylistId
-                            println("✅ Found song at index $songIndex in current playlist $currentPlaylistId")
-                        }
+        }
+        // Case 2: If fromPlaylist is not provided, search in current/loaded playlist first
+        else {
+            println("🎵 TrackPlayerCore: No playlist specified, checking current playlist")
+
+            // Check if song exists in currently loaded playlist
+            if (currentPlaylistId != null) {
+                val currentPlaylist = playlistManager.getPlaylist(currentPlaylistId!!)
+                if (currentPlaylist != null) {
+                    songIndex = currentPlaylist.tracks.indexOfFirst { it.id == songId }
+                    if (songIndex >= 0) {
+                        targetPlaylistId = currentPlaylistId
+                        println("✅ Found song at index $songIndex in current playlist $currentPlaylistId")
                     }
                 }
+            }
 
-                // If not found in current playlist, search in all playlists
-                if (songIndex == -1) {
-                    println("🔍 Song not found in current playlist, searching all playlists...")
-                    val allPlaylists = playlistManager.getAllPlaylists()
-
-                    for (playlist in allPlaylists) {
-                        songIndex = playlist.tracks.indexOfFirst { it.id == songId }
-                        if (songIndex >= 0) {
-                            targetPlaylistId = playlist.id
-                            println("✅ Found song at index $songIndex in playlist ${playlist.id}")
-                            break
-                        }
-                    }
+            // If not found in current playlist, search in all playlists
+            if (songIndex == -1) {
+                println("🔍 Song not found in current playlist, searching all playlists...")
+                val allPlaylists = playlistManager.getAllPlaylists()
 
-                    // If still not found, just use the first playlist if available
-                    if (songIndex == -1 && allPlaylists.isNotEmpty()) {
-                        targetPlaylistId = allPlaylists[0].id
-                        songIndex = 0
-                        println("⚠️ Song not found in any playlist, using first playlist and starting at index 0")
+                for (playlist in allPlaylists) {
+                    songIndex = playlist.tracks.indexOfFirst { it.id == songId }
+                    if (songIndex >= 0) {
+                        targetPlaylistId = playlist.id
+                        println("✅ Found song at index $songIndex in playlist ${playlist.id}")
+                        break
                     }
                 }
-            }
 
-            // Now play the song
-            if (targetPlaylistId == null || songIndex < 0) {
-                println("❌ Could not determine playlist or song index")
-                return@post
+                // If still not found, just use the first playlist if available
+                if (songIndex == -1 && allPlaylists.isNotEmpty()) {
+                    targetPlaylistId = allPlaylists[0].id
+                    songIndex = 0
+                    println("⚠️ Song not found in any playlist, using first playlist and starting at index 0")
+                }
             }
+        }
 
-            // Load playlist if it's different from current
-            if (currentPlaylistId != targetPlaylistId) {
-                println("🔄 Loading new playlist: $targetPlaylistId")
-                val playlist = playlistManager.getPlaylist(targetPlaylistId)
-                if (playlist != null) {
-                    currentPlaylistId = targetPlaylistId
-                    updatePlayerQueue(playlist.tracks)
+        // Now play the song
+        if (targetPlaylistId == null || songIndex < 0) {
+            println("❌ Could not determine playlist or song index")
+            return
+        }
 
-                    // Wait a bit for playlist to load, then play from index
-                    handler.postDelayed({
-                        println("▶️ Playing from index: $songIndex")
-                        playFromIndex(songIndex)
-                    }, 100)
-                }
-            } else {
-                // Playlist already loaded, just play from index
+        // Load playlist if it's different from current
+        if (currentPlaylistId != targetPlaylistId) {
+            println("🔄 Loading new playlist: $targetPlaylistId")
+            val playlist = playlistManager.getPlaylist(targetPlaylistId)
+            if (playlist != null) {
+                currentPlaylistId = targetPlaylistId
+                updatePlayerQueue(playlist.tracks)
+
+                // Wait a bit for playlist to load, then play from index
+                // Note: Removed postDelayed to avoid race conditions with subsequent queue operations
                 println("▶️ Playing from index: $songIndex")
                 playFromIndex(songIndex)
             }
+        } else {
+            // Playlist already loaded, just play from index
+            println("▶️ Playing from index: $songIndex")
+            playFromIndex(songIndex)
         }
     }
 
@@ -484,8 +625,18 @@ class TrackPlayerCore private constructor(
 
     fun skipToPrevious() {
         handler.post {
-            if (player.hasPreviousMediaItem()) {
-                player.seekToPreviousMediaItem()
+            // If playing temporary track, just seek to beginning (temps not navigable backwards)
+            if (currentTemporaryType != TemporaryType.NONE) {
+                println("🔄 TrackPlayerCore: Playing temporary track - seeking to beginning")
+                player.seekTo(0)
+            } else if (currentTrackIndex > 0) {
+                // Go to previous track in original playlist
+                println("🔄 TrackPlayerCore: Going to previous track, currentTrackIndex: $currentTrackIndex -> ${currentTrackIndex - 1}")
+                playFromIndexInternal(currentTrackIndex - 1)
+            } else {
+                // Already at first track, seek to beginning
+                println("🔄 TrackPlayerCore: Already at first track, seeking to beginning")
+                player.seekTo(0)
             }
         }
     }
@@ -513,6 +664,7 @@ class TrackPlayerCore private constructor(
     }
 
     fun getState(): PlayerState {
+        // Called from Promise.async background thread
         // Check if we're already on the main thread
         if (android.os.Looper.myLooper() == handler.looper) {
             return getStateInternal()
@@ -542,13 +694,8 @@ class TrackPlayerCore private constructor(
 
     private fun getStateInternal(): PlayerState =
         if (::player.isInitialized) {
-            val currentMediaItem = player.currentMediaItem
-            val track =
-                if (currentMediaItem != null) {
-                    findTrack(currentMediaItem)
-                } else {
-                    null
-                }
+            // Use getCurrentTrack() which handles temporary tracks properly
+            val track = getCurrentTrack()
 
             // Convert nullable TrackItem to Variant_NullType_TrackItem
             val currentTrack: Variant_NullType_TrackItem? =
@@ -581,6 +728,18 @@ class TrackPlayerCore private constructor(
                     -1.0
                 }
 
+            // Map internal temporary type to CurrentPlayingType
+            val currentPlayingTypeValue =
+                if (track == null) {
+                    CurrentPlayingType.NOT_PLAYING
+                } else {
+                    when (currentTemporaryType) {
+                        TemporaryType.NONE -> CurrentPlayingType.PLAYLIST
+                        TemporaryType.PLAY_NEXT -> CurrentPlayingType.PLAY_NEXT
+                        TemporaryType.UP_NEXT -> CurrentPlayingType.UP_NEXT
+                    }
+                }
+
             PlayerState(
                 currentTrack = currentTrack,
                 currentPosition = currentPosition,
@@ -588,6 +747,7 @@ class TrackPlayerCore private constructor(
                 currentState = currentState,
                 currentPlaylistId = currentPlaylistId?.let { Variant_NullType_String.create(it) },
                 currentIndex = currentIndex,
+                currentPlayingType = currentPlayingTypeValue,
             )
         } else {
             // Return default state if player is not initialized
@@ -598,6 +758,7 @@ class TrackPlayerCore private constructor(
                 currentState = TrackPlayerState.STOPPED,
                 currentPlaylistId = currentPlaylistId?.let { Variant_NullType_String.create(it) },
                 currentIndex = -1.0,
+                currentPlayingType = CurrentPlayingType.NOT_PLAYING,
             )
         }
 
@@ -625,17 +786,418 @@ class TrackPlayerCore private constructor(
     fun getCurrentTrack(): TrackItem? {
         if (!::player.isInitialized) return null
         val currentMediaItem = player.currentMediaItem ?: return null
+
+        // If playing a temporary track, return that
+        if (currentTemporaryType != TemporaryType.NONE) {
+            val trackId = extractTrackId(currentMediaItem.mediaId)
+
+            when (currentTemporaryType) {
+                TemporaryType.PLAY_NEXT -> {
+                    return playNextStack.firstOrNull { it.id == trackId }
+                }
+
+                TemporaryType.UP_NEXT -> {
+                    return upNextQueue.firstOrNull { it.id == trackId }
+                }
+
+                else -> {}
+            }
+        }
+
+        // Otherwise return from original playlist
         return findTrack(currentMediaItem)
     }
 
+    private fun extractTrackId(mediaId: String): String =
+        if (mediaId.contains(':')) {
+            // Format: "playlistId:trackId"
+            mediaId.substring(mediaId.indexOf(':') + 1)
+        } else {
+            mediaId
+        }
+
+    // Public method to play from a specific index (for Android Auto)
     // Public method to play from a specific index (for Android Auto)
     fun playFromIndex(index: Int) {
+        if (android.os.Looper.myLooper() == handler.looper) {
+            playFromIndexInternal(index)
+        } else {
+            handler.post {
+                playFromIndexInternal(index)
+            }
+        }
+    }
+
+    // MARK: - Skip to Index in Actual Queue
+
+    fun skipToIndex(index: Int): Boolean {
+        // Check if we're already on the main thread
+        if (android.os.Looper.myLooper() == handler.looper) {
+            return skipToIndexInternal(index)
+        }
+
+        // Use CountDownLatch to wait for the result on the main thread
+        val latch = CountDownLatch(1)
+        var result = false
+
+        handler.post {
+            try {
+                result = skipToIndexInternal(index)
+            } finally {
+                latch.countDown()
+            }
+        }
+
+        try {
+            // Wait up to 5 seconds for the result
+            latch.await(5, TimeUnit.SECONDS)
+        } catch (e: InterruptedException) {
+            Thread.currentThread().interrupt()
+        }
+
+        return result
+    }
+
+    private fun skipToIndexInternal(index: Int): Boolean {
+        println("\n🎯 TrackPlayerCore: SKIP TO INDEX $index")
+
+        if (!::player.isInitialized) {
+            println("   ❌ Player not initialized")
+            return false
+        }
+
+        // Get actual queue to validate index and determine position
+        val actualQueue = getActualQueueInternal()
+        val totalQueueSize = actualQueue.size
+
+        // Validate index
+        if (index < 0 || index >= totalQueueSize) {
+            println("   ❌ Invalid index $index, queue size is $totalQueueSize")
+            return false
+        }
+
+        // Calculate queue section boundaries
+        // ActualQueue structure: [before_current] + [current] + [playNext] + [upNext] + [remaining_original]
+        // Use our internal tracking instead of player.currentMediaItemIndex (which is relative to ExoPlayer's subset queue)
+        val currentPos = currentTrackIndex
+        val playNextStart = currentPos + 1
+        val playNextEnd = playNextStart + playNextStack.size
+        val upNextStart = playNextEnd
+        val upNextEnd = upNextStart + upNextQueue.size
+        val originalRemainingStart = upNextEnd
+
+        println("   Queue structure:")
+        println("      currentPos: $currentPos")
+        println("      playNextStart: $playNextStart, playNextEnd: $playNextEnd")
+        println("      upNextStart: $upNextStart, upNextEnd: $upNextEnd")
+        println("      originalRemainingStart: $originalRemainingStart")
+        println("      totalQueueSize: $totalQueueSize")
+
+        // Case 1: Target is before current - use playFromIndex on original
+        if (index < currentPos) {
+            println("   📍 Target is before current, jumping to original playlist index $index")
+            playFromIndexInternal(index)
+            return true
+        }
+
+        // Case 2: Target is current - seek to beginning
+        if (index == currentPos) {
+            println("   📍 Target is current track, seeking to beginning")
+            player.seekTo(0)
+            return true
+        }
+
+        // Case 3: Target is in playNext section
+        if (index >= playNextStart && index < playNextEnd) {
+            val playNextIndex = index - playNextStart
+            println("   📍 Target is in playNext section at position $playNextIndex")
+
+            // Remove tracks before the target from playNext (they're being skipped)
+            if (playNextIndex > 0) {
+                repeat(playNextIndex) { playNextStack.removeAt(0) }
+                println("      Removed $playNextIndex tracks from playNext stack")
+            }
+
+            // Rebuild queue and advance
+            rebuildQueueFromCurrentPosition()
+            player.seekToNextMediaItem()
+            return true
+        }
+
+        // Case 4: Target is in upNext section
+        if (index >= upNextStart && index < upNextEnd) {
+            val upNextIndex = index - upNextStart
+            println("   📍 Target is in upNext section at position $upNextIndex")
+
+            // Clear all playNext tracks (they're being skipped)
+            playNextStack.clear()
+            println("      Cleared all playNext tracks")
+
+            // Remove tracks before target from upNext
+            if (upNextIndex > 0) {
+                repeat(upNextIndex) { upNextQueue.removeAt(0) }
+                println("      Removed $upNextIndex tracks from upNext queue")
+            }
+
+            // Rebuild queue and advance
+            rebuildQueueFromCurrentPosition()
+            player.seekToNextMediaItem()
+            return true
+        }
+
+        // Case 5: Target is in remaining original tracks
+        if (index >= originalRemainingStart) {
+            // Get the target track directly from actualQueue
+            val targetTrack = actualQueue[index]
+
+            println("   📍 Case 5: Target is in remaining original tracks")
+            println("      targetTrack.id: ${targetTrack.id}")
+            println("      currentTracks.count: ${currentTracks.size}")
+            println("      currentTracks IDs: ${currentTracks.map { it.id }}")
+
+            // Find this track's index in the original playlist
+            val originalIndex = currentTracks.indexOfFirst { it.id == targetTrack.id }
+            if (originalIndex == -1) {
+                println("   ❌ Could not find track ${targetTrack.id} in original playlist")
+                println("      Available tracks: ${currentTracks.map { it.id }}")
+                return false
+            }
+
+            println("      originalIndex found: $originalIndex")
+
+            // Clear all temporary tracks (they're being skipped)
+            playNextStack.clear()
+            upNextQueue.clear()
+            currentTemporaryType = TemporaryType.NONE
+            println("      Cleared all temporary tracks")
+
+            // IMPORTANT: Rebuild the ExoPlayer queue without temporary tracks, then seek
+            // We need to rebuild from the target index, not just seek
+            rebuildQueueAndPlayFromIndex(originalIndex)
+            return true
+        }
+
+        println("   ❌ Unexpected case, index $index not handled")
+        return false
+    }
+
+    private fun playFromIndexInternal(index: Int) {
+        // Clear temporary tracks when jumping to specific index
+        playNextStack.clear()
+        upNextQueue.clear()
+        currentTemporaryType = TemporaryType.NONE
+        println("   🧹 Cleared temporary tracks")
+
+        rebuildQueueAndPlayFromIndex(index)
+    }
+
+    /**
+     * Rebuild the entire ExoPlayer queue from the original playlist starting at the given index
+     * This clears all temporary tracks and rebuilds the queue fresh
+     */
+    private fun rebuildQueueAndPlayFromIndex(index: Int) {
+        if (!::player.isInitialized) {
+            println("   ❌ Player not initialized")
+            return
+        }
+
+        if (index < 0 || index >= currentTracks.size) {
+            println("   ❌ Invalid index $index for currentTracks size ${currentTracks.size}")
+            return
+        }
+
+        println("\n🔄 TrackPlayerCore: REBUILD QUEUE AND PLAY FROM INDEX $index")
+        println("   currentTracks.size: ${currentTracks.size}")
+        println("   currentTracks IDs: ${currentTracks.map { it.id }}")
+
+        // Build queue from the target index onwards
+        val tracksToPlay = currentTracks.subList(index, currentTracks.size)
+        println("   tracksToPlay (${tracksToPlay.size}): ${tracksToPlay.map { it.id }}")
+
+        val playlistId = currentPlaylistId ?: ""
+        val mediaItems =
+            tracksToPlay.map { track ->
+                val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
+                track.toMediaItem(mediaId)
+            }
+
+        // Update our internal tracking of the position in original playlist
+        currentTrackIndex = index
+        println("   Setting currentTrackIndex to $index")
+
+        // Clear the entire player queue and set new items
+        player.clearMediaItems()
+        player.setMediaItems(mediaItems)
+        player.seekToDefaultPosition(0) // Seek to first item (which is our target track)
+        player.playWhenReady = true
+        player.prepare()
+
+        println("   ✅ Queue rebuilt with ${player.mediaItemCount} items, playing from index 0 (track ${tracksToPlay.firstOrNull()?.id})")
+    }
+
+    // MARK: - Temporary Track Management
+
+    /**
+     * Add a track to the up-next queue (FIFO - first added plays first)
+     * Track will be inserted after currently playing track and any playNext tracks
+     */
+    fun addToUpNext(trackId: String) {
+        handler.post {
+            addToUpNextInternal(trackId)
+        }
+    }
+
+    private fun addToUpNextInternal(trackId: String) {
+        println("📋 TrackPlayerCore: addToUpNext($trackId)")
+
+        // Find the track from current playlist or all playlists
+        val track = findTrackById(trackId)
+        if (track == null) {
+            println("❌ TrackPlayerCore: Track $trackId not found")
+            return
+        }
+
+        // Add to end of upNext queue (FIFO)
+        upNextQueue.add(track)
+        println("   ✅ Added '${track.title}' to upNext queue (position: ${upNextQueue.size})")
+
+        // Rebuild the player queue if actively playing
+        if (::player.isInitialized && player.currentMediaItem != null) {
+            rebuildQueueFromCurrentPosition()
+        }
+    }
+
+    /**
+     * Add a track to play next (LIFO - last added plays first)
+     * Track will be inserted immediately after currently playing track
+     */
+    fun playNext(trackId: String) {
         handler.post {
-            if (::player.isInitialized && index >= 0 && index < player.mediaItemCount) {
-                player.seekToDefaultPosition(index)
-                player.playWhenReady = true
+            playNextInternal(trackId)
+        }
+    }
+
+    private fun playNextInternal(trackId: String) {
+        println("⏭️ TrackPlayerCore: playNext($trackId)")
+
+        // Find the track from current playlist or all playlists
+        val track = findTrackById(trackId)
+        if (track == null) {
+            println("❌ TrackPlayerCore: Track $trackId not found")
+            return
+        }
+
+        // Insert at beginning of playNext stack (LIFO)
+        playNextStack.add(0, track)
+        println("   ✅ Added '${track.title}' to playNext stack (position: 1)")
+
+        // Rebuild the player queue if actively playing
+        if (::player.isInitialized && player.currentMediaItem != null) {
+            rebuildQueueFromCurrentPosition()
+        }
+    }
+
+    /**
+     * Rebuild the ExoPlayer queue from current position with temporary tracks
+     * Order: [current] + [playNext stack] + [upNext queue] + [remaining original]
+     */
+    private fun rebuildQueueFromCurrentPosition() {
+        if (!::player.isInitialized) return
+
+        println("\n🔄 TrackPlayerCore: REBUILDING QUEUE FROM CURRENT POSITION")
+        println("   currentIndex: ${player.currentMediaItemIndex}")
+        println("   currentMediaItem: ${player.currentMediaItem?.mediaId}")
+        println("   playNextStack (${playNextStack.size}): ${playNextStack.map { "${it.id}:${it.title}" }}")
+        println("   upNextQueue (${upNextQueue.size}): ${upNextQueue.map { "${it.id}:${it.title}" }}")
+
+        val currentIndex = player.currentMediaItemIndex
+        if (currentIndex < 0) return
+
+        // Build new queue order:
+        // [playNext stack] + [upNext queue] + [remaining original tracks]
+        val newQueueTracks = mutableListOf<TrackItem>()
+
+        // Add playNext stack (LIFO - most recently added plays first)
+        // Stack is already in correct order since we insert at position 0
+        newQueueTracks.addAll(playNextStack)
+
+        // Add upNext queue (in order, FIFO)
+        newQueueTracks.addAll(upNextQueue)
+
+        // Add remaining original tracks
+        if (currentIndex + 1 < currentTracks.size) {
+            val remaining = currentTracks.subList(currentIndex + 1, currentTracks.size)
+            println("   remaining original (${remaining.size}): ${remaining.map { it.id }}")
+            newQueueTracks.addAll(remaining)
+        }
+
+        println("   New queue total: ${newQueueTracks.size} tracks")
+        println("   Queue order: ${newQueueTracks.map { it.id }}")
+
+        // Create MediaItems for new tracks
+        val playlistId = currentPlaylistId ?: ""
+        val newMediaItems =
+            newQueueTracks.map { track ->
+                val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
+                println("   Creating MediaItem: mediaId=$mediaId, title=${track.title}")
+                track.toMediaItem(mediaId)
+            }
+
+        // Remove all items after current
+        val removedCount = player.mediaItemCount - currentIndex - 1
+        println("   Removing $removedCount items after current")
+        while (player.mediaItemCount > currentIndex + 1) {
+            player.removeMediaItem(currentIndex + 1)
+        }
+
+        // Add new items
+        player.addMediaItems(newMediaItems)
+
+        println("   ✅ Queue rebuilt. Player now has ${player.mediaItemCount} items")
+        for (i in 0 until player.mediaItemCount) {
+            println("      [$i]: ${player.getMediaItemAt(i).mediaId}")
+        }
+    }
+
+    /**
+     * Find a track by ID from current playlist or all playlists
+     */
+    private fun findTrackById(trackId: String): TrackItem? {
+        // First check current playlist
+        currentTracks.find { it.id == trackId }?.let { return it }
+
+        // Then check all playlists
+        val allPlaylists = playlistManager.getAllPlaylists()
+        for (playlist in allPlaylists) {
+            playlist.tracks.find { it.id == trackId }?.let { return it }
+        }
+
+        return null
+    }
+
+    /**
+     * Determine what type of track is currently playing
+     */
+    private fun determineCurrentTemporaryType(): TemporaryType {
+        val currentItem = player.currentMediaItem ?: return TemporaryType.NONE
+        val trackId =
+            if (currentItem.mediaId.contains(':')) {
+                currentItem.mediaId.substring(currentItem.mediaId.indexOf(':') + 1)
+            } else {
+                currentItem.mediaId
             }
+
+        // Check if in playNext stack
+        if (playNextStack.any { it.id == trackId }) {
+            return TemporaryType.PLAY_NEXT
         }
+
+        // Check if in upNext queue
+        if (upNextQueue.any { it.id == trackId }) {
+            return TemporaryType.UP_NEXT
+        }
+
+        return TemporaryType.NONE
     }
 
     // Clean up resources
@@ -689,4 +1251,199 @@ class TrackPlayerCore private constructor(
             println("⚠️ TrackPlayerCore: Cannot set volume - player not initialized")
             false
         }
+
+    // Add event listeners
+    fun addOnChangeTrackListener(callback: (TrackItem, Reason?) -> Unit) {
+        val box = WeakCallbackBox(WeakReference(this), callback)
+        onChangeTrackListeners.add(box)
+    }
+
+    fun addOnPlaybackStateChangeListener(callback: (TrackPlayerState, Reason?) -> Unit) {
+        val box = WeakCallbackBox(WeakReference(this), callback)
+        onPlaybackStateChangeListeners.add(box)
+    }
+
+    fun addOnSeekListener(callback: (Double, Double) -> Unit) {
+        val box = WeakCallbackBox(WeakReference(this), callback)
+        onSeekListeners.add(box)
+    }
+
+    fun addOnPlaybackProgressChangeListener(callback: (Double, Double, Boolean?) -> Unit) {
+        val box = WeakCallbackBox(WeakReference(this), callback)
+        onPlaybackProgressChangeListeners.add(box)
+    }
+
+    // Notification helpers with auto-cleanup
+    private fun notifyTrackChange(
+        track: TrackItem,
+        reason: Reason?,
+    ) {
+        val liveCallbacks =
+            synchronized(onChangeTrackListeners) {
+                onChangeTrackListeners.removeAll { !it.isAlive }
+                onChangeTrackListeners.filter { it.isAlive }.map { it.callback }
+            }
+
+        handler.post {
+            for (callback in liveCallbacks) {
+                try {
+                    callback(track, reason)
+                } catch (e: Exception) {
+                    println("⚠️ Error in track change listener: ${e.message}")
+                }
+            }
+        }
+    }
+
+    private fun notifyPlaybackStateChange(
+        state: TrackPlayerState,
+        reason: Reason?,
+    ) {
+        val liveCallbacks =
+            synchronized(onPlaybackStateChangeListeners) {
+                onPlaybackStateChangeListeners.removeAll { !it.isAlive }
+                onPlaybackStateChangeListeners.filter { it.isAlive }.map { it.callback }
+            }
+
+        handler.post {
+            for (callback in liveCallbacks) {
+                try {
+                    callback(state, reason)
+                } catch (e: Exception) {
+                    println("⚠️ Error in playback state listener: ${e.message}")
+                }
+            }
+        }
+    }
+
+    private fun notifySeek(
+        position: Double,
+        duration: Double,
+    ) {
+        val liveCallbacks =
+            synchronized(onSeekListeners) {
+                onSeekListeners.removeAll { !it.isAlive }
+                onSeekListeners.filter { it.isAlive }.map { it.callback }
+            }
+
+        handler.post {
+            for (callback in liveCallbacks) {
+                try {
+                    callback(position, duration)
+                } catch (e: Exception) {
+                    println("⚠️ Error in seek listener: ${e.message}")
+                }
+            }
+        }
+    }
+
+    private fun notifyPlaybackProgress(
+        position: Double,
+        duration: Double,
+        isPlaying: Boolean?,
+    ) {
+        val liveCallbacks =
+            synchronized(onPlaybackProgressChangeListeners) {
+                onPlaybackProgressChangeListeners.removeAll { !it.isAlive }
+                onPlaybackProgressChangeListeners.filter { it.isAlive }.map { it.callback }
+            }
+
+        handler.post {
+            for (callback in liveCallbacks) {
+                try {
+                    callback(position, duration, isPlaying)
+                } catch (e: Exception) {
+                    println("⚠️ Error in playback progress listener: ${e.message}")
+                }
+            }
+        }
+    }
+
+    /**
+     * Get the actual queue with temporary tracks
+     * Returns: [original_before_current] + [current] + [playNext_stack] + [upNext_queue] + [original_after_current]
+     */
+    fun getActualQueue(): List<TrackItem> {
+        // Called from Promise.async background thread
+        // Check if we're already on the main thread
+        if (android.os.Looper.myLooper() == handler.looper) {
+            return getActualQueueInternal()
+        }
+
+        // Use CountDownLatch to wait for the result on the main thread
+        val latch = CountDownLatch(1)
+        var result: List<TrackItem>? = null
+
+        handler.post {
+            try {
+                result = getActualQueueInternal()
+            } finally {
+                latch.countDown()
+            }
+        }
+
+        try {
+            // Wait up to 5 seconds for the result
+            latch.await(5, TimeUnit.SECONDS)
+        } catch (e: InterruptedException) {
+            println("⚠️ TrackPlayerCore: Interrupted while waiting for actual queue")
+        }
+
+        return result ?: emptyList()
+    }
+
+    private fun getActualQueueInternal(): List<TrackItem> {
+        println("\n🔍 TrackPlayerCore: getActualQueueInternal() called")
+        println("   playNextStack size: ${playNextStack.size}, tracks: ${playNextStack.map { it.id }}")
+        println("   upNextQueue size: ${upNextQueue.size}, tracks: ${upNextQueue.map { it.id }}")
+        println("   currentTracks size: ${currentTracks.size}, tracks: ${currentTracks.map { it.id }}")
+        println("   currentTrackIndex: $currentTrackIndex")
+
+        val queue = mutableListOf<TrackItem>()
+
+        if (!::player.isInitialized) {
+            println("   ❌ Player not initialized, returning empty")
+            return emptyList()
+        }
+
+        // Use our internal tracking of position in original playlist
+        val currentIndex = currentTrackIndex
+        println("   Using currentTrackIndex: $currentIndex")
+        if (currentIndex < 0) {
+            println("   ❌ currentIndex < 0, returning empty")
+            return emptyList()
+        }
+
+        // Add tracks before current (original playlist)
+        if (currentIndex > 0 && currentIndex <= currentTracks.size) {
+            val beforeCurrent = currentTracks.subList(0, currentIndex)
+            println("   Adding ${beforeCurrent.size} tracks before current")
+            queue.addAll(beforeCurrent)
+        }
+
+        // Add current track
+        getCurrentTrack()?.let {
+            println("   Adding current track: ${it.id}")
+            queue.add(it)
+        }
+
+        // Add playNext stack (LIFO - most recently added plays first)
+        // Stack is already in correct order since we insert at position 0
+        println("   Adding ${playNextStack.size} playNext tracks")
+        queue.addAll(playNextStack)
+
+        // Add upNext queue (in order, FIFO)
+        println("   Adding ${upNextQueue.size} upNext tracks")
+        queue.addAll(upNextQueue)
+
+        // Add remaining original tracks
+        if (currentIndex + 1 < currentTracks.size) {
+            val remaining = currentTracks.subList(currentIndex + 1, currentTracks.size)
+            println("   Adding ${remaining.size} remaining tracks")
+            queue.addAll(remaining)
+        }
+
+        println("   ✅ Final queue size: ${queue.size}, tracks: ${queue.map { it.id }}")
+        return queue
+    }
 }