react-native-nitro-player 0.3.0-alpha.16 → 0.3.0-alpha.18

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

@@ -12,6 +12,7 @@ import org.json.JSONArray
 import org.json.JSONObject
 import java.util.UUID
 import java.util.concurrent.CopyOnWriteArrayList
+
 import com.margelo.nitro.core.AnyMap
 
 /**
@@ -384,7 +385,7 @@ class PlaylistManager private constructor(
                                         track.artwork?.let { put("artwork", it) }
                                         // Serialize extraPayload to JSON for persistence
                                         track.extraPayload?.let { payload ->
-                                            val extraPayloadMap = payload.toMap()
+                                            val extraPayloadMap = payload.toHashMap()
                                             val extraPayloadJson = JSONObject(extraPayloadMap)
                                             put("extraPayload", extraPayloadJson)
                                         }

package/ios/core/TrackPlayerCore.swift

@@ -566,11 +566,13 @@ class TrackPlayerCore: NSObject {
   private func setupCurrentItemObservers(item: AVPlayerItem) {
     print("📱 TrackPlayerCore: Setting up item observers")
 
-    // Observe status - recreate boundaries when ready
+    // Observe status - recreate boundaries when ready and update now playing info
     let statusObserver = item.observe(\.status, options: [.new]) { [weak self] item, _ in
       if item.status == .readyToPlay {
         print("✅ TrackPlayerCore: Item ready, setting up boundaries")
         self?.setupBoundaryTimeObserver()
+        // Update now playing info now that duration is available
+        self?.mediaSessionManager?.updateNowPlayingInfo()
       } else if item.status == .failed {
         print("❌ TrackPlayerCore: Item failed")
         self?.notifyPlaybackStateChange(.stopped, .error)
@@ -1406,6 +1408,10 @@ class TrackPlayerCore: NSObject {
     self.isManuallySeeked = true
     let time = CMTime(seconds: position, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
     player.seek(to: time) { [weak self] completed in
+      // Always update now playing info to restore playback rate after seek
+      // This ensures the scrubber animation resumes correctly
+      self?.mediaSessionManager?.updateNowPlayingInfo()
+      
       if completed {
         let duration = player.currentItem?.duration.seconds ?? 0.0
         self?.notifySeek(position, duration)

package/ios/media/MediaSessionManager.swift

@@ -106,36 +106,29 @@ class MediaSessionManager {
       return .success
     }
 
-    // Seek forward
-    commandCenter.seekForwardCommand.isEnabled = true
-    commandCenter.seekForwardCommand.addTarget { [weak self] event in
-      guard let self = self, let core = self.trackPlayerCore else { return .commandFailed }
-      let state = core.getState()
-      let newPosition = min(state.currentPosition + Constants.seekInterval, state.totalDuration)
-      core.seek(position: newPosition)
-      return .success
-    }
+    // Disable continuous seek commands - they replace the interactive scrubber
+    // with non-interactive forward/backward buttons on the lock screen
+    commandCenter.seekForwardCommand.isEnabled = false
+    commandCenter.seekBackwardCommand.isEnabled = false
 
-    // Seek backward
-    commandCenter.seekBackwardCommand.isEnabled = true
-    commandCenter.seekBackwardCommand.addTarget { [weak self] event in
-      guard let self = self, let core = self.trackPlayerCore else { return .commandFailed }
-      let state = core.getState()
-      let newPosition = max(state.currentPosition - Constants.seekInterval, 0.0)
-      core.seek(position: newPosition)
-      return .success
-    }
-
-    // Change playback position
+    // Change playback position (interactive scrubber)
     commandCenter.changePlaybackPositionCommand.isEnabled = true
     commandCenter.changePlaybackPositionCommand.addTarget { [weak self] event in
       guard let self = self,
         let core = self.trackPlayerCore,
-        let event = event as? MPChangePlaybackPositionCommandEvent
+        let positionEvent = event as? MPChangePlaybackPositionCommandEvent
       else {
         return .commandFailed
       }
-      core.seek(position: event.positionTime)
+      // Immediately update elapsed time AND set playback rate to 0 during seek
+      // This prevents the scrubber from freezing/desyncing during the async seek operation
+      if var info = MPNowPlayingInfoCenter.default().nowPlayingInfo {
+        info[MPNowPlayingInfoPropertyElapsedPlaybackTime] = positionEvent.positionTime
+        // Set rate to 0 to pause scrubber animation during seek
+        info[MPNowPlayingInfoPropertyPlaybackRate] = 0.0
+        MPNowPlayingInfoCenter.default().nowPlayingInfo = info
+      }
+      core.seek(position: positionEvent.positionTime)
       return .success
     }
   }
@@ -156,20 +149,39 @@ class MediaSessionManager {
 
     let state = core.getState()
 
-    let nowPlayingInfo: [String: Any] = [
+    // Use player duration if valid, otherwise fall back to track metadata duration.
+    // Duration must always be present for the lock screen scrubber to be interactive.
+    let playerDuration = state.totalDuration
+    let effectiveDuration: Double
+    if playerDuration > 0 && !playerDuration.isNaN && !playerDuration.isInfinite {
+      effectiveDuration = playerDuration
+    } else {
+      effectiveDuration = track.duration
+    }
+
+    var nowPlayingInfo: [String: Any] = [
       MPMediaItemPropertyTitle: track.title,
       MPMediaItemPropertyArtist: track.artist,
       MPMediaItemPropertyAlbumTitle: track.album,
       MPNowPlayingInfoPropertyElapsedPlaybackTime: state.currentPosition,
-      MPMediaItemPropertyPlaybackDuration: state.totalDuration,
+      MPMediaItemPropertyPlaybackDuration: effectiveDuration,
       MPNowPlayingInfoPropertyPlaybackRate: state.currentState == .playing ? 1.0 : 0.0,
     ]
 
-    // Load artwork asynchronously
+    // Add artwork synchronously if cached, otherwise load async
     if let artwork = track.artwork, case .second(let artworkUrl) = artwork {
-      loadArtwork(url: artworkUrl) { [weak self] image in
-        if let image = image {
-          var updatedInfo = nowPlayingInfo
+      if let cachedImage = artworkCache[artworkUrl] {
+        // Artwork is cached - include it directly to avoid overwrite race condition
+        nowPlayingInfo[MPMediaItemPropertyArtwork] = MPMediaItemArtwork(
+          boundsSize: CGSize(width: Constants.artworkSize, height: Constants.artworkSize),
+          requestHandler: { _ in cachedImage }
+        )
+      } else {
+        // Artwork not cached - load asynchronously and update later
+        loadArtwork(url: artworkUrl) { [weak self] image in
+          guard let self = self, let image = image else { return }
+          // Re-read current nowPlayingInfo to avoid overwriting other updates
+          var updatedInfo = MPNowPlayingInfoCenter.default().nowPlayingInfo ?? [:]
           updatedInfo[MPMediaItemPropertyArtwork] = MPMediaItemArtwork(
             boundsSize: CGSize(width: Constants.artworkSize, height: Constants.artworkSize),
             requestHandler: { _ in image }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "0.3.0-alpha.16",
+  "version": "0.3.0-alpha.18",
   "description": "react-native-nitro-player",
   "main": "lib/index",
   "module": "lib/index",