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

package/src/hooks/useDownloadActions.ts

@@ -0,0 +1,179 @@
+import { useCallback, useState } from 'react'
+import { DownloadManager } from '../index'
+import type { DownloadConfig, PlaybackSource } from '../types/DownloadTypes'
+import type { TrackItem } from '../types/PlayerQueue'
+
+export interface UseDownloadActionsResult {
+  // Download actions
+  downloadTrack: (track: TrackItem, playlistId?: string) => Promise<string>
+  downloadPlaylist: (
+    playlistId: string,
+    tracks: TrackItem[]
+  ) => Promise<string[]>
+
+  // Control actions
+  pauseDownload: (downloadId: string) => Promise<void>
+  resumeDownload: (downloadId: string) => Promise<void>
+  cancelDownload: (downloadId: string) => Promise<void>
+  retryDownload: (downloadId: string) => Promise<void>
+
+  // Bulk control
+  pauseAll: () => Promise<void>
+  resumeAll: () => Promise<void>
+  cancelAll: () => Promise<void>
+
+  // Delete actions
+  deleteTrack: (trackId: string) => Promise<void>
+  deletePlaylist: (playlistId: string) => Promise<void>
+  deleteAll: () => Promise<void>
+
+  // Configuration
+  configure: (config: DownloadConfig) => void
+  setPlaybackSourcePreference: (preference: PlaybackSource) => void
+  getPlaybackSourcePreference: () => PlaybackSource
+
+  // Loading states
+  isDownloading: boolean
+  isDeleting: boolean
+  error: Error | null
+}
+
+/**
+ * Hook for download actions (download, pause, resume, cancel, delete)
+ */
+export function useDownloadActions(): UseDownloadActionsResult {
+  const [isDownloading, setIsDownloading] = useState(false)
+  const [isDeleting, setIsDeleting] = useState(false)
+  const [error, setError] = useState<Error | null>(null)
+
+  const downloadTrack = useCallback(
+    async (track: TrackItem, playlistId?: string) => {
+      setIsDownloading(true)
+      setError(null)
+      try {
+        const downloadId = await DownloadManager.downloadTrack(
+          track,
+          playlistId
+        )
+        return downloadId
+      } catch (e) {
+        setError(e as Error)
+        throw e
+      } finally {
+        setIsDownloading(false)
+      }
+    },
+    []
+  )
+
+  const downloadPlaylist = useCallback(
+    async (playlistId: string, tracks: TrackItem[]) => {
+      setIsDownloading(true)
+      setError(null)
+      try {
+        const downloadIds = await DownloadManager.downloadPlaylist(
+          playlistId,
+          tracks
+        )
+        return downloadIds
+      } catch (e) {
+        setError(e as Error)
+        throw e
+      } finally {
+        setIsDownloading(false)
+      }
+    },
+    []
+  )
+
+  const pauseDownload = useCallback(async (downloadId: string) => {
+    await DownloadManager.pauseDownload(downloadId)
+  }, [])
+
+  const resumeDownload = useCallback(async (downloadId: string) => {
+    await DownloadManager.resumeDownload(downloadId)
+  }, [])
+
+  const cancelDownload = useCallback(async (downloadId: string) => {
+    await DownloadManager.cancelDownload(downloadId)
+  }, [])
+
+  const retryDownload = useCallback(async (downloadId: string) => {
+    await DownloadManager.retryDownload(downloadId)
+  }, [])
+
+  const pauseAll = useCallback(async () => {
+    await DownloadManager.pauseAllDownloads()
+  }, [])
+
+  const resumeAll = useCallback(async () => {
+    await DownloadManager.resumeAllDownloads()
+  }, [])
+
+  const cancelAll = useCallback(async () => {
+    await DownloadManager.cancelAllDownloads()
+  }, [])
+
+  const deleteTrack = useCallback(async (trackId: string) => {
+    setIsDeleting(true)
+    try {
+      await DownloadManager.deleteDownloadedTrack(trackId)
+    } finally {
+      setIsDeleting(false)
+    }
+  }, [])
+
+  const deletePlaylist = useCallback(async (playlistId: string) => {
+    setIsDeleting(true)
+    try {
+      await DownloadManager.deleteDownloadedPlaylist(playlistId)
+    } finally {
+      setIsDeleting(false)
+    }
+  }, [])
+
+  const deleteAll = useCallback(async () => {
+    setIsDeleting(true)
+    try {
+      await DownloadManager.deleteAllDownloads()
+    } finally {
+      setIsDeleting(false)
+    }
+  }, [])
+
+  const configure = useCallback((config: DownloadConfig) => {
+    DownloadManager.configure(config)
+  }, [])
+
+  const setPlaybackSourcePreference = useCallback(
+    (preference: PlaybackSource) => {
+      DownloadManager.setPlaybackSourcePreference(preference)
+    },
+    []
+  )
+
+  const getPlaybackSourcePreference = useCallback(() => {
+    return DownloadManager.getPlaybackSourcePreference()
+  }, [])
+
+  return {
+    downloadTrack,
+    downloadPlaylist,
+    pauseDownload,
+    resumeDownload,
+    cancelDownload,
+    retryDownload,
+    pauseAll,
+    resumeAll,
+    cancelAll,
+    deleteTrack,
+    deletePlaylist,
+    deleteAll,
+    configure,
+    setPlaybackSourcePreference,
+    getPlaybackSourcePreference,
+    isDownloading,
+    isDeleting,
+    error,
+  }
+}

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,
+  }
+}