Files
qbz/crates/qbz-slint/src/album_map.rs
T
vicrodh 201082d4a1 feat(locallibrary): complete Albums 1:1 + dedicated local album view with versions
Albums tab — full 1:1 with Tauri in one pass:
- Switch from the chunked-paginated grid to a full-load + in-memory derive so
  grouping/filtering span the whole set. derive_albums = search + sort + group
  (off / by letter with A-Z jump / by artist, both with section headers) + the
  quality/format/source filter (1:1 with matchesQualityFilters: OR within a
  group, AND between groups; empty group passes).
- Grid/list view toggle; the list view shows a SOURCE column (Local/Offline/
  Plex), placed after TYPE. Filter popup now FLOATS (sibling of the content
  layout, not a layout slot) with an active-count badge. Fixed the year sort
  (sort_album_items maps year-asc/desc — was also silently broken in Folders).
- Album covers dual-set by id across the full set + visible + grouped sections.

Dedicated local album view — SEPARATE from the Qobuz AlbumView:
- New ContentView::local-album + NavEntry::LocalAlbum + ui/album/LocalAlbumView.slint,
  reusing TrackRow/NavButtons/CircleAction/QualityBadge internals but ONLY local
  actions (play all / shuffle / edit tags / add to playlist) — no Qobuz chrome.
- Versions: an album's tracks are split by source directory into versions, so
  multiple copies of the same album no longer merge into a duplicated track
  list. Best-quality version is the default; a source-icon version picker
  (hard-drive / Qobuz / Plex glyph in both the selected display and the options)
  switches the shown copy in place. The album cover is the best-quality version
  that has one, falling through versions, else a placeholder (covers backfilled
  from disk via fill_missing_covers). Header padding-top 11px matches the app.

Fix: Artists tab deadlock — fetch_missing_artist_images snapshotted names with a
blocking rx.recv() called from inside an event-loop closure, freezing the UI
(static spinner, no error). Names are now snapshotted on the UI thread and
passed in; the worker never blocks the event loop.

cc
2026-05-29 19:16:09 -06:00

228 lines
8.5 KiB
Rust

