react-native-nitro-player 0.5.6 → 0.5.7

package/README.md

@@ -50,6 +50,8 @@ npm install react-native-nitro-modules
 | `skipToNext()`              | Both     | Skips to the next track in the queue.                               |
 | `skipToPrevious()`          | Both     | Skips to the previous track.                                        |
 | `seek(position)`            | Both     | Seeks to a specific time position in seconds.                       |
+| `setPlaybackSpeed(speed)`   | Both     | **Async**. Sets playback speed (e.g. 0.5x, 1x, 1.5x, 2x).           |
+| `getPlaybackSpeed()`        | Both     | **Async**. Gets the current playback speed.                         |
 | `setVolume(0-100)`          | Both     | Sets playback volume (0-100).                                       |
 | `setRepeatMode(mode)`       | Both     | Sets repeat mode (`off`, `track`, `Playlist`).                      |
 | `addToUpNext(id)`           | Both     | **Async**. Adds a track to the "up next" queue (FIFO).              |

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

@@ -106,6 +106,7 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
             androidAutoEnabled = config.androidAutoEnabled,
             carPlayEnabled = config.carPlayEnabled,
             showInNotification = config.showInNotification,
+            lookaheadCount = config.lookaheadCount?.toInt(),
         )
     }
 
@@ -127,4 +128,46 @@ class HybridTrackPlayer : HybridTrackPlayerSpec() {
         Promise.async {
             core.skipToIndex(index.toInt())
         }
+
+    override fun updateTracks(tracks: Array<TrackItem>): Promise<Unit> =
+        Promise.async {
+            core.updateTracks(tracks.toList())
+        }
+
+    override fun getTracksById(trackIds: Array<String>): Promise<Array<TrackItem>> =
+        Promise.async {
+            core.getTracksById(trackIds.toList()).toTypedArray()
+        }
+
+    override fun getTracksNeedingUrls(): Promise<Array<TrackItem>> =
+        Promise.async {
+            core.getTracksNeedingUrls().toTypedArray()
+        }
+
+    override fun getNextTracks(count: Double): Promise<Array<TrackItem>> =
+        Promise.async {
+            core.getNextTracks(count.toInt()).toTypedArray()
+        }
+
+    override fun getCurrentTrackIndex(): Promise<Double> =
+        Promise.async {
+            core.getCurrentTrackIndex().toDouble()
+        }
+
+    override fun setPlaybackSpeed(speed: Double): Promise<Unit> =
+        Promise.async {
+            core.setPlayBackSpeed(speed)
+            Unit
+        }
+
+    override fun getPlaybackSpeed(): Promise<Double> =
+        Promise.async {
+            core.getPlayBackSpeed()
+        }
+
+    override fun onTracksNeedUpdate(callback: (tracks: Array<TrackItem>, lookahead: Double) -> Unit) {
+        core.addOnTracksNeedUpdateListener { tracks, lookahead ->
+            callback(tracks.toTypedArray(), lookahead.toDouble())
+        }
+    }
 }

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

@@ -83,6 +83,7 @@ class TrackPlayerCore private constructor(
         Collections.synchronizedList(mutableListOf<WeakCallbackBox<(Double, Double, Boolean?) -> Unit>>())
 
     private var currentRepeatMode: RepeatMode = RepeatMode.OFF
+    private var lookaheadCount: Int = 5 // Number of tracks to preload ahead
 
     // Temporary tracks for addToUpNext and playNext
     private var playNextStack: MutableList<TrackItem> = mutableListOf() // LIFO - last added plays first
@@ -283,6 +284,9 @@ class TrackPlayerCore private constructor(
                                     }
                                 notifyTrackChange(track, r)
                                 mediaSessionManager?.onTrackChanged()
+
+                                // Check if upcoming tracks need URLs
+                                checkUpcomingTracksForUrls(lookahead = lookaheadCount)
                             }
                         }
 
@@ -380,6 +384,9 @@ class TrackPlayerCore private constructor(
             if (playlist != null) {
                 currentPlaylistId = playlistId
                 updatePlayerQueue(playlist.tracks)
+
+                // Check if upcoming tracks need URLs
+                checkUpcomingTracksForUrls(lookahead = lookaheadCount)
             }
         }
     }
