react-native-mp3 0.1.0

package/src/hooks/useMusicPlayer.ts

@@ -0,0 +1,358 @@
+import { useState, useEffect, useCallback } from 'react';
+import { Player, PlayerEvents } from '../index';
+import type { Song, PlaybackState, PlayerOptions } from '../types/common.types';
+
+interface UseMusicPlayerProps {
+  autoSetup?: boolean;
+  playerOptions?: PlayerOptions;
+}
+
+interface UseMusicPlayerReturn {
+  // State
+  playbackState: PlaybackState;
+  currentSong: Song | null;
+  queue: Song[];
+  isPlaying: boolean;
+  isLoading: boolean;
+  error: string | null;
+  
+  // Playback Controls
+  play: (uri: string) => Promise<void>;
+  playSong: (song: Song) => Promise<void>;
+  playFromQueue: (index: number) => void;
+  pause: () => void;
+  stop: () => void;
+  seekTo: (position: number) => void;
+  skipToNext: () => void;
+  skipToPrevious: () => void;
+  setVolume: (volume: number) => void;
+  setPlaybackRate: (rate: number) => void;
+  
+  // Queue Management
+  setQueue: (songs: Song[]) => void;
+  addToQueue: (songs: Song[]) => void;
+  clearQueue: () => void;
+  getQueue: () => Promise<Song[]>;
+  
+  // Playback Modes
+  setRepeatMode: (mode: 'none' | 'one' | 'all') => void;
+  setShuffleMode: (enabled: boolean) => void;
+  
+  // Equalizer
+  setEqualizerPreset: (preset: string) => void;
+  setEqualizerBands: (bands: number[]) => void;
+  enableEqualizer: (enabled: boolean) => void;
+  
+  // Background Playback
+  setupBackgroundPlayback: (config?: any) => void;
+  stopBackgroundPlayback: () => void;
+  
+  // Sleep Timer
+  setSleepTimer: (minutes: number) => void;
+  cancelSleepTimer: () => void;
+}
+
+const defaultPlaybackState: PlaybackState = {
+  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,
+};
+
+export const useMusicPlayer = ({
+  autoSetup = true,
+  playerOptions,
+}: UseMusicPlayerProps = {}): UseMusicPlayerReturn => {
+  const [playbackState, setPlaybackState] = useState<PlaybackState>(defaultPlaybackState);
+  const [currentSong, setCurrentSong] = useState<Song | null>(null);
+  const [queue, setQueue] = useState<Song[]>([]);
+  const [isPlaying, setIsPlaying] = useState<boolean>(false);
+  const [isLoading, setIsLoading] = useState<boolean>(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Initialize player
+  const initializePlayer = useCallback(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      
+      // Setup background playback if options specify
+      if (playerOptions?.audioFocus !== false) {
+        Player.setupBackgroundPlayback({
+          keepAwake: playerOptions?.keepAwake ?? true,
+          ducking: playerOptions?.ducking ?? true,
+        });
+      }
+      
+      // Get initial state
+      const state = await Player.getPlaybackState();
+      updateStateFromNative(state);
+      
+    } catch (err: any) {
+      setError(err.message || 'Failed to initialize player');
+      console.error('Error initializing player:', err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [playerOptions]);
+
+  // Update state from native response
+  const updateStateFromNative = useCallback((state: any) => {
+    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 = useCallback(async (uri: string) => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      await Player.play(uri);
+    } catch (err: any) {
+      setError(err.message || 'Failed to play song');
+      console.error('Error playing song:', err);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  // Play a song object
+  const playSong = useCallback(async (song: Song) => {
+    await play(song.uri);
+  }, [play]);
+
+  // Play from queue
+  const playFromQueue = useCallback((index: number) => {
+    Player.playFromQueue(index);
+  }, []);
+
+  // Pause playback
+  const pause = useCallback(() => {
+    Player.pause();
+  }, []);
+
+  // Stop playback
+  const stop = useCallback(() => {
+    Player.stop();
+  }, []);
+
+  // Seek to position
+  const seekTo = useCallback((position: number) => {
+    Player.seekTo(position);
+  }, []);
+
+  // Skip to next
+  const skipToNext = useCallback(() => {
+    Player.skipToNext();
+  }, []);
+
+  // Skip to previous
+  const skipToPrevious = useCallback(() => {
+    Player.skipToPrevious();
+  }, []);
+
+  // Set volume
+  const setVolume = useCallback((volume: number) => {
+    Player.setVolume(volume);
+  }, []);
+
+  // Set playback rate
+  const setPlaybackRate = useCallback((rate: number) => {
+    Player.setPlaybackRate(rate);
+  }, []);
+
+  // Set queue
+  const setQueueCallback = useCallback((songs: Song[]) => {
+    Player.setQueue(songs);
+  }, []);
+
+  // Add to queue
+  const addToQueue = useCallback((songs: Song[]) => {
+    Player.addToQueue(songs);
+  }, []);
+
+  // Clear queue
+  const clearQueue = useCallback(() => {
+    Player.clearQueue();
+  }, []);
+
+  // Get queue
+  const getQueue = useCallback(async (): Promise<Song[]> => {
+    return await Player.getQueue();
+  }, []);
+
+  // Set repeat mode
+  const setRepeatMode = useCallback((mode: 'none' | 'one' | 'all') => {
+    Player.setRepeatMode(mode);
+  }, []);
+
+  // Set shuffle mode
+  const setShuffleMode = useCallback((enabled: boolean) => {
+    Player.setShuffleMode(enabled);
+  }, []);
+
+  // Equalizer controls
+  const setEqualizerPreset = useCallback((preset: string) => {
+    Player.setEqualizerPreset(preset);
+  }, []);
+
+  const setEqualizerBands = useCallback((bands: number[]) => {
+    Player.setEqualizerBands(bands);
+  }, []);
+
+  const enableEqualizer = useCallback((enabled: boolean) => {
+    Player.enableEqualizer(enabled);
+  }, []);
+
+  // Background playback
+  const setupBackgroundPlayback = useCallback((config?: any) => {
+    Player.setupBackgroundPlayback(config);
+  }, []);
+
+  const stopBackgroundPlayback = useCallback(() => {
+    Player.stopBackgroundPlayback();
+  }, []);
+
+  // Sleep timer
+  const setSleepTimer = useCallback((minutes: number) => {
+    Player.setSleepTimer(minutes);
+  }, []);
+
+  const cancelSleepTimer = useCallback(() => {
+    Player.cancelSleepTimer();
+  }, []);
+
+    // Set up event listeners
+  useEffect(() => {
+    if (!autoSetup) return;
+
+    const playbackStateSub = Player.addEventListener(
+      PlayerEvents.PLAYBACK_STATE_CHANGED,
+      (data: any) => {
+        setPlaybackState(prev => ({
+          ...prev,
+          isPlaying: data.isPlaying,
+          currentTime: data.currentTime,
+          duration: data.duration,
+          volume: data.volume,
+          playbackRate: data.playbackRate,
+        }));
+        setIsPlaying(data.isPlaying);
+      }
+    );
+
+    const queueChangedSub = Player.addEventListener(
+      PlayerEvents.PLAYBACK_QUEUE_CHANGED,
+      (data: any) => {
+        setQueue(data.queue || []);
+        setPlaybackState(prev => ({
+          ...prev,
+          queue: data.queue || [],
+          queuePosition: data.position,
+        }));
+      }
+    );
+
+    const playbackErrorSub = Player.addEventListener(
+      PlayerEvents.PLAYBACK_ERROR,
+      (data: any) => {
+        setError(data.error || 'Playback error');
+        setPlaybackState(prev => ({
+          ...prev,
+          error: data.error,
+        }));
+      }
+    );
+
+    const playbackCompleteSub = Player.addEventListener(
+      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?.audioFocus !== false) {
+        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,
+  };
+};

package/src/hooks/useMusicScanner.ts

@@ -0,0 +1,286 @@
+import { useState, useEffect, useCallback } from 'react';
+import { Scanner, ScannerEvents } from '../index';
+import type { Song, Album, Artist, ScannerOptions } from '../types/common.types';
+
+interface UseMusicScannerProps {
+  autoScan?: boolean;
+  scanOptions?: ScannerOptions;
+}
+
+interface UseMusicScannerReturn {
+  // State
+  songs: Song[];
+  albums: Album[];
+  artists: Artist[];
+  isLoading: boolean;
+  isScanning: boolean;
+  scanProgress: number;
+  permissionGranted: boolean;
+  error: string | null;
+  
+  // Methods
+  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>;
+  
+  // Event handlers
+  onScanProgress?: (progress: number) => void;
+  onScanComplete?: (totalSongs: number) => void;
+}
+
+export const useMusicScanner = ({
+  autoScan = true,
+  scanOptions,
+}: UseMusicScannerProps = {}): UseMusicScannerReturn => {
+  const [songs, setSongs] = useState<Song[]>([]);
+  const [albums, setAlbums] = useState<Album[]>([]);
+  const [artists, setArtists] = useState<Artist[]>([]);
+  const [isLoading, setIsLoading] = useState<boolean>(false);
+  const [isScanning, setIsScanning] = useState<boolean>(false);
+  const [scanProgress, setScanProgress] = useState<number>(0);
+  const [permissionGranted, setPermissionGranted] = useState<boolean>(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Load initial data
+  const loadInitialData = useCallback(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      
+      const hasPermission = await Scanner.checkPermissionStatus();
+      setPermissionGranted(hasPermission);
+      
+      if (hasPermission) {
+        const cachedSongs = await Scanner.getCachedSongs();
+        setSongs(cachedSongs);
+        
+        const [albumsList, artistsList] = await Promise.all([
+          Scanner.getAlbums(),
+          Scanner.getArtists(),
+        ]);
+        
+        setAlbums(albumsList);
+        setArtists(artistsList);
+      }
+    } catch (err: any) {
+      setError(err.message || 'Failed to load music library');
+      console.error('Error loading music library:', err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  // Scan music files
+  const scanMusic = useCallback(async (options?: ScannerOptions) => {
+    try {
+      setIsScanning(true);
+      setScanProgress(0);
+      setError(null);
+      
+      const hasPermission = await Scanner.checkPermissionStatus();
+      if (!hasPermission) {
+        const granted = await 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 Scanner.scanMusicFiles(scanOpts);
+      
+      // Reload data after scan
+      await loadInitialData();
+      
+      return result;
+    } catch (err: any) {
+      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 = useCallback(async () => {
+    await loadInitialData();
+  }, [loadInitialData]);
+
+  // Search songs
+  const search = useCallback(async (query: string): Promise<Song[]> => {
+    if (!query.trim()) {
+      return songs;
+    }
+    
+    try {
+      const results = await Scanner.searchSongs(query);
+      return results;
+    } catch (err: any) {
+      setError(err.message || 'Search failed');
+      console.error('Error searching songs:', err);
+      return [];
+    }
+  }, [songs]);
+
+  // Delete song
+  const deleteSong = useCallback(async (songId: string): Promise<boolean> => {
+    try {
+      const success = await 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: any) {
+      setError(err.message || 'Failed to delete song');
+      console.error('Error deleting song:', err);
+      return false;
+    }
+  }, [refresh]);
+
+  // Add to favorites
+  const addToFavorites = useCallback(async (songId: string) => {
+    try {
+      await Scanner.addToFavorites(songId);
+      // Update local state
+      setSongs(prev => prev.map(song => 
+        song.id === songId ? { ...song, isFavorite: true } : song
+      ));
+    } catch (err: any) {
+      setError(err.message || 'Failed to add to favorites');
+      console.error('Error adding to favorites:', err);
+    }
+  }, []);
+
+  // Remove from favorites
+  const removeFromFavorites = useCallback(async (songId: string) => {
+    try {
+      await Scanner.removeFromFavorites(songId);
+      // Update local state
+      setSongs(prev => prev.map(song => 
+        song.id === songId ? { ...song, isFavorite: false } : song
+      ));
+    } catch (err: any) {
+      setError(err.message || 'Failed to remove from favorites');
+      console.error('Error removing from favorites:', err);
+    }
+  }, []);
+
+  // Request permission
+  const requestPermission = useCallback(async (): Promise<boolean> => {
+    try {
+      const granted = await Scanner.requestStoragePermission();
+      setPermissionGranted(granted);
+      return granted;
+    } catch (err: any) {
+      setError(err.message || 'Failed to request permission');
+      console.error('Error requesting permission:', err);
+      return false;
+    }
+  }, []);
+
+  // Check permission
+  const checkPermission = useCallback(async (): Promise<boolean> => {
+    try {
+      const granted = await Scanner.checkPermissionStatus();
+      setPermissionGranted(granted);
+      return granted;
+    } catch (err: any) {
+      setError(err.message || 'Failed to check permission');
+      console.error('Error checking permission:', err);
+      return false;
+    }
+  }, []);
+
+    // Set up event listeners
+  useEffect(() => {
+    const scanProgressSub = Scanner.addEventListener(
+      ScannerEvents.SCAN_PROGRESS,
+      (data: any) => {
+        setScanProgress(data.percentage);
+      }
+    );
+
+    const scanCompleteSub = Scanner.addEventListener(
+      ScannerEvents.SCAN_COMPLETE,
+      () => {
+        loadInitialData();
+      }
+    );
+
+    const fileAddedSub = Scanner.addEventListener(
+      ScannerEvents.FILE_ADDED,
+      () => {
+        loadInitialData();
+      }
+    );
+
+    const fileDeletedSub = Scanner.addEventListener(
+      ScannerEvents.FILE_DELETED,
+      () => {
+        loadInitialData();
+      }
+    );
+
+    const permissionSub = Scanner.addEventListener(
+      ScannerEvents.PERMISSION_STATUS,
+      (data: any) => {
+        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,
+  };
+};

package/src/hooks/usePermissions.ts

@@ -0,0 +1,64 @@
+import { useState, useEffect } from 'react';
+import { Scanner } from '../index';
+
+interface UsePermissionsReturn {
+  permissionGranted: boolean;
+  isChecking: boolean;
+  error: string | null;
+  requestPermission: () => Promise<boolean>;
+  checkPermission: () => Promise<boolean>;
+}
+
+export const usePermissions = (): UsePermissionsReturn => {
+  const [permissionGranted, setPermissionGranted] = useState<boolean>(false);
+  const [isChecking, setIsChecking] = useState<boolean>(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const checkPermission = async (): Promise<boolean> => {
+    try {
+      setIsChecking(true);
+      setError(null);
+      
+      const granted = await Scanner.checkPermissionStatus();
+      setPermissionGranted(granted);
+      
+      return granted;
+    } catch (err: any) {
+      setError(err.message || 'Failed to check permission');
+      console.error('Error checking permission:', err);
+      return false;
+    } finally {
+      setIsChecking(false);
+    }
+  };
+
+  const requestPermission = async (): Promise<boolean> => {
+    try {
+      setIsChecking(true);
+      setError(null);
+      
+      const granted = await Scanner.requestStoragePermission();
+      setPermissionGranted(granted);
+      
+      return granted;
+    } catch (err: any) {
+      setError(err.message || 'Failed to request permission');
+      console.error('Error requesting permission:', err);
+      return false;
+    } finally {
+      setIsChecking(false);
+    }
+  };
+
+  useEffect(() => {
+    checkPermission();
+  }, []);
+
+  return {
+    permissionGranted,
+    isChecking,
+    error,
+    requestPermission,
+    checkPermission,
+  };
+};