From d66e26d0f41a778f599d813d569d1a028c280ba0 Mon Sep 17 00:00:00 2001 From: Joshua Higgins Date: Wed, 19 Aug 2026 11:44:29 -0400 Subject: [PATCH] feat(mobile): use native playlists for queued playback (#17) - Add native playlist windowing and lock-screen controls - Sync playback queues through a batched Convex song query --------- Co-authored-by: Rem Helper Reviewed-on: https://git.abunchofknowitalls.com/joshuafhiggins/otunes/pulls/17 --- apps/mobile/contexts/playback.tsx | 597 ++++++++++-------- apps/mobile/lib/audio-playlist-lock-screen.ts | 80 +++ apps/mobile/lib/native-playlist-window.ts | 56 ++ packages/convex/convex/library.ts | 17 + 4 files changed, 480 insertions(+), 270 deletions(-) create mode 100644 apps/mobile/lib/audio-playlist-lock-screen.ts create mode 100644 apps/mobile/lib/native-playlist-window.ts diff --git a/apps/mobile/contexts/playback.tsx b/apps/mobile/contexts/playback.tsx index c50757a..d6dbe08 100644 --- a/apps/mobile/contexts/playback.tsx +++ b/apps/mobile/contexts/playback.tsx @@ -1,9 +1,10 @@ import { - createAudioPlayer, + createAudioPlaylist, setAudioModeAsync, type AudioMetadata, - type AudioPlayer, - type AudioStatus, + type AudioPlaylist, + type AudioPlaylistStatus, + type AudioSource, } from "expo-audio" import { useConvex, useMutation, useQuery } from "convex/react" import { @@ -26,6 +27,16 @@ import { playbackStreamPlan } from "@otunes/convex/playback-stream" import { getAuthCookieHeader } from "@/lib/auth-cookies" import { showError } from "@/lib/toast" import { albumCoverUrl, songAudioSource } from "@/lib/urls" +import { + activatePlaylistLockScreen, + releaseAudioPlaylist, + updatePlaylistLockScreenMetadata, +} from "@/lib/audio-playlist-lock-screen" +import { + nativePlaylistNeedsRebuild, + nativePlaylistSongIds, + repeatToPlaylistLoop, +} from "@/lib/native-playlist-window" type RepeatMode = "none" | "once" | "always" @@ -33,12 +44,6 @@ const PREVIOUS_TRACK_RESTART_THRESHOLD_SECONDS = 5 const VOLUME_STORAGE_KEY = "otunes:volume" const DEFAULT_VOLUME = 0.8 -function statusLooksPaused(status: AudioStatus) { - const timeControlStatus = status.timeControlStatus.toLowerCase() - const playbackState = status.playbackState.toLowerCase() - return timeControlStatus.includes("paused") || playbackState.includes("paused") -} - function lockScreenMetadata( song: BrowseSong, serverUrl: string @@ -121,9 +126,15 @@ export function PlaybackProvider({ children }: { children: ReactNode }) { const user = useQuery(api.auth.currentUser) const playback = useQuery(api.playback.getPlaybackState) - const playerRef = useRef(null) + const playlistRef = useRef(null) const statusSubscriptionRef = useRef<{ remove: () => void } | null>(null) - const loadedSongKeyRef = useRef(null) + const trackChangedSubscriptionRef = useRef<{ remove: () => void } | null>( + null + ) + const loadedSongIdsRef = useRef[]>([]) + const loadedLoadKeyRef = useRef(null) + const ignoreTrackChangeRef = useRef(false) + const applyingFromNativeRef = useRef(false) const autoPlayNextRef = useRef(false) const isPlayingRef = useRef(false) const progressRestoredForSongRef = useRef | null>(null) @@ -131,21 +142,18 @@ export function PlaybackProvider({ children }: { children: ReactNode }) { const prevIsPlayingRef = useRef(false) const currentTimeRef = useRef(0) const pendingSeekRef = useRef(null) - const prevSongIdRef = useRef | null>(null) - const pendingSongChangeRef = useRef(false) const currentSongIdRef = useRef | null>(null) - const loadedSongIdRef = useRef | null>(null) const loadRequestIdRef = useRef(0) const handlingEndRef = useRef(false) - // While set, block playback of this song so skip-while-paused cannot - // restart the current track before the queue advances. - const skippingFromSongIdRef = useRef | null>(null) + const volumeRef = useRef(DEFAULT_VOLUME) const [isPlaying, setIsPlayingState] = useState(false) const [currentTime, setCurrentTime] = useState(0) const [duration, setDuration] = useState(0) const [volume, setVolumeState] = useState(DEFAULT_VOLUME) - const [progressToRestore, setProgressToRestore] = useState(null) + const [progressToRestore, setProgressToRestore] = useState( + null + ) const playInOrderMutation = useMutation(api.playback.playInOrder) const playShuffledMutation = useMutation(api.playback.playShuffled) @@ -162,11 +170,15 @@ export function PlaybackProvider({ children }: { children: ReactNode }) { const skipToQueueIndexMutation = useMutation(api.playback.skipToQueueIndex) const skipNextMutation = useMutation(api.playback.skipNext) const skipPreviousMutation = useMutation(api.playback.skipPrevious) - const updateSongProgressMutation = useMutation(api.playback.updateSongProgress) + const updateSongProgressMutation = useMutation( + api.playback.updateSongProgress + ) const currentSong = playback?.currentSong ?? null const repeatEnabled = playback?.repeatEnabled ?? "none" const queueLength = playback?.queueSongIds.length ?? 0 + const queueSongIds = playback?.queueSongIds ?? [] + const queueHistorySongIds = playback?.queueHistorySongIds ?? [] useEffect(() => { currentSongIdRef.current = currentSong?.id ?? null @@ -174,6 +186,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) { const repeatEnabledRef = useRef(repeatEnabled) const queueLengthRef = useRef(queueLength) + const historyLengthRef = useRef(queueHistorySongIds.length) useEffect(() => { repeatEnabledRef.current = repeatEnabled @@ -183,74 +196,82 @@ export function PlaybackProvider({ children }: { children: ReactNode }) { queueLengthRef.current = queueLength }, [queueLength]) + useEffect(() => { + historyLengthRef.current = queueHistorySongIds.length + }, [queueHistorySongIds.length]) + const skipNextMutationRef = useRef(skipNextMutation) useEffect(() => { skipNextMutationRef.current = skipNextMutation }, [skipNextMutation]) - const destroyPlayer = useCallback(() => { + const skipPreviousMutationRef = useRef(skipPreviousMutation) + useEffect(() => { + skipPreviousMutationRef.current = skipPreviousMutation + }, [skipPreviousMutation]) + + const skipToQueueIndexMutationRef = useRef(skipToQueueIndexMutation) + useEffect(() => { + skipToQueueIndexMutationRef.current = skipToQueueIndexMutation + }, [skipToQueueIndexMutation]) + + const destroyPlaylist = useCallback(() => { statusSubscriptionRef.current?.remove() statusSubscriptionRef.current = null - const player = playerRef.current - player?.pause() - player?.setActiveForLockScreen(false) - player?.remove() - playerRef.current = null - loadedSongKeyRef.current = null - loadedSongIdRef.current = null + trackChangedSubscriptionRef.current?.remove() + trackChangedSubscriptionRef.current = null + const playlist = playlistRef.current + if (playlist) { + playlist.pause() + releaseAudioPlaylist(playlist) + } + playlistRef.current = null + loadedSongIdsRef.current = [] + loadedLoadKeyRef.current = null }, []) - const handlePlaybackStatusUpdate = useCallback((status: AudioStatus) => { - if (!status.isLoaded) return - if (loadedSongIdRef.current !== currentSongIdRef.current) return - if ( - skippingFromSongIdRef.current !== null && - loadedSongIdRef.current === skippingFromSongIdRef.current - ) { - return - } - - currentTimeRef.current = status.currentTime - setCurrentTime(status.currentTime) - if (status.duration > 0) { - setDuration(status.duration) - } - - if (pendingSeekRef.current !== null && pendingSeekRef.current > 0) { - const seekSeconds = pendingSeekRef.current - pendingSeekRef.current = null - void playerRef.current?.seekTo(seekSeconds) - currentTimeRef.current = seekSeconds - setCurrentTime(seekSeconds) - } - - if (status.playing) { - autoPlayNextRef.current = false - if (!isPlayingRef.current) { - isPlayingRef.current = true - setIsPlayingState(true) - } - } else if ( - isPlayingRef.current && - !status.didJustFinish && - statusLooksPaused(status) - ) { - autoPlayNextRef.current = false - isPlayingRef.current = false - setIsPlayingState(false) - } - - if (status.didJustFinish) { - if (handlingEndRef.current) return - handlingEndRef.current = true - - if (repeatEnabledRef.current === "once") { - void playerRef.current?.seekTo(0) - playerRef.current?.play() - handlingEndRef.current = false + const handlePlaylistStatusUpdate = useCallback( + (status: AudioPlaylistStatus) => { + if (!status.isLoaded) return + if ( + loadedSongIdsRef.current[status.currentIndex] !== + currentSongIdRef.current + ) { return } + currentTimeRef.current = status.currentTime + setCurrentTime(status.currentTime) + if (status.duration > 0) { + setDuration(status.duration) + } + + if (pendingSeekRef.current !== null && pendingSeekRef.current > 0) { + const seekSeconds = pendingSeekRef.current + pendingSeekRef.current = null + void playlistRef.current?.seekTo(seekSeconds) + currentTimeRef.current = seekSeconds + setCurrentTime(seekSeconds) + } + + if (status.playing) { + autoPlayNextRef.current = false + if (!isPlayingRef.current) { + isPlayingRef.current = true + setIsPlayingState(true) + } + } else if (isPlayingRef.current && !status.didJustFinish) { + autoPlayNextRef.current = false + isPlayingRef.current = false + setIsPlayingState(false) + } + + if (!status.didJustFinish) return + if (handlingEndRef.current) return + if (repeatEnabledRef.current === "once") return + if (status.currentIndex < status.trackCount - 1) return + + handlingEndRef.current = true const shouldContinue = repeatEnabledRef.current !== "none" || queueLengthRef.current > 1 if (shouldContinue) { @@ -271,7 +292,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) { autoPlayNextRef.current = false isPlayingRef.current = false - void playerRef.current?.seekTo(0) + void playlistRef.current?.seekTo(0) currentTimeRef.current = 0 setCurrentTime(0) setIsPlayingState(false) @@ -284,23 +305,72 @@ export function PlaybackProvider({ children }: { children: ReactNode }) { .finally(() => { handlingEndRef.current = false }) - } - }, []) + }, + [] + ) - const ensurePlayer = useCallback(() => { - if (playerRef.current) { - return playerRef.current - } + const handleTrackChanged = useCallback( + (data: { currentIndex: number; previousIndex: number }) => { + if (ignoreTrackChangeRef.current) return + if (data.currentIndex === data.previousIndex) return - const player = createAudioPlayer(null, { updateInterval: 500 }) - player.volume = volume - statusSubscriptionRef.current = player.addListener( - "playbackStatusUpdate", - handlePlaybackStatusUpdate - ) - playerRef.current = player - return player - }, [handlePlaybackStatusUpdate, volume]) + applyingFromNativeRef.current = true + autoPlayNextRef.current = true + isPlayingRef.current = true + setIsPlayingState(true) + + const steps = data.currentIndex - data.previousIndex + if (steps > 0) { + void ( + steps === 1 + ? skipNextMutationRef.current() + : skipToQueueIndexMutationRef.current({ index: steps }) + ).catch(() => { + applyingFromNativeRef.current = false + }) + return + } + + void (async () => { + for (let i = 0; i < -steps; i++) { + await skipPreviousMutationRef.current() + } + })().catch(() => { + applyingFromNativeRef.current = false + }) + }, + [] + ) + + const ensurePlaylist = useCallback( + (sources: AudioSource[]) => { + if (playlistRef.current) { + return playlistRef.current + } + + ignoreTrackChangeRef.current = true + const playlist = createAudioPlaylist({ + sources, + updateInterval: 500, + loop: repeatToPlaylistLoop(repeatEnabledRef.current), + }) + playlist.volume = volumeRef.current + statusSubscriptionRef.current = playlist.addListener( + "playlistStatusUpdate", + handlePlaylistStatusUpdate + ) + trackChangedSubscriptionRef.current = playlist.addListener( + "trackChanged", + handleTrackChanged + ) + playlistRef.current = playlist + setTimeout(() => { + ignoreTrackChangeRef.current = false + }, 150) + return playlist + }, + [handlePlaylistStatusUpdate, handleTrackChanged] + ) useEffect(() => { void setAudioModeAsync({ @@ -319,61 +389,52 @@ export function PlaybackProvider({ children }: { children: ReactNode }) { }) return () => { - destroyPlayer() + destroyPlaylist() } - }, [destroyPlayer]) + }, [destroyPlaylist]) useEffect(() => { - if (playerRef.current) { - playerRef.current.volume = volume + volumeRef.current = volume + if (playlistRef.current) { + playlistRef.current.volume = volume } }, [volume]) + useEffect(() => { + const playlist = playlistRef.current + if (playlist) { + playlist.loop = repeatToPlaylistLoop(repeatEnabled) + } + }, [repeatEnabled]) + const setIsPlaying = useCallback((playing: boolean) => { - skippingFromSongIdRef.current = null isPlayingRef.current = playing setIsPlayingState(playing) - const player = playerRef.current - if (!player) return + const playlist = playlistRef.current + if (!playlist) return if (playing) { - player.play() + playlist.play() } else { - player.pause() + playlist.pause() } }, []) - const beginQueueSkip = useCallback(() => { - skippingFromSongIdRef.current = currentSongIdRef.current - // Cancel in-flight loads so they cannot replace/restart the current track. - loadRequestIdRef.current += 1 - - // Never unpause the current track during a skip. Playback resumes only - // after the next song has been loaded. - playerRef.current?.pause() - isPlayingRef.current = false - setIsPlayingState(false) - autoPlayNextRef.current = true - }, []) - - const clearQueueSkip = useCallback(() => { - skippingFromSongIdRef.current = null - }, []) - const setVolume = useCallback((nextVolume: number) => { const clamped = Math.min(1, Math.max(0, nextVolume)) setVolumeState(clamped) void AsyncStorage.setItem(VOLUME_STORAGE_KEY, String(clamped)) - if (playerRef.current) { - playerRef.current.volume = clamped + if (playlistRef.current) { + playlistRef.current.volume = clamped } }, []) const seekTo = useCallback( async (seconds: number) => { - const player = playerRef.current - if (!player) return - const clamped = Math.max(0, Math.min(seconds, duration || 0)) - await player.seekTo(clamped) + const playlist = playlistRef.current + if (!playlist) return + const maxDuration = playlist.duration || duration || 0 + const clamped = Math.max(0, Math.min(seconds, maxDuration)) + await playlist.seekTo(clamped) currentTimeRef.current = clamped setCurrentTime(clamped) }, @@ -392,52 +453,31 @@ export function PlaybackProvider({ children }: { children: ReactNode }) { useEffect(() => { if (!currentSong) { - prevSongIdRef.current = null - loadedSongKeyRef.current = null - loadedSongIdRef.current = null - skippingFromSongIdRef.current = null - destroyPlayer() + progressRestoredForSongRef.current = null + applyingFromNativeRef.current = false + destroyPlaylist() return } - if (prevSongIdRef.current === currentSong.id) return - - const isInitialLoad = prevSongIdRef.current === null - prevSongIdRef.current = currentSong.id - loadedSongKeyRef.current = null - loadedSongIdRef.current = null - pendingSeekRef.current = null - progressRestoredForSongRef.current = null - currentTimeRef.current = 0 - setCurrentTime(0) - setDuration(0) - setProgressToRestore(null) - lastSavedProgressRef.current = -1 - if (!isInitialLoad) { - pendingSongChangeRef.current = true - destroyPlayer() - } - }, [currentSong?.id, destroyPlayer]) - - useEffect(() => { - if (!currentSong || !playback) return if (progressRestoredForSongRef.current === currentSong.id) return progressRestoredForSongRef.current = currentSong.id lastSavedProgressRef.current = -1 - if (pendingSongChangeRef.current) { - pendingSongChangeRef.current = false + currentTimeRef.current = 0 + setCurrentTime(0) + setDuration(currentSong.durationSeconds) + if (applyingFromNativeRef.current) { + applyingFromNativeRef.current = false setProgressToRestore(0) return } - setProgressToRestore(playback.currentSongProgress ?? 0) - }, [currentSong?.id, playback]) + setProgressToRestore(playback?.currentSongProgress ?? 0) + }, [currentSong?.id, currentSong, destroyPlaylist, playback]) useEffect(() => { if (progressToRestore === null || progressToRestore <= 0) return - if (!currentSong || !playerRef.current) return + if (!currentSong || !playlistRef.current) return - const maxDuration = - duration > 0 ? duration : progressToRestore + const maxDuration = duration > 0 ? duration : progressToRestore const clamped = Math.min(progressToRestore, maxDuration) pendingSeekRef.current = clamped setProgressToRestore(null) @@ -452,33 +492,21 @@ export function PlaybackProvider({ children }: { children: ReactNode }) { useEffect(() => { const loadRequestId = ++loadRequestIdRef.current - const isCurrentLoad = () => - loadRequestIdRef.current === loadRequestId && - currentSongIdRef.current === currentSong?.id + const isCurrentLoad = () => loadRequestIdRef.current === loadRequestId - async function loadSong() { + async function syncPlaylist() { if (!config || !currentSong || user === undefined || !user) { if (!currentSong) { - destroyPlayer() + destroyPlaylist() } return } - const song = await convex.query(api.library.getSong, { - id: currentSong.id, - }) - if (!song || !isCurrentLoad()) { - return - } - - const plan = playbackStreamPlan( - song.files, - user.playbackQuality, - user.preferAtmos ?? false + const windowSongIds = nativePlaylistSongIds( + queueHistorySongIds, + queueSongIds ) - const loadKey = `${currentSong.id}:${plan.playbackQuality}:${plan.useHls ? "hls" : "file"}` - if (loadedSongKeyRef.current === loadKey) return - + const currentIndex = queueHistorySongIds.length const cookieHeader = await getAuthCookieHeader( config.serverUrl, config.convexUrl @@ -487,87 +515,119 @@ export function PlaybackProvider({ children }: { children: ReactNode }) { showError("Your session has expired. Please sign in again.") return } + if (!isCurrentLoad()) return + const loadKey = `${user.playbackQuality}:${user.preferAtmos ?? false}:${cookieHeader}` + const needsRebuild = + loadedLoadKeyRef.current !== loadKey || + nativePlaylistNeedsRebuild( + loadedSongIdsRef.current, + queueHistorySongIds, + queueSongIds + ) + + const metadata = lockScreenMetadata(currentSong, config.serverUrl) + const shouldPlay = isPlayingRef.current || autoPlayNextRef.current + + if (!needsRebuild) { + const playlist = playlistRef.current + if (!playlist) return + ignoreTrackChangeRef.current = true + if (playlist.currentIndex !== currentIndex) { + playlist.skipTo(currentIndex) + } + playlist.loop = repeatToPlaylistLoop(repeatEnabled) + playlist.volume = volumeRef.current + updatePlaylistLockScreenMetadata(playlist, metadata) + setTimeout(() => { + ignoreTrackChangeRef.current = false + }, 150) + if (shouldPlay) { + isPlayingRef.current = true + setIsPlayingState(true) + playlist.play() + } + return + } + + const songs = await convex.query(api.library.getSongsForPlayback, { + ids: windowSongIds, + }) + if (!isCurrentLoad()) return + + const sources: AudioSource[] = [] + for (let i = 0; i < windowSongIds.length; i++) { + const song = songs[i] + if (!song) { + showError("Could not play this track. The queue has been cleared.") + void clearQueueMutation() + setIsPlayingState(false) + return + } + const plan = playbackStreamPlan( + song.files, + user.playbackQuality, + user.preferAtmos ?? false + ) + sources.push( + songAudioSource( + config.serverUrl, + song.id, + plan.playbackQuality, + plan.preferAtmos, + plan.useHls, + { cookieHeader, songTitle: song.title } + ) + ) + } + + ignoreTrackChangeRef.current = true + destroyPlaylist() if (!isCurrentLoad()) { + ignoreTrackChangeRef.current = false return } - const source = songAudioSource( - config.serverUrl, - currentSong.id, - plan.playbackQuality, - plan.preferAtmos, - plan.useHls, - { cookieHeader, songTitle: currentSong.title } - ) - - if ( - skippingFromSongIdRef.current !== null && - skippingFromSongIdRef.current === currentSong.id - ) { - return + const playlist = ensurePlaylist(sources) + loadedSongIdsRef.current = windowSongIds + loadedLoadKeyRef.current = loadKey + playlist.volume = volumeRef.current + playlist.loop = repeatToPlaylistLoop(repeatEnabled) + if (currentIndex > 0) { + playlist.skipTo(currentIndex) } + activatePlaylistLockScreen(playlist, metadata) + setTimeout(() => { + ignoreTrackChangeRef.current = false + }, 150) - const shouldPlayAfterLoad = isPlayingRef.current || autoPlayNextRef.current - - destroyPlayer() - if (!isCurrentLoad()) { - return - } - - if ( - skippingFromSongIdRef.current !== null && - skippingFromSongIdRef.current === currentSong.id - ) { - return - } - - const player = ensurePlayer() - loadedSongKeyRef.current = loadKey - loadedSongIdRef.current = currentSong.id - skippingFromSongIdRef.current = null - - player.replace(source) - player.volume = volume - player.setActiveForLockScreen( - true, - lockScreenMetadata(currentSong, config.serverUrl), - { showSeekForward: true, showSeekBackward: true } - ) - - if (!isCurrentLoad()) { - return - } - - if (shouldPlayAfterLoad) { + if (shouldPlay) { isPlayingRef.current = true setIsPlayingState(true) - player.play() + playlist.play() } else { - player.pause() + playlist.pause() } setDuration(currentSong.durationSeconds) } - void loadSong().catch(() => { + void syncPlaylist().catch(() => { showError("Could not play this track. The queue has been cleared.") void clearQueueMutation() setIsPlayingState(false) }) }, [ - config, - currentSong?.id, - user?.playbackQuality, - user?.preferAtmos, - user === undefined, - volume, - destroyPlayer, - ensurePlayer, clearQueueMutation, - currentSong, - user, + config, convex, + currentSong, + destroyPlaylist, + ensurePlaylist, + queueHistorySongIds, + queueSongIds, + repeatEnabled, + user, ]) useEffect(() => { @@ -711,11 +771,11 @@ export function PlaybackProvider({ children }: { children: ReactNode }) { const value = useMemo( () => ({ - queueSongIds: playback?.queueSongIds ?? [], - queueHistorySongIds: playback?.queueHistorySongIds ?? [], - currentSong: playback?.currentSong ?? null, + queueSongIds, + queueHistorySongIds, + currentSong, shuffleEnabled: playback?.shuffleEnabled ?? false, - repeatEnabled: playback?.repeatEnabled ?? "none", + repeatEnabled, isPlaying: Boolean(currentSong && isPlaying), volume, currentTime, @@ -750,28 +810,25 @@ export function PlaybackProvider({ children }: { children: ReactNode }) { }, skipToQueueIndex: async (index) => { if (index <= 0) return - beginQueueSkip() + autoPlayNextRef.current = true await skipToQueueIndexMutation({ index }) }, skipNext: async () => { const isFinishingQueue = repeatEnabled === "none" && queueLength <= 1 if (isFinishingQueue) { - clearQueueSkip() setIsPlaying(false) await seekTo(0) await skipNextMutation() await seekTo(0) return } - // These paths keep the same current song id — restart in place. if (repeatEnabled === "once" || queueLength <= 1) { - clearQueueSkip() await seekTo(0) await skipNextMutation() setIsPlaying(true) return } - beginQueueSkip() + autoPlayNextRef.current = true await skipNextMutation() }, skipPrevious: async () => { @@ -779,56 +836,56 @@ export function PlaybackProvider({ children }: { children: ReactNode }) { await seekTo(0) return } - const historyLength = playback?.queueHistorySongIds.length ?? 0 - if (historyLength === 0) { - clearQueueSkip() + if (queueHistorySongIds.length === 0) { await seekTo(0) await skipPreviousMutation() return } - beginQueueSkip() + autoPlayNextRef.current = true await skipPreviousMutation() }, }), [ - playback, - currentSong, - isPlaying, - volume, - currentTime, - duration, - seekTo, - setIsPlaying, - setVolume, - playInOrder, - playShuffled, - addToQueueNext, addToQueueLast, - playFromSong, - playFromLibrarySong, + addToQueueNext, + currentSong, + currentTime, + cycleRepeatMutation, + duration, + isPlaying, playAlbum, playAlbumShuffled, playArtist, playArtistShuffled, + playFromLibrarySong, + playFromSong, + playInOrder, playPlaylist, playPlaylistShuffled, - toggleShuffleMutation, - cycleRepeatMutation, - clearQueueMutation, + playShuffled, + playback?.shuffleEnabled, + queueHistorySongIds, + queueLength, + queueSongIds, reorderQueueMutation, - skipToQueueIndexMutation, + repeatEnabled, + seekTo, + setIsPlaying, + setVolume, skipNextMutation, skipPreviousMutation, - beginQueueSkip, - clearQueueSkip, - repeatEnabled, - queueLength, + skipToQueueIndexMutation, + toggleShuffleMutation, + clearQueueMutation, + volume, ] ) return ( - {children} + + {children} + ) } diff --git a/apps/mobile/lib/audio-playlist-lock-screen.ts b/apps/mobile/lib/audio-playlist-lock-screen.ts new file mode 100644 index 0000000..39a74b5 --- /dev/null +++ b/apps/mobile/lib/audio-playlist-lock-screen.ts @@ -0,0 +1,80 @@ +import type { AudioMetadata, AudioPlaylist } from "expo-audio" + +/** + * Lock-screen options added in Expo SDK 58 (`expo-audio` playlist lock screen). + * SDK 57 only understands seek-forward/back; next/previous are ignored until upgrade. + */ +export type PlaylistLockScreenOptions = { + isLiveStream?: boolean + showNextTrack?: boolean + showPreviousTrack?: boolean + showSeekBackward?: boolean + showSeekForward?: boolean +} + +type PlaylistLockScreenApi = { + setActiveForLockScreen: ( + active: boolean, + metadata?: AudioMetadata, + options?: PlaylistLockScreenOptions + ) => void + updateLockScreenMetadata?: (metadata: AudioMetadata) => void + clearLockScreenControls?: () => void +} + +const TRACK_SKIP_LOCK_SCREEN_OPTIONS: PlaylistLockScreenOptions = { + showNextTrack: true, + showPreviousTrack: true, + showSeekForward: false, + showSeekBackward: false, +} + +function lockScreenApi(playlist: AudioPlaylist): PlaylistLockScreenApi | null { + const candidate = playlist as AudioPlaylist & Partial + if (typeof candidate.setActiveForLockScreen !== "function") { + return null + } + return candidate as PlaylistLockScreenApi +} + +export function activatePlaylistLockScreen( + playlist: AudioPlaylist, + metadata: AudioMetadata +) { + lockScreenApi(playlist)?.setActiveForLockScreen( + true, + metadata, + TRACK_SKIP_LOCK_SCREEN_OPTIONS + ) +} + +export function updatePlaylistLockScreenMetadata( + playlist: AudioPlaylist, + metadata: AudioMetadata +) { + const api = lockScreenApi(playlist) + if (typeof api?.updateLockScreenMetadata === "function") { + api.updateLockScreenMetadata(metadata) + return + } + api?.setActiveForLockScreen(true, metadata, TRACK_SKIP_LOCK_SCREEN_OPTIONS) +} + +export function deactivatePlaylistLockScreen(playlist: AudioPlaylist) { + const api = lockScreenApi(playlist) + if (typeof api?.clearLockScreenControls === "function") { + api.clearLockScreenControls() + return + } + api?.setActiveForLockScreen(false) +} + +export function releaseAudioPlaylist(playlist: AudioPlaylist) { + deactivatePlaylistLockScreen(playlist) + const withDestroy = playlist as AudioPlaylist & { + destroy?: () => void + } + if (typeof withDestroy.destroy === "function") { + withDestroy.destroy() + } +} diff --git a/apps/mobile/lib/native-playlist-window.ts b/apps/mobile/lib/native-playlist-window.ts new file mode 100644 index 0000000..ec6a955 --- /dev/null +++ b/apps/mobile/lib/native-playlist-window.ts @@ -0,0 +1,56 @@ +import type { Id } from "@otunes/convex/_generated/dataModel" + +type RepeatMode = "none" | "once" | "always" +type PlaylistLoopMode = "none" | "single" | "all" + +export const NATIVE_UPCOMING_TRACKS = 30 + +export function nativePlaylistSongIds( + historySongIds: Id<"songs">[], + queueSongIds: Id<"songs">[] +) { + return [ + ...historySongIds, + ...queueSongIds.slice(0, 1 + NATIVE_UPCOMING_TRACKS), + ] +} + +export function repeatToPlaylistLoop(repeat: RepeatMode): PlaylistLoopMode { + if (repeat === "once") { + return "single" + } + return "none" +} + +export function nativePlaylistNeedsRebuild( + loadedSongIds: Id<"songs">[], + historySongIds: Id<"songs">[], + queueSongIds: Id<"songs">[] +) { + if (loadedSongIds.length === 0 || queueSongIds.length === 0) { + return true + } + + const currentIndex = historySongIds.length + if (currentIndex >= loadedSongIds.length) { + return true + } + if (loadedSongIds[currentIndex] !== queueSongIds[0]) { + return true + } + + const remainingNative = loadedSongIds.length - currentIndex - 1 + const remainingQueue = queueSongIds.length - 1 + if (remainingQueue > remainingNative && remainingNative < 5) { + return true + } + + const compareCount = Math.min(remainingNative, remainingQueue) + for (let i = 0; i < compareCount; i++) { + if (loadedSongIds[currentIndex + 1 + i] !== queueSongIds[1 + i]) { + return true + } + } + + return false +} diff --git a/packages/convex/convex/library.ts b/packages/convex/convex/library.ts index 6746306..d53fa39 100644 --- a/packages/convex/convex/library.ts +++ b/packages/convex/convex/library.ts @@ -943,6 +943,23 @@ export const getSong = query({ }, }) +export const getSongsForPlayback = query({ + args: { ids: v.array(v.id("songs")) }, + handler: async (ctx, { ids }) => { + const songs = await Promise.all(ids.map((id) => ctx.db.get(id))) + return songs.map((song, index) => { + if (!song) { + return null + } + return { + id: ids[index], + title: song.name, + files: song.files, + } + }) + }, +}) + export const getSongByName = query({ args: { name: v.string() }, handler: async (ctx, args) => {