@@ -641,6 +648,9 @@ class TrackPlayerCore private constructor(
         handler.post {
             if (player.hasNextMediaItem()) {
                 player.seekToNextMediaItem()
+
+                // Check if upcoming tracks need URLs
+                checkUpcomingTracksForUrls(lookahead = lookaheadCount)
             }
         }
     }
@@ -684,6 +694,9 @@ class TrackPlayerCore private constructor(
                 NitroPlayerLogger.log("TrackPlayerCore", "🔄 TrackPlayerCore: Already at first track, seeking to beginning")
                 player.seekTo(0)
             }
+
+            // Check if upcoming tracks need URLs
+            checkUpcomingTracksForUrls(lookahead = lookaheadCount)
         }
     }
 
@@ -811,11 +824,16 @@ class TrackPlayerCore private constructor(
         androidAutoEnabled: Boolean?,
         carPlayEnabled: Boolean?,
         showInNotification: Boolean?,
+        lookaheadCount: Int? = null,
     ) {
         handler.post {
             androidAutoEnabled?.let {
                 NitroPlayerMediaBrowserService.isAndroidAutoEnabled = it
             }
+            lookaheadCount?.let {
+                this.lookaheadCount = it
+                NitroPlayerLogger.log("TrackPlayerCore", "🔄 Lookahead count set to: $it")
+            }
             mediaSessionManager?.configure(
                 androidAutoEnabled,
                 carPlayEnabled,
@@ -1015,9 +1033,16 @@ class TrackPlayerCore private constructor(
             currentTemporaryType = TemporaryType.NONE
 
             rebuildQueueAndPlayFromIndex(originalIndex)
+
+            // Check if upcoming tracks need URLs
+            checkUpcomingTracksForUrls(lookahead = lookaheadCount)
+
             return true
         }
 
+        // Check if upcoming tracks need URLs after any successful skip
+        checkUpcomingTracksForUrls(lookahead = lookaheadCount)
+
         return false
     }
 
@@ -1468,4 +1493,319 @@ class TrackPlayerCore private constructor(
 
         return queue
     }
+
+    // MARK: - Lazy URL Loading Support
+
+    /**
+     * Update entire track objects and rebuild queue if needed
+     * Skips currently playing track to preserve gapless playback
+     */
+    fun updateTracks(tracks: List<TrackItem>) {
+        handler.post {
+            NitroPlayerLogger.log("TrackPlayerCore", "🔄 updateTracks: ${tracks.size} updates")
+
+            // Get current track ID to avoid updating it (preserves gapless playback)
+            val currentTrackId = getCurrentTrack()?.id
+
+            // Filter out current track and validate
+            val safeTracks =
+                tracks.filter { track ->
+                    when {
+                        track.id == currentTrackId -> {
+                            NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Skipping update for currently playing track: ${track.id} (preserves gapless)")
+                            false
+                        }
+
+                        track.url.isEmpty() -> {
+                            NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Skipping track with empty URL: ${track.id}")
+                            false
+                        }
+
+                        else -> {
+                            true
+                        }
+                    }
+                }
+
+            if (safeTracks.isEmpty()) {
+                NitroPlayerLogger.log("TrackPlayerCore", "✅ No valid updates to apply")
+                return@post
+            }
+
+            // Update in PlaylistManager
+            val affectedPlaylists = playlistManager.updateTracks(safeTracks)
+
+            // Rebuild queue if current playlist was affected
+            if (currentPlaylistId != null && affectedPlaylists.containsKey(currentPlaylistId)) {
+                NitroPlayerLogger.log("TrackPlayerCore", "🔄 Rebuilding queue - ${affectedPlaylists[currentPlaylistId]} tracks updated in current playlist")
+
+                // This method preserves current item and gapless buffering
+                rebuildQueueFromCurrentPosition()
+
+                NitroPlayerLogger.log("TrackPlayerCore", "✅ Queue rebuilt, gapless playback preserved")
+            }
+
+            NitroPlayerLogger.log("TrackPlayerCore", "✅ Track updates complete - ${affectedPlaylists.size} playlists affected")
+        }
+    }
+
+    /**
+     * Get tracks by IDs from all playlists
+     */
+    fun getTracksById(trackIds: List<String>): List<TrackItem> {
+        if (android.os.Looper.myLooper() == handler.looper) {
+            return playlistManager.getTracksById(trackIds)
+        }
+
+        val latch = CountDownLatch(1)
+        var result: List<TrackItem>? = null
+
+        handler.post {
+            try {
+                result = playlistManager.getTracksById(trackIds)
+            } finally {
+                latch.countDown()
+            }
+        }
+
+        try {
+            latch.await(5, TimeUnit.SECONDS)
+        } catch (e: InterruptedException) {
+            Thread.currentThread().interrupt()
+        }
+
+        return result ?: emptyList()
+    }
+
+    /**
+     * Get tracks needing URLs from current playlist
+     */
+    fun getTracksNeedingUrls(): List<TrackItem> {
+        if (android.os.Looper.myLooper() == handler.looper) {
+            return getTracksNeedingUrlsInternal()
+        }
+
+        val latch = CountDownLatch(1)
+        var result: List<TrackItem>? = null
+
+        handler.post {
+            try {
+                result = getTracksNeedingUrlsInternal()
+            } finally {
+                latch.countDown()
+            }
+        }
+
+        try {
+            latch.await(5, TimeUnit.SECONDS)
+        } catch (e: InterruptedException) {
+            Thread.currentThread().interrupt()
+        }
+
+        return result ?: emptyList()
+    }
+
+    private fun getTracksNeedingUrlsInternal(): List<TrackItem> {
+        if (currentPlaylistId == null) return emptyList()
+
+        val playlist = playlistManager.getPlaylist(currentPlaylistId!!)
+        return playlist?.tracks?.filter { it.url.isEmpty() } ?: emptyList()
+    }
+
+    /**
+     * Get next N tracks from current position
+     */
+    fun getNextTracks(count: Int): List<TrackItem> {
+        if (android.os.Looper.myLooper() == handler.looper) {
+            return getNextTracksInternal(count)
+        }
+
+        val latch = CountDownLatch(1)
+        var result: List<TrackItem>? = null
+
+        handler.post {
+            try {
+                result = getNextTracksInternal(count)
+            } finally {
+                latch.countDown()
+            }
+        }
+
+        try {
+            latch.await(5, TimeUnit.SECONDS)
+        } catch (e: InterruptedException) {
+            Thread.currentThread().interrupt()
+        }
+
+        return result ?: emptyList()
+    }
+
+    private fun getNextTracksInternal(count: Int): List<TrackItem> {
+        val actualQueue = getActualQueueInternal()
+        if (actualQueue.isEmpty()) return emptyList()
+
+        val currentIndex = actualQueue.indexOfFirst { it.id == getCurrentTrack()?.id }
+        if (currentIndex == -1) return emptyList()
+
+        val startIndex = currentIndex + 1
+        val endIndex = minOf(startIndex + count, actualQueue.size)
+
+        return if (startIndex < actualQueue.size) {
+            actualQueue.subList(startIndex, endIndex)
+        } else {
+            emptyList()
+        }
+    }
+
+    /**
+     * Get current track index in playlist
+     */
+    fun getCurrentTrackIndex(): Int {
+        if (android.os.Looper.myLooper() == handler.looper) {
+            return currentTrackIndex
+        }
+
+        val latch = CountDownLatch(1)
+        var result = -1
+
+        handler.post {
+            try {
+                result = currentTrackIndex
+            } finally {
+                latch.countDown()
+            }
+        }
+
+        try {
+            latch.await(5, TimeUnit.SECONDS)
+        } catch (e: InterruptedException) {
+            Thread.currentThread().interrupt()
+        }
+
+        return result
+    }
+
+    /**
+     * Callback interface for tracks needing update
+     */
+    fun interface OnTracksNeedUpdateListener {
+        fun onTracksNeedUpdate(
+            tracks: List<TrackItem>,
+            lookahead: Int,
+        )
+    }
+
+    // Add to class properties
+    private val onTracksNeedUpdateListeners = mutableListOf<WeakReference<OnTracksNeedUpdateListener>>()
+
+    /**
+     * Register listener for when tracks need update
+     */
+    fun addOnTracksNeedUpdateListener(listener: OnTracksNeedUpdateListener) {
+        handler.post {
+            onTracksNeedUpdateListeners.add(WeakReference(listener))
+        }
+    }
+
+    /**
+     * Remove listener
+     */
+    fun removeOnTracksNeedUpdateListener(listener: OnTracksNeedUpdateListener) {
+        handler.post {
+            onTracksNeedUpdateListeners.removeAll { it.get() == listener || it.get() == null }
+        }
+    }
+
+    /**
+     * Notify listeners that tracks need updating
+     * Called internally when moving to next track and upcoming tracks have empty URLs
+     */
+    private fun notifyTracksNeedUpdate(
+        tracks: List<TrackItem>,
+        lookahead: Int,
+    ) {
+        val liveCallbacks =
+            synchronized(onTracksNeedUpdateListeners) {
+                onTracksNeedUpdateListeners.removeAll { it.get() == null }
+                onTracksNeedUpdateListeners.mapNotNull { it.get() }
+            }
+
+        handler.post {
+            for (callback in liveCallbacks) {
+                try {
+                    callback.onTracksNeedUpdate(tracks, lookahead)
+                } catch (e: Exception) {
+                    NitroPlayerLogger.log("TrackPlayerCore", "⚠️ Error in onTracksNeedUpdate listener: ${e.message}")
+                }
+            }
+        }
+    }
+
+    /**
+     * Check if upcoming tracks need URLs and notify listeners
+     * Call this in onMediaItemTransition or after skipTo operations
+     */
+    private fun checkUpcomingTracksForUrls(lookahead: Int = 5) {
+        val nextTracks = getNextTracksInternal(lookahead)
+        val tracksNeedingUrls = nextTracks.filter { it.url.isEmpty() }
+
+        if (tracksNeedingUrls.isNotEmpty()) {
+            NitroPlayerLogger.log("TrackPlayerCore", "⚠️ ${tracksNeedingUrls.size} upcoming tracks need URLs")
+            notifyTracksNeedUpdate(tracksNeedingUrls, lookahead)
+        }
+    }
+
+    fun setPlayBackSpeed(speed: Double) {
+        if (android.os.Looper.myLooper() == handler.looper) {
+            setPlayBackSpeedInternal(speed)
+            return
+        }
+        val latch = CountDownLatch(1)
+        handler.post {
+            try {
+                setPlayBackSpeedInternal(speed)
+            } finally {
+                latch.countDown()
+            }
+        }
+        try {
+            latch.await(5, TimeUnit.SECONDS)
+        } catch (e: InterruptedException) {
+            Thread.currentThread().interrupt()
+        }
+    }
+
+    private fun setPlayBackSpeedInternal(speed: Double) {
+        if (::player.isInitialized) {
+            player.setPlaybackSpeed(speed.toFloat())
+        }
+    }
+
+    fun getPlayBackSpeed(): Double {
+        if (android.os.Looper.myLooper() == handler.looper) {
+            return getPlayBackSpeedInternal()
+        }
+        val latch = CountDownLatch(1)
+        var result = 1.0
+        handler.post {
+            try {
+                result = getPlayBackSpeedInternal()
+            } finally {
+                latch.countDown()
+            }
+        }
+        try {
+            latch.await(5, TimeUnit.SECONDS)
+        } catch (e: InterruptedException) {
+            Thread.currentThread().interrupt()
+        }
+        return result
+    }
+
+    private fun getPlayBackSpeedInternal(): Double =
+        if (::player.isInitialized) {
+            player.playbackParameters.speed.toDouble()
+        } else {
+            1.0
+        }
 }

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

@@ -302,6 +302,66 @@ class PlaylistManager private constructor(
         return true
     }
 
+    /**
+     * Update entire track objects across all playlists
+     * Matches by track.id and replaces the entire track object
+     * @param tracks List of full TrackItem objects to update
+     * @return Map of playlistId -> count of tracks updated
+     */
+    fun updateTracks(tracks: List<TrackItem>): Map<String, Int> {
+        val tracksMap = tracks.associateBy { it.id }
+        val affectedPlaylists = mutableMapOf<String, Int>()
+
+        synchronized(playlists) {
+            playlists.forEach { (playlistId, playlist) ->
+                var updateCount = 0
+                val newTracks =
+                    playlist.tracks
+                        .map { track ->
+                            tracksMap[track.id]?.also { updateCount++ } ?: track
+                        }.toMutableList()
+
+                if (updateCount > 0) {
+                    affectedPlaylists[playlistId] = updateCount
+                    playlists[playlistId] = playlist.copy(tracks = newTracks)
+                }
+            }
+        }
+
+        if (affectedPlaylists.isNotEmpty()) {
+            scheduleSave()
+            affectedPlaylists.keys.forEach { playlistId ->
+                notifyPlaylistChanged(playlistId, QueueOperation.UPDATE)
+            }
+            notifyPlaylistsChanged(QueueOperation.UPDATE)
+        }
+
+        return affectedPlaylists
+    }
+
+    /**
+     * Get tracks by IDs from all playlists
+     * @param trackIds List of track IDs to fetch
+     * @return List of matching TrackItem objects
+     */
+    fun getTracksById(trackIds: List<String>): List<TrackItem> {
+        val trackIdSet = trackIds.toSet()
+        val foundTracks = mutableMapOf<String, TrackItem>()
+
+        synchronized(playlists) {
+            playlists.values.forEach { playlist ->
+                playlist.tracks.forEach { track ->
+                    if (trackIdSet.contains(track.id) && !foundTracks.containsKey(track.id)) {
+                        foundTracks[track.id] = track
+                    }
+                }
+            }
+        }
+
+        // Return in same order as requested
+        return trackIds.mapNotNull { foundTracks[it] }
+    }
+
     /**
      * Load a playlist for playback (sets it as current)
      */

package/ios/HybridTrackPlayer.swift

@@ -88,7 +88,8 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
     core.configure(
       androidAutoEnabled: config.androidAutoEnabled,
       carPlayEnabled: config.carPlayEnabled,
-      showInNotification: config.showInNotification
+      showInNotification: config.showInNotification,
+      lookaheadCount: config.lookaheadCount.map { Int($0) }
     )
   }
 
