react-native-mp3 0.1.0

package/src/index.ts

@@ -0,0 +1,214 @@
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+
+// Import constants
+import { ScannerEvents, PlayerEvents, RepeatMode, EqualizerPresets, AudioExtensions } from './utils/constants';
+import { Album, Artist, PlaybackState, ScannerOptions, Song } from './types';
+
+// Types - Re-export explicitly to avoid conflicts
+export {
+  Song,
+  Album,
+  Artist,
+  Playlist,
+  PlaybackState,
+  EqualizerPreset,
+  ScannerOptions,
+  PlayerOptions,
+} from './types/common.types';
+
+export type {
+  ScannerEvents as ScannerEventsType,
+  ScannerEventType,
+} from './types/scanner.types';
+
+export type {
+  PlayerEvents as PlayerEventsType,
+  PlayerEventType,
+} from './types/player.types';
+
+// Constants - export as values
+export {
+  ScannerEvents,
+  PlayerEvents,
+  RepeatMode,
+  EqualizerPresets,
+  AudioExtensions,
+};
+
+// Hooks
+export { useMusicPlayer } from './hooks/useMusicPlayer';
+export { useMusicScanner } from './hooks/useMusicScanner';
+export { usePermissions } from './hooks/usePermissions';
+
+// Optional UI Components (if needed)
+// export { MusicPlayerUI } from './components/MusicPlayerUI';
+// export { MusicList } from './components/MusicList';
+
+// Native Modules
+const { ScannerModule, PlayerModule, MetadataModule, NotificationModule } =
+  NativeModules;
+
+// Event Emitters
+const scannerEventEmitter = new NativeEventEmitter(ScannerModule);
+const playerEventEmitter = new NativeEventEmitter(PlayerModule);
+
+// Check if native modules are available
+if (!ScannerModule || !PlayerModule) {
+  console.warn(
+    'react-native-mp3 native modules are not available. Make sure to link the package properly.'
+  );
+}
+
+// Scanner Module Functions
+export const Scanner = {
+  // Permission
+  requestStoragePermission: (): Promise<boolean> =>
+    ScannerModule.requestStoragePermission(),
+  checkPermissionStatus: (): Promise<boolean> =>
+    ScannerModule.checkPermissionStatus(),
+
+  // Scanning
+  scanMusicFiles: (options?: ScannerOptions): Promise<any> =>
+    ScannerModule.scanMusicFiles(options || {}),
+  getCachedSongs: (options?: any): Promise<Song[]> =>
+    ScannerModule.getCachedSongs(options || {}),
+
+  // File Operations
+  deleteSong: (songId: string): Promise<boolean> =>
+    ScannerModule.deleteSong(songId),
+  addToFavorites: (songId: string): Promise<boolean> =>
+    ScannerModule.addToFavorites(songId),
+  removeFromFavorites: (songId: string): Promise<boolean> =>
+    ScannerModule.removeFromFavorites(songId),
+
+  // Metadata
+  getAlbums: (): Promise<Album[]> => ScannerModule.getAlbums(),
+  getArtists: (): Promise<Artist[]> => ScannerModule.getArtists(),
+  searchSongs: (query: string): Promise<Song[]> => ScannerModule.searchSongs(query),
+
+  // Cache Management
+  clearCache: (): Promise<boolean> => ScannerModule.clearCache(),
+
+  // File Monitoring
+  startFileMonitoring: (): void => ScannerModule.startFileMonitoring(),
+  stopFileMonitoring: (): void => ScannerModule.stopFileMonitoring(),
+
+  // Events
+  addEventListener: (
+    event: string,
+    listener: (data: any) => void
+  ): { remove: () => void } => {
+    const subscription = scannerEventEmitter.addListener(event, listener);
+    return { remove: () => subscription.remove() };
+  },
+
+  removeAllListeners: (event?: string): void => {
+    if (event) {
+      scannerEventEmitter.removeAllListeners(event);
+    } else {
+      // Remove all events by specifying each event type
+      const scannerEventTypes = Object.values(ScannerEvents) as string[];
+      scannerEventTypes.forEach(eventType => {
+        scannerEventEmitter.removeAllListeners(eventType);
+      });
+    }
+  },
+};
+
+// Player Module Functions
+export const Player = {
+  // Playback Control
+  play: (uri: string): Promise<void> => PlayerModule.play(uri),
+  playFromQueue: (index: number): void => PlayerModule.playFromQueue(index),
+  pause: (): void => PlayerModule.pause(),
+  stop: (): void => PlayerModule.stop(),
+  seekTo: (position: number): void => PlayerModule.seekTo(position),
+  skipToNext: (): void => PlayerModule.skipToNext(),
+  skipToPrevious: (): void => PlayerModule.skipToPrevious(),
+  setVolume: (volume: number): void => PlayerModule.setVolume(volume),
+  setPlaybackRate: (rate: number): void => PlayerModule.setPlaybackRate(rate),
+
+  // Queue Management
+  setQueue: (songs: Song[]): void => PlayerModule.setQueue(songs),
+  addToQueue: (songs: Song[]): void => PlayerModule.addToQueue(songs),
+  clearQueue: (): void => PlayerModule.clearQueue(),
+  getQueue: (): Promise<Song[]> => PlayerModule.getQueue(),
+  getCurrentTrack: (): Promise<Song> => PlayerModule.getCurrentTrack(),
+
+  // Playback State
+  getPlaybackState: (): Promise<PlaybackState> => PlayerModule.getPlaybackState(),
+  getCurrentTime: (): Promise<number> => PlayerModule.getCurrentTime(),
+  getDuration: (): Promise<number> => PlayerModule.getDuration(),
+  isPlaying: (): Promise<boolean> => PlayerModule.isPlaying(),
+
+  // Playback Modes
+  setRepeatMode: (mode: 'none' | 'one' | 'all'): void =>
+    PlayerModule.setRepeatMode(mode),
+  setShuffleMode: (enabled: boolean): void => PlayerModule.setShuffleMode(enabled),
+
+  // Equalizer
+  setEqualizerPreset: (preset: string): void => PlayerModule.setEqualizerPreset(preset),
+  setEqualizerBands: (bands: number[]): void => PlayerModule.setEqualizerBands(bands),
+  getEqualizerPresets: (): Promise<string[]> => PlayerModule.getEqualizerPresets(),
+  enableEqualizer: (enabled: boolean): void => PlayerModule.enableEqualizer(enabled),
+
+  // Sleep Timer
+  setSleepTimer: (minutes: number): void => PlayerModule.setSleepTimer(minutes),
+  cancelSleepTimer: (): void => PlayerModule.cancelSleepTimer(),
+
+  // Background Playback
+  setupBackgroundPlayback: (config?: any): void =>
+    PlayerModule.setupBackgroundPlayback(config || {}),
+  stopBackgroundPlayback: (): void => PlayerModule.stopBackgroundPlayback(),
+
+  // Events
+  addEventListener: (
+    event: string,
+    listener: (data: any) => void
+  ): { remove: () => void } => {
+    const subscription = playerEventEmitter.addListener(event, listener);
+    return { remove: () => subscription.remove() };
+  },
+
+  removeAllListeners: (event?: string): void => {
+    if (event) {
+      playerEventEmitter.removeAllListeners(event);
+    } else {
+      // Remove all events by specifying each event type
+      const playerEventTypes = Object.values(PlayerEvents) as string[];
+      playerEventTypes.forEach(eventType => {
+        playerEventEmitter.removeAllListeners(eventType);
+      });
+    }
+  },
+};
+
+// Metadata Module Functions
+export const Metadata = {
+  extractMetadata: (uri: string): Promise<any> => MetadataModule.extractMetadata(uri),
+  getAlbumArt: (uri: string, size?: number): Promise<string> =>
+    MetadataModule.getAlbumArt(uri, size || 300),
+  getLyrics: (uri: string): Promise<string | null> => MetadataModule.getLyrics(uri),
+  updateMetadata: (uri: string, metadata: any): Promise<boolean> =>
+    MetadataModule.updateMetadata(uri, metadata),
+};
+
+// Notification Module Functions
+export const Notifications = {
+  setupNotificationChannel: (): void => NotificationModule.setupNotificationChannel(),
+  updateNotification: (metadata: any): void => NotificationModule.updateNotification(metadata),
+  hideNotification: (): void => NotificationModule.hideNotification(),
+  showNotification: (): void => NotificationModule.showNotification(),
+};
+
+// Default export
+export default {
+  Scanner,
+  Player,
+  Metadata,
+  Notifications,
+};
+
+// Platform check
+export const isAndroid = Platform.OS === 'android';
+export const isIOS = Platform.OS === 'ios';

