199 lines
6.3 KiB
TypeScript
199 lines
6.3 KiB
TypeScript
import { useConvex, useQuery } from "convex/react"
|
|
import * as AppIntents from "expo-app-intents"
|
|
import type { AppIntentEntity } from "expo-app-intents"
|
|
import { useEffect, useRef } from "react"
|
|
import { AppState } from "react-native"
|
|
|
|
import { useCacheScope } from "@/contexts/persistent-cache"
|
|
import {
|
|
loadCatalogCursors,
|
|
saveCatalogCursors,
|
|
type CatalogCursors,
|
|
} from "@/lib/app-intent-handled"
|
|
import {
|
|
publishMusicCatalog,
|
|
readMusicCatalog,
|
|
trackMusicCatalogSync,
|
|
} from "@/lib/app-intents"
|
|
import { api } from "@otunes/convex/_generated/api"
|
|
import type { FunctionReturnType } from "convex/server"
|
|
|
|
const LIBRARY_KINDS = ["artist", "album", "song"] as const
|
|
type LibraryKind = (typeof LIBRARY_KINDS)[number]
|
|
const PAGE_SIZE = 500
|
|
type CatalogPage = FunctionReturnType<typeof api.intentCatalog.page>
|
|
|
|
type Favorites = {
|
|
favoriteSongs: string[]
|
|
favoriteAlbums: string[]
|
|
favoriteArtists: string[]
|
|
}
|
|
|
|
function favoriteIds(favorites: Favorites, kind: LibraryKind) {
|
|
return new Set<string>(
|
|
kind === "song"
|
|
? favorites.favoriteSongs
|
|
: kind === "album"
|
|
? favorites.favoriteAlbums
|
|
: favorites.favoriteArtists
|
|
)
|
|
}
|
|
|
|
/** Stamps `metadata.favorite`, which Siri uses to rank suggestions. */
|
|
function withFavorite(entity: AppIntentEntity, favorite: boolean) {
|
|
const flag = favorite ? "1" : "0"
|
|
return entity.metadata?.favorite === flag
|
|
? entity
|
|
: { ...entity, metadata: { ...entity.metadata, favorite: flag } }
|
|
}
|
|
|
|
/**
|
|
* Keeps the on-device Siri catalog in step with the server. `intentCatalog.head`
|
|
* is a live subscription, so the library is fetched only when it changes, and
|
|
* then only the records changed since the stored cursor. Favorites are applied
|
|
* locally from the existing favorites subscription.
|
|
*/
|
|
export function useMusicCatalogSync() {
|
|
const convex = useConvex()
|
|
const scope = useCacheScope()
|
|
const head = useQuery(api.intentCatalog.head)
|
|
const favorites = useQuery(api.favorites.getUserFavorites)
|
|
const playlists = useQuery(api.intentCatalog.playlists)
|
|
const latest = useRef({ head, favorites, playlists })
|
|
latest.current = { head, favorites, playlists }
|
|
const schedule = useRef<() => void>(() => undefined)
|
|
|
|
useEffect(() => {
|
|
if (!AppIntents.isAvailable()) return
|
|
let stopped = false
|
|
let running = false
|
|
let dirty = false
|
|
let cursors: CatalogCursors | null = null
|
|
// What the disk catalog reflects, to skip no-op republishes.
|
|
const appliedFavorites = new Map<LibraryKind, Set<string>>()
|
|
let publishedPlaylists: string | null = null
|
|
|
|
async function fetchChanges(kind: LibraryKind, since: number | undefined) {
|
|
const upserts: AppIntentEntity[] = []
|
|
let removed: string[] = []
|
|
let head = 0
|
|
let cursor: string | null = null
|
|
do {
|
|
const result: CatalogPage = await convex.query(api.intentCatalog.page, {
|
|
kind,
|
|
since,
|
|
paginationOpts: { cursor, numItems: PAGE_SIZE },
|
|
})
|
|
if (stopped) return null
|
|
if (cursor === null) {
|
|
if (result.reset) return fetchChanges(kind, undefined)
|
|
head = result.head ?? 0
|
|
removed = result.removed
|
|
}
|
|
upserts.push(...result.page)
|
|
cursor = result.isDone ? null : result.continueCursor
|
|
} while (cursor !== null)
|
|
return { upserts, removed, head, full: since === undefined }
|
|
}
|
|
|
|
async function syncKind(
|
|
kind: LibraryKind,
|
|
serverHead: number,
|
|
favorites: Favorites
|
|
) {
|
|
if (!cursors) return
|
|
const since = cursors[kind]
|
|
const stale = since === undefined || serverHead > since
|
|
const liked = favoriteIds(favorites, kind)
|
|
const previousLiked = appliedFavorites.get(kind)
|
|
const likesChanged =
|
|
!previousLiked ||
|
|
previousLiked.size !== liked.size ||
|
|
[...liked].some((id) => !previousLiked.has(id))
|
|
if (!stale && !likesChanged) return
|
|
|
|
const changes = stale ? await fetchChanges(kind, since) : null
|
|
if (stopped) return
|
|
const records = new Map<string, AppIntentEntity>()
|
|
if (!changes?.full) {
|
|
for (const entity of await readMusicCatalog(kind)) {
|
|
records.set(entity.id, entity)
|
|
}
|
|
}
|
|
for (const id of changes?.removed ?? []) records.delete(id)
|
|
for (const entity of changes?.upserts ?? [])
|
|
records.set(entity.id, entity)
|
|
|
|
let modified = changes !== null
|
|
for (const [id, entity] of records) {
|
|
const next = withFavorite(entity, liked.has(id))
|
|
if (next !== entity) {
|
|
records.set(id, next)
|
|
modified = true
|
|
}
|
|
}
|
|
if (stopped) return
|
|
if (modified) await publishMusicCatalog(kind, [...records.values()])
|
|
appliedFavorites.set(kind, liked)
|
|
if (changes && !stopped) {
|
|
cursors = { ...cursors, [kind]: changes.head }
|
|
await saveCatalogCursors(scope, cursors)
|
|
}
|
|
}
|
|
|
|
async function syncOnce() {
|
|
const { head, favorites, playlists } = latest.current
|
|
cursors ??= await loadCatalogCursors(scope)
|
|
if (head && favorites) {
|
|
for (const kind of LIBRARY_KINDS) {
|
|
if (stopped) return
|
|
await syncKind(kind, head[kind], favorites)
|
|
}
|
|
}
|
|
if (playlists && !stopped) {
|
|
const json = JSON.stringify(playlists)
|
|
if (json !== publishedPlaylists) {
|
|
await publishMusicCatalog("playlist", playlists)
|
|
publishedPlaylists = json
|
|
}
|
|
}
|
|
}
|
|
|
|
schedule.current = () => {
|
|
if (stopped) return
|
|
if (running) {
|
|
dirty = true
|
|
return
|
|
}
|
|
running = true
|
|
const sync = (async () => {
|
|
do {
|
|
dirty = false
|
|
await syncOnce()
|
|
} while (dirty && !stopped)
|
|
})()
|
|
.catch((error) =>
|
|
console.warn("Could not publish music catalog.", error)
|
|
)
|
|
.finally(() => {
|
|
running = false
|
|
})
|
|
trackMusicCatalogSync(sync)
|
|
}
|
|
schedule.current()
|
|
// Retries a failed sync; a no-op without server queries when current.
|
|
const subscription = AppState.addEventListener("change", (state) => {
|
|
if (state === "active") schedule.current()
|
|
})
|
|
return () => {
|
|
stopped = true
|
|
schedule.current = () => undefined
|
|
subscription.remove()
|
|
}
|
|
}, [convex, scope])
|
|
|
|
useEffect(() => {
|
|
schedule.current()
|
|
}, [head, favorites, playlists])
|
|
}
|