react-native-nitro-player 0.3.0-alpha.9 → 0.4.0

package/src/hooks/useDownloadProgress.ts

@@ -0,0 +1,126 @@
+import { useEffect, useState, useRef, useCallback } from 'react'
+import { DownloadManager } from '../index'
+import { downloadCallbackManager } from './downloadCallbackManager'
+import type { DownloadProgress } from '../types/DownloadTypes'
+
+export interface UseDownloadProgressOptions {
+  /** Track specific track ID(s) */
+  trackIds?: string[]
+  /** Track specific download ID(s) */
+  downloadIds?: string[]
+  /** Only track active downloads */
+  activeOnly?: boolean
+}
+
+export interface UseDownloadProgressResult {
+  /** Map of trackId to DownloadProgress */
+  progressMap: Map<string, DownloadProgress>
+  /** Array of all tracked progress */
+  progressList: DownloadProgress[]
+  /** Overall progress for tracked downloads (0-1) */
+  overallProgress: number
+  /** Whether any download is in progress */
+  isDownloading: boolean
+  /** Get progress for a specific track */
+  getProgress: (trackId: string) => DownloadProgress | undefined
+}
+
+/**
+ * Hook for tracking download progress
+ */
+export function useDownloadProgress(
+  options: UseDownloadProgressOptions = {}
+): UseDownloadProgressResult {
+  const { trackIds, downloadIds, activeOnly = false } = options
+  const [progressMap, setProgressMap] = useState<Map<string, DownloadProgress>>(
+    new Map()
+  )
+  const isMounted = useRef(true)
+
+  const shouldTrack = useCallback(
+    (progress: DownloadProgress): boolean => {
+      if (
+        trackIds &&
+        trackIds.length > 0 &&
+        !trackIds.includes(progress.trackId)
+      ) {
+        return false
+      }
+      if (
+        downloadIds &&
+        downloadIds.length > 0 &&
+        !downloadIds.includes(progress.downloadId)
+      ) {
+        return false
+      }
+      if (activeOnly && progress.state !== 'downloading') {
+        return false
+      }
+      return true
+    },
+    [trackIds, downloadIds, activeOnly]
+  )
+
+  useEffect(() => {
+    isMounted.current = true
+
+    // Initialize with current active downloads
+    try {
+      const activeDownloads = DownloadManager.getActiveDownloads()
+      const initialMap = new Map<string, DownloadProgress>()
+      activeDownloads.forEach((task) => {
+        if (shouldTrack(task.progress)) {
+          initialMap.set(task.trackId, task.progress)
+        }
+      })
+      setProgressMap(initialMap)
+    } catch (error) {
+      console.error('[useDownloadProgress] Error initializing:', error)
+    }
+
+    const unsubscribe = downloadCallbackManager.subscribeToProgress(
+      (progress) => {
+        if (!isMounted.current) return
+        if (!shouldTrack(progress)) return
+
+        setProgressMap((prev) => {
+          const next = new Map(prev)
+          if (
+            progress.state === 'completed' ||
+            progress.state === 'cancelled'
+          ) {
+            next.delete(progress.trackId)
+          } else {
+            next.set(progress.trackId, progress)
+          }
+          return next
+        })
+      }
+    )
+
+    return () => {
+      isMounted.current = false
+      unsubscribe()
+    }
+  }, [shouldTrack])
+
+  const progressList = Array.from(progressMap.values())
+  const overallProgress =
+    progressList.length > 0
+      ? progressList.reduce((sum, p) => sum + p.progress, 0) /
+        progressList.length
+      : 0
+  const isDownloading = progressList.some((p) => p.state === 'downloading')
+  const getProgress = useCallback(
+    (trackId: string) => progressMap.get(trackId),
+    [progressMap]
+  )
+
+  return {
+    progressMap,
+    progressList,
+    overallProgress,
+    isDownloading,
+    getProgress,
+  }
+}

package/src/hooks/useDownloadStorage.ts

