Files
qbz/crates/qbz-slint/src/sidebar.rs
T
vicrodh 81587f4d17 feat(slint): playlist snapshot (names+membership) and offline favorites rail
Qobuz playlist snapshot, captured opportunistically with zero new API
traffic: every online sidebar/manager list load upserts id+name+owner+
track_count for the user's playlists; opening a playlist detail online
full-replaces its membership track ids (refusing playlists never listed,
so viewed public playlists don't land). Offline consumers: synthesized
sidebar/manager entries resolve the persisted name (killing the cold-start
'Playlist (N local)' fallback when a snapshot exists), and the mixed-
playlist offline detail now renders the snapshot tracks that are playable
(snapshot intersect cached intersect grace) from the offline-cache index -
snapshot block first in snapshot order, sidecar local/plex block after.
D11 availability widens: a playlist with zero sidecar rows but cached
snapshot tracks now shows offline. 4 repo tests.

Offline favorites rail: the Favorites placeholder gains an 'Available
offline (N)' block - disk-cached favorite ids intersected with the
offline-cache READY index and LocalLibrary qobuz_download copies, compact
rows with the offline cover chain, click plays the rail as a queue through
the cache tier. Shared OfflinePlaceholder gains an @children slot; only
the Favorites mount injects the rail.

Single commit: the two features interleave in main.rs/state wiring and
ship together to keep every commit compiling.

cc
2026-06-10 02:27:54 -06:00

632 lines
25 KiB
Rust

//! Sidebar playlists + folders controller. Builds the flattened
//! left-nav list (folder headers with their playlists + root
//! playlists) from the user's Qobuz playlists and the local folder
//! organization (library.db). The loaded data is cached so expand /
//! move operations rebuild the list without re-hitting the network.
use std::collections::{HashMap, HashSet};
use std::sync::{LazyLock, Mutex};
use qbz_app::shell::AppRuntime;
use qbz_core::FrontendAdapter;
use slint::{ComponentHandle, ModelRc, VecModel};
use crate::folders::FolderInfo;
use crate::{AppWindow, SidebarEntry, SidebarFolderPopupState, SidebarPlaylistItem, SidebarState};
#[derive(Clone)]
pub struct SidebarPlaylist {
pub id: u64,
pub name: String,
/// Playlist description (Qobuz). Empty when none. Used to prefill the
/// edit-playlist modal opened from the sidebar context menu.
pub description: String,
/// Total track count (Qobuz). Used by the "# of tracks" sort.
pub tracks_count: u32,
/// Up to four cover-art URLs for the micro-collage, sourced from the
/// `get_user_playlists()` payload (images300 / images150 / images).
/// No extra fetch — same as Tauri's `images150 ?? images300 ?? images`.
pub cover_urls: Vec<String>,
/// Custom-sort position (from `playlist_settings.position`); the
/// `Custom` sort orders by this ascending.
pub position: i32,
}
/// Pick up to four de-duplicated cover URLs for a playlist, preferring the
/// largest available list (mirrors Tauri's `images150 ?? images300 ??
/// images`, but de-duplicated and capped at four for the 2x2 collage).
fn playlist_cover_urls(p: &qbz_models::Playlist) -> Vec<String> {
let source = [&p.images300, &p.images150, &p.images]
.into_iter()
.flatten()
.find(|v| !v.is_empty());
let mut out: Vec<String> = Vec::new();
if let Some(list) = source {
for url in list {
if !url.is_empty() && !out.contains(url) {
out.push(url.clone());
}
if out.len() == 4 {
break;
}
}
}
out
}
/// One LOCAL playlist (library.db entity, id `local:<uuid>`) listed
/// alongside the Qobuz playlists. Always available — including offline.
#[derive(Clone)]
pub struct LocalSidebarPlaylist {
pub id: String,
pub name: String,
pub description: String,
pub offline_only: bool,
}
#[derive(Clone, Default)]
pub struct SidebarData {
pub playlists: Vec<SidebarPlaylist>,
pub folders: Vec<FolderInfo>,
pub folder_map: HashMap<u64, String>,
/// Playlist ids the user has hidden from the sidebar (local settings).
pub hidden_playlists: HashSet<u64>,
/// First-class local playlists (offline-mode D7), appended as root rows.
pub local_playlists: Vec<LocalSidebarPlaylist>,
/// Qobuz playlist id -> local sidecar track count (library.db
/// `playlist_local_tracks`). The D11.b offline filter keeps only the
/// MIXED playlists (count > 0); unused while online.
pub local_counts: HashMap<u64, u32>,
/// B8: Qobuz playlists whose local SNAPSHOT membership has >= 1 track
/// playable offline (snapshot ∩ cached, grace-gated). Extends the
/// D11.b offline filter; empty while online.
pub snapshot_available: HashSet<u64>,
}
/// Session-only folder expand state (matches Tauri — not persisted).
static EXPANDED: LazyLock<Mutex<HashSet<String>>> = LazyLock::new(|| Mutex::new(HashSet::new()));
/// Last loaded data, so expand/move rebuild without a refetch.
static CACHE: LazyLock<Mutex<SidebarData>> = LazyLock::new(|| Mutex::new(SidebarData::default()));
/// Active sort option, mirrored from `SidebarState.sort-option`. Session
/// scope (Tauri persists in localStorage; we have no equivalent store
/// here yet, so this matches the in-session behavior).
static SORT: LazyLock<Mutex<String>> = LazyLock::new(|| Mutex::new("name".to_string()));
/// Active playlist-name search query (lowercased), mirrored from
/// `SidebarState.search-query`. Filters the rebuilt list recursively.
static SEARCH: LazyLock<Mutex<String>> = LazyLock::new(|| Mutex::new(String::new()));
/// playlist id -> (name, description) from the last loaded payload, so the
/// sidebar context menu can prefill the edit-playlist modal without a
/// refetch.
static NAME_DESC: LazyLock<Mutex<HashMap<u64, (String, String)>>> =
LazyLock::new(|| Mutex::new(HashMap::new()));
pub fn set_loading(window: &AppWindow, loading: bool) {
window.global::<SidebarState>().set_loading(loading);
}
/// Update the active sort option and re-render (matches Tauri's five
/// options). Unknown values fall back to "name".
pub fn set_sort(window: &AppWindow, option: &str) {
let opt = match option {
"name" | "recent" | "tracks" | "playcount" | "custom" => option,
_ => "name",
};
if let Ok(mut s) = SORT.lock() {
*s = opt.to_string();
}
window.global::<SidebarState>().set_sort_option(opt.into());
rebuild(window);
}
/// Update the playlist-name search filter and re-render. An empty query
/// shows everything.
pub fn set_search(window: &AppWindow, query: &str) {
if let Ok(mut q) = SEARCH.lock() {
*q = query.trim().to_lowercase();
}
rebuild(window);
}
/// Order playlists by the active sort option, mirroring Tauri's
/// comparators. `recent` keeps reverse insertion order (most-recently
/// added first); `playcount` has no per-playlist count source here, so it
/// stays stable like Tauri does when `play_count` is absent (0).
fn sort_playlists(playlists: &[SidebarPlaylist]) -> Vec<SidebarPlaylist> {
let sort = SORT.lock().map(|s| s.clone()).unwrap_or_else(|_| "name".into());
let mut out: Vec<SidebarPlaylist> = playlists.to_vec();
match sort.as_str() {
"name" => out.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase())),
"recent" => out.reverse(),
"tracks" => out.sort_by(|a, b| b.tracks_count.cmp(&a.tracks_count)),
"playcount" => { /* no play_count source — stable, like Tauri's absent field */ }
"custom" => out.sort_by(|a, b| a.position.cmp(&b.position)),
_ => out.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase())),
}
out
}
/// Fetch playlists (Qobuz) + folders + folder membership (local).
pub async fn load<A>(runtime: &AppRuntime<A>) -> SidebarData
where
A: FrontendAdapter + Send + Sync + 'static,
{
let playlists: Vec<SidebarPlaylist> = match runtime.core().get_user_playlists().await {
Ok(pls) => {
// B7 producer (names): persist id+name(+owner, track_count) for
// ALL listed playlists — data this load already fetched, written
// detached so the render never waits. Offline the fetch is
// gate-refused (Err), so the snapshot is never clobbered.
crate::playlist_snapshot::record_names_detached(
pls.iter()
.map(|p| crate::playlist_snapshot::SnapshotNameEntry {
qobuz_playlist_id: p.id,
name: p.name.clone(),
owner: Some(p.owner.name.clone()).filter(|o| !o.is_empty()),
track_count: Some(p.tracks_count),
})
.collect(),
);
pls.into_iter()
.map(|p| SidebarPlaylist {
id: p.id,
name: p.name.clone(),
description: p.description.clone().unwrap_or_default(),
tracks_count: p.tracks_count,
cover_urls: playlist_cover_urls(&p),
position: 0,
})
.collect()
}
Err(e) => {
log::warn!("[qbz-slint] sidebar playlists load failed: {e}");
Vec::new()
}
};
// Folders (hidden folders excluded) + folder membership +
// per-playlist custom-sort positions + hidden-playlist set + the
// first-class LOCAL playlists + the per-playlist local sidecar counts
// (all local, library.db) + OFFLINE only: the playlist-snapshot names
// and the snapshot-available set (B7/B8).
let (
folders,
folder_map,
positions,
hidden_playlists,
local_playlists,
local_counts,
snapshot_names,
snapshot_available,
) =
tokio::task::spawn_blocking(|| {
let folders: Vec<FolderInfo> = crate::folders::load_folders_full()
.into_iter()
.filter(|f| !f.is_hidden)
.map(|f| FolderInfo {
id: f.id,
name: f.name,
})
.collect();
let hidden_playlists: HashSet<u64> = crate::folders::playlist_settings_map()
.into_iter()
.filter(|(_, s)| s.hidden)
.map(|(id, _)| id)
.collect();
// Hidden locals drop from the sidebar (B3) the way hidden Qobuz
// playlists do — they stay reachable via the manager's "hidden"
// filter, which reads the repo list directly.
let local_playlists: Vec<LocalSidebarPlaylist> =
crate::local_playlist::list_blocking()
.into_iter()
.filter(|p| !p.hidden)
.map(|p| LocalSidebarPlaylist {
id: p.id,
name: p.name,
description: p.description.unwrap_or_default(),
offline_only: p.offline_only,
})
.collect();
// B7/B8 (offline only): the snapshot names replace the
// synthesized "Playlist (N local)" fallback, and the
// snapshot-available set extends the D11.b visibility filter.
let (snapshot_names, snapshot_available) =
if crate::offline_mode::engine().is_offline() {
(
crate::playlist_snapshot::headers_blocking(),
crate::playlist_snapshot::available_offline_blocking(),
)
} else {
(HashMap::new(), HashSet::new())
};
(
folders,
crate::folders::playlist_folder_map(),
crate::folders::playlist_positions(),
hidden_playlists,
local_playlists,
crate::folders::playlist_local_counts(),
snapshot_names,
snapshot_available,
)
})
.await
.unwrap_or_default();
let mut playlists = playlists;
// D11.b — OFFLINE: the Qobuz fetch above is gate-refused (empty), so the
// reachable playlists are synthesized locally: the MIXED ones (>= 1
// local sidecar row) plus — B8 — the snapshot-available ones (>= 1
// cached snapshot track). Names come from the previous load's session
// cache, else the persisted snapshot (B7 — survives a cold offline
// start), else the synthesized "Playlist (N local)" fallback.
if crate::offline_mode::engine().is_offline() {
let known: HashSet<u64> = playlists.iter().map(|p| p.id).collect();
let prior: HashMap<u64, (String, String)> =
NAME_DESC.lock().map(|nd| nd.clone()).unwrap_or_default();
let mut ids: Vec<u64> = local_counts
.iter()
.filter(|&(_, &count)| count > 0)
.map(|(&id, _)| id)
.collect();
for &id in &snapshot_available {
if !ids.contains(&id) {
ids.push(id);
}
}
for id in ids {
if known.contains(&id) {
continue;
}
let count = local_counts.get(&id).copied().unwrap_or(0);
let snapshot = snapshot_names.get(&id);
let (name, description) = prior
.get(&id)
.cloned()
.or_else(|| snapshot.map(|(name, _)| (name.clone(), String::new())))
.unwrap_or_else(|| (format!("Playlist ({count} local)"), String::new()));
// Track count: the snapshot's point-in-time Qobuz total when
// known (the "# of tracks" sort key), else the local count.
let tracks_count = snapshot.and_then(|(_, tc)| *tc).unwrap_or(count);
playlists.push(SidebarPlaylist {
id,
name,
description,
tracks_count,
cover_urls: Vec::new(),
position: 0,
});
}
}
for p in &mut playlists {
if let Some(pos) = positions.get(&p.id) {
p.position = *pos;
}
}
// Cache the loaded playlists' name+description for the sidebar
// context-menu edit modal (no extra fetch on right-click).
if let Ok(mut nd) = NAME_DESC.lock() {
nd.clear();
for p in &playlists {
nd.insert(p.id, (p.name.clone(), p.description.clone()));
}
}
SidebarData {
playlists,
folders,
folder_map,
hidden_playlists,
local_playlists,
local_counts,
snapshot_available,
}
}
/// Name + description + offline_only for a LOCAL playlist id, from the
/// last loaded sidebar cache (the local twin of `playlist_name_desc`).
pub fn local_playlist_meta(id: &str) -> Option<(String, String, bool)> {
CACHE.lock().ok().and_then(|c| {
c.local_playlists
.iter()
.find(|p| p.id == id)
.map(|p| (p.name.clone(), p.description.clone(), p.offline_only))
})
}
/// Name + description for `id`, from the last loaded playlist payload.
/// Used by the sidebar context menu to prefill the edit-playlist modal
/// without a refetch. Returns None when the playlist is unknown.
pub fn playlist_name_desc(id: u64) -> Option<(String, String)> {
NAME_DESC.lock().ok().and_then(|nd| nd.get(&id).cloned())
}
/// Total track count for `id`, from the last loaded playlist cache. Used by the
/// sidebar "Add to Mixtape/Collection" context action to populate the AddItem
/// `track_count` (the SidebarEntry struct doesn't carry it). Returns None when
/// the playlist is unknown.
pub fn playlist_track_count(id: u64) -> Option<u32> {
CACHE
.lock()
.ok()
.and_then(|c| c.playlists.iter().find(|p| p.id == id).map(|p| p.tracks_count))
}
/// Store the freshly-loaded data and render it.
pub fn apply(window: &AppWindow, data: SidebarData) {
if let Ok(mut cache) = CACHE.lock() {
*cache = data;
}
rebuild(window);
}
/// Build a playlist `SidebarEntry` (with its cover URLs for the
/// micro-collage). The decoded `cover*` images stay default here and are
/// filled asynchronously by the artwork pipeline (see `artwork_jobs`).
fn playlist_entry(p: &SidebarPlaylist, indent: bool, folder_id: &str) -> SidebarEntry {
let url = |i: usize| -> slint::SharedString {
p.cover_urls.get(i).cloned().unwrap_or_default().into()
};
SidebarEntry {
kind: "playlist".into(),
id: p.id.to_string().into(),
name: p.name.clone().into(),
expanded: false,
count: 0,
indent,
folder_id: folder_id.into(),
local_kind: "".into(),
cover_count: p.cover_urls.len().min(4) as i32,
url1: url(0),
url2: url(1),
url3: url(2),
url4: url(3),
cover1: slint::Image::default(),
cover2: slint::Image::default(),
cover3: slint::Image::default(),
cover4: slint::Image::default(),
}
}
/// Build a LOCAL playlist root row (hard-drive glyph; no cover collage).
fn local_playlist_entry(p: &LocalSidebarPlaylist) -> SidebarEntry {
SidebarEntry {
kind: "playlist".into(),
id: p.id.clone().into(),
name: p.name.clone().into(),
expanded: false,
count: 0,
indent: false,
folder_id: "".into(),
local_kind: if p.offline_only { "offline" } else { "local" }.into(),
cover_count: 0,
url1: Default::default(),
url2: Default::default(),
url3: Default::default(),
url4: Default::default(),
cover1: slint::Image::default(),
cover2: slint::Image::default(),
cover3: slint::Image::default(),
cover4: slint::Image::default(),
}
}
/// Populate the collapsed-sidebar folder flyout with `folder_id`'s playlists,
/// built from the cache so it works even for collapsed folders (whose
/// children are absent from the flattened `entries`).
pub fn load_folder_popup(window: &AppWindow, folder_id: &str) {
let data = CACHE.lock().map(|c| c.clone()).unwrap_or_default();
let offline = crate::offline_mode::engine().is_offline();
let sorted = sort_playlists(&data.playlists);
let entries: Vec<SidebarEntry> = sorted
.iter()
.filter(|p| {
data.folder_map
.get(&p.id)
.map(|f| f.as_str() == folder_id)
.unwrap_or(false)
})
.filter(|p| !data.hidden_playlists.contains(&p.id))
.filter(|p| offline_visible(&data, offline, p))
.map(|p| playlist_entry(p, true, folder_id))
.collect();
window
.global::<SidebarFolderPopupState>()
.set_playlists(ModelRc::new(VecModel::from(entries)));
}
/// D11.b visibility: ONLINE every playlist shows; OFFLINE the MIXED ones
/// (>= 1 local sidecar track) stay, plus — B8 — the snapshot-available ones
/// (>= 1 cached snapshot track). Everything else hides.
fn offline_visible(data: &SidebarData, offline: bool, p: &SidebarPlaylist) -> bool {
!offline
|| data.local_counts.get(&p.id).copied().unwrap_or(0) > 0
|| data.snapshot_available.contains(&p.id)
}
/// Rebuild the flattened entries (+ the folders list for the
/// move-to-folder menu) from the cache + expand state, applying the
/// active sort and the playlist-name search filter.
pub fn rebuild(window: &AppWindow) {
let data = CACHE.lock().map(|c| c.clone()).unwrap_or_default();
let expanded = EXPANDED.lock().map(|e| e.clone()).unwrap_or_default();
let query = SEARCH.lock().map(|q| q.clone()).unwrap_or_default();
let searching = !query.is_empty();
let offline = crate::offline_mode::engine().is_offline();
let folder_ids: HashSet<&String> = data.folders.iter().map(|f| &f.id).collect();
// Sort then filter by the playlist-name query (recursive — the same
// filter applies to playlists nested in folders).
let sorted = sort_playlists(&data.playlists);
let matches = |p: &SidebarPlaylist| !searching || p.name.to_lowercase().contains(&query);
let mut entries: Vec<SidebarEntry> = Vec::new();
for folder in &data.folders {
let members: Vec<&SidebarPlaylist> = sorted
.iter()
.filter(|p| data.folder_map.get(&p.id).map(|f| f == &folder.id).unwrap_or(false))
.filter(|p| matches(p))
.filter(|p| !data.hidden_playlists.contains(&p.id))
.filter(|p| offline_visible(&data, offline, p))
.collect();
// While searching, skip folders with no matching playlists
// (mirrors Tauri's `if (isSearching && folderPlaylists.length === 0) continue`).
// Offline the same rule hides folders whose members are all filtered
// out (D11.b) — an empty folder header carries no information there.
if (searching || offline) && members.is_empty() {
continue;
}
// When searching, force-expand so matches inside are visible.
let is_exp = searching || expanded.contains(&folder.id);
entries.push(SidebarEntry {
kind: "folder".into(),
id: folder.id.clone().into(),
name: folder.name.clone().into(),
expanded: is_exp,
count: members.len() as i32,
indent: false,
folder_id: "".into(),
local_kind: "".into(),
cover_count: 0,
url1: Default::default(),
url2: Default::default(),
url3: Default::default(),
url4: Default::default(),
cover1: slint::Image::default(),
cover2: slint::Image::default(),
cover3: slint::Image::default(),
cover4: slint::Image::default(),
});
if is_exp {
for p in members {
entries.push(playlist_entry(p, true, &folder.id));
}
}
}
// Root playlists — no folder, or a folder that no longer exists.
for p in &sorted {
let in_folder = data
.folder_map
.get(&p.id)
.map(|f| folder_ids.contains(f))
.unwrap_or(false);
if !in_folder
&& matches(p)
&& !data.hidden_playlists.contains(&p.id)
&& offline_visible(&data, offline, p)
{
entries.push(playlist_entry(p, false, ""));
}
}
// LOCAL playlists (library.db, D7) — root rows after the Qobuz set,
// name-sorted, honoring the same search filter. Always present, online
// or offline (they never depend on a Qobuz fetch).
{
let mut locals: Vec<&LocalSidebarPlaylist> = data
.local_playlists
.iter()
.filter(|p| !searching || p.name.to_lowercase().contains(&query))
.collect();
locals.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
for p in locals {
entries.push(local_playlist_entry(p));
}
}
let folders: Vec<SidebarPlaylistItem> = data
.folders
.iter()
.map(|f| SidebarPlaylistItem {
id: f.id.clone().into(),
name: f.name.clone().into(),
})
.collect();
let state = window.global::<SidebarState>();
state.set_entries(ModelRc::new(VecModel::from(entries)));
state.set_folders(ModelRc::new(VecModel::from(folders.clone())));
// The move-to-folder menu starts unfiltered (= the full folder set);
// the search box narrows it via `search_menu_folders`.
state.set_menu_folders(ModelRc::new(VecModel::from(folders)));
state.set_loading(false);
}
/// Filter the move-to-folder menu's folder list by a case-insensitive
/// substring of the search query (Slint strings have no `contains`, so
/// this lives in Rust). An empty query restores the full list.
pub fn search_menu_folders(window: &AppWindow, query: &str) {
let q = query.trim().to_lowercase();
let data = CACHE.lock().map(|c| c.clone()).unwrap_or_default();
let filtered: Vec<SidebarPlaylistItem> = data
.folders
.iter()
.filter(|f| q.is_empty() || f.name.to_lowercase().contains(&q))
.map(|f| SidebarPlaylistItem {
id: f.id.clone().into(),
name: f.name.clone().into(),
})
.collect();
window
.global::<SidebarState>()
.set_menu_folders(ModelRc::new(VecModel::from(filtered)));
}
/// Build artwork-download jobs for every playlist row's collage covers,
/// targeting `SidebarState.entries` by row index. Call after `apply` /
/// `rebuild` updates the entries.
pub fn artwork_jobs(window: &AppWindow) -> Vec<crate::artwork::ArtworkJob> {
use slint::Model;
let mut jobs = Vec::new();
let entries = window.global::<SidebarState>().get_entries();
for idx in 0..entries.row_count() {
let Some(e) = entries.row_data(idx) else { continue };
if e.kind != "playlist" {
continue;
}
let urls = [e.url1, e.url2, e.url3, e.url4];
for (slot, url) in urls.iter().enumerate() {
if !url.is_empty() {
jobs.push(crate::artwork::ArtworkJob {
target: crate::artwork::ArtworkTarget::SidebarPlaylistCover { idx, slot },
url: url.to_string(),
});
}
}
}
jobs
}
/// Toggle a folder's expanded state, then re-render from cache.
pub fn toggle_folder(window: &AppWindow, folder_id: &str) {
if let Ok(mut exp) = EXPANDED.lock() {
if !exp.remove(folder_id) {
exp.insert(folder_id.to_string());
}
}
rebuild(window);
}
/// Optimistically move a playlist in the cache (folder_id "" = root)
/// and re-render. The DB write happens separately.
pub fn move_playlist_local(window: &AppWindow, playlist_id: u64, folder_id: &str) {
if let Ok(mut cache) = CACHE.lock() {
if folder_id.is_empty() {
cache.folder_map.remove(&playlist_id);
} else {
cache.folder_map.insert(playlist_id, folder_id.to_string());
}
}
rebuild(window);
}
/// Highlight the open playlist in the sidebar (or clear with "").
pub fn set_active(window: &AppWindow, id: &str) {
window.global::<SidebarState>().set_active_id(id.into());
}
/// Whether `id` is one of the user's own playlists — used to gate
/// playlist editing.
pub fn contains(window: &AppWindow, id: &str) -> bool {
use slint::Model;
let entries = window.global::<SidebarState>().get_entries();
entries
.iter()
.any(|e| e.kind == "playlist" && e.id == id)
}