react-native-nitro-player 0.5.5 → 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/NitroPlayerLogger.kt

@@ -12,7 +12,10 @@ object NitroPlayerLogger {
      * Use trailing lambda syntax: NitroPlayerLogger.log("Tag") { "msg $value" }
      * The lambda is inlined (no heap allocation) and skipped entirely when disabled.
      */
-    inline fun log(header: String = "NitroPlayer", message: () -> String) {
+    inline fun log(
+        header: String = "NitroPlayer",
+        message: () -> String,
+    ) {
         if (isEnabled) {
             Log.d(header, message())
         }
@@ -23,7 +26,10 @@ object NitroPlayerLogger {
      * Note: the String is evaluated at the call site before this function runs.
      * Migrate to the lambda overload for hot paths.
      */
-    fun log(header: String = "NitroPlayer", message: String) {
+    fun log(
+        header: String = "NitroPlayer",
+        message: String,
+    ) {
         if (isEnabled) {
             Log.d(header, message)
         }

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)
         }
     }
 
@@ -698,10 +711,11 @@ class TrackPlayerCore private constructor(
         currentRepeatMode = mode
         if (::player.isInitialized) {
             handler.post {
-                player.repeatMode = when (mode) {
-                    RepeatMode.TRACK -> Player.REPEAT_MODE_ONE
-                    else -> Player.REPEAT_MODE_OFF
-                }
+                player.repeatMode =
+                    when (mode) {
+                        RepeatMode.TRACK -> Player.REPEAT_MODE_ONE
+                        else -> Player.REPEAT_MODE_OFF
+                    }
             }
         }
         NitroPlayerLogger.log("TrackPlayerCore", "🔁 setRepeatMode: $mode")
@@ -810,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,
@@ -1014,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
     }
 
@@ -1467,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/download/DownloadDatabase.kt

@@ -1,6 +1,7 @@
 package com.margelo.nitro.nitroplayer.download
 
 import android.content.Context
+import com.margelo.nitro.core.AnyMap
 import com.margelo.nitro.core.NullType
 import com.margelo.nitro.nitroplayer.*
 import com.margelo.nitro.nitroplayer.core.NitroPlayerLogger
@@ -18,6 +19,7 @@ class DownloadDatabase private constructor(
 ) {
     companion object {
         private const val TAG = "DownloadDatabase"
+
         // Legacy SharedPreferences keys (migration only)
         private const val LEGACY_PREFS_NAME = "NitroPlayerDownloads"
         private const val LEGACY_KEY_DOWNLOADED_TRACKS = "downloaded_tracks"
@@ -304,10 +306,11 @@ class DownloadDatabase private constructor(
                 playlistJson.put(playlistId, JSONArray(trackIds.toList()))
             }
 
-            val wrapper = JSONObject().apply {
-                put("downloadedTracks", tracksJson)
-                put("playlistTracks", playlistJson)
-            }
+            val wrapper =
+                JSONObject().apply {
+                    put("downloadedTracks", tracksJson)
+                    put("playlistTracks", playlistJson)
+                }
             NitroPlayerStorage.write(context, "downloads.json", wrapper.toString())
         } catch (e: Exception) {
             e.printStackTrace()
@@ -390,8 +393,14 @@ class DownloadDatabase private constructor(
     }
 
     // Conversion Helpers
-    private fun trackItemToRecord(track: TrackItem): TrackItemRecord =
-        TrackItemRecord(
+    private fun trackItemToRecord(track: TrackItem): TrackItemRecord {
+        val extraPayloadJson =
+            track.extraPayload?.let { payload ->
+                val extraPayloadMap = payload.toHashMap()
+                JSONObject(extraPayloadMap)
+            }
+
+        return TrackItemRecord(
             id = track.id,
             title = track.title,
             artist = track.artist,
@@ -399,7 +408,9 @@ class DownloadDatabase private constructor(
             duration = track.duration,
             url = track.url,
             artwork = track.artwork?.asSecondOrNull(),
+            extraPayload = extraPayloadJson,
         )
+    }
 
     private fun recordToTrackItem(record: TrackItemRecord): TrackItem {
         val artworkVariant =
@@ -409,6 +420,21 @@ class DownloadDatabase private constructor(
                 null
             }
 
+        val extraPayload: AnyMap? =
+            record.extraPayload?.let { extraPayloadJson ->
+                val map = AnyMap()
+                val keyIterator = extraPayloadJson.keys()
+                while (keyIterator.hasNext()) {
+                    val key = keyIterator.next()
+                    when (val value = extraPayloadJson.get(key)) {
+                        is String -> map.setString(key, value)
+                        is Number -> map.setDouble(key, value.toDouble())
+                        is Boolean -> map.setBoolean(key, value)
+                    }
+                }
+                map
+            }
+
         return TrackItem(
             id = record.id,
             title = record.title,
@@ -417,7 +443,7 @@ class DownloadDatabase private constructor(
             duration = record.duration,
             url = record.url,
             artwork = artworkVariant,
-            extraPayload = null,
+            extraPayload = extraPayload,
         )
     }
 
@@ -440,15 +466,14 @@ class DownloadDatabase private constructor(
         )
     }
 
-    private fun convertPlaylistManagerToNitro(playlist: com.margelo.nitro.nitroplayer.playlist.Playlist): Playlist {
-        return Playlist(
+    private fun convertPlaylistManagerToNitro(playlist: com.margelo.nitro.nitroplayer.playlist.Playlist): Playlist =
+        Playlist(
             id = playlist.id,
             name = playlist.name,
             description = null,
             artwork = null,
             tracks = playlist.tracks.toTypedArray(),
         )
-    }
 }
 
 // Internal record classes
@@ -494,6 +519,7 @@ internal data class TrackItemRecord(
     val duration: Double,
     val url: String,
     val artwork: String?,
+    val extraPayload: JSONObject?,
 ) {
     fun toJson(): JSONObject =
         JSONObject().apply {
@@ -504,6 +530,7 @@ internal data class TrackItemRecord(
             put("duration", duration)
             put("url", url)
             put("artwork", artwork)
+            put("extraPayload", extraPayload)
         }
 
     companion object {
@@ -516,6 +543,12 @@ internal data class TrackItemRecord(
                 duration = json.getDouble("duration"),
                 url = json.getString("url"),
                 artwork = if (json.isNull("artwork")) null else json.getString("artwork"),
+                extraPayload =
+                    if (json.has("extraPayload") && !json.isNull("extraPayload")) {
+                        json.getJSONObject("extraPayload")
+                    } else {
+                        null
+                    },
             )
     }
 }