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

package/lib/hooks/useEqualizer.js

@@ -0,0 +1,124 @@
+import { useEffect, useState, useCallback, useRef } from 'react';
+import { Equalizer } from '../index';
+import { equalizerCallbackManager } from './equalizerCallbackManager';
+const DEFAULT_BANDS = [
+    { index: 0, centerFrequency: 60, gainDb: 0, frequencyLabel: '60 Hz' },
+    { index: 1, centerFrequency: 230, gainDb: 0, frequencyLabel: '230 Hz' },
+    { index: 2, centerFrequency: 910, gainDb: 0, frequencyLabel: '910 Hz' },
+    { index: 3, centerFrequency: 3600, gainDb: 0, frequencyLabel: '3.6 kHz' },
+    { index: 4, centerFrequency: 14000, gainDb: 0, frequencyLabel: '14 kHz' },
+];
+export function useEqualizer() {
+    const [isEnabled, setIsEnabledState] = useState(false);
+    const [bands, setBands] = useState(DEFAULT_BANDS);
+    const [currentPreset, setCurrentPreset] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const [gainRange, setGainRange] = useState({ min: -12, max: 12 });
+    const isMounted = useRef(true);
+    // Load initial state
+    useEffect(() => {
+        isMounted.current = true;
+        const loadState = async () => {
+            try {
+                const state = Equalizer.getState();
+                if (isMounted.current) {
+                    setIsEnabledState(state.enabled);
+                    setBands(state.bands);
+                    setCurrentPreset(state.currentPreset);
+                    const range = Equalizer.getBandRange();
+                    setGainRange({ min: range.min, max: range.max });
+                    setIsLoading(false);
+                }
+            }
+            catch (error) {
+                console.error('[useEqualizer] Error loading state:', error);
+                if (isMounted.current) {
+                    setIsLoading(false);
+                }
+            }
+        };
+        loadState();
+        return () => {
+            isMounted.current = false;
+        };
+    }, []);
+    // Subscribe to enabled changes
+    useEffect(() => {
+        const unsubscribe = equalizerCallbackManager.subscribeToEnabledChange((enabled) => {
+            if (isMounted.current) {
+                setIsEnabledState(enabled);
+            }
+        });
+        return unsubscribe;
+    }, []);
+    // Subscribe to band changes
+    useEffect(() => {
+        const unsubscribe = equalizerCallbackManager.subscribeToBandChange((newBands) => {
+            if (isMounted.current) {
+                setBands(newBands);
+            }
+        });
+        return unsubscribe;
+    }, []);
+    // Subscribe to preset changes
+    useEffect(() => {
+        const unsubscribe = equalizerCallbackManager.subscribeToPresetChange((presetName) => {
+            if (isMounted.current) {
+                setCurrentPreset(presetName);
+            }
+        });
+        return unsubscribe;
+    }, []);
+    const setEnabled = useCallback((enabled) => {
+        try {
+            return Equalizer.setEnabled(enabled);
+        }
+        catch (error) {
+            console.error('[useEqualizer] Error setting enabled:', error);
+            return false;
+        }
+    }, []);
+    const setBandGain = useCallback((bandIndex, gainDb) => {
+        // Optimistic update
+        setBands((prevBands) => prevBands.map((b) => (b.index === bandIndex ? { ...b, gainDb } : b)));
+        try {
+            return Equalizer.setBandGain(bandIndex, gainDb);
+        }
+        catch (error) {
+            console.error('[useEqualizer] Error setting band gain:', error);
+            return false;
+        }
+    }, []);
+    const setAllBandGains = useCallback((gains) => {
+        // Optimistic update
+        setBands((prevBands) => prevBands.map((b, i) => ({ ...b, gainDb: gains[i] ?? b.gainDb })));
+        try {
+            return Equalizer.setAllBandGains(gains);
+        }
+        catch (error) {
+            console.error('[useEqualizer] Error setting all band gains:', error);
+            return false;
+        }
+    }, []);
+    const reset = useCallback(() => {
+        // Optimistic update
+        setBands((prevBands) => prevBands.map((b) => ({ ...b, gainDb: 0 })));
+        try {
+            Equalizer.reset();
+        }
+        catch (error) {
+            console.error('[useEqualizer] Error resetting equalizer:', error);
+        }
+    }, []);
+    return {
+        isEnabled,
+        bands,
+        currentPreset,
+        setEnabled,
+        setBandGain,
+        setAllBandGains,
+        reset,
+        isLoading,
+        gainRange,
+    };
+}

package/lib/hooks/useEqualizerPresets.d.ts

