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

package/lib/hooks/index.d.ts

@@ -1,7 +1,25 @@
 export { useOnChangeTrack } from './useOnChangeTrack';
+export type { TrackChangeResult } from './useOnChangeTrack';
 export { useOnPlaybackStateChange } from './useOnPlaybackStateChange';
+export type { PlaybackStateResult } from './useOnPlaybackStateChange';
 export { useOnSeek } from './useOnSeek';
 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;

package/lib/hooks/useActualQueue.js

@@ -0,0 +1,98 @@
+import { useEffect, useState, useRef, useCallback } from 'react';
+import { TrackPlayer } from '../index';
+import { callbackManager } from './callbackManager';
+/**
+ * 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() {
+    const [queue, setQueue] = useState([]);
+    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/lib/hooks/useDownloadActions.d.ts

@@ -0,0 +1,26 @@
+import type { DownloadConfig, PlaybackSource } from '../types/DownloadTypes';
+import type { TrackItem } from '../types/PlayerQueue';
+export interface UseDownloadActionsResult {
+    downloadTrack: (track: TrackItem, playlistId?: string) => Promise<string>;
+    downloadPlaylist: (playlistId: string, tracks: TrackItem[]) => Promise<string[]>;
+    pauseDownload: (downloadId: string) => Promise<void>;
+    resumeDownload: (downloadId: string) => Promise<void>;
+    cancelDownload: (downloadId: string) => Promise<void>;
+    retryDownload: (downloadId: string) => Promise<void>;
+    pauseAll: () => Promise<void>;
+    resumeAll: () => Promise<void>;
+    cancelAll: () => Promise<void>;
+    deleteTrack: (trackId: string) => Promise<void>;
+    deletePlaylist: (playlistId: string) => Promise<void>;
+    deleteAll: () => Promise<void>;
+    configure: (config: DownloadConfig) => void;
+    setPlaybackSourcePreference: (preference: PlaybackSource) => void;
+    getPlaybackSourcePreference: () => PlaybackSource;
+    isDownloading: boolean;
+    isDeleting: boolean;
+    error: Error | null;
+}
+/**
+ * Hook for download actions (download, pause, resume, cancel, delete)
+ */
+export declare function useDownloadActions(): UseDownloadActionsResult;

package/lib/hooks/useDownloadActions.js