package/src/types/common.types.ts

@@ -0,0 +1,86 @@
+export interface Song {
+  id: string;
+  title: string;
+  artist: string;
+  album: string;
+  duration: number;
+  path: string;
+  uri: string;
+  albumArtUri?: string;
+  size: number;
+  mimeType: string;
+  trackNumber: number;
+  year?: number;
+  genre?: string;
+  dateAdded: number;
+  lastModified: number;
+  isFavorite: boolean;
+  playCount: number;
+  lastPlayed?: number;
+  bitrate?: number;
+  sampleRate?: number;
+  channels?: number;
+  composer?: string;
+  bookmark: number;
+  isPodcast: boolean;
+  rating?: number;
+}
+
+export interface Album {
+  name: string;
+  songCount: number;
+  albumArtUri?: string;
+  artist?: string;
+  year?: number;
+}
+
+export interface Artist {
+  name: string;
+  songCount: number;
+  albumCount: number;
+}
+
+export interface Playlist {
+  id: string;
+  name: string;
+  songCount: number;
+  thumbnailUri?: string;
+  createdAt: number;
+}
+
+export interface PlaybackState {
+  isPlaying: boolean;
+  currentTime: number;
+  duration: number;
+  buffered?: number;
+  playbackRate: number;
+  volume: number;
+  repeatMode: 'none' | 'one' | 'all';
+  shuffleMode: boolean;
+  currentSong?: Song;
+  queue: Song[];
+  queuePosition: number;
+  error?: string;
+}
+
+export interface EqualizerPreset {
+  name: string;
+  bands: number[];
+}
+
+export interface ScannerOptions {
+  forceRescan?: boolean;
+  paths?: string[];
+  maxFiles?: number;
+  extensions?: string[];
+}
+
+export interface PlayerOptions {
+  autoPlay?: boolean;
+  keepAwake?: boolean;
+  volume?: number;
+  speed?: number;
+  repeatMode?: 'none' | 'one' | 'all';
+  audioFocus?: boolean;
+  ducking?: boolean;
+}

