react-native-nitro-player 1.0.3 → 1.2.0

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/TrackPlayerPlayback.kt

@@ -167,7 +167,7 @@ internal fun TrackPlayerCore.emitStateChange(reason: Reason? = null) {
     val state =
         when (exo.playbackState) {
             Player.STATE_IDLE -> TrackPlayerState.STOPPED
-            Player.STATE_BUFFERING -> if (exo.playWhenReady) TrackPlayerState.PLAYING else TrackPlayerState.PAUSED
+            Player.STATE_BUFFERING -> if (exo.playWhenReady) TrackPlayerState.BUFFERING else TrackPlayerState.PAUSED
             Player.STATE_READY -> if (exo.isPlaying) TrackPlayerState.PLAYING else TrackPlayerState.PAUSED
             Player.STATE_ENDED -> TrackPlayerState.STOPPED
             else -> TrackPlayerState.STOPPED

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

@@ -38,7 +38,7 @@ internal fun TrackPlayerCore.getStateInternal(): PlayerState {
     val state =
         when (exo.playbackState) {
             Player.STATE_IDLE -> TrackPlayerState.STOPPED
-            Player.STATE_BUFFERING -> if (exo.playWhenReady) TrackPlayerState.PLAYING else TrackPlayerState.PAUSED
+            Player.STATE_BUFFERING -> if (exo.playWhenReady) TrackPlayerState.BUFFERING else TrackPlayerState.PAUSED
             Player.STATE_READY -> if (exo.isPlaying) TrackPlayerState.PLAYING else TrackPlayerState.PAUSED
             Player.STATE_ENDED -> TrackPlayerState.STOPPED
             else -> TrackPlayerState.STOPPED

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

@@ -11,14 +11,29 @@ 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) {
+            playFromIndexInternal(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/TrackPlayerListener.swift

@@ -372,16 +372,18 @@ extension TrackPlayerCore {
     }
     currentItemObservers.append(statusObserver)
 
-    let bufferEmptyObserver = item.observe(\.isPlaybackBufferEmpty, options: [.new]) { item, _ in
+    let bufferEmptyObserver = item.observe(\.isPlaybackBufferEmpty, options: [.new]) { [weak self] item, _ in
       if item.isPlaybackBufferEmpty {
         NitroPlayerLogger.log("TrackPlayerCore", "⏸️ Buffer empty (buffering)")
+        self?.emitStateChange()
       }
     }
     currentItemObservers.append(bufferEmptyObserver)
 
-    let bufferKeepUpObserver = item.observe(\.isPlaybackLikelyToKeepUp, options: [.new]) { item, _ in
+    let bufferKeepUpObserver = item.observe(\.isPlaybackLikelyToKeepUp, options: [.new]) { [weak self] item, _ in
       if item.isPlaybackLikelyToKeepUp {
         NitroPlayerLogger.log("TrackPlayerCore", "▶️ Buffer likely to keep up")
+        self?.emitStateChange()
       }
     }
     currentItemObservers.append(bufferKeepUpObserver)
@@ -390,10 +392,15 @@ extension TrackPlayerCore {
   func emitStateChange(reason: Reason? = nil) {
     guard let player else { return }
     let state: TrackPlayerState
-    if player.rate == 0 { state = .paused }
-    else if player.timeControlStatus == .playing { state = .playing }
-    else if player.timeControlStatus == .waitingToPlayAtSpecifiedRate { state = .paused }
-    else { state = .stopped }
+    if player.timeControlStatus == .playing {
+      state = .playing
+    } else if player.timeControlStatus == .waitingToPlayAtSpecifiedRate {
+      state = .buffering
+    } else if player.rate == 0 {
+      state = .paused
+    } else {
+      state = .stopped
+    }
     NitroPlayerLogger.log("TrackPlayerCore", "🔔 Emitting state change: \(state)")
     notifyPlaybackStateChange(state, reason)
   }

package/ios/core/TrackPlayerQueue.swift

@@ -47,8 +47,9 @@ extension TrackPlayerCore {
     let totalDuration = (rawDuration > 0 && !rawDuration.isNaN && !rawDuration.isInfinite) ? rawDuration : 0.0
 
     let state: TrackPlayerState
-    if player.rate == 0 { state = .paused }
-    else if player.timeControlStatus == .playing { state = .playing }
+    if player.timeControlStatus == .playing { state = .playing }
+    else if player.timeControlStatus == .waitingToPlayAtSpecifiedRate { state = .buffering }
+    else if player.rate == 0 { state = .paused }
     else { state = .stopped }
 
     let currentIndex: Double = currentTrackIndex >= 0 ? Double(currentTrackIndex) : -1.0

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

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,22 @@ 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.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/lib/types/PlayerQueue.d.ts

@@ -18,7 +18,7 @@ export interface Playlist {
     tracks: TrackItem[];
 }
 export type QueueOperation = 'add' | 'remove' | 'clear' | 'update';
-export type TrackPlayerState = 'playing' | 'paused' | 'stopped';
+export type TrackPlayerState = 'playing' | 'paused' | 'stopped' | 'buffering';
 export type Reason = 'user_action' | 'skip' | 'end' | 'error' | 'repeat';
 export interface PlayerState {
     currentTrack: TrackItem | null;

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/c++/JTrackPlayerState.hpp

@@ -51,6 +51,9 @@ namespace margelo::nitro::nitroplayer {
         case TrackPlayerState::STOPPED:
           static const auto fieldSTOPPED = clazz->getStaticField<JTrackPlayerState>("STOPPED");
           return clazz->getStaticFieldValue(fieldSTOPPED);
+        case TrackPlayerState::BUFFERING:
+          static const auto fieldBUFFERING = clazz->getStaticField<JTrackPlayerState>("BUFFERING");
+          return clazz->getStaticFieldValue(fieldBUFFERING);
         default:
           std::string stringValue = std::to_string(static_cast<int>(value));
           throw std::invalid_argument("Invalid enum value (" + stringValue + "!");

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/android/kotlin/com/margelo/nitro/nitroplayer/TrackPlayerState.kt

@@ -18,7 +18,8 @@ import com.facebook.proguard.annotations.DoNotStrip
 enum class TrackPlayerState(@DoNotStrip @Keep val value: Int) {
   PAUSED(0),
   PLAYING(1),
-  STOPPED(2);
+  STOPPED(2),
+  BUFFERING(3);
 
   companion object
 }

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/ios/swift/TrackPlayerState.swift

@@ -23,6 +23,8 @@ public extension TrackPlayerState {
         self = .playing
       case "stopped":
         self = .stopped
+      case "buffering":
+        self = .buffering
       default:
         return nil
     }
@@ -39,6 +41,8 @@ public extension TrackPlayerState {
         return "playing"
       case .stopped:
         return "stopped"
+      case .buffering:
+        return "buffering"
     }
   }
 }

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/nitrogen/generated/shared/c++/TrackPlayerState.hpp

@@ -32,6 +32,7 @@ namespace margelo::nitro::nitroplayer {
     PAUSED      SWIFT_NAME(paused) = 0,
     PLAYING      SWIFT_NAME(playing) = 1,
     STOPPED      SWIFT_NAME(stopped) = 2,
+    BUFFERING      SWIFT_NAME(buffering) = 3,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::nitroplayer
@@ -47,6 +48,7 @@ namespace margelo::nitro {
         case hashString("paused"): return margelo::nitro::nitroplayer::TrackPlayerState::PAUSED;
         case hashString("playing"): return margelo::nitro::nitroplayer::TrackPlayerState::PLAYING;
         case hashString("stopped"): return margelo::nitro::nitroplayer::TrackPlayerState::STOPPED;
+        case hashString("buffering"): return margelo::nitro::nitroplayer::TrackPlayerState::BUFFERING;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum TrackPlayerState - invalid value!");
       }
@@ -56,6 +58,7 @@ namespace margelo::nitro {
         case margelo::nitro::nitroplayer::TrackPlayerState::PAUSED: return JSIConverter<std::string>::toJSI(runtime, "paused");
         case margelo::nitro::nitroplayer::TrackPlayerState::PLAYING: return JSIConverter<std::string>::toJSI(runtime, "playing");
         case margelo::nitro::nitroplayer::TrackPlayerState::STOPPED: return JSIConverter<std::string>::toJSI(runtime, "stopped");
+        case margelo::nitro::nitroplayer::TrackPlayerState::BUFFERING: return JSIConverter<std::string>::toJSI(runtime, "buffering");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert TrackPlayerState to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
@@ -70,6 +73,7 @@ namespace margelo::nitro {
         case hashString("paused"):
         case hashString("playing"):
         case hashString("stopped"):
+        case hashString("buffering"):
           return true;
         default:
           return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "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

package/src/types/PlayerQueue.ts

@@ -26,7 +26,7 @@ export interface Playlist {
 
 export type QueueOperation = 'add' | 'remove' | 'clear' | 'update'
 
-export type TrackPlayerState = 'playing' | 'paused' | 'stopped'
+export type TrackPlayerState = 'playing' | 'paused' | 'stopped' | 'buffering'
 
 export type Reason = 'user_action' | 'skip' | 'end' | 'error' | 'repeat'