@@ -139,4 +140,56 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
   func setVolume(volume: Double) throws -> Bool {
     return core.setVolume(volume: volume)
   }
+
+  // MARK: - Lazy URL Loading
+
+  func updateTracks(tracks: [TrackItem]) throws -> Promise<Void> {
+    return Promise.async {
+      self.core.updateTracks(tracks: tracks)
+    }
+  }
+
+  func getTracksById(trackIds: [String]) throws -> Promise<[TrackItem]> {
+    return Promise.async {
+      return self.core.getTracksById(trackIds: trackIds)
+    }
+  }
+
+  func getTracksNeedingUrls() throws -> Promise<[TrackItem]> {
+    return Promise.async {
+      return self.core.getTracksNeedingUrls()
+    }
+  }
+
+  func getNextTracks(count: Double) throws -> Promise<[TrackItem]> {
+    return Promise.async {
+      return self.core.getNextTracks(count: Int(count))
+    }
+  }
+
+  func getCurrentTrackIndex() throws -> Promise<Double> {
+    return Promise.async {
+      return Double(self.core.getCurrentTrackIndex())
+    }
+  }
+
+  func onTracksNeedUpdate(callback: @escaping ([TrackItem], Double) -> Void) throws {
+    core.addOnTracksNeedUpdateListener { tracks, lookahead in
+      callback(tracks, Double(lookahead))
+    }
+  }
+  
+  func setPlaybackSpeed(speed: Double) throws -> Promise<Void> {
+    Promise.async{
+      self.core.setPlaybackSpeed(speed)
+    }
+    
+  }
+  
+  func getPlaybackSpeed() throws -> Promise<Double> {
+    return Promise.async{
+      return self.core.getPlaybackSpeed()
+    }
+    
+  }
 }