@@ -0,0 +1,84 @@
+import { useEffect, useState, useRef, useCallback } from 'react'
+import { DownloadManager } from '../index'
+import type { DownloadStorageInfo } from '../types/DownloadTypes'
+
+export interface UseDownloadStorageResult {
+  /** Storage information */
+  storageInfo: DownloadStorageInfo | null
+  /** Loading state */
+  isLoading: boolean
+  /** Refresh storage info */
+  refresh: () => Promise<void>
+  /** Formatted total downloaded size (e.g., "2.5 GB") */
+  formattedSize: string
+  /** Formatted available space (e.g., "10.2 GB") */
+  formattedAvailable: string
+  /** Usage percentage (0-100) */
+  usagePercentage: number
+}
+
+/**
+ * Formats bytes into a human-readable string
+ */
+function formatBytes(bytes: number): string {
+  if (bytes === 0) return '0 B'
+  const k = 1024
+  const sizes = ['B', 'KB', 'MB', 'GB', 'TB']
+  const i = Math.floor(Math.log(bytes) / Math.log(k))
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
+}
+
+/**
+ * Hook for accessing download storage information
+ */
+export function useDownloadStorage(): UseDownloadStorageResult {
+  const [storageInfo, setStorageInfo] = useState<DownloadStorageInfo | null>(
+    null
+  )
+  const [isLoading, setIsLoading] = useState(true)
+  const isMounted = useRef(true)
+
+  const refresh = useCallback(async () => {
+    try {
+      const info = await DownloadManager.getStorageInfo()
+      if (isMounted.current) {
+        setStorageInfo(info)
+        setIsLoading(false)
+      }
+    } catch (error) {
+      console.error('[useDownloadStorage] Error:', error)
+      if (isMounted.current) {
+        setIsLoading(false)
+      }
+    }
+  }, [])
+
+  useEffect(() => {
+    isMounted.current = true
+    refresh()
+    return () => {
+      isMounted.current = false
+    }
+  }, [refresh])
+
+  const formattedSize = storageInfo
+    ? formatBytes(storageInfo.totalDownloadedSize)
+    : '0 B'
+
+  const formattedAvailable = storageInfo
+    ? formatBytes(storageInfo.availableSpace)
+    : '0 B'
+
+  const usagePercentage = storageInfo
+    ? (storageInfo.totalDownloadedSize / storageInfo.totalSpace) * 100
+    : 0
+
+  return {
+    storageInfo,
+    isLoading,
+    refresh,
+    formattedSize,
+    formattedAvailable,
+    usagePercentage,
+  }
+}

package/src/hooks/useDownloadedTracks.ts

@@ -0,0 +1,138 @@
+import { useEffect, useState, useRef, useCallback, useMemo } from 'react'
+import { DownloadManager } from '../index'
+import { downloadCallbackManager } from './downloadCallbackManager'
+import type {
+  DownloadedTrack,
+  DownloadedPlaylist,
+} from '../types/DownloadTypes'
+
+export interface UseDownloadedTracksResult {
+  /** All downloaded tracks */
+  downloadedTracks: DownloadedTrack[]
+  /** All downloaded playlists */
+  downloadedPlaylists: DownloadedPlaylist[]
+  /** Check if a track is downloaded */
+  isTrackDownloaded: (trackId: string) => boolean
+  /** Check if a playlist is fully downloaded */
+  isPlaylistDownloaded: (playlistId: string) => boolean
+  /** Check if a playlist is partially downloaded */
+  isPlaylistPartiallyDownloaded: (playlistId: string) => boolean
+  /** Get downloaded track info */
+  getDownloadedTrack: (trackId: string) => DownloadedTrack | undefined
+  /** Get downloaded playlist info */
+  getDownloadedPlaylist: (playlistId: string) => DownloadedPlaylist | undefined
+  /** Refresh downloaded content list */
+  refresh: () => void
+  /** Loading state */
+  isLoading: boolean
+}
+
+/**
+ * Hook for accessing downloaded tracks and playlists
+ */
+export function useDownloadedTracks(): UseDownloadedTracksResult {
+  const [downloadedTracks, setDownloadedTracks] = useState<DownloadedTrack[]>(
+    []
+  )
+  const [downloadedPlaylists, setDownloadedPlaylists] = useState<
+    DownloadedPlaylist[]
+  >([])
+  const [isLoading, setIsLoading] = useState(true)
+  const isMounted = useRef(true)
+
+  const refresh = useCallback(() => {
+    if (!isMounted.current) return
+
+    try {
+      const tracks = DownloadManager.getAllDownloadedTracks()
+      const playlists = DownloadManager.getAllDownloadedPlaylists()
+
+      if (isMounted.current) {
+        setDownloadedTracks(tracks)
+        setDownloadedPlaylists(playlists)
+        setIsLoading(false)
+      }
+    } catch (error) {
+      console.error('[useDownloadedTracks] Error refreshing:', error)
+      if (isMounted.current) {
+        setIsLoading(false)
+      }
+    }
+  }, [])
+
+  useEffect(() => {
+    isMounted.current = true
+    refresh()
+
+    const unsubscribeComplete = downloadCallbackManager.subscribeToComplete(
+      () => {
+        refresh()
+      }
+    )
+
+    const unsubscribeStateChange =
+      downloadCallbackManager.subscribeToStateChange(
+        (_downloadId, _trackId, state) => {
+          if (state === 'completed') {
+            refresh()
+          }
+        }
+      )
+
+    return () => {
+      isMounted.current = false
+      unsubscribeComplete()
+      unsubscribeStateChange()
+    }
+  }, [refresh])
+
+  const trackMap = useMemo(
+    () => new Map(downloadedTracks.map((t) => [t.trackId, t])),
+    [downloadedTracks]
+  )
+
+  const playlistMap = useMemo(
+    () => new Map(downloadedPlaylists.map((p) => [p.playlistId, p])),
+    [downloadedPlaylists]
+  )
+
+  const isTrackDownloaded = useCallback(
+    (trackId: string) => trackMap.has(trackId),
+    [trackMap]
+  )
+
+  const isPlaylistDownloaded = useCallback(
+    (playlistId: string) => {
+      const p = playlistMap.get(playlistId)
+      return p ? p.isComplete : false
+    },
+    [playlistMap]
+  )
+
+  const isPlaylistPartiallyDownloaded = useCallback(
+    (playlistId: string) => playlistMap.has(playlistId),
+    [playlistMap]
+  )
+
+  const getDownloadedTrack = useCallback(
+    (trackId: string) => trackMap.get(trackId),
+    [trackMap]
+  )
+
+  const getDownloadedPlaylist = useCallback(
+    (playlistId: string) => playlistMap.get(playlistId),
+    [playlistMap]
+  )
+
+  return {
+    downloadedTracks,
+    downloadedPlaylists,
+    isTrackDownloaded,
+    isPlaylistDownloaded,
+    isPlaylistPartiallyDownloaded,
+    getDownloadedTrack,
+    getDownloadedPlaylist,
+    refresh,
+    isLoading,
+  }
+}

