From 99d45a9e55d533ef992564d56e37e02cdd1c2095 Mon Sep 17 00:00:00 2001 From: vicrodh <103399283+vicrodh@users.noreply.github.com> Date: Tue, 19 May 2026 11:34:32 -0600 Subject: [PATCH] feat(slint): search controller with load/map/apply stages search.rs follows the album.rs three-stage pattern: load_search fetches a combined search via QbzCore on a worker thread, the map_* layer turns domain types into plain Send rows, and apply_search writes SearchState on the event loop. The map_* functions are unit-tested. Wired into navigation in the next task. cc --- crates/qbz-slint/src/main.rs | 1 + crates/qbz-slint/src/search.rs | 401 +++++++++++++++++++++++++++++++++ 2 files changed, 402 insertions(+) create mode 100644 crates/qbz-slint/src/search.rs diff --git a/crates/qbz-slint/src/main.rs b/crates/qbz-slint/src/main.rs index 8cfcef54c..7477b7429 100644 --- a/crates/qbz-slint/src/main.rs +++ b/crates/qbz-slint/src/main.rs @@ -25,6 +25,7 @@ mod nav; mod playback; mod queue; mod recently; +mod search; mod settings; mod ui_prefs; diff --git a/crates/qbz-slint/src/search.rs b/crates/qbz-slint/src/search.rs new file mode 100644 index 000000000..1c9ca5292 --- /dev/null +++ b/crates/qbz-slint/src/search.rs @@ -0,0 +1,401 @@ +//! Search results controller. +//! +//! Three stages, mirroring `album.rs`: `load_search` fetches a combined +//! search through `QbzCore` on a worker thread, `map_*` turns the domain +//! types into plain `Send` rows (the unit-tested layer), and +//! `apply_search` writes the `SearchState` global on the Slint event loop. + +use std::sync::Arc; + +use qbz_app::shell::AppRuntime; +use qbz_core::FrontendAdapter; +use qbz_models::{Album, Artist, MostPopularItem, Playlist, SearchAllResults, Track}; +use slint::{ComponentHandle, ModelRc, VecModel}; + +use crate::{AlbumCardItem, AppWindow, SearchPlaylistItem, SearchState, SearchTrackItem, SlimItem}; + +// ==================== Plain (Send) row types ==================== + +/// An album result row, before it becomes a Slint `AlbumCardItem`. +#[derive(Debug, Clone, PartialEq)] +pub struct AlbumRow { + pub id: String, + pub title: String, + pub artist: String, + pub genre: String, + pub year: String, + pub quality_tier: String, + pub quality_label: String, + pub artwork_url: String, +} + +/// A track result row, before it becomes a Slint `SearchTrackItem`. +#[derive(Debug, Clone, PartialEq)] +pub struct TrackRow { + pub id: String, + pub title: String, + pub artist: String, + pub duration: String, + pub quality_tier: String, + pub explicit: bool, + pub artwork_url: String, +} + +/// An artist result row, before it becomes a Slint `SlimItem`. +#[derive(Debug, Clone, PartialEq)] +pub struct ArtistRow { + pub id: String, + pub name: String, + pub subtitle: String, + pub artwork_url: String, +} + +/// A playlist result row, before it becomes a Slint `SearchPlaylistItem`. +#[derive(Debug, Clone, PartialEq)] +pub struct PlaylistRow { + pub id: String, + pub title: String, + pub subtitle: String, + pub artwork_url: String, +} + +/// The most-popular hero entry. +#[derive(Debug, Clone, PartialEq)] +pub enum MostPopularRow { + None, + Album(AlbumRow), + Artist(ArtistRow), + Track(TrackRow), +} + +/// The full result of a combined search, as plain `Send` data. +pub struct SearchData { + pub query: String, + pub albums: Vec, + pub tracks: Vec, + pub artists: Vec, + pub playlists: Vec, + pub albums_total: u32, + pub tracks_total: u32, + pub artists_total: u32, + pub playlists_total: u32, + pub most_popular: MostPopularRow, +} + +// ==================== Pure helpers ==================== + +/// 24-bit and up is Hi-Res, anything else with depth info is CD-quality. +fn tier(bit_depth: Option) -> &'static str { + match bit_depth { + Some(depth) if depth >= 24 => "hires", + Some(_) => "cd", + None => "", + } +} + +/// Quality-badge tooltip, e.g. "Hi-Res 24-bit / 96 kHz". Empty when no +/// quality info is available. +fn quality_label(bit_depth: Option, sample_rate: Option) -> String { + match bit_depth { + None => String::new(), + Some(depth) => { + let prefix = if depth >= 24 { "Hi-Res" } else { "CD" }; + let rate = sample_rate.unwrap_or(if depth >= 24 { 96.0 } else { 44.1 }); + let rate = if rate.fract().abs() < f64::EPSILON { + format!("{}", rate as i64) + } else { + format!("{rate}") + }; + format!("{prefix} {depth}-bit / {rate} kHz") + } + } +} + +/// `m:ss` track duration. +fn mmss(secs: u32) -> String { + format!("{}:{:02}", secs / 60, secs % 60) +} + +/// First four characters of an ISO date, or empty. +fn year_of(date: Option<&str>) -> String { + date.and_then(|d| d.get(0..4)).unwrap_or("").to_string() +} + +// ==================== Mappers (unit-tested) ==================== + +pub fn map_album(album: Album) -> AlbumRow { + AlbumRow { + id: album.id, + title: album.title, + artist: album.artist.name, + genre: album + .genre + .map(|g| g.name) + .filter(|n| !n.is_empty()) + .unwrap_or_default(), + year: year_of(album.release_date_original.as_deref()), + quality_tier: tier(album.maximum_bit_depth).to_string(), + quality_label: quality_label(album.maximum_bit_depth, album.maximum_sampling_rate), + artwork_url: album.image.best().cloned().unwrap_or_default(), + } +} + +pub fn map_track(track: Track) -> TrackRow { + let mut title = track.title; + if let Some(version) = track.version.as_ref().filter(|v| !v.is_empty()) { + title = format!("{title} ({version})"); + } + let artwork_url = track + .album + .as_ref() + .and_then(|a| a.image.best().cloned()) + .unwrap_or_default(); + TrackRow { + id: track.id.to_string(), + title, + artist: track.performer.map(|p| p.name).unwrap_or_default(), + duration: mmss(track.duration), + quality_tier: tier(track.maximum_bit_depth).to_string(), + explicit: track.parental_warning, + artwork_url, + } +} + +pub fn map_artist(artist: &Artist) -> ArtistRow { + ArtistRow { + id: artist.id.to_string(), + name: artist.name.clone(), + subtitle: match artist.albums_count { + Some(n) if n > 0 => format!("{n} albums"), + _ => String::new(), + }, + artwork_url: artist + .image + .as_ref() + .and_then(|i| i.best().cloned()) + .unwrap_or_default(), + } +} + +pub fn map_playlist(playlist: Playlist) -> PlaylistRow { + let artwork_url = playlist + .images150 + .as_ref() + .or(playlist.images.as_ref()) + .or(playlist.images300.as_ref()) + .and_then(|imgs| imgs.first().cloned()) + .unwrap_or_default(); + let mut subtitle = playlist.owner.name.clone(); + if playlist.tracks_count > 0 { + if subtitle.is_empty() { + subtitle = format!("{} tracks", playlist.tracks_count); + } else { + subtitle = format!("{} • {} tracks", subtitle, playlist.tracks_count); + } + } + PlaylistRow { + id: playlist.id.to_string(), + title: playlist.name, + subtitle, + artwork_url, + } +} + +fn map_most_popular(item: Option) -> MostPopularRow { + match item { + Some(MostPopularItem::Albums(a)) => MostPopularRow::Album(map_album(a)), + Some(MostPopularItem::Artists(a)) => MostPopularRow::Artist(map_artist(&a)), + Some(MostPopularItem::Tracks(t)) => MostPopularRow::Track(map_track(t)), + None => MostPopularRow::None, + } +} + +/// Map a combined-search result into plain `Send` data. +pub fn map_search_all(query: &str, results: SearchAllResults) -> SearchData { + SearchData { + query: query.to_string(), + albums_total: results.albums.total, + tracks_total: results.tracks.total, + artists_total: results.artists.total, + playlists_total: results.playlists.total, + albums: results.albums.items.into_iter().map(map_album).collect(), + tracks: results.tracks.items.into_iter().map(map_track).collect(), + artists: results.artists.items.iter().map(map_artist).collect(), + playlists: results.playlists.items.into_iter().map(map_playlist).collect(), + most_popular: map_most_popular(results.most_popular), + } +} + +// ==================== Load (async, worker thread) ==================== + +/// Run a combined search and map it to plain `Send` data. +pub async fn load_search( + runtime: &Arc>, + query: &str, +) -> Result +where + A: FrontendAdapter + Send + Sync + 'static, +{ + // Plan A passes an empty blacklist; the blacklist module is migrated + // separately (roadmap task #9). + let blacklist: std::collections::HashSet = std::collections::HashSet::new(); + let results = runtime + .core() + .search_all(query, &blacklist) + .await + .map_err(|e| e.to_string())?; + Ok(map_search_all(query, results)) +} + +// ==================== Apply (Slint event loop) ==================== + +fn album_item(row: AlbumRow) -> AlbumCardItem { + AlbumCardItem { + id: row.id.into(), + title: row.title.into(), + artist: row.artist.into(), + genre: row.genre.into(), + year: row.year.into(), + quality_tier: row.quality_tier.into(), + quality_label: row.quality_label.into(), + ribbon: Default::default(), + ribbon_kind: Default::default(), + artwork_url: row.artwork_url.into(), + artwork: slint::Image::default(), + } +} + +fn track_item(row: TrackRow) -> SearchTrackItem { + SearchTrackItem { + id: row.id.into(), + title: row.title.into(), + artist: row.artist.into(), + duration: row.duration.into(), + quality_tier: row.quality_tier.into(), + explicit: row.explicit, + artwork_url: row.artwork_url.into(), + artwork: slint::Image::default(), + } +} + +fn artist_item(row: ArtistRow) -> SlimItem { + SlimItem { + id: row.id.into(), + title: row.name.into(), + subtitle: row.subtitle.into(), + rank: Default::default(), + artwork_url: row.artwork_url.into(), + artwork: slint::Image::default(), + } +} + +fn playlist_item(row: PlaylistRow) -> SearchPlaylistItem { + SearchPlaylistItem { + id: row.id.into(), + title: row.title.into(), + subtitle: row.subtitle.into(), + artwork_url: row.artwork_url.into(), + artwork: slint::Image::default(), + } +} + +/// Apply search results to the `SearchState` global. Runs on the Slint +/// event loop. +pub fn apply_search(window: &AppWindow, data: SearchData) { + let state = window.global::(); + state.set_query(data.query.into()); + + let albums: Vec = data.albums.into_iter().map(album_item).collect(); + let tracks: Vec = data.tracks.into_iter().map(track_item).collect(); + let artists: Vec = data.artists.into_iter().map(artist_item).collect(); + let playlists: Vec = + data.playlists.into_iter().map(playlist_item).collect(); + + state.set_albums(ModelRc::new(VecModel::from(albums))); + state.set_tracks(ModelRc::new(VecModel::from(tracks))); + state.set_artists(ModelRc::new(VecModel::from(artists))); + state.set_playlists(ModelRc::new(VecModel::from(playlists))); + + state.set_albums_total(data.albums_total as i32); + state.set_tracks_total(data.tracks_total as i32); + state.set_artists_total(data.artists_total as i32); + state.set_playlists_total(data.playlists_total as i32); + + match data.most_popular { + MostPopularRow::Album(row) => { + state.set_most_popular_kind("album".into()); + state.set_most_popular_album(album_item(row)); + } + MostPopularRow::Artist(row) => { + state.set_most_popular_kind("artist".into()); + state.set_most_popular_artist(artist_item(row)); + } + MostPopularRow::Track(row) => { + state.set_most_popular_kind("track".into()); + state.set_most_popular_track(track_item(row)); + } + MostPopularRow::None => { + state.set_most_popular_kind("".into()); + } + } +} + +/// Clear search state and show the loading state (used when starting a new +/// search so the previous results do not flash). +pub fn reset_search(window: &AppWindow) { + let state = window.global::(); + state.set_albums(ModelRc::new(VecModel::from(Vec::::new()))); + state.set_tracks(ModelRc::new(VecModel::from(Vec::::new()))); + state.set_artists(ModelRc::new(VecModel::from(Vec::::new()))); + state.set_playlists(ModelRc::new(VecModel::from(Vec::::new()))); + state.set_albums_total(0); + state.set_tracks_total(0); + state.set_artists_total(0); + state.set_playlists_total(0); + state.set_most_popular_kind("".into()); + state.set_loading(true); +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn mmss_pads_seconds() { + assert_eq!(mmss(5), "0:05"); + assert_eq!(mmss(65), "1:05"); + assert_eq!(mmss(225), "3:45"); + } + + #[test] + fn tier_classifies_bit_depth() { + assert_eq!(tier(Some(24)), "hires"); + assert_eq!(tier(Some(16)), "cd"); + assert_eq!(tier(None), ""); + } + + #[test] + fn quality_label_formats_known_quality() { + assert_eq!(quality_label(Some(24), Some(96.0)), "Hi-Res 24-bit / 96 kHz"); + assert_eq!(quality_label(Some(16), Some(44.1)), "CD 16-bit / 44.1 kHz"); + assert_eq!(quality_label(None, None), ""); + } + + #[test] + fn map_artist_builds_album_count_subtitle() { + let artist = Artist { + id: 7, + name: "Metallica".into(), + image: None, + albums_count: Some(12), + biography: None, + albums: None, + tracks_appears_on: None, + playlists: None, + }; + let row = map_artist(&artist); + assert_eq!(row.id, "7"); + assert_eq!(row.name, "Metallica"); + assert_eq!(row.subtitle, "12 albums"); + } +}