react-native-nitro-player 0.3.0-alpha.9 → 0.4.0

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/ios/playlist/PlaylistManager.swift

@@ -260,7 +260,8 @@ class PlaylistManager {
    * Load a playlist for playback (sets it as current)
    */
   func loadPlaylist(playlistId: String) -> Bool {
-    guard let playlist = queue.sync(execute: { playlists[playlistId] }) else {
+    let exists = queue.sync { playlists[playlistId] != nil }
+    guard exists else {
       return false
     }
 
@@ -326,18 +327,26 @@ class PlaylistManager {
   }
 
   private func notifyPlaylistsChanged(_ operation: QueueOperation?) {
-    let allPlaylists = queue.sync {
-      return Array(playlists.values)
+    let (allPlaylists, currentListeners) = queue.sync {
+      (Array(playlists.values), listeners)
+    }
+    DispatchQueue.main.async {
+      currentListeners.forEach { $0.1(allPlaylists, operation) }
     }
-    listeners.forEach { $0.1(allPlaylists, operation) }
   }
 
   private func notifyPlaylistChanged(_ playlistId: String, _ operation: QueueOperation?) {
-    guard let playlist = queue.sync(execute: { playlists[playlistId] }) else {
-      return
+    let result: (PlaylistModel, [(String, (PlaylistModel, QueueOperation?) -> Void)])? = queue.sync
+    {
+      guard let p = playlists[playlistId] else { return nil }
+      return (p, playlistListeners[playlistId] ?? [])
     }
 
-    playlistListeners[playlistId]?.forEach { $0.1(playlist, operation) }
+    guard let (playlist, currentListeners) = result else { return }
+
+    DispatchQueue.main.async {
+      currentListeners.forEach { $0.1(playlist, operation) }
+    }
   }
 
   private func savePlaylistsToUserDefaults() {
@@ -368,6 +377,10 @@ class PlaylistManager {
             } else {
               trackDict["artwork"] = ""
             }
+            // Serialize extraPayload to dictionary for persistence
+            if let extraPayload = track.extraPayload {
+              trackDict["extraPayload"] = extraPayload.toDictionary()
+            }
             return trackDict
           },
         ]
@@ -386,7 +399,6 @@ class PlaylistManager {
     }
 
     do {
-      let decoder = JSONDecoder()
       let playlistsDict = try JSONSerialization.jsonObject(with: data) as? [[String: Any]] ?? []
 
       queue.sync {
@@ -417,6 +429,24 @@ class PlaylistManager {
             let artwork = artworkString.flatMap {
               !$0.isEmpty ? Variant_NullType_String.second($0) : nil
             }
+            
+            // Deserialize extraPayload from dictionary
+            var extraPayload: AnyMap? = nil
+            if let extraPayloadDict = trackDict["extraPayload"] as? [String: Any] {
+              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: id,
               title: title,
@@ -424,7 +454,8 @@ class PlaylistManager {
               album: album,
               duration: duration,
               url: url,
-              artwork: artwork
+              artwork: artwork,
+              extraPayload: extraPayload
             )
           }
 

package/ios/queue/HybridPlayerQueue.swift

@@ -9,8 +9,12 @@ import NitroModules
 
 final class HybridPlayerQueue: HybridPlayerQueueSpec {
   private let playlistManager = PlaylistManager.shared
-  private var playlistsChangeListener: (() -> Void)?
-  private var playlistChangeListeners: [String: () -> Void] = [:]
+
+  // Static storage for callbacks to ensure they persist across HybridPlayerQueue instances
+  private static var playlistsChangeCallbacks: [([Playlist], QueueOperation?) -> Void] = []
+  private static var playlistChangeCallbacks: [(String, Playlist, QueueOperation?) -> Void] = []
+  private static var isPlaylistsListenerRegistered = false
+  private static var playlistListenerIds: Set<String> = []
 
   func createPlaylist(name: String, description: String?, artwork: String?) throws -> String {
     return playlistManager.createPlaylist(name: name, description: description, artwork: artwork)
@@ -72,24 +76,40 @@ final class HybridPlayerQueue: HybridPlayerQueueSpec {
   }
 
   func onPlaylistsChanged(callback: @escaping ([Playlist], QueueOperation?) -> Void) throws {
-    // Remove previous listener if exists
-    playlistsChangeListener?()
-
-    // Add new listener
-    playlistsChangeListener = playlistManager.addPlaylistsChangeListener { playlists, operation in
-      callback(playlists.map { $0.toGeneratedPlaylist() }, operation)
+    // Store callback in static storage so it persists across HybridPlayerQueue instances
+    HybridPlayerQueue.playlistsChangeCallbacks.append(callback)
+
+    // Register a single listener with PlaylistManager that dispatches to all callbacks
+    if !HybridPlayerQueue.isPlaylistsListenerRegistered {
+      HybridPlayerQueue.isPlaylistsListenerRegistered = true
+      _ = playlistManager.addPlaylistsChangeListener { playlists, operation in
+        let generatedPlaylists = playlists.map { $0.toGeneratedPlaylist() }
+        // Call all registered callbacks
+        for cb in HybridPlayerQueue.playlistsChangeCallbacks {
+          cb(generatedPlaylists, operation)
+        }
+      }
     }
   }
 
   func onPlaylistChanged(callback: @escaping (String, Playlist, QueueOperation?) -> Void) throws {
-    // Listen to all playlists
+    // Store callback in static storage so it persists across HybridPlayerQueue instances
+    HybridPlayerQueue.playlistChangeCallbacks.append(callback)
+
+    // Register listeners for all existing playlists (only once per playlist)
     let allPlaylists = playlistManager.getAllPlaylists()
     for playlist in allPlaylists {
-      let removeListener = playlistManager.addPlaylistChangeListener(playlistId: playlist.id) {
-        updatedPlaylist, operation in
-        callback(updatedPlaylist.id, updatedPlaylist.toGeneratedPlaylist(), operation)
+      if !HybridPlayerQueue.playlistListenerIds.contains(playlist.id) {
+        HybridPlayerQueue.playlistListenerIds.insert(playlist.id)
+        _ = playlistManager.addPlaylistChangeListener(playlistId: playlist.id) {
+          updatedPlaylist, operation in
+          let generatedPlaylist = updatedPlaylist.toGeneratedPlaylist()
+          // Call all registered callbacks
+          for cb in HybridPlayerQueue.playlistChangeCallbacks {
+            cb(updatedPlaylist.id, generatedPlaylist, operation)
+          }
+        }
       }
-      playlistChangeListeners[playlist.id] = removeListener
     }
   }
 }

package/lib/hooks/downloadCallbackManager.d.ts

@@ -0,0 +1,36 @@
+import type { DownloadProgress, DownloadState, DownloadedTrack, DownloadError } from '../types/DownloadTypes';
+type ProgressCallback = (progress: DownloadProgress) => void;
+type StateChangeCallback = (downloadId: string, trackId: string, state: DownloadState, error?: DownloadError) => void;
+type CompleteCallback = (downloadedTrack: DownloadedTrack) => void;
+/**
+ * Internal subscription manager for download callbacks.
+ * Allows multiple hooks to subscribe to a single native callback.
+ */
+declare class DownloadCallbackSubscriptionManager {
+    private progressSubscribers;
+    private stateChangeSubscribers;
+    private completeSubscribers;
+    private isProgressRegistered;
+    private isStateChangeRegistered;
+    private isCompleteRegistered;
+    /**
+     * Subscribe to download progress updates
+     * @returns Unsubscribe function
+     */
+    subscribeToProgress(callback: ProgressCallback): () => void;
+    /**
+     * Subscribe to download state changes
+     * @returns Unsubscribe function
+     */
+    subscribeToStateChange(callback: StateChangeCallback): () => void;
+    /**
+     * Subscribe to download completions
+     * @returns Unsubscribe function
+     */
+    subscribeToComplete(callback: CompleteCallback): () => void;
+    private ensureProgressRegistered;
+    private ensureStateChangeRegistered;
+    private ensureCompleteRegistered;
+}
+export declare const downloadCallbackManager: DownloadCallbackSubscriptionManager;
+export {};

package/lib/hooks/downloadCallbackManager.js

@@ -0,0 +1,108 @@
+import { DownloadManager } from '../index';
+/**
+ * Internal subscription manager for download callbacks.
+ * Allows multiple hooks to subscribe to a single native callback.
+ */
+class DownloadCallbackSubscriptionManager {
+    progressSubscribers = new Set();
+    stateChangeSubscribers = new Set();
+    completeSubscribers = new Set();
+    isProgressRegistered = false;
+    isStateChangeRegistered = false;
+    isCompleteRegistered = false;
+    /**
+     * Subscribe to download progress updates
+     * @returns Unsubscribe function
+     */
+    subscribeToProgress(callback) {
+        this.progressSubscribers.add(callback);
+        this.ensureProgressRegistered();
+        return () => {
+            this.progressSubscribers.delete(callback);
+        };
+    }
+    /**
+     * Subscribe to download state changes
+     * @returns Unsubscribe function
+     */
+    subscribeToStateChange(callback) {
+        this.stateChangeSubscribers.add(callback);
+        this.ensureStateChangeRegistered();
+        return () => {
+            this.stateChangeSubscribers.delete(callback);
+        };
+    }
+    /**
+     * Subscribe to download completions
+     * @returns Unsubscribe function
+     */
+    subscribeToComplete(callback) {
+        this.completeSubscribers.add(callback);
+        this.ensureCompleteRegistered();
+        return () => {
+            this.completeSubscribers.delete(callback);
+        };
+    }
+    ensureProgressRegistered() {
+        if (this.isProgressRegistered)
+            return;
+        try {
+            DownloadManager.onDownloadProgress((progress) => {
+                this.progressSubscribers.forEach((subscriber) => {
+                    try {
+                        subscriber(progress);
+                    }
+                    catch (error) {
+                        console.error('[DownloadCallbackManager] Error in progress subscriber:', error);
+                    }
+                });
+            });
+            this.isProgressRegistered = true;
+        }
+        catch (error) {
+            console.error('[DownloadCallbackManager] Failed to register progress callback:', error);
+        }
+    }
+    ensureStateChangeRegistered() {
+        if (this.isStateChangeRegistered)
+            return;
+        try {
+            DownloadManager.onDownloadStateChange((downloadId, trackId, state, error) => {
+                this.stateChangeSubscribers.forEach((subscriber) => {
+                    try {
+                        subscriber(downloadId, trackId, state, error);
+                    }
+                    catch (err) {
+                        console.error('[DownloadCallbackManager] Error in state change subscriber:', err);
+                    }
+                });
+            });
+            this.isStateChangeRegistered = true;
+        }
+        catch (error) {
+            console.error('[DownloadCallbackManager] Failed to register state change callback:', error);
+        }
+    }
+    ensureCompleteRegistered() {
+        if (this.isCompleteRegistered)
+            return;
+        try {
+            DownloadManager.onDownloadComplete((downloadedTrack) => {
+                this.completeSubscribers.forEach((subscriber) => {
+                    try {
+                        subscriber(downloadedTrack);
+                    }
+                    catch (error) {
+                        console.error('[DownloadCallbackManager] Error in complete subscriber:', error);
+                    }
+                });
+            });
+            this.isCompleteRegistered = true;
+        }
+        catch (error) {
+            console.error('[DownloadCallbackManager] Failed to register complete callback:', error);
+        }
+    }
+}
+// Export singleton instance
+export const downloadCallbackManager = new DownloadCallbackSubscriptionManager();

package/lib/hooks/equalizerCallbackManager.d.ts

@@ -0,0 +1,37 @@
+import type { EqualizerBand } from '../types/EqualizerTypes';
+type EnabledChangeCallback = (enabled: boolean) => void;
+type BandChangeCallback = (bands: EqualizerBand[]) => void;
+type PresetChangeCallback = (presetName: string | null) => void;
+/**
+ * Internal subscription manager that allows multiple hooks to subscribe
+ * to equalizer callbacks. This solves the problem where registering
+ * a new callback overwrites the previous one.
+ */
+declare class EqualizerCallbackSubscriptionManager {
+    private enabledChangeSubscribers;
+    private bandChangeSubscribers;
+    private presetChangeSubscribers;
+    private isEnabledChangeRegistered;
+    private isBandChangeRegistered;
+    private isPresetChangeRegistered;
+    /**
+     * Subscribe to enabled state changes
+     * @returns Unsubscribe function
+     */
+    subscribeToEnabledChange(callback: EnabledChangeCallback): () => void;
+    /**
+     * Subscribe to band changes
+     * @returns Unsubscribe function
+     */
+    subscribeToBandChange(callback: BandChangeCallback): () => void;
+    /**
+     * Subscribe to preset changes
+     * @returns Unsubscribe function
+     */
+    subscribeToPresetChange(callback: PresetChangeCallback): () => void;
+    private ensureEnabledChangeRegistered;
+    private ensureBandChangeRegistered;
+    private ensurePresetChangeRegistered;
+}
+export declare const equalizerCallbackManager: EqualizerCallbackSubscriptionManager;
+export {};

package/lib/hooks/equalizerCallbackManager.js

@@ -0,0 +1,109 @@
+import { Equalizer } from '../index';
+/**
+ * Internal subscription manager that allows multiple hooks to subscribe
+ * to equalizer callbacks. This solves the problem where registering
+ * a new callback overwrites the previous one.
+ */
+class EqualizerCallbackSubscriptionManager {
+    enabledChangeSubscribers = new Set();
+    bandChangeSubscribers = new Set();
+    presetChangeSubscribers = new Set();
+    isEnabledChangeRegistered = false;
+    isBandChangeRegistered = false;
+    isPresetChangeRegistered = false;
+    /**
+     * Subscribe to enabled state changes
+     * @returns Unsubscribe function
+     */
+    subscribeToEnabledChange(callback) {
+        this.enabledChangeSubscribers.add(callback);
+        this.ensureEnabledChangeRegistered();
+        return () => {
+            this.enabledChangeSubscribers.delete(callback);
+        };
+    }
+    /**
+     * Subscribe to band changes
+     * @returns Unsubscribe function
+     */
+    subscribeToBandChange(callback) {
+        this.bandChangeSubscribers.add(callback);
+        this.ensureBandChangeRegistered();
+        return () => {
+            this.bandChangeSubscribers.delete(callback);
+        };
+    }
+    /**
+     * Subscribe to preset changes
+     * @returns Unsubscribe function
+     */
+    subscribeToPresetChange(callback) {
+        this.presetChangeSubscribers.add(callback);
+        this.ensurePresetChangeRegistered();
+        return () => {
+            this.presetChangeSubscribers.delete(callback);
+        };
+    }
+    ensureEnabledChangeRegistered() {
+        if (this.isEnabledChangeRegistered)
+            return;
+        try {
+            Equalizer.onEnabledChange((enabled) => {
+                this.enabledChangeSubscribers.forEach((subscriber) => {
+                    try {
+                        subscriber(enabled);
+                    }
+                    catch (error) {
+                        console.error('[EqualizerCallbackManager] Error in enabled change subscriber:', error);
+                    }
+                });
+            });
+            this.isEnabledChangeRegistered = true;
+        }
+        catch (error) {
+            console.error('[EqualizerCallbackManager] Failed to register enabled change callback:', error);
+        }
+    }
+    ensureBandChangeRegistered() {
+        if (this.isBandChangeRegistered)
+            return;
+        try {
+            Equalizer.onBandChange((bands) => {
+                this.bandChangeSubscribers.forEach((subscriber) => {
+                    try {
+                        subscriber(bands);
+                    }
+                    catch (error) {
+                        console.error('[EqualizerCallbackManager] Error in band change subscriber:', error);
+                    }
+                });
+            });
+            this.isBandChangeRegistered = true;
+        }
+        catch (error) {
+            console.error('[EqualizerCallbackManager] Failed to register band change callback:', error);
+        }
+    }
+    ensurePresetChangeRegistered() {
+        if (this.isPresetChangeRegistered)
+            return;
+        try {
+            Equalizer.onPresetChange((presetName) => {
+                this.presetChangeSubscribers.forEach((subscriber) => {
+                    try {
+                        subscriber(presetName);
+                    }
+                    catch (error) {
+                        console.error('[EqualizerCallbackManager] Error in preset change subscriber:', error);
+                    }
+                });
+            });
+            this.isPresetChangeRegistered = true;
+        }
+        catch (error) {
+            console.error('[EqualizerCallbackManager] Failed to register preset change callback:', error);
+        }
+    }
+}
+// Export singleton instance
+export const equalizerCallbackManager = new EqualizerCallbackSubscriptionManager();

package/lib/hooks/index.d.ts

@@ -7,3 +7,19 @@ export { useOnPlaybackProgressChange } from './useOnPlaybackProgressChange';
 export { useAndroidAutoConnection } from './useAndroidAutoConnection';
 export { useAudioDevices } from './useAudioDevices';
 export { useNowPlaying } from './useNowPlaying';
+export { usePlaylist } from './usePlaylist';
+export type { UsePlaylistResult } from './usePlaylist';
+export { useActualQueue } from './useActualQueue';
+export type { UseActualQueueResult } from './useActualQueue';
+export { useDownloadProgress } from './useDownloadProgress';
+export type { UseDownloadProgressOptions, UseDownloadProgressResult, } from './useDownloadProgress';
+export { useDownloadedTracks } from './useDownloadedTracks';
+export type { UseDownloadedTracksResult } from './useDownloadedTracks';
+export { useDownloadActions } from './useDownloadActions';
+export type { UseDownloadActionsResult } from './useDownloadActions';
+export { useDownloadStorage } from './useDownloadStorage';
+export type { UseDownloadStorageResult } from './useDownloadStorage';
+export { useEqualizer } from './useEqualizer';
+export type { UseEqualizerResult } from './useEqualizer';
+export { useEqualizerPresets } from './useEqualizerPresets';
+export type { UseEqualizerPresetsResult } from './useEqualizerPresets';

package/lib/hooks/index.js

@@ -5,3 +5,13 @@ export { useOnPlaybackProgressChange } from './useOnPlaybackProgressChange';
 export { useAndroidAutoConnection } from './useAndroidAutoConnection';
 export { useAudioDevices } from './useAudioDevices';
 export { useNowPlaying } from './useNowPlaying';
+export { usePlaylist } from './usePlaylist';
+export { useActualQueue } from './useActualQueue';
+// Download hooks
+export { useDownloadProgress } from './useDownloadProgress';
+export { useDownloadedTracks } from './useDownloadedTracks';
+export { useDownloadActions } from './useDownloadActions';
+export { useDownloadStorage } from './useDownloadStorage';
+// Equalizer hooks
+export { useEqualizer } from './useEqualizer';
+export { useEqualizerPresets } from './useEqualizerPresets';

package/lib/hooks/useActualQueue.d.ts

@@ -0,0 +1,48 @@
+import type { TrackItem } from '../types/PlayerQueue';
+export interface UseActualQueueResult {
+    /** The current queue in playback order */
+    queue: TrackItem[];
+    /** Manually refresh the queue */
+    refreshQueue: () => void;
+    /** Whether the queue is currently loading */
+    isLoading: boolean;
+}
+/**
+ * Hook to get the actual playback queue including temporary tracks
+ *
+ * Returns the complete queue in playback order:
+ * [tracks_before_current] + [current] + [playNext_stack] + [upNext_queue] + [remaining_tracks]
+ *
+ * Auto-updates when:
+ * - Track changes
+ * - Playback state changes
+ *
+ * Call `refreshQueue()` after adding tracks via `playNext()` or `addToUpNext()`
+ * to immediately see the updated queue.
+ *
+ * @returns Object containing queue array, refresh function, and loading state
+ *
+ * @example
+ * ```tsx
+ * function QueueView() {
+ *   const { queue, refreshQueue, isLoading } = useActualQueue();
+ *
+ *   const handleAddToUpNext = (trackId: string) => {
+ *     TrackPlayer.addToUpNext(trackId);
+ *     // Refresh queue after adding track
+ *     setTimeout(refreshQueue, 100);
+ *   };
+ *
+ *   return (
+ *     <ScrollView>
+ *       {queue.map((track, index) => (
+ *         <Text key={track.id}>
+ *           {index + 1}. {track.title}
+ *         </Text>
+ *       ))}
+ *     </ScrollView>
+ *   );
+ * }
+ * ```
+ */
+export declare function useActualQueue(): UseActualQueueResult;