react-native-nitro-player 0.3.0-alpha.12 → 0.3.0-alpha.13

package/README.md

@@ -52,6 +52,7 @@ npm install react-native-nitro-modules
 | `playNext(id)`              | Both     | **Async**. Adds a track to the "play next" stack (LIFO).            |
 | `getActualQueue()`          | Both     | **Async**. Gets the full playback queue including temporary tracks. |
 | `getState()`                | Both     | **Async**. Gets the current player state immediately.               |
+| `skipToIndex(index)`        | Both     | **Async**. Skips to a specific index in the actual queue.           |
 | `configure(config)`         | Both     | Configures player settings (Android Auto, etc.).                    |
 | `isAndroidAutoConnected()`  | Both     | Checks if Android Auto is currently connected.                      |
 
@@ -270,6 +271,29 @@ Temporary tracks are automatically cleared when:
 - `PlayerQueue.loadPlaylist()` is called
 - `TrackPlayer.playFromIndex()` is called
 
+### `skipToIndex(index: number): Promise<boolean>`
+
+Skips to a specific index in the **actual queue** (the combined queue with temporary tracks).
+
+**Behavior:**
+
+- Takes an index into the actual queue structure
+- If the target is a temporary track (playNext or upNext), plays that track
+- If the target is beyond temporary tracks (in the remaining original playlist), clears all temporary tracks and plays from the original playlist
+- Returns `true` if successful, `false` if the index is invalid
+
+**Example:**
+
+```typescript
+// Queue: [track1(0), track2(1, current), playNext-A(2), upNext-B(3), track3(4), track4(5)]
+
+// Skip to playNext track
+await TrackPlayer.skipToIndex(2) // Plays playNext-A
+
+// Skip to original playlist track (clears temporary tracks)
+await TrackPlayer.skipToIndex(4) // Clears temps, plays track3
+```
+
 ### Getting the Actual Queue
 
 Use `useActualQueue()` hook to see the complete queue including temporary tracks:
