move track player hooks and mapping into state

app/hooks/trackplayer.ts

@@ -1,17 +1,6 @@
-import { Song } from '@app/models/music'
-import { selectCache } from '@app/state/cache'
 import { useStore } from '@app/state/store'
-import {
-  getCurrentTrack,
-  getQueue,
-  getRepeatMode,
-  QueueContextType,
-  selectTrackPlayer,
-  TrackExt,
-  trackPlayerCommands,
-} from '@app/state/trackplayer'
-import { useCallback } from 'react'
-import TrackPlayer, { RepeatMode } from 'react-native-track-player'
+import { getQueue, selectTrackPlayer, trackPlayerCommands } from '@app/state/trackplayer'
+import TrackPlayer from 'react-native-track-player'
 
 export const usePlay = () => {
   return () => trackPlayerCommands.enqueue(() => TrackPlayer.play())
@@ -67,33 +56,8 @@ export const useSeekTo = () => {
     })
 }
 
-export const useToggleRepeat = () => {
-  const setRepeatMode = useStore(selectTrackPlayer.setRepeatMode)
-
-  return () =>
-    trackPlayerCommands.enqueue(async () => {
-      const repeatMode = await getRepeatMode()
-      let nextMode = RepeatMode.Off
-
-      switch (repeatMode) {
-        case RepeatMode.Off:
-          nextMode = RepeatMode.Queue
-          break
-        case RepeatMode.Queue:
-          nextMode = RepeatMode.Track
-          break
-        default:
-          nextMode = RepeatMode.Off
-          break
-      }
-
-      await TrackPlayer.setRepeatMode(nextMode)
-      setRepeatMode(nextMode)
-    })
-}
-
 export const useReset = (enqueue = true) => {
-  const resetStore = useStore(selectTrackPlayer.reset)
+  const resetStore = useStore(selectTrackPlayer.resetTrackPlayerState)
 
   const reset = async () => {
     await TrackPlayer.reset()
@@ -103,166 +67,6 @@ export const useReset = (enqueue = true) => {
   return enqueue ? () => trackPlayerCommands.enqueue(reset) : reset
 }
 
-function shuffleTracks(tracks: TrackExt[], firstTrack?: number) {
-  if (tracks.length === 0) {
-    return { tracks, shuffleOrder: [] }
-  }
-
-  const trackIndexes = tracks.map((_t, i) => i)
-  let shuffleOrder: number[] = []
-
-  for (let i = trackIndexes.length; i--; i > 0) {
-    const randi = Math.floor(Math.random() * (i + 1))
-    shuffleOrder.push(trackIndexes.splice(randi, 1)[0])
-  }
-
-  if (firstTrack !== undefined) {
-    shuffleOrder.splice(shuffleOrder.indexOf(firstTrack), 1)
-    shuffleOrder = [firstTrack, ...shuffleOrder]
-  }
-
-  tracks = shuffleOrder.map(i => tracks[i])
-
-  return { tracks, shuffleOrder }
-}
-
-function unshuffleTracks(tracks: TrackExt[], shuffleOrder: number[]): TrackExt[] {
-  if (tracks.length === 0 || shuffleOrder.length === 0) {
-    return tracks
-  }
-
-  return shuffleOrder.map((_v, i) => tracks[shuffleOrder.indexOf(i)])
-}
-
-export const useToggleShuffle = () => {
-  const setCurrentTrackIdx = useStore(selectTrackPlayer.setCurrentTrackIdx)
-  const setQueue = useStore(selectTrackPlayer.setQueue)
-  const setShuffleOrder = useStore(selectTrackPlayer.setShuffleOrder)
-  const getShuffleOrder = useCallback(() => useStore.getState().shuffleOrder, [])
-  const setProgress = useStore(selectTrackPlayer.setProgress)
-  const getProgress = useCallback(() => useStore.getState().progress, [])
-
-  return async () => {
-    return trackPlayerCommands.enqueue(async () => {
-      const queue = await getQueue()
-      const current = await getCurrentTrack()
-      const queueShuffleOrder = getShuffleOrder()
-      const progress = getProgress()
-
-      await TrackPlayer.remove(queue.map((_t, i) => i).filter(i => i !== current))
-
-      if (queueShuffleOrder === undefined) {
-        let { tracks, shuffleOrder } = shuffleTracks(queue, current)
-        if (tracks.length > 0) {
-          tracks = tracks.slice(1)
-        }
-
-        await TrackPlayer.add(tracks)
-        setShuffleOrder(shuffleOrder)
-      } else {
-        const tracks = unshuffleTracks(queue, queueShuffleOrder)
-
-        if (current !== undefined) {
-          const shuffledCurrent = queueShuffleOrder[current]
-          const tracks1 = tracks.slice(0, shuffledCurrent)
-          const tracks2 = tracks.slice(shuffledCurrent + 1)
-
-          await TrackPlayer.add(tracks2)
-          await TrackPlayer.add(tracks1, 0)
-        } else {
-          await TrackPlayer.add(tracks)
-        }
-
-        setShuffleOrder(undefined)
-      }
-
-      setQueue(await getQueue())
-      setCurrentTrackIdx(await getCurrentTrack())
-      setProgress(progress)
-    })
-  }
-}
-
-export const useSetQueue = () => {
-  const setCurrentTrackIdx = useStore(selectTrackPlayer.setCurrentTrackIdx)
-  const setQueue = useStore(selectTrackPlayer.setQueue)
-  const setShuffleOrder = useStore(selectTrackPlayer.setShuffleOrder)
-  const setQueueName = useStore(selectTrackPlayer.setQueueName)
-  const getQueueShuffled = useCallback(() => !!useStore.getState().shuffleOrder, [])
-  const setQueueContextType = useStore(selectTrackPlayer.setQueueContextType)
-  const setQueueContextId = useStore(selectTrackPlayer.setQueueContextId)
-  const fetchCoverArtFilePath = useStore(selectCache.fetchCoverArtFilePath)
-  const buildStreamUri = useStore(selectTrackPlayer.buildStreamUri)
-
-  return async (
-    songs: Song[],
-    name: string,
-    contextType: QueueContextType,
-    contextId: string,
-    playTrack?: number,
-    shuffle?: boolean,
-  ) =>
-    trackPlayerCommands.enqueue(async () => {
-      const shuffled = shuffle !== undefined ? shuffle : getQueueShuffled()
-
-      await TrackPlayer.setupPlayer()
-      await TrackPlayer.reset()
-
-      if (songs.length === 0) {
-        return
-      }
-
-      const coverArtPaths: { [coverArt: string]: string | undefined } = {}
-      for (const s of songs) {
-        if (!s.coverArt) {
-          continue
-        }
-
-        coverArtPaths[s.coverArt] = await fetchCoverArtFilePath(s.coverArt)
-      }
-
-      let queue = songs.map(s => mapSongToTrack(s, coverArtPaths))
-
-      try {
-        for (const t of queue) {
-          t.url = buildStreamUri(t.id)
-        }
-      } catch {
-        return
-      }
-
-      if (shuffled) {
-        const { tracks, shuffleOrder } = shuffleTracks(queue, playTrack)
-        setShuffleOrder(shuffleOrder)
-        queue = tracks
-        playTrack = 0
-      } else {
-        setShuffleOrder(undefined)
-      }
-
-      playTrack = playTrack || 0
-
-      setQueue(queue)
-      setCurrentTrackIdx(playTrack)
-      setQueueName(name)
-      setQueueContextType(contextType)
-      setQueueContextId(contextId)
-
-      if (playTrack === 0) {
-        await TrackPlayer.add(queue)
-        await TrackPlayer.play()
-      } else {
-        const tracks1 = queue.slice(0, playTrack)
-        const tracks2 = queue.slice(playTrack)
-
-        await TrackPlayer.add(tracks2)
-        await TrackPlayer.play()
-
-        await TrackPlayer.add(tracks1, 0)
-      }
-    })
-}
-
 export const useIsPlaying = (contextId: string | undefined, track: number) => {
   const queueContextId = useStore(selectTrackPlayer.queueContextId)
   const currentTrackIdx = useStore(selectTrackPlayer.currentTrackIdx)
@@ -279,34 +83,3 @@ export const useIsPlaying = (contextId: string | undefined, track: number) => {
 
   return contextId === queueContextId && track === currentTrackIdx
 }
-
-function mapSongToTrack(song: Song, coverArtPaths: { [coverArt: string]: string | undefined }): TrackExt {
-  return {
-    id: song.id,
-    title: song.title,
-    artist: song.artist || 'Unknown Artist',
-    album: song.album || 'Unknown Album',
-    url: song.streamUri,
-    artwork:
-      song.coverArt && coverArtPaths[song.coverArt] ? coverArtPaths[song.coverArt] : require('@res/fallback.png'),
-    coverArt: song.coverArt,
-    duration: song.duration,
-    artistId: song.artistId,
-    albumId: song.albumId,
-  }
-}
-
-export function mapTrackExtToSong(track: TrackExt): Song {
-  return {
-    itemType: 'song',
-    id: track.id,
-    title: track.title as string,
-    artist: track.artist,
-    album: track.album,
-    streamUri: track.url as string,
-    coverArt: track.coverArt,
-    duration: track.duration,
-    artistId: track.artistId,
-    albumId: track.albumId,
-  }
-}