react-native-nitro-player 0.3.0-alpha.9 → 0.4.1-alpha.0

package/src/hooks/callbackManager.ts

@@ -3,6 +3,12 @@ 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
@@ -12,8 +18,12 @@ type TrackChangeCallback = (track: TrackItem, reason?: Reason) => void
 class CallbackSubscriptionManager {
   private playbackStateSubscribers = new Set<PlaybackStateCallback>()
   private trackChangeSubscribers = new Set<TrackChangeCallback>()
+  private playbackProgressSubscribers = new Set<PlaybackProgressCallback>()
+  private seekSubscribers = new Set<SeekCallback>()
   private isPlaybackStateRegistered = false
   private isTrackChangeRegistered = false
+  private isPlaybackProgressRegistered = false
+  private isSeekRegistered = false
 
   /**
    * Subscribe to playback state changes
@@ -90,6 +100,83 @@ class CallbackSubscriptionManager {
       )
     }
   }
+
+  /**
+   * Subscribe to playback progress changes
+   * @returns Unsubscribe function
+   */
+  subscribeToPlaybackProgressChange(
+    callback: PlaybackProgressCallback
+  ): () => void {
+    this.playbackProgressSubscribers.add(callback)
+    this.ensurePlaybackProgressRegistered()
+
+    return () => {
+      this.playbackProgressSubscribers.delete(callback)
+    }
+  }
+
+  /**
+   * Subscribe to seek events
+   * @returns Unsubscribe function
+   */
+  subscribeToSeek(callback: SeekCallback): () => void {
+    this.seekSubscribers.add(callback)
+    this.ensureSeekRegistered()
+
+    return () => {
+      this.seekSubscribers.delete(callback)
+    }
+  }
+
+  private ensurePlaybackProgressRegistered(): void {
+    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
+      )
+    }
+  }
+
+  private ensureSeekRegistered(): void {
+    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

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 }
+}