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

package/src/hooks/useEqualizerPresets.ts

@@ -0,0 +1,140 @@
+import { useEffect, useState, useCallback, useRef } from 'react'
+import { Equalizer } from '../index'
+import type { EqualizerPreset } from '../types/EqualizerTypes'
+import { equalizerCallbackManager } from './equalizerCallbackManager'
+
+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 function useEqualizerPresets(): UseEqualizerPresetsResult {
+  const [presets, setPresets] = useState<EqualizerPreset[]>([])
+  const [builtInPresets, setBuiltInPresets] = useState<EqualizerPreset[]>([])
+  const [customPresets, setCustomPresets] = useState<EqualizerPreset[]>([])
+  const [currentPreset, setCurrentPreset] = useState<string | null>(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: string): boolean => {
+    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: string): boolean => {
+      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: string): boolean => {
+      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/src/hooks/useNowPlaying.ts

@@ -10,6 +10,7 @@ const DEFAULT_STATE: PlayerState = {
   currentState: 'stopped',
   currentPlaylistId: null,
   currentIndex: -1,
+  currentPlayingType: 'not-playing',
 }
 
 /**
@@ -50,12 +51,14 @@ export function useNowPlaying(): PlayerState {
   const [state, setState] = useState<PlayerState>(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)
     }
@@ -64,34 +67,44 @@ export function useNowPlaying(): PlayerState {
   // Initialize with current state
   useEffect(() => {
     isMounted.current = true
-    updateState()
+    fetchFullState()
 
     return () => {
       isMounted.current = false
     }
-  }, [updateState])
+  }, [fetchFullState])
 
-  // Subscribe to track changes
+  // Subscribe to track changes — full refresh
   useEffect(() => {
-    const unsubscribe = callbackManager.subscribeToTrackChange(() => {
-      updateState()
+    return callbackManager.subscribeToTrackChange(() => {
+      fetchFullState()
     })
+  }, [fetchFullState])
 
-    return () => {
-      unsubscribe()
-    }
-  }, [updateState])
-
-  // Subscribe to playback state changes
+  // Subscribe to playback state changes — full refresh
   useEffect(() => {
-    const unsubscribe = callbackManager.subscribeToPlaybackState(() => {
-      updateState()
+    return callbackManager.subscribeToPlaybackState(() => {
+      fetchFullState()
     })
+  }, [fetchFullState])
 
-    return () => {
-      unsubscribe()
-    }
-  }, [updateState])
+  // 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/src/hooks/useOnChangeTrack.ts

@@ -48,20 +48,24 @@ export function useOnChangeTrack(): TrackChangeResult {
   useEffect(() => {
     isMounted.current = true
 
-    try {
-      const playerState = 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)
+    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)
+        }
       }
     }
 
+    initializeTrack()
+
     return () => {
       isMounted.current = false
     }

package/src/hooks/useOnPlaybackProgressChange.ts

@@ -1,5 +1,5 @@
 import { useEffect, useState } from 'react'
-import { TrackPlayer } from '../index'
+import { callbackManager } from './callbackManager'
 
 /**
  * Hook to get the current playback progress
@@ -17,7 +17,7 @@ export function useOnPlaybackProgressChange(): {
   )
 
   useEffect(() => {
-    TrackPlayer.onPlaybackProgressChange(
+    return callbackManager.subscribeToPlaybackProgressChange(
       (newPosition, newTotalDuration, newIsManuallySeeked) => {
         setPosition(newPosition)
         setTotalDuration(newTotalDuration)

package/src/hooks/useOnPlaybackStateChange.ts

@@ -47,24 +47,28 @@ export function useOnPlaybackStateChange(): PlaybackStateResult {
   useEffect(() => {
     isMounted.current = true
 
-    // Get initial state synchronously
-    try {
-      const playerState = 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)
+    // 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)
+        }
       }
     }
 
+    initializeState()
+
     return () => {
       isMounted.current = false
     }

package/src/hooks/usePlaylist.ts

@@ -0,0 +1,161 @@
+import { useEffect, useState, useRef, useCallback } from 'react'
+import { PlayerQueue } from '../index'
+import { callbackManager } from './callbackManager'
+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 function usePlaylist(): UsePlaylistResult {
+  const [currentPlaylist, setCurrentPlaylist] = useState<Playlist | null>(null)
+  const [currentPlaylistId, setCurrentPlaylistId] = useState<string | null>(
+    null
+  )
+  const [allPlaylists, setAllPlaylists] = useState<Playlist[]>([])
+  const [allTracks, setAllTracks] = useState<TrackItem[]>([])
+  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<string, TrackItem>()
+      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/src/index.ts

@@ -9,6 +9,8 @@ import type {
 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 const PlayerQueue =
   NitroModules.createHybridObject<PlayerQueueType>('PlayerQueue')
@@ -35,12 +37,22 @@ export const AudioRoutePicker =
     ? NitroModules.createHybridObject<AudioRoutePickerType>('AudioRoutePicker')
     : null
 
+// Download Manager
+export const DownloadManager =
+  NitroModules.createHybridObject<DownloadManagerType>('DownloadManager')
+
+// Equalizer
+export const Equalizer =
+  NitroModules.createHybridObject<EqualizerType>('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 type { TAudioDevice } from './specs/AudioDevices.nitro'
 export type { RepeatMode } from './specs/TrackPlayer.nitro'
 // Export utilities