reorg again, absolute (module) imports

app/state/trackplayer.ts

@@ -0,0 +1,278 @@
+import equal from 'fast-deep-equal'
+import { atom } from 'jotai'
+import { useAtomValue, useUpdateAtom } from 'jotai/utils'
+import { useEffect } from 'react'
+import TrackPlayer, { State, Track } from 'react-native-track-player'
+import { Song } from '@app/models/music'
+import PromiseQueue from '@app/util/PromiseQueue'
+
+type TrackExt = Track & {
+  id: string
+  queueName: string
+  artworkThumb?: string
+}
+
+type OptionalTrackExt = TrackExt | undefined
+
+type Progress = {
+  position: number
+  duration: number
+  buffered: number
+}
+
+const playerState = atom<State>(State.None)
+export const playerStateAtom = atom<State, State>(
+  get => get(playerState),
+  (get, set, update) => {
+    if (get(playerState) !== update) {
+      set(playerState, update)
+    }
+  },
+)
+
+const currentTrack = atom<OptionalTrackExt>(undefined)
+export const currentTrackAtom = atom<OptionalTrackExt, OptionalTrackExt>(
+  get => get(currentTrack),
+  (get, set, update) => {
+    if (!equal(get(currentTrack), update)) {
+      set(currentTrack, update)
+    }
+  },
+)
+
+const _queue = atom<TrackExt[]>([])
+export const queueReadAtom = atom<TrackExt[]>(get => get(_queue))
+export const queueWriteAtom = atom<TrackExt[], TrackExt[]>(
+  get => get(_queue),
+  (get, set, update) => {
+    if (!equal(get(_queue), update)) {
+      set(_queue, update)
+    }
+  },
+)
+
+export const queueNameAtom = atom<string | undefined>(get => {
+  const queue = get(_queue)
+  if (queue.length > 0) {
+    return queue[0].queueName
+  }
+  return undefined
+})
+
+const _progress = atom<Progress>({ position: 0, duration: 0, buffered: 0 })
+export const progressAtom = atom<Progress, Progress>(
+  get => get(_progress),
+  (get, set, update) => {
+    if (!equal(get(_progress), update)) {
+      set(_progress, update)
+    }
+  },
+)
+
+const progressSubs = atom(0)
+export const progressSubsAtom = atom(get => get(progressSubs))
+const addProgressSub = atom(null, (get, set) => {
+  set(progressSubs, get(progressSubs) + 1)
+})
+const removeProgressSub = atom(null, (get, set) => {
+  set(progressSubs, get(progressSubs) - 1)
+})
+
+export const trackPlayerCommands = new PromiseQueue(1)
+
+const getQueue = async (): Promise<TrackExt[]> => {
+  return ((await TrackPlayer.getQueue()) as TrackExt[]) || []
+}
+
+const getTrack = async (index: number): Promise<TrackExt> => {
+  return ((await TrackPlayer.getTrack(index)) as TrackExt) || undefined
+}
+
+const getPlayerState = async (): Promise<State> => {
+  return (await TrackPlayer.getState()) || State.None
+}
+
+const getProgress = async (): Promise<Progress> => {
+  const [position, duration, buffered] = await Promise.all([
+    TrackPlayer.getPosition(),
+    TrackPlayer.getDuration(),
+    TrackPlayer.getBufferedPosition(),
+  ])
+  return {
+    position: position || 0,
+    duration: duration || 0,
+    buffered: buffered || 0,
+  }
+}
+
+export const useRefreshQueue = () => {
+  const setQueue = useUpdateAtom(queueWriteAtom)
+
+  return () =>
+    trackPlayerCommands.enqueue(async () => {
+      setQueue(await getQueue())
+    })
+}
+
+export const useRefreshCurrentTrack = () => {
+  const setCurrentTrack = useUpdateAtom(currentTrackAtom)
+
+  return () =>
+    trackPlayerCommands.enqueue(async () => {
+      const index = await TrackPlayer.getCurrentTrack()
+      if (typeof index === 'number' && index >= 0) {
+        setCurrentTrack(await getTrack(index))
+      } else {
+        setCurrentTrack(undefined)
+      }
+    })
+}
+
+export const useRefreshPlayerState = () => {
+  const setPlayerState = useUpdateAtom(playerStateAtom)
+
+  return () =>
+    trackPlayerCommands.enqueue(async () => {
+      setPlayerState(await getPlayerState())
+    })
+}
+
+export const useRefreshProgress = () => {
+  const setProgress = useUpdateAtom(progressAtom)
+
+  return () =>
+    trackPlayerCommands.enqueue(async () => {
+      setProgress(await getProgress())
+    })
+}
+
+export const usePlay = () => {
+  return () => trackPlayerCommands.enqueue(() => TrackPlayer.play())
+}
+
+export const usePause = () => {
+  return () => trackPlayerCommands.enqueue(() => TrackPlayer.pause())
+}
+
+export const usePrevious = () => {
+  const setCurrentTrack = useUpdateAtom(currentTrackAtom)
+
+  return () =>
+    trackPlayerCommands.enqueue(async () => {
+      const [current, queue] = await Promise.all([await TrackPlayer.getCurrentTrack(), await getQueue()])
+      if (current > 0) {
+        await TrackPlayer.skipToPrevious()
+        setCurrentTrack(queue[current - 1])
+      } else {
+        await TrackPlayer.seekTo(0)
+      }
+      await TrackPlayer.play()
+    })
+}
+
+export const useNext = () => {
+  const setCurrentTrack = useUpdateAtom(currentTrackAtom)
+
+  return () =>
+    trackPlayerCommands.enqueue(async () => {
+      const [current, queue] = await Promise.all([await TrackPlayer.getCurrentTrack(), await getQueue()])
+      if (current >= queue.length - 1) {
+        await TrackPlayer.skip(0)
+        await TrackPlayer.pause()
+        setCurrentTrack(queue[0])
+      } else {
+        await TrackPlayer.skipToNext()
+        setCurrentTrack(queue[current + 1])
+        await TrackPlayer.play()
+      }
+    })
+}
+
+export const useAdd = () => {
+  const setQueue = useUpdateAtom(queueWriteAtom)
+  const setCurrentTrack = useUpdateAtom(currentTrackAtom)
+
+  return (tracks: TrackExt | TrackExt[], insertBeforeindex?: number) =>
+    trackPlayerCommands.enqueue(async () => {
+      await TrackPlayer.add(tracks, insertBeforeindex)
+
+      const queue = await getQueue()
+      setQueue(queue)
+      setCurrentTrack(queue.length > 0 ? queue[await TrackPlayer.getCurrentTrack()] : undefined)
+    })
+}
+
+export const useReset = (enqueue = true) => {
+  const setQueue = useUpdateAtom(queueWriteAtom)
+  const setCurrentTrack = useUpdateAtom(currentTrackAtom)
+
+  const reset = async () => {
+    await TrackPlayer.reset()
+    setQueue([])
+    setCurrentTrack(undefined)
+  }
+
+  return enqueue ? () => trackPlayerCommands.enqueue(reset) : reset
+}
+
+export const useSetQueue = () => {
+  const setCurrentTrack = useUpdateAtom(currentTrackAtom)
+  const setQueue = useUpdateAtom(queueWriteAtom)
+  const reset = useReset(false)
+
+  return async (songs: Song[], name: string, playId?: string) =>
+    trackPlayerCommands.enqueue(async () => {
+      await TrackPlayer.setupPlayer()
+      await reset()
+      const tracks = songs.map(s => mapSongToTrack(s, name))
+
+      if (playId) {
+        setCurrentTrack(tracks.find(t => t.id === playId))
+      }
+
+      if (!playId) {
+        await TrackPlayer.add(tracks)
+      } else if (playId === tracks[0].id) {
+        await TrackPlayer.add(tracks)
+        await TrackPlayer.play()
+      } else {
+        const playIndex = tracks.findIndex(t => t.id === playId)
+        const tracks1 = tracks.slice(0, playIndex)
+        const tracks2 = tracks.slice(playIndex)
+
+        await TrackPlayer.add(tracks2)
+        await TrackPlayer.play()
+
+        await TrackPlayer.add(tracks1, 0)
+      }
+
+      setQueue(await getQueue())
+    })
+}
+
+export const useProgress = () => {
+  const progress = useAtomValue(progressAtom)
+  const addSub = useUpdateAtom(addProgressSub)
+  const removeSub = useUpdateAtom(removeProgressSub)
+
+  useEffect(() => {
+    addSub()
+    return removeSub
+  }, [addSub, removeSub])
+
+  return progress
+}
+
+function mapSongToTrack(song: Song, queueName: string): TrackExt {
+  return {
+    id: song.id,
+    queueName,
+    title: song.title,
+    artist: song.artist || 'Unknown Artist',
+    album: song.album || 'Unknown Album',
+    url: song.streamUri,
+    artwork: song.coverArtUri,
+    artworkThumb: song.coverArtThumbUri,
+    duration: song.duration,
+  }
+}