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

package/src/hooks/downloadCallbackManager.ts

@@ -0,0 +1,149 @@
+import { DownloadManager } from '../index'
+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.
+ */
+class DownloadCallbackSubscriptionManager {
+  private progressSubscribers = new Set<ProgressCallback>()
+  private stateChangeSubscribers = new Set<StateChangeCallback>()
+  private completeSubscribers = new Set<CompleteCallback>()
+
+  private isProgressRegistered = false
+  private isStateChangeRegistered = false
+  private isCompleteRegistered = false
+
+  /**
+   * Subscribe to download progress updates
+   * @returns Unsubscribe function
+   */
+  subscribeToProgress(callback: ProgressCallback): () => void {
+    this.progressSubscribers.add(callback)
+    this.ensureProgressRegistered()
+
+    return () => {
+      this.progressSubscribers.delete(callback)
+    }
+  }
+
+  /**
+   * Subscribe to download state changes
+   * @returns Unsubscribe function
+   */
+  subscribeToStateChange(callback: StateChangeCallback): () => void {
+    this.stateChangeSubscribers.add(callback)
+    this.ensureStateChangeRegistered()
+
+    return () => {
+      this.stateChangeSubscribers.delete(callback)
+    }
+  }
+
+  /**
+   * Subscribe to download completions
+   * @returns Unsubscribe function
+   */
+  subscribeToComplete(callback: CompleteCallback): () => void {
+    this.completeSubscribers.add(callback)
+    this.ensureCompleteRegistered()
+
+    return () => {
+      this.completeSubscribers.delete(callback)
+    }
+  }
+
+  private ensureProgressRegistered(): void {
+    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
+      )
+    }
+  }
+
+  private ensureStateChangeRegistered(): void {
+    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
+      )
+    }
+  }
+
+  private ensureCompleteRegistered(): void {
+    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/src/hooks/equalizerCallbackManager.ts

@@ -0,0 +1,138 @@
+import { Equalizer } from '../index'
+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.
+ */
+class EqualizerCallbackSubscriptionManager {
+  private enabledChangeSubscribers = new Set<EnabledChangeCallback>()
+  private bandChangeSubscribers = new Set<BandChangeCallback>()
+  private presetChangeSubscribers = new Set<PresetChangeCallback>()
+  private isEnabledChangeRegistered = false
+  private isBandChangeRegistered = false
+  private isPresetChangeRegistered = false
+
+  /**
+   * Subscribe to enabled state changes
+   * @returns Unsubscribe function
+   */
+  subscribeToEnabledChange(callback: EnabledChangeCallback): () => void {
+    this.enabledChangeSubscribers.add(callback)
+    this.ensureEnabledChangeRegistered()
+
+    return () => {
+      this.enabledChangeSubscribers.delete(callback)
+    }
+  }
+
+  /**
+   * Subscribe to band changes
+   * @returns Unsubscribe function
+   */
+  subscribeToBandChange(callback: BandChangeCallback): () => void {
+    this.bandChangeSubscribers.add(callback)
+    this.ensureBandChangeRegistered()
+
+    return () => {
+      this.bandChangeSubscribers.delete(callback)
+    }
+  }
+
+  /**
+   * Subscribe to preset changes
+   * @returns Unsubscribe function
+   */
+  subscribeToPresetChange(callback: PresetChangeCallback): () => void {
+    this.presetChangeSubscribers.add(callback)
+    this.ensurePresetChangeRegistered()
+
+    return () => {
+      this.presetChangeSubscribers.delete(callback)
+    }
+  }
+
+  private ensureEnabledChangeRegistered(): void {
+    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
+      )
+    }
+  }
+
+  private ensureBandChangeRegistered(): void {
+    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
+      )
+    }
+  }
+
+  private ensurePresetChangeRegistered(): void {
+    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/src/hooks/index.ts

@@ -7,3 +7,26 @@ 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'
+
+// Download hooks
+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'
+
+// Equalizer hooks
+export { useEqualizer } from './useEqualizer'
+export type { UseEqualizerResult } from './useEqualizer'
+export { useEqualizerPresets } from './useEqualizerPresets'
+export type { UseEqualizerPresetsResult } from './useEqualizerPresets'

package/src/hooks/useActualQueue.ts

@@ -0,0 +1,116 @@
+import { useEffect, useState, useRef, useCallback } from 'react'
+import { TrackPlayer } from '../index'
+import { callbackManager } from './callbackManager'
+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 function useActualQueue(): UseActualQueueResult {
+  const [queue, setQueue] = useState<TrackItem[]>([])
+  const [isLoading, setIsLoading] = useState(true)
+  const isMounted = useRef(true)
+
+  const updateQueue = useCallback(async () => {
+    if (!isMounted.current) return
+
+    try {
+      const actualQueue = await TrackPlayer.getActualQueue()
+      if (isMounted.current) {
+        setQueue(actualQueue)
+        setIsLoading(false)
+      }
+    } catch (error) {
+      console.error('[useActualQueue] Error getting queue:', error)
+      if (isMounted.current) {
+        setQueue([])
+        setIsLoading(false)
+      }
+    }
+  }, [])
+
+  const refreshQueue = useCallback(() => {
+    if (!isMounted.current) return
+    setIsLoading(true)
+    updateQueue()
+  }, [updateQueue])
+
+  // Initialize queue
+  useEffect(() => {
+    isMounted.current = true
+    updateQueue()
+
+    return () => {
+      isMounted.current = false
+    }
+  }, [updateQueue])
+
+  // Update queue on track changes (with slight delay to ensure native side has updated)
+  useEffect(() => {
+    const unsubscribe = callbackManager.subscribeToTrackChange(() => {
+      // Small delay to ensure native queue is updated
+      setTimeout(updateQueue, 50)
+    })
+
+    return () => {
+      unsubscribe()
+    }
+  }, [updateQueue])
+
+  // Update queue on playback state changes
+  useEffect(() => {
+    const unsubscribe = callbackManager.subscribeToPlaybackState(() => {
+      updateQueue()
+    })
+
+    return () => {
+      unsubscribe()
+    }
+  }, [updateQueue])
+
+  return { queue, refreshQueue, isLoading }
+}

package/src/hooks/useDownloadActions.ts

@@ -0,0 +1,179 @@
+import { useCallback, useState } from 'react'
+import { DownloadManager } from '../index'
+import type { DownloadConfig, PlaybackSource } from '../types/DownloadTypes'
+import type { TrackItem } from '../types/PlayerQueue'
+
+export interface UseDownloadActionsResult {
+  // Download actions
+  downloadTrack: (track: TrackItem, playlistId?: string) => Promise<string>
+  downloadPlaylist: (
+    playlistId: string,
+    tracks: TrackItem[]
+  ) => Promise<string[]>
+
+  // Control actions
+  pauseDownload: (downloadId: string) => Promise<void>
+  resumeDownload: (downloadId: string) => Promise<void>
+  cancelDownload: (downloadId: string) => Promise<void>
+  retryDownload: (downloadId: string) => Promise<void>
+
+  // Bulk control
+  pauseAll: () => Promise<void>
+  resumeAll: () => Promise<void>
+  cancelAll: () => Promise<void>
+
+  // Delete actions
+  deleteTrack: (trackId: string) => Promise<void>
+  deletePlaylist: (playlistId: string) => Promise<void>
+  deleteAll: () => Promise<void>
+
+  // Configuration
+  configure: (config: DownloadConfig) => void
+  setPlaybackSourcePreference: (preference: PlaybackSource) => void
+  getPlaybackSourcePreference: () => PlaybackSource
+
+  // Loading states
+  isDownloading: boolean
+  isDeleting: boolean
+  error: Error | null
+}
+
+/**
+ * Hook for download actions (download, pause, resume, cancel, delete)
+ */
+export function useDownloadActions(): UseDownloadActionsResult {
+  const [isDownloading, setIsDownloading] = useState(false)
+  const [isDeleting, setIsDeleting] = useState(false)
+  const [error, setError] = useState<Error | null>(null)
+
+  const downloadTrack = useCallback(
+    async (track: TrackItem, playlistId?: string) => {
+      setIsDownloading(true)
+      setError(null)
+      try {
+        const downloadId = await DownloadManager.downloadTrack(
+          track,
+          playlistId
+        )
+        return downloadId
+      } catch (e) {
+        setError(e as Error)
+        throw e
+      } finally {
+        setIsDownloading(false)
+      }
+    },
+    []
+  )
+
+  const downloadPlaylist = useCallback(
+    async (playlistId: string, tracks: TrackItem[]) => {
+      setIsDownloading(true)
+      setError(null)
+      try {
+        const downloadIds = await DownloadManager.downloadPlaylist(
+          playlistId,
+          tracks
+        )
+        return downloadIds
+      } catch (e) {
+        setError(e as Error)
+        throw e
+      } finally {
+        setIsDownloading(false)
+      }
+    },
+    []
+  )
+
+  const pauseDownload = useCallback(async (downloadId: string) => {
+    await DownloadManager.pauseDownload(downloadId)
+  }, [])
+
+  const resumeDownload = useCallback(async (downloadId: string) => {
+    await DownloadManager.resumeDownload(downloadId)
+  }, [])
+
+  const cancelDownload = useCallback(async (downloadId: string) => {
+    await DownloadManager.cancelDownload(downloadId)
+  }, [])
+
+  const retryDownload = useCallback(async (downloadId: string) => {
+    await DownloadManager.retryDownload(downloadId)
+  }, [])
+
+  const pauseAll = useCallback(async () => {
+    await DownloadManager.pauseAllDownloads()
+  }, [])
+
+  const resumeAll = useCallback(async () => {
+    await DownloadManager.resumeAllDownloads()
+  }, [])
+
+  const cancelAll = useCallback(async () => {
+    await DownloadManager.cancelAllDownloads()
+  }, [])
+
+  const deleteTrack = useCallback(async (trackId: string) => {
+    setIsDeleting(true)
+    try {
+      await DownloadManager.deleteDownloadedTrack(trackId)
+    } finally {
+      setIsDeleting(false)
+    }
+  }, [])
+
+  const deletePlaylist = useCallback(async (playlistId: string) => {
+    setIsDeleting(true)
+    try {
+      await DownloadManager.deleteDownloadedPlaylist(playlistId)
+    } finally {
+      setIsDeleting(false)
+    }
+  }, [])
+
+  const deleteAll = useCallback(async () => {
+    setIsDeleting(true)
+    try {
+      await DownloadManager.deleteAllDownloads()
+    } finally {
+      setIsDeleting(false)
+    }
+  }, [])
+
+  const configure = useCallback((config: DownloadConfig) => {
+    DownloadManager.configure(config)
+  }, [])
+
+  const setPlaybackSourcePreference = useCallback(
+    (preference: PlaybackSource) => {
+      DownloadManager.setPlaybackSourcePreference(preference)
+    },
+    []
+  )
+
+  const getPlaybackSourcePreference = useCallback(() => {
+    return DownloadManager.getPlaybackSourcePreference()
+  }, [])
+
+  return {
+    downloadTrack,
+    downloadPlaylist,
+    pauseDownload,
+    resumeDownload,
+    cancelDownload,
+    retryDownload,
+    pauseAll,
+    resumeAll,
+    cancelAll,
+    deleteTrack,
+    deletePlaylist,
+    deleteAll,
+    configure,
+    setPlaybackSourcePreference,
+    getPlaybackSourcePreference,
+    isDownloading,
+    isDeleting,
+    error,
+  }
+}