react-native-nitro-player 0.5.5 → 0.5.7

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)
      */
@@ -405,10 +465,11 @@ class PlaylistManager private constructor(
                 }
             }
 
-            val wrapper = JSONObject().apply {
-                put("playlists", jsonArray)
-                put("currentPlaylistId", currentPlaylistId)
-            }
+            val wrapper =
+                JSONObject().apply {
+                    put("playlists", jsonArray)
+                    put("currentPlaylistId", currentPlaylistId)
+                }
             NitroPlayerStorage.write(context, "playlists.json", wrapper.toString())
         } catch (e: Exception) {
             e.printStackTrace()
@@ -423,8 +484,12 @@ class PlaylistManager private constructor(
                 val wrapper = JSONObject(json)
                 val jsonArray = wrapper.optJSONArray("playlists") ?: JSONArray()
                 parseAndLoadPlaylists(jsonArray)
-                currentPlaylistId = if (wrapper.isNull("currentPlaylistId")) null
-                                    else wrapper.optString("currentPlaylistId", null.toString()).takeIf { it != "null" }
+                currentPlaylistId =
+                    if (wrapper.isNull("currentPlaylistId")) {
+                        null
+                    } else {
+                        wrapper.optString("currentPlaylistId", null.toString()).takeIf { it != "null" }
+                    }
             } catch (e: Exception) {
                 e.printStackTrace()
             }
@@ -440,7 +505,11 @@ class PlaylistManager private constructor(
                 parseAndLoadPlaylists(jsonArray)
                 currentPlaylistId = prefs.getString("currentPlaylistId", null)
                 // Remove old SharedPreferences data to free space
-                prefs.edit().remove("playlists").remove("currentPlaylistId").apply()
+                prefs
+                    .edit()
+                    .remove("playlists")
+                    .remove("currentPlaylistId")
+                    .apply()
                 // Persist in new format
                 saveToFile()
             } catch (e: Exception) {

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

@@ -9,7 +9,10 @@ object NitroPlayerStorage {
     private const val DIR_NAME = "nitroplayer"
 
     /** Reads the contents of [filename] from the NitroPlayer storage directory, or null if absent. */
-    fun read(context: Context, filename: String): String? {
+    fun read(
+        context: Context,
+        filename: String,
+    ): String? {
         val file = File(storageDirectory(context), filename)
         return if (file.exists()) {
             try {
@@ -28,7 +31,11 @@ object NitroPlayerStorage {
      * Writes to `<filename>.tmp` first, then renames — leaving the prior file
      * untouched on failure (crash-safe).
      */
-    fun write(context: Context, filename: String, json: String) {
+    fun write(
+        context: Context,
+        filename: String,
+        json: String,
+    ) {
         try {
             val dir = storageDirectory(context)
             dir.mkdirs()

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()
+    }
+    
+  }
 }

package/ios/core/TrackPlayerCore.swift

@@ -50,6 +50,7 @@ class TrackPlayerCore: NSObject {
   private var currentTracks: [TrackItem] = []
   private var isManuallySeeked = false
   private var currentRepeatMode: RepeatMode = .off
+  private var lookaheadCount: Int = 5  // Number of tracks to preload ahead
   private var boundaryTimeObserver: Any?
   private var currentItemObservers: [NSKeyValueObservation] = []
 
@@ -310,6 +311,9 @@ class TrackPlayerCore: NSObject {
     if let player = player {
       NitroPlayerLogger.log("TrackPlayerCore", "📋 Remaining items in queue: \(player.items().count)")
     }
+
+    // Check if upcoming tracks need URLs
+    checkUpcomingTracksForUrls(lookahead: lookaheadCount)
   }
 
   @objc private func playerItemFailedToPlayToEndTime(notification: Notification) {
@@ -571,6 +575,14 @@ class TrackPlayerCore: NSObject {
       }
     }
   }
+  
+  func setPlaybackSpeed(_ speed: Double) {
+    player?.rate = Float(speed)
+  }
+  
+  func getPlaybackSpeed() -> Double {
+    return Double(player?.rate ?? 1.0)
+  }
 
   private func loadPlaylistInternal(playlistId: String) {
     NitroPlayerLogger.log("TrackPlayerCore", "\n" + String(repeating: "🎼", count: Constants.playlistSeparatorLength))
@@ -596,6 +608,9 @@ class TrackPlayerCore: NSObject {
       self.updatePlayerQueue(tracks: playlist.tracks)
       // Emit initial state (paused/stopped before play)
       self.emitStateChange()
+
+      // Check if upcoming tracks need URLs
+      self.checkUpcomingTracksForUrls(lookahead: lookaheadCount)
     } else {
       NitroPlayerLogger.log("TrackPlayerCore", "   ❌ Playlist NOT FOUND")
       NitroPlayerLogger.log("TrackPlayerCore", String(repeating: "🎼", count: Constants.playlistSeparatorLength) + "\n")
@@ -1301,6 +1316,9 @@ class TrackPlayerCore: NSObject {
       queuePlayer.pause()
       self.notifyPlaybackStateChange(.stopped, .end)
     }
+
+    // Check if upcoming tracks need URLs
+    checkUpcomingTracksForUrls(lookahead: lookaheadCount)
   }
 
   func skipToPrevious() {
@@ -1343,6 +1361,9 @@ class TrackPlayerCore: NSObject {
       // Already at first track, restart it
       queuePlayer.seek(to: .zero)
     }
+
+    // Check if upcoming tracks need URLs
+    checkUpcomingTracksForUrls(lookahead: lookaheadCount)
   }
 
   func seek(position: Double) {
@@ -1469,9 +1490,14 @@ class TrackPlayerCore: NSObject {
   func configure(
     androidAutoEnabled: Bool?,
     carPlayEnabled: Bool?,
-    showInNotification: Bool?
+    showInNotification: Bool?,
+    lookaheadCount: Int? = nil
   ) {
     DispatchQueue.main.async { [weak self] in
+      if let lookahead = lookaheadCount {
+        self?.lookaheadCount = lookahead
+        NitroPlayerLogger.log("TrackPlayerCore", "🔄 Lookahead count set to: \(lookahead)")
+      }
       self?.mediaSessionManager?.configure(
         androidAutoEnabled: androidAutoEnabled,
         carPlayEnabled: carPlayEnabled,
@@ -1619,9 +1645,17 @@ class TrackPlayerCore: NSObject {
       upNextQueue.removeAll()
       currentTemporaryType = .none
 
-      return playFromIndexInternalWithResult(index: originalIndex)
+      let result = playFromIndexInternalWithResult(index: originalIndex)
+
+      // Check if upcoming tracks need URLs
+      checkUpcomingTracksForUrls(lookahead: lookaheadCount)
+
+      return result
     }
 
+    // Check if upcoming tracks need URLs after any successful skip
+    checkUpcomingTracksForUrls(lookahead: lookaheadCount)
+
     return false
   }
 
@@ -1857,6 +1891,224 @@ class TrackPlayerCore: NSObject {
     return .none
   }
 
+  // MARK: - Lazy URL Loading Support
+
+  /**
+   * Update entire track objects and rebuild queue if needed
+   * Skips currently playing track to preserve gapless playback
+   * CRITICAL: Invalidates preloaded assets and re-preloads for gapless
+   */
+  func updateTracks(tracks: [TrackItem]) {
+    DispatchQueue.main.async { [weak self] in
+      guard let self = self else { return }
+
+      NitroPlayerLogger.log("TrackPlayerCore", "🔄 updateTracks: \(tracks.count) updates")
+
+      // Get current track ID to avoid updating it (preserves gapless playback)
+      let currentTrackId = self.getCurrentTrack()?.id
+
+      // Filter out current track and validate
+      let safeTracks = tracks.filter { track in
+        switch true {
+        case track.id == currentTrackId:
+          NitroPlayerLogger.log(
+            "TrackPlayerCore",
+            "⚠️ Skipping update for currently playing track: \(track.id) (preserves gapless)")
+          return false
+        case track.url.isEmpty:
+          NitroPlayerLogger.log(
+            "TrackPlayerCore", "⚠️ Skipping track with empty URL: \(track.id)")
+          return false
+        default:
+          return true
+        }
+      }
+
+      guard !safeTracks.isEmpty else {
+        NitroPlayerLogger.log("TrackPlayerCore", "✅ No valid updates to apply")
+        return
+      }
+
+      // Invalidate preloaded assets for tracks with updated data
+      // This is CRITICAL for gapless playback - old assets might use old URLs
+      let updatedTrackIds = Set(safeTracks.map { $0.id })
+      for trackId in updatedTrackIds {
+        if self.preloadedAssets[trackId] != nil {
+          NitroPlayerLogger.log(
+            "TrackPlayerCore", "🗑️ Invalidating preloaded asset for track: \(trackId)")
+          self.preloadedAssets.removeValue(forKey: trackId)
+        }
+      }
+
+      // Update in PlaylistManager
+      let affectedPlaylists = self.playlistManager.updateTracks(tracks: safeTracks)
+
+      // Rebuild queue if current playlist was affected
+      if let currentId = self.currentPlaylistId,
+        let updateCount = affectedPlaylists[currentId]
+      {
+        NitroPlayerLogger.log(
+          "TrackPlayerCore",
+          "🔄 Rebuilding queue - \(updateCount) tracks updated in current playlist")
+
+        // This method preserves current item
+        self.rebuildAVQueueFromCurrentPosition()
+
+        // Re-preload upcoming tracks for gapless playback
+        // CRITICAL: This restores gapless buffering after queue rebuild
+        self.preloadUpcomingTracks(from: self.currentTrackIndex + 1)
+
+        NitroPlayerLogger.log("TrackPlayerCore", "✅ Queue rebuilt, gapless playback preserved")
+      }
+
+      NitroPlayerLogger.log(
+        "TrackPlayerCore",
+        "✅ Track updates complete - \(affectedPlaylists.count) playlists affected")
+    }
+  }
+
+  /**
+   * Get tracks by IDs from all playlists
+   */
+  func getTracksById(trackIds: [String]) -> [TrackItem] {
+    if Thread.isMainThread {
+      return playlistManager.getTracksById(trackIds: trackIds)
+    } else {
+      var tracks: [TrackItem] = []
+      DispatchQueue.main.sync { [weak self] in
+        tracks = self?.playlistManager.getTracksById(trackIds: trackIds) ?? []
+      }
+      return tracks
+    }
+  }
+
+  /**
+   * Get tracks needing URLs from current playlist
+   */
+  func getTracksNeedingUrls() -> [TrackItem] {
+    if Thread.isMainThread {
+      return getTracksNeedingUrlsInternal()
+    } else {
+      var tracks: [TrackItem] = []
+      DispatchQueue.main.sync { [weak self] in
+        tracks = self?.getTracksNeedingUrlsInternal() ?? []
+      }
+      return tracks
+    }
+  }
+
+  private func getTracksNeedingUrlsInternal() -> [TrackItem] {
+    guard let currentId = currentPlaylistId,
+      let playlist = playlistManager.getPlaylist(playlistId: currentId)
+    else {
+      return []
+    }
+
+    return playlist.tracks.filter { $0.url.isEmpty }
+  }
+
+  /**
+   * Get next N tracks from current position
+   */
+  func getNextTracks(count: Int) -> [TrackItem] {
+    if Thread.isMainThread {
+      return getNextTracksInternal(count: count)
+    } else {
+      var tracks: [TrackItem] = []
+      DispatchQueue.main.sync { [weak self] in
+        tracks = self?.getNextTracksInternal(count: count) ?? []
+      }
+      return tracks
+    }
+  }
+
+  private func getNextTracksInternal(count: Int) -> [TrackItem] {
+    let actualQueue = getActualQueueInternal()
+    guard !actualQueue.isEmpty else { return [] }
+
+    guard let currentTrack = getCurrentTrack(),
+      let currentIndex = actualQueue.firstIndex(where: { $0.id == currentTrack.id })
+    else {
+      return []
+    }
+
+    let startIndex = currentIndex + 1
+    let endIndex = min(startIndex + count, actualQueue.count)
+
+    return startIndex < actualQueue.count ? Array(actualQueue[startIndex..<endIndex]) : []
+  }
+
+  /**
+   * Get current track index in playlist
+   */
+  func getCurrentTrackIndex() -> Int {
+    if Thread.isMainThread {
+      return currentTrackIndex
+    } else {
+      var index = -1
+      DispatchQueue.main.sync { [weak self] in
+        index = self?.currentTrackIndex ?? -1
+      }
+      return index
+    }
+  }
+
+  /**
+   * Callback for tracks needing update
+   */
+  typealias OnTracksNeedUpdateCallback = ([TrackItem], Int) -> Void
+
+  // Add to class properties
+  private var onTracksNeedUpdateListeners: [(callback: OnTracksNeedUpdateCallback, isAlive: Bool)] =
+    []
+  private let tracksNeedUpdateQueue = DispatchQueue(
+    label: "com.nitroplayer.tracksneedupdate", attributes: .concurrent)
+
+  /**
+   * Register listener for when tracks need update
+   */
+  func addOnTracksNeedUpdateListener(callback: @escaping OnTracksNeedUpdateCallback) {
+    tracksNeedUpdateQueue.async(flags: .barrier) { [weak self] in
+      self?.onTracksNeedUpdateListeners.append((callback: callback, isAlive: true))
+    }
+  }
+
+  /**
+   * Notify listeners that tracks need updating
+   */
+  private func notifyTracksNeedUpdate(tracks: [TrackItem], lookahead: Int) {
+    tracksNeedUpdateQueue.async(flags: .barrier) { [weak self] in
+      guard let self = self else { return }
+
+      // Clean up dead listeners
+      self.onTracksNeedUpdateListeners.removeAll { !$0.isAlive }
+      let liveCallbacks = self.onTracksNeedUpdateListeners.map { $0.callback }
+
+      if !liveCallbacks.isEmpty {
+        DispatchQueue.main.async {
+          for callback in liveCallbacks {
+            callback(tracks, lookahead)
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Check if upcoming tracks need URLs and notify listeners
+   * Call this in playerItemDidPlayToEndTime or after skip operations
+   */
+  private func checkUpcomingTracksForUrls(lookahead: Int = 5) {
+    let nextTracks = getNextTracksInternal(count: lookahead)
+    let tracksNeedingUrls = nextTracks.filter { $0.url.isEmpty }
+
+    if !tracksNeedingUrls.isEmpty {
+      NitroPlayerLogger.log(
+        "TrackPlayerCore", "⚠️ \(tracksNeedingUrls.count) upcoming tracks need URLs")
+      notifyTracksNeedUpdate(tracks: tracksNeedingUrls, lookahead: lookahead)
+    }
+  }
+
   // MARK: - Cleanup
 
   deinit {

package/ios/download/DownloadDatabase.swift

@@ -490,6 +490,11 @@ final class DownloadDatabase {
   }
 
   private func trackItemToRecord(_ track: TrackItem) -> TrackItemRecord {
+    var extraPayloadDict: [String: Any]? = nil
+    if let extraPayload = track.extraPayload {
+      extraPayloadDict = extraPayload.toDictionary()
+    }
+
     return TrackItemRecord(
       id: track.id,
       title: track.title,
@@ -497,11 +502,28 @@ final class DownloadDatabase {
       album: track.album,
       duration: track.duration,
       url: track.url,
-      artwork: variantToString(track.artwork)
+      artwork: variantToString(track.artwork),
+      extraPayload: extraPayloadDict
     )
   }
 
   private func recordToTrackItem(_ record: TrackItemRecord) -> TrackItem {
+    var extraPayload: AnyMap? = nil
+    if let extraPayloadDict = record.extraPayload {
+      extraPayload = AnyMap()
+      for (key, value) in extraPayloadDict {
+        if let stringValue = value as? String {
+          extraPayload?.setString(key: key, value: stringValue)
+        } else if let doubleValue = value as? Double {
+          extraPayload?.setDouble(key: key, value: doubleValue)
+        } else if let intValue = value as? Int {
+          extraPayload?.setDouble(key: key, value: Double(intValue))
+        } else if let boolValue = value as? Bool {
+          extraPayload?.setBoolean(key: key, value: boolValue)
+        }
+      }
+    }
+
     return TrackItem(
       id: record.id,
       title: record.title,
@@ -510,7 +532,7 @@ final class DownloadDatabase {
       duration: record.duration,
       url: record.url,
       artwork: stringToVariant(record.artwork),
-      extraPayload: nil
+      extraPayload: extraPayload
     )
   }
 
@@ -547,4 +569,59 @@ private struct TrackItemRecord: Codable {
   let duration: Double
   let url: String
   let artwork: String?
+  let extraPayload: [String: Any]?
+
+  enum CodingKeys: String, CodingKey {
+    case id, title, artist, album, duration, url, artwork, extraPayload
+  }
+
+  // Manual encoding to handle [String: Any]
+  func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encode(id, forKey: .id)
+    try container.encode(title, forKey: .title)
+    try container.encode(artist, forKey: .artist)
+    try container.encode(album, forKey: .album)
+    try container.encode(duration, forKey: .duration)
+    try container.encode(url, forKey: .url)
+    try container.encodeIfPresent(artwork, forKey: .artwork)
+
+    if let extraPayload = extraPayload {
+      let jsonData = try JSONSerialization.data(withJSONObject: extraPayload)
+      if let jsonString = String(data: jsonData, encoding: .utf8) {
+        try container.encode(jsonString, forKey: .extraPayload)
+      }
+    }
+  }
+
+  // Manual decoding to handle [String: Any]
+  init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    id = try container.decode(String.self, forKey: .id)
+    title = try container.decode(String.self, forKey: .title)
+    artist = try container.decode(String.self, forKey: .artist)
+    album = try container.decode(String.self, forKey: .album)
+    duration = try container.decode(Double.self, forKey: .duration)
+    url = try container.decode(String.self, forKey: .url)
+    artwork = try container.decodeIfPresent(String.self, forKey: .artwork)
+
+    if let jsonString = try? container.decodeIfPresent(String.self, forKey: .extraPayload),
+       let jsonData = jsonString.data(using: .utf8) {
+      extraPayload = try? JSONSerialization.jsonObject(with: jsonData) as? [String: Any]
+    } else {
+      extraPayload = nil
+    }
+  }
+
+  // Initializer for code creation
+  init(id: String, title: String, artist: String, album: String, duration: Double, url: String, artwork: String?, extraPayload: [String: Any]?) {
+    self.id = id
+    self.title = title
+    self.artist = artist
+    self.album = album
+    self.duration = duration
+    self.url = url
+    self.artwork = artwork
+    self.extraPayload = extraPayload
+  }
 }