Files
otunes/apps/web/components/playback-provider.tsx
T
joshuafhigginsandClaude Opus 5.5 Verified 46b355ae79 fix(convex): keep large libraries under Convex array and read limits
Whole-library and favorites queries return lists split into chunks of at
most 8,192 values, and search keeps the top 500 per section. Favorite
writes and song detail lookups read whole ranges instead of one id at a
time, and large unfavorites finish in scheduled batches, so they stay
under Convex's 4,096 reads per function.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 10:44:19 -05:00

1501 lines
39 KiB
TypeScript

"use client"
import {
useState,
useEffect,
useCallback,
useRef,
RefObject,
createContext,
useContext,
ReactNode,
useSyncExternalStore,
useMemo,
} from "react"
import { useConvex, useMutation, useQuery } from "convex/react"
import type Hls from "hls.js"
import { toast } from "sonner"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import type { BrowseSong } from "@otunes/convex/types"
import {
playbackFormat,
type PlaybackFormat,
type PlaybackQuality,
playbackStreamPlan,
songHlsPlaylistPath,
songPlayPath,
} from "@otunes/convex/playback-stream"
import {
ANONYMOUS_CACHE_SCOPE,
useCacheScope,
} from "@/components/persistent-cache-provider"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { useMediaSession } from "@/hooks/use-media-session"
import { fetchCachedQuery } from "@otunes/convex/client/cached-query"
import { supportsDolbyAtmosPlayback } from "@/lib/dolby-atmos-support"
import { flushPersistentCache } from "@/lib/persistent-cache"
import * as playbackQueue from "@otunes/convex/client/playback-queue"
import type { RepeatMode } from "@otunes/convex/client/playback-queue"
import {
getPlaybackStore,
getServerPlaybackSnapshot,
} from "@otunes/convex/client/playback-store"
import { rememberSongs, useSong } from "@/lib/song-cache"
const PREVIOUS_TRACK_RESTART_THRESHOLD_SECONDS = 5
const PROGRESS_SAVE_INTERVAL_MS = 5000
type PlaybackContextValue = {
queueSongIds: Id<"songs">[]
queueHistorySongIds: Id<"songs">[]
currentFormat: PlaybackFormat | null
currentSong: BrowseSong | null
shuffleEnabled: boolean
repeatEnabled: RepeatMode
queueOpen: boolean
isPlaying: boolean
volume: number
setQueueOpen: (open: boolean) => void
toggleQueueOpen: () => void
setIsPlaying: (playing: boolean) => void
setVolume: (volume: number) => void
playInOrder: (songIds: Id<"songs">[]) => Promise<void>
playShuffled: (songIds: Id<"songs">[]) => Promise<void>
addToQueueNext: (songIds: Id<"songs">[]) => Promise<void>
addToQueueLast: (songIds: Id<"songs">[]) => Promise<void>
playFromSong: (
songId: Id<"songs">,
songIds: Id<"songs">[],
origin?: string
) => Promise<void>
playFromLibrarySong: (
songId: Id<"songs">,
sort: {
sortKey: "title" | "artist" | "album"
sortDirection: "asc" | "desc"
}
) => Promise<void>
/** Pass `songIds` when the caller already has the album's tracks. */
playAlbum: (albumId: Id<"albums">, songIds?: Id<"songs">[]) => Promise<void>
playAlbumShuffled: (
albumId: Id<"albums">,
songIds?: Id<"songs">[]
) => Promise<void>
playArtist: (artistId: Id<"artists">) => Promise<void>
playArtistShuffled: (artistId: Id<"artists">) => Promise<void>
/** Pass `songIds` when the caller already has the playlist's songs. */
playPlaylist: (
playlistId: Id<"playlists">,
songIds?: Id<"songs">[]
) => Promise<void>
playPlaylistShuffled: (
playlistId: Id<"playlists">,
songIds?: Id<"songs">[]
) => Promise<void>
toggleShuffle: () => Promise<void>
cycleRepeat: () => Promise<void>
clearQueue: () => Promise<void>
reorderQueue: (songIds: Id<"songs">[]) => Promise<void>
skipToQueueIndex: (index: number) => Promise<void>
skipNext: () => Promise<void>
skipPrevious: () => Promise<void>
dolbyAtmosSupported: boolean | null
}
type PlaybackActions = Omit<
PlaybackContextValue,
| "queueSongIds"
| "queueHistorySongIds"
| "currentFormat"
| "currentSong"
| "shuffleEnabled"
| "repeatEnabled"
| "queueOpen"
| "isPlaying"
| "volume"
| "dolbyAtmosSupported"
>
const PlaybackContext = createContext<PlaybackContextValue | null>(null)
// Long lists read these narrow contexts so playback state changes do not
// re-render every row.
const PlaybackActionsContext = createContext<PlaybackActions | null>(null)
const CurrentSongIdContext = createContext<Id<"songs"> | null>(null)
const IsPlayingContext = createContext(false)
const PlaybackProgressContext = createContext<{
currentTime: number
duration: number
seekTo: (seconds: number) => void
} | null>(null)
const VOLUME_STORAGE_KEY = "otunes:volume"
const DEFAULT_VOLUME = 80
const volumeListeners = new Set<() => void>()
let dolbyAtmosSnapshot: boolean | undefined
function subscribePlaybackCapabilities() {
return () => {}
}
function getDolbyAtmosSnapshot() {
dolbyAtmosSnapshot ??= supportsDolbyAtmosPlayback(new Audio())
return dolbyAtmosSnapshot
}
function subscribeVolume(listener: () => void) {
volumeListeners.add(listener)
const onStorage = (event: StorageEvent) => {
if (event.key === null || event.key === VOLUME_STORAGE_KEY) {
listener()
}
}
window.addEventListener("storage", onStorage)
return () => {
volumeListeners.delete(listener)
window.removeEventListener("storage", onStorage)
}
}
function notifyVolumeChange() {
for (const listener of volumeListeners) {
listener()
}
}
function readStoredVolume(): number {
try {
const stored = localStorage.getItem(VOLUME_STORAGE_KEY)
if (stored === null) {
return DEFAULT_VOLUME
}
const parsed = Number(stored)
if (!Number.isFinite(parsed)) {
return DEFAULT_VOLUME
}
return Math.min(100, Math.max(0, Math.round(parsed)))
} catch {
return DEFAULT_VOLUME
}
}
type PlaybackLoadSettings = {
preferAtmos: boolean
playbackQuality: PlaybackQuality
useHls: boolean
}
function playbackLoadSettings(
user: {
preferAtmos?: boolean
playbackQuality?: PlaybackQuality
},
dolbyAtmosSupported: boolean | null,
files: Record<string, unknown>
): PlaybackLoadSettings {
const preferAtmos =
dolbyAtmosSupported === true && (user.preferAtmos ?? false)
const plan = playbackStreamPlan(files, user.playbackQuality, preferAtmos)
return {
preferAtmos: plan.preferAtmos,
playbackQuality: plan.playbackQuality,
useHls: plan.useHls,
}
}
function songLoadKey(songId: string, settings: PlaybackLoadSettings) {
return `${songId}:${settings.preferAtmos}:${settings.playbackQuality}:${settings.useHls ? "hls" : "file"}`
}
function destroyHlsInstance(hlsRef: RefObject<Hls | null>) {
hlsRef.current?.destroy()
hlsRef.current = null
}
function adoptPreloadedPlayback(
mainAudio: HTMLAudioElement,
mainHlsRef: RefObject<Hls | null>,
preloadAudio: HTMLAudioElement,
preloadHlsRef: RefObject<Hls | null>
) {
const preloadHls = preloadHlsRef.current
if (preloadHls) {
preloadHls.detachMedia()
preloadHlsRef.current = null
mainHlsRef.current = preloadHls
preloadHls.attachMedia(mainAudio)
} else {
mainAudio.src = preloadAudio.src
}
preloadAudio.pause()
preloadAudio.removeAttribute("src")
}
type AudioSourceCleanup = () => void
function loadAudioSource(
audio: HTMLAudioElement,
hlsRef: RefObject<Hls | null>,
songId: string,
settings: PlaybackLoadSettings,
onReady: () => void
): AudioSourceCleanup {
let disposed = false
let hlsInstance: Hls | null = null
const directUrl = songPlayPath(
songId,
settings.playbackQuality,
settings.preferAtmos
)
const hlsUrl = songHlsPlaylistPath(
songId,
settings.playbackQuality,
settings.preferAtmos
)
const onReadyToPlay = () => {
audio.removeEventListener("loadedmetadata", onReadyToPlay)
audio.removeEventListener("loadeddata", onReadyToPlay)
audio.removeEventListener("canplay", onReadyToPlay)
onReady()
}
audio.addEventListener("loadedmetadata", onReadyToPlay)
audio.addEventListener("loadeddata", onReadyToPlay)
audio.addEventListener("canplay", onReadyToPlay)
const loadDirectSource = () => {
if (disposed) {
return
}
audio.src = directUrl
audio.load()
}
if (settings.useHls && audio.canPlayType("application/vnd.apple.mpegurl")) {
audio.src = hlsUrl
audio.load()
} else if (settings.useHls) {
void import("hls.js")
.then(({ default: HlsConstructor }) => {
if (disposed) {
return
}
if (!HlsConstructor.isSupported()) {
loadDirectSource()
return
}
const hls = new HlsConstructor()
hlsInstance = hls
hlsRef.current = hls
hls.on(HlsConstructor.Events.MANIFEST_PARSED, onReady)
hls.loadSource(hlsUrl)
hls.attachMedia(audio)
})
.catch(loadDirectSource)
} else {
loadDirectSource()
}
return () => {
disposed = true
audio.removeEventListener("loadedmetadata", onReadyToPlay)
audio.removeEventListener("loadeddata", onReadyToPlay)
audio.removeEventListener("canplay", onReadyToPlay)
if (hlsInstance && hlsRef.current === hlsInstance) {
hlsInstance.destroy()
hlsRef.current = null
}
}
}
export function usePlayback() {
const context = useContext(PlaybackContext)
if (!context) {
throw new Error("usePlayback must be used within PlaybackProvider")
}
return context
}
export function usePlaybackActions() {
const context = useContext(PlaybackActionsContext)
if (!context) {
throw new Error("usePlaybackActions must be used within PlaybackProvider")
}
return context
}
export function useCurrentSongId() {
return useContext(CurrentSongIdContext)
}
export function useIsPlaying() {
return useContext(IsPlayingContext)
}
export function usePlaybackProgress() {
const context = useContext(PlaybackProgressContext)
if (!context) {
throw new Error("usePlaybackProgress must be used within PlaybackProvider")
}
return context
}
export function PlaybackProvider({ children }: { children: ReactNode }) {
const convex = useConvex()
const cacheScope = useCacheScope()
const isSignedIn = cacheScope !== ANONYMOUS_CACHE_SCOPE
const store = useMemo(
() => getPlaybackStore(isSignedIn ? cacheScope : null),
[cacheScope, isSignedIn]
)
const playback = useSyncExternalStore(
store.subscribe,
store.getSnapshot,
getServerPlaybackSnapshot
)
const user = useCachedQuery(api.auth.currentUser)
const serverPlayback = useQuery(
api.playback.getPlaybackState,
isSignedIn ? {} : "skip"
)
const syncPlaybackStateMutation = useMutation(api.playback.syncPlaybackState)
const recordPlayMutation = useMutation(api.playback.recordPlay)
const updateSongProgressMutation = useMutation(
api.playback.updateSongProgress
)
useEffect(() => {
if (!isSignedIn) {
return
}
store.setTransport({
sync: (state) =>
syncPlaybackStateMutation({
songQueue: state.queue,
queueHistory: state.history,
shuffleEnabled: state.shuffleEnabled,
repeatEnabled: state.repeatEnabled,
currentSongProgress: state.progressSeconds,
}),
loadProgress: () => convex.query(api.playback.getSongProgress, {}),
})
return () => store.setTransport(null)
}, [store, isSignedIn, syncPlaybackStateMutation, convex])
useEffect(() => {
if (!serverPlayback) {
return
}
if (serverPlayback.currentSong) {
rememberSongs([serverPlayback.currentSong])
}
store.receiveServerState(serverPlayback)
}, [store, serverPlayback])
const recordPlay = useCallback(
(args: { songId?: Id<"songs">; playlistId?: Id<"playlists"> }) => {
void recordPlayMutation(args).catch(() => {})
},
[recordPlayMutation]
)
const audioRef = useRef<HTMLAudioElement | null>(null)
const hlsRef = useRef<Hls | null>(null)
const preloadAudioRef = useRef<HTMLAudioElement | null>(null)
const preloadHlsRef = useRef<Hls | null>(null)
const loadedSongKeyRef = useRef<string | null>(null)
const preloadedSongKeyRef = useRef<string | null>(null)
const playbackErrorHandledRef = useRef(false)
const isPlayingRef = useRef(false)
const autoPlayNextRef = useRef(false)
const intentionalLoadRef = useRef(false)
const ignoreAudioSyncRef = useRef(false)
const progressRestoredForSongRef = useRef<Id<"songs"> | null>(null)
const lastSavedProgressRef = useRef(-1)
const prevIsPlayingRef = useRef(false)
const currentTimeRef = useRef(0)
const durationRef = useRef(0)
const [queueOpen, setQueueOpen] = useState(false)
const [isPlaying, setIsPlaying] = useState(false)
const [playbackStartVersion, setPlaybackStartVersion] = useState(0)
const [currentTime, setCurrentTime] = useState(0)
const [measuredDuration, setMeasuredDuration] = useState<{
songId: string
seconds: number
} | null>(null)
const [progressToRestore, setProgressToRestore] = useState<number | null>(
null
)
const dolbyAtmosSupported = useSyncExternalStore(
subscribePlaybackCapabilities,
getDolbyAtmosSnapshot,
() => null
)
const volume = useSyncExternalStore(
subscribeVolume,
readStoredVolume,
() => DEFAULT_VOLUME
)
const setVolume = useCallback((nextVolume: number) => {
const clamped = Math.min(100, Math.max(0, Math.round(nextVolume)))
try {
localStorage.setItem(VOLUME_STORAGE_KEY, String(clamped))
notifyVolumeChange()
} catch {
// Ignore storage failures (private browsing, quota, etc.)
}
}, [])
const queueSongIds = playback.queue
const currentSongId = queueSongIds[0] ?? null
const currentSong = useSong(currentSongId)
const playbackQuality = user?.playbackQuality
const preferAtmos = user?.preferAtmos
const duration =
currentSongId && measuredDuration?.songId === currentSongId
? measuredDuration.seconds
: (currentSong?.durationSeconds ?? 0)
useEffect(() => {
durationRef.current = duration
}, [duration])
const currentSongDoc = useCachedQuery(
api.library.getSongPlaybackInfo,
currentSongId ? { id: currentSongId } : "skip"
)
const isPlaybackActive = Boolean(currentSongId && isPlaying)
const repeatEnabled = playback.repeatEnabled
const queueLength = queueSongIds.length
const nextQueueSongId = queueSongIds.length > 1 ? queueSongIds[1] : null
const nextQueueSongDoc = useCachedQuery(
api.library.getSongPlaybackInfo,
nextQueueSongId ? { id: nextQueueSongId } : "skip"
)
const seekTo = useCallback((seconds: number) => {
const audio = audioRef.current
if (!audio) {
return
}
const maxDuration =
Number.isFinite(audio.duration) && audio.duration > 0
? audio.duration
: durationRef.current
const clamped = Math.max(0, Math.min(seconds, maxDuration || 0))
audio.currentTime = clamped
currentTimeRef.current = clamped
setCurrentTime(clamped)
}, [])
const saveProgress = useCallback(
(seconds: number) => {
if (!currentSongId) {
return
}
const progressSeconds = Math.max(0, Math.floor(seconds))
if (progressSeconds === lastSavedProgressRef.current) {
return
}
lastSavedProgressRef.current = progressSeconds
store.setProgress(currentSongId, progressSeconds)
if (isSignedIn) {
void updateSongProgressMutation({
songId: currentSongId,
progressSeconds,
}).catch(() => {})
}
},
[currentSongId, store, isSignedIn, updateSongProgressMutation]
)
useEffect(() => {
if (!currentSongId) {
return
}
if (progressRestoredForSongRef.current === currentSongId) {
return
}
progressRestoredForSongRef.current = currentSongId
lastSavedProgressRef.current = -1
setProgressToRestore(store.getState().progressSeconds)
}, [currentSongId, store])
useEffect(() => {
if (progressToRestore === null || progressToRestore <= 0) {
return
}
const audio = audioRef.current
if (!audio || !currentSongId) {
return
}
const applyProgress = () => {
const maxDuration =
Number.isFinite(audio.duration) && audio.duration > 0
? audio.duration
: progressToRestore
const clamped = Math.min(progressToRestore, maxDuration)
audio.currentTime = clamped
currentTimeRef.current = clamped
setCurrentTime(clamped)
setProgressToRestore(null)
}
if (audio.readyState >= HTMLMediaElement.HAVE_METADATA) {
applyProgress()
return
}
audio.addEventListener("loadedmetadata", applyProgress, { once: true })
return () => {
audio.removeEventListener("loadedmetadata", applyProgress)
}
}, [progressToRestore, currentSongId])
useEffect(() => {
const audio = audioRef.current
if (!audio || !currentSongId) {
return
}
if (prevIsPlayingRef.current === isPlaying) {
return
}
prevIsPlayingRef.current = isPlaying
saveProgress(audio.currentTime)
}, [isPlaying, currentSongId, saveProgress])
useEffect(() => {
if (!isPlaying || !currentSongId) {
return
}
const interval = window.setInterval(() => {
const audio = audioRef.current
if (!audio) {
return
}
saveProgress(audio.currentTime)
}, PROGRESS_SAVE_INTERVAL_MS)
return () => {
window.clearInterval(interval)
}
}, [isPlaying, currentSongId, saveProgress])
useEffect(() => {
const persistNow = () => {
const audio = audioRef.current
const restorePending = progressToRestore !== null && progressToRestore > 0
if (audio && currentSongId && !restorePending) {
saveProgress(audio.currentTime)
}
flushPersistentCache()
}
const onVisibilityChange = () => {
if (document.visibilityState === "hidden") {
persistNow()
}
}
window.addEventListener("pagehide", persistNow)
document.addEventListener("visibilitychange", onVisibilityChange)
return () => {
window.removeEventListener("pagehide", persistNow)
document.removeEventListener("visibilitychange", onVisibilityChange)
}
}, [currentSongId, progressToRestore, saveProgress])
useEffect(() => {
isPlayingRef.current = isPlaying
}, [isPlaying])
const runWithoutAudioSync = useCallback((fn: () => void) => {
ignoreAudioSyncRef.current = true
try {
fn()
} finally {
ignoreAudioSyncRef.current = false
}
}, [])
const destroyHls = useCallback(() => {
destroyHlsInstance(hlsRef)
}, [])
const destroyPreloadHls = useCallback(() => {
destroyHlsInstance(preloadHlsRef)
}, [])
const clearPreload = useCallback(() => {
const preloadAudio = preloadAudioRef.current
destroyPreloadHls()
preloadedSongKeyRef.current = null
if (preloadAudio) {
preloadAudio.pause()
preloadAudio.removeAttribute("src")
}
}, [destroyPreloadHls])
useEffect(() => {
const audio = new Audio()
const preloadAudio = new Audio()
preloadAudio.preload = "auto"
audioRef.current = audio
preloadAudioRef.current = preloadAudio
const syncPlayingFromAudio = () => {
if (ignoreAudioSyncRef.current) {
return
}
if (autoPlayNextRef.current && audio.paused) {
return
}
setIsPlaying(!audio.paused)
}
audio.addEventListener("play", syncPlayingFromAudio)
audio.addEventListener("pause", syncPlayingFromAudio)
return () => {
audio.removeEventListener("play", syncPlayingFromAudio)
audio.removeEventListener("pause", syncPlayingFromAudio)
destroyHls()
destroyPreloadHls()
audio.pause()
audio.removeAttribute("src")
preloadAudio.pause()
preloadAudio.removeAttribute("src")
audioRef.current = null
preloadAudioRef.current = null
loadedSongKeyRef.current = null
preloadedSongKeyRef.current = null
}
}, [destroyHls, destroyPreloadHls])
useEffect(() => {
const audio = audioRef.current
if (!audio) {
return
}
audio.volume = volume / 100
}, [volume])
const attemptPlayback = useCallback(
(
audio: HTMLAudioElement,
expectedLoadKey: string,
playState: { playPending: boolean; playSucceeded: boolean }
) => {
if (
!(isPlayingRef.current || autoPlayNextRef.current) ||
playState.playPending ||
playState.playSucceeded
) {
return
}
playState.playPending = true
void audio
.play()
.then(() => {
playState.playPending = false
playState.playSucceeded = true
intentionalLoadRef.current = false
autoPlayNextRef.current = false
isPlayingRef.current = true
setIsPlaying(true)
})
.catch((error: unknown) => {
playState.playPending = false
if (loadedSongKeyRef.current !== expectedLoadKey) {
return
}
if (error instanceof DOMException && error.name === "AbortError") {
return
}
intentionalLoadRef.current = false
autoPlayNextRef.current = false
isPlayingRef.current = false
setIsPlaying(false)
})
},
[]
)
useEffect(() => {
const audio = audioRef.current
const preloadAudio = preloadAudioRef.current
if (!audio) {
return
}
if (!currentSongId) {
autoPlayNextRef.current = false
intentionalLoadRef.current = false
destroyHls()
clearPreload()
audio.pause()
audio.removeAttribute("src")
loadedSongKeyRef.current = null
return
}
if (!user || !currentSongDoc) {
return
}
const settings = playbackLoadSettings(
{ playbackQuality, preferAtmos },
dolbyAtmosSupported,
currentSongDoc.files
)
const loadKey = songLoadKey(currentSongId, settings)
if (loadedSongKeyRef.current === loadKey) {
return
}
playbackErrorHandledRef.current = false
intentionalLoadRef.current = true
runWithoutAudioSync(() => {
audio.pause()
})
const playState = { playPending: false, playSucceeded: false }
const requestPlay = () => {
if (!(isPlayingRef.current || autoPlayNextRef.current)) {
intentionalLoadRef.current = false
return
}
attemptPlayback(audio, loadKey, playState)
}
if (
preloadAudio &&
preloadedSongKeyRef.current === loadKey &&
(preloadHlsRef.current !== null || preloadAudio.src !== "")
) {
destroyHls()
adoptPreloadedPlayback(audio, hlsRef, preloadAudio, preloadHlsRef)
loadedSongKeyRef.current = loadKey
preloadedSongKeyRef.current = null
requestPlay()
return () => {
intentionalLoadRef.current = false
}
}
destroyHls()
loadedSongKeyRef.current = loadKey
const cleanupSource = loadAudioSource(
audio,
hlsRef,
currentSongId,
settings,
requestPlay
)
return () => {
intentionalLoadRef.current = false
cleanupSource()
}
}, [
currentSongId,
currentSongDoc,
user,
playbackQuality,
preferAtmos,
dolbyAtmosSupported,
runWithoutAudioSync,
destroyHls,
clearPreload,
attemptPlayback,
])
useEffect(() => {
const preloadAudio = preloadAudioRef.current
if (!preloadAudio || !nextQueueSongId || !currentSongId) {
clearPreload()
return
}
if (!user || !nextQueueSongDoc) {
return
}
const settings = playbackLoadSettings(
{ playbackQuality, preferAtmos },
dolbyAtmosSupported,
nextQueueSongDoc.files
)
const loadKey = songLoadKey(nextQueueSongId, settings)
if (preloadedSongKeyRef.current === loadKey) {
return
}
clearPreload()
const onPreloadReady = () => {
if (preloadedSongKeyRef.current !== null) {
return
}
preloadedSongKeyRef.current = loadKey
}
const cleanupSource = loadAudioSource(
preloadAudio,
preloadHlsRef,
nextQueueSongId,
settings,
onPreloadReady
)
return () => {
cleanupSource()
if (preloadedSongKeyRef.current === loadKey) {
preloadedSongKeyRef.current = null
}
destroyPreloadHls()
preloadAudio.pause()
preloadAudio.removeAttribute("src")
}
}, [
currentSongId,
nextQueueSongId,
nextQueueSongDoc,
user,
playbackQuality,
preferAtmos,
dolbyAtmosSupported,
clearPreload,
destroyPreloadHls,
])
useEffect(() => {
const audio = audioRef.current
if (!audio || !currentSongId) {
return
}
if (!isPlaying && !autoPlayNextRef.current) {
audio.pause()
return
}
const expectedLoadKey = loadedSongKeyRef.current
if (!expectedLoadKey) {
return
}
const playState = { playPending: false, playSucceeded: false }
if (audio.readyState >= HTMLMediaElement.HAVE_FUTURE_DATA) {
attemptPlayback(audio, expectedLoadKey, playState)
return
}
const onCanPlay = () => {
audio.removeEventListener("canplay", onCanPlay)
attemptPlayback(audio, expectedLoadKey, playState)
}
audio.addEventListener("canplay", onCanPlay)
return () => {
audio.removeEventListener("canplay", onCanPlay)
}
}, [isPlaying, currentSongId, playbackStartVersion, attemptPlayback])
useEffect(() => {
const audio = audioRef.current
if (!audio) {
return
}
const handleEnded = () => {
const loopsSingleSong = repeatEnabled === "always" && queueLength === 1
if (repeatEnabled === "once" || loopsSingleSong) {
audio.currentTime = 0
void audio.play()
return
}
const shouldContinuePlaying = repeatEnabled !== "none" || queueLength > 1
if (shouldContinuePlaying) {
autoPlayNextRef.current = true
isPlayingRef.current = true
setIsPlaying(true)
}
const preloadAudio = preloadAudioRef.current
if (
shouldContinuePlaying &&
preloadAudio &&
nextQueueSongId &&
user &&
nextQueueSongDoc
) {
const settings = playbackLoadSettings(
user,
dolbyAtmosSupported,
nextQueueSongDoc.files
)
const nextLoadKey = songLoadKey(nextQueueSongId, settings)
if (
preloadedSongKeyRef.current === nextLoadKey &&
(preloadHlsRef.current !== null || preloadAudio.src !== "")
) {
intentionalLoadRef.current = true
runWithoutAudioSync(() => {
audio.pause()
})
destroyHls()
adoptPreloadedPlayback(audio, hlsRef, preloadAudio, preloadHlsRef)
loadedSongKeyRef.current = nextLoadKey
preloadedSongKeyRef.current = null
const playState = { playPending: false, playSucceeded: false }
if (audio.readyState >= HTMLMediaElement.HAVE_FUTURE_DATA) {
attemptPlayback(audio, nextLoadKey, playState)
} else {
const onCanPlay = () => {
audio.removeEventListener("canplay", onCanPlay)
attemptPlayback(audio, nextLoadKey, playState)
}
audio.addEventListener("canplay", onCanPlay)
}
}
}
store.update(playbackQueue.skipNext)
if (!shouldContinuePlaying) {
autoPlayNextRef.current = false
isPlayingRef.current = false
audio.pause()
audio.currentTime = 0
currentTimeRef.current = 0
setCurrentTime(0)
setIsPlaying(false)
}
}
const handleError = () => {
if (intentionalLoadRef.current) {
return
}
if (!currentSongId || playbackErrorHandledRef.current) {
return
}
playbackErrorHandledRef.current = true
const { error } = audio
if (error) {
console.error("Audio playback error:", {
code: error.code,
message: error.message,
src: audio.src,
})
}
audio.pause()
autoPlayNextRef.current = false
destroyHls()
audio.removeAttribute("src")
loadedSongKeyRef.current = null
setIsPlaying(false)
toast.error("Playback error", {
description: "Could not play this track. The queue has been cleared.",
})
store.update(playbackQueue.clearQueue)
}
audio.addEventListener("ended", handleEnded)
audio.addEventListener("error", handleError)
return () => {
audio.removeEventListener("ended", handleEnded)
audio.removeEventListener("error", handleError)
}
}, [
repeatEnabled,
currentSongId,
queueLength,
nextQueueSongId,
nextQueueSongDoc,
user,
dolbyAtmosSupported,
store,
destroyHls,
runWithoutAudioSync,
attemptPlayback,
])
useEffect(() => {
const audio = audioRef.current
if (!audio) {
return
}
const syncDuration = () => {
if (!currentSongId) {
return
}
if (Number.isFinite(audio.duration) && audio.duration > 0) {
setMeasuredDuration({
songId: currentSongId,
seconds: audio.duration,
})
} else if (currentSong) {
setMeasuredDuration({
songId: currentSongId,
seconds: currentSong.durationSeconds,
})
}
}
const syncTime = () => {
currentTimeRef.current = audio.currentTime
setCurrentTime(audio.currentTime)
}
audio.addEventListener("timeupdate", syncTime)
audio.addEventListener("durationchange", syncDuration)
audio.addEventListener("loadedmetadata", syncDuration)
audio.addEventListener("seeked", syncTime)
return () => {
audio.removeEventListener("timeupdate", syncTime)
audio.removeEventListener("durationchange", syncDuration)
audio.removeEventListener("loadedmetadata", syncDuration)
audio.removeEventListener("seeked", syncTime)
}
}, [currentSongId, currentSong])
const queueOriginRef = useRef<string | undefined>(undefined)
const playRequestRef = useRef(0)
const startPlayback = useCallback(
(
recipe: (
state: playbackQueue.PlaybackQueueState
) => playbackQueue.PlaybackQueueState,
recorded: { playlistId?: Id<"playlists">; origin?: string } = {}
) => {
playRequestRef.current += 1
queueOriginRef.current =
recorded.origin ??
(recorded.playlistId ? `playlist:${recorded.playlistId}` : undefined)
const previousSongId = store.getState().queue[0]
store.update(playbackQueue.clearQueue)
store.update(recipe)
const firstSongId = store.getState().queue[0]
if (!firstSongId) {
return
}
if (firstSongId === previousSongId) {
seekTo(0)
}
// Repeated Play/Shuffle presses must request playback even when the
// first song and playing state have not changed.
isPlayingRef.current = true
setIsPlaying(true)
setPlaybackStartVersion((version) => version + 1)
recordPlay(
recorded.playlistId
? { playlistId: recorded.playlistId }
: { songId: firstSongId }
)
},
[store, seekTo, recordPlay]
)
const playCollection = useCallback(
async (
songIds: Id<"songs">[] | Promise<Id<"songs">[]>,
shuffled: boolean,
recorded: { playlistId?: Id<"playlists">; origin?: string } = {}
) => {
const request = ++playRequestRef.current
let resolvedSongIds: Id<"songs">[]
try {
resolvedSongIds = await songIds
} catch {
toast.error("Could not load songs to play")
return
}
if (request !== playRequestRef.current || resolvedSongIds.length === 0) {
return
}
startPlayback(
(state) => playbackQueue.startQueue(state, resolvedSongIds, shuffled),
recorded
)
},
[startPlayback]
)
const playInOrder = useCallback(
async (songIds: Id<"songs">[]) => {
if (songIds.length === 0) {
return
}
startPlayback((state) => playbackQueue.startQueue(state, songIds, false))
},
[startPlayback]
)
const playShuffled = useCallback(
async (songIds: Id<"songs">[]) => {
if (songIds.length === 0) {
return
}
startPlayback((state) => playbackQueue.startQueue(state, songIds, true))
},
[startPlayback]
)
const addToQueueNext = useCallback(
async (songIds: Id<"songs">[]) => {
if (songIds.length === 0) {
return
}
store.update((state) => playbackQueue.addToQueue(state, songIds, "next"))
setIsPlaying(true)
},
[store]
)
const addToQueueLast = useCallback(
async (songIds: Id<"songs">[]) => {
if (songIds.length === 0) {
return
}
store.update((state) => playbackQueue.addToQueue(state, songIds, "last"))
setIsPlaying(true)
},
[store]
)
const playFromSong = useCallback(
async (songId: Id<"songs">, songIds: Id<"songs">[], origin?: string) => {
if (
origin &&
queueOriginRef.current === origin &&
store.getState().queue[0] === songId
)
return
startPlayback(
(state) => playbackQueue.startQueueFromSong(state, songId, songIds),
{ origin }
)
},
[startPlayback, store]
)
const playFromLibrarySong = useCallback(
async (
songId: Id<"songs">,
sort: {
sortKey: "title" | "artist" | "album"
sortDirection: "asc" | "desc"
}
) => {
startPlayback((state) =>
playbackQueue.startQueueFromSong(state, songId, [songId])
)
const request = playRequestRef.current
let songIds: Id<"songs">[]
try {
songIds = (
await fetchCachedQuery(
convex,
cacheScope,
api.library.browseSortedSongIds,
sort
)
).flat()
} catch {
return
}
if (request === playRequestRef.current) {
store.update((state) =>
playbackQueue.extendQueueFromSong(state, songId, songIds)
)
}
},
[convex, cacheScope, store, startPlayback]
)
const loadAlbumSongIds = useCallback(
(albumId: Id<"albums">, songIds?: Id<"songs">[]) =>
songIds ??
fetchCachedQuery(convex, cacheScope, api.playlists.getAlbumSongIds, {
albumId,
}),
[convex, cacheScope]
)
const loadArtistSongIds = useCallback(
(artistId: Id<"artists">) =>
fetchCachedQuery(
convex,
cacheScope,
api.playlists.getOrderedArtistSongIds,
{ artistId }
).then((chunks) => chunks.flat()),
[convex, cacheScope]
)
const loadPlaylistSongIds = useCallback(
(playlistId: Id<"playlists">, songIds?: Id<"songs">[]) =>
songIds ??
fetchCachedQuery(convex, cacheScope, api.playlists.getPlaylistSongIds, {
playlistId,
}),
[convex, cacheScope]
)
const playAlbum = useCallback(
(albumId: Id<"albums">, songIds?: Id<"songs">[]) =>
playCollection(loadAlbumSongIds(albumId, songIds), false, {
origin: `album:${albumId}`,
}),
[playCollection, loadAlbumSongIds]
)
const playAlbumShuffled = useCallback(
(albumId: Id<"albums">, songIds?: Id<"songs">[]) =>
playCollection(loadAlbumSongIds(albumId, songIds), true, {
origin: `album:${albumId}`,
}),
[playCollection, loadAlbumSongIds]
)
const playArtist = useCallback(
(artistId: Id<"artists">) =>
playCollection(loadArtistSongIds(artistId), false),
[playCollection, loadArtistSongIds]
)
const playArtistShuffled = useCallback(
(artistId: Id<"artists">) =>
playCollection(loadArtistSongIds(artistId), true),
[playCollection, loadArtistSongIds]
)
const playPlaylist = useCallback(
(playlistId: Id<"playlists">, songIds?: Id<"songs">[]) =>
playCollection(loadPlaylistSongIds(playlistId, songIds), false, {
playlistId,
}),
[playCollection, loadPlaylistSongIds]
)
const playPlaylistShuffled = useCallback(
(playlistId: Id<"playlists">, songIds?: Id<"songs">[]) =>
playCollection(loadPlaylistSongIds(playlistId, songIds), true, {
playlistId,
}),
[playCollection, loadPlaylistSongIds]
)
const toggleQueueOpen = useCallback(() => {
setQueueOpen((open) => !open)
}, [])
const toggleShuffle = useCallback(async () => {
store.update(playbackQueue.toggleShuffle)
}, [store])
const cycleRepeat = useCallback(async () => {
store.update(playbackQueue.cycleRepeat)
}, [store])
const clearQueue = useCallback(async () => {
playRequestRef.current += 1
store.update(playbackQueue.clearQueue)
setIsPlaying(false)
}, [store])
const reorderQueue = useCallback(
async (songIds: Id<"songs">[]) => {
store.update((state) => playbackQueue.reorderQueue(state, songIds))
},
[store]
)
const skipToQueueIndex = useCallback(
async (index: number) => {
store.update((state) => playbackQueue.skipToQueueIndex(state, index))
},
[store]
)
const skipNext = useCallback(async () => {
const before = store.getState()
if (before.repeatEnabled === "none" && before.queue.length <= 1) {
setIsPlaying(false)
}
store.update(playbackQueue.skipNext)
if (store.getState().queue[0] === before.queue[0]) {
seekTo(0)
}
}, [store, seekTo])
const skipPrevious = useCallback(async () => {
if (currentTimeRef.current > PREVIOUS_TRACK_RESTART_THRESHOLD_SECONDS) {
seekTo(0)
return
}
const previousSongId = store.getState().queue[0]
store.update(playbackQueue.skipPrevious)
if (store.getState().queue[0] === previousSongId) {
seekTo(0)
}
}, [store, seekTo])
useMediaSession({
song: currentSong,
isPlaying: isPlaybackActive,
duration,
currentTime,
seekTo,
setIsPlaying,
skipNext,
skipPrevious,
})
const currentFormat =
currentSongDoc && user
? playbackFormat(
currentSongDoc.files,
user.playbackQuality,
dolbyAtmosSupported === true && (user.preferAtmos ?? false)
)
: null
const actions = useMemo<PlaybackActions>(
() => ({
setQueueOpen,
toggleQueueOpen,
setIsPlaying,
setVolume,
playInOrder,
playShuffled,
addToQueueNext,
addToQueueLast,
playFromSong,
playFromLibrarySong,
playAlbum,
playAlbumShuffled,
playArtist,
playArtistShuffled,
playPlaylist,
playPlaylistShuffled,
toggleShuffle,
cycleRepeat,
clearQueue,
reorderQueue,
skipToQueueIndex,
skipNext,
skipPrevious,
}),
[
toggleQueueOpen,
setVolume,
playInOrder,
playShuffled,
addToQueueNext,
addToQueueLast,
playFromSong,
playFromLibrarySong,
playAlbum,
playAlbumShuffled,
playArtist,
playArtistShuffled,
playPlaylist,
playPlaylistShuffled,
toggleShuffle,
cycleRepeat,
clearQueue,
reorderQueue,
skipToQueueIndex,
skipNext,
skipPrevious,
]
)
const value = useMemo<PlaybackContextValue>(
() => ({
...actions,
queueSongIds: playback.queue,
queueHistorySongIds: playback.history,
currentSong,
currentFormat,
shuffleEnabled: playback.shuffleEnabled,
repeatEnabled: playback.repeatEnabled,
queueOpen,
isPlaying: isPlaybackActive,
volume,
dolbyAtmosSupported,
}),
[
actions,
playback,
currentSong,
currentFormat,
queueOpen,
isPlaybackActive,
volume,
dolbyAtmosSupported,
]
)
const progressValue = useMemo(
() => ({ currentTime, duration, seekTo }),
[currentTime, duration, seekTo]
)
return (
<PlaybackActionsContext.Provider value={actions}>
<CurrentSongIdContext.Provider value={currentSongId}>
<IsPlayingContext.Provider value={isPlaybackActive}>
<PlaybackContext.Provider value={value}>
<PlaybackProgressContext.Provider value={progressValue}>
{children}
</PlaybackProgressContext.Provider>
</PlaybackContext.Provider>
</IsPlayingContext.Provider>
</CurrentSongIdContext.Provider>
</PlaybackActionsContext.Provider>
)
}