react-native-nitro-player 0.6.1 → 0.7.1-alpha.0

package/src/hooks/useDownloadedTracks.ts

@@ -43,21 +43,25 @@ export function useDownloadedTracks(): UseDownloadedTracksResult {
   const refresh = useCallback(() => {
     if (!isMounted.current) return
 
-    try {
-      const tracks = DownloadManager.getAllDownloadedTracks()
-      const playlists = DownloadManager.getAllDownloadedPlaylists()
-
-      if (isMounted.current) {
-        setDownloadedTracks(tracks)
-        setDownloadedPlaylists(playlists)
-        setIsLoading(false)
-      }
-    } catch (error) {
-      console.error('[useDownloadedTracks] Error refreshing:', error)
-      if (isMounted.current) {
-        setIsLoading(false)
+    const run = async () => {
+      try {
+        const tracks = await DownloadManager.getAllDownloadedTracks()
+        const playlists = await DownloadManager.getAllDownloadedPlaylists()
+
+        if (isMounted.current) {
+          setDownloadedTracks(tracks)
+          setDownloadedPlaylists(playlists)
+          setIsLoading(false)
+        }
+      } catch (error) {
+        console.error('[useDownloadedTracks] Error refreshing:', error)
+        if (isMounted.current) {
+          setIsLoading(false)
+        }
       }
     }
+
+    void run()
   }, [])
 
   useEffect(() => {

package/src/hooks/useEqualizer.ts

@@ -11,13 +11,13 @@ export interface UseEqualizerResult {
   /** Currently applied preset name */
   currentPreset: string | null
   /** Toggle equalizer on/off */
-  setEnabled: (enabled: boolean) => boolean
+  setEnabled: (enabled: boolean) => Promise<boolean>
   /** Set gain for a specific band */
-  setBandGain: (bandIndex: number, gainDb: number) => boolean
+  setBandGain: (bandIndex: number, gainDb: number) => Promise<boolean>
   /** Set all band gains at once */
-  setAllBandGains: (gains: number[]) => boolean
+  setAllBandGains: (gains: number[]) => Promise<boolean>
   /** Reset to flat response */
-  reset: () => void
+  reset: () => Promise<void>
   /** Whether equalizer is loading */
   isLoading: boolean
   /** Gain range (min/max in dB) */
@@ -46,7 +46,7 @@ export function useEqualizer(): UseEqualizerResult {
 
     const loadState = async () => {
       try {
-        const state = Equalizer.getState()
+        const state = await Equalizer.getState()
         if (isMounted.current) {
           setIsEnabledState(state.enabled)
           setBands(state.bands)
@@ -111,9 +111,10 @@ export function useEqualizer(): UseEqualizerResult {
     return unsubscribe
   }, [])
 
-  const setEnabled = useCallback((enabled: boolean): boolean => {
+  const setEnabled = useCallback(async (enabled: boolean): Promise<boolean> => {
     try {
-      return Equalizer.setEnabled(enabled)
+      await Equalizer.setEnabled(enabled)
+      return true
     } catch (error) {
       console.error('[useEqualizer] Error setting enabled:', error)
       return false
@@ -121,13 +122,13 @@ export function useEqualizer(): UseEqualizerResult {
   }, [])
 
   const setBandGain = useCallback(
-    (bandIndex: number, gainDb: number): boolean => {
-      // Optimistic update
+    async (bandIndex: number, gainDb: number): Promise<boolean> => {
       setBands((prevBands) =>
         prevBands.map((b) => (b.index === bandIndex ? { ...b, gainDb } : b))
       )
       try {
-        return Equalizer.setBandGain(bandIndex, gainDb)
+        await Equalizer.setBandGain(bandIndex, gainDb)
+        return true
       } catch (error) {
         console.error('[useEqualizer] Error setting band gain:', error)
         return false
@@ -136,24 +137,23 @@ export function useEqualizer(): UseEqualizerResult {
     []
   )
 
-  const setAllBandGains = useCallback((gains: number[]): boolean => {
-    // Optimistic update
+  const setAllBandGains = useCallback(async (gains: number[]): Promise<boolean> => {
     setBands((prevBands) =>
       prevBands.map((b, i) => ({ ...b, gainDb: gains[i] ?? b.gainDb }))
     )
     try {
-      return Equalizer.setAllBandGains(gains)
+      await Equalizer.setAllBandGains(gains)
+      return true
     } catch (error) {
       console.error('[useEqualizer] Error setting all band gains:', error)
       return false
     }
   }, [])
 
-  const reset = useCallback(() => {
-    // Optimistic update
+  const reset = useCallback(async () => {
     setBands((prevBands) => prevBands.map((b) => ({ ...b, gainDb: 0 })))
     try {
-      Equalizer.reset()
+      await Equalizer.reset()
     } catch (error) {
       console.error('[useEqualizer] Error resetting equalizer:', error)
     }

package/src/hooks/useEqualizerPresets.ts

@@ -11,11 +11,11 @@ export interface UseEqualizerPresetsResult {
   /** Custom user presets */
   customPresets: EqualizerPreset[]
   /** Apply a preset by name */
-  applyPreset: (name: string) => boolean
+  applyPreset: (name: string) => Promise<boolean>
   /** Save current settings as custom preset */
-  saveCustomPreset: (name: string) => boolean
+  saveCustomPreset: (name: string) => Promise<boolean>
   /** Delete a custom preset */
-  deleteCustomPreset: (name: string) => boolean
+  deleteCustomPreset: (name: string) => Promise<boolean>
   /** Currently applied preset name */
   currentPreset: string | null
   /** Whether presets are loading */
@@ -75,13 +75,11 @@ export function useEqualizerPresets(): UseEqualizerPresetsResult {
     return unsubscribe
   }, [])
 
-  const applyPreset = useCallback((name: string): boolean => {
+  const applyPreset = useCallback(async (name: string): Promise<boolean> => {
     try {
-      const success = Equalizer.applyPreset(name)
-      if (success) {
-        setCurrentPreset(name)
-      }
-      return success
+      await Equalizer.applyPreset(name)
+      setCurrentPreset(name)
+      return true
     } catch (error) {
       console.error('[useEqualizerPresets] Error applying preset:', error)
       return false
@@ -89,13 +87,11 @@ export function useEqualizerPresets(): UseEqualizerPresetsResult {
   }, [])
 
   const saveCustomPreset = useCallback(
-    (name: string): boolean => {
+    async (name: string): Promise<boolean> => {
       try {
-        const success = Equalizer.saveCustomPreset(name)
-        if (success) {
-          refreshPresets()
-        }
-        return success
+        await Equalizer.saveCustomPreset(name)
+        refreshPresets()
+        return true
       } catch (error) {
         console.error(
           '[useEqualizerPresets] Error saving custom preset:',
@@ -108,13 +104,11 @@ export function useEqualizerPresets(): UseEqualizerPresetsResult {
   )
 
   const deleteCustomPreset = useCallback(
-    (name: string): boolean => {
+    async (name: string): Promise<boolean> => {
       try {
-        const success = Equalizer.deleteCustomPreset(name)
-        if (success) {
-          refreshPresets()
-        }
-        return success
+        await Equalizer.deleteCustomPreset(name)
+        refreshPresets()
+        return true
       } catch (error) {
         console.error(
           '[useEqualizerPresets] Error deleting custom preset:',

package/src/specs/AndroidAutoMediaLibrary.nitro.ts

@@ -12,11 +12,11 @@ export interface AndroidAutoMediaLibrary
    *
    * @param libraryJson - JSON string of the MediaLibrary structure
    */
-  setMediaLibrary(libraryJson: string): void
+  setMediaLibrary(libraryJson: string): Promise<void>
 
   /**
    * Clear the Android Auto media library
    * Falls back to showing all playlists
    */
-  clearMediaLibrary(): void
+  clearMediaLibrary(): Promise<void>
 }

package/src/specs/AudioDevices.nitro.ts

@@ -19,7 +19,7 @@ export interface AudioDevices extends HybridObject<{ android: 'kotlin' }> {
    * Set the audio device
    *
    * @param deviceId - The ID of the audio device
-   * @returns True if the audio device was set successfully, false otherwise
+   * @returns Promise that resolves when the device has been set
    */
-  setAudioDevice(deviceId: number): boolean
+  setAudioDevice(deviceId: number): Promise<void>
 }

package/src/specs/DownloadManager.nitro.ts

@@ -102,42 +102,42 @@ export interface DownloadManager
   /**
    * Check if a track is downloaded
    */
-  isTrackDownloaded(trackId: string): boolean
+  isTrackDownloaded(trackId: string): Promise<boolean>
 
   /**
    * Check if a playlist is fully downloaded
    */
-  isPlaylistDownloaded(playlistId: string): boolean
+  isPlaylistDownloaded(playlistId: string): Promise<boolean>
 
   /**
    * Check if a playlist is partially downloaded
    */
-  isPlaylistPartiallyDownloaded(playlistId: string): boolean
+  isPlaylistPartiallyDownloaded(playlistId: string): Promise<boolean>
 
   /**
    * Get downloaded track by track ID
    */
-  getDownloadedTrack(trackId: string): DownloadedTrack | null
+  getDownloadedTrack(trackId: string): Promise<DownloadedTrack | null>
 
   /**
    * Get all downloaded tracks
    */
-  getAllDownloadedTracks(): DownloadedTrack[]
+  getAllDownloadedTracks(): Promise<DownloadedTrack[]>
 
   /**
    * Get downloaded playlist by playlist ID
    */
-  getDownloadedPlaylist(playlistId: string): DownloadedPlaylist | null
+  getDownloadedPlaylist(playlistId: string): Promise<DownloadedPlaylist | null>
 
   /**
    * Get all downloaded playlists
    */
-  getAllDownloadedPlaylists(): DownloadedPlaylist[]
+  getAllDownloadedPlaylists(): Promise<DownloadedPlaylist[]>
 
   /**
    * Get local file path for a downloaded track
    */
-  getLocalPath(trackId: string): string | null
+  getLocalPath(trackId: string): Promise<string | null>
 
   /**
    * Delete a downloaded track
@@ -163,7 +163,7 @@ export interface DownloadManager
    * Call this to clean up after manual file deletion
    * @returns number of orphaned records that were cleaned up
    */
-  syncDownloads(): number
+  syncDownloads(): Promise<number>
   /**
    * Set playback source preference
    */
@@ -177,7 +177,7 @@ export interface DownloadManager
   /**
    * Get the effective URL for a track (local or network based on preference)
    */
-  getEffectiveUrl(track: TrackItem): string
+  getEffectiveUrl(track: TrackItem): Promise<string>
 
   /**
    * Called when download progress updates

package/src/specs/Equalizer.nitro.ts

@@ -10,20 +10,20 @@ export interface Equalizer
   extends HybridObject<{ android: 'kotlin'; ios: 'swift' }> {
   // === Enable/Disable ===
   /** Enable or disable the equalizer */
-  setEnabled(enabled: boolean): boolean
+  setEnabled(enabled: boolean): Promise<void>
 
   /** Check if equalizer is currently enabled */
   isEnabled(): boolean
 
   // === Band Control ===
   /** Get all equalizer bands with current gain values */
-  getBands(): EqualizerBand[]
+  getBands(): Promise<EqualizerBand[]>
 
   /** Set gain for a specific band index (-12 to +12 dB) */
-  setBandGain(bandIndex: number, gainDb: number): boolean
+  setBandGain(bandIndex: number, gainDb: number): Promise<void>
 
   /** Set gains for all bands at once (array of 5 values) */
-  setAllBandGains(gains: number[]): boolean
+  setAllBandGains(gains: number[]): Promise<void>
 
   /** Get the valid gain range for bands */
   getBandRange(): GainRange
@@ -39,23 +39,23 @@ export interface Equalizer
   getCustomPresets(): EqualizerPreset[]
 
   /** Apply a preset by name */
-  applyPreset(presetName: string): boolean
+  applyPreset(presetName: string): Promise<void>
 
   /** Get currently applied preset name (null if custom values) */
   getCurrentPresetName(): string | null
 
   /** Save current settings as a custom preset */
-  saveCustomPreset(name: string): boolean
+  saveCustomPreset(name: string): Promise<void>
 
   /** Delete a custom preset by name */
-  deleteCustomPreset(name: string): boolean
+  deleteCustomPreset(name: string): Promise<void>
 
   // === State ===
   /** Get complete equalizer state */
-  getState(): EqualizerState
+  getState(): Promise<EqualizerState>
 
   /** Reset to flat response (all bands at 0 dB) */
-  reset(): void
+  reset(): Promise<void>
 
   // === Events ===
   /** Called when equalizer enabled state changes */

package/src/specs/TrackPlayer.nitro.ts

@@ -12,33 +12,33 @@ import type {
 export interface PlayerQueue
   extends HybridObject<{ android: 'kotlin'; ios: 'swift' }> {
   // Playlist management
-  createPlaylist(name: string, description?: string, artwork?: string): string
-  deletePlaylist(playlistId: string): void
+  createPlaylist(name: string, description?: string, artwork?: string): Promise<string>
+  deletePlaylist(playlistId: string): Promise<void>
   updatePlaylist(
     playlistId: string,
     name?: string,
     description?: string,
     artwork?: string
-  ): void
+  ): Promise<void>
   getPlaylist(playlistId: string): Playlist | null
   getAllPlaylists(): Playlist[]
 
   // Track management within playlists
-  addTrackToPlaylist(playlistId: string, track: TrackItem, index?: number): void
+  addTrackToPlaylist(playlistId: string, track: TrackItem, index?: number): Promise<void>
   addTracksToPlaylist(
     playlistId: string,
     tracks: TrackItem[],
     index?: number
-  ): void
-  removeTrackFromPlaylist(playlistId: string, trackId: string): void
+  ): Promise<void>
+  removeTrackFromPlaylist(playlistId: string, trackId: string): Promise<void>
   reorderTrackInPlaylist(
     playlistId: string,
     trackId: string,
     newIndex: number
-  ): void
+  ): Promise<void>
 
   // Playback control
-  loadPlaylist(playlistId: string): void
+  loadPlaylist(playlistId: string): Promise<void>
   getCurrentPlaylistId(): string | null
 
   // Events
@@ -58,20 +58,20 @@ export type RepeatMode = 'off' | 'Playlist' | 'track'
 
 export interface TrackPlayer
   extends HybridObject<{ android: 'kotlin'; ios: 'swift' }> {
-  play(): void
-  pause(): void
+  play(): Promise<void>
+  pause(): Promise<void>
   playSong(songId: string, fromPlaylist?: string): Promise<void>
-  skipToNext(): void
+  skipToNext(): Promise<void>
   skipToIndex(index: number): Promise<boolean>
-  skipToPrevious(): void
-  seek(position: number): void
+  skipToPrevious(): Promise<void>
+  seek(position: number): Promise<void>
   addToUpNext(trackId: string): Promise<void>
   playNext(trackId: string): Promise<void>
   getActualQueue(): Promise<TrackItem[]>
   getState(): Promise<PlayerState>
-  setRepeatMode(mode: RepeatMode): boolean
+  setRepeatMode(mode: RepeatMode): Promise<void>
   getRepeatMode(): RepeatMode
-  configure(config: PlayerConfig): void
+  configure(config: PlayerConfig): Promise<void>
   onChangeTrack(callback: (track: TrackItem, reason?: Reason) => void): void
   onPlaybackStateChange(
     callback: (state: TrackPlayerState, reason?: Reason) => void
@@ -86,7 +86,7 @@ export interface TrackPlayer
   ): void
   onAndroidAutoConnectionChange(callback: (connected: boolean) => void): void
   isAndroidAutoConnected(): boolean
-  setVolume(volume: number): boolean
+  setVolume(volume: number): Promise<void>
 
   /**
    * Update entire track objects across all playlists
@@ -144,4 +144,40 @@ export interface TrackPlayer
    * @returns Promise resolving to playback speed
    */
   getPlaybackSpeed(): Promise<number>
+
+  // =========================================================
+  // Temporary queue management (v2)
+  // =========================================================
+
+  /** Remove a track from the playNext stack by ID. Returns true if found and removed. */
+  removeFromPlayNext(trackId: string): Promise<boolean>
+
+  /** Remove a track from the upNext queue by ID. Returns true if found and removed. */
+  removeFromUpNext(trackId: string): Promise<boolean>
+
+  /** Clear the entire playNext stack */
+  clearPlayNext(): Promise<void>
+
+  /** Clear the entire upNext queue */
+  clearUpNext(): Promise<void>
+
+  /**
+   * Reorder a temporary track within the combined virtual queue
+   * (playNextStack + upNextQueue). newIndex is 0-based within that combined list.
+   * Returns true if the track was found and moved.
+   */
+  reorderTemporaryTrack(trackId: string, newIndex: number): Promise<boolean>
+
+  /** Get the current playNext stack (LIFO order, index 0 plays first) */
+  getPlayNextQueue(): Promise<TrackItem[]>
+
+  /** Get the current upNext queue (FIFO order, index 0 plays first) */
+  getUpNextQueue(): Promise<TrackItem[]>
+
+  /**
+   * Register callback that fires whenever the temporary queue (playNext or upNext) changes.
+   */
+  onTemporaryQueueChange(
+    callback: (playNextQueue: TrackItem[], upNextQueue: TrackItem[]) => void
+  ): void
 }