//! Shared album → card mapping for every Qobuz album surface (label
//! releases, favorites albums, and any toolbar-driven album list).
//!
//! Owns the V2-nested-first-with-flat-fallback decode so the list-row
//! extras (TYPE / QUALITY / TRACKS / YEAR columns of `AlbumListRow`)
//! populate consistently, the quality-tier classification, and the
//! local sort used by the grid/list toolbar views. Both `label.rs` and
//! `favorites.rs` map through here so there is one implementation to
//! maintain.
use qbz_models::Album;
use crate::AlbumCardItem;
/// Plain album card — every field an `AlbumCard`/`AlbumListRow` can show.
#[derive(Clone)]
pub struct AlbumCard {
pub id: String,
pub title: String,
pub artist: String,
pub artist_id: String,
pub genre: String,
pub year: String,
pub quality_tier: String,
pub quality_label: String,
pub artwork_url: String,
// List-row extras (AlbumListRow columns; ignored by the grid card).
pub release_type: String, // "Album" | "EP" | "Single" (TYPE column)
// "local" | "qobuz_download" | "plex" | "" — SOURCE column + the
// always-visible source badge on the Local Library grid card.
pub source: String,
pub quality_detail: String, // "24-bit / 96 kHz"
pub track_count: String, // "12"
pub plain_year: String, // "1973"
}
/// Map a decoded Qobuz album into an `AlbumCard`.
///
/// Prefers the V2 nested shape (`audio_info` / `dates` / `track_count` /
/// `artists[]`) returned by `/label/getAlbums` and the discover feeds,
/// falling back to the flat fields used by the favorites (`legacy`)
/// payload. The fallbacks resolve to the flat values when the nested
/// fields are absent, so favorites albums map losslessly too.
pub fn map_album(album: Album) -> AlbumCard {
let bit_depth = album
.audio_info
.as_ref()
.and_then(|a| a.maximum_bit_depth)
.or(album.maximum_bit_depth);
let sample_rate = album
.audio_info
.as_ref()
.and_then(|a| a.maximum_sampling_rate)
.or(album.maximum_sampling_rate);
let quality_tier = tier_hires(bit_depth, album.hires || album.hires_streamable).to_string();
let quality_label = match (bit_depth, sample_rate) {
(Some(bd), Some(sr)) => format!("{}-bit / {} kHz", bd, sr),
_ => String::new(),
};
let quality_detail = quality_label.clone();
// Release date — nested `dates` first (original > download > stream),
// else the flat `release_date_original`.
let date = album
.dates
.as_ref()
.and_then(|d| {
d.original
.clone()
.or_else(|| d.download.clone())
.or_else(|| d.stream.clone())
})
.or_else(|| album.release_date_original.clone());
let year = crate::dates::release_label(date.as_deref());
let plain_year = date
.as_deref()
.and_then(|s| s.get(..4).map(|y| y.to_string()))
.unwrap_or_default();
let tc = album.track_count.or(album.tracks_count);
let track_count = tc
.filter(|n| *n > 0)
.map(|n| n.to_string())
.unwrap_or_default();
let release_type = release_type_label(album.release_type.as_deref(), tc);
// Borrow `album` (artist) before any owned field is moved out below.
let (artist, artist_id) = album_artist(&album);
let genre = album.genre.map(|g| g.name).unwrap_or_default();
AlbumCard {
id: album.id,
title: album.title,
artist,
artist_id,
genre,
year,
quality_tier,
quality_label,
artwork_url: album.image.best().cloned().unwrap_or_default(),
release_type,
// Qobuz album surfaces (Discover / Favorites / Label) hide the SOURCE
// column and the badge, so leave it empty (preserves prior behavior).
source: String::new(),
quality_detail,
track_count,
plain_year,
}
}
/// Quality tier from a bit depth alone — `hires` above 16-bit, else `cd`.
pub fn tier(bit_depth: Option<u32>) -> &'static str {
match bit_depth {
Some(b) if b > 16 => "hires",
Some(_) => "cd",
None => "",
}
}
/// Quality tier from a resolved bit depth, with a `hires` boolean fallback
/// for payloads that omit the bit depth but still flag the release hi-res.
pub fn tier_hires(bit_depth: Option<u32>, hires: bool) -> &'static str {
match bit_depth {
Some(b) if b > 16 => "hires",
Some(_) => "cd",
None if hires => "hires",
None => "",
}
}
/// Display label for the TYPE column — the explicit `release_type` when the
/// payload provides a known one, else a track-count heuristic.
fn release_type_label(release_type: Option<&str>, track_count: Option<u32>) -> String {
match release_type {
Some("album") | Some("download") => "Album".to_string(),
Some("ep") | Some("epSingle") => "EP".to_string(),
Some("single") => "Single".to_string(),
Some("live") => "Live".to_string(),
Some("compilation") => "Compilation".to_string(),
_ => classify_release_type(track_count).to_string(),
}
}
/// Album artist name + id. Many /label/getAlbums items leave the `artist`
/// object empty and only populate the `artists` credit array, which left
/// group-by-artist showing "Unknown Artist". Fall back to the main-artist
/// credit (else the first) — mirrors artist.rs map_release.
fn album_artist(album: &Album) -> (String, String) {
if !album.artist.name.is_empty() {
return (album.artist.name.clone(), album.artist.id.to_string());
}
if let Some(list) = album.artists.as_ref() {
let pick = list
.iter()
.find(|a| {
a.roles
.as_ref()
.map(|r| r.iter().any(|role| role == "main-artist"))
.unwrap_or(false)
})
.or_else(|| list.first());
if let Some(a) = pick {
return (a.name.clone(), a.id.to_string());
}
}
(String::new(), String::new())
}
/// Classify the list-row TYPE column from the album's track count, for
/// payloads (favorites, /label/getAlbums) that carry no explicit
/// release_type. Mirrors home.rs's Discover heuristic
/// (<=3 = Single, <=6 = EP, else Album).
pub fn classify_release_type(track_count: Option<u32>) -> &'static str {
match track_count {
Some(n) if n <= 3 => "Single",
Some(n) if n <= 6 => "EP",
_ => "Album",
}
}
/// Build a Slint `AlbumCardItem` from an `AlbumCard`. SOURCE is left empty
/// (single-source Qobuz context — hide the column with `show-source: false`).
pub fn to_item(card: AlbumCard) -> AlbumCardItem {
AlbumCardItem {
id: card.id.into(),
title: card.title.into(),
artist: card.artist.into(),
artist_id: card.artist_id.into(),
genre: card.genre.into(),
year: card.year.into(),
quality_tier: card.quality_tier.into(),
quality_label: card.quality_label.into(),
ribbon: "".into(),
ribbon_kind: "".into(),
artwork_url: card.artwork_url.into(),
artwork: slint::Image::default(),
// List-row extras — feed the AlbumListRow columns (TYPE / QUALITY /
// TRACKS / YEAR) for the list view toggle.
release_type: card.release_type.into(),
source: card.source.into(),
quality_detail: card.quality_detail.into(),
track_count: card.track_count.into(),
plain_year: card.plain_year.into(),
..Default::default()
}
}
/// Local sort over already-mapped card items, by the toolbar's sort key.
/// `newest`/`oldest` sort on `plain_year`; `title-*`/`artist-*` are
/// case-insensitive; any other key (e.g. `default`) leaves order intact.
pub fn sort_album_items(items: &mut [AlbumCardItem], sort: &str) {
match sort {
"oldest" | "year-asc" => {
items.sort_by(|a, b| a.plain_year.as_str().cmp(b.plain_year.as_str()))
}
"newest" | "year-desc" => {
items.sort_by(|a, b| b.plain_year.as_str().cmp(a.plain_year.as_str()))
}
"title-asc" => items.sort_by(|a, b| a.title.to_lowercase().cmp(&b.title.to_lowercase())),
"title-desc" => items.sort_by(|a, b| b.title.to_lowercase().cmp(&a.title.to_lowercase())),
"artist-asc" => {
items.sort_by(|a, b| a.artist.to_lowercase().cmp(&b.artist.to_lowercase()))
}
"artist-desc" => {
items.sort_by(|a, b| b.artist.to_lowercase().cmp(&a.artist.to_lowercase()))
}
_ => {}
}
}