package/src/types/index.ts

@@ -0,0 +1,4 @@
+// Re-export everything explicitly
+export type { Song, Album, Artist, Playlist, PlaybackState, EqualizerPreset, ScannerOptions, PlayerOptions } from './common.types';
+export type { ScannerEvents, ScannerEventType } from './scanner.types';
+export type { PlayerEvents, PlayerEventType } from './player.types';

package/src/types/player.types.ts

@@ -0,0 +1,37 @@
+export interface PlayerEvents {
+  PLAYBACK_STATE_CHANGED: {
+    isPlaying: boolean;
+    currentTime: number;
+    duration: number;
+    buffered?: number;
+  };
+  PLAYBACK_QUEUE_CHANGED: {
+    queue: any[];
+    position: number;
+  };
+  PLAYBACK_ERROR: {
+    error: string;
+    songId?: string;
+  };
+  PLAYBACK_COMPLETE: {
+    songId: string;
+  };
+  PLAYBACK_NEXT: {
+    songId: string;
+  };
+  PLAYBACK_PREVIOUS: {
+    songId: string;
+  };
+  EQUALIZER_CHANGED: {
+    enabled: boolean;
+    preset?: string;
+    bands?: number[];
+  };
+}
+
+export type PlayerEventType = keyof PlayerEvents;
+
+export interface AudioFocusConfig {
+  focusGain: number; // AudioManager.AUDIOFOCUS_GAIN
+  willPauseWhenDucked: boolean;
+}

package/src/types/scanner.types.ts

@@ -0,0 +1,31 @@
+export interface ScannerEvents {
+  SCAN_PROGRESS: {
+    processed: number;
+    total: number;
+    percentage: number;
+  };
+  SCAN_COMPLETE: {
+    totalSongs: number;
+    scanPaths: string[];
+  };
+  FILE_ADDED: {
+    songId: string;
+    path: string;
+    song: any;
+  };
+  FILE_DELETED: {
+    songId: string;
+    path: string;
+  };
+  PERMISSION_STATUS: {
+    granted: boolean;
+    message: string;
+  };
+}
+
+export type ScannerEventType = keyof ScannerEvents;
+
+export interface ScanResult {
+  totalSongs: number;
+  scanPaths: string[];
+}

package/src/utils/constants.ts

@@ -0,0 +1,56 @@
+export const ScannerEvents = {
+  SCAN_PROGRESS: 'SCAN_PROGRESS',
+  SCAN_COMPLETE: 'SCAN_COMPLETE',
+  FILE_ADDED: 'FILE_ADDED',
+  FILE_DELETED: 'FILE_DELETED',
+  PERMISSION_STATUS: 'PERMISSION_STATUS',
+} as const;
+
+export const PlayerEvents = {
+  PLAYBACK_STATE_CHANGED: 'PLAYBACK_STATE_CHANGED',
+  PLAYBACK_QUEUE_CHANGED: 'PLAYBACK_QUEUE_CHANGED',
+  PLAYBACK_ERROR: 'PLAYBACK_ERROR',
+  PLAYBACK_COMPLETE: 'PLAYBACK_COMPLETE',
+  PLAYBACK_NEXT: 'PLAYBACK_NEXT',
+  PLAYBACK_PREVIOUS: 'PLAYBACK_PREVIOUS',
+  EQUALIZER_CHANGED: 'EQUALIZER_CHANGED',
+} as const;
+
+export const RepeatMode = {
+  NONE: 'none',
+  ONE: 'one',
+  ALL: 'all',
+} as const;
+
+export const EqualizerPresets = {
+  NORMAL: 'normal',
+  ROCK: 'rock',
+  POP: 'pop',
+  JAZZ: 'jazz',
+  CLASSIC: 'classic',
+  DANCE: 'dance',
+  FLAT: 'flat',
+} as const;
+
+export const AudioExtensions = [
+  '.mp3',
+  '.mp4',
+  '.m4a',
+  '.aac',
+  '.flac',
+  '.wav',
+  '.ogg',
+  '.opus',
+  '.wma',
+  '.amr',
+  '.aif',
+  '.aiff',
+  '.mid',
+  '.midi',
+  '.xmf',
+  '.mxmf',
+  '.rtttl',
+  '.rtx',
+  '.ota',
+  '.imy',
+];