react-native-mp3 0.1.0

package/lib/hooks/useMusicPlayer.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMusicPlayer = void 0;
+const react_1 = require("react");
+const index_1 = require("../index");
+const defaultPlaybackState = {
+    isPlaying: false,
+    currentTime: 0,
+    duration: 0,
+    buffered: 0,
+    playbackRate: 1.0,
+    volume: 1.0,
+    repeatMode: 'none',
+    shuffleMode: false,
+    currentSong: undefined,
+    queue: [],
+    queuePosition: -1,
+    error: undefined,
+};
+const useMusicPlayer = ({ autoSetup = true, playerOptions, } = {}) => {
+    const [playbackState, setPlaybackState] = (0, react_1.useState)(defaultPlaybackState);
+    const [currentSong, setCurrentSong] = (0, react_1.useState)(null);
+    const [queue, setQueue] = (0, react_1.useState)([]);
+    const [isPlaying, setIsPlaying] = (0, react_1.useState)(false);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    // Initialize player
+    const initializePlayer = (0, react_1.useCallback)(async () => {
+        var _a, _b;
+        try {
+            setIsLoading(true);
+            setError(null);
+            // Setup background playback if options specify
+            if ((playerOptions === null || playerOptions === void 0 ? void 0 : playerOptions.audioFocus) !== false) {
+                index_1.Player.setupBackgroundPlayback({
+                    keepAwake: (_a = playerOptions === null || playerOptions === void 0 ? void 0 : playerOptions.keepAwake) !== null && _a !== void 0 ? _a : true,
+                    ducking: (_b = playerOptions === null || playerOptions === void 0 ? void 0 : playerOptions.ducking) !== null && _b !== void 0 ? _b : true,
+                });
+            }
+            // Get initial state
+            const state = await index_1.Player.getPlaybackState();
+            updateStateFromNative(state);
+        }
+        catch (err) {
+            setError(err.message || 'Failed to initialize player');
+            console.error('Error initializing player:', err);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [playerOptions]);
+    // Update state from native response
+    const updateStateFromNative = (0, react_1.useCallback)((state) => {
+        setPlaybackState({
+            isPlaying: state.isPlaying,
+            currentTime: state.currentTime,
+            duration: state.duration,
+            playbackRate: state.playbackRate,
+            volume: state.volume,
+            repeatMode: state.repeatMode,
+            shuffleMode: state.shuffleMode,
+            currentSong: state.currentSong,
+            queue: state.queue || [],
+            queuePosition: state.queuePosition,
+        });
+        setIsPlaying(state.isPlaying);
+        setCurrentSong(state.currentSong || null);
+        setQueue(state.queue || []);
+    }, []);
+    // Play a song by URI
+    const play = (0, react_1.useCallback)(async (uri) => {
+        try {
+            setIsLoading(true);
+            setError(null);
+            await index_1.Player.play(uri);
+        }
+        catch (err) {
+            setError(err.message || 'Failed to play song');
+            console.error('Error playing song:', err);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, []);
+    // Play a song object
+    const playSong = (0, react_1.useCallback)(async (song) => {
+        await play(song.uri);
+    }, [play]);
+    // Play from queue
+    const playFromQueue = (0, react_1.useCallback)((index) => {
+        index_1.Player.playFromQueue(index);
+    }, []);
+    // Pause playback
+    const pause = (0, react_1.useCallback)(() => {
+        index_1.Player.pause();
+    }, []);
+    // Stop playback
+    const stop = (0, react_1.useCallback)(() => {
+        index_1.Player.stop();
+    }, []);
+    // Seek to position
+    const seekTo = (0, react_1.useCallback)((position) => {
+        index_1.Player.seekTo(position);
+    }, []);
+    // Skip to next
+    const skipToNext = (0, react_1.useCallback)(() => {
+        index_1.Player.skipToNext();
+    }, []);
+    // Skip to previous
+    const skipToPrevious = (0, react_1.useCallback)(() => {
+        index_1.Player.skipToPrevious();
+    }, []);
+    // Set volume
+    const setVolume = (0, react_1.useCallback)((volume) => {
+        index_1.Player.setVolume(volume);
+    }, []);
+    // Set playback rate
+    const setPlaybackRate = (0, react_1.useCallback)((rate) => {
+        index_1.Player.setPlaybackRate(rate);
+    }, []);
+    // Set queue
+    const setQueueCallback = (0, react_1.useCallback)((songs) => {
+        index_1.Player.setQueue(songs);
+    }, []);
+    // Add to queue
+    const addToQueue = (0, react_1.useCallback)((songs) => {
+        index_1.Player.addToQueue(songs);
+    }, []);
+    // Clear queue
+    const clearQueue = (0, react_1.useCallback)(() => {
+        index_1.Player.clearQueue();
+    }, []);
+    // Get queue
+    const getQueue = (0, react_1.useCallback)(async () => {
+        return await index_1.Player.getQueue();
+    }, []);
+    // Set repeat mode
+    const setRepeatMode = (0, react_1.useCallback)((mode) => {
+        index_1.Player.setRepeatMode(mode);
+    }, []);
+    // Set shuffle mode
+    const setShuffleMode = (0, react_1.useCallback)((enabled) => {
+        index_1.Player.setShuffleMode(enabled);
+    }, []);
+    // Equalizer controls
+    const setEqualizerPreset = (0, react_1.useCallback)((preset) => {
+        index_1.Player.setEqualizerPreset(preset);
+    }, []);
+    const setEqualizerBands = (0, react_1.useCallback)((bands) => {
+        index_1.Player.setEqualizerBands(bands);
+    }, []);
+    const enableEqualizer = (0, react_1.useCallback)((enabled) => {
+        index_1.Player.enableEqualizer(enabled);
+    }, []);
+    // Background playback
+    const setupBackgroundPlayback = (0, react_1.useCallback)((config) => {
+        index_1.Player.setupBackgroundPlayback(config);
+    }, []);
+    const stopBackgroundPlayback = (0, react_1.useCallback)(() => {
+        index_1.Player.stopBackgroundPlayback();
+    }, []);
+    // Sleep timer
+    const setSleepTimer = (0, react_1.useCallback)((minutes) => {
+        index_1.Player.setSleepTimer(minutes);
+    }, []);
+    const cancelSleepTimer = (0, react_1.useCallback)(() => {
+        index_1.Player.cancelSleepTimer();
+    }, []);
+    // Set up event listeners
+    (0, react_1.useEffect)(() => {
+        if (!autoSetup)
+            return;
+        const playbackStateSub = index_1.Player.addEventListener(index_1.PlayerEvents.PLAYBACK_STATE_CHANGED, (data) => {
+            setPlaybackState(prev => (Object.assign(Object.assign({}, prev), { isPlaying: data.isPlaying, currentTime: data.currentTime, duration: data.duration, volume: data.volume, playbackRate: data.playbackRate })));
+            setIsPlaying(data.isPlaying);
+        });
+        const queueChangedSub = index_1.Player.addEventListener(index_1.PlayerEvents.PLAYBACK_QUEUE_CHANGED, (data) => {
+            setQueue(data.queue || []);
+            setPlaybackState(prev => (Object.assign(Object.assign({}, prev), { queue: data.queue || [], queuePosition: data.position })));
+        });
+        const playbackErrorSub = index_1.Player.addEventListener(index_1.PlayerEvents.PLAYBACK_ERROR, (data) => {
+            setError(data.error || 'Playback error');
+            setPlaybackState(prev => (Object.assign(Object.assign({}, prev), { error: data.error })));
+        });
+        const playbackCompleteSub = index_1.Player.addEventListener(index_1.PlayerEvents.PLAYBACK_COMPLETE, () => {
+            // Auto-play next is handled by native module
+        });
+        // Initialize player
+        initializePlayer();
+        return () => {
+            // Remove specific listeners
+            playbackStateSub.remove();
+            queueChangedSub.remove();
+            playbackErrorSub.remove();
+            playbackCompleteSub.remove();
+            // Clean up background playback if it was set up
+            if (autoSetup && (playerOptions === null || playerOptions === void 0 ? void 0 : playerOptions.audioFocus) !== false) {
+                index_1.Player.stopBackgroundPlayback();
+            }
+        };
+    }, [autoSetup, initializePlayer, playerOptions]);
+    return {
+        // State
+        playbackState,
+        currentSong,
+        queue,
+        isPlaying,
+        isLoading,
+        error,
+        // Playback Controls
+        play,
+        playSong,
+        playFromQueue,
+        pause,
+        stop,
+        seekTo,
+        skipToNext,
+        skipToPrevious,
+        setVolume,
+        setPlaybackRate,
+        // Queue Management
+        setQueue: setQueueCallback,
+        addToQueue,
+        clearQueue,
+        getQueue,
+        // Playback Modes
+        setRepeatMode,
+        setShuffleMode,
+        // Equalizer
+        setEqualizerPreset,
+        setEqualizerBands,
+        enableEqualizer,
+        // Background Playback
+        setupBackgroundPlayback,
+        stopBackgroundPlayback,
+        // Sleep Timer
+        setSleepTimer,
+        cancelSleepTimer,
+    };
+};
+exports.useMusicPlayer = useMusicPlayer;

package/lib/hooks/useMusicScanner.d.ts

@@ -0,0 +1,27 @@
+import type { Song, Album, Artist, ScannerOptions } from '../types/common.types';
+interface UseMusicScannerProps {
+    autoScan?: boolean;
+    scanOptions?: ScannerOptions;
+}
+interface UseMusicScannerReturn {
+    songs: Song[];
+    albums: Album[];
+    artists: Artist[];
+    isLoading: boolean;
+    isScanning: boolean;
+    scanProgress: number;
+    permissionGranted: boolean;
+    error: string | null;
+    scanMusic: (options?: ScannerOptions) => Promise<void>;
+    refresh: () => Promise<void>;
+    search: (query: string) => Promise<Song[]>;
+    deleteSong: (songId: string) => Promise<boolean>;
+    addToFavorites: (songId: string) => Promise<void>;
+    removeFromFavorites: (songId: string) => Promise<void>;
+    requestPermission: () => Promise<boolean>;
+    checkPermission: () => Promise<boolean>;
+    onScanProgress?: (progress: number) => void;
+    onScanComplete?: (totalSongs: number) => void;
+}
+export declare const useMusicScanner: ({ autoScan, scanOptions, }?: UseMusicScannerProps) => UseMusicScannerReturn;
+export {};

package/lib/hooks/useMusicScanner.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMusicScanner = void 0;
+const react_1 = require("react");
+const index_1 = require("../index");
+const useMusicScanner = ({ autoScan = true, scanOptions, } = {}) => {
+    const [songs, setSongs] = (0, react_1.useState)([]);
+    const [albums, setAlbums] = (0, react_1.useState)([]);
+    const [artists, setArtists] = (0, react_1.useState)([]);
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const [isScanning, setIsScanning] = (0, react_1.useState)(false);
+    const [scanProgress, setScanProgress] = (0, react_1.useState)(0);
+    const [permissionGranted, setPermissionGranted] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    // Load initial data
+    const loadInitialData = (0, react_1.useCallback)(async () => {
+        try {
+            setIsLoading(true);
+            setError(null);
+            const hasPermission = await index_1.Scanner.checkPermissionStatus();
+            setPermissionGranted(hasPermission);
+            if (hasPermission) {
+                const cachedSongs = await index_1.Scanner.getCachedSongs();
+                setSongs(cachedSongs);
+                const [albumsList, artistsList] = await Promise.all([
+                    index_1.Scanner.getAlbums(),
+                    index_1.Scanner.getArtists(),
+                ]);
+                setAlbums(albumsList);
+                setArtists(artistsList);
+            }
+        }
+        catch (err) {
+            setError(err.message || 'Failed to load music library');
+            console.error('Error loading music library:', err);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, []);
+    // Scan music files
+    const scanMusic = (0, react_1.useCallback)(async (options) => {
+        try {
+            setIsScanning(true);
+            setScanProgress(0);
+            setError(null);
+            const hasPermission = await index_1.Scanner.checkPermissionStatus();
+            if (!hasPermission) {
+                const granted = await index_1.Scanner.requestStoragePermission();
+                if (!granted) {
+                    setError('Storage permission is required to scan music files');
+                    setIsScanning(false);
+                    return;
+                }
+                setPermissionGranted(true);
+            }
+            const scanOpts = options || scanOptions || {};
+            const result = await index_1.Scanner.scanMusicFiles(scanOpts);
+            // Reload data after scan
+            await loadInitialData();
+            return result;
+        }
+        catch (err) {
+            setError(err.message || 'Failed to scan music files');
+            console.error('Error scanning music files:', err);
+            throw err;
+        }
+        finally {
+            setIsScanning(false);
+            setScanProgress(0);
+        }
+    }, [scanOptions, loadInitialData]);
+    // Refresh data
+    const refresh = (0, react_1.useCallback)(async () => {
+        await loadInitialData();
+    }, [loadInitialData]);
+    // Search songs
+    const search = (0, react_1.useCallback)(async (query) => {
+        if (!query.trim()) {
+            return songs;
+        }
+        try {
+            const results = await index_1.Scanner.searchSongs(query);
+            return results;
+        }
+        catch (err) {
+            setError(err.message || 'Search failed');
+            console.error('Error searching songs:', err);
+            return [];
+        }
+    }, [songs]);
+    // Delete song
+    const deleteSong = (0, react_1.useCallback)(async (songId) => {
+        try {
+            const success = await index_1.Scanner.deleteSong(songId);
+            if (success) {
+                // Remove from local state
+                setSongs(prev => prev.filter(song => song.id !== songId));
+                // Update albums and artists
+                await refresh();
+            }
+            return success;
+        }
+        catch (err) {
+            setError(err.message || 'Failed to delete song');
+            console.error('Error deleting song:', err);
+            return false;
+        }
+    }, [refresh]);
+    // Add to favorites
+    const addToFavorites = (0, react_1.useCallback)(async (songId) => {
+        try {
+            await index_1.Scanner.addToFavorites(songId);
+            // Update local state
+            setSongs(prev => prev.map(song => song.id === songId ? Object.assign(Object.assign({}, song), { isFavorite: true }) : song));
+        }
+        catch (err) {
+            setError(err.message || 'Failed to add to favorites');
+            console.error('Error adding to favorites:', err);
+        }
+    }, []);
+    // Remove from favorites
+    const removeFromFavorites = (0, react_1.useCallback)(async (songId) => {
+        try {
+            await index_1.Scanner.removeFromFavorites(songId);
+            // Update local state
+            setSongs(prev => prev.map(song => song.id === songId ? Object.assign(Object.assign({}, song), { isFavorite: false }) : song));
+        }
+        catch (err) {
+            setError(err.message || 'Failed to remove from favorites');
+            console.error('Error removing from favorites:', err);
+        }
+    }, []);
+    // Request permission
+    const requestPermission = (0, react_1.useCallback)(async () => {
+        try {
+            const granted = await index_1.Scanner.requestStoragePermission();
+            setPermissionGranted(granted);
+            return granted;
+        }
+        catch (err) {
+            setError(err.message || 'Failed to request permission');
+            console.error('Error requesting permission:', err);
+            return false;
+        }
+    }, []);
+    // Check permission
+    const checkPermission = (0, react_1.useCallback)(async () => {
+        try {
+            const granted = await index_1.Scanner.checkPermissionStatus();
+            setPermissionGranted(granted);
+            return granted;
+        }
+        catch (err) {
+            setError(err.message || 'Failed to check permission');
+            console.error('Error checking permission:', err);
+            return false;
+        }
+    }, []);
+    // Set up event listeners
+    (0, react_1.useEffect)(() => {
+        const scanProgressSub = index_1.Scanner.addEventListener(index_1.ScannerEvents.SCAN_PROGRESS, (data) => {
+            setScanProgress(data.percentage);
+        });
+        const scanCompleteSub = index_1.Scanner.addEventListener(index_1.ScannerEvents.SCAN_COMPLETE, () => {
+            loadInitialData();
+        });
+        const fileAddedSub = index_1.Scanner.addEventListener(index_1.ScannerEvents.FILE_ADDED, () => {
+            loadInitialData();
+        });
+        const fileDeletedSub = index_1.Scanner.addEventListener(index_1.ScannerEvents.FILE_DELETED, () => {
+            loadInitialData();
+        });
+        const permissionSub = index_1.Scanner.addEventListener(index_1.ScannerEvents.PERMISSION_STATUS, (data) => {
+            setPermissionGranted(data.granted);
+        });
+        // Auto scan on mount if enabled
+        if (autoScan && permissionGranted) {
+            loadInitialData();
+        }
+        return () => {
+            // Remove specific listeners instead of all
+            scanProgressSub.remove();
+            scanCompleteSub.remove();
+            fileAddedSub.remove();
+            fileDeletedSub.remove();
+            permissionSub.remove();
+            // If you want to remove all listeners:
+            // Scanner.removeAllListeners(ScannerEvents.SCAN_PROGRESS);
+            // Scanner.removeAllListeners(ScannerEvents.SCAN_COMPLETE);
+            // Scanner.removeAllListeners(ScannerEvents.FILE_ADDED);
+            // Scanner.removeAllListeners(ScannerEvents.FILE_DELETED);
+            // Scanner.removeAllListeners(ScannerEvents.PERMISSION_STATUS);
+        };
+    }, [autoScan, loadInitialData, permissionGranted]);
+    return {
+        // State
+        songs,
+        albums,
+        artists,
+        isLoading,
+        isScanning,
+        scanProgress,
+        permissionGranted,
+        error,
+        // Methods
+        scanMusic,
+        refresh,
+        search,
+        deleteSong,
+        addToFavorites,
+        removeFromFavorites,
+        requestPermission,
+        checkPermission,
+    };
+};
+exports.useMusicScanner = useMusicScanner;

package/lib/hooks/usePermissions.d.ts

@@ -0,0 +1,9 @@
+interface UsePermissionsReturn {
+    permissionGranted: boolean;
+    isChecking: boolean;
+    error: string | null;
+    requestPermission: () => Promise<boolean>;
+    checkPermission: () => Promise<boolean>;
+}
+export declare const usePermissions: () => UsePermissionsReturn;
+export {};

package/lib/hooks/usePermissions.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePermissions = void 0;
+const react_1 = require("react");
+const index_1 = require("../index");
+const usePermissions = () => {
+    const [permissionGranted, setPermissionGranted] = (0, react_1.useState)(false);
+    const [isChecking, setIsChecking] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const checkPermission = async () => {
+        try {
+            setIsChecking(true);
+            setError(null);
+            const granted = await index_1.Scanner.checkPermissionStatus();
+            setPermissionGranted(granted);
+            return granted;
+        }
+        catch (err) {
+            setError(err.message || 'Failed to check permission');
+            console.error('Error checking permission:', err);
+            return false;
+        }
+        finally {
+            setIsChecking(false);
+        }
+    };
+    const requestPermission = async () => {
+        try {
+            setIsChecking(true);
+            setError(null);
+            const granted = await index_1.Scanner.requestStoragePermission();
+            setPermissionGranted(granted);
+            return granted;
+        }
+        catch (err) {
+            setError(err.message || 'Failed to request permission');
+            console.error('Error requesting permission:', err);
+            return false;
+        }
+        finally {
+            setIsChecking(false);
+        }
+    };
+    (0, react_1.useEffect)(() => {
+        checkPermission();
+    }, []);
+    return {
+        permissionGranted,
+        isChecking,
+        error,
+        requestPermission,
+        checkPermission,
+    };
+};
+exports.usePermissions = usePermissions;