react-native-nitro-player 1.1.0 → 1.2.1

package/android/src/main/AndroidManifest.xml

@@ -8,6 +8,11 @@
     <uses-permission android:name="android.permission.WAKE_LOCK" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
+    <!-- Required so Android Auto / Assistant treat this as a media app. -->
+    <uses-feature
+        android:name="android.hardware.audio.output"
+        android:required="false" />
+
     <application>
         <!-- PlaybackService keeps music alive when screen is locked / app backgrounded -->
         <service
@@ -18,6 +23,13 @@
             <intent-filter>
                 <action android:name="androidx.media3.session.MediaSessionService" />
             </intent-filter>
+            <!-- Legacy voice-search entry point. Modern Android Auto / Assistant
+                 routes through MediaSession.Callback.onSetMediaItems with a
+                 searchQuery, but some surfaces still send this action. -->
+            <intent-filter>
+                <action android:name="android.media.action.MEDIA_PLAY_FROM_SEARCH" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
         </service>
 
         <!-- WorkManager's SystemForegroundService for download notifications -->

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

@@ -109,9 +109,12 @@ class HybridPlayerQueue : HybridPlayerQueueSpec() {
 
     // ── Playback control ──────────────────────────────────────────────────────
 
-    override fun loadPlaylist(playlistId: String): Promise<Unit> =
+    override fun loadPlaylist(playlistId: String, index: Double?): Promise<Unit> =
         Promise.async {
-            core.loadPlaylist(playlistId)
+            val startIndex = index?.toInt()
+            val loaded = playlistManager.loadPlaylist(playlistId, startIndex)
+            if (!loaded) return@async
+            core.loadPlaylist(playlistId, startIndex)
         }
 
     override fun getCurrentPlaylistId(): Variant_NullType_String {

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

@@ -30,8 +30,7 @@ internal fun TrackPlayerCore.rebuildQueueAndPlayFromIndex(index: Int) {
 
     currentTrackIndex = index
     exo.clearMediaItems()
-    exo.setMediaItems(mediaItems)
-    exo.seekToDefaultPosition(0)
+    exo.setMediaItems(mediaItems, true)
     exo.prepare()
 }
 
@@ -123,7 +122,7 @@ internal fun TrackPlayerCore.updatePlayerQueue(tracks: List<TrackItem>) {
             val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
             makeMediaItem(track, mediaId)
         }
-    exo.setMediaItems(mediaItems, false)
+    exo.setMediaItems(mediaItems, true)
     if (exo.playbackState == Player.STATE_IDLE && mediaItems.isNotEmpty()) {
         exo.prepare()
     }

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

@@ -11,14 +11,33 @@ import com.margelo.nitro.nitroplayer.TrackItem
 
 // ── Playlist loading ──────────────────────────────────────────────────────
 
-suspend fun TrackPlayerCore.loadPlaylist(playlistId: String) =
+suspend fun TrackPlayerCore.loadPlaylist(
+    playlistId: String,
+    startIndex: Int? = null,
+) =
     withPlayerContext {
         playNextStack.clear()
         upNextQueue.clear()
         currentTemporaryType = TrackPlayerCore.TemporaryType.NONE
         val playlist = playlistManager.getPlaylist(playlistId) ?: return@withPlayerContext
+
+        val targetIndex =
+            if (startIndex != null) {
+                if (startIndex < 0 || startIndex >= playlist.tracks.size) return@withPlayerContext
+                startIndex
+            } else {
+                0
+            }
+
         currentPlaylistId = playlistId
-        updatePlayerQueue(playlist.tracks)
+        if (targetIndex == 0) {
+            updatePlayerQueue(playlist.tracks)
+        } else {
+            // Bypass updatePlayerQueue to avoid emitting a spurious onTrackChange for index 0.
+            // Set currentTracks directly so rebuildQueueAndPlayFromIndex can use them.
+            currentTracks = playlist.tracks
+            rebuildQueueAndPlayFromIndex(targetIndex)
+        }
         checkUpcomingTracksForUrls(lookaheadCount)
         notifyTemporaryQueueChange()
     }

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

@@ -3,6 +3,7 @@
 package com.margelo.nitro.nitroplayer.media
 
 import android.net.Uri
+import android.provider.MediaStore
 import androidx.media3.common.MediaItem
 import androidx.media3.common.MediaMetadata
 import androidx.media3.exoplayer.ExoPlayer
@@ -14,6 +15,7 @@ import com.google.common.util.concurrent.ListenableFuture
 import com.margelo.nitro.nitroplayer.TrackItem
 import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
 import com.margelo.nitro.nitroplayer.core.loadPlaylist
+import com.margelo.nitro.nitroplayer.playlist.Playlist
 import com.margelo.nitro.nitroplayer.playlist.PlaylistManager
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -52,6 +54,13 @@ object MediaSessionCallbackFactory {
                 mediaItems: MutableList<MediaItem>,
             ): ListenableFuture<MutableList<MediaItem>> {
                 NitroPlayerLogger.log("MediaSessionCallback") { "onAddMediaItems called with ${mediaItems.size} items" }
+
+                // Voice search ("Add X to the queue") lands here too.
+                val voiceMatch = resolveVoiceSearch(mediaItems, playlistManager)
+                if (voiceMatch != null) {
+                    return Futures.immediateFuture(voiceMatch.items.toMutableList())
+                }
+
                 if (mediaItems.isEmpty()) return Futures.immediateFuture(mutableListOf())
 
                 val updated = mutableListOf<MediaItem>()
@@ -90,6 +99,21 @@ object MediaSessionCallbackFactory {
                 startPositionMs: Long,
             ): ListenableFuture<MediaSession.MediaItemsWithStartPosition> {
                 NitroPlayerLogger.log("MediaSessionCallback") { "onSetMediaItems called with ${mediaItems.size} items, startIndex: $startIndex" }
+
+                // Voice search ("Hey Google, play X on …") routes here with a
+                // MediaItem whose requestMetadata.searchQuery is set. Resolve
+                // it against loaded playlists before falling through.
+                val voiceMatch = resolveVoiceSearch(mediaItems, playlistManager)
+                if (voiceMatch != null) {
+                    val (playlistId, items, trackIndex) = voiceMatch
+                    service.trackPlayerCore?.let { core ->
+                        scope.launch { core.loadPlaylist(playlistId) }
+                    }
+                    return Futures.immediateFuture(
+                        MediaSession.MediaItemsWithStartPosition(items, trackIndex, startPositionMs),
+                    )
+                }
+
                 if (mediaItems.isEmpty()) {
                     return Futures.immediateFuture(
                         MediaSession.MediaItemsWithStartPosition(mutableListOf(), 0, 0),
@@ -125,6 +149,17 @@ object MediaSessionCallbackFactory {
                 } catch (e: Exception) {
                     NitroPlayerLogger.log("MediaSessionCallback") { "Error in onSetMediaItems: ${e.message}" }
                 }
+
+                // If a voice query was issued but found nothing, return an
+                // explicit failure so the controller (Assistant) surfaces a
+                // spoken error instead of silently no-oping. Without this the
+                // Auto QA bot reports "no music played or error message shown".
+                if (mediaItems.isNotEmpty() && mediaItems[0].requestMetadata.searchQuery != null) {
+                    return Futures.immediateFailedFuture(
+                        UnsupportedOperationException("No matching tracks for voice search"),
+                    )
+                }
+
                 return Futures.immediateFuture(
                     MediaSession.MediaItemsWithStartPosition(mediaItems, startIndex, startPositionMs),
                 )
@@ -140,6 +175,149 @@ object MediaSessionCallbackFactory {
         }
     }
 
+    private data class VoiceMatch(
+        val playlistId: String,
+        val items: List<MediaItem>,
+        val startIndex: Int,
+    )
+
+    /**
+     * Resolves a voice-search MediaItem into a concrete playlist + start index.
+     *
+     * Triggered when Google Assistant ("Hey Google, play X on …") sends a
+     * MediaItem with `requestMetadata.searchQuery`. Honors the
+     * `MediaStore.EXTRA_MEDIA_FOCUS` bundle so artist/album/genre/playlist/title
+     * queries narrow the search appropriately. Empty queries fall back to the
+     * current or first available playlist (Assistant: "Play music").
+     */
+    @Suppress("DEPRECATION") // MediaStore.Audio.Playlists constants — Assistant still sends them.
+    private fun resolveVoiceSearch(
+        mediaItems: List<MediaItem>,
+        playlistManager: PlaylistManager,
+    ): VoiceMatch? {
+        val first = mediaItems.firstOrNull() ?: return null
+        val request = first.requestMetadata
+        val rawQuery = request.searchQuery ?: return null
+        val query = rawQuery.trim()
+        val extras = request.extras
+
+        // Empty query → "play music"-style resume. Prefer current playlist,
+        // otherwise the first non-empty playlist.
+        if (query.isEmpty()) {
+            val fallback =
+                playlistManager.getCurrentPlaylist()
+                    ?: playlistManager.getAllPlaylists().firstOrNull { it.tracks.isNotEmpty() }
+                    ?: return null
+            val items =
+                fallback.tracks.map { createMediaItem(it, "${fallback.id}:${it.id}") }
+            return VoiceMatch(fallback.id, items, 0)
+        }
+
+        val focus = extras?.getString(MediaStore.EXTRA_MEDIA_FOCUS)
+        val artist = extras?.getString(MediaStore.EXTRA_MEDIA_ARTIST)
+        val album = extras?.getString(MediaStore.EXTRA_MEDIA_ALBUM)
+        val title = extras?.getString(MediaStore.EXTRA_MEDIA_TITLE)
+        val playlistName = extras?.getString(MediaStore.EXTRA_MEDIA_PLAYLIST)
+        val genre = extras?.getString(MediaStore.EXTRA_MEDIA_GENRE)
+
+        val all = playlistManager.getAllPlaylists()
+        if (all.isEmpty()) return null
+
+        // Playlist-focused query: best match by playlist name.
+        if (focus == MediaStore.Audio.Playlists.ENTRY_CONTENT_TYPE && !playlistName.isNullOrBlank()) {
+            val matched = bestPlaylistByName(all, playlistName) ?: bestPlaylistByName(all, query)
+            if (matched != null && matched.tracks.isNotEmpty()) {
+                val items = matched.tracks.map { createMediaItem(it, "${matched.id}:${it.id}") }
+                return VoiceMatch(matched.id, items, 0)
+            }
+        }
+
+        // Score every track across every playlist; play the best track in the
+        // context of its playlist so "next/previous" still work naturally.
+        var bestPlaylist: Playlist? = null
+        var bestIndex = -1
+        var bestScore = 0
+
+        for (playlist in all) {
+            playlist.tracks.forEachIndexed { idx, track ->
+                val score = scoreTrack(track, query, focus, title, artist, album, genre)
+                if (score > bestScore) {
+                    bestScore = score
+                    bestPlaylist = playlist
+                    bestIndex = idx
+                }
+            }
+        }
+
+        val match = bestPlaylist
+        if (match == null || bestIndex < 0 || bestScore <= 0) return null
+
+        val items = match.tracks.map { createMediaItem(it, "${match.id}:${it.id}") }
+        return VoiceMatch(match.id, items, bestIndex)
+    }
+
+    private fun bestPlaylistByName(
+        playlists: List<Playlist>,
+        name: String,
+    ): Playlist? {
+        val q = name.lowercase().trim()
+        if (q.isEmpty()) return null
+        return playlists
+            .map { it to it.name.lowercase() }
+            .filter { (_, n) -> n.contains(q) || q.contains(n) }
+            .minByOrNull { (_, n) -> kotlin.math.abs(n.length - q.length) }
+            ?.first
+    }
+
+    private fun scoreTrack(
+        track: TrackItem,
+        query: String,
+        focus: String?,
+        title: String?,
+        artist: String?,
+        album: String?,
+        genre: String?,
+    ): Int {
+        val q = query.lowercase()
+        val titleL = track.title.lowercase()
+        val artistL = track.artist.lowercase()
+        val albumL = track.album.lowercase()
+
+        var score = 0
+
+        when (focus) {
+            MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE -> {
+                if (!artist.isNullOrBlank() && artistL.contains(artist.lowercase())) score += 80
+                if (artistL.contains(q)) score += 40
+            }
+            MediaStore.Audio.Albums.ENTRY_CONTENT_TYPE -> {
+                if (!album.isNullOrBlank() && albumL.contains(album.lowercase())) score += 80
+                if (albumL.contains(q)) score += 40
+            }
+            MediaStore.Audio.Genres.ENTRY_CONTENT_TYPE -> {
+                if (!genre.isNullOrBlank()) {
+                    val g = genre.lowercase()
+                    if (titleL.contains(g) || albumL.contains(g) || artistL.contains(g)) score += 40
+                }
+            }
+            else -> {
+                if (!title.isNullOrBlank() && titleL.contains(title.lowercase())) score += 80
+                if (!artist.isNullOrBlank() && artistL.contains(artist.lowercase())) score += 50
+                if (!album.isNullOrBlank() && albumL.contains(album.lowercase())) score += 30
+            }
+        }
+
+        // Token-overlap fallback against the whole free-text query.
+        val tokens = q.split(' ', ',', '-').filter { it.length >= 2 }
+        for (t in tokens) {
+            if (titleL.contains(t)) score += 10
+            if (artistL.contains(t)) score += 6
+            if (albumL.contains(t)) score += 3
+        }
+        if (titleL == q || artistL == q || albumL == q) score += 100
+        return score
+    }
+
     private fun createMediaItem(
         track: TrackItem,
         mediaId: String,

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

@@ -304,8 +304,9 @@ class PlaylistManager private constructor(
     /**
      * Load a playlist for playback (sets it as current)
      */
-    fun loadPlaylist(playlistId: String): Boolean {
-        if (playlists[playlistId] == null) return false
+    fun loadPlaylist(playlistId: String, index: Int? = null): Boolean {
+        val playlist = playlists[playlistId] ?: return false
+        if (index != null && (index < 0 || index >= playlist.tracks.size)) return false
         currentPlaylistId = playlistId
         return true
     }

package/ios/core/TrackPlayerQueueBuild.swift

@@ -55,11 +55,11 @@ extension TrackPlayerCore {
     NitroPlayerLogger.log("TrackPlayerCore", "🔄 Removing \(existingPlayer.items().count) old items from player")
     existingPlayer.removeAllItems()
 
-    // Lazy-load mode: if any track has no URL AND is not downloaded locally,
-    // we can't create an AVPlayerItem for it and the queue order would be wrong.
-    let isLazyLoad = tracks.contains {
+    // Lazy-load mode if the first track needs a URL. Tracks further in the queue with
+    // empty URLs are dropped safely by compactMap below and resolved via onTracksNeedUpdate.
+    let isLazyLoad = tracks.first.map {
       $0.url.isEmpty && !DownloadManagerCore.shared.isTrackDownloaded(trackId: $0.id)
-    }
+    } ?? false
     if isLazyLoad {
       NitroPlayerLogger.log("TrackPlayerCore", "⏳ Lazy-load mode — player cleared, awaiting URL resolution")
       return
@@ -156,6 +156,12 @@ extension TrackPlayerCore {
       && !DownloadManagerCore.shared.isTrackDownloaded(trackId: targetTrack.id)
     if isLazyLoad {
       NitroPlayerLogger.log("TrackPlayerCore", "   ⏳ Lazy-load — deferring AVQueuePlayer setup; emitting track change for index \(index)")
+      // Clear old items immediately so the previous track stops while waiting for the URL to resolve
+      if let boundaryObserver = self.boundaryTimeObserver {
+        player?.removeTimeObserver(boundaryObserver)
+        self.boundaryTimeObserver = nil
+      }
+      player?.removeAllItems()
       self.currentTracks = fullPlaylist
       if let track = self.currentTracks[safe: index] {
         notifyTrackChange(track, .skip)

package/ios/core/TrackPlayerTempQueue.swift

@@ -8,7 +8,7 @@ import Foundation
 
 extension TrackPlayerCore {
 
-  func loadPlaylist(playlistId: String) async {
+  func loadPlaylist(playlistId: String, startIndex: Int? = nil) async {
     await withPlayerQueueNoThrow {
       self.playNextStack.removeAll()
       self.upNextQueue.removeAll()
@@ -32,8 +32,27 @@ extension TrackPlayerCore {
       }
       NitroPlayerLogger.log("TrackPlayerCore", String(repeating: "🎼", count: Constants.playlistSeparatorLength) + "\n")
 
+      let targetIndex: Int
+      if let startIndex {
+        guard startIndex >= 0 && startIndex < playlist.tracks.count else {
+          NitroPlayerLogger.log("TrackPlayerCore", "   ❌ Invalid start index: \(startIndex) (track count: \(playlist.tracks.count))")
+          return
+        }
+        targetIndex = startIndex
+      } else {
+        targetIndex = 0
+      }
+
       self.currentPlaylistId = playlistId
-      self.updatePlayerQueue(tracks: playlist.tracks)
+      if targetIndex == 0 {
+        self.updatePlayerQueue(tracks: playlist.tracks)
+      } else {
+        // Bypass updatePlayerQueue to avoid emitting a spurious onTrackChange for index 0.
+        // Set currentTracks directly so rebuildQueueFromPlaylistIndex can use them.
+        self.currentTracks = playlist.tracks
+        self.preloadedAssets.removeAll()
+        _ = self.rebuildQueueFromPlaylistIndex(index: targetIndex)
+      }
       self.emitStateChange()
       self.checkUpcomingTracksForUrls(lookahead: self.lookaheadCount)
       self.notifyTemporaryQueueChange()

package/ios/playlist/PlaylistManager.swift

@@ -261,9 +261,13 @@ class PlaylistManager {
   /**
    * Load a playlist for playback (sets it as current)
    */
-  func loadPlaylist(playlistId: String) -> Bool {
-    let exists = queue.sync { playlists[playlistId] != nil }
-    guard exists else {
+  func loadPlaylist(playlistId: String, index: Int? = nil) -> Bool {
+    let isValid = queue.sync {
+      guard let playlist = playlists[playlistId] else { return false }
+      guard let index else { return true }
+      return index >= 0 && index < playlist.tracks.count
+    }
+    guard isValid else {
       return false
     }
 

package/ios/queue/HybridPlayerQueue.swift

@@ -77,11 +77,13 @@ final class HybridPlayerQueue: HybridPlayerQueueSpec {
 
   // MARK: - Playback control
 
-  func loadPlaylist(playlistId: String) throws -> Promise<Void> {
+  func loadPlaylist(playlistId: String, index: Double?) throws -> Promise<Void> {
     Promise.async {
+      let startIndex = index.map { Int($0) }
       // Update PlaylistManager.currentPlaylistId so getCurrentPlaylistId() returns correctly
-      _ = self.playlistManager.loadPlaylist(playlistId: playlistId)
-      await self.core.loadPlaylist(playlistId: playlistId)
+      let loaded = self.playlistManager.loadPlaylist(playlistId: playlistId, index: startIndex)
+      guard loaded else { return }
+      await self.core.loadPlaylist(playlistId: playlistId, startIndex: startIndex)
     }
   }
 

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

@@ -13,7 +13,7 @@ export interface PlayerQueue extends HybridObject<{
     addTracksToPlaylist(playlistId: string, tracks: TrackItem[], index?: number): Promise<void>;
     removeTrackFromPlaylist(playlistId: string, trackId: string): Promise<void>;
     reorderTrackInPlaylist(playlistId: string, trackId: string, newIndex: number): Promise<void>;
-    loadPlaylist(playlistId: string): Promise<void>;
+    loadPlaylist(playlistId: string, index?: number): Promise<void>;
     getCurrentPlaylistId(): string | null;
     onPlaylistsChanged(callback: (playlists: Playlist[], operation?: QueueOperation) => void): void;
     onPlaylistChanged(callback: (playlistId: string, playlist: Playlist, operation?: QueueOperation) => void): void;

package/nitrogen/generated/android/c++/JHybridPlayerQueueSpec.cpp

@@ -205,9 +205,9 @@ namespace margelo::nitro::nitroplayer {
       return __promise;
     }();
   }
-  std::shared_ptr<Promise<void>> JHybridPlayerQueueSpec::loadPlaylist(const std::string& playlistId) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* playlistId */)>("loadPlaylist");
-    auto __result = method(_javaPart, jni::make_jstring(playlistId));
+  std::shared_ptr<Promise<void>> JHybridPlayerQueueSpec::loadPlaylist(const std::string& playlistId, std::optional<double> index) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* playlistId */, jni::alias_ref<jni::JDouble> /* index */)>("loadPlaylist");
+    auto __result = method(_javaPart, jni::make_jstring(playlistId), index.has_value() ? jni::JDouble::valueOf(index.value()) : nullptr);
     return [&]() {
       auto __promise = Promise<void>::create();
       __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {

package/nitrogen/generated/android/c++/JHybridPlayerQueueSpec.hpp

@@ -63,7 +63,7 @@ namespace margelo::nitro::nitroplayer {
     std::shared_ptr<Promise<void>> addTracksToPlaylist(const std::string& playlistId, const std::vector<TrackItem>& tracks, std::optional<double> index) override;
     std::shared_ptr<Promise<void>> removeTrackFromPlaylist(const std::string& playlistId, const std::string& trackId) override;
     std::shared_ptr<Promise<void>> reorderTrackInPlaylist(const std::string& playlistId, const std::string& trackId, double newIndex) override;
-    std::shared_ptr<Promise<void>> loadPlaylist(const std::string& playlistId) override;
+    std::shared_ptr<Promise<void>> loadPlaylist(const std::string& playlistId, std::optional<double> index) override;
     std::variant<nitro::NullType, std::string> getCurrentPlaylistId() override;
     void onPlaylistsChanged(const std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>& callback) override;
     void onPlaylistChanged(const std::function<void(const std::string& /* playlistId */, const Playlist& /* playlist */, std::optional<QueueOperation> /* operation */)>& callback) override;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/HybridPlayerQueueSpec.kt

@@ -68,7 +68,7 @@ abstract class HybridPlayerQueueSpec: HybridObject() {
   
   @DoNotStrip
   @Keep
-  abstract fun loadPlaylist(playlistId: String): Promise<Unit>
+  abstract fun loadPlaylist(playlistId: String, index: Double?): Promise<Unit>
   
   @DoNotStrip
   @Keep

package/nitrogen/generated/ios/c++/HybridPlayerQueueSpecSwift.hpp

@@ -153,8 +153,8 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<void>> loadPlaylist(const std::string& playlistId) override {
-      auto __result = _swiftPart.loadPlaylist(playlistId);
+    inline std::shared_ptr<Promise<void>> loadPlaylist(const std::string& playlistId, std::optional<double> index) override {
+      auto __result = _swiftPart.loadPlaylist(playlistId, index);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }

package/nitrogen/generated/ios/swift/HybridPlayerQueueSpec.swift

@@ -22,7 +22,7 @@ public protocol HybridPlayerQueueSpec_protocol: HybridObject {
   func addTracksToPlaylist(playlistId: String, tracks: [TrackItem], index: Double?) throws -> Promise<Void>
   func removeTrackFromPlaylist(playlistId: String, trackId: String) throws -> Promise<Void>
   func reorderTrackInPlaylist(playlistId: String, trackId: String, newIndex: Double) throws -> Promise<Void>
-  func loadPlaylist(playlistId: String) throws -> Promise<Void>
+  func loadPlaylist(playlistId: String, index: Double?) throws -> Promise<Void>
   func getCurrentPlaylistId() throws -> Variant_NullType_String
   func onPlaylistsChanged(callback: @escaping (_ playlists: [Playlist], _ operation: QueueOperation?) -> Void) throws -> Void
   func onPlaylistChanged(callback: @escaping (_ playlistId: String, _ playlist: Playlist, _ operation: QueueOperation?) -> Void) throws -> Void

package/nitrogen/generated/ios/swift/HybridPlayerQueueSpec_cxx.swift

@@ -344,9 +344,16 @@ open class HybridPlayerQueueSpec_cxx {
   }
   
   @inline(__always)
-  public final func loadPlaylist(playlistId: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
+  public final func loadPlaylist(playlistId: std.string, index: bridge.std__optional_double_) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
-      let __result = try self.__implementation.loadPlaylist(playlistId: String(playlistId))
+      let __result = try self.__implementation.loadPlaylist(playlistId: String(playlistId), index: { () -> Double? in
+        if bridge.has_value_std__optional_double_(index) {
+          let __unwrapped = bridge.get_std__optional_double_(index)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }())
       let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
         let __promise = bridge.create_std__shared_ptr_Promise_void__()
         let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)

package/nitrogen/generated/shared/c++/HybridPlayerQueueSpec.hpp

@@ -71,7 +71,7 @@ namespace margelo::nitro::nitroplayer {
       virtual std::shared_ptr<Promise<void>> addTracksToPlaylist(const std::string& playlistId, const std::vector<TrackItem>& tracks, std::optional<double> index) = 0;
       virtual std::shared_ptr<Promise<void>> removeTrackFromPlaylist(const std::string& playlistId, const std::string& trackId) = 0;
       virtual std::shared_ptr<Promise<void>> reorderTrackInPlaylist(const std::string& playlistId, const std::string& trackId, double newIndex) = 0;
-      virtual std::shared_ptr<Promise<void>> loadPlaylist(const std::string& playlistId) = 0;
+      virtual std::shared_ptr<Promise<void>> loadPlaylist(const std::string& playlistId, std::optional<double> index) = 0;
       virtual std::variant<nitro::NullType, std::string> getCurrentPlaylistId() = 0;
       virtual void onPlaylistsChanged(const std::function<void(const std::vector<Playlist>& /* playlists */, std::optional<QueueOperation> /* operation */)>& callback) = 0;
       virtual void onPlaylistChanged(const std::function<void(const std::string& /* playlistId */, const Playlist& /* playlist */, std::optional<QueueOperation> /* operation */)>& callback) = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "A powerful audio player library for React Native with playlist management, playback controls, and support for Android Auto and CarPlay",
   "main": "lib/index",
   "module": "lib/index",

package/src/specs/TrackPlayer.nitro.ts

@@ -48,7 +48,7 @@ export interface PlayerQueue extends HybridObject<{
   ): Promise<void>
 
   // Playback control
-  loadPlaylist(playlistId: string): Promise<void>
+  loadPlaylist(playlistId: string, index?: number): Promise<void>
   getCurrentPlaylistId(): string | null
 
   // Events