@@ -0,0 +1,117 @@
+import { useCallback, useState } from 'react';
+import { DownloadManager } from '../index';
+/**
+ * Hook for download actions (download, pause, resume, cancel, delete)
+ */
+export function useDownloadActions() {
+    const [isDownloading, setIsDownloading] = useState(false);
+    const [isDeleting, setIsDeleting] = useState(false);
+    const [error, setError] = useState(null);
+    const downloadTrack = useCallback(async (track, playlistId) => {
+        setIsDownloading(true);
+        setError(null);
+        try {
+            const downloadId = await DownloadManager.downloadTrack(track, playlistId);
+            return downloadId;
+        }
+        catch (e) {
+            setError(e);
+            throw e;
+        }
+        finally {
+            setIsDownloading(false);
+        }
+    }, []);
+    const downloadPlaylist = useCallback(async (playlistId, tracks) => {
+        setIsDownloading(true);
+        setError(null);
+        try {
+            const downloadIds = await DownloadManager.downloadPlaylist(playlistId, tracks);
+            return downloadIds;
+        }
+        catch (e) {
+            setError(e);
+            throw e;
+        }
+        finally {
+            setIsDownloading(false);
+        }
+    }, []);
+    const pauseDownload = useCallback(async (downloadId) => {
+        await DownloadManager.pauseDownload(downloadId);
+    }, []);
+    const resumeDownload = useCallback(async (downloadId) => {
+        await DownloadManager.resumeDownload(downloadId);
+    }, []);
+    const cancelDownload = useCallback(async (downloadId) => {
+        await DownloadManager.cancelDownload(downloadId);
+    }, []);
+    const retryDownload = useCallback(async (downloadId) => {
+        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) => {
+        setIsDeleting(true);
+        try {
+            await DownloadManager.deleteDownloadedTrack(trackId);
+        }
+        finally {
+            setIsDeleting(false);
+        }
+    }, []);
+    const deletePlaylist = useCallback(async (playlistId) => {
+        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) => {
+        DownloadManager.configure(config);
+    }, []);
+    const setPlaybackSourcePreference = useCallback((preference) => {
+        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,
+    };
+}

package/lib/hooks/useDownloadProgress.d.ts

@@ -0,0 +1,25 @@
+import type { DownloadProgress } from '../types/DownloadTypes';
+export interface UseDownloadProgressOptions {
+    /** Track specific track ID(s) */
+    trackIds?: string[];
+    /** Track specific download ID(s) */
+    downloadIds?: string[];
+    /** Only track active downloads */
+    activeOnly?: boolean;
+}
+export interface UseDownloadProgressResult {
+    /** Map of trackId to DownloadProgress */
+    progressMap: Map<string, DownloadProgress>;
+    /** Array of all tracked progress */
+    progressList: DownloadProgress[];
+    /** Overall progress for tracked downloads (0-1) */
+    overallProgress: number;
+    /** Whether any download is in progress */
+    isDownloading: boolean;
+    /** Get progress for a specific track */
+    getProgress: (trackId: string) => DownloadProgress | undefined;
+}
+/**
+ * Hook for tracking download progress
+ */
+export declare function useDownloadProgress(options?: UseDownloadProgressOptions): UseDownloadProgressResult;

package/lib/hooks/useDownloadProgress.js

@@ -0,0 +1,79 @@
+import { useEffect, useState, useRef, useCallback } from 'react';
+import { DownloadManager } from '../index';
+import { downloadCallbackManager } from './downloadCallbackManager';
+/**
+ * Hook for tracking download progress
+ */
+export function useDownloadProgress(options = {}) {
+    const { trackIds, downloadIds, activeOnly = false } = options;
+    const [progressMap, setProgressMap] = useState(new Map());
+    const isMounted = useRef(true);
+    const shouldTrack = useCallback((progress) => {
+        if (trackIds &&
+            trackIds.length > 0 &&
+            !trackIds.includes(progress.trackId)) {
+            return false;
+        }
+        if (downloadIds &&
+            downloadIds.length > 0 &&
+            !downloadIds.includes(progress.downloadId)) {
+            return false;
+        }
+        if (activeOnly && progress.state !== 'downloading') {
+            return false;
+        }
+        return true;
+    }, [trackIds, downloadIds, activeOnly]);
+    useEffect(() => {
+        isMounted.current = true;
+        // Initialize with current active downloads
+        try {
+            const activeDownloads = DownloadManager.getActiveDownloads();
+            const initialMap = new Map();
+            activeDownloads.forEach((task) => {
+                if (shouldTrack(task.progress)) {
+                    initialMap.set(task.trackId, task.progress);
+                }
+            });
+            setProgressMap(initialMap);
+        }
+        catch (error) {
+            console.error('[useDownloadProgress] Error initializing:', error);
+        }
+        const unsubscribe = downloadCallbackManager.subscribeToProgress((progress) => {
+            if (!isMounted.current)
+                return;
+            if (!shouldTrack(progress))
+                return;
+            setProgressMap((prev) => {
+                const next = new Map(prev);
+                if (progress.state === 'completed' ||
+                    progress.state === 'cancelled') {
+                    next.delete(progress.trackId);
+                }
+                else {
+                    next.set(progress.trackId, progress);
+                }
+                return next;
+            });
+        });
+        return () => {
+            isMounted.current = false;
+            unsubscribe();
+        };
+    }, [shouldTrack]);
+    const progressList = Array.from(progressMap.values());
+    const overallProgress = progressList.length > 0
+        ? progressList.reduce((sum, p) => sum + p.progress, 0) /
+            progressList.length
+        : 0;
+    const isDownloading = progressList.some((p) => p.state === 'downloading');
+    const getProgress = useCallback((trackId) => progressMap.get(trackId), [progressMap]);
+    return {
+        progressMap,
+        progressList,
+        overallProgress,
+        isDownloading,
+        getProgress,
+    };
+}

package/lib/hooks/useDownloadStorage.d.ts

@@ -0,0 +1,19 @@
+import type { DownloadStorageInfo } from '../types/DownloadTypes';
+export interface UseDownloadStorageResult {
+    /** Storage information */
+    storageInfo: DownloadStorageInfo | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Refresh storage info */
+    refresh: () => Promise<void>;
+    /** Formatted total downloaded size (e.g., "2.5 GB") */
+    formattedSize: string;
+    /** Formatted available space (e.g., "10.2 GB") */
+    formattedAvailable: string;
+    /** Usage percentage (0-100) */
+    usagePercentage: number;
+}
+/**
+ * Hook for accessing download storage information
+ */
+export declare function useDownloadStorage(): UseDownloadStorageResult;

package/lib/hooks/useDownloadStorage.js

@@ -0,0 +1,60 @@
+import { useEffect, useState, useRef, useCallback } from 'react';
+import { DownloadManager } from '../index';
+/**
+ * Formats bytes into a human-readable string
+ */
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+/**
+ * Hook for accessing download storage information
+ */
+export function useDownloadStorage() {
+    const [storageInfo, setStorageInfo] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const isMounted = useRef(true);
+    const refresh = useCallback(async () => {
+        try {
+            const info = await DownloadManager.getStorageInfo();
+            if (isMounted.current) {
+                setStorageInfo(info);
+                setIsLoading(false);
+            }
+        }
+        catch (error) {
+            console.error('[useDownloadStorage] Error:', error);
+            if (isMounted.current) {
+                setIsLoading(false);
+            }
+        }
+    }, []);
+    useEffect(() => {
+        isMounted.current = true;
+        refresh();
+        return () => {
+            isMounted.current = false;
+        };
+    }, [refresh]);
+    const formattedSize = storageInfo
+        ? formatBytes(storageInfo.totalDownloadedSize)
+        : '0 B';
+    const formattedAvailable = storageInfo
+        ? formatBytes(storageInfo.availableSpace)
+        : '0 B';
+    const usagePercentage = storageInfo
+        ? (storageInfo.totalDownloadedSize / storageInfo.totalSpace) * 100
+        : 0;
+    return {
+        storageInfo,
+        isLoading,
+        refresh,
+        formattedSize,
+        formattedAvailable,
+        usagePercentage,
+    };
+}

package/lib/hooks/useDownloadedTracks.d.ts

@@ -0,0 +1,25 @@
+import type { DownloadedTrack, DownloadedPlaylist } from '../types/DownloadTypes';
+export interface UseDownloadedTracksResult {
+    /** All downloaded tracks */
+    downloadedTracks: DownloadedTrack[];
+    /** All downloaded playlists */
+    downloadedPlaylists: DownloadedPlaylist[];
+    /** Check if a track is downloaded */
+    isTrackDownloaded: (trackId: string) => boolean;
+    /** Check if a playlist is fully downloaded */
+    isPlaylistDownloaded: (playlistId: string) => boolean;
+    /** Check if a playlist is partially downloaded */
+    isPlaylistPartiallyDownloaded: (playlistId: string) => boolean;
+    /** Get downloaded track info */
+    getDownloadedTrack: (trackId: string) => DownloadedTrack | undefined;
+    /** Get downloaded playlist info */
+    getDownloadedPlaylist: (playlistId: string) => DownloadedPlaylist | undefined;
+    /** Refresh downloaded content list */
+    refresh: () => void;
+    /** Loading state */
+    isLoading: boolean;
+}
+/**
+ * Hook for accessing downloaded tracks and playlists
+ */
+export declare function useDownloadedTracks(): UseDownloadedTracksResult;

package/lib/hooks/useDownloadedTracks.js

@@ -0,0 +1,69 @@
+import { useEffect, useState, useRef, useCallback, useMemo } from 'react';
+import { DownloadManager } from '../index';
+import { downloadCallbackManager } from './downloadCallbackManager';
+/**
+ * Hook for accessing downloaded tracks and playlists
+ */
+export function useDownloadedTracks() {
+    const [downloadedTracks, setDownloadedTracks] = useState([]);
+    const [downloadedPlaylists, setDownloadedPlaylists] = useState([]);
+    const [isLoading, setIsLoading] = useState(true);
+    const isMounted = useRef(true);
+    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);
+            }
+        }
+    }, []);
+    useEffect(() => {
+        isMounted.current = true;
+        refresh();
+        const unsubscribeComplete = downloadCallbackManager.subscribeToComplete(() => {
+            refresh();
+        });
+        const unsubscribeStateChange = downloadCallbackManager.subscribeToStateChange((_downloadId, _trackId, state) => {
+            if (state === 'completed') {
+                refresh();
+            }
+        });
+        return () => {
+            isMounted.current = false;
+            unsubscribeComplete();
+            unsubscribeStateChange();
+        };
+    }, [refresh]);
+    const trackMap = useMemo(() => new Map(downloadedTracks.map((t) => [t.trackId, t])), [downloadedTracks]);
+    const playlistMap = useMemo(() => new Map(downloadedPlaylists.map((p) => [p.playlistId, p])), [downloadedPlaylists]);
+    const isTrackDownloaded = useCallback((trackId) => trackMap.has(trackId), [trackMap]);
+    const isPlaylistDownloaded = useCallback((playlistId) => {
+        const p = playlistMap.get(playlistId);
+        return p ? p.isComplete : false;
+    }, [playlistMap]);
+    const isPlaylistPartiallyDownloaded = useCallback((playlistId) => playlistMap.has(playlistId), [playlistMap]);
+    const getDownloadedTrack = useCallback((trackId) => trackMap.get(trackId), [trackMap]);
+    const getDownloadedPlaylist = useCallback((playlistId) => playlistMap.get(playlistId), [playlistMap]);
+    return {
+        downloadedTracks,
+        downloadedPlaylists,
+        isTrackDownloaded,
+        isPlaylistDownloaded,
+        isPlaylistPartiallyDownloaded,
+        getDownloadedTrack,
+        getDownloadedPlaylist,
+        refresh,
+        isLoading,
+    };
+}

package/lib/hooks/useEqualizer.d.ts

@@ -0,0 +1,25 @@
+import type { EqualizerBand } from '../types/EqualizerTypes';
+export interface UseEqualizerResult {
+    /** Whether the equalizer is enabled */
+    isEnabled: boolean;
+    /** Current band settings */
+    bands: EqualizerBand[];
+    /** Currently applied preset name */
+    currentPreset: string | null;
+    /** Toggle equalizer on/off */
+    setEnabled: (enabled: boolean) => boolean;
+    /** Set gain for a specific band */
+    setBandGain: (bandIndex: number, gainDb: number) => boolean;
+    /** Set all band gains at once */
+    setAllBandGains: (gains: number[]) => boolean;
+    /** Reset to flat response */
+    reset: () => void;
+    /** Whether equalizer is loading */
+    isLoading: boolean;
+    /** Gain range (min/max in dB) */
+    gainRange: {
+        min: number;
+        max: number;
+    };
+}
+export declare function useEqualizer(): UseEqualizerResult;