move track player hooks and mapping into state

app/state/trackplayer.ts

@@ -1,7 +1,7 @@
 import { NoClientError } from '@app/models/error'
+import { Song } from '@app/models/music'
 import PromiseQueue from '@app/util/PromiseQueue'
 import produce from 'immer'
-import { ToastAndroid } from 'react-native'
 import TrackPlayer, { RepeatMode, State, Track } from 'react-native-track-player'
 import { GetState, SetState } from 'zustand'
 import { Store } from './store'
@@ -32,10 +32,10 @@ export type TrackPlayerSlice = {
   setQueueContextId: (queueContextId?: string) => void
 
   shuffleOrder?: number[]
-  setShuffleOrder: (shuffleOrder?: number[]) => void
+  toggleShuffle: () => Promise<void>
 
   repeatMode: RepeatMode
-  setRepeatMode: (repeatMode: RepeatMode) => void
+  toggleRepeatMode: () => Promise<void>
 
   playerState: State
   setPlayerState: (playerState: State) => void
@@ -45,7 +45,14 @@ export type TrackPlayerSlice = {
   setCurrentTrackIdx: (idx?: number) => void
 
   queue: TrackExt[]
-  setQueue: (queue: TrackExt[]) => void
+  setQueue: (
+    songs: Song[],
+    name: string,
+    contextType: QueueContextType,
+    contextId: string,
+    playTrack?: number,
+    shuffle?: boolean,
+  ) => Promise<void>
 
   progress: Progress
   setProgress: (progress: Progress) => void
@@ -57,7 +64,7 @@ export type TrackPlayerSlice = {
 
   rebuildQueue: () => Promise<void>
   buildStreamUri: (id: string) => string
-  reset: () => void
+  resetTrackPlayerState: () => void
 }
 
 export const selectTrackPlayer = {
@@ -71,11 +78,11 @@ export const selectTrackPlayer = {
   setQueueContextId: (store: TrackPlayerSlice) => store.setQueueContextId,
 
   shuffleOrder: (store: TrackPlayerSlice) => store.shuffleOrder,
-  setShuffleOrder: (store: TrackPlayerSlice) => store.setShuffleOrder,
   shuffled: (store: TrackPlayerSlice) => !!store.shuffleOrder,
+  toggleShuffle: (store: TrackPlayerSlice) => store.toggleShuffle,
 
   repeatMode: (store: TrackPlayerSlice) => store.repeatMode,
-  setRepeatMode: (store: TrackPlayerSlice) => store.setRepeatMode,
+  toggleRepeatMode: (store: TrackPlayerSlice) => store.toggleRepeatMode,
 
   playerState: (store: TrackPlayerSlice) => store.playerState,
   setPlayerState: (store: TrackPlayerSlice) => store.setPlayerState,
@@ -95,7 +102,7 @@ export const selectTrackPlayer = {
   setNetState: (store: TrackPlayerSlice) => store.setNetState,
   buildStreamUri: (store: TrackPlayerSlice) => store.buildStreamUri,
 
-  reset: (store: TrackPlayerSlice) => store.reset,
+  resetTrackPlayerState: (store: TrackPlayerSlice) => store.resetTrackPlayerState,
 }
 
 export const trackPlayerCommands = new PromiseQueue(1)
@@ -111,10 +118,66 @@ export const createTrackPlayerSlice = (set: SetState<Store>, get: GetState<Store
   setQueueContextId: queueContextId => set({ queueContextId }),
 
   shuffleOrder: undefined,
-  setShuffleOrder: shuffleOrder => set({ shuffleOrder }),
+  toggleShuffle: async () => {
+    return trackPlayerCommands.enqueue(async () => {
+      const queue = await getQueue()
+      const current = await getCurrentTrack()
+      const queueShuffleOrder = get().shuffleOrder
+
+      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)
+        set({ 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)
+        }
+
+        set({ shuffleOrder: undefined })
+      }
+
+      set({ queue: await getQueue() })
+      get().setCurrentTrackIdx(await getCurrentTrack())
+    })
+  },
 
   repeatMode: RepeatMode.Off,
-  setRepeatMode: repeatMode => set({ repeatMode }),
+  toggleRepeatMode: async () => {
+    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)
+      set({ repeatMode: nextMode })
+    })
+  },
 
   playerState: State.None,
   setPlayerState: playerState => set({ playerState }),
@@ -131,7 +194,64 @@ export const createTrackPlayerSlice = (set: SetState<Store>, get: GetState<Store
   },
 
   queue: [],
-  setQueue: queue => set({ queue }),
+  setQueue: async (songs, name, contextType, contextId, playTrack, shuffle) => {
+    return trackPlayerCommands.enqueue(async () => {
+      const shuffled = shuffle !== undefined ? shuffle : !!get().shuffleOrder
+
+      await TrackPlayer.setupPlayer()
+      await TrackPlayer.reset()
+
+      if (songs.length === 0) {
+        return
+      }
+
+      let queue = await get().mapSongstoTrackExts(songs)
+
+      try {
+        for (const t of queue) {
+          t.url = get().buildStreamUri(t.id)
+        }
+      } catch {
+        return
+      }
+
+      if (shuffled) {
+        const { tracks, shuffleOrder } = shuffleTracks(queue, playTrack)
+        set({ shuffleOrder })
+        queue = tracks
+        playTrack = 0
+      } else {
+        set({ shuffleOrder: undefined })
+      }
+
+      playTrack = playTrack || 0
+
+      try {
+        set({
+          queue,
+          queueName: name,
+          queueContextType: contextType,
+          queueContextId: contextId,
+        })
+        get().setCurrentTrackIdx(playTrack)
+
+        if (playTrack === 0) {
+          await TrackPlayer.add(queue)
+        } else {
+          const tracks1 = queue.slice(0, playTrack)
+          const tracks2 = queue.slice(playTrack)
+
+          await TrackPlayer.add(tracks2)
+          await TrackPlayer.add(tracks1, 0)
+        }
+
+        await TrackPlayer.play()
+      } catch {
+        get().resetTrackPlayerState()
+        await TrackPlayer.reset()
+      }
+    })
+  },
 
   progress: { position: 0, duration: 0, buffered: 0 },
   setProgress: progress => set({ progress }),
@@ -194,10 +314,13 @@ export const createTrackPlayerSlice = (set: SetState<Store>, get: GetState<Store
       get().setCurrentTrackIdx(currentTrack)
 
       await TrackPlayer.add(queue)
+
       if (currentTrack) {
         await TrackPlayer.skip(currentTrack)
       }
+
       await TrackPlayer.seekTo(position)
+
       if (state === State.Playing) {
         await TrackPlayer.play()
       }
@@ -217,7 +340,7 @@ export const createTrackPlayerSlice = (set: SetState<Store>, get: GetState<Store
     })
   },
 
-  reset: () => {
+  resetTrackPlayerState: () => {
     set({
       queueName: undefined,
       queueContextType: undefined,
@@ -249,3 +372,34 @@ export const getPlayerState = async (): Promise<State> => {
 export const getRepeatMode = async (): Promise<RepeatMode> => {
   return (await TrackPlayer.getRepeatMode()) || RepeatMode.Off
 }
+
+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)])
+}