@@ -298,6 +322,31 @@ function QueueView() {
 - `refreshQueue: () => void` - Manually refresh the queue
 - `isLoading: boolean` - Whether the queue is currently loading
 
+## CurrentPlayingType
+
+The `currentPlayingType` field in `PlayerState` indicates the source of the currently playing track:
+
+| Value          | Description                                              |
+| -------------- | -------------------------------------------------------- |
+| `'playlist'`   | Playing from the original playlist                       |
+| `'play-next'`  | Playing a track added via `playNext()` (LIFO stack)      |
+| `'up-next'`    | Playing a track added via `addToUpNext()` (FIFO queue)   |
+| `'not-playing'`| No track is currently playing                            |
+
+**Example:**
+
+```typescript
+const state = await TrackPlayer.getState()
+
+if (state.currentPlayingType === 'play-next') {
+  console.log('Playing a play-next track')
+} else if (state.currentPlayingType === 'up-next') {
+  console.log('Playing an up-next track')
+} else if (state.currentPlayingType === 'playlist') {
+  console.log('Playing from the original playlist')
+}
+```
+
 ## Core Concepts
 
 ### PlayerQueue
@@ -390,6 +439,7 @@ Returns the complete current player state (same as `TrackPlayer.getState()`). Th
   - `currentState: TrackPlayerState` - Current playback state (`'playing'`, `'paused'`, or `'stopped'`)
   - `currentPlaylistId: string | null` - ID of the currently loaded playlist, or `null` if no playlist is loaded
   - `currentIndex: number` - Index of the current track in the playlist (-1 if no track is playing)
+  - `currentPlayingType: CurrentPlayingType` - Source of the current track (`'playlist'`, `'play-next'`, `'up-next'`, or `'not-playing'`)
 
 **Note:** This hook is equivalent to calling `TrackPlayer.getState()` but provides reactive updates. It listens to track changes and playback state changes to update automatically. Also dont rely on progress from this hook
 
@@ -489,7 +539,7 @@ import { AudioDevices } from 'react-native-nitro-player'
 
 if (AudioDevices) {
   const devices = AudioDevices.getAudioDevices()
-  devices.forEach(device => {
+  devices.forEach((device) => {
     console.log(`${device.name} - Active: ${device.isActive}`)
   })
 }
@@ -736,7 +786,7 @@ TrackPlayer.onPlaybackProgressChange(
 )
 
 // Listen to Android Auto connection changes
-TrackPlayer.onAndroidAutoConnectionChange(connected => {
+TrackPlayer.onAndroidAutoConnectionChange((connected) => {
   console.log('Android Auto:', connected ? 'Connected' : 'Disconnected')
 })
 ```
@@ -754,6 +804,7 @@ console.log(state.totalDuration) // total duration in seconds
 console.log(state.currentTrack) // current TrackItem or null
 console.log(state.currentPlaylistId) // current playlist ID or null
 console.log(state.currentIndex) // current track index in playlist
+console.log(state.currentPlayingType) // 'playlist' | 'play-next' | 'up-next' | 'not-playing'
 ```
 
 ## Track Item Structure
@@ -978,6 +1029,7 @@ import type {
   Playlist,
   PlayerState,
   TrackPlayerState,
+  CurrentPlayingType,
   QueueOperation,
   Reason,
   PlayerConfig,

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

@@ -114,4 +114,11 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
     @DoNotStrip
     @Keep
     override fun setVolume(volume: Double): Boolean = core.setVolume(volume)
+
+    @DoNotStrip
+    @Keep
+    override fun skipToIndex(index: Double): Promise<Boolean> =
+        Promise.async {
+            core.skipToIndex(index.toInt())
+        }
 }

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
@@ -84,6 +85,7 @@ class TrackPlayerCore private constructor(
     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 {
@@ -228,6 +230,16 @@ class TrackPlayerCore private constructor(
                         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(':')) {
@@ -596,10 +608,13 @@ class TrackPlayerCore private constructor(
             if (currentTemporaryType != TemporaryType.NONE) {
                 println("🔄 TrackPlayerCore: Playing temporary track - seeking to beginning")
                 player.seekTo(0)
-            } else if (player.hasPreviousMediaItem()) {
-                player.seekToPreviousMediaItem()
+            } 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)
             }
         }
@@ -692,6 +707,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,
@@ -699,6 +726,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
@@ -709,6 +737,7 @@ class TrackPlayerCore private constructor(
                 currentState = TrackPlayerState.STOPPED,
                 currentPlaylistId = currentPlaylistId?.let { Variant_NullType_String.create(it) },
                 currentIndex = -1.0,
+                currentPlayingType = CurrentPlayingType.NOT_PLAYING,
             )
         }
 
@@ -778,6 +807,159 @@ class TrackPlayerCore private constructor(
         }
     }
 
+    // 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()
@@ -785,10 +967,51 @@ class TrackPlayerCore private constructor(
         currentTemporaryType = TemporaryType.NONE
         println("   🧹 Cleared temporary tracks")
 
-        if (::player.isInitialized && index >= 0 && index < player.mediaItemCount) {
-            player.seekToDefaultPosition(index)
-            player.playWhenReady = true
+        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
@@ -1153,6 +1376,7 @@ class TrackPlayerCore private constructor(
         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>()
 
@@ -1161,8 +1385,9 @@ class TrackPlayerCore private constructor(
             return emptyList()
         }
 
-        val currentIndex = player.currentMediaItemIndex
-        println("   currentIndex: $currentIndex")
+        // 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()

package/ios/HybridTrackPlayer.swift

@@ -124,6 +124,12 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
     return false
   }
 
+  func skipToIndex(index: Double) throws -> Promise<Bool> {
+    return Promise.async {
+      return self.core.skipToIndex(index: Int(index))
+    }
+  }
+
   // MARK: - Volume Control
 
   func setVolume(volume: Double) throws -> Bool {

package/ios/core/TrackPlayerCore.swift

@@ -1436,7 +1436,8 @@ class TrackPlayerCore: NSObject {
             totalDuration: 0.0,
             currentState: .stopped,
             currentPlaylistId: nil,
-            currentIndex: -1.0
+            currentIndex: -1.0,
+            currentPlayingType: .notPlaying
           )
       }
       return state
@@ -1451,7 +1452,8 @@ class TrackPlayerCore: NSObject {
         totalDuration: 0.0,
         currentState: .stopped,
         currentPlaylistId: currentPlaylistId.map { Variant_NullType_String.second($0) },
-        currentIndex: -1.0
+        currentIndex: -1.0,
+        currentPlayingType: .notPlaying
       )
     }
 
@@ -1471,13 +1473,29 @@ class TrackPlayerCore: NSObject {
     // Get current index
     let currentIndex: Double = currentTrackIndex >= 0 ? Double(currentTrackIndex) : -1.0
 
+    // Map internal temporary type to CurrentPlayingType
+    let currentPlayingType: CurrentPlayingType
+    if currentTrack == nil {
+      currentPlayingType = .notPlaying
+    } else {
+      switch currentTemporaryType {
+      case .none:
+        currentPlayingType = .playlist
+      case .playNext:
+        currentPlayingType = .playNext
+      case .upNext:
+        currentPlayingType = .upNext
+      }
+    }
+
     return PlayerState(
       currentTrack: currentTrack.map { Variant_NullType_TrackItem.second($0) },
       currentPosition: currentPosition,
       totalDuration: totalDuration,
       currentState: currentState,
       currentPlaylistId: currentPlaylistId.map { Variant_NullType_String.second($0) },
-      currentIndex: currentIndex
+      currentIndex: currentIndex,
+      currentPlayingType: currentPlayingType
     )
   }
 
@@ -1531,10 +1549,143 @@ class TrackPlayerCore: NSObject {
     }
   }
 
+  // MARK: - Skip to Index in Actual Queue
+
+  func skipToIndex(index: Int) -> Bool {
+    if Thread.isMainThread {
+      return skipToIndexInternal(index: index)
+    } else {
+      var result = false
+      DispatchQueue.main.sync { [weak self] in
+        result = self?.skipToIndexInternal(index: index) ?? false
+      }
+      return result
+    }
+  }
+
+  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
+    }
+
+    // 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 upNextStart = playNextEnd
+    let upNextEnd = upNextStart + upNextQueue.count
+    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
+    }
+
+    // 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)")
+
+      // Remove tracks before the target from playNext (they're being skipped)
+      if playNextIndex > 0 {
+        playNextStack.removeFirst(playNextIndex)
+        print("      Removed \(playNextIndex) tracks from playNext stack")
+      }
+
+      // Rebuild queue and advance
+      rebuildAVQueueFromCurrentPosition()
+      player?.advanceToNextItem()
+      return true
+    }
+
+    // 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)")
+
+      // 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")
+      }
+
+      // Rebuild queue and advance
+      rebuildAVQueueFromCurrentPosition()
+      player?.advanceToNextItem()
+      return true
+    }
+
+    // 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
+    }
+
+    print("   ❌ Unexpected case, index \(index) not handled")
+    return false
+  }
+
   private func playFromIndexInternal(index: Int) {
+    _ = playFromIndexInternalWithResult(index: index)
+  }
+
+  private func playFromIndexInternalWithResult(index: Int) -> Bool {
     guard index >= 0 && index < self.currentTracks.count else {
-      print("❌ TrackPlayerCore: playFromIndex - invalid index \(index)")
-      return
+      print("❌ TrackPlayerCore: playFromIndex - invalid index \(index), currentTracks.count = \(self.currentTracks.count)")
+      return false
     }
 
     print("\n🎯 TrackPlayerCore: PLAY FROM INDEX \(index)")
@@ -1569,7 +1720,7 @@ class TrackPlayerCore: NSObject {
 
     guard let player = self.player, !items.isEmpty else {
       print("❌ No player or no items to play")
-      return
+      return false
     }
 
     // Remove old boundary observer
@@ -1600,6 +1751,7 @@ class TrackPlayerCore: NSObject {
     self.preloadUpcomingTracks(from: index + 1)
 
     player.play()
+    return true
   }
 
   // MARK: - Temporary Track Management

package/lib/hooks/useNowPlaying.js

@@ -8,6 +8,7 @@ const DEFAULT_STATE = {
     currentState: 'stopped',
     currentPlaylistId: null,
     currentIndex: -1,
+    currentPlayingType: 'not-playing',
 };
 /**
  * Hook to get the current player state (same as TrackPlayer.getState())

package/lib/specs/TrackPlayer.nitro.d.ts

@@ -27,6 +27,7 @@ export interface TrackPlayer extends HybridObject<{
     pause(): void;
     playSong(songId: string, fromPlaylist?: string): Promise<void>;
     skipToNext(): void;
+    skipToIndex(index: number): Promise<boolean>;
     skipToPrevious(): void;
     seek(position: number): void;
     addToUpNext(trackId: string): Promise<void>;