package/src/hooks/useEqualizer.ts

@@ -0,0 +1,173 @@
+import { useEffect, useState, useCallback, useRef } from 'react'
+import { Equalizer } from '../index'
+import type { EqualizerBand } from '../types/EqualizerTypes'
+import { equalizerCallbackManager } from './equalizerCallbackManager'
+
+export interface UseEqualizerResult {
+  /** Whether the equalizer is enabled */
+  isEnabled: boolean
+  /** Current band settings */
+  bands: EqualizerBand[]
+  /** Currently applied preset name */
+  currentPreset: string | null
+  /** Toggle equalizer on/off */
+  setEnabled: (enabled: boolean) => boolean
+  /** Set gain for a specific band */
+  setBandGain: (bandIndex: number, gainDb: number) => boolean
+  /** Set all band gains at once */
+  setAllBandGains: (gains: number[]) => boolean
+  /** Reset to flat response */
+  reset: () => void
+  /** Whether equalizer is loading */
+  isLoading: boolean
+  /** Gain range (min/max in dB) */
+  gainRange: { min: number; max: number }
+}
+
+const DEFAULT_BANDS: EqualizerBand[] = [
+  { 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(): UseEqualizerResult {
+  const [isEnabled, setIsEnabledState] = useState(false)
+  const [bands, setBands] = useState<EqualizerBand[]>(DEFAULT_BANDS)
+  const [currentPreset, setCurrentPreset] = useState<string | null>(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: boolean): boolean => {
+    try {
+      return Equalizer.setEnabled(enabled)
+    } catch (error) {
+      console.error('[useEqualizer] Error setting enabled:', error)
+      return false
+    }
+  }, [])
+
+  const setBandGain = useCallback(
+    (bandIndex: number, gainDb: number): boolean => {
+      // 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: number[]): boolean => {
+    // 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/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,11 +51,11 @@ export function useNowPlaying(): PlayerState {
   const [state, setState] = useState<PlayerState>(DEFAULT_STATE)
   const isMounted = useRef(true)
 
-  const updateState = useCallback(() => {
+  const updateState = useCallback(async () => {
     if (!isMounted.current) return
 
     try {
-      const newState = TrackPlayer.getState()
+      const newState = await TrackPlayer.getState()
       setState(newState)
     } catch (error) {
       console.error('[useNowPlaying] Error updating player state:', error)