feat: download music for offline playback on web and mobile

Users pick Medium, High, Lossless, or Dolby Atmos per download (with
optional "Remember my choice"). Songs without the picked format fall back
to High, and Medium is always transcoded. Web stores audio in IndexedDB
like YouTube Music; mobile stores files per server via expo-file-system.
Downloaded playlists stay in sync, and settings break down storage by
quality and by album or playlist.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
joshuafhigginsandClaude Opus 5.5 committed 2026-11-19 13:06:57 -05:00 Verified
1 parent b86ca9cd1f
commit 64e2847179
40 files changed
+3404 -160

No files matched your search

@@ -22,6 +22,12 @@ import {
DiscHeader,
} from "@/components/collection-list"
import { AudioFormatBadge } from "@/components/audio-format-badge"
import { DownloadHeaderButton } from "@/components/download-header-button"
import {
useDownloads,
useIsCollectionDownloaded,
useIsSongDownloaded,
} from "@/contexts/downloads"
import { CoverImage } from "@/components/cover-image"
import {
@@ -81,6 +87,17 @@ export default function AlbumScreen() {
() => album?.tracks.map((track) => track.id as Id<"songs">) ?? [],
[album]
)
const { requestDownload, removeDownload } = useDownloads()
const downloadTarget = useMemo(
() => ({
kind: "album" as const,
id: typeof id === "string" ? id : "",
title: album?.title ?? "",
songIds,
}),
[album?.title, id, songIds]
)
const albumDownloaded = useIsCollectionDownloaded(downloadTarget)
useEffect(() => {
if (album) {
@@ -193,28 +210,41 @@ export default function AlbumScreen() {
}
: {}),
headerRight: () => (
<MediaActionMenu
stationArtistId={album.artist.id}
selectedCount={album.tracks.length}
favorited={isAlbumFav(album.id)}
share={{ type: "album", albumId: album.id, title: album.title }}
onAction={(action) =>
void handleAlbumDetailAction(
album.id as Id<"albums">,
songIds,
action,
album.artist.id as Id<"artists">
)
}
>
<Pressable hitSlop={8}>
<Ionicons
name="ellipsis-horizontal"
size={22}
color={colors.foreground}
/>
</Pressable>
</MediaActionMenu>
<View style={styles.headerActions}>
<DownloadHeaderButton
target={downloadTarget}
color={colors.foreground}
/>
<MediaActionMenu
stationArtistId={album.artist.id}
selectedCount={album.tracks.length}
favorited={isAlbumFav(album.id)}
downloaded={albumDownloaded}
share={{ type: "album", albumId: album.id, title: album.title }}
onAction={(action) => {
if (action === "download") {
void requestDownload(downloadTarget)
} else if (action === "remove-download") {
void removeDownload(downloadTarget)
} else {
void handleAlbumDetailAction(
album.id as Id<"albums">,
songIds,
action,
album.artist.id as Id<"artists">
)
}
}}
>
<Pressable hitSlop={8}>
<Ionicons
name="ellipsis-horizontal"
size={22}
color={colors.foreground}
/>
</Pressable>
</MediaActionMenu>
</View>
),
}}
/>
@@ -451,6 +481,7 @@ const AlbumTrackRow = memo(function AlbumTrackRow({
}) {
const Row = Platform.OS !== "web" ? SongSwipeRow : Pressable
const { config } = useServerConfig()
const downloaded = useIsSongDownloaded(track.id)
return (
<MediaContextMenu
preview={
@@ -467,6 +498,7 @@ const AlbumTrackRow = memo(function AlbumTrackRow({
}
stationArtistId={album.artist.id}
favorited={favorited}
downloaded={downloaded}
navigation={{
artist: { id: album.artist.id },
album: { id: album.id },
@@ -515,6 +547,14 @@ const AlbumTrackRow = memo(function AlbumTrackRow({
</Text>
) : null}
</View>
{downloaded ? (
<Ionicons
name="arrow-down-circle"
size={14}
color={palette.secondaryForeground}
accessibilityLabel="Downloaded"
/>
) : null}
<Text style={{ color: palette.secondaryForeground }}>
{formatDuration(track.durationSeconds)}
</Text>
@@ -527,6 +567,7 @@ const AlbumTrackRow = memo(function AlbumTrackRow({
const styles = StyleSheet.create({
empty: { flex: 1, alignItems: "center", justifyContent: "center" },
headerActions: { flexDirection: "row", alignItems: "center", gap: 16 },
cover: {
width: 220,
height: 220,
@@ -44,6 +44,12 @@ import {
import { CollectionDetailSkeleton } from "@/components/skeletons"
import { Button } from "@/components/ui/primitives"
import { contentBottomInset, SongListRow } from "@/components/player"
import { DownloadHeaderButton } from "@/components/download-header-button"
import {
FAVORITES_DOWNLOAD_ID,
useDownloads,
useIsCollectionDownloaded,
} from "@/contexts/downloads"
import { useFavorites } from "@/contexts/favorites"
import { usePlaybackActions } from "@/contexts/playback"
import { useServerConfig } from "@/contexts/server-config"
@@ -175,6 +181,7 @@ function PlaylistContent({
usePlaybackActions()
const { isSongFavorite } = useFavorites()
const { handleSongAction, handlePlaylistDetailAction } = useMediaMenuActions()
const { requestDownload, removeDownload } = useDownloads()
const subscribe = useMutation(api.playlists.subscribeToPlaylist)
const unsubscribe = useMutation(api.playlists.unsubscribeFromPlaylist)
const deletePlaylist = useMutation(api.playlists.deletePlaylist)
@@ -187,6 +194,16 @@ function PlaylistContent({
const { filteredSongs, onQueryChange, onSearchSubmit } =
usePlaylistSearch(songs)
const swipeGroup = useSwipeRowGroup()
const downloadTarget = useMemo(
() => ({
kind: "playlist" as const,
id: playlistId ?? FAVORITES_DOWNLOAD_ID,
title: playlist.title,
songIds,
}),
[playlist.title, playlistId, songIds]
)
const playlistDownloaded = useIsCollectionDownloaded(downloadTarget)
const handlePlaySong = useCallback(
(song: BrowseSong) =>
@@ -261,6 +278,14 @@ function PlaylistContent({
void handleDelete()
return
}
if (action === "download") {
void requestDownload(downloadTarget)
return
}
if (action === "remove-download") {
void removeDownload(downloadTarget)
return
}
void handlePlaylistDetailAction(songIds, action)
}
@@ -278,31 +303,42 @@ function PlaylistContent({
}
: {}),
headerRight: () => (
<MediaActionMenu
selectedCount={songIds.length}
playlistLabel={PLAYLIST_LABEL}
share={{
type: "playlist",
playlistId: playlistId ?? "favorites",
title: playlist?.title ?? "oTunes",
}}
includeActions={canEdit ? OWNER_MENU_ACTIONS : undefined}
onAction={handlePlaylistMenuAction}
>
<Pressable hitSlop={8}>
<Ionicons
name="ellipsis-horizontal"
size={22}
color={colors.foreground}
/>
</Pressable>
</MediaActionMenu>
<View style={styles.headerActions}>
<DownloadHeaderButton
target={downloadTarget}
color={colors.foreground}
/>
<MediaActionMenu
selectedCount={songIds.length}
playlistLabel={PLAYLIST_LABEL}
downloaded={playlistDownloaded}
share={{
type: "playlist",
playlistId: playlistId ?? "favorites",
title: playlist?.title ?? "oTunes",
}}
includeActions={canEdit ? OWNER_MENU_ACTIONS : undefined}
onAction={handlePlaylistMenuAction}
>
<Pressable hitSlop={8}>
<Ionicons
name="ellipsis-horizontal"
size={22}
color={colors.foreground}
/>
</Pressable>
</MediaActionMenu>
</View>
),
}
}, [
canEdit,
colors.foreground,
deletePlaylist,
downloadTarget,
playlistDownloaded,
requestDownload,
removeDownload,
handlePlaylistDetailAction,
palette.foreground,
palette.isDark,
@@ -606,6 +642,7 @@ const PlaylistHero = memo(function PlaylistHero({
const styles = StyleSheet.create({
emptyResults: { padding: spacing.lg, textAlign: "center" },
empty: { flex: 1, alignItems: "center", justifyContent: "center" },
headerActions: { flexDirection: "row", alignItems: "center", gap: 16 },
listContent: { paddingBottom: contentBottomInset },
cover: {
width: 200,
@@ -16,6 +16,8 @@ import { CollectionDivider } from "@/components/collection-list"
import { CollectionDetailSkeleton } from "@/components/skeletons"
import { Button } from "@/components/ui/primitives"
import { contentBottomInset, SongListRow } from "@/components/player"
import { DownloadHeaderButton } from "@/components/download-header-button"
import { FAVORITES_DOWNLOAD_ID } from "@/contexts/downloads"
import { useFavorites } from "@/contexts/favorites"
import { usePlaybackActions } from "@/contexts/playback"
import { useServerConfig } from "@/contexts/server-config"
@@ -41,6 +43,23 @@ export default function FavoritesScreen() {
const { isSongFavorite } = useFavorites()
const { handleSongAction } = useMediaMenuActions()
const songIds = useMemo(() => songs.map((song) => song.id), [songs])
const screenOptions = useMemo(
() => ({
...SCREEN_OPTIONS,
headerRight: () => (
<DownloadHeaderButton
target={{
kind: "playlist",
id: FAVORITES_DOWNLOAD_ID,
title: favorites?.title ?? "Favorites",
songIds,
}}
color={colors.foreground}
/>
),
}),
[colors.foreground, favorites?.title, songIds]
)
const { filteredSongs, onQueryChange, onSearchSubmit } =
usePlaylistSearch(songs)
@@ -104,7 +123,7 @@ export default function FavoritesScreen() {
return (
<>
<Stack.Screen options={SCREEN_OPTIONS} />
<Stack.Screen options={screenOptions} />
<PlaylistSearchBar
onQueryChange={onQueryChange}
onSearchSubmit={onSearchSubmit}
+335 -2
View File
@@ -3,9 +3,10 @@ import { Ionicons } from "@expo/vector-icons"
import { useAction, useMutation, useQuery } from "convex/react"
import { Image } from "expo-image"
import * as ImagePicker from "expo-image-picker"
import { useState } from "react"
import { useEffect, useMemo, useState } from "react"
import { router } from "expo-router"
import {
Alert,
Platform,
Pressable,
ScrollView,
@@ -16,7 +17,20 @@ import {
} from "react-native"
import type { StyleProp, ViewStyle } from "react-native"
import { AudioFormatBadge } from "@/components/audio-format-badge"
import { contentBottomInset } from "@/components/player"
import { useDownloads, useDownloadsVersion } from "@/contexts/downloads"
import {
readRememberedDownloadQuality,
writeRememberedDownloadQuality,
} from "@/lib/downloads"
import {
DOWNLOAD_QUALITIES,
DOWNLOAD_QUALITY_DETAILS,
DOWNLOAD_QUALITY_LABELS,
formatBytes,
type DownloadQuality,
} from "@otunes/convex/download-quality"
import { Button, Input, LoadingView } from "@/components/ui/primitives"
import { useInvalidateAuthSession } from "@/contexts/convex-auth-session"
import { useServerConfig } from "@/contexts/server-config"
@@ -35,7 +49,7 @@ import type { PlaybackQuality } from "@otunes/convex/playback-stream"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
type Section = "profile" | "quality" | "library" | "users"
type Section = "profile" | "quality" | "downloads" | "library" | "users"
type CurrentUser = {
_id: Id<"users">
@@ -75,6 +89,7 @@ const QUALITY_OPTIONS: {
const SECTIONS: SectionConfig[] = [
{ id: "profile", label: "Profile", icon: "person-circle-outline" },
{ id: "quality", label: "Playback", icon: "volume-high-outline" },
{ id: "downloads", label: "Downloads", icon: "arrow-down-circle-outline" },
{ id: "library", label: "Library", icon: "library-outline", admin: true },
{ id: "users", label: "Users", icon: "people-outline", admin: true },
]
@@ -156,6 +171,7 @@ export default function SettingsScreen() {
</>
) : null}
{section === "quality" ? <QualitySection user={user} /> : null}
{section === "downloads" ? <DownloadsSection /> : null}
{section === "library" && isAdmin ? <LibrarySection /> : null}
{section === "users" && isAdmin && allUsers ? (
<UsersSection users={allUsers} currentUserId={user._id} />
@@ -432,6 +448,298 @@ function QualitySection({ user }: { user: CurrentUser }) {
)
}
/** Shades of the text color, faintest for the smallest files. */
const QUALITY_OPACITY: Record<DownloadQuality, number> = {
medium: 0.25,
high: 0.45,
lossless: 0.7,
atmos: 1,
}
function songCount(count: number) {
return count === 1 ? "1 song" : `${count} songs`
}
function QualityName({
quality,
color,
backgroundColor,
}: {
quality: DownloadQuality
color: string
backgroundColor: string
}) {
if (quality === "lossless" || quality === "atmos") {
return (
<AudioFormatBadge
format={quality}
color={color}
backgroundColor={backgroundColor}
/>
)
}
return (
<Text style={{ color, fontSize: 13, fontWeight: "500" }}>
{DOWNLOAD_QUALITY_LABELS[quality]}
</Text>
)
}
function confirm(title: string, onConfirm: () => void) {
Alert.alert(title, undefined, [
{ text: "Cancel", style: "cancel" },
{ text: "Remove", style: "destructive", onPress: onConfirm },
])
}
function RememberedQualityCard() {
const colors = useThemeColors()
// undefined until read; null means ask every time.
const [remembered, setRemembered] = useState<DownloadQuality | null>()
useEffect(() => {
void readRememberedDownloadQuality().then((quality) =>
setRemembered(quality ?? null)
)
}, [])
const options: {
value: DownloadQuality | null
label: string
detail: string
}[] = [
{ value: null, label: "Ask every time", detail: "Choose when downloading" },
...DOWNLOAD_QUALITIES.map((quality) => ({
value: quality,
label: DOWNLOAD_QUALITY_LABELS[quality],
detail: DOWNLOAD_QUALITY_DETAILS[quality],
})),
]
return (
<SettingsCard title="Download Quality">
{options.map((option) => {
const selected = remembered === option.value
return (
<Pressable
key={option.value ?? "ask"}
accessibilityRole="button"
accessibilityState={{ selected }}
onPress={() => {
setRemembered(option.value)
void writeRememberedDownloadQuality(option.value ?? undefined)
}}
style={[
styles.optionRow,
{
borderColor: selected ? colors.primary : colors.border,
backgroundColor: selected ? colors.muted : colors.card,
},
]}
>
<View style={styles.optionCopy}>
<Text style={[styles.optionTitle, { color: colors.foreground }]}>
{option.label}
</Text>
<Text style={{ color: colors.mutedForeground }}>
{option.detail}
</Text>
</View>
{selected ? (
<Ionicons
name="checkmark-circle"
size={22}
color={colors.primary}
/>
) : null}
</Pressable>
)
})}
</SettingsCard>
)
}
function DownloadsSection() {
const colors = useThemeColors()
const { queue } = useDownloads()
const version = useDownloadsVersion()
const breakdown = useMemo(
() => queue?.breakdown(),
// version invalidates the breakdown when downloads change.
// eslint-disable-next-line react-hooks/exhaustive-deps
[queue, version]
)
if (!queue || !breakdown) return null
const qualities = breakdown.byQuality.filter((entry) => entry.songs > 0)
return (
<>
<SettingsCard title="Storage">
<Text style={{ color: colors.foreground, fontSize: 15 }}>
{formatBytes(breakdown.bytes)} · {songCount(breakdown.songs)}
{breakdown.queued > 0 ? ` · ${breakdown.queued} downloading` : ""}
</Text>
{breakdown.songs > 0 ? (
<>
<View
style={[styles.storageBar, { backgroundColor: colors.muted }]}
>
{qualities.map((entry) => (
<View
key={entry.quality}
style={{
flex: entry.bytes,
backgroundColor: colors.foreground,
opacity: QUALITY_OPACITY[entry.quality],
}}
/>
))}
</View>
{qualities.map((entry) => (
<View key={entry.quality} style={styles.storageRow}>
<View
style={[
styles.storageDot,
{
backgroundColor: colors.foreground,
opacity: QUALITY_OPACITY[entry.quality],
},
]}
/>
<View style={{ flex: 1 }}>
<QualityName
quality={entry.quality}
color={colors.foreground}
backgroundColor={colors.card}
/>
</View>
<Text style={{ color: colors.mutedForeground, fontSize: 13 }}>
{songCount(entry.songs)}
</Text>
<Text
style={[styles.storageSize, { color: colors.foreground }]}
>
{formatBytes(entry.bytes)}
</Text>
</View>
))}
</>
) : null}
</SettingsCard>
<RememberedQualityCard />
{breakdown.collections.length > 0 ||
breakdown.singles.songIds.length > 0 ? (
<SettingsCard title="Downloaded">
{breakdown.collections.map(
({ collection, bytes, status, fallbackCount }) => (
<View
key={`${collection.kind}:${collection.id}`}
style={styles.storageRow}
>
<View style={styles.optionCopy}>
<Text
style={{ color: colors.foreground, fontSize: 15 }}
numberOfLines={1}
>
{collection.title}
</Text>
<View style={styles.collectionMeta}>
<Text
style={{ color: colors.mutedForeground, fontSize: 13 }}
>
{collection.kind === "album" ? "Album" : "Playlist"} ·
</Text>
<QualityName
quality={collection.quality}
color={colors.mutedForeground}
backgroundColor={colors.card}
/>
{fallbackCount > 0 ? (
<Text
style={{ color: colors.mutedForeground, fontSize: 13 }}
>
({fallbackCount} in High)
</Text>
) : null}
{status.downloaded < status.total ? (
<Text
style={{ color: colors.mutedForeground, fontSize: 13 }}
>
· {status.downloaded} of {status.total}
</Text>
) : null}
</View>
</View>
<Text
style={[styles.storageSize, { color: colors.foreground }]}
>
{formatBytes(bytes)}
</Text>
<Pressable
hitSlop={8}
accessibilityRole="button"
accessibilityLabel={`Remove download of ${collection.title}`}
onPress={() =>
confirm(
`Remove ${collection.title}?`,
() => void queue.removeCollection(collection)
)
}
>
<Ionicons
name="trash-outline"
size={20}
color={colors.mutedForeground}
/>
</Pressable>
</View>
)
)}
{breakdown.singles.songIds.length > 0 ? (
<View style={styles.storageRow}>
<View style={styles.optionCopy}>
<Text style={{ color: colors.foreground, fontSize: 15 }}>
Individual songs
</Text>
<Text style={{ color: colors.mutedForeground, fontSize: 13 }}>
{songCount(breakdown.singles.songIds.length)}
</Text>
</View>
<Text style={[styles.storageSize, { color: colors.foreground }]}>
{formatBytes(breakdown.singles.bytes)}
</Text>
<Pressable
hitSlop={8}
accessibilityRole="button"
accessibilityLabel="Remove individually downloaded songs"
onPress={() =>
confirm(
"Remove individual songs?",
() => void queue.remove(breakdown.singles.songIds)
)
}
>
<Ionicons
name="trash-outline"
size={20}
color={colors.mutedForeground}
/>
</Pressable>
</View>
) : null}
<Button
title="Remove All Downloads"
variant="destructive"
onPress={() =>
confirm("Remove all downloads?", () => void queue.removeAll())
}
/>
</SettingsCard>
) : null}
</>
)
}
function LibrarySection() {
const updateLibrary = useAction(api.actions.updateLibrary)
const cleanupHlsStreams = useAction(api.actions.adminCleanupHlsStreams)
@@ -874,6 +1182,31 @@ const styles = StyleSheet.create({
divider: {
height: StyleSheet.hairlineWidth,
},
storageBar: {
height: 8,
borderRadius: 4,
overflow: "hidden",
flexDirection: "row",
},
storageRow: {
flexDirection: "row",
alignItems: "center",
gap: spacing.md,
minHeight: 36,
},
storageDot: { width: 8, height: 8, borderRadius: 4 },
storageSize: {
minWidth: 56,
textAlign: "right",
fontSize: 13,
fontVariant: ["tabular-nums"],
},
collectionMeta: {
flexDirection: "row",
alignItems: "center",
flexWrap: "wrap",
gap: 4,
},
optionRow: {
borderWidth: 1,
borderRadius: radius.lg,
+49 -46
View File
@@ -17,6 +17,7 @@ import { useEffect, useSyncExternalStore } from "react"
import { AppIntentBridge } from "@/components/app-intent-bridge"
import { ConvexAuthRecovery } from "@/components/convex-auth-recovery"
import { AddToPlaylistProvider } from "@/contexts/add-to-playlist"
import { DownloadsProvider } from "@/contexts/downloads"
import { useInvalidateAuthSession } from "@/contexts/convex-auth-session"
import { FavoritesProvider } from "@/contexts/favorites"
import { PlaybackProvider } from "@/contexts/playback"
@@ -75,52 +76,54 @@ export default function AppLayout() {
<PlaybackProvider>
<AppNavigationSync />
<AddToPlaylistProvider>
<FavoritesProvider>
<AppIntentBridge />
<Stack screenOptions={stackOptions}>
<Stack.Screen
name="(tabs)"
options={{ headerShown: false, animation: "none" }}
/>
<Stack.Screen
name="settings"
options={{
headerShown: Platform.OS === "android",
title: "Settings",
presentation:
Platform.OS === "ios" ? "modal" : "fullScreenModal",
animation: "slide_from_bottom",
gestureEnabled: true,
gestureDirection: "vertical",
}}
/>
<Stack.Screen
name="create-account"
options={{
title: "Create account",
presentation: "modal",
headerLargeTitle: false,
headerTransparent: false,
headerStyle: { backgroundColor: "#000" },
headerTintColor: "#fff",
contentStyle: { backgroundColor: "#000" },
}}
/>
<Stack.Screen
name="player"
options={{
headerShown: false,
// Keep the library visible behind the custom swipe animation.
presentation: "transparentModal",
contentStyle: { backgroundColor: "transparent" },
animation: "slide_from_bottom",
gestureEnabled: true,
gestureDirection: "vertical",
fullScreenGestureEnabled: true,
}}
/>
</Stack>
</FavoritesProvider>
<DownloadsProvider>
<FavoritesProvider>
<AppIntentBridge />
<Stack screenOptions={stackOptions}>
<Stack.Screen
name="(tabs)"
options={{ headerShown: false, animation: "none" }}
/>
<Stack.Screen
name="settings"
options={{
headerShown: Platform.OS === "android",
title: "Settings",
presentation:
Platform.OS === "ios" ? "modal" : "fullScreenModal",
animation: "slide_from_bottom",
gestureEnabled: true,
gestureDirection: "vertical",
}}
/>
<Stack.Screen
name="create-account"
options={{
title: "Create account",
presentation: "modal",
headerLargeTitle: false,
headerTransparent: false,
headerStyle: { backgroundColor: "#000" },
headerTintColor: "#fff",
contentStyle: { backgroundColor: "#000" },
}}
/>
<Stack.Screen
name="player"
options={{
headerShown: false,
// Keep the library visible behind the custom swipe animation.
presentation: "transparentModal",
contentStyle: { backgroundColor: "transparent" },
animation: "slide_from_bottom",
gestureEnabled: true,
gestureDirection: "vertical",
fullScreenGestureEnabled: true,
}}
/>
</Stack>
</FavoritesProvider>
</DownloadsProvider>
</AddToPlaylistProvider>
</PlaybackProvider>
</ConvexAuthRecovery>
@@ -0,0 +1,110 @@
import { Ionicons } from "@expo/vector-icons"
import { Alert, Pressable } from "react-native"
import Svg, { Circle, Rect } from "react-native-svg"
import {
useDownloads,
useDownloadsVersion,
type DownloadTarget,
} from "@/contexts/downloads"
const SIZE = 22
const RADIUS = 9
const RING_LENGTH = 2 * Math.PI * RADIUS
/** Static ring that fills as songs finish; the square means "tap to stop". */
function ProgressRing({
fraction,
color,
}: {
fraction: number
color: string
}) {
return (
<Svg width={SIZE} height={SIZE} viewBox="0 0 22 22">
<Circle
cx={11}
cy={11}
r={RADIUS}
fill="none"
stroke={color}
strokeOpacity={0.3}
strokeWidth={2}
/>
<Circle
cx={11}
cy={11}
r={RADIUS}
fill="none"
stroke={color}
strokeWidth={2}
strokeDasharray={RING_LENGTH}
strokeDashoffset={RING_LENGTH * (1 - fraction)}
transform="rotate(-90 11 11)"
/>
<Rect x={8} y={8} width={6} height={6} fill={color} />
</Svg>
)
}
/** Download, progress, and downloaded states for an album or playlist header. */
export function DownloadHeaderButton({
target,
color,
}: {
target: Exclude<DownloadTarget, { kind: "songs" }>
color: string
}) {
const { queue, requestDownload, removeDownload } = useDownloads()
useDownloadsVersion()
const collection = queue?.getCollection(target)
const status = queue?.status(target.songIds)
const inProgress = collection !== undefined && (status?.queued ?? 0) > 0
const done = collection !== undefined && !inProgress
function handlePress() {
if (inProgress) {
void removeDownload(target)
} else if (done) {
Alert.alert("Remove download?", undefined, [
{ text: "Cancel", style: "cancel" },
{
text: "Remove",
style: "destructive",
onPress: () => void removeDownload(target),
},
])
} else {
void requestDownload(target)
}
}
return (
<Pressable
hitSlop={8}
accessibilityRole="button"
accessibilityLabel={
inProgress
? "Stop downloading"
: done
? `Remove download of ${target.title}`
: `Download ${target.title}`
}
disabled={target.songIds.length === 0}
onPress={handlePress}
>
{inProgress && status ? (
<ProgressRing
fraction={status.downloaded / status.total}
color={color}
/>
) : (
<Ionicons
name={done ? "checkmark-circle" : "arrow-down-circle-outline"}
size={SIZE + 2}
color={color}
/>
)}
</Pressable>
)
}
+8
View File
@@ -20,6 +20,7 @@ import {
import { CoverImage } from "@/components/cover-image"
import { MediaContextMenu } from "@/components/media-context-menu"
import { useIsCollectionDownloaded } from "@/contexts/downloads"
import { useMediaMenuActions } from "@/hooks/use-media-menu-actions"
import { useServerConfig } from "@/contexts/server-config"
import { useAppNavigation } from "@/lib/app-navigation"
@@ -51,6 +52,7 @@ export const AlbumCard = memo(function AlbumCard({
const { config } = useServerConfig()
const colors = useThemeColors()
const { handleAlbumAction, isAlbumFavorite } = useMediaMenuActions()
const downloaded = useIsCollectionDownloaded({ kind: "album", id: album.id })
if (!config) return null
const card = (
@@ -102,6 +104,7 @@ export const AlbumCard = memo(function AlbumCard({
hasArtwork: album.cover != null,
}}
favorited={isAlbumFavorite(album.id)}
downloaded={downloaded}
stationArtistId={album.artist.id}
navigation={{ artist: { id: album.artist.id } }}
share={{ type: "album", albumId: album.id, title: album.title }}
@@ -187,6 +190,10 @@ export const PlaylistCard = memo(function PlaylistCard({
const { config } = useServerConfig()
const colors = useThemeColors()
const { handlePlaylistAction } = useMediaMenuActions()
const downloaded = useIsCollectionDownloaded({
kind: "playlist",
id: playlist.id,
})
if (!config) return null
const card = (
@@ -231,6 +238,7 @@ export const PlaylistCard = memo(function PlaylistCard({
return (
<MediaContextMenu
showFavorite={false}
downloaded={downloaded}
share={{
type: "playlist",
playlistId: playlist.id,
@@ -34,6 +34,8 @@ export type MediaAction =
| "go-album"
| "remove-from-playlist"
| "delete-playlist"
| "download"
| "remove-download"
export type MediaNavigation = {
artist?: { id: string }
@@ -59,6 +61,8 @@ export type MediaMenuConfig = {
stationArtistId?: string
navigation?: MediaNavigation
share?: MediaShareContext
/** Shows Download, or Remove Download when true. Omit to hide both. */
downloaded?: boolean
includeActions?: MediaAction[]
onAction: (action: MediaAction) => void
}
@@ -86,6 +90,17 @@ const MEDIA_ACTION_ITEMS: {
`${playlistLabel}${countSuffix}`,
image: "text.badge.plus",
},
{
action: "download",
label: (countSuffix) => `Download${countSuffix}`,
image: "arrow.down.circle",
},
{
action: "remove-download",
label: (countSuffix) => `Remove Download${countSuffix}`,
image: "xmark.circle",
destructive: true,
},
{
action: "play-next",
label: (countSuffix) => `Play Next${countSuffix}`,
@@ -147,6 +162,14 @@ function isActionIncluded(
return config.showRemoveFromPlaylist === true
}
if (action === "download") {
return config.downloaded === false
}
if (action === "remove-download") {
return config.downloaded === true
}
if (config.includeActions) {
return config.includeActions.includes(action)
}
@@ -27,6 +27,8 @@ const actionIcons = {
"go-album": "disc-outline",
"remove-from-playlist": "remove-circle-outline",
"delete-playlist": "trash-outline",
download: "arrow-down-circle-outline",
"remove-download": "close-circle-outline",
} satisfies Record<MediaAction, ComponentProps<typeof Ionicons>["name"]>
// The community MenuView creates a dynamic-color Host internally. Own this
+13
View File
@@ -3,6 +3,8 @@ import type { SwipeRowGroup } from "@/components/ios-swipe-to-remove-row"
import { MusicEntityView } from "@/components/music-entity-view"
import { collectionInset } from "@/components/collection-list"
import { CoverImage } from "@/components/cover-image"
import { Ionicons } from "@expo/vector-icons"
import { useIsSongDownloaded } from "@/contexts/downloads"
import { useServerConfig } from "@/contexts/server-config"
import type { BrowseSong } from "@otunes/convex/types"
import type { CoverPalette } from "@/lib/cover-palette"
@@ -53,6 +55,7 @@ export const SongRow = memo(function SongRow({
}) {
const { config } = useServerConfig()
const colors = useThemeColors()
const downloaded = useIsSongDownloaded(song.id)
if (!config) return null
const foreground = palette?.foreground ?? colors.foreground
@@ -76,6 +79,14 @@ export const SongRow = memo(function SongRow({
{song.artist.name} · {song.album.title}
</Text>
</View>
{downloaded ? (
<Ionicons
name="arrow-down-circle"
size={14}
color={secondaryForeground}
accessibilityLabel="Downloaded"
/>
) : null}
<Text style={[styles.duration, { color: secondaryForeground }]}>
{formatDuration(song.durationSeconds)}
</Text>
@@ -176,6 +187,7 @@ export const SongListRow = memo(function SongListRow({
onAction: (song: BrowseSong, action: MediaAction) => void
}) {
const { config } = useServerConfig()
const downloaded = useIsSongDownloaded(song.id)
const handlePress = useCallback(() => onPlay(song), [onPlay, song])
return (
@@ -198,6 +210,7 @@ export const SongListRow = memo(function SongListRow({
: undefined,
stationArtistId: song.artist.id,
favorited,
downloaded,
playlistLabel,
showRemoveFromPlaylist: removable,
navigation: {
+424
View File
@@ -0,0 +1,424 @@
import { useConvex, useQuery } from "convex/react"
import {
createContext,
useCallback,
useContext,
useEffect,
useMemo,
useState,
useSyncExternalStore,
type ReactNode,
} from "react"
import {
Modal,
Platform,
Pressable,
StyleSheet,
Switch,
Text,
View,
} from "react-native"
import { toast } from "sonner-native"
import { AndroidSheet } from "@/components/android-sheet"
import { AudioFormatBadge } from "@/components/audio-format-badge"
import { useCacheScope } from "@/contexts/persistent-cache"
import { useServerConfig } from "@/contexts/server-config"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { getAuthCookieHeader } from "@/lib/auth-cookies"
import {
downloadQueueFor,
readRememberedDownloadQuality,
writeRememberedDownloadQuality,
} from "@/lib/downloads"
import { loadPlaybackSongs } from "@/lib/playback-files"
import type { ServerConfig } from "@/lib/server-config"
import { showError } from "@/lib/toast"
import { useThemeColors } from "@/lib/theme"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import type {
CollectionRef,
DownloadableSong,
DownloadQueue,
} from "@otunes/convex/client/download-queue"
import {
DOWNLOAD_OPTIONS_PATH,
DOWNLOAD_QUALITY_DETAILS,
DOWNLOAD_QUALITY_LABELS,
formatBytes,
type DownloadOptionsResponse,
type DownloadQuality,
type SizedDownloadOption,
} from "@otunes/convex/download-quality"
/** Songs on their own, or an album or playlist that stays downloaded as a whole. */
export type DownloadTarget =
| { kind: "songs"; songIds: string[]; title: string }
| (CollectionRef & { title: string; songIds: string[] })
/** The Favorites playlist has no ID, so downloads use this one. */
export const FAVORITES_DOWNLOAD_ID = "favorites"
type DownloadsContextValue = {
queue: DownloadQueue | null
/** Asks for a quality (unless remembered) and starts downloading. */
requestDownload: (target: DownloadTarget) => Promise<void>
removeDownload: (target: DownloadTarget) => Promise<void>
}
const DownloadsContext = createContext<DownloadsContextValue | null>(null)
export function useDownloads() {
const context = useContext(DownloadsContext)
if (!context) {
throw new Error("useDownloads must be used within DownloadsProvider")
}
return context
}
const noopSubscribe = () => () => {}
/** Re-renders on every download change. Prefer the narrower hooks in lists. */
export function useDownloadsVersion() {
const { queue } = useDownloads()
return useSyncExternalStore(
queue?.subscribe ?? noopSubscribe,
() => queue?.getVersion() ?? 0
)
}
/** Only re-renders when this song is downloaded or removed. */
export function useIsSongDownloaded(songId: string) {
const { queue } = useDownloads()
return useSyncExternalStore(
queue?.subscribe ?? noopSubscribe,
() => queue?.getDownloaded(songId) !== undefined
)
}
/** Whether an album or playlist is downloaded. */
export function useIsCollectionDownloaded(ref: CollectionRef) {
const { queue } = useDownloads()
return useSyncExternalStore(
queue?.subscribe ?? noopSubscribe,
() => queue?.getCollection(ref) !== undefined
)
}
async function fetchDownloadOptions(config: ServerConfig, songIds: string[]) {
const cookieHeader = await getAuthCookieHeader(
config.serverUrl,
config.convexUrl
)
if (!cookieHeader) throw new Error("Sign in to download")
const response = await fetch(`${config.serverUrl}${DOWNLOAD_OPTIONS_PATH}`, {
method: "POST",
headers: { "Content-Type": "application/json", Cookie: cookieHeader },
body: JSON.stringify({
songIds,
losslessFormat: Platform.OS === "ios" ? "alac" : undefined,
}),
})
if (!response.ok) {
throw new Error("Could not reach the server to download")
}
return (await response.json()) as DownloadOptionsResponse
}
function startDownload(
queue: DownloadQueue,
target: DownloadTarget,
songs: DownloadableSong[],
quality: DownloadQuality
) {
if (target.kind === "songs") return queue.enqueue(songs, quality)
return queue.downloadCollection(
{ kind: target.kind, id: target.id, title: target.title, quality },
songs
)
}
function optionDetail(option: SizedDownloadOption, songCount: number) {
if (option.fallbackCount === 0) {
return DOWNLOAD_QUALITY_DETAILS[option.quality]
}
const included = songCount - option.fallbackCount
return `${included} of ${songCount} songs, ${option.fallbackCount} in High`
}
function DownloadQualitySheet({
pending,
onClose,
onPick,
}: {
pending: { target: DownloadTarget; response: DownloadOptionsResponse } | null
onClose: () => void
onPick: (quality: DownloadQuality, remember: boolean) => void
}) {
const colors = useThemeColors()
const [remember, setRemember] = useState(false)
const songCount = pending?.response.songs.length ?? 0
return (
<Modal
visible={pending !== null}
animationType="slide"
transparent
onRequestClose={onClose}
>
<AndroidSheet>
<Pressable style={styles.overlay} onPress={onClose}>
<Pressable
style={[
styles.sheet,
{ backgroundColor: colors.card, borderColor: colors.border },
]}
onPress={(event) => event.stopPropagation()}
>
<View
style={[styles.grabber, { backgroundColor: colors.border }]}
/>
<Text style={[styles.title, { color: colors.foreground }]}>
Download Quality
</Text>
<Text
style={[styles.subtitle, { color: colors.mutedForeground }]}
numberOfLines={1}
>
{pending?.target.title}
</Text>
{pending?.response.options.map((option) => (
<Pressable
key={option.quality}
accessibilityRole="button"
style={[styles.row, { borderBottomColor: colors.border }]}
onPress={() => onPick(option.quality, remember)}
>
<View style={styles.rowText}>
{option.quality === "lossless" ||
option.quality === "atmos" ? (
<AudioFormatBadge
format={option.quality}
color={colors.foreground}
backgroundColor={colors.card}
/>
) : (
<Text style={[styles.label, { color: colors.foreground }]}>
{DOWNLOAD_QUALITY_LABELS[option.quality]}
</Text>
)}
<Text style={{ color: colors.mutedForeground, fontSize: 12 }}>
{optionDetail(option, songCount)}
</Text>
</View>
<Text style={[styles.size, { color: colors.mutedForeground }]}>
{option.estimated ? "~" : ""}
{formatBytes(option.bytes)}
</Text>
</Pressable>
))}
<View style={styles.rememberRow}>
<Text style={{ color: colors.foreground, fontSize: 15 }}>
Remember my choice
</Text>
<Switch value={remember} onValueChange={setRemember} />
</View>
</Pressable>
</Pressable>
</AndroidSheet>
</Modal>
)
}
/** Keeps a downloaded playlist's songs in step with the playlist. */
function useSyncDownloadedPlaylist(
queue: DownloadQueue,
id: string,
songIds: readonly string[] | undefined
) {
const convex = useConvex()
const cacheScope = useCacheScope()
useEffect(() => {
if (!songIds) return
void queue
.syncCollection({ kind: "playlist", id }, songIds, async (added) => {
const songs = await loadPlaybackSongs(
convex,
cacheScope,
added as Id<"songs">[]
)
return songs.filter((song) => song !== null)
})
.catch(() => {})
}, [cacheScope, convex, id, queue, songIds])
}
function PlaylistSync({ queue, id }: { queue: DownloadQueue; id: string }) {
const songIds = useQuery(api.playlists.getPlaylistSongIds, {
playlistId: id as Id<"playlists">,
})
useSyncDownloadedPlaylist(queue, id, songIds)
return null
}
function FavoritesSync({ queue }: { queue: DownloadQueue }) {
const favorites = useCachedQuery(api.favorites.getUserFavorites)
const songIds = useMemo(() => favorites?.favoriteSongs.flat(), [favorites])
useSyncDownloadedPlaylist(queue, FAVORITES_DOWNLOAD_ID, songIds)
return null
}
function DownloadSync({ queue }: { queue: DownloadQueue }) {
useSyncExternalStore(queue.subscribe, queue.getVersion)
return queue
.collections()
.filter((collection) => collection.kind === "playlist")
.map((collection) =>
collection.id === FAVORITES_DOWNLOAD_ID ? (
<FavoritesSync key={collection.id} queue={queue} />
) : (
<PlaylistSync key={collection.id} queue={queue} id={collection.id} />
)
)
}
export function DownloadsProvider({ children }: { children: ReactNode }) {
const { config } = useServerConfig()
const convex = useConvex()
const cacheScope = useCacheScope()
const queue = useMemo(
() => (config ? downloadQueueFor(config) : null),
[config]
)
const [pending, setPending] = useState<{
target: DownloadTarget
response: DownloadOptionsResponse
} | null>(null)
useEffect(() => {
if (!queue) return
void queue.load().catch(() => {})
// Reports failed songs once per burst instead of once per song.
let failed = 0
let timer: ReturnType<typeof setTimeout> | null = null
const unsubscribe = queue.onFailure(() => {
failed += 1
timer ??= setTimeout(() => {
showError(
failed === 1
? "A song could not be downloaded"
: `${failed} songs could not be downloaded`
)
failed = 0
timer = null
}, 1000)
})
return () => {
unsubscribe()
if (timer) clearTimeout(timer)
}
}, [queue])
const requestDownload = useCallback(
async (target: DownloadTarget) => {
if (!config || !queue || target.songIds.length === 0) return
try {
// Caches titles and formats so downloads can be queued offline.
void loadPlaybackSongs(
convex,
cacheScope,
target.songIds as Id<"songs">[]
).catch(() => {})
const response = await fetchDownloadOptions(config, target.songIds)
const remembered = await readRememberedDownloadQuality()
if (remembered) {
await startDownload(queue, target, response.songs, remembered)
toast(`Downloading ${target.title}`)
} else {
setPending({ target, response })
}
} catch (error) {
showError(error instanceof Error ? error.message : "Download failed")
}
},
[cacheScope, config, convex, queue]
)
const removeDownload = useCallback(
async (target: DownloadTarget) => {
if (!queue) return
if (target.kind === "songs") await queue.remove(target.songIds)
else await queue.removeCollection(target)
},
[queue]
)
const handlePick = useCallback(
(quality: DownloadQuality, remember: boolean) => {
if (!pending || !queue) return
setPending(null)
if (remember) void writeRememberedDownloadQuality(quality)
void startDownload(queue, pending.target, pending.response.songs, quality)
},
[pending, queue]
)
const value = useMemo(
() => ({ queue, requestDownload, removeDownload }),
[queue, requestDownload, removeDownload]
)
return (
<DownloadsContext.Provider value={value}>
{children}
{queue ? <DownloadSync queue={queue} /> : null}
<DownloadQualitySheet
pending={pending}
onClose={() => setPending(null)}
onPick={handlePick}
/>
</DownloadsContext.Provider>
)
}
const styles = StyleSheet.create({
overlay: {
flex: 1,
backgroundColor: "rgba(0,0,0,0.45)",
justifyContent: "flex-end",
},
sheet: {
borderTopLeftRadius: 16,
borderTopRightRadius: 16,
borderWidth: 1,
paddingHorizontal: 16,
paddingTop: 8,
paddingBottom: 24,
},
grabber: {
width: 36,
height: 4,
borderRadius: 2,
alignSelf: "center",
marginBottom: 12,
},
title: { fontSize: 18, fontWeight: "700" },
subtitle: { fontSize: 13, marginBottom: 4 },
row: {
flexDirection: "row",
alignItems: "center",
gap: 12,
paddingVertical: 12,
borderBottomWidth: StyleSheet.hairlineWidth,
},
rowText: { flex: 1, minWidth: 0, gap: 2 },
label: { fontSize: 15, fontWeight: "500" },
size: { fontSize: 13, fontVariant: ["tabular-nums"] },
rememberRow: {
flexDirection: "row",
alignItems: "center",
justifyContent: "space-between",
paddingTop: 12,
},
})
+60 -1
View File
@@ -3,6 +3,7 @@ import { useCallback } from "react"
import type { MediaAction } from "@/components/media-context-menu"
import { useAddToPlaylist } from "@/contexts/add-to-playlist"
import { useDownloads } from "@/contexts/downloads"
import { useCacheScope } from "@/contexts/persistent-cache"
import { useFavorites } from "@/contexts/favorites"
import { usePlaybackActions } from "@/contexts/playback"
@@ -48,6 +49,7 @@ export function useMediaMenuActions() {
} = useFavorites()
const { addToQueueNext, addToQueueLast, playShuffled, playArtistShuffled } =
usePlaybackActions()
const { requestDownload, removeDownload } = useDownloads()
const runQueueAction = useCallback(
async (action: MediaAction, songIds: Id<"songs">[]) => {
@@ -97,6 +99,14 @@ export function useMediaMenuActions() {
case "go-album":
push(`/album/${song.album.id}`)
break
case "download":
case "remove-download": {
const target = { kind: "songs" as const, songIds, title: song.title }
await (action === "download"
? requestDownload(target)
: removeDownload(target))
break
}
default:
break
}
@@ -107,6 +117,8 @@ export function useMediaMenuActions() {
runQueueAction,
toggleSongFavorite,
playArtistShuffled,
requestDownload,
removeDownload,
]
)
@@ -138,6 +150,25 @@ export function useMediaMenuActions() {
case "go-artist":
push(`/artist/${album.artist.id}`)
break
case "download":
case "remove-download": {
const songIds = await fetchCachedQuery(
convex,
cacheScope,
api.playlists.getAlbumSongIds,
{ albumId: album.id as Id<"albums"> }
)
const target = {
kind: "album" as const,
id: album.id,
title: album.title,
songIds,
}
await (action === "download"
? requestDownload(target)
: removeDownload(target))
break
}
default:
break
}
@@ -151,6 +182,8 @@ export function useMediaMenuActions() {
push,
runQueueAction,
toggleAlbumFavorite,
requestDownload,
removeDownload,
]
)
@@ -211,12 +244,38 @@ export function useMediaMenuActions() {
await runQueueAction(action, songIds)
break
}
case "download":
case "remove-download": {
const songIds = await fetchCachedQuery(
convex,
cacheScope,
api.playlists.getPlaylistSongIds,
{ playlistId: playlist.id as Id<"playlists"> }
)
const target = {
kind: "playlist" as const,
id: playlist.id,
title: playlist.title,
songIds,
}
await (action === "download"
? requestDownload(target)
: removeDownload(target))
break
}
default:
break
}
})
},
[convex, cacheScope, openAddPlaylistToPlaylist, runQueueAction]
[
convex,
cacheScope,
openAddPlaylistToPlaylist,
runQueueAction,
requestDownload,
removeDownload,
]
)
const handleAlbumDetailAction = useCallback(
+13 -1
View File
@@ -22,6 +22,7 @@ import * as playbackQueue from "@otunes/convex/client/playback-queue"
import type { RepeatMode } from "@otunes/convex/client/playback-queue"
import type { PlaybackStore } from "@otunes/convex/client/playback-store"
import { getAuthCookieHeader } from "@/lib/auth-cookies"
import { downloadedAudioUri, downloadQueueFor } from "@/lib/downloads"
import { loadPlaybackSongs } from "@/lib/playback-files"
import { showError } from "@/lib/toast"
import { albumCoverUrl, songAudioSource } from "@/lib/urls"
@@ -493,10 +494,21 @@ export function useNativePlaylistSync({
}
const buildSources = async (songIds: Id<"songs">[]) => {
const songs = await loadPlaybackSongs(convex, cacheScope, songIds)
const [songs] = await Promise.all([
loadPlaybackSongs(convex, cacheScope, songIds),
downloadQueueFor(config)
.load()
.catch(() => {}),
])
const sources = new Map<Id<"songs">, AudioSource>()
for (const song of songs) {
if (!song) return null
// Downloads play from this device, whatever the streaming quality.
const localUri = downloadedAudioUri(config, song.id)
if (localUri) {
sources.set(song.id, { uri: localUri, name: song.title })
continue
}
const plan = playbackStreamPlan(
song.files,
user.playbackQuality,
+164
View File
@@ -0,0 +1,164 @@
import AsyncStorage from "@react-native-async-storage/async-storage"
import { Directory, File, Paths } from "expo-file-system"
import { Platform } from "react-native"
import {
createDownloadQueue,
type DownloadedCollection,
type DownloadedSong,
type DownloadQueue,
type DownloadStorage,
} from "@otunes/convex/client/download-queue"
import {
parseDownloadQuality,
songDownloadPath,
type DownloadQuality,
} from "@otunes/convex/download-quality"
import { getAuthCookieHeader } from "@/lib/auth-cookies"
import type { ServerConfig } from "@/lib/server-config"
const REMEMBERED_QUALITY_KEY = "otunes.download-quality"
const PARTIAL_SUFFIX = ".partial"
// Each song is a folder named `<songId>.<quality>` holding one audio file,
// named by the server so it keeps the right extension. Folders end in
// `.partial` until their download completes.
function serverDirectory(config: ServerConfig) {
const host = config.hostname.replace(/[^a-z0-9.-]/gi, "_")
return new Directory(Paths.document, "downloads", host)
}
function parseSongFolder(name: string) {
const dot = name.lastIndexOf(".")
const quality = parseDownloadQuality(name.slice(dot + 1))
return quality ? { songId: name.slice(0, dot), quality } : null
}
function songFolders(root: Directory) {
if (!root.exists) return []
return root
.list()
.filter((entry): entry is Directory => entry instanceof Directory)
}
function audioFile(folder: Directory) {
return folder.list().find((entry): entry is File => entry instanceof File)
}
function createStorage(config: ServerConfig): DownloadStorage {
const root = serverDirectory(config)
const collectionsFile = new File(root, "collections.json")
function foldersFor(songIds: ReadonlySet<string>) {
return songFolders(root).filter((folder) => {
const name = folder.name.replace(PARTIAL_SUFFIX, "")
const parsed = parseSongFolder(name)
return parsed !== null && songIds.has(parsed.songId)
})
}
return {
async list() {
const songs: DownloadedSong[] = []
for (const folder of songFolders(root)) {
const parsed = parseSongFolder(folder.name)
const file = parsed ? audioFile(folder) : undefined
if (!parsed || !file) {
// Interrupted downloads from an earlier launch.
folder.delete()
continue
}
songs.push({ ...parsed, bytes: file.size ?? 0 })
}
return songs
},
async save({ songId, requested, quality }, signal) {
const cookieHeader = await getAuthCookieHeader(
config.serverUrl,
config.convexUrl
)
if (!cookieHeader) throw new Error("Sign in to download")
root.create({ intermediates: true, idempotent: true })
const name = `${songId}.${quality}`
const partial = new Directory(root, `${name}${PARTIAL_SUFFIX}`)
if (partial.exists) partial.delete()
partial.create()
try {
const path = songDownloadPath(songId, requested, {
losslessFormat: Platform.OS === "ios" ? "alac" : undefined,
})
const file = await File.downloadFileAsync(
`${config.serverUrl}${path}`,
partial,
{ headers: { Cookie: cookieHeader }, signal }
)
signal.throwIfAborted()
partial.rename(name)
return file.size ?? 0
} catch (error) {
if (partial.exists) partial.delete()
throw error
}
},
async readCollections() {
if (!collectionsFile.exists) return []
try {
return JSON.parse(
await collectionsFile.text()
) as DownloadedCollection[]
} catch {
return []
}
},
async writeCollections(collections) {
root.create({ intermediates: true, idempotent: true })
if (!collectionsFile.exists) collectionsFile.create()
await collectionsFile.write(JSON.stringify(collections))
},
async remove(songIds) {
for (const folder of foldersFor(new Set(songIds))) folder.delete()
},
}
}
const queues = new Map<string, DownloadQueue>()
/** Downloads are kept per server, since song IDs only mean something there. */
export function downloadQueueFor(config: ServerConfig) {
let queue = queues.get(config.hostname)
if (!queue) {
queue = createDownloadQueue(createStorage(config))
queues.set(config.hostname, queue)
}
return queue
}
/** The local file for a downloaded song, for the player to use offline. */
export function downloadedAudioUri(config: ServerConfig, songId: string) {
const song = downloadQueueFor(config).getDownloaded(songId)
if (!song) return null
const folder = new Directory(
serverDirectory(config),
`${songId}.${song.quality}`
)
return folder.exists ? (audioFile(folder)?.uri ?? null) : null
}
export async function readRememberedDownloadQuality() {
try {
return parseDownloadQuality(
await AsyncStorage.getItem(REMEMBERED_QUALITY_KEY)
)
} catch {
return undefined
}
}
/** Pass undefined to ask every time again. */
export async function writeRememberedDownloadQuality(
quality: DownloadQuality | undefined
) {
if (quality) await AsyncStorage.setItem(REMEMBERED_QUALITY_KEY, quality)
else await AsyncStorage.removeItem(REMEMBERED_QUALITY_KEY)
}
+1
View File
@@ -29,6 +29,7 @@
"expo-blur": "~58.0.5",
"expo-constants": "~58.0.13",
"expo-dev-client": "~58.0.14",
"expo-file-system": "~58.0.10",
"expo-font": "~58.0.9",
"expo-glass-effect": "~58.0.5",
"expo-haptics": "~58.0.7",
+15 -12
View File
@@ -1,4 +1,5 @@
import { AddToPlaylistProvider } from "@/components/add-to-playlist-provider"
import { DownloadsProvider } from "@/components/downloads-provider"
import { FavoritesProvider } from "@/components/favorites-provider"
import { PlaybackProvider } from "@/components/playback-provider"
import { PlayerBar } from "@/components/player-bar"
@@ -17,18 +18,20 @@ export default function AppLayout({
<SidebarProvider>
<PlaybackProvider>
<AddToPlaylistProvider>
<FavoritesProvider>
<AppSidebar />
<div className="flex min-h-svh min-w-0 flex-1">
<SidebarInset className="min-w-0 flex-1">
<Suspense>
<ScrollRestoration>{children}</ScrollRestoration>
</Suspense>
</SidebarInset>
<LazyQueuePanel />
</div>
<PlayerBar />
</FavoritesProvider>
<DownloadsProvider>
<FavoritesProvider>
<AppSidebar />
<div className="flex min-h-svh min-w-0 flex-1">
<SidebarInset className="min-w-0 flex-1">
<Suspense>
<ScrollRestoration>{children}</ScrollRestoration>
</Suspense>
</SidebarInset>
<LazyQueuePanel />
</div>
<PlayerBar />
</FavoritesProvider>
</DownloadsProvider>
</AddToPlaylistProvider>
</PlaybackProvider>
</SidebarProvider>
+103
View File
@@ -0,0 +1,103 @@
import {
DOWNLOAD_QUALITIES,
downloadOptions,
downloadPlan,
estimatedAacBytes,
type DownloadOptionsResponse,
} from "@otunes/convex/download-quality"
import { audioInfo } from "@/lib/server-audio-info"
import { getSongSources } from "@/lib/server-song"
import { NextRequest, NextResponse, userAgent } from "next/server"
import fs from "node:fs/promises"
const MAX_SONGS = 5000
type FileSize = { bytes: number; estimated: boolean }
/**
* Sizes every quality the songs can download in. Files sent as-is have exact
* sizes; re-encodes (including ALAC to FLAC) are estimates.
*/
export async function POST(request: NextRequest) {
const body = (await request.json().catch(() => null)) as {
songIds?: unknown
losslessFormat?: unknown
} | null
const songIds = body?.songIds
if (
!Array.isArray(songIds) ||
songIds.length > MAX_SONGS ||
!songIds.every((id) => typeof id === "string")
) {
return new Response("Expected songIds", { status: 400 })
}
const acceptsAlac =
userAgent(request).browser.name === "Safari" ||
body?.losslessFormat === "alac"
let songs: Awaited<ReturnType<typeof getSongSources>>
try {
songs = await getSongSources(songIds)
} catch {
return new Response("Not found", { status: 404 })
}
const fileSizes = new Map<string, Promise<FileSize>>()
const sizeOf = (path: string, source: string, seconds: number) => {
let size = fileSizes.get(path)
if (!size) {
size = (async () => {
const { size: bytes } = await fs.stat(path)
if (source !== "lossless" || acceptsAlac) {
return { bytes, estimated: false }
}
// ALAC is converted to FLAC for clients that cannot play it.
const estimated = (await audioInfo(path)).codec === "ALAC"
return { bytes, estimated }
})().catch(() => ({
bytes: estimatedAacBytes(seconds, 256),
estimated: true,
}))
fileSizes.set(path, size)
}
return size
}
const totals = await Promise.all(
DOWNLOAD_QUALITIES.map(async (quality) => {
const sizes = await Promise.all(
songs.map((song) => {
const plan = downloadPlan(song.files, quality)
if (plan.kbps > 0) {
return {
bytes: estimatedAacBytes(song.length, plan.kbps),
estimated: true,
}
}
return sizeOf(song.files[plan.source], plan.source, song.length)
})
)
return {
quality,
bytes: sizes.reduce((total, size) => total + size.bytes, 0),
estimated: sizes.some((size) => size.estimated),
}
})
)
const response: DownloadOptionsResponse = {
songs: songs.map((song) => ({
id: song._id,
files: Object.fromEntries(
Object.keys(song.files).map((codec) => [codec, true as const])
),
})),
options: downloadOptions(songs.map((song) => song.files)).map((option) => {
const total = totals.find(({ quality }) => quality === option.quality)!
return { ...option, bytes: total.bytes, estimated: total.estimated }
}),
}
return NextResponse.json(response, {
headers: { "Cache-Control": "no-store" },
})
}
@@ -0,0 +1,150 @@
import {
downloadPlan,
parseDownloadQuality,
} from "@otunes/convex/download-quality"
import { audioContentTypeForPath } from "@/lib/audio-content-type"
import { audioInfo } from "@/lib/server-audio-info"
import { streamFile } from "@/lib/server-audio-stream"
import { spawnFfmpeg } from "@/lib/server-ffmpeg"
import { seekableLosslessFile } from "@/lib/server-lossless"
import { getSongSource } from "@/lib/server-song"
import { NextRequest, NextResponse, userAgent } from "next/server"
import fs from "node:fs/promises"
import os from "node:os"
import path from "node:path"
/** The filename tells native clients which extension to save the file with. */
function downloadHeaders(
songId: string,
extension: string,
contentType: string,
size: number
) {
return {
"Cache-Control": "no-store",
"Content-Disposition": `attachment; filename="${songId}${extension}"`,
"Content-Length": String(size),
"Content-Type": contentType,
}
}
async function fileResponse(songId: string, file: string, contentType: string) {
const { size } = await fs.stat(file)
return new NextResponse(streamFile(file), {
headers: downloadHeaders(
songId,
path.extname(file).toLowerCase(),
contentType,
size
),
})
}
/**
* Transcodes to an AAC .m4a with its index up front, so the saved file has a
* duration and seeks offline. The temporary file is removed once sent.
*/
async function transcodeResponse(
songId: string,
source: string,
kbps: number,
signal: AbortSignal
) {
const dir = await fs.mkdtemp(path.join(os.tmpdir(), "otunes-download-"))
const output = path.join(dir, "audio.m4a")
const cleanup = () => fs.rm(dir, { recursive: true, force: true })
try {
const ffmpeg = await spawnFfmpeg(
[
"-i",
source,
"-map",
"0:a:0",
"-c:a",
"aac",
"-b:a",
`${kbps}k`,
"-movflags",
"+faststart",
output,
],
signal
)
const onAbort = () => ffmpeg.child.kill("SIGKILL")
signal.addEventListener("abort", onAbort, { once: true })
const code = await ffmpeg.exited
signal.removeEventListener("abort", onAbort)
if (code !== 0) {
throw new Error(
`Download transcode failed: ${code}: ${ffmpeg.stderrTail()}`
)
}
const { size } = await fs.stat(output)
return new NextResponse(streamFile(output, undefined, cleanup), {
headers: downloadHeaders(songId, ".m4a", "audio/mp4", size),
})
} catch (error) {
await cleanup()
throw error
}
}
/** Sends one song as a whole file for offline playback. */
export async function GET(
request: NextRequest,
{ params }: { params: Promise<{ id: string }> }
) {
const { id } = await params
const quality = parseDownloadQuality(
request.nextUrl.searchParams.get("quality")
)
if (!quality) {
return new Response("Unknown quality", { status: 400 })
}
let song: Awaited<ReturnType<typeof getSongSource>>
try {
song = await getSongSource(id)
} catch {
return new Response("Not found", { status: 404 })
}
const plan = downloadPlan(song.files, quality)
const sourceFile = song.files[plan.source]
if (!sourceFile) {
return new Response("Not found", { status: 404 })
}
try {
if (plan.kbps > 0) {
return await transcodeResponse(
song._id,
sourceFile,
plan.kbps,
request.signal
)
}
if (plan.source === "lossless") {
// Only Safari and iOS play ALAC, so everyone else gets FLAC.
const acceptsAlac =
userAgent(request).browser.name === "Safari" ||
request.nextUrl.searchParams.get("losslessFormat") === "alac"
if (!acceptsAlac && (await audioInfo(sourceFile)).codec === "ALAC") {
const flac = await seekableLosslessFile(sourceFile)
return await fileResponse(song._id, flac, "audio/flac")
}
}
return await fileResponse(
song._id,
sourceFile,
audioContentTypeForPath(sourceFile)
)
} catch (error) {
if (!request.signal.aborted) {
console.error("Song download failed", error)
}
return new Response("Server Error", { status: 500 })
}
}
+20
View File
@@ -14,6 +14,8 @@ import {
type MediaContextAction,
} from "@/components/media-context-menu"
import { usePlaybackActions } from "@/components/playback-provider"
import { useDownloads } from "@/components/downloads-provider"
import { useIsCollectionDownloaded } from "@/hooks/use-downloads"
import { useQueueMediaActions } from "@/hooks/use-queue-media-actions"
import { api } from "@otunes/convex/_generated/api"
import { Button } from "@/components/ui/button"
@@ -50,6 +52,9 @@ export function AlbumCard({ album }: { album: BrowseAlbum }) {
const { isAlbumFavorite, toggleAlbumFavorite } = useFavorites()
const { playAlbum } = usePlaybackActions()
const { runQueueAction, createStation } = useQueueMediaActions()
const { requestDownload, removeDownload } = useDownloads()
const downloadRef = { kind: "album" as const, id: album.id }
const downloaded = useIsCollectionDownloaded(downloadRef)
const [menuOpen, setMenuOpen] = React.useState(false)
const [hovered, setHovered] = React.useState(false)
const showActions = hovered || menuOpen
@@ -94,6 +99,20 @@ export function AlbumCard({ album }: { album: BrowseAlbum }) {
void runQueueAction(action, songIds)
break
}
case "download":
case "remove-download": {
const songIds = await fetchCachedQuery(
convex,
cacheScope,
api.playlists.getAlbumSongIds,
{ albumId: album.id as Id<"albums"> }
)
const target = { ...downloadRef, title: album.title, songIds }
void (action === "download"
? requestDownload(target)
: removeDownload(target))
break
}
}
}
@@ -157,6 +176,7 @@ export function AlbumCard({ album }: { album: BrowseAlbum }) {
selectedCount={1}
onAction={(action) => void handleCardAction(action)}
favorited={isAlbumFavorite(album.id)}
downloaded={downloaded}
navigation={{ artist: { id: album.artist.id } }}
share={{ type: "album", albumId: album.id }}
/>
+24
View File
@@ -9,7 +9,10 @@ import { Play, Share2, Shuffle } from "lucide-react"
import { AudioFormatBadge } from "@/components/audio-format-badge"
import { MediaCollectionFooter } from "@/components/media-collection-footer"
import { DownloadButton } from "@/components/download-button"
import { useDownloads } from "@/components/downloads-provider"
import { FavoriteMediaButton } from "@/components/favorite-media-button"
import { useIsCollectionDownloaded } from "@/hooks/use-downloads"
import { useFavorites } from "@/components/favorites-provider"
import {
useCurrentSongId,
@@ -189,6 +192,17 @@ export function AlbumView({
selectedIds,
artistId: album.artist.id,
})
const { requestDownload, removeDownload } = useDownloads()
const downloadTarget = React.useMemo(
() => ({
kind: "album" as const,
id: album.id,
title: album.title,
songIds: albumSongIds,
}),
[album.id, album.title, albumSongIds]
)
const albumDownloaded = useIsCollectionDownloaded(downloadTarget)
const handleRowSelect = React.useCallback(
(index: number, event: React.MouseEvent) => {
@@ -220,6 +234,14 @@ export function AlbumView({
void toggleAlbumFavorite(album.id as Id<"albums">)
return
}
if (action === "download") {
void requestDownload(downloadTarget)
return
}
if (action === "remove-download") {
void removeDownload(downloadTarget)
return
}
runSongsAction(action, albumSongIds, album.artist.id)
}
@@ -307,6 +329,7 @@ export function AlbumView({
favoritedLabel={`Remove ${album.title} from favorites`}
unfavoritedLabel={`Favorite ${album.title}`}
/>
<DownloadButton target={downloadTarget} />
<Button
variant="secondary"
size="icon"
@@ -323,6 +346,7 @@ export function AlbumView({
onOpenMenu={() => {}}
onAction={handleAlbumMediaAction}
favorited={isAlbumFavorite(album.id)}
downloaded={albumDownloaded}
trackRowTrigger={false}
triggerVariant="secondary"
triggerClassName="rounded-full"
+112
View File
@@ -0,0 +1,112 @@
"use client"
import * as React from "react"
import { ArrowDownToLine, Check } from "lucide-react"
import {
useDownloads,
type DownloadTarget,
} from "@/components/downloads-provider"
import {
AlertDialog,
AlertDialogAction,
AlertDialogCancel,
AlertDialogContent,
AlertDialogFooter,
AlertDialogHeader,
AlertDialogTitle,
} from "@/components/ui/alert-dialog"
import { Button } from "@/components/ui/button"
import { useCollectionDownload } from "@/hooks/use-downloads"
const RING_RADIUS = 14
const RING_LENGTH = 2 * Math.PI * RING_RADIUS
/** Static ring that fills as songs finish; a square in the middle means "tap to stop". */
function ProgressRing({ fraction }: { fraction: number }) {
return (
<svg viewBox="0 0 36 36" className="size-6" aria-hidden>
<circle
cx="18"
cy="18"
r={RING_RADIUS}
fill="none"
stroke="currentColor"
strokeOpacity={0.25}
strokeWidth={3}
/>
<circle
cx="18"
cy="18"
r={RING_RADIUS}
fill="none"
stroke="currentColor"
strokeWidth={3}
strokeDasharray={RING_LENGTH}
strokeDashoffset={RING_LENGTH * (1 - fraction)}
transform="rotate(-90 18 18)"
/>
<rect x="14" y="14" width="8" height="8" fill="currentColor" />
</svg>
)
}
/** Download, progress, and downloaded states for an album or playlist header. */
export function DownloadButton({
target,
}: {
target: Exclude<DownloadTarget, { kind: "songs" }>
}) {
const { requestDownload, removeDownload } = useDownloads()
const { collection, status } = useCollectionDownload(target, target.songIds)
const [confirmRemove, setConfirmRemove] = React.useState(false)
const inProgress = collection !== undefined && status.queued > 0
const done = collection !== undefined && !inProgress && status.total > 0
let label = `Download ${target.title}`
let icon: React.ReactNode = <ArrowDownToLine />
if (inProgress) {
label = `Stop downloading, ${status.downloaded} of ${status.total} done`
icon = <ProgressRing fraction={status.downloaded / status.total} />
} else if (done) {
label = `Remove download of ${target.title}`
icon = <Check />
}
return (
<>
<Button
variant={done ? "default" : "secondary"}
size="icon"
className="rounded-full"
aria-label={label}
title={label}
disabled={target.songIds.length === 0}
onClick={() => {
if (inProgress) void removeDownload(target)
else if (done) setConfirmRemove(true)
else void requestDownload(target)
}}
>
{icon}
</Button>
<AlertDialog open={confirmRemove} onOpenChange={setConfirmRemove}>
<AlertDialogContent size="sm">
<AlertDialogHeader>
<AlertDialogTitle>Remove download?</AlertDialogTitle>
</AlertDialogHeader>
<AlertDialogFooter>
<AlertDialogCancel>Cancel</AlertDialogCancel>
<AlertDialogAction
variant="destructive"
onClick={() => void removeDownload(target)}
>
Remove
</AlertDialogAction>
</AlertDialogFooter>
</AlertDialogContent>
</AlertDialog>
</>
)
}
+319
View File
@@ -0,0 +1,319 @@
"use client"
import * as React from "react"
import { useConvex, useQuery } from "convex/react"
import { toast } from "sonner"
import { AudioFormatBadge } from "@/components/audio-format-badge"
import { Button } from "@/components/ui/button"
import { Checkbox } from "@/components/ui/checkbox"
import {
Dialog,
DialogContent,
DialogFooter,
DialogHeader,
DialogTitle,
} from "@/components/ui/dialog"
import { Label } from "@/components/ui/label"
import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { useDownloadsVersion } from "@/hooks/use-downloads"
import {
downloadQueue,
readRememberedDownloadQuality,
requestPersistentStorage,
writeRememberedDownloadQuality,
} from "@/lib/downloads"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import type {
CollectionRef,
DownloadableSong,
} from "@otunes/convex/client/download-queue"
import {
DOWNLOAD_OPTIONS_PATH,
DOWNLOAD_QUALITY_DETAILS,
DOWNLOAD_QUALITY_LABELS,
formatBytes,
type DownloadOptionsResponse,
type DownloadQuality,
type SizedDownloadOption,
} from "@otunes/convex/download-quality"
/** Songs on their own, or an album or playlist that stays downloaded as a whole. */
export type DownloadTarget =
| { kind: "songs"; songIds: string[]; title: string }
| (CollectionRef & { title: string; songIds: string[] })
/** The Favorites playlist has no ID, so downloads use this one. */
export const FAVORITES_DOWNLOAD_ID = "favorites"
type DownloadsContextValue = {
/** Asks for a quality (unless remembered) and starts downloading. */
requestDownload: (target: DownloadTarget) => Promise<void>
removeDownload: (target: DownloadTarget) => Promise<void>
}
const DownloadsContext = React.createContext<DownloadsContextValue | null>(null)
export function useDownloads() {
const context = React.useContext(DownloadsContext)
if (!context) {
throw new Error("useDownloads must be used within DownloadsProvider")
}
return context
}
async function fetchDownloadOptions(songIds: string[]) {
const response = await fetch(DOWNLOAD_OPTIONS_PATH, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ songIds }),
})
if (!response.ok) {
throw new Error("Could not reach the server to download")
}
return (await response.json()) as DownloadOptionsResponse
}
function startDownload(
target: DownloadTarget,
songs: DownloadableSong[],
quality: DownloadQuality
) {
requestPersistentStorage()
if (target.kind === "songs") {
return downloadQueue.enqueue(songs, quality)
}
return downloadQueue.downloadCollection(
{ kind: target.kind, id: target.id, title: target.title, quality },
songs
)
}
function optionDetail(option: SizedDownloadOption, songCount: number) {
if (option.fallbackCount === 0) {
return DOWNLOAD_QUALITY_DETAILS[option.quality]
}
const included = songCount - option.fallbackCount
return `${included} of ${songCount} songs, ${option.fallbackCount} in High`
}
function QualityLabel({ quality }: { quality: DownloadQuality }) {
if (quality === "lossless" || quality === "atmos") {
return (
<AudioFormatBadge format={quality} backgroundColor="var(--popover)" />
)
}
return (
<span className="text-[13px] font-medium">
{DOWNLOAD_QUALITY_LABELS[quality]}
</span>
)
}
function DownloadQualityDialog({
pending,
onClose,
}: {
pending: { target: DownloadTarget; response: DownloadOptionsResponse } | null
onClose: () => void
}) {
const [quality, setQuality] = React.useState<DownloadQuality>("high")
const [remember, setRemember] = React.useState(false)
const options = pending?.response.options ?? []
const songCount = pending?.response.songs.length ?? 0
async function handleDownload() {
if (!pending) return
if (remember) writeRememberedDownloadQuality(quality)
onClose()
await startDownload(pending.target, pending.response.songs, quality)
}
return (
<Dialog open={pending !== null} onOpenChange={(open) => !open && onClose()}>
<DialogContent className="gap-3 sm:max-w-sm">
<DialogHeader>
<DialogTitle className="truncate">
Download &ldquo;{pending?.target.title}&rdquo;
</DialogTitle>
</DialogHeader>
<RadioGroup
value={quality}
onValueChange={(value) => setQuality(value as DownloadQuality)}
className="gap-0"
>
{options.map((option) => (
<Label
key={option.quality}
htmlFor={`download-${option.quality}`}
className="grid cursor-pointer grid-cols-[auto_1fr_auto] items-center gap-3 rounded-md px-1 py-2 font-normal has-data-[state=checked]:bg-muted"
>
<RadioGroupItem
value={option.quality}
id={`download-${option.quality}`}
/>
<span className="flex min-w-0 flex-col gap-0.5">
<QualityLabel quality={option.quality} />
<span className="text-xs text-muted-foreground">
{optionDetail(option, songCount)}
</span>
</span>
<span className="text-xs text-muted-foreground tabular-nums">
{option.estimated ? "~" : ""}
{formatBytes(option.bytes)}
</span>
</Label>
))}
</RadioGroup>
<div className="flex items-center gap-2">
<Checkbox
id="download-remember"
checked={remember}
onCheckedChange={(checked) => setRemember(checked === true)}
/>
<Label htmlFor="download-remember" className="font-normal">
Remember my choice
</Label>
</div>
<DialogFooter>
<Button variant="ghost" onClick={onClose}>
Cancel
</Button>
<Button onClick={() => void handleDownload()}>Download</Button>
</DialogFooter>
</DialogContent>
</Dialog>
)
}
const SYNC_BATCH_SIZE = 200
/** Keeps a downloaded playlist's songs in step with the playlist. */
function useSyncDownloadedPlaylist(
id: string,
songIds: readonly string[] | undefined
) {
const convex = useConvex()
React.useEffect(() => {
if (!songIds) return
void downloadQueue
.syncCollection({ kind: "playlist", id }, songIds, async (added) => {
const songs: DownloadableSong[] = []
for (let start = 0; start < added.length; start += SYNC_BATCH_SIZE) {
const batch = await convex.query(api.library.getSongsForPlayback, {
ids: added.slice(start, start + SYNC_BATCH_SIZE) as Id<"songs">[],
})
for (const song of batch) if (song) songs.push(song)
}
return songs
})
.catch(() => {})
}, [convex, id, songIds])
}
function PlaylistSync({ id }: { id: string }) {
const songIds = useQuery(api.playlists.getPlaylistSongIds, {
playlistId: id as Id<"playlists">,
})
useSyncDownloadedPlaylist(id, songIds)
return null
}
function FavoritesSync() {
const favorites = useCachedQuery(api.favorites.getUserFavorites)
const songIds = React.useMemo(
() => favorites?.favoriteSongs.flat(),
[favorites]
)
useSyncDownloadedPlaylist(FAVORITES_DOWNLOAD_ID, songIds)
return null
}
function DownloadSync() {
useDownloadsVersion()
return downloadQueue
.collections()
.filter((collection) => collection.kind === "playlist")
.map((collection) =>
collection.id === FAVORITES_DOWNLOAD_ID ? (
<FavoritesSync key={collection.id} />
) : (
<PlaylistSync key={collection.id} id={collection.id} />
)
)
}
/** Reports failed songs once per burst instead of once per song. */
function useFailureToasts() {
React.useEffect(() => {
let failed = 0
let timer: ReturnType<typeof setTimeout> | null = null
const unsubscribe = downloadQueue.onFailure(() => {
failed += 1
timer ??= setTimeout(() => {
toast.error(
failed === 1
? "A song could not be downloaded"
: `${failed} songs could not be downloaded`
)
failed = 0
timer = null
}, 1000)
})
return () => {
unsubscribe()
if (timer) clearTimeout(timer)
}
}, [])
}
export function DownloadsProvider({ children }: { children: React.ReactNode }) {
const [pending, setPending] = React.useState<{
target: DownloadTarget
response: DownloadOptionsResponse
} | null>(null)
useFailureToasts()
React.useEffect(() => {
void downloadQueue.load().catch(() => {})
}, [])
const requestDownload = React.useCallback(async (target: DownloadTarget) => {
if (target.songIds.length === 0) return
try {
const response = await fetchDownloadOptions(target.songIds)
const remembered = readRememberedDownloadQuality()
if (remembered) {
await startDownload(target, response.songs, remembered)
toast(`Downloading ${target.title}`)
} else {
setPending({ target, response })
}
} catch (error) {
toast.error(error instanceof Error ? error.message : "Download failed")
}
}, [])
const removeDownload = React.useCallback(async (target: DownloadTarget) => {
if (target.kind === "songs") await downloadQueue.remove(target.songIds)
else await downloadQueue.removeCollection(target)
}, [])
const value = React.useMemo(
() => ({ requestDownload, removeDownload }),
[requestDownload, removeDownload]
)
return (
<DownloadsContext.Provider value={value}>
{children}
<DownloadSync />
<DownloadQualityDialog
pending={pending}
onClose={() => setPending(null)}
/>
</DownloadsContext.Provider>
)
}
+250
View File
@@ -0,0 +1,250 @@
"use client"
import * as React from "react"
import { Trash2 } from "lucide-react"
import { AudioFormatBadge } from "@/components/audio-format-badge"
import {
AlertDialog,
AlertDialogAction,
AlertDialogCancel,
AlertDialogContent,
AlertDialogFooter,
AlertDialogHeader,
AlertDialogTitle,
AlertDialogTrigger,
} from "@/components/ui/alert-dialog"
import { Button } from "@/components/ui/button"
import {
Select,
SelectContent,
SelectItem,
SelectTrigger,
SelectValue,
} from "@/components/ui/select"
import { useDownloadsVersion } from "@/hooks/use-downloads"
import {
downloadQueue,
readRememberedDownloadQuality,
writeRememberedDownloadQuality,
} from "@/lib/downloads"
import {
DOWNLOAD_QUALITIES,
DOWNLOAD_QUALITY_LABELS,
formatBytes,
type DownloadQuality,
} from "@otunes/convex/download-quality"
const ASK_EVERY_TIME = "ask"
/** Shades of the text color, darkest for the smallest files. */
const QUALITY_OPACITY: Record<DownloadQuality, number> = {
medium: 0.25,
high: 0.45,
lossless: 0.7,
atmos: 1,
}
function QualityName({ quality }: { quality: DownloadQuality }) {
if (quality === "lossless" || quality === "atmos") {
return <AudioFormatBadge format={quality} />
}
return <span>{DOWNLOAD_QUALITY_LABELS[quality]}</span>
}
function songCount(count: number) {
return count === 1 ? "1 song" : `${count} songs`
}
function RememberedQualitySelect() {
const [value, setValue] = React.useState<string>(
() => readRememberedDownloadQuality() ?? ASK_EVERY_TIME
)
return (
<div className="flex items-center justify-between gap-4 text-sm">
<span>Download quality</span>
<Select
value={value}
onValueChange={(next) => {
setValue(next)
writeRememberedDownloadQuality(
next === ASK_EVERY_TIME ? undefined : (next as DownloadQuality)
)
}}
>
<SelectTrigger className="w-40">
<SelectValue />
</SelectTrigger>
<SelectContent>
<SelectItem value={ASK_EVERY_TIME}>Ask every time</SelectItem>
{DOWNLOAD_QUALITIES.map((quality) => (
<SelectItem key={quality} value={quality}>
{DOWNLOAD_QUALITY_LABELS[quality]}
</SelectItem>
))}
</SelectContent>
</Select>
</div>
)
}
/** Storage used by downloads in this browser, by quality and by album or playlist. */
export function DownloadsSettings() {
const version = useDownloadsVersion()
const breakdown = React.useMemo(
() => downloadQueue.breakdown(),
// version invalidates the breakdown when downloads change.
// eslint-disable-next-line react-hooks/exhaustive-deps
[version]
)
const qualities = breakdown.byQuality.filter((entry) => entry.songs > 0)
return (
<div className="space-y-6">
<div className="flex items-baseline justify-between gap-4">
<h3 className="text-base font-medium">Downloads</h3>
<span className="text-sm text-muted-foreground tabular-nums">
{formatBytes(breakdown.bytes)} · {songCount(breakdown.songs)}
{breakdown.queued > 0 ? ` · ${breakdown.queued} downloading` : ""}
</span>
</div>
<RememberedQualitySelect />
{breakdown.songs > 0 ? (
<div className="space-y-2">
<div className="flex h-2 overflow-hidden rounded-full bg-muted">
{qualities.map((entry) => (
<div
key={entry.quality}
className="h-full bg-foreground"
style={{
width: `${(entry.bytes / breakdown.bytes) * 100}%`,
opacity: QUALITY_OPACITY[entry.quality],
}}
/>
))}
</div>
<div className="divide-y text-sm">
{qualities.map((entry) => (
<div
key={entry.quality}
className="flex items-center gap-3 py-1.5"
>
<span
className="size-2 shrink-0 rounded-full bg-foreground"
style={{ opacity: QUALITY_OPACITY[entry.quality] }}
/>
<span className="flex-1">
<QualityName quality={entry.quality} />
</span>
<span className="text-muted-foreground tabular-nums">
{songCount(entry.songs)}
</span>
<span className="w-16 text-right tabular-nums">
{formatBytes(entry.bytes)}
</span>
</div>
))}
</div>
</div>
) : null}
{breakdown.collections.length > 0 ||
breakdown.singles.songIds.length > 0 ? (
<div className="divide-y text-sm">
{breakdown.collections.map(
({ collection, bytes, status, fallbackCount }) => (
<div
key={`${collection.kind}:${collection.id}`}
className="flex items-center gap-3 py-2"
>
<div className="min-w-0 flex-1">
<p className="truncate">{collection.title}</p>
<p className="flex flex-wrap items-center gap-x-1.5 text-xs text-muted-foreground">
<span>
{collection.kind === "album" ? "Album" : "Playlist"}
</span>
<span aria-hidden>·</span>
<QualityName quality={collection.quality} />
{fallbackCount > 0 ? (
<span>({fallbackCount} in High)</span>
) : null}
{status.downloaded < status.total ? (
<>
<span aria-hidden>·</span>
<span className="tabular-nums">
{status.downloaded} of {status.total}
</span>
</>
) : null}
</p>
</div>
<span className="tabular-nums">{formatBytes(bytes)}</span>
<Button
variant="ghost"
size="icon-sm"
aria-label={`Remove download of ${collection.title}`}
onClick={() =>
void downloadQueue.removeCollection(collection)
}
>
<Trash2 />
</Button>
</div>
)
)}
{breakdown.singles.songIds.length > 0 ? (
<div className="flex items-center gap-3 py-2">
<div className="min-w-0 flex-1">
<p>Individual songs</p>
<p className="text-xs text-muted-foreground">
{songCount(breakdown.singles.songIds.length)}
</p>
</div>
<span className="tabular-nums">
{formatBytes(breakdown.singles.bytes)}
</span>
<Button
variant="ghost"
size="icon-sm"
aria-label="Remove individually downloaded songs"
onClick={() =>
void downloadQueue.remove(breakdown.singles.songIds)
}
>
<Trash2 />
</Button>
</div>
) : null}
</div>
) : (
<p className="text-sm text-muted-foreground">
Nothing downloaded in this browser.
</p>
)}
{breakdown.songs > 0 || breakdown.queued > 0 ? (
<AlertDialog>
<AlertDialogTrigger asChild>
<Button variant="destructive">Remove all downloads</Button>
</AlertDialogTrigger>
<AlertDialogContent size="sm">
<AlertDialogHeader>
<AlertDialogTitle>Remove all downloads?</AlertDialogTitle>
</AlertDialogHeader>
<AlertDialogFooter>
<AlertDialogCancel>Cancel</AlertDialogCancel>
<AlertDialogAction
variant="destructive"
onClick={() => void downloadQueue.removeAll()}
>
Remove
</AlertDialogAction>
</AlertDialogFooter>
</AlertDialogContent>
</AlertDialog>
) : null}
</div>
)
}
@@ -3,6 +3,8 @@
import * as React from "react"
import Link from "next/link"
import {
ArrowDownToLine,
CircleX,
GalleryVerticalEnd,
ListEnd,
ListPlus,
@@ -40,6 +42,8 @@ export type MediaContextAction =
| "shuffle"
| "create-station"
| "favorite"
| "download"
| "remove-download"
export type MediaContextNavigation = {
artist?: { id: string }
@@ -83,6 +87,7 @@ export function MediaContextMenuItems({
stationArtistId,
navigation,
share,
downloaded,
}: {
selectedCount: number
onAction: (action: MediaContextAction) => void
@@ -92,6 +97,8 @@ export function MediaContextMenuItems({
stationArtistId?: string
navigation?: MediaContextNavigation
share?: MediaShareContext
/** Shows Download, or Remove Download when true. Omit to hide both. */
downloaded?: boolean
}) {
const { artist, album } = navigation ?? {}
const showShare = shouldShowShare(share, selectedCount)
@@ -117,6 +124,18 @@ export function MediaContextMenuItems({
{actionLabel(playlistLabel, selectedCount)}
<ListPlus />
</MediaMenuItem>
{downloaded !== undefined ? (
<MediaMenuItem
className="justify-between"
onClick={() => onAction(downloaded ? "remove-download" : "download")}
>
{actionLabel(
downloaded ? "Remove Download" : "Download",
selectedCount
)}
{downloaded ? <CircleX /> : <ArrowDownToLine />}
</MediaMenuItem>
) : null}
<MediaMenuSeparator />
<MediaMenuItem
className="justify-between"
@@ -222,6 +241,7 @@ export type MediaContextMenuProps = {
stationArtistId?: string
navigation?: MediaContextNavigation
share?: MediaShareContext
downloaded?: boolean
inSelectionRange?: boolean
/** When false, the trigger uses default button/dropdown styling (page headers). */
trackRowTrigger?: boolean
@@ -264,6 +284,7 @@ export function MediaContextMenuArea({
stationArtistId={menu.stationArtistId}
navigation={menu.navigation}
share={menu.share}
downloaded={menu.downloaded}
/>
{menu.children}
</MenuKindContext>
@@ -283,6 +304,7 @@ export function MediaContextMenu({
stationArtistId,
navigation,
share,
downloaded,
inSelectionRange = false,
trackRowTrigger = true,
triggerClassName,
@@ -324,6 +346,7 @@ export function MediaContextMenu({
stationArtistId={stationArtistId}
navigation={navigation}
share={share}
downloaded={downloaded}
/>
{children}
</DropdownMenuContent>
+9 -1
View File
@@ -39,6 +39,7 @@ import {
TableHeader,
TableRow,
} from "@/components/ui/table"
import { DownloadsSettings } from "@/components/downloads-settings"
import { usePlayback } from "@/components/playback-provider"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
@@ -46,7 +47,7 @@ import type { PlaybackQuality } from "@otunes/convex/playback-stream"
import { resizeProfileImageToDataUrl } from "@/lib/resize-profile-image"
import { cn } from "@/lib/utils"
type Section = "profile" | "quality" | "users" | "library"
type Section = "profile" | "quality" | "downloads" | "users" | "library"
type CurrentUser = {
_id: Id<"users">
@@ -949,6 +950,12 @@ export function OptionsModal({
>
Quality
</NavButton>
<NavButton
active={activeSection === "downloads"}
onClick={() => setSection("downloads")}
>
Downloads
</NavButton>
</nav>
{isAdmin ? (
@@ -979,6 +986,7 @@ export function OptionsModal({
<div className="p-6">
{activeSection === "profile" && <ProfileSection user={user} />}
{activeSection === "quality" && <QualitySection user={user} />}
{activeSection === "downloads" && <DownloadsSettings />}
{activeSection === "library" && isAdmin ? (
<LibrarySection />
) : null}
+140 -51
View File
@@ -35,6 +35,7 @@ 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 { downloadedAudioUrl, downloadQueue } from "@/lib/downloads"
import { flushPersistentCache } from "@/lib/persistent-cache"
import * as playbackQueue from "@otunes/convex/client/playback-queue"
import type { RepeatMode } from "@otunes/convex/client/playback-queue"
@@ -207,10 +208,52 @@ function playbackLoadSettings(
}
}
function songLoadKey(songId: string, settings: PlaybackLoadSettings) {
/** Where a song plays from: this device's download, or the server. */
type AudioSourceChoice =
{ kind: "download" } | { kind: "stream"; settings: PlaybackLoadSettings }
/** Downloads play without the user or file info, so they also work offline. */
function audioSourceChoice(
songId: string,
user: { preferAtmos?: boolean; playbackQuality?: PlaybackQuality } | null,
dolbyAtmosSupported: boolean | null,
files: Record<string, unknown> | undefined
): AudioSourceChoice | null {
if (downloadQueue.getDownloaded(songId)) {
return { kind: "download" }
}
if (!user || !files) {
return null
}
return {
kind: "stream",
settings: playbackLoadSettings(user, dolbyAtmosSupported, files),
}
}
function songLoadKey(songId: string, source: AudioSourceChoice) {
if (source.kind === "download") {
return `${songId}:download`
}
const { settings } = source
return `${songId}:${settings.preferAtmos}:${settings.playbackQuality}:${settings.useHls ? "hls" : "file"}`
}
/**
* True when `loadedKey` is this song from the other side of download vs
* stream. Finishing or removing a download keeps the loaded audio playing.
*/
function switchesDownloadSource(
loadedKey: string | null,
songId: string,
source: AudioSourceChoice
) {
if (!loadedKey?.startsWith(`${songId}:`)) {
return false
}
return (source.kind === "download") !== loadedKey.endsWith(":download")
}
function destroyHlsInstance(hlsRef: RefObject<Hls | null>) {
hlsRef.current?.destroy()
hlsRef.current = null
@@ -242,21 +285,11 @@ function loadAudioSource(
audio: HTMLAudioElement,
hlsRef: RefObject<Hls | null>,
songId: string,
settings: PlaybackLoadSettings,
source: AudioSourceChoice,
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)
@@ -269,6 +302,48 @@ function loadAudioSource(
audio.addEventListener("loadeddata", onReadyToPlay)
audio.addEventListener("canplay", onReadyToPlay)
const cleanup = () => {
disposed = true
audio.removeEventListener("loadedmetadata", onReadyToPlay)
audio.removeEventListener("loadeddata", onReadyToPlay)
audio.removeEventListener("canplay", onReadyToPlay)
if (hlsInstance && hlsRef.current === hlsInstance) {
hlsInstance.destroy()
hlsRef.current = null
}
}
if (source.kind === "download") {
void downloadedAudioUrl(songId)
.catch(() => null)
.then((url) => {
if (disposed) {
return
}
if (!url) {
// Removed since it was chosen; the audio error handler reports it.
audio.removeAttribute("src")
audio.load()
return
}
audio.src = url
audio.load()
})
return cleanup
}
const { settings } = source
const directUrl = songPlayPath(
songId,
settings.playbackQuality,
settings.preferAtmos
)
const hlsUrl = songHlsPlaylistPath(
songId,
settings.playbackQuality,
settings.preferAtmos
)
const loadDirectSource = () => {
if (disposed) {
return
@@ -302,16 +377,7 @@ function loadAudioSource(
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
}
}
return cleanup
}
export function usePlayback() {
@@ -439,6 +505,15 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
getDolbyAtmosSnapshot,
() => null
)
// Re-picks audio sources when songs finish downloading or are removed.
const downloadsVersion = useSyncExternalStore(
downloadQueue.subscribe,
downloadQueue.getVersion,
() => 0
)
useEffect(() => {
void downloadQueue.load().catch(() => {})
}, [])
const volume = useSyncExternalStore(
subscribeVolume,
readStoredVolume,
@@ -759,18 +834,21 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
return
}
if (!user || !currentSongDoc) {
const source = audioSourceChoice(
currentSongId,
user ? { playbackQuality, preferAtmos } : null,
dolbyAtmosSupported,
currentSongDoc?.files
)
if (!source) {
return
}
const loadKey = songLoadKey(currentSongId, source)
const settings = playbackLoadSettings(
{ playbackQuality, preferAtmos },
dolbyAtmosSupported,
currentSongDoc.files
)
const loadKey = songLoadKey(currentSongId, settings)
if (loadedSongKeyRef.current === loadKey) {
if (
loadedSongKeyRef.current === loadKey ||
switchesDownloadSource(loadedSongKeyRef.current, currentSongId, source)
) {
return
}
@@ -811,7 +889,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
audio,
hlsRef,
currentSongId,
settings,
source,
requestPlay
)
@@ -826,6 +904,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
playbackQuality,
preferAtmos,
dolbyAtmosSupported,
downloadsVersion,
runWithoutAudioSync,
destroyHls,
clearPreload,
@@ -839,16 +918,16 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
return
}
if (!user || !nextQueueSongDoc) {
const source = audioSourceChoice(
nextQueueSongId,
user ? { playbackQuality, preferAtmos } : null,
dolbyAtmosSupported,
nextQueueSongDoc?.files
)
if (!source) {
return
}
const settings = playbackLoadSettings(
{ playbackQuality, preferAtmos },
dolbyAtmosSupported,
nextQueueSongDoc.files
)
const loadKey = songLoadKey(nextQueueSongId, settings)
const loadKey = songLoadKey(nextQueueSongId, source)
if (preloadedSongKeyRef.current === loadKey) {
return
@@ -867,7 +946,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
preloadAudio,
preloadHlsRef,
nextQueueSongId,
settings,
source,
onPreloadReady
)
@@ -888,6 +967,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
playbackQuality,
preferAtmos,
dolbyAtmosSupported,
downloadsVersion,
clearPreload,
destroyPreloadHls,
])
@@ -949,19 +1029,21 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
}
const preloadAudio = preloadAudioRef.current
const nextSource = nextQueueSongId
? audioSourceChoice(
nextQueueSongId,
user ?? null,
dolbyAtmosSupported,
nextQueueSongDoc?.files
)
: null
if (
shouldContinuePlaying &&
preloadAudio &&
nextQueueSongId &&
user &&
nextQueueSongDoc
nextSource
) {
const settings = playbackLoadSettings(
user,
dolbyAtmosSupported,
nextQueueSongDoc.files
)
const nextLoadKey = songLoadKey(nextQueueSongId, settings)
const nextLoadKey = songLoadKey(nextQueueSongId, nextSource)
if (
preloadedSongKeyRef.current === nextLoadKey &&
@@ -1393,8 +1475,15 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
skipPrevious,
})
const currentFormat =
currentSongDoc && user
const currentDownload = currentSongId
? downloadQueue.getDownloaded(currentSongId)
: undefined
const currentFormat = currentDownload
? currentDownload.quality === "atmos" ||
currentDownload.quality === "lossless"
? currentDownload.quality
: null
: currentSongDoc && user
? playbackFormat(
currentSongDoc.files,
user.playbackQuality,
+20
View File
@@ -22,6 +22,8 @@ import {
DropdownMenuContent,
DropdownMenuTrigger,
} from "@/components/ui/dropdown-menu"
import { useDownloads } from "@/components/downloads-provider"
import { useIsCollectionDownloaded } from "@/hooks/use-downloads"
import { useQueueMediaActions } from "@/hooks/use-queue-media-actions"
import { api } from "@otunes/convex/_generated/api"
import { fetchCachedQuery } from "@otunes/convex/client/cached-query"
@@ -32,6 +34,9 @@ export function PlaylistCard({ playlist }: { playlist: PlaylistSummary }) {
const { openAddPlaylistToPlaylist } = useAddToPlaylist()
const { playPlaylist } = usePlaybackActions()
const { runQueueAction } = useQueueMediaActions()
const { requestDownload, removeDownload } = useDownloads()
const downloadRef = { kind: "playlist" as const, id: playlist.id }
const downloaded = useIsCollectionDownloaded(downloadRef)
async function handleCardAction(action: MediaContextAction) {
switch (action) {
@@ -52,6 +57,20 @@ export function PlaylistCard({ playlist }: { playlist: PlaylistSummary }) {
void runQueueAction(action, songIds)
break
}
case "download":
case "remove-download": {
const songIds = await fetchCachedQuery(
convex,
cacheScope,
api.playlists.getPlaylistSongIds,
{ playlistId: playlist.id as Id<"playlists"> }
)
const target = { ...downloadRef, title: playlist.title, songIds }
void (action === "download"
? requestDownload(target)
: removeDownload(target))
break
}
case "favorite":
break
}
@@ -101,6 +120,7 @@ export function PlaylistCard({ playlist }: { playlist: PlaylistSummary }) {
<MediaContextMenuItems
selectedCount={1}
showFavorite={false}
downloaded={downloaded}
onAction={(action) => void handleCardAction(action)}
share={{ type: "playlist", playlistId: playlist.id }}
/>
+28
View File
@@ -9,7 +9,13 @@ import { useMutation } from "convex/react"
import { Play, SearchIcon, Share2, Shuffle, Star, Trash2 } from "lucide-react"
import { toast } from "sonner"
import { DownloadButton } from "@/components/download-button"
import {
FAVORITES_DOWNLOAD_ID,
useDownloads,
} from "@/components/downloads-provider"
import { useFavorites } from "@/components/favorites-provider"
import { useIsCollectionDownloaded } from "@/hooks/use-downloads"
import {
useCurrentSongId,
usePlaybackActions,
@@ -146,7 +152,27 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
const handleMediaAction = useTrackListMediaAction({ selectedIds, songs })
const { requestDownload, removeDownload } = useDownloads()
const downloadTarget = React.useMemo(
() => ({
kind: "playlist" as const,
id: playlist.id ?? FAVORITES_DOWNLOAD_ID,
title: playlist.title,
songIds: playlistSongIds,
}),
[playlist.id, playlist.title, playlistSongIds]
)
const playlistDownloaded = useIsCollectionDownloaded(downloadTarget)
function handlePlaylistMediaAction(action: MediaContextAction) {
if (action === "download") {
void requestDownload(downloadTarget)
return
}
if (action === "remove-download") {
void removeDownload(downloadTarget)
return
}
runSongsAction(action, playlistSongIds)
}
@@ -351,6 +377,7 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
{isSubscribed ? "Subscribed" : "Subscribe"}
</Button>
) : null}
<DownloadButton target={downloadTarget} />
{!isFavorites ? (
<Button
variant="secondary"
@@ -373,6 +400,7 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
onAction={handlePlaylistMediaAction}
playlistLabel={ADD_TO_ANOTHER_PLAYLIST}
showFavorite={!isFavorites}
downloaded={playlistDownloaded}
trackRowTrigger={false}
triggerVariant="secondary"
triggerClassName="rounded-full"
+16
View File
@@ -1,5 +1,7 @@
"use client"
import { useDownloads } from "@/components/downloads-provider"
import { useIsSongDownloaded } from "@/hooks/use-downloads"
import Image from "next/image"
import Link from "next/link"
import { useAddToPlaylist } from "@/components/add-to-playlist-provider"
@@ -20,6 +22,13 @@ export function SearchSongItem({ song }: { song: BrowseSong }) {
const { isSongFavorite, toggleSongFavorite } = useFavorites()
const { runQueueAction, createStation } = useQueueMediaActions()
const songIds = [song.id as Id<"songs">]
const { requestDownload, removeDownload } = useDownloads()
const downloaded = useIsSongDownloaded(song.id)
const downloadTarget = {
kind: "songs" as const,
songIds,
title: song.title,
}
function handleAction(action: MediaContextAction) {
switch (action) {
@@ -37,6 +46,12 @@ export function SearchSongItem({ song }: { song: BrowseSong }) {
case "favorite":
void toggleSongFavorite(song.id as Id<"songs">)
break
case "download":
void requestDownload(downloadTarget)
break
case "remove-download":
void removeDownload(downloadTarget)
break
}
}
@@ -47,6 +62,7 @@ export function SearchSongItem({ song }: { song: BrowseSong }) {
onOpenMenu: () => {},
onAction: handleAction,
favorited: isSongFavorite(song.id),
downloaded,
navigation: {
artist: { id: song.artist.id },
album: { id: song.album.id },
+8 -2
View File
@@ -3,7 +3,7 @@
import * as React from "react"
import Image from "next/image"
import Link from "next/link"
import { Music2, Play, Star, Trash2 } from "lucide-react"
import { ArrowDownToLine, Music2, Play, Star, Trash2 } from "lucide-react"
import {
MediaContextMenu,
@@ -28,6 +28,7 @@ import {
type SelectionRangePosition,
} from "@/lib/selection-range-styles"
import { formatDuration } from "@/lib/format-duration"
import { useIsSongDownloaded } from "@/hooks/use-downloads"
import { cn } from "@/lib/utils"
import type { BrowseSong } from "@otunes/convex/types"
@@ -270,6 +271,7 @@ function TrackRowComponent({
onDrop,
}: TrackRowProps) {
const inRange = isInSelectionRange(selectionPosition)
const isDownloaded = useIsSongDownloaded(song.id)
const flush = variant === "library" || variant === "queue"
const play = () => onPlay(index)
const toggleFavorite = () => onToggleFavorite?.(song.id)
@@ -303,11 +305,14 @@ function TrackRowComponent({
const duration = (
<span
className={cn(
"shrink-0 text-right tabular-nums",
"flex shrink-0 items-center justify-end gap-2 tabular-nums",
variant === "queue" && "text-xs",
inRange ? "text-primary-foreground" : "text-muted-foreground"
)}
>
{isDownloaded ? (
<ArrowDownToLine className="size-3.5" aria-label="Downloaded" />
) : null}
{formatDuration(song.durationSeconds)}
</span>
)
@@ -329,6 +334,7 @@ function TrackRowComponent({
album: { id: song.album.id },
},
share: { type: "song", albumId: song.album.id, songId: song.id },
downloaded: isDownloaded,
children:
removeLabel && onRemove ? (
<>
+62
View File
@@ -0,0 +1,62 @@
"use client"
import { useMemo, useSyncExternalStore } from "react"
import type { CollectionRef } from "@otunes/convex/client/download-queue"
import { downloadQueue } from "@/lib/downloads"
/** Re-renders on every download change. Prefer the narrower hooks in lists. */
export function useDownloadsVersion() {
return useSyncExternalStore(
downloadQueue.subscribe,
downloadQueue.getVersion,
() => 0
)
}
/** Only re-renders when this song is downloaded or removed. */
export function useIsSongDownloaded(songId: string) {
return useSyncExternalStore(
downloadQueue.subscribe,
() => downloadQueue.getDownloaded(songId) !== undefined,
() => false
)
}
/** True when every song is downloaded. Re-renders only when that flips. */
export function useAreSongsDownloaded(songIds: readonly string[]) {
return useSyncExternalStore(
downloadQueue.subscribe,
() =>
songIds.length > 0 &&
songIds.every((songId) => downloadQueue.getDownloaded(songId)),
() => false
)
}
/** A downloaded album or playlist and how far along its songs are. */
export function useCollectionDownload(
ref: CollectionRef,
songIds?: readonly string[]
) {
const version = useDownloadsVersion()
const { kind, id } = ref
return useMemo(() => {
const collection = downloadQueue.getCollection({ kind, id })
return {
collection,
status: downloadQueue.status(songIds ?? collection?.songIds ?? []),
}
// version invalidates the lookup when downloads change.
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [kind, id, songIds, version])
}
/** Whether an album or playlist is downloaded, for menus that list many. */
export function useIsCollectionDownloaded(ref: CollectionRef) {
return useSyncExternalStore(
downloadQueue.subscribe,
() => downloadQueue.getCollection(ref) !== undefined,
() => false
)
}
+29 -1
View File
@@ -4,21 +4,32 @@ import * as React from "react"
import { useConvex } from "convex/react"
import { useAddToPlaylist } from "@/components/add-to-playlist-provider"
import { useDownloads } from "@/components/downloads-provider"
import { useFavorites } from "@/components/favorites-provider"
import type { MediaContextAction } from "@/components/media-context-menu"
import { useCacheScope } from "@/components/persistent-cache-provider"
import { useQueueMediaActions } from "@/hooks/use-queue-media-actions"
import { getCachedSong } from "@/lib/song-cache"
import { stationArtistId } from "@/lib/station-artist"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import { fetchCachedQuery } from "@otunes/convex/client/cached-query"
/** The song's title for one song, else a count. */
function songsTitle(songIds: readonly string[]) {
if (songIds.length === 1) {
return getCachedSong(songIds[0])?.title ?? "1 song"
}
return `${songIds.length} songs`
}
export function useMediaActions() {
const { openAddToPlaylist, openAddArtistToPlaylist } = useAddToPlaylist()
const { favoriteSongs, toggleArtistFavorite } = useFavorites()
const { runQueueAction, createStation } = useQueueMediaActions()
const convex = useConvex()
const cacheScope = useCacheScope()
const { requestDownload, removeDownload } = useDownloads()
const runSongsAction = React.useCallback(
(
@@ -41,9 +52,26 @@ export function useMediaActions() {
case "shuffle":
void runQueueAction(action, songIds)
break
case "download":
void requestDownload({
kind: "songs",
songIds,
title: songsTitle(songIds),
})
break
case "remove-download":
void removeDownload({ kind: "songs", songIds, title: "" })
break
}
},
[createStation, favoriteSongs, openAddToPlaylist, runQueueAction]
[
createStation,
favoriteSongs,
openAddToPlaylist,
runQueueAction,
requestDownload,
removeDownload,
]
)
const runArtistAction = React.useCallback(
+166
View File
@@ -0,0 +1,166 @@
import {
createDownloadQueue,
type DownloadedCollection,
type DownloadedSong,
type DownloadStorage,
} from "@otunes/convex/client/download-queue"
import {
parseDownloadQuality,
songDownloadPath,
type DownloadQuality,
} from "@otunes/convex/download-quality"
// Like YouTube Music on the web, downloads live in this browser's IndexedDB
// and only play inside the app. Clearing site data removes them.
const DB_NAME = "otunes-downloads"
const AUDIO_STORE = "audio"
const SONG_STORE = "songs"
const REMEMBERED_QUALITY_KEY = "otunes:download-quality"
const COLLECTIONS_KEY = "otunes:download-collections"
let database: Promise<IDBDatabase> | null = null
function openDatabase() {
database ??= new Promise<IDBDatabase>((resolve, reject) => {
const request = indexedDB.open(DB_NAME, 1)
request.onupgradeneeded = () => {
request.result.createObjectStore(AUDIO_STORE)
request.result.createObjectStore(SONG_STORE, { keyPath: "songId" })
}
request.onsuccess = () => resolve(request.result)
request.onerror = () => {
database = null
reject(request.error)
}
})
return database
}
async function transaction(
mode: IDBTransactionMode,
run: (audio: IDBObjectStore, songs: IDBObjectStore) => void
) {
const db = await openDatabase()
await new Promise<void>((resolve, reject) => {
const tx = db.transaction([AUDIO_STORE, SONG_STORE], mode)
run(tx.objectStore(AUDIO_STORE), tx.objectStore(SONG_STORE))
tx.oncomplete = () => resolve()
tx.onerror = () => reject(tx.error)
tx.onabort = () => reject(tx.error)
})
}
function readRequest<T>(store: IDBObjectStore, key?: string) {
return new Promise<T>((resolve, reject) => {
const request = key === undefined ? store.getAll() : store.get(key)
request.onsuccess = () => resolve(request.result as T)
request.onerror = () => reject(request.error)
})
}
const storage: DownloadStorage = {
async list() {
const db = await openDatabase()
return readRequest<DownloadedSong[]>(
db.transaction(SONG_STORE).objectStore(SONG_STORE)
)
},
async save({ songId, requested, quality }, signal) {
const response = await fetch(songDownloadPath(songId, requested), {
signal,
})
if (!response.ok) {
throw new Error(`Download failed with ${response.status}`)
}
const blob = await response.blob()
signal.throwIfAborted()
const entry: DownloadedSong = { songId, quality, bytes: blob.size }
await transaction("readwrite", (audio, songs) => {
audio.put(blob, songId)
songs.put(entry)
})
return blob.size
},
async readCollections() {
try {
const raw = localStorage.getItem(COLLECTIONS_KEY)
return raw ? (JSON.parse(raw) as DownloadedCollection[]) : []
} catch {
return []
}
},
async writeCollections(collections) {
localStorage.setItem(COLLECTIONS_KEY, JSON.stringify(collections))
},
async remove(songIds) {
if (songIds.length === 0) return
for (const songId of songIds) revokeAudioUrl(songId)
await transaction("readwrite", (audio, songs) => {
for (const songId of songIds) {
audio.delete(songId)
songs.delete(songId)
}
})
},
}
export const downloadQueue = createDownloadQueue(storage)
/** Asks the browser not to evict downloads when storage runs low. */
export function requestPersistentStorage() {
void navigator.storage?.persist?.().catch(() => false)
}
// Object URLs keep blobs alive, so only the few in use (playing and preloaded) stay open.
const MAX_AUDIO_URLS = 3
const audioUrls = new Map<string, string>()
function revokeAudioUrl(songId: string) {
const url = audioUrls.get(songId)
if (url) {
URL.revokeObjectURL(url)
audioUrls.delete(songId)
}
}
/** A playable URL for a downloaded song, or null when it is not downloaded. */
export async function downloadedAudioUrl(songId: string) {
const existing = audioUrls.get(songId)
if (existing) {
audioUrls.delete(songId)
audioUrls.set(songId, existing)
return existing
}
const db = await openDatabase()
const blob = await readRequest<Blob | undefined>(
db.transaction(AUDIO_STORE).objectStore(AUDIO_STORE),
songId
)
if (!blob) return null
const url = URL.createObjectURL(blob)
audioUrls.set(songId, url)
while (audioUrls.size > MAX_AUDIO_URLS) {
revokeAudioUrl(audioUrls.keys().next().value!)
}
return url
}
export function readRememberedDownloadQuality() {
try {
return parseDownloadQuality(localStorage.getItem(REMEMBERED_QUALITY_KEY))
} catch {
return undefined
}
}
/** Pass undefined to ask every time again. */
export function writeRememberedDownloadQuality(
quality: DownloadQuality | undefined
) {
try {
if (quality) localStorage.setItem(REMEMBERED_QUALITY_KEY, quality)
else localStorage.removeItem(REMEMBERED_QUALITY_KEY)
} catch {
// Without storage the prompt simply shows every time.
}
}
+9 -1
View File
@@ -69,8 +69,16 @@ function toWebStream(
)
}
export function streamFile(path: string, range?: ByteRange) {
/** Streams a file. `onClose` runs once it is fully sent or abandoned. */
export function streamFile(
path: string,
range?: ByteRange,
onClose?: () => void
) {
const file = createReadStream(path, range)
if (onClose) {
file.once("close", onClose)
}
return toWebStream(file, { cancel: () => file.destroy() })
}
+21
View File
@@ -21,3 +21,24 @@ export async function getSongSource(id: string): Promise<SongSource> {
}
return song
}
const SOURCE_BATCH_SIZE = 200
/** `getSongSource` for many songs, in batches. Missing songs are left out. */
export async function getSongSources(ids: string[]): Promise<SongSource[]> {
const token = await convexAuthNextjsToken()
const batches: string[][] = []
for (let start = 0; start < ids.length; start += SOURCE_BATCH_SIZE) {
batches.push(ids.slice(start, start + SOURCE_BATCH_SIZE))
}
const results = await Promise.all(
batches.map((batch) =>
fetchQuery(
api.library.getSongSources,
{ ids: batch as Id<"songs">[] },
convexServerOptions(token)
)
)
)
return results.flat()
}
+363
View File
@@ -0,0 +1,363 @@
import {
DOWNLOAD_QUALITIES,
downloadPlan,
type DownloadQuality,
} from "../download-quality"
export type DownloadedSong = {
songId: string
/** The quality the file is in, after any fallback to High. */
quality: DownloadQuality
bytes: number
}
/**
* An album or playlist downloaded as a whole. Playlists stay in sync: songs
* added later download in `quality`, and songs taken out are removed.
*/
export type DownloadedCollection = {
kind: "album" | "playlist"
id: string
title: string
quality: DownloadQuality
songIds: string[]
}
export type CollectionRef = Pick<DownloadedCollection, "kind" | "id">
/** Where a platform keeps downloaded audio. */
export type DownloadStorage = {
list(): Promise<DownloadedSong[]>
/**
* Fetches `requested` from the server and stores it, recording `quality`
* (what the server falls back to). Returns the stored size. Must leave
* nothing behind when it throws or `signal` aborts.
*/
save(
song: {
songId: string
requested: DownloadQuality
quality: DownloadQuality
},
signal: AbortSignal
): Promise<number>
remove(songIds: readonly string[]): Promise<void>
readCollections(): Promise<DownloadedCollection[]>
writeCollections(collections: DownloadedCollection[]): Promise<void>
}
export type DownloadableSong = {
id: string
files: Record<string, unknown>
}
export type DownloadStatus = {
downloaded: number
queued: number
total: number
}
export type DownloadBreakdown = {
bytes: number
songs: number
queued: number
byQuality: { quality: DownloadQuality; bytes: number; songs: number }[]
collections: {
collection: DownloadedCollection
bytes: number
status: DownloadStatus
/** Downloaded songs that fell back to High. */
fallbackCount: number
}[]
/** Songs downloaded on their own, outside any album or playlist. */
singles: { bytes: number; songIds: string[] }
}
export type DownloadQueue = ReturnType<typeof createDownloadQueue>
function collectionKey({ kind, id }: CollectionRef) {
return `${kind}:${id}`
}
/**
* Downloads songs a few at a time and tracks which songs, albums, and
* playlists are on this device. Read it from React with
* `useSyncExternalStore(subscribe, getVersion)`.
*/
export function createDownloadQueue(
storage: DownloadStorage,
{ concurrency = 2 }: { concurrency?: number } = {}
) {
const downloaded = new Map<string, DownloadedSong>()
const collections = new Map<string, DownloadedCollection>()
const waiting: { song: DownloadableSong; quality: DownloadQuality }[] = []
const running = new Map<string, AbortController>()
const listeners = new Set<() => void>()
const failureListeners = new Set<(songId: string, error: unknown) => void>()
let version = 0
let loading: Promise<void> | null = null
function notify() {
version += 1
for (const listener of listeners) listener()
}
function load() {
loading ??= Promise.all([storage.list(), storage.readCollections()]).then(
([songs, saved]) => {
for (const song of songs) downloaded.set(song.songId, song)
for (const collection of saved) {
collections.set(collectionKey(collection), collection)
}
notify()
},
(error) => {
loading = null
throw error
}
)
return loading
}
function saveCollections() {
return storage.writeCollections([...collections.values()])
}
function isQueued(songId: string) {
return running.has(songId) || waiting.some(({ song }) => song.id === songId)
}
function status(songIds: readonly string[]): DownloadStatus {
let done = 0
let queued = 0
for (const songId of songIds) {
if (downloaded.has(songId)) done += 1
else if (isQueued(songId)) queued += 1
}
return { downloaded: done, queued, total: songIds.length }
}
function pump() {
while (running.size < concurrency && waiting.length > 0) {
const { song, quality } = waiting.shift()!
const controller = new AbortController()
const actual = downloadPlan(song.files, quality).quality
running.set(song.id, controller)
void storage
.save(
{ songId: song.id, requested: quality, quality: actual },
controller.signal
)
.then(
(bytes) => {
if (controller.signal.aborted) return
downloaded.set(song.id, { songId: song.id, quality: actual, bytes })
},
(error) => {
if (controller.signal.aborted) return
for (const listener of failureListeners) listener(song.id, error)
}
)
.finally(() => {
if (running.get(song.id) === controller) running.delete(song.id)
notify()
pump()
})
}
}
function enqueueLoaded(
songs: readonly DownloadableSong[],
quality: DownloadQuality
) {
for (const song of songs) {
if (downloaded.has(song.id) || isQueued(song.id)) continue
waiting.push({ song, quality })
}
}
async function remove(songIds: readonly string[]) {
const ids = new Set(songIds)
for (let index = waiting.length - 1; index >= 0; index -= 1) {
if (ids.has(waiting[index].song.id)) waiting.splice(index, 1)
}
for (const songId of ids) {
running.get(songId)?.abort()
running.delete(songId)
downloaded.delete(songId)
}
notify()
await storage.remove([...ids])
pump()
}
/** Song IDs held by any downloaded collection other than `except`. */
function songsInOtherCollections(except: string) {
const held = new Set<string>()
for (const [key, collection] of collections) {
if (key === except) continue
for (const songId of collection.songIds) held.add(songId)
}
return held
}
return {
load,
subscribe(listener: () => void) {
listeners.add(listener)
return () => {
listeners.delete(listener)
}
},
/** Changes whenever anything downloads, queues, or is removed. */
getVersion: () => version,
/** Called when a song fails to download; it is left undownloaded. */
onFailure(listener: (songId: string, error: unknown) => void) {
failureListeners.add(listener)
return () => {
failureListeners.delete(listener)
}
},
getDownloaded: (songId: string) => downloaded.get(songId),
getCollection: (ref: CollectionRef) => collections.get(collectionKey(ref)),
collections: () => [...collections.values()],
isQueued,
status,
/** Queues songs that are not downloaded or queued yet. */
async enqueue(
songs: readonly DownloadableSong[],
quality: DownloadQuality
) {
await load()
enqueueLoaded(songs, quality)
notify()
pump()
},
/** Downloads an album or playlist and remembers it for syncing. */
async downloadCollection(
collection: Omit<DownloadedCollection, "songIds">,
songs: readonly DownloadableSong[]
) {
await load()
collections.set(collectionKey(collection), {
...collection,
songIds: songs.map((song) => song.id),
})
enqueueLoaded(songs, collection.quality)
notify()
pump()
await saveCollections()
},
/**
* Brings a downloaded playlist up to date with its current songs.
* `loadSongs` fetches file info for the songs that were added.
*/
async syncCollection(
ref: CollectionRef,
songIds: readonly string[],
loadSongs: (songIds: string[]) => Promise<DownloadableSong[]>
) {
await load()
const key = collectionKey(ref)
const collection = collections.get(key)
if (!collection) return
const before = new Set(collection.songIds)
const after = new Set(songIds)
const added = songIds.filter((songId) => !before.has(songId))
const held = songsInOtherCollections(key)
const dropped = collection.songIds.filter(
(songId) => !after.has(songId) && !held.has(songId)
)
if (added.length === 0 && dropped.length === 0) return
collections.set(key, { ...collection, songIds: [...songIds] })
await saveCollections()
if (dropped.length > 0) await remove(dropped)
if (added.length > 0) {
enqueueLoaded(await loadSongs(added), collection.quality)
notify()
pump()
}
},
/** Forgets a collection and removes its songs no other collection holds. */
async removeCollection(ref: CollectionRef) {
await load()
const key = collectionKey(ref)
const collection = collections.get(key)
if (!collection) return
collections.delete(key)
const held = songsInOtherCollections(key)
await saveCollections()
await remove(collection.songIds.filter((songId) => !held.has(songId)))
},
/** Cancels queued songs and removes downloaded ones. */
remove,
async removeAll() {
await load()
collections.clear()
await saveCollections()
await remove([
...downloaded.keys(),
...running.keys(),
...waiting.map(({ song }) => song.id),
])
},
/** Where download storage goes, for settings. */
breakdown(): DownloadBreakdown {
const byQuality = DOWNLOAD_QUALITIES.map((quality) => ({
quality,
bytes: 0,
songs: 0,
}))
let bytes = 0
for (const song of downloaded.values()) {
const entry = byQuality.find(({ quality }) => quality === song.quality)!
entry.bytes += song.bytes
entry.songs += 1
bytes += song.bytes
}
const inCollections = new Set<string>()
const collectionRows = [...collections.values()].map((collection) => {
let collectionBytes = 0
let fallbackCount = 0
for (const songId of collection.songIds) {
inCollections.add(songId)
const song = downloaded.get(songId)
if (!song) continue
collectionBytes += song.bytes
if (song.quality !== collection.quality) fallbackCount += 1
}
return {
collection,
bytes: collectionBytes,
status: status(collection.songIds),
fallbackCount,
}
})
const singles = { bytes: 0, songIds: [] as string[] }
for (const song of downloaded.values()) {
if (inCollections.has(song.songId)) continue
singles.bytes += song.bytes
singles.songIds.push(song.songId)
}
return {
bytes,
songs: downloaded.size,
queued: running.size + waiting.length,
byQuality,
collections: collectionRows.sort((a, b) => b.bytes - a.bytes),
singles,
}
},
}
}
+15
View File
@@ -993,6 +993,21 @@ export const getSongSource = query({
},
})
/** Batch of `getSongSource` for download sizing. Missing songs are skipped. */
export const getSongSources = query({
args: { ids: v.array(v.id("songs")) },
handler: async (ctx, args) => {
await requireSignedIn(ctx)
if (args.ids.length > MAX_SONGS_BY_IDS) {
throw new ConvexError(`Request at most ${MAX_SONGS_BY_IDS} songs`)
}
const songs = await Promise.all(args.ids.map((id) => ctx.db.get(id)))
return songs.flatMap((song) =>
song ? [{ _id: song._id, files: song.files, length: song.length }] : []
)
},
})
function playbackCodecMap(files: Record<string, string>) {
return Object.fromEntries(Object.keys(files).map((codec) => [codec, true]))
}
+150
View File
@@ -0,0 +1,150 @@
import type { PlaybackSource } from "./playback-stream"
/** Qualities a listener can pick when downloading, lowest first. */
export const DOWNLOAD_QUALITIES = [
"medium",
"high",
"lossless",
"atmos",
] as const
export type DownloadQuality = (typeof DOWNLOAD_QUALITIES)[number]
export const DOWNLOAD_QUALITY_LABELS: Record<DownloadQuality, string> = {
medium: "Medium",
high: "High",
lossless: "Lossless",
atmos: "Dolby Atmos",
}
export const DOWNLOAD_QUALITY_DETAILS: Record<DownloadQuality, string> = {
medium: "AAC 128 kbps",
high: "AAC 256 kbps",
lossless: "ALAC or FLAC",
atmos: "Spatial audio",
}
const MEDIUM_KBPS = 128
const HIGH_KBPS = 256
export function parseDownloadQuality(
value: string | null | undefined
): DownloadQuality | undefined {
return DOWNLOAD_QUALITIES.find((quality) => quality === value)
}
export type DownloadPlan = {
/** What the song actually downloads as after falling back. */
quality: DownloadQuality
source: PlaybackSource
/** AAC bitrate to transcode to; 0 sends the source file as-is. */
kbps: number
}
function highPlan(files: Record<string, unknown>): DownloadPlan {
if ("normal" in files) {
return { quality: "high", source: "normal", kbps: 0 }
}
return {
quality: "high",
source: "lossless" in files ? "lossless" : "atmos",
kbps: HIGH_KBPS,
}
}
/**
* Picks the file for one song. Lossless and Dolby Atmos fall back to High when
* the song lacks them, and Medium is always transcoded.
*/
export function downloadPlan(
files: Record<string, unknown>,
quality: DownloadQuality
): DownloadPlan {
switch (quality) {
case "medium":
return {
quality,
source:
"lossless" in files
? "lossless"
: "normal" in files
? "normal"
: "atmos",
kbps: MEDIUM_KBPS,
}
case "high":
return highPlan(files)
case "lossless":
case "atmos": {
const source = quality === "lossless" ? "lossless" : "atmos"
return source in files ? { quality, source, kbps: 0 } : highPlan(files)
}
}
}
export type DownloadOption = {
quality: DownloadQuality
/** How many of the songs fall back to High for this quality. */
fallbackCount: number
}
/**
* The qualities to offer for a set of songs. Lossless and Dolby Atmos only
* appear when at least one song has them.
*/
export function downloadOptions(
songs: readonly Record<string, unknown>[]
): DownloadOption[] {
return DOWNLOAD_QUALITIES.flatMap((quality) => {
const fallbackCount = songs.filter(
(files) => downloadPlan(files, quality).quality !== quality
).length
if (
fallbackCount === songs.length &&
quality !== "medium" &&
quality !== "high"
) {
return []
}
return [{ quality, fallbackCount }]
})
}
export type SizedDownloadOption = DownloadOption & {
bytes: number
/** True when part of the size is a guess because the server re-encodes. */
estimated: boolean
}
/** Server answer for a set of songs about to be downloaded. */
export type DownloadOptionsResponse = {
songs: { id: string; files: Record<string, true> }[]
options: SizedDownloadOption[]
}
/** POST `{ songIds, losslessFormat? }` here for `DownloadOptionsResponse`. */
export const DOWNLOAD_OPTIONS_PATH = "/api/download/options"
/** Rough size of an AAC encode, including container overhead. */
export function estimatedAacBytes(seconds: number, kbps: number) {
return Math.round(((seconds * kbps * 1000) / 8) * 1.02)
}
export function formatBytes(bytes: number) {
if (bytes < 1000 * 1000) return `${Math.max(1, Math.round(bytes / 1000))} KB`
if (bytes < 1000 * 1000 * 1000) return `${Math.round(bytes / 1000 / 1000)} MB`
return `${(bytes / 1000 / 1000 / 1000).toFixed(1)} GB`
}
/** Download route for one song. iOS asks for ALAC so it skips FLAC conversion. */
export function songDownloadPath(
songId: string,
quality: DownloadQuality,
options?: { losslessFormat?: "alac" }
) {
const params = new URLSearchParams({ quality })
if (options?.losslessFormat) {
params.set("losslessFormat", options.losslessFormat)
}
return `/api/song/${songId}/download?${params}`
}
+8
View File
@@ -15,6 +15,10 @@
"types": "./convex/types.ts",
"default": "./convex/types.ts"
},
"./download-quality": {
"types": "./download-quality.ts",
"default": "./download-quality.ts"
},
"./playback-stream": {
"types": "./playback-stream.ts",
"default": "./playback-stream.ts"
@@ -35,6 +39,10 @@
"types": "./client/cached-query.ts",
"default": "./client/cached-query.ts"
},
"./client/download-queue": {
"types": "./client/download-queue.ts",
"default": "./client/download-queue.ts"
},
"./client/favorites": {
"types": "./client/favorites.ts",
"default": "./client/favorites.ts"
+3
View File
@@ -88,6 +88,9 @@ importers:
expo-dev-client:
specifier: ~58.0.14
version: 58.0.14(expo@58.0.17)(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7))(@types/react@19.3.0)(react@19.3.0))
expo-file-system:
specifier: ~58.0.10
version: 58.0.10(patch_hash=8e68fafb653077a9ba74fe6c33a742af88e3299ce9470723f8c2ec97fe86073c)(expo@58.0.17)(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7))(@types/react@19.3.0)(react@19.3.0))
expo-font:
specifier: ~58.0.9
version: 58.0.9(expo@58.0.17)(react-native@0.88.0(@babel/core@7.29.7)(@react-native/metro-config@0.88.0(@babel/core@7.29.7))(@types/react@19.3.0)(react@19.3.0))(react@19.3.0)