@@ -0,0 +1,22 @@
+import type { EqualizerPreset } from '../types/EqualizerTypes';
+export interface UseEqualizerPresetsResult {
+    /** All available presets */
+    presets: EqualizerPreset[];
+    /** Built-in presets only */
+    builtInPresets: EqualizerPreset[];
+    /** Custom user presets */
+    customPresets: EqualizerPreset[];
+    /** Apply a preset by name */
+    applyPreset: (name: string) => boolean;
+    /** Save current settings as custom preset */
+    saveCustomPreset: (name: string) => boolean;
+    /** Delete a custom preset */
+    deleteCustomPreset: (name: string) => boolean;
+    /** Currently applied preset name */
+    currentPreset: string | null;
+    /** Whether presets are loading */
+    isLoading: boolean;
+    /** Refresh presets from native */
+    refreshPresets: () => void;
+}
+export declare function useEqualizerPresets(): UseEqualizerPresetsResult;

package/lib/hooks/useEqualizerPresets.js

@@ -0,0 +1,96 @@
+import { useEffect, useState, useCallback, useRef } from 'react';
+import { Equalizer } from '../index';
+import { equalizerCallbackManager } from './equalizerCallbackManager';
+export function useEqualizerPresets() {
+    const [presets, setPresets] = useState([]);
+    const [builtInPresets, setBuiltInPresets] = useState([]);
+    const [customPresets, setCustomPresets] = useState([]);
+    const [currentPreset, setCurrentPreset] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const isMounted = useRef(true);
+    const refreshPresets = useCallback(() => {
+        try {
+            const allPresets = Equalizer.getPresets();
+            const builtIn = Equalizer.getBuiltInPresets();
+            const custom = Equalizer.getCustomPresets();
+            const current = Equalizer.getCurrentPresetName();
+            if (isMounted.current) {
+                setPresets(allPresets);
+                setBuiltInPresets(builtIn);
+                setCustomPresets(custom);
+                setCurrentPreset(current);
+            }
+        }
+        catch (error) {
+            console.error('[useEqualizerPresets] Error refreshing presets:', error);
+        }
+    }, []);
+    // Load initial presets
+    useEffect(() => {
+        isMounted.current = true;
+        refreshPresets();
+        setIsLoading(false);
+        return () => {
+            isMounted.current = false;
+        };
+    }, [refreshPresets]);
+    // Subscribe to preset changes
+    useEffect(() => {
+        const unsubscribe = equalizerCallbackManager.subscribeToPresetChange((presetName) => {
+            if (isMounted.current) {
+                setCurrentPreset(presetName);
+            }
+        });
+        return unsubscribe;
+    }, []);
+    const applyPreset = useCallback((name) => {
+        try {
+            const success = Equalizer.applyPreset(name);
+            if (success) {
+                setCurrentPreset(name);
+            }
+            return success;
+        }
+        catch (error) {
+            console.error('[useEqualizerPresets] Error applying preset:', error);
+            return false;
+        }
+    }, []);
+    const saveCustomPreset = useCallback((name) => {
+        try {
+            const success = Equalizer.saveCustomPreset(name);
+            if (success) {
+                refreshPresets();
+            }
+            return success;
+        }
+        catch (error) {
+            console.error('[useEqualizerPresets] Error saving custom preset:', error);
+            return false;
+        }
+    }, [refreshPresets]);
+    const deleteCustomPreset = useCallback((name) => {
+        try {
+            const success = Equalizer.deleteCustomPreset(name);
+            if (success) {
+                refreshPresets();
+            }
+            return success;
+        }
+        catch (error) {
+            console.error('[useEqualizerPresets] Error deleting custom preset:', error);
+            return false;
+        }
+    }, [refreshPresets]);
+    return {
+        presets,
+        builtInPresets,
+        customPresets,
+        applyPreset,
+        saveCustomPreset,
+        deleteCustomPreset,
+        currentPreset,
+        isLoading,
+        refreshPresets,
+    };
+}

package/lib/hooks/useNowPlaying.js

