react-native-nitro-player 0.4.0 → 0.4.1-alpha.0

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

@@ -625,10 +625,32 @@ class TrackPlayerCore private constructor(
 
     fun skipToPrevious() {
         handler.post {
-            // If playing temporary track, just seek to beginning (temps not navigable backwards)
-            if (currentTemporaryType != TemporaryType.NONE) {
-                println("🔄 TrackPlayerCore: Playing temporary track - seeking to beginning")
+            val currentPosition = player.currentPosition // milliseconds
+
+            if (currentPosition > 2000) {
+                // More than 2 seconds in, restart current track
+                println("🔄 TrackPlayerCore: Past threshold, restarting current track")
                 player.seekTo(0)
+            } else if (currentTemporaryType != TemporaryType.NONE) {
+                // Playing temporary track within threshold — remove from its list, go back to original
+                println("🔄 TrackPlayerCore: Removing temp track, going back to original")
+                val currentMediaItem = player.currentMediaItem
+                if (currentMediaItem != null) {
+                    val trackId = extractTrackId(currentMediaItem.mediaId)
+                    when (currentTemporaryType) {
+                        TemporaryType.PLAY_NEXT -> {
+                            val idx = playNextStack.indexOfFirst { it.id == trackId }
+                            if (idx >= 0) playNextStack.removeAt(idx)
+                        }
+                        TemporaryType.UP_NEXT -> {
+                            val idx = upNextQueue.indexOfFirst { it.id == trackId }
+                            if (idx >= 0) upNextQueue.removeAt(idx)
+                        }
+                        else -> {}
+                    }
+                }
+                currentTemporaryType = TemporaryType.NONE
+                playFromIndexInternal(currentTrackIndex)
             } else if (currentTrackIndex > 0) {
                 // Go to previous track in original playlist
                 println("🔄 TrackPlayerCore: Going to previous track, currentTrackIndex: $currentTrackIndex -> ${currentTrackIndex - 1}")
@@ -859,50 +881,40 @@ class TrackPlayerCore private constructor(
     }
 
     private fun skipToIndexInternal(index: Int): Boolean {
-        println("\n🎯 TrackPlayerCore: SKIP TO INDEX $index")
-
-        if (!::player.isInitialized) {
-            println("   ❌ Player not initialized")
-            return false
-        }
+        if (!::player.isInitialized) 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
-        }
+        if (index < 0 || index >= totalQueueSize) return false
+
+        // Calculate queue section boundaries using effective sizes
+        // (reduced by 1 when current track is from that temp list, matching getActualQueueInternal)
+        // When temp is playing, the original track at currentTrackIndex is included in "before",
+        // so the current playing position shifts by 1
+        val currentPos = if (currentTemporaryType != TemporaryType.NONE)
+            currentTrackIndex + 1 else currentTrackIndex
+        val effectivePlayNextSize = if (currentTemporaryType == TemporaryType.PLAY_NEXT)
+            maxOf(0, playNextStack.size - 1) else playNextStack.size
+        val effectiveUpNextSize = if (currentTemporaryType == TemporaryType.UP_NEXT)
+            maxOf(0, upNextQueue.size - 1) else upNextQueue.size
 
-        // 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 playNextEnd = playNextStart + effectivePlayNextSize
         val upNextStart = playNextEnd
-        val upNextEnd = upNextStart + upNextQueue.size
+        val upNextEnd = upNextStart + effectiveUpNextSize
         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
         }
@@ -910,12 +922,13 @@ class TrackPlayerCore private constructor(
         // 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")
+            // Offset by 1 if current is from playNext (index 0 is already playing)
+            val actualListIndex = if (currentTemporaryType == TemporaryType.PLAY_NEXT)
+                playNextIndex + 1 else 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")
+            if (actualListIndex > 0) {
+                repeat(actualListIndex) { playNextStack.removeAt(0) }
             }
 
             // Rebuild queue and advance
@@ -927,16 +940,16 @@ class TrackPlayerCore private constructor(
         // 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")
+            // Offset by 1 if current is from upNext (index 0 is already playing)
+            val actualListIndex = if (currentTemporaryType == TemporaryType.UP_NEXT)
+                upNextIndex + 1 else 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")
+            if (actualListIndex > 0) {
+                repeat(actualListIndex) { upNextQueue.removeAt(0) }
             }
 
             // Rebuild queue and advance
@@ -947,37 +960,21 @@ class TrackPlayerCore private constructor(
 
         // 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")
+            if (originalIndex == -1) return false
 
             // 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
     }
 
@@ -986,7 +983,6 @@ class TrackPlayerCore private constructor(
         playNextStack.clear()
         upNextQueue.clear()
         currentTemporaryType = TemporaryType.NONE
-        println("   🧹 Cleared temporary tracks")
 
         rebuildQueueAndPlayFromIndex(index)
     }
@@ -1104,59 +1100,48 @@ class TrackPlayerCore private constructor(
     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)
+        // Skip index 0 if current track is from playNext (it's already playing)
+        if (currentTemporaryType == TemporaryType.PLAY_NEXT && playNextStack.size > 1) {
+            newQueueTracks.addAll(playNextStack.subList(1, playNextStack.size))
+        } else if (currentTemporaryType != TemporaryType.PLAY_NEXT) {
+            newQueueTracks.addAll(playNextStack)
+        }
 
         // Add upNext queue (in order, FIFO)
-        newQueueTracks.addAll(upNextQueue)
+        // Skip index 0 if current track is from upNext (it's already playing)
+        if (currentTemporaryType == TemporaryType.UP_NEXT && upNextQueue.size > 1) {
+            newQueueTracks.addAll(upNextQueue.subList(1, upNextQueue.size))
+        } else if (currentTemporaryType != TemporaryType.UP_NEXT) {
+            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 }}")
+        // Add remaining original tracks — use currentTrackIndex (original playlist position)
+        if (currentTrackIndex + 1 < currentTracks.size) {
+            val remaining = currentTracks.subList(currentTrackIndex + 1, currentTracks.size)
             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}")
-        }
     }
 
     /**
@@ -1393,57 +1378,46 @@ class TrackPlayerCore private constructor(
     }
 
     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()
-        }
+        if (!::player.isInitialized) 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()
-        }
+        if (currentIndex < 0) 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)
+        // When a temp track is playing, include the original track at currentTrackIndex
+        // (it already played before the temp track started)
+        val beforeEnd = if (currentTemporaryType != TemporaryType.NONE)
+            minOf(currentIndex + 1, currentTracks.size) else currentIndex
+        if (beforeEnd > 0) {
+            queue.addAll(currentTracks.subList(0, beforeEnd))
         }
 
-        // Add current track
-        getCurrentTrack()?.let {
-            println("   Adding current track: ${it.id}")
-            queue.add(it)
-        }
+        // Add current track (temp or original)
+        getCurrentTrack()?.let { 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)
+        // Skip index 0 if current track is from playNext (it's already added as current)
+        if (currentTemporaryType == TemporaryType.PLAY_NEXT && playNextStack.size > 1) {
+            queue.addAll(playNextStack.subList(1, playNextStack.size))
+        } else if (currentTemporaryType != TemporaryType.PLAY_NEXT) {
+            queue.addAll(playNextStack)
+        }
 
         // Add upNext queue (in order, FIFO)
-        println("   Adding ${upNextQueue.size} upNext tracks")
-        queue.addAll(upNextQueue)
+        // Skip index 0 if current track is from upNext (it's already added as current)
+        if (currentTemporaryType == TemporaryType.UP_NEXT && upNextQueue.size > 1) {
+            queue.addAll(upNextQueue.subList(1, upNextQueue.size))
+        } else if (currentTemporaryType != TemporaryType.UP_NEXT) {
+            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)
+            queue.addAll(currentTracks.subList(currentIndex + 1, currentTracks.size))
         }
 
-        println("   ✅ Final queue size: ${queue.size}, tracks: ${queue.map { it.id }}")
         return queue
     }
 }

package/ios/core/TrackPlayerCore.swift

@@ -280,8 +280,7 @@ class TrackPlayerCore: NSObject {
     print("\n🏁 TrackPlayerCore: Track finished playing")
 
     guard let finishedItem = notification.object as? AVPlayerItem else {
-      print("⚠️ Cannot identify finished item")
-      skipToNext()
+      // Don't call skipToNext — AVQueuePlayer with actionAtItemEnd = .advance already auto-advances
       return
     }
 
@@ -352,7 +351,9 @@ class TrackPlayerCore: NSObject {
       print("🔁 TrackPlayerCore: Repeat mode is OFF")
     }
 
-    // Track ended naturally
+    // Track ended naturally — notify with .end reason
+    // AVQueuePlayer with actionAtItemEnd = .advance auto-advances to next item
+    // The KVO observer (currentItemDidChange) will handle the track change notification
     notifyTrackChange(
       getCurrentTrack()
         ?? TrackItem(
@@ -365,9 +366,6 @@ class TrackPlayerCore: NSObject {
           artwork: nil,
           extraPayload: nil
         ), .end)
-
-    // Try to play next track
-    skipToNext()
   }
 
   @objc private func playerItemFailedToPlayToEndTime(notification: Notification) {
@@ -642,12 +640,21 @@ class TrackPlayerCore: NSObject {
   func updatePlaylist(playlistId: String) {
     DispatchQueue.main.async { [weak self] in
       guard let self = self else { return }
-      if self.currentPlaylistId == playlistId {
+      guard self.currentPlaylistId == playlistId,
         let playlist = self.playlistManager.getPlaylist(playlistId: playlistId)
-        if let playlist = playlist {
-          self.updatePlayerQueue(tracks: playlist.tracks)
-        }
+      else { return }
+
+      // If nothing is playing yet, do a full load
+      guard let player = self.player, player.currentItem != nil else {
+        self.updatePlayerQueue(tracks: playlist.tracks)
+        return
       }
+
+      // Update tracks list without interrupting playback
+      self.currentTracks = playlist.tracks
+
+      // Rebuild only the items after the currently playing item
+      self.rebuildAVQueueFromCurrentPosition()
     }
   }
 
@@ -1134,21 +1141,34 @@ class TrackPlayerCore: NSObject {
     var queue: [TrackItem] = []
 
     // Add tracks before current (original playlist)
-    if currentTrackIndex > 0 {
-      queue.append(contentsOf: Array(currentTracks[0..<currentTrackIndex]))
+    // When a temp track is playing, include the original track at currentTrackIndex
+    // (it already played before the temp track started)
+    let beforeEnd = currentTemporaryType != .none
+      ? min(currentTrackIndex + 1, currentTracks.count) : currentTrackIndex
+    if beforeEnd > 0 {
+      queue.append(contentsOf: Array(currentTracks[0..<beforeEnd]))
     }
 
-    // Add current track
+    // Add current track (temp or original)
     if let current = getCurrentTrack() {
       queue.append(current)
     }
 
     // Add playNext stack (LIFO - most recently added plays first)
-    // Stack is already in correct order since we insert at position 0
-    queue.append(contentsOf: playNextStack)
+    // Skip index 0 if current track is from playNext (it's already added as current)
+    if currentTemporaryType == .playNext && playNextStack.count > 1 {
+      queue.append(contentsOf: Array(playNextStack.dropFirst()))
+    } else if currentTemporaryType != .playNext {
+      queue.append(contentsOf: playNextStack)
+    }
 
     // Add upNext queue (in order, FIFO)
-    queue.append(contentsOf: upNextQueue)
+    // Skip index 0 if current track is from upNext (it's already added as current)
+    if currentTemporaryType == .upNext && upNextQueue.count > 1 {
+      queue.append(contentsOf: Array(upNextQueue.dropFirst()))
+    } else if currentTemporaryType != .upNext {
+      queue.append(contentsOf: upNextQueue)
+    }
 
     // Add remaining original tracks
     if currentTrackIndex + 1 < currentTracks.count {
@@ -1314,39 +1334,23 @@ class TrackPlayerCore: NSObject {
   private func skipToNextInternal() {
     guard let queuePlayer = self.player else { return }
 
-    print("\n⏭️ TrackPlayerCore: SKIP TO NEXT")
-    print("   BEFORE:")
-    print("      currentTrackIndex: \(self.currentTrackIndex)")
-    print("      Total tracks in currentTracks: \(self.currentTracks.count)")
-    print("      Items in player queue: \(queuePlayer.items().count)")
-
-    if let currentItem = queuePlayer.currentItem, let trackId = currentItem.trackId {
-      if let track = self.currentTracks.first(where: { $0.id == trackId }) {
-        print("      Currently playing: \(track.title) (ID: \(track.id))")
+    // Remove current temp track from its list before advancing
+    if let trackId = queuePlayer.currentItem?.trackId {
+      if currentTemporaryType == .playNext {
+        if let idx = playNextStack.firstIndex(where: { $0.id == trackId }) {
+          playNextStack.remove(at: idx)
+        }
+      } else if currentTemporaryType == .upNext {
+        if let idx = upNextQueue.firstIndex(where: { $0.id == trackId }) {
+          upNextQueue.remove(at: idx)
+        }
       }
     }
 
-    // Check if there are more items in the queue
-    if self.currentTrackIndex + 1 < self.currentTracks.count {
-      print("   🔄 Calling advanceToNextItem()...")
+    // Check if there are more items in the player queue
+    if queuePlayer.items().count > 1 {
       queuePlayer.advanceToNextItem()
-
-      // NOTE: Don't manually update currentTrackIndex here!
-      // The KVO observer (currentItemDidChange) will update it automatically
-
-      print("   AFTER advanceToNextItem():")
-      print("      Items in player queue: \(queuePlayer.items().count)")
-
-      if let newCurrentItem = queuePlayer.currentItem, let trackId = newCurrentItem.trackId {
-        if let track = self.currentTracks.first(where: { $0.id == trackId }) {
-          print("      New current item: \(track.title) (ID: \(track.id))")
-        }
-      }
-
-      print("   ⏳ Waiting for KVO observer to update index...")
     } else {
-      print("   ⚠️ No more tracks in playlist")
-      // At end of playlist - stop or loop
       queuePlayer.pause()
       self.notifyPlaybackStateChange(.stopped, .end)
     }
@@ -1365,29 +1369,31 @@ class TrackPlayerCore: NSObject {
   private func skipToPreviousInternal() {
     guard let queuePlayer = self.player else { return }
 
-    print("\n⏮️ TrackPlayerCore: SKIP TO PREVIOUS")
-    print("   Current index: \(self.currentTrackIndex)")
-    print("   Temporary type: \(self.currentTemporaryType)")
-    print("   Current time: \(queuePlayer.currentTime().seconds)s")
-
     let currentTime = queuePlayer.currentTime()
     if currentTime.seconds > Constants.skipToPreviousThreshold {
       // If more than threshold seconds in, restart current track
-      print(
-        "   🔄 More than \(Int(Constants.skipToPreviousThreshold))s in, restarting current track")
       queuePlayer.seek(to: .zero)
     } else if self.currentTemporaryType != .none {
-      // Playing temporary track - just restart it (temps are not navigable backwards)
-      print("   🔄 Playing temporary track - restarting it (temps not navigable backwards)")
-      queuePlayer.seek(to: .zero)
+      // Playing temporary track — remove from its list, then restart
+      if let trackId = queuePlayer.currentItem?.trackId {
+        if currentTemporaryType == .playNext {
+          if let idx = playNextStack.firstIndex(where: { $0.id == trackId }) {
+            playNextStack.remove(at: idx)
+          }
+        } else if currentTemporaryType == .upNext {
+          if let idx = upNextQueue.firstIndex(where: { $0.id == trackId }) {
+            upNextQueue.remove(at: idx)
+          }
+        }
+      }
+      // Go to current original track position (skip back from temp)
+      self.playFromIndex(index: self.currentTrackIndex)
     } else if self.currentTrackIndex > 0 {
       // Go to previous track in original playlist
       let previousIndex = self.currentTrackIndex - 1
-      print("   ⏮️ Going to previous track at index \(previousIndex)")
       self.playFromIndex(index: previousIndex)
     } else {
       // Already at first track, restart it
-      print("   🔄 Already at first track, restarting it")
       queuePlayer.seek(to: .zero)
     }
   }
@@ -1577,44 +1583,38 @@ class TrackPlayerCore: NSObject {
   }
 
   private func skipToIndexInternal(index: Int) -> Bool {
-    print("\n🎯 TrackPlayerCore: SKIP TO INDEX \(index)")
-
     // Get actual queue to validate index and determine position
     let actualQueue = getActualQueueInternal()
     let totalQueueSize = actualQueue.count
 
     // Validate index
-    guard index >= 0 && index < totalQueueSize else {
-      print("   ❌ Invalid index \(index), queue size is \(totalQueueSize)")
-      return false
-    }
+    guard index >= 0 && index < totalQueueSize else { return false }
+
+    // Calculate queue section boundaries using effective sizes
+    // (reduced by 1 when current track is from that temp list, matching getActualQueueInternal)
+    // When temp is playing, the original track at currentTrackIndex is included in "before",
+    // so the current playing position shifts by 1
+    let currentPos = currentTemporaryType != .none
+      ? currentTrackIndex + 1 : currentTrackIndex
+    let effectivePlayNextSize = currentTemporaryType == .playNext
+      ? max(0, playNextStack.count - 1) : playNextStack.count
+    let effectiveUpNextSize = currentTemporaryType == .upNext
+      ? max(0, upNextQueue.count - 1) : upNextQueue.count
 
-    // Calculate queue section boundaries
-    // ActualQueue structure: [before_current] + [current] + [playNext] + [upNext] + [remaining_original]
-    let currentPos = currentTrackIndex
     let playNextStart = currentPos + 1
-    let playNextEnd = playNextStart + playNextStack.count
+    let playNextEnd = playNextStart + effectivePlayNextSize
     let upNextStart = playNextEnd
-    let upNextEnd = upNextStart + upNextQueue.count
+    let upNextEnd = upNextStart + effectiveUpNextSize
     let originalRemainingStart = upNextEnd
 
-    print("   Queue structure:")
-    print("      currentPos: \(currentPos)")
-    print("      playNextStart: \(playNextStart), playNextEnd: \(playNextEnd)")
-    print("      upNextStart: \(upNextStart), upNextEnd: \(upNextEnd)")
-    print("      originalRemainingStart: \(originalRemainingStart)")
-    print("      totalQueueSize: \(totalQueueSize)")
-
     // Case 1: Target is before current - use playFromIndex on original
     if index < currentPos {
-      print("   📍 Target is before current, jumping to original playlist index \(index)")
       playFromIndexInternal(index: index)
       return true
     }
 
     // Case 2: Target is current - seek to beginning
     if index == currentPos {
-      print("   📍 Target is current track, seeking to beginning")
       player?.seek(to: .zero)
       return true
     }
@@ -1622,12 +1622,13 @@ class TrackPlayerCore: NSObject {
     // Case 3: Target is in playNext section
     if index >= playNextStart && index < playNextEnd {
       let playNextIndex = index - playNextStart
-      print("   📍 Target is in playNext section at position \(playNextIndex)")
+      // Offset by 1 if current is from playNext (index 0 is already playing)
+      let actualListIndex = currentTemporaryType == .playNext
+        ? playNextIndex + 1 : playNextIndex
 
       // Remove tracks before the target from playNext (they're being skipped)
-      if playNextIndex > 0 {
-        playNextStack.removeFirst(playNextIndex)
-        print("      Removed \(playNextIndex) tracks from playNext stack")
+      if actualListIndex > 0 {
+        playNextStack.removeFirst(actualListIndex)
       }
 
       // Rebuild queue and advance
@@ -1639,16 +1640,16 @@ class TrackPlayerCore: NSObject {
     // Case 4: Target is in upNext section
     if index >= upNextStart && index < upNextEnd {
       let upNextIndex = index - upNextStart
-      print("   📍 Target is in upNext section at position \(upNextIndex)")
+      // Offset by 1 if current is from upNext (index 0 is already playing)
+      let actualListIndex = currentTemporaryType == .upNext
+        ? upNextIndex + 1 : upNextIndex
 
       // Clear all playNext tracks (they're being skipped)
       playNextStack.removeAll()
-      print("      Cleared all playNext tracks")
 
       // Remove tracks before target from upNext
-      if upNextIndex > 0 {
-        upNextQueue.removeFirst(upNextIndex)
-        print("      Removed \(upNextIndex) tracks from upNext queue")
+      if actualListIndex > 0 {
+        upNextQueue.removeFirst(actualListIndex)
       }
 
       // Rebuild queue and advance
@@ -1659,35 +1660,21 @@ class TrackPlayerCore: NSObject {
 
     // Case 5: Target is in remaining original tracks
     if index >= originalRemainingStart {
-      // Get the target track directly from actualQueue
       let targetTrack = actualQueue[index]
 
-      print("   📍 Case 5: Target is in remaining original tracks")
-      print("      targetTrack.id: \(targetTrack.id)")
-      print("      currentTracks.count: \(currentTracks.count)")
-      print("      currentTracks IDs: \(currentTracks.map { $0.id })")
-
       // Find this track's index in the original playlist
       guard let originalIndex = currentTracks.firstIndex(where: { $0.id == targetTrack.id }) else {
-        print("   ❌ Could not find track \(targetTrack.id) in original playlist")
-        print("      Available tracks: \(currentTracks.map { $0.id })")
         return false
       }
 
-      print("      originalIndex found: \(originalIndex)")
-
       // Clear all temporary tracks (they're being skipped)
       playNextStack.removeAll()
       upNextQueue.removeAll()
       currentTemporaryType = .none
-      print("      Cleared all temporary tracks")
 
-      // Play from the original playlist index
-      let success = playFromIndexInternalWithResult(index: originalIndex)
-      return success
+      return playFromIndexInternalWithResult(index: originalIndex)
     }
 
-    print("   ❌ Unexpected case, index \(index) not handled")
     return false
   }
 
@@ -1836,24 +1823,26 @@ class TrackPlayerCore: NSObject {
   private func rebuildAVQueueFromCurrentPosition() {
     guard let player = self.player else { return }
 
-    print("\n🔄 TrackPlayerCore: REBUILDING QUEUE FROM CURRENT POSITION")
-    print("   playNext stack: \(playNextStack.count) tracks")
-    print("   upNext queue: \(upNextQueue.count) tracks")
-
-    // Don't interrupt currently playing item
     let currentItem = player.currentItem
     let playingItems = player.items()
 
-    // Build new queue order:
-    // [playNext stack] + [upNext queue] + [remaining original tracks]
     var newQueueTracks: [TrackItem] = []
 
     // Add playNext stack (LIFO - most recently added plays first)
-    // Stack is already in correct order since we insert at position 0
-    newQueueTracks.append(contentsOf: playNextStack)
+    // Skip index 0 if current track is from playNext (it's already playing)
+    if currentTemporaryType == .playNext && playNextStack.count > 1 {
+      newQueueTracks.append(contentsOf: Array(playNextStack.dropFirst()))
+    } else if currentTemporaryType != .playNext {
+      newQueueTracks.append(contentsOf: playNextStack)
+    }
 
     // Add upNext queue (in order, FIFO)
-    newQueueTracks.append(contentsOf: upNextQueue)
+    // Skip index 0 if current track is from upNext (it's already playing)
+    if currentTemporaryType == .upNext && upNextQueue.count > 1 {
+      newQueueTracks.append(contentsOf: Array(upNextQueue.dropFirst()))
+    } else if currentTemporaryType != .upNext {
+      newQueueTracks.append(contentsOf: upNextQueue)
+    }
 
     // Add remaining original tracks
     if currentTrackIndex + 1 < currentTracks.count {
@@ -1861,8 +1850,6 @@ class TrackPlayerCore: NSObject {
       newQueueTracks.append(contentsOf: remainingOriginal)
     }
 
-    print("   New queue: \(newQueueTracks.count) tracks total")
-
     // Remove all items from player EXCEPT the currently playing one
     for item in playingItems where item != currentItem {
       player.remove(item)
@@ -1877,7 +1864,6 @@ class TrackPlayerCore: NSObject {
       }
     }
 
-    print("   ✅ Queue rebuilt successfully")
   }
 
   /**

package/lib/hooks/callbackManager.d.ts

@@ -1,6 +1,8 @@
 import type { TrackItem, TrackPlayerState, Reason } from '../types/PlayerQueue';
 type PlaybackStateCallback = (state: TrackPlayerState, reason?: Reason) => void;
 type TrackChangeCallback = (track: TrackItem, reason?: Reason) => void;
+type PlaybackProgressCallback = (position: number, totalDuration: number, isManuallySeeked?: boolean) => void;
+type SeekCallback = (position: number, totalDuration: number) => void;
 /**
  * Internal subscription manager that allows multiple hooks to subscribe
  * to a single native callback. This solves the problem where registering
@@ -9,8 +11,12 @@ type TrackChangeCallback = (track: TrackItem, reason?: Reason) => void;
 declare class CallbackSubscriptionManager {
     private playbackStateSubscribers;
     private trackChangeSubscribers;
+    private playbackProgressSubscribers;
+    private seekSubscribers;
     private isPlaybackStateRegistered;
     private isTrackChangeRegistered;
+    private isPlaybackProgressRegistered;
+    private isSeekRegistered;
     /**
      * Subscribe to playback state changes
      * @returns Unsubscribe function
@@ -23,6 +29,18 @@ declare class CallbackSubscriptionManager {
     subscribeToTrackChange(callback: TrackChangeCallback): () => void;
     private ensurePlaybackStateRegistered;
     private ensureTrackChangeRegistered;
+    /**
+     * Subscribe to playback progress changes
+     * @returns Unsubscribe function
+     */
+    subscribeToPlaybackProgressChange(callback: PlaybackProgressCallback): () => void;
+    /**
+     * Subscribe to seek events
+     * @returns Unsubscribe function
+     */
+    subscribeToSeek(callback: SeekCallback): () => void;
+    private ensurePlaybackProgressRegistered;
+    private ensureSeekRegistered;
 }
 export declare const callbackManager: CallbackSubscriptionManager;
 export {};

package/lib/hooks/callbackManager.js

@@ -7,8 +7,12 @@ import { TrackPlayer } from '../index';
 class CallbackSubscriptionManager {
     playbackStateSubscribers = new Set();
     trackChangeSubscribers = new Set();
+    playbackProgressSubscribers = new Set();
+    seekSubscribers = new Set();
     isPlaybackStateRegistered = false;
     isTrackChangeRegistered = false;
+    isPlaybackProgressRegistered = false;
+    isSeekRegistered = false;
     /**
      * Subscribe to playback state changes
      * @returns Unsubscribe function
@@ -71,6 +75,68 @@ class CallbackSubscriptionManager {
             console.error('[CallbackManager] Failed to register track change callback:', error);
         }
     }
+    /**
+     * Subscribe to playback progress changes
+     * @returns Unsubscribe function
+     */
+    subscribeToPlaybackProgressChange(callback) {
+        this.playbackProgressSubscribers.add(callback);
+        this.ensurePlaybackProgressRegistered();
+        return () => {
+            this.playbackProgressSubscribers.delete(callback);
+        };
+    }
+    /**
+     * Subscribe to seek events
+     * @returns Unsubscribe function
+     */
+    subscribeToSeek(callback) {
+        this.seekSubscribers.add(callback);
+        this.ensureSeekRegistered();
+        return () => {
+            this.seekSubscribers.delete(callback);
+        };
+    }
+    ensurePlaybackProgressRegistered() {
+        if (this.isPlaybackProgressRegistered)
+            return;
+        try {
+            TrackPlayer.onPlaybackProgressChange((position, totalDuration, isManuallySeeked) => {
+                this.playbackProgressSubscribers.forEach((subscriber) => {
+                    try {
+                        subscriber(position, totalDuration, isManuallySeeked);
+                    }
+                    catch (error) {
+                        console.error('[CallbackManager] Error in playback progress subscriber:', error);
+                    }
+                });
+            });
+            this.isPlaybackProgressRegistered = true;
+        }
+        catch (error) {
+            console.error('[CallbackManager] Failed to register playback progress callback:', error);
+        }
+    }
+    ensureSeekRegistered() {
+        if (this.isSeekRegistered)
+            return;
+        try {
+            TrackPlayer.onSeek((position, totalDuration) => {
+                this.seekSubscribers.forEach((subscriber) => {
+                    try {
+                        subscriber(position, totalDuration);
+                    }
+                    catch (error) {
+                        console.error('[CallbackManager] Error in seek subscriber:', error);
+                    }
+                });
+            });
+            this.isSeekRegistered = true;
+        }
+        catch (error) {
+            console.error('[CallbackManager] Failed to register seek callback:', error);
+        }
+    }
 }
 // Export singleton instance
 export const callbackManager = new CallbackSubscriptionManager();

package/lib/hooks/useNowPlaying.js

@@ -47,12 +47,14 @@ const DEFAULT_STATE = {
 export function useNowPlaying() {
     const [state, setState] = useState(DEFAULT_STATE);
     const isMounted = useRef(true);
-    const updateState = useCallback(async () => {
+    const fetchFullState = useCallback(async () => {
         if (!isMounted.current)
             return;
         try {
             const newState = await TrackPlayer.getState();
-            setState(newState);
+            if (isMounted.current) {
+                setState(newState);
+            }
         }
         catch (error) {
             console.error('[useNowPlaying] Error updating player state:', error);
@@ -61,28 +63,38 @@ export function useNowPlaying() {
     // Initialize with current state
     useEffect(() => {
         isMounted.current = true;
-        updateState();
+        fetchFullState();
         return () => {
             isMounted.current = false;
         };
-    }, [updateState]);
-    // Subscribe to track changes
+    }, [fetchFullState]);
+    // Subscribe to track changes — full refresh
     useEffect(() => {
-        const unsubscribe = callbackManager.subscribeToTrackChange(() => {
-            updateState();
+        return callbackManager.subscribeToTrackChange(() => {
+            fetchFullState();
         });
-        return () => {
-            unsubscribe();
-        };
-    }, [updateState]);
-    // Subscribe to playback state changes
+    }, [fetchFullState]);
+    // Subscribe to playback state changes — full refresh
     useEffect(() => {
-        const unsubscribe = callbackManager.subscribeToPlaybackState(() => {
-            updateState();
+        return callbackManager.subscribeToPlaybackState(() => {
+            fetchFullState();
         });
-        return () => {
-            unsubscribe();
-        };
-    }, [updateState]);
+    }, [fetchFullState]);
+    // Subscribe to progress changes — lightweight position/duration update
+    useEffect(() => {
+        return callbackManager.subscribeToPlaybackProgressChange((currentPosition, totalDuration) => {
+            if (!isMounted.current)
+                return;
+            setState((prev) => ({ ...prev, currentPosition, totalDuration }));
+        });
+    }, []);
+    // Subscribe to seek events — lightweight position/duration update
+    useEffect(() => {
+        return callbackManager.subscribeToSeek((currentPosition, totalDuration) => {
+            if (!isMounted.current)
+                return;
+            setState((prev) => ({ ...prev, currentPosition, totalDuration }));
+        });
+    }, []);
     return state;
 }

package/lib/hooks/useOnPlaybackProgressChange.js

@@ -1,5 +1,5 @@
 import { useEffect, useState } from 'react';
-import { TrackPlayer } from '../index';
+import { callbackManager } from './callbackManager';
 /**
  * Hook to get the current playback progress
  * @returns Object with current position, total duration, and manual seek indicator
@@ -9,7 +9,7 @@ export function useOnPlaybackProgressChange() {
     const [totalDuration, setTotalDuration] = useState(0);
     const [isManuallySeeked, setIsManuallySeeked] = useState(undefined);
     useEffect(() => {
-        TrackPlayer.onPlaybackProgressChange((newPosition, newTotalDuration, newIsManuallySeeked) => {
+        return callbackManager.subscribeToPlaybackProgressChange((newPosition, newTotalDuration, newIsManuallySeeked) => {
             setPosition(newPosition);
             setTotalDuration(newTotalDuration);
             setIsManuallySeeked(newIsManuallySeeked);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "0.4.0",
+  "version": "0.4.1-alpha.0",
   "description": "react-native-nitro-player",
   "main": "lib/index",
   "module": "lib/index",

package/src/hooks/callbackManager.ts

@@ -3,6 +3,12 @@ import type { TrackItem, TrackPlayerState, Reason } from '../types/PlayerQueue'
 
 type PlaybackStateCallback = (state: TrackPlayerState, reason?: Reason) => void
 type TrackChangeCallback = (track: TrackItem, reason?: Reason) => void
+type PlaybackProgressCallback = (
+  position: number,
+  totalDuration: number,
+  isManuallySeeked?: boolean
+) => void
+type SeekCallback = (position: number, totalDuration: number) => void
 
 /**
  * Internal subscription manager that allows multiple hooks to subscribe
@@ -12,8 +18,12 @@ type TrackChangeCallback = (track: TrackItem, reason?: Reason) => void
 class CallbackSubscriptionManager {
   private playbackStateSubscribers = new Set<PlaybackStateCallback>()
   private trackChangeSubscribers = new Set<TrackChangeCallback>()
+  private playbackProgressSubscribers = new Set<PlaybackProgressCallback>()
+  private seekSubscribers = new Set<SeekCallback>()
   private isPlaybackStateRegistered = false
   private isTrackChangeRegistered = false
+  private isPlaybackProgressRegistered = false
+  private isSeekRegistered = false
 
   /**
    * Subscribe to playback state changes
@@ -90,6 +100,83 @@ class CallbackSubscriptionManager {
       )
     }
   }
+
+  /**
+   * Subscribe to playback progress changes
+   * @returns Unsubscribe function
+   */
+  subscribeToPlaybackProgressChange(
+    callback: PlaybackProgressCallback
+  ): () => void {
+    this.playbackProgressSubscribers.add(callback)
+    this.ensurePlaybackProgressRegistered()
+
+    return () => {
+      this.playbackProgressSubscribers.delete(callback)
+    }
+  }
+
+  /**
+   * Subscribe to seek events
+   * @returns Unsubscribe function
+   */
+  subscribeToSeek(callback: SeekCallback): () => void {
+    this.seekSubscribers.add(callback)
+    this.ensureSeekRegistered()
+
+    return () => {
+      this.seekSubscribers.delete(callback)
+    }
+  }
+
+  private ensurePlaybackProgressRegistered(): void {
+    if (this.isPlaybackProgressRegistered) return
+
+    try {
+      TrackPlayer.onPlaybackProgressChange(
+        (position, totalDuration, isManuallySeeked) => {
+          this.playbackProgressSubscribers.forEach((subscriber) => {
+            try {
+              subscriber(position, totalDuration, isManuallySeeked)
+            } catch (error) {
+              console.error(
+                '[CallbackManager] Error in playback progress subscriber:',
+                error
+              )
+            }
+          })
+        }
+      )
+      this.isPlaybackProgressRegistered = true
+    } catch (error) {
+      console.error(
+        '[CallbackManager] Failed to register playback progress callback:',
+        error
+      )
+    }
+  }
+
+  private ensureSeekRegistered(): void {
+    if (this.isSeekRegistered) return
+
+    try {
+      TrackPlayer.onSeek((position, totalDuration) => {
+        this.seekSubscribers.forEach((subscriber) => {
+          try {
+            subscriber(position, totalDuration)
+          } catch (error) {
+            console.error('[CallbackManager] Error in seek subscriber:', error)
+          }
+        })
+      })
+      this.isSeekRegistered = true
+    } catch (error) {
+      console.error(
+        '[CallbackManager] Failed to register seek callback:',
+        error
+      )
+    }
+  }
 }
 
 // Export singleton instance

package/src/hooks/useNowPlaying.ts

@@ -51,12 +51,14 @@ export function useNowPlaying(): PlayerState {
   const [state, setState] = useState<PlayerState>(DEFAULT_STATE)
   const isMounted = useRef(true)
 
-  const updateState = useCallback(async () => {
+  const fetchFullState = useCallback(async () => {
     if (!isMounted.current) return
 
     try {
       const newState = await TrackPlayer.getState()
-      setState(newState)
+      if (isMounted.current) {
+        setState(newState)
+      }
     } catch (error) {
       console.error('[useNowPlaying] Error updating player state:', error)
     }
@@ -65,34 +67,44 @@ export function useNowPlaying(): PlayerState {
   // Initialize with current state
   useEffect(() => {
     isMounted.current = true
-    updateState()
+    fetchFullState()
 
     return () => {
       isMounted.current = false
     }
-  }, [updateState])
+  }, [fetchFullState])
 
-  // Subscribe to track changes
+  // Subscribe to track changes — full refresh
   useEffect(() => {
-    const unsubscribe = callbackManager.subscribeToTrackChange(() => {
-      updateState()
+    return callbackManager.subscribeToTrackChange(() => {
+      fetchFullState()
     })
+  }, [fetchFullState])
 
-    return () => {
-      unsubscribe()
-    }
-  }, [updateState])
-
-  // Subscribe to playback state changes
+  // Subscribe to playback state changes — full refresh
   useEffect(() => {
-    const unsubscribe = callbackManager.subscribeToPlaybackState(() => {
-      updateState()
+    return callbackManager.subscribeToPlaybackState(() => {
+      fetchFullState()
     })
+  }, [fetchFullState])
 
-    return () => {
-      unsubscribe()
-    }
-  }, [updateState])
+  // Subscribe to progress changes — lightweight position/duration update
+  useEffect(() => {
+    return callbackManager.subscribeToPlaybackProgressChange(
+      (currentPosition, totalDuration) => {
+        if (!isMounted.current) return
+        setState((prev) => ({ ...prev, currentPosition, totalDuration }))
+      }
+    )
+  }, [])
+
+  // Subscribe to seek events — lightweight position/duration update
+  useEffect(() => {
+    return callbackManager.subscribeToSeek((currentPosition, totalDuration) => {
+      if (!isMounted.current) return
+      setState((prev) => ({ ...prev, currentPosition, totalDuration }))
+    })
+  }, [])
 
   return state
 }

package/src/hooks/useOnPlaybackProgressChange.ts

@@ -1,5 +1,5 @@
 import { useEffect, useState } from 'react'
-import { TrackPlayer } from '../index'
+import { callbackManager } from './callbackManager'
 
 /**
  * Hook to get the current playback progress
@@ -17,7 +17,7 @@ export function useOnPlaybackProgressChange(): {
   )
 
   useEffect(() => {
-    TrackPlayer.onPlaybackProgressChange(
+    return callbackManager.subscribeToPlaybackProgressChange(
       (newPosition, newTotalDuration, newIsManuallySeeked) => {
         setPosition(newPosition)
         setTotalDuration(newTotalDuration)