react-native-nitro-player 0.4.0 → 0.5.0

package/ios/media/MediaSessionManager.swift

@@ -15,10 +15,6 @@ class MediaSessionManager {
   // MARK: - Constants
 
   private enum Constants {
-    // Seek intervals (in seconds)
-    static let seekInterval: Double = 10.0
-
-    // Artwork size
     static let artworkSize: CGFloat = 500.0
   }
 
@@ -27,10 +23,11 @@ class MediaSessionManager {
   private var trackPlayerCore: TrackPlayerCore?
   private var artworkCache: [String: UIImage] = [:]
 
-  private var androidAutoEnabled: Bool = false
-  private var carPlayEnabled: Bool = false
   private var showInNotification: Bool = true
 
+  // Tracks the artwork URL currently shown so we can discard stale async loads
+  private var lastArtworkUrl: String?
+
   init() {
     setupRemoteCommandCenter()
   }
@@ -44,47 +41,165 @@ class MediaSessionManager {
     carPlayEnabled: Bool?,
     showInNotification: Bool?
   ) {
-    if let androidAutoEnabled = androidAutoEnabled {
-      self.androidAutoEnabled = androidAutoEnabled
-    }
-    if let carPlayEnabled = carPlayEnabled {
-      self.carPlayEnabled = carPlayEnabled
-      // CarPlay is handled by the app's CarPlaySceneDelegate
-      // We just maintain the flag here for reference
-    }
     if let showInNotification = showInNotification {
       self.showInNotification = showInNotification
-      if showInNotification {
-        updateNowPlayingInfo()
+    }
+    refresh()
+  }
+
+  // MARK: - Single refresh entry point
+  //
+  // All public callbacks route here. Always dispatches to main thread so
+  // MPNowPlayingInfoCenter and MPRemoteCommandCenter are only touched from main.
+
+  func refresh() {
+    if Thread.isMainThread {
+      refreshInternal()
+    } else {
+      DispatchQueue.main.async { [weak self] in
+        self?.refreshInternal()
+      }
+    }
+  }
+
+  // Convenience aliases used by TrackPlayerCore call sites
+  func updateNowPlayingInfo() { refresh() }
+  func onTrackChanged() { refresh() }
+  func onPlaybackStateChanged() { refresh() }
+  func onQueueChanged() { refresh() }
+
+  // MARK: - Core internal update (main thread only)
+
+  private func refreshInternal() {
+    guard showInNotification else {
+      clearNowPlayingInfo()
+      disableAllCommands()
+      return
+    }
+
+    guard let core = trackPlayerCore,
+      let track = core.getCurrentTrack()
+    else {
+      clearNowPlayingInfo()
+      disableAllCommands()
+      return
+    }
+
+    // Fetch snapshot once — both calls are cheap on main thread (no sync overhead)
+    let state = core.getState()
+    let queue = core.getActualQueue()
+
+    // Find the actual position of the current track inside the actual queue.
+    // state.currentIndex is the original-playlist index which is wrong when a
+    // temp (playNext / upNext) track is playing.
+    let positionInQueue = queue.firstIndex(where: { $0.id == track.id }) ?? -1
+
+    updateNowPlayingInfoInternal(track: track, state: state, queue: queue, positionInQueue: positionInQueue)
+    updateCommandCenterState(state: state, queue: queue, positionInQueue: positionInQueue)
+  }
+
+  // MARK: - Now Playing Info
+
+  private func updateNowPlayingInfoInternal(
+    track: TrackItem,
+    state: PlayerState,
+    queue: [TrackItem],
+    positionInQueue: Int
+  ) {
+    let playerDuration = state.totalDuration
+    let effectiveDuration: Double
+    if playerDuration > 0 && !playerDuration.isNaN && !playerDuration.isInfinite {
+      effectiveDuration = playerDuration
+    } else if track.duration > 0 {
+      effectiveDuration = track.duration
+    } else {
+      effectiveDuration = 0
+    }
+
+    let currentPosition = state.currentPosition
+    let safePosition = currentPosition.isNaN || currentPosition.isInfinite ? 0 : currentPosition
+    let isPlaying = state.currentState == .playing
+
+    var nowPlayingInfo: [String: Any] = [
+      MPMediaItemPropertyTitle: track.title,
+      MPMediaItemPropertyArtist: track.artist,
+      MPMediaItemPropertyAlbumTitle: track.album,
+      MPNowPlayingInfoPropertyElapsedPlaybackTime: safePosition,
+      MPMediaItemPropertyPlaybackDuration: effectiveDuration,
+      MPNowPlayingInfoPropertyPlaybackRate: isPlaying ? 1.0 : 0.0,
+      MPNowPlayingInfoPropertyDefaultPlaybackRate: 1.0,
+      MPNowPlayingInfoPropertyPlaybackQueueCount: max(1, queue.count),
+      MPNowPlayingInfoPropertyPlaybackQueueIndex: max(0, positionInQueue),
+    ]
+
+    // Artwork: use cache synchronously when available, otherwise kick off async load
+    if let artwork = track.artwork, case .second(let artworkUrl) = artwork {
+      lastArtworkUrl = artworkUrl
+      if let cachedImage = artworkCache[artworkUrl] {
+        nowPlayingInfo[MPMediaItemPropertyArtwork] = MPMediaItemArtwork(
+          boundsSize: CGSize(width: Constants.artworkSize, height: Constants.artworkSize),
+          requestHandler: { _ in cachedImage }
+        )
       } else {
-        clearNowPlayingInfo()
+        // Write info first without artwork, then patch it in when loaded
+        MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
+        loadArtwork(url: artworkUrl) { [weak self] image in
+          guard let self = self, let image = image else { return }
+          // Discard if track changed while loading
+          guard self.lastArtworkUrl == artworkUrl else { return }
+          var updated = MPNowPlayingInfoCenter.default().nowPlayingInfo ?? [:]
+          updated[MPMediaItemPropertyArtwork] = MPMediaItemArtwork(
+            boundsSize: CGSize(width: Constants.artworkSize, height: Constants.artworkSize),
+            requestHandler: { _ in image }
+          )
+          MPNowPlayingInfoCenter.default().nowPlayingInfo = updated
+        }
+        return
       }
+    } else {
+      lastArtworkUrl = nil
     }
+
+    MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
   }
 
+  // MARK: - Command Center State
+
   private func setupRemoteCommandCenter() {
     let commandCenter = MPRemoteCommandCenter.shared()
 
-    // Play command
+    // Clear any previously registered targets before adding fresh ones.
+    // Prevents duplicate handlers if this were ever called more than once.
+    commandCenter.playCommand.removeTarget(nil)
+    commandCenter.pauseCommand.removeTarget(nil)
+    commandCenter.togglePlayPauseCommand.removeTarget(nil)
+    commandCenter.nextTrackCommand.removeTarget(nil)
+    commandCenter.previousTrackCommand.removeTarget(nil)
+    commandCenter.seekForwardCommand.removeTarget(nil)
+    commandCenter.seekBackwardCommand.removeTarget(nil)
+    commandCenter.changePlaybackPositionCommand.removeTarget(nil)
+
+    // Play
     commandCenter.playCommand.isEnabled = true
     commandCenter.playCommand.addTarget { [weak self] _ in
-      self?.trackPlayerCore?.play()
+      guard let core = self?.trackPlayerCore else { return .commandFailed }
+      core.play()
       return .success
     }
 
-    // Pause command
+    // Pause
     commandCenter.pauseCommand.isEnabled = true
     commandCenter.pauseCommand.addTarget { [weak self] _ in
-      self?.trackPlayerCore?.pause()
+      guard let core = self?.trackPlayerCore else { return .commandFailed }
+      core.pause()
       return .success
     }
 
     // Toggle play/pause
     commandCenter.togglePlayPauseCommand.isEnabled = true
     commandCenter.togglePlayPauseCommand.addTarget { [weak self] _ in
-      guard let self = self, let core = self.trackPlayerCore else { return .commandFailed }
-      let state = core.getState()
-      if state.currentState == .playing {
+      guard let core = self?.trackPlayerCore else { return .commandFailed }
+      if core.getState().currentState == .playing {
         core.pause()
       } else {
         core.play()
@@ -92,27 +207,28 @@ class MediaSessionManager {
       return .success
     }
 
-    // Next track command
-    commandCenter.nextTrackCommand.isEnabled = true
+    // Next track — isEnabled managed dynamically in updateCommandCenterState
+    commandCenter.nextTrackCommand.isEnabled = false
     commandCenter.nextTrackCommand.addTarget { [weak self] _ in
-      self?.trackPlayerCore?.skipToNext()
+      guard let core = self?.trackPlayerCore else { return .commandFailed }
+      core.skipToNext()
       return .success
     }
 
-    // Previous track command
-    commandCenter.previousTrackCommand.isEnabled = true
+    // Previous track — isEnabled managed dynamically in updateCommandCenterState
+    commandCenter.previousTrackCommand.isEnabled = false
     commandCenter.previousTrackCommand.addTarget { [weak self] _ in
-      self?.trackPlayerCore?.skipToPrevious()
+      guard let core = self?.trackPlayerCore else { return .commandFailed }
+      core.skipToPrevious()
       return .success
     }
 
-    // Disable continuous seek commands - they replace the interactive scrubber
-    // with non-interactive forward/backward buttons on the lock screen
+    // Disable skip-forward/backward — these replace the scrubber with non-interactive buttons
     commandCenter.seekForwardCommand.isEnabled = false
     commandCenter.seekBackwardCommand.isEnabled = false
 
-    // Change playback position (interactive scrubber)
-    commandCenter.changePlaybackPositionCommand.isEnabled = true
+    // Scrubber — isEnabled managed dynamically based on known duration
+    commandCenter.changePlaybackPositionCommand.isEnabled = false
     commandCenter.changePlaybackPositionCommand.addTarget { [weak self] event in
       guard let self = self,
         let core = self.trackPlayerCore,
@@ -120,11 +236,10 @@ class MediaSessionManager {
       else {
         return .commandFailed
       }
-      // Immediately update elapsed time AND set playback rate to 0 during seek
-      // This prevents the scrubber from freezing/desyncing during the async seek operation
+      // Optimistically freeze the scrubber at the tapped position while the async
+      // seek is in flight — updateNowPlayingInfo in the seek completion restores it.
       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
       }
@@ -133,73 +248,43 @@ class MediaSessionManager {
     }
   }
 
-  private func getCurrentTrack() -> TrackItem? {
-    return trackPlayerCore?.getCurrentTrack()
-  }
-
-  func updateNowPlayingInfo() {
-    guard showInNotification else { return }
-
-    guard let track = getCurrentTrack(),
-      let core = trackPlayerCore
-    else {
-      clearNowPlayingInfo()
-      return
-    }
-
-    let state = core.getState()
+  private func updateCommandCenterState(
+    state: PlayerState,
+    queue: [TrackItem],
+    positionInQueue: Int
+  ) {
+    let commandCenter = MPRemoteCommandCenter.shared()
+    let hasCurrentTrack = positionInQueue >= 0
+    let isNotLast = positionInQueue < queue.count - 1
 
-    // 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
-    }
+    let hasDuration = playerDuration > 0 && !playerDuration.isNaN && !playerDuration.isInfinite
 
-    var nowPlayingInfo: [String: Any] = [
-      MPMediaItemPropertyTitle: track.title,
-      MPMediaItemPropertyArtist: track.artist,
-      MPMediaItemPropertyAlbumTitle: track.album,
-      MPNowPlayingInfoPropertyElapsedPlaybackTime: state.currentPosition,
-      MPMediaItemPropertyPlaybackDuration: effectiveDuration,
-      MPNowPlayingInfoPropertyPlaybackRate: state.currentState == .playing ? 1.0 : 0.0,
-    ]
+    // Next: only enabled when there is a track after the current one
+    commandCenter.nextTrackCommand.isEnabled = hasCurrentTrack && isNotLast
 
-    // Add artwork synchronously if cached, otherwise load async
-    if let artwork = track.artwork, case .second(let artworkUrl) = artwork {
-      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 }
-          )
-          MPNowPlayingInfoCenter.default().nowPlayingInfo = updatedInfo
-        }
-      }
-    }
+    // Previous: always enabled when something is playing — either restarts current or goes back
+    commandCenter.previousTrackCommand.isEnabled = hasCurrentTrack
 
-    MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
+    // Scrubber: only enabled when we have a known, finite duration
+    commandCenter.changePlaybackPositionCommand.isEnabled = hasCurrentTrack && hasDuration
+  }
+
+  private func disableAllCommands() {
+    let commandCenter = MPRemoteCommandCenter.shared()
+    commandCenter.nextTrackCommand.isEnabled = false
+    commandCenter.previousTrackCommand.isEnabled = false
+    commandCenter.changePlaybackPositionCommand.isEnabled = false
   }
 
+  // MARK: - Helpers
+
   private func clearNowPlayingInfo() {
     MPNowPlayingInfoCenter.default().nowPlayingInfo = nil
+    lastArtworkUrl = nil
   }
 
   private func loadArtwork(url: String, completion: @escaping (UIImage?) -> Void) {
-    // Check cache first
     if let cached = artworkCache[url] {
       completion(cached)
       return
@@ -210,33 +295,21 @@ class MediaSessionManager {
       return
     }
 
-    // Load image asynchronously
     URLSession.shared.dataTask(with: imageUrl) { [weak self] data, _, _ in
-      guard let data = data,
-        let image = UIImage(data: data)
-      else {
-        completion(nil)
+      guard let data = data, let image = UIImage(data: data) else {
+        DispatchQueue.main.async { completion(nil) }
         return
       }
-
-      // Cache the image
-      self?.artworkCache[url] = image
       DispatchQueue.main.async {
+        self?.artworkCache[url] = image
         completion(image)
       }
     }.resume()
   }
 
-  func onTrackChanged() {
-    updateNowPlayingInfo()
-  }
-
-  func onPlaybackStateChanged() {
-    updateNowPlayingInfo()
-  }
-
   func release() {
     clearNowPlayingInfo()
+    disableAllCommands()
     artworkCache.removeAll()
   }
 }

package/lib/hooks/callbackManager.d.ts

@@ -1,6 +1,8 @@
 import type { TrackItem, TrackPlayerState, Reason } from '../types/PlayerQueue';
 type PlaybackStateCallback = (state: TrackPlayerState, reason?: Reason) => void;
 type TrackChangeCallback = (track: TrackItem, reason?: Reason) => void;
+type PlaybackProgressCallback = (position: number, totalDuration: number, isManuallySeeked?: boolean) => void;
+type SeekCallback = (position: number, totalDuration: number) => void;
 /**
  * Internal subscription manager that allows multiple hooks to subscribe
  * to a single native callback. This solves the problem where registering
@@ -9,8 +11,12 @@ type TrackChangeCallback = (track: TrackItem, reason?: Reason) => void;
 declare class CallbackSubscriptionManager {
     private playbackStateSubscribers;
     private trackChangeSubscribers;
+    private playbackProgressSubscribers;
+    private seekSubscribers;
     private isPlaybackStateRegistered;
     private isTrackChangeRegistered;
+    private isPlaybackProgressRegistered;
+    private isSeekRegistered;
     /**
      * Subscribe to playback state changes
      * @returns Unsubscribe function
@@ -23,6 +29,18 @@ declare class CallbackSubscriptionManager {
     subscribeToTrackChange(callback: TrackChangeCallback): () => void;
     private ensurePlaybackStateRegistered;
     private ensureTrackChangeRegistered;
+    /**
+     * Subscribe to playback progress changes
+     * @returns Unsubscribe function
+     */
+    subscribeToPlaybackProgressChange(callback: PlaybackProgressCallback): () => void;
+    /**
+     * Subscribe to seek events
+     * @returns Unsubscribe function
+     */
+    subscribeToSeek(callback: SeekCallback): () => void;
+    private ensurePlaybackProgressRegistered;
+    private ensureSeekRegistered;
 }
 export declare const callbackManager: CallbackSubscriptionManager;
 export {};

package/lib/hooks/callbackManager.js

@@ -7,8 +7,12 @@ import { TrackPlayer } from '../index';
 class CallbackSubscriptionManager {
     playbackStateSubscribers = new Set();
     trackChangeSubscribers = new Set();
+    playbackProgressSubscribers = new Set();
+    seekSubscribers = new Set();
     isPlaybackStateRegistered = false;
     isTrackChangeRegistered = false;
+    isPlaybackProgressRegistered = false;
+    isSeekRegistered = false;
     /**
      * Subscribe to playback state changes
      * @returns Unsubscribe function
@@ -71,6 +75,68 @@ class CallbackSubscriptionManager {
             console.error('[CallbackManager] Failed to register track change callback:', error);
         }
     }
+    /**
+     * Subscribe to playback progress changes
+     * @returns Unsubscribe function
+     */
+    subscribeToPlaybackProgressChange(callback) {
+        this.playbackProgressSubscribers.add(callback);
+        this.ensurePlaybackProgressRegistered();
+        return () => {
+            this.playbackProgressSubscribers.delete(callback);
+        };
+    }
+    /**
+     * Subscribe to seek events
+     * @returns Unsubscribe function
+     */
+    subscribeToSeek(callback) {
+        this.seekSubscribers.add(callback);
+        this.ensureSeekRegistered();
+        return () => {
+            this.seekSubscribers.delete(callback);
+        };
+    }
+    ensurePlaybackProgressRegistered() {
+        if (this.isPlaybackProgressRegistered)
+            return;
+        try {
+            TrackPlayer.onPlaybackProgressChange((position, totalDuration, isManuallySeeked) => {
+                this.playbackProgressSubscribers.forEach((subscriber) => {
+                    try {
+                        subscriber(position, totalDuration, isManuallySeeked);
+                    }
+                    catch (error) {
+                        console.error('[CallbackManager] Error in playback progress subscriber:', error);
+                    }
+                });
+            });
+            this.isPlaybackProgressRegistered = true;
+        }
+        catch (error) {
+            console.error('[CallbackManager] Failed to register playback progress callback:', error);
+        }
+    }
+    ensureSeekRegistered() {
+        if (this.isSeekRegistered)
+            return;
+        try {
+            TrackPlayer.onSeek((position, totalDuration) => {
+                this.seekSubscribers.forEach((subscriber) => {
+                    try {
+                        subscriber(position, totalDuration);
+                    }
+                    catch (error) {
+                        console.error('[CallbackManager] Error in seek subscriber:', error);
+                    }
+                });
+            });
+            this.isSeekRegistered = true;
+        }
+        catch (error) {
+            console.error('[CallbackManager] Failed to register seek callback:', error);
+        }
+    }
 }
 // Export singleton instance
 export const callbackManager = new CallbackSubscriptionManager();

package/lib/hooks/useNowPlaying.js

@@ -47,12 +47,14 @@ const DEFAULT_STATE = {
 export function useNowPlaying() {
     const [state, setState] = useState(DEFAULT_STATE);
     const isMounted = useRef(true);
-    const updateState = useCallback(async () => {
+    const fetchFullState = useCallback(async () => {
         if (!isMounted.current)
             return;
         try {
             const newState = await TrackPlayer.getState();
-            setState(newState);
+            if (isMounted.current) {
+                setState(newState);
+            }
         }
         catch (error) {
             console.error('[useNowPlaying] Error updating player state:', error);
@@ -61,28 +63,38 @@ export function useNowPlaying() {
     // Initialize with current state
     useEffect(() => {
         isMounted.current = true;
-        updateState();
+        fetchFullState();
         return () => {
             isMounted.current = false;
         };
-    }, [updateState]);
-    // Subscribe to track changes
+    }, [fetchFullState]);
+    // Subscribe to track changes — full refresh
     useEffect(() => {
-        const unsubscribe = callbackManager.subscribeToTrackChange(() => {
-            updateState();
+        return callbackManager.subscribeToTrackChange(() => {
+            fetchFullState();
         });
-        return () => {
-            unsubscribe();
-        };
-    }, [updateState]);
-    // Subscribe to playback state changes
+    }, [fetchFullState]);
+    // Subscribe to playback state changes — full refresh
     useEffect(() => {
-        const unsubscribe = callbackManager.subscribeToPlaybackState(() => {
-            updateState();
+        return callbackManager.subscribeToPlaybackState(() => {
+            fetchFullState();
         });
-        return () => {
-            unsubscribe();
-        };
-    }, [updateState]);
+    }, [fetchFullState]);
+    // Subscribe to progress changes — lightweight position/duration update
+    useEffect(() => {
+        return callbackManager.subscribeToPlaybackProgressChange((currentPosition, totalDuration) => {
+            if (!isMounted.current)
+                return;
+            setState((prev) => ({ ...prev, currentPosition, totalDuration }));
+        });
+    }, []);
+    // Subscribe to seek events — lightweight position/duration update
+    useEffect(() => {
+        return callbackManager.subscribeToSeek((currentPosition, totalDuration) => {
+            if (!isMounted.current)
+                return;
+            setState((prev) => ({ ...prev, currentPosition, totalDuration }));
+        });
+    }, []);
     return state;
 }

package/lib/hooks/useOnPlaybackProgressChange.js

@@ -1,5 +1,5 @@
 import { useEffect, useState } from 'react';
-import { TrackPlayer } from '../index';
+import { callbackManager } from './callbackManager';
 /**
  * Hook to get the current playback progress
  * @returns Object with current position, total duration, and manual seek indicator
@@ -9,7 +9,7 @@ export function useOnPlaybackProgressChange() {
     const [totalDuration, setTotalDuration] = useState(0);
     const [isManuallySeeked, setIsManuallySeeked] = useState(undefined);
     useEffect(() => {
-        TrackPlayer.onPlaybackProgressChange((newPosition, newTotalDuration, newIsManuallySeeked) => {
+        return callbackManager.subscribeToPlaybackProgressChange((newPosition, newTotalDuration, newIsManuallySeeked) => {
             setPosition(newPosition);
             setTotalDuration(newTotalDuration);
             setIsManuallySeeked(newIsManuallySeeked);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-native-nitro-player",
-  "version": "0.4.0",
-  "description": "react-native-nitro-player",
+  "version": "0.5.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",
   "types": "lib/index.d.ts",