@@ -8,6 +8,7 @@ const DEFAULT_STATE = {
     currentState: 'stopped',
     currentPlaylistId: null,
     currentIndex: -1,
+    currentPlayingType: 'not-playing',
 };
 /**
  * Hook to get the current player state (same as TrackPlayer.getState())
@@ -46,12 +47,14 @@ const DEFAULT_STATE = {
 export function useNowPlaying() {
     const [state, setState] = useState(DEFAULT_STATE);
     const isMounted = useRef(true);
-    const updateState = useCallback(() => {
+    const fetchFullState = useCallback(async () => {
         if (!isMounted.current)
             return;
         try {
-            const newState = TrackPlayer.getState();
-            setState(newState);
+            const newState = await TrackPlayer.getState();
+            if (isMounted.current) {
+                setState(newState);
+            }
         }
         catch (error) {
             console.error('[useNowPlaying] Error updating player state:', error);
@@ -60,28 +63,38 @@ export function useNowPlaying() {
     // Initialize with current state
     useEffect(() => {
         isMounted.current = true;
-        updateState();
+        fetchFullState();
         return () => {
             isMounted.current = false;
         };
-    }, [updateState]);
-    // Subscribe to track changes
+    }, [fetchFullState]);
+    // Subscribe to track changes — full refresh
     useEffect(() => {
-        const unsubscribe = callbackManager.subscribeToTrackChange(() => {
-            updateState();
+        return callbackManager.subscribeToTrackChange(() => {
+            fetchFullState();
         });
-        return () => {
-            unsubscribe();
-        };
-    }, [updateState]);
-    // Subscribe to playback state changes
+    }, [fetchFullState]);
+    // Subscribe to playback state changes — full refresh
     useEffect(() => {
-        const unsubscribe = callbackManager.subscribeToPlaybackState(() => {
-            updateState();
+        return callbackManager.subscribeToPlaybackState(() => {
+            fetchFullState();
         });
-        return () => {
-            unsubscribe();
-        };
-    }, [updateState]);
+    }, [fetchFullState]);
+    // Subscribe to progress changes — lightweight position/duration update
+    useEffect(() => {
+        return callbackManager.subscribeToPlaybackProgressChange((currentPosition, totalDuration) => {
+            if (!isMounted.current)
+                return;
+            setState((prev) => ({ ...prev, currentPosition, totalDuration }));
+        });
+    }, []);
+    // Subscribe to seek events — lightweight position/duration update
+    useEffect(() => {
+        return callbackManager.subscribeToSeek((currentPosition, totalDuration) => {
+            if (!isMounted.current)
+                return;
+            setState((prev) => ({ ...prev, currentPosition, totalDuration }));
+        });
+    }, []);
     return state;
 }

package/lib/hooks/useOnChangeTrack.js

@@ -38,20 +38,23 @@ export function useOnChangeTrack() {
     // Initialize with current track from the player
     useEffect(() => {
         isMounted.current = true;
-        try {
-            const playerState = TrackPlayer.getState();
-            if (isMounted.current) {
-                setTrack(playerState.currentTrack);
-                setIsReady(true);
+        const initializeTrack = async () => {
+            try {
+                const playerState = await TrackPlayer.getState();
+                if (isMounted.current) {
+                    setTrack(playerState.currentTrack);
+                    setIsReady(true);
+                }
             }
-        }
-        catch (error) {
-            console.error('[useOnChangeTrack] Failed to get initial state:', error);
-            if (isMounted.current) {
-                setTrack(null);
-                setIsReady(true);
+            catch (error) {
+                console.error('[useOnChangeTrack] Failed to get initial state:', error);
+                if (isMounted.current) {
+                    setTrack(null);
+                    setIsReady(true);
+                }
             }
-        }
+        };
+        initializeTrack();
         return () => {
             isMounted.current = false;
         };

package/lib/hooks/useOnPlaybackProgressChange.js

@@ -1,5 +1,5 @@
 import { useEffect, useState } from 'react';
-import { TrackPlayer } from '../index';
+import { callbackManager } from './callbackManager';
 /**
  * Hook to get the current playback progress
  * @returns Object with current position, total duration, and manual seek indicator
@@ -9,7 +9,7 @@ export function useOnPlaybackProgressChange() {
     const [totalDuration, setTotalDuration] = useState(0);
     const [isManuallySeeked, setIsManuallySeeked] = useState(undefined);
     useEffect(() => {
-        TrackPlayer.onPlaybackProgressChange((newPosition, newTotalDuration, newIsManuallySeeked) => {
+        return callbackManager.subscribeToPlaybackProgressChange((newPosition, newTotalDuration, newIsManuallySeeked) => {
             setPosition(newPosition);
             setTotalDuration(newTotalDuration);
             setIsManuallySeeked(newIsManuallySeeked);

package/lib/hooks/useOnPlaybackStateChange.js

@@ -37,21 +37,24 @@ export function useOnPlaybackStateChange() {
     // Initialize with current state from the player
     useEffect(() => {
         isMounted.current = true;
-        // Get initial state synchronously
-        try {
-            const playerState = TrackPlayer.getState();
-            if (isMounted.current) {
-                setState(playerState.currentState);
-                setIsReady(true);
+        // Get initial state asynchronously
+        const initializeState = async () => {
+            try {
+                const playerState = await TrackPlayer.getState();
+                if (isMounted.current) {
+                    setState(playerState.currentState);
+                    setIsReady(true);
+                }
             }
-        }
-        catch (error) {
-            console.error('[useOnPlaybackStateChange] Failed to get initial state:', error);
-            if (isMounted.current) {
-                setState('stopped');
-                setIsReady(true);
+            catch (error) {
+                console.error('[useOnPlaybackStateChange] Failed to get initial state:', error);
+                if (isMounted.current) {
+                    setState('stopped');
+                    setIsReady(true);
+                }
             }
-        }
+        };
+        initializeState();
         return () => {
             isMounted.current = false;
         };

package/lib/hooks/usePlaylist.d.ts

@@ -0,0 +1,48 @@
+import type { Playlist, TrackItem } from '../types/PlayerQueue';
+export interface UsePlaylistResult {
+    /** The currently loaded playlist */
+    currentPlaylist: Playlist | null;
+    /** ID of the currently loaded playlist */
+    currentPlaylistId: string | null;
+    /** All available playlists */
+    allPlaylists: Playlist[];
+    /** All tracks from all playlists (flattened) */
+    allTracks: TrackItem[];
+    /** Whether the playlists are currently loading */
+    isLoading: boolean;
+    /** Manually refresh playlist data */
+    refreshPlaylists: () => void;
+}
+/**
+ * Hook to manage playlist state
+ *
+ * Provides current playlist, all playlists, and all tracks across playlists.
+ * Automatically refreshes when:
+ * - Component mounts
+ * - Track changes (to update currentPlaylistId)
+ * - Playlists are modified via PlayerQueue methods
+ *
+ * Call `refreshPlaylists()` after creating/deleting playlists to update the state.
+ *
+ * @returns Object containing playlist state and refresh function
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { currentPlaylist, allTracks, refreshPlaylists } = usePlaylist();
+ *
+ *   const handleCreatePlaylist = () => {
+ *     PlayerQueue.createPlaylist('New Playlist');
+ *     refreshPlaylists(); // Refresh to see the new playlist
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       <Text>{currentPlaylist?.name}</Text>
+ *       <Text>Total tracks: {allTracks.length}</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+export declare function usePlaylist(): UsePlaylistResult;

package/lib/hooks/usePlaylist.js

@@ -0,0 +1,136 @@
+import { useEffect, useState, useRef, useCallback } from 'react';
+import { PlayerQueue } from '../index';
+import { callbackManager } from './callbackManager';
+/**
+ * Hook to manage playlist state
+ *
+ * Provides current playlist, all playlists, and all tracks across playlists.
+ * Automatically refreshes when:
+ * - Component mounts
+ * - Track changes (to update currentPlaylistId)
+ * - Playlists are modified via PlayerQueue methods
+ *
+ * Call `refreshPlaylists()` after creating/deleting playlists to update the state.
+ *
+ * @returns Object containing playlist state and refresh function
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { currentPlaylist, allTracks, refreshPlaylists } = usePlaylist();
+ *
+ *   const handleCreatePlaylist = () => {
+ *     PlayerQueue.createPlaylist('New Playlist');
+ *     refreshPlaylists(); // Refresh to see the new playlist
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       <Text>{currentPlaylist?.name}</Text>
+ *       <Text>Total tracks: {allTracks.length}</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+export function usePlaylist() {
+    const [currentPlaylist, setCurrentPlaylist] = useState(null);
+    const [currentPlaylistId, setCurrentPlaylistId] = useState(null);
+    const [allPlaylists, setAllPlaylists] = useState([]);
+    const [allTracks, setAllTracks] = useState([]);
+    const [isLoading, setIsLoading] = useState(true);
+    const isMounted = useRef(true);
+    const hasSubscribed = useRef(false);
+    const refreshPlaylists = useCallback(() => {
+        if (!isMounted.current)
+            return;
+        try {
+            // Get current playlist ID
+            const playlistId = PlayerQueue.getCurrentPlaylistId();
+            if (!isMounted.current)
+                return;
+            setCurrentPlaylistId(playlistId);
+            // Get current playlist details
+            if (playlistId) {
+                const playlist = PlayerQueue.getPlaylist(playlistId);
+                if (isMounted.current) {
+                    setCurrentPlaylist(playlist);
+                }
+            }
+            else {
+                if (isMounted.current) {
+                    setCurrentPlaylist(null);
+                }
+            }
+            // Get all playlists
+            const playlists = PlayerQueue.getAllPlaylists();
+            if (!isMounted.current)
+                return;
+            setAllPlaylists(playlists);
+            // Get all tracks from all playlists (deduplicated by id)
+            const trackMap = new Map();
+            playlists.forEach((playlist) => {
+                playlist.tracks.forEach((track) => {
+                    if (!trackMap.has(track.id)) {
+                        trackMap.set(track.id, track);
+                    }
+                });
+            });
+            if (isMounted.current) {
+                setAllTracks(Array.from(trackMap.values()));
+                setIsLoading(false);
+            }
+        }
+        catch (error) {
+            console.error('[usePlaylist] Error refreshing playlists:', error);
+            if (isMounted.current) {
+                setIsLoading(false);
+            }
+        }
+    }, []);
+    // Initialize and setup mounted ref
+    useEffect(() => {
+        isMounted.current = true;
+        // Initial load
+        refreshPlaylists();
+        return () => {
+            isMounted.current = false;
+        };
+    }, [refreshPlaylists]);
+    // Subscribe to native playlist changes (only once)
+    useEffect(() => {
+        if (hasSubscribed.current)
+            return;
+        hasSubscribed.current = true;
+        try {
+            PlayerQueue.onPlaylistsChanged(() => {
+                if (isMounted.current) {
+                    refreshPlaylists();
+                }
+            });
+        }
+        catch (error) {
+            console.error('[usePlaylist] Error setting up playlist listener:', error);
+        }
+    }, [refreshPlaylists]);
+    // Also refresh when track changes (as it might indicate playlist loaded)
+    useEffect(() => {
+        const unsubscribe = callbackManager.subscribeToTrackChange(() => {
+            // Refresh to update currentPlaylistId when track changes
+            if (isMounted.current) {
+                refreshPlaylists();
+            }
+        });
+        return () => {
+            unsubscribe();
+        };
+    }, [refreshPlaylists]);
+    return {
+        currentPlaylist,
+        currentPlaylistId,
+        allPlaylists,
+        allTracks,
+        isLoading,
+        refreshPlaylists,
+    };
+}

package/lib/index.d.ts

@@ -2,14 +2,20 @@ import type { PlayerQueue as PlayerQueueType, TrackPlayer as TrackPlayerType } f
 import type { AndroidAutoMediaLibrary as AndroidAutoMediaLibraryType } from './specs/AndroidAutoMediaLibrary.nitro';
 import type { AudioDevices as AudioDevicesType } from './specs/AudioDevices.nitro';
 import type { AudioRoutePicker as AudioRoutePickerType } from './specs/AudioRoutePicker.nitro';
+import type { DownloadManager as DownloadManagerType } from './specs/DownloadManager.nitro';
+import type { Equalizer as EqualizerType } from './specs/Equalizer.nitro';
 export declare const PlayerQueue: PlayerQueueType;
 export declare const TrackPlayer: TrackPlayerType;
 export declare const AndroidAutoMediaLibrary: AndroidAutoMediaLibraryType | null;
 export declare const AudioDevices: AudioDevicesType | null;
 export declare const AudioRoutePicker: AudioRoutePickerType | null;
+export declare const DownloadManager: DownloadManagerType;
+export declare const Equalizer: EqualizerType;
 export * from './hooks';
 export * from './types/PlayerQueue';
 export * from './types/AndroidAutoMediaLibrary';
+export * from './types/DownloadTypes';
+export * from './types/EqualizerTypes';
 export type { TAudioDevice } from './specs/AudioDevices.nitro';
 export type { RepeatMode } from './specs/TrackPlayer.nitro';
 export { AndroidAutoMediaLibraryHelper } from './utils/androidAutoMediaLibrary';

package/lib/index.js

@@ -15,10 +15,16 @@ export const AudioDevices = Platform.OS === 'android'
 export const AudioRoutePicker = Platform.OS === 'ios'
     ? NitroModules.createHybridObject('AudioRoutePicker')
     : null;
+// Download Manager
+export const DownloadManager = NitroModules.createHybridObject('DownloadManager');
+// Equalizer
+export const Equalizer = NitroModules.createHybridObject('Equalizer');
 // Export hooks
 export * from './hooks';
 // Export types
 export * from './types/PlayerQueue';
 export * from './types/AndroidAutoMediaLibrary';
+export * from './types/DownloadTypes';
+export * from './types/EqualizerTypes';
 // Export utilities
 export { AndroidAutoMediaLibraryHelper } from './utils/androidAutoMediaLibrary';