111 lines
3.4 KiB
TypeScript
111 lines
3.4 KiB
TypeScript
import { useMutation } from "convex/react"
|
|
import { useCallback, useEffect, useRef, type RefObject } from "react"
|
|
import { AppState } from "react-native"
|
|
|
|
import { api } from "@otunes/convex/_generated/api"
|
|
import type { Id } from "@otunes/convex/_generated/dataModel"
|
|
import type { PlaybackStore } from "@otunes/convex/client/playback-store"
|
|
import { flushPersistentCache } from "@/lib/persistent-cache"
|
|
|
|
const PROGRESS_SAVE_INTERVAL_MS = 5000
|
|
|
|
/**
|
|
* Restores the saved position when a song becomes current, and saves the
|
|
* position while it plays, on pause, and when the app leaves the foreground.
|
|
*/
|
|
export function useProgressPersistence({
|
|
store,
|
|
currentSongId,
|
|
isPlaying,
|
|
queueStartVersion,
|
|
currentTimeRef,
|
|
hasPlayer,
|
|
queueSeek,
|
|
resetPosition,
|
|
}: {
|
|
store: PlaybackStore
|
|
currentSongId: Id<"songs"> | null
|
|
isPlaying: boolean
|
|
queueStartVersion: number
|
|
currentTimeRef: RefObject<number>
|
|
hasPlayer: () => boolean
|
|
queueSeek: (seconds: number) => void
|
|
resetPosition: () => void
|
|
}) {
|
|
const updateSongProgressMutation = useMutation(
|
|
api.playback.updateSongProgress
|
|
)
|
|
const storeRef = useRef(store)
|
|
storeRef.current = store
|
|
|
|
const progressRestoredForSongRef = useRef<Id<"songs"> | null>(null)
|
|
const lastSavedProgressRef = useRef(-1)
|
|
const prevIsPlayingRef = useRef(false)
|
|
|
|
const saveProgress = useCallback(
|
|
(seconds: number) => {
|
|
const songId = storeRef.current.getState().queue[0]
|
|
if (!songId) return
|
|
const progressSeconds = Math.max(0, Math.floor(seconds))
|
|
if (progressSeconds === lastSavedProgressRef.current) return
|
|
lastSavedProgressRef.current = progressSeconds
|
|
storeRef.current.setProgress(songId, progressSeconds)
|
|
void updateSongProgressMutation({
|
|
songId,
|
|
progressSeconds,
|
|
}).catch(() => {})
|
|
},
|
|
[updateSongProgressMutation]
|
|
)
|
|
|
|
const resetProgress = useCallback(() => {
|
|
progressRestoredForSongRef.current = null
|
|
lastSavedProgressRef.current = -1
|
|
}, [])
|
|
|
|
useEffect(() => {
|
|
if (!currentSongId) {
|
|
progressRestoredForSongRef.current = null
|
|
return
|
|
}
|
|
|
|
if (progressRestoredForSongRef.current === currentSongId) return
|
|
progressRestoredForSongRef.current = currentSongId
|
|
lastSavedProgressRef.current = -1
|
|
resetPosition()
|
|
// Queue the seek before the song loads, so playback starts there.
|
|
const progressSeconds = store.getState().progressSeconds
|
|
if (progressSeconds > 0) {
|
|
queueSeek(progressSeconds)
|
|
}
|
|
}, [currentSongId, queueStartVersion, queueSeek, resetPosition, store])
|
|
|
|
useEffect(() => {
|
|
if (!currentSongId) return
|
|
if (prevIsPlayingRef.current === isPlaying) return
|
|
prevIsPlayingRef.current = isPlaying
|
|
saveProgress(currentTimeRef.current)
|
|
}, [isPlaying, currentSongId, currentTimeRef, saveProgress])
|
|
|
|
useEffect(() => {
|
|
const subscription = AppState.addEventListener("change", (state) => {
|
|
if (state === "active") return
|
|
if (currentSongId && hasPlayer()) {
|
|
saveProgress(currentTimeRef.current)
|
|
}
|
|
flushPersistentCache()
|
|
})
|
|
return () => subscription.remove()
|
|
}, [currentSongId, currentTimeRef, hasPlayer, saveProgress])
|
|
|
|
useEffect(() => {
|
|
if (!isPlaying || !currentSongId) return
|
|
const interval = setInterval(() => {
|
|
saveProgress(currentTimeRef.current)
|
|
}, PROGRESS_SAVE_INTERVAL_MS)
|
|
return () => clearInterval(interval)
|
|
}, [isPlaying, currentSongId, currentTimeRef, saveProgress])
|
|
|
|
return { resetProgress }
|
|
}
|