feat: cover art cache, Collection tabs, and album, artist and playlist pages

- ym-api: album/artist/playlist summaries and pages, liked albums and
  artists, own and liked playlists (batch-resolved from like ids),
  playlist tracks with missing ones looked up, image download
- Cover cache: fetched when a cover nears the viewport (sensor), at most
  eight at once, kept in memory and on disk; arrivals are batched every
  150 ms so cached lists rebuild once per batch
- Collection tabs for liked tracks, albums, artists and playlists, each
  loading on first visit with a retry on failure
- Album, Artist and Playlist routes with cover headers, Play/Shuffle and
  track lists; pages cached per session; sidebar lists playlists
- Shared lazy track list keyed on contents, playing track, likes and
  cover version; card grid that wraps
This commit is contained in:
Yuriy Panov committed 2026-10-15 14:51:51 +06:00
1 parent b73af1f870
commit 3b934df8cc
22 files changed
+1753 -227

No files matched your search

Generated
+38
View File
@@ -1090,6 +1090,27 @@ dependencies = [
"ctutils", "ctutils",
] ]
[[package]]
name = "directories"
version = "6.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "16f5094c54661b38d03bd7e50df373292118db60b585c08a411c6d840017fe7d"
dependencies = [
"dirs-sys",
]
[[package]]
name = "dirs-sys"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
dependencies = [
"libc",
"option-ext",
"redox_users",
"windows-sys 0.61.2",
]
[[package]] [[package]]
name = "dispatch" name = "dispatch"
version = "0.2.0" version = "0.2.0"
@@ -2860,6 +2881,7 @@ dependencies = [
name = "musyx" name = "musyx"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"directories",
"iced", "iced",
"keyring", "keyring",
"open", "open",
@@ -3496,6 +3518,12 @@ dependencies = [
"libc", "libc",
] ]
[[package]]
name = "option-ext"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
[[package]] [[package]]
name = "orbclient" name = "orbclient"
version = "0.3.55" version = "0.3.55"
@@ -4138,6 +4166,16 @@ dependencies = [
"bitflags 2.13.2", "bitflags 2.13.2",
] ]
[[package]]
name = "redox_users"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60dc65c0ff1a7ae1294b0c67b9f14baf70b644404010370171787bfac1038fc0"
dependencies = [
"libredox",
"thiserror 2.0.21",
]
[[package]] [[package]]
name = "regex" name = "regex"
version = "1.13.1" version = "1.13.1"
+2 -1
View File
@@ -14,7 +14,8 @@ rodio = { version = "0.23.0", default-features = false, features = ["playback",
rand = "0.9" rand = "0.9"
open = "5.4.4" open = "5.4.4"
serde_json = "1" serde_json = "1"
tokio = { version = "1", features = ["time", "rt"] } tokio = { version = "1", features = ["time", "rt", "fs", "sync"] }
directories = "6.0.0"
png = { version = "0.18.1", optional = true } png = { version = "0.18.1", optional = true }
[features] [features]
+215 -71
View File
@@ -1,19 +1,25 @@
//! Application state, messages and the window layout. //! Application state, messages and the window layout.
use std::collections::HashMap;
use std::sync::Arc;
use iced::theme::Mode; use iced::theme::Mode;
use iced::widget::{column, container, row, scrollable, space}; use iced::widget::{column, container, row, scrollable, space};
use iced::{Element, Fill, Subscription, Task, Theme}; use iced::{Element, Fill, Subscription, Task, Theme};
use ym_api::auth::Credentials; use ym_api::auth::Credentials;
use ym_api::{Account, Error, YmClient}; use ym_api::{Account, AlbumSummary, ArtistSummary, Error, LibraryPlaylists, Track, YmClient};
use crate::covers::Covers;
use crate::player::{self, Audio, Effect, Player}; use crate::player::{self, Audio, Effect, Player};
use crate::route::{Navigator, Route}; use crate::route::{Navigator, Route};
use crate::screens::collection::Liked; use crate::screens::collection::{Library, Liked, Tab};
use crate::screens::{self, sign_in}; use crate::screens::detail::{self, Page};
use crate::screens::{self, Loadable, sign_in};
use crate::session::{self, Restored}; use crate::session::{self, Restored};
use crate::ui::theme::{self, shell}; use crate::ui::theme::{self, shell};
use crate::widgets::drawer::{self, Panel}; use crate::widgets::drawer::{self, Panel};
use crate::widgets::player_bar; use crate::widgets::player_bar;
use crate::widgets::track_list::Env;
use crate::widgets::{sidebar, topbar}; use crate::widgets::{sidebar, topbar};
/// Where sign-in stands. Everything but `SignedIn` takes the whole window. /// Where sign-in stands. Everything but `SignedIn` takes the whole window.
@@ -36,7 +42,10 @@ pub struct App {
search: String, search: String,
drawer: Option<Panel>, drawer: Option<Panel>,
player: Player, player: Player,
liked: Liked, library: Library,
/// Album, artist and playlist pages visited this session.
pages: HashMap<Route, Loadable<Page>>,
covers: Covers,
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
@@ -56,9 +65,18 @@ pub enum Message {
ToggleDrawer(Panel), ToggleDrawer(Panel),
CloseDrawer, CloseDrawer,
Player(player::Msg), Player(player::Msg),
PlayTracks { tracks: Arc<[Track]>, start: usize, shuffle: bool },
LoadLiked, LoadLiked,
LikedLoaded(Result<Vec<ym_api::Track>, Error>), LikedLoaded(Result<Vec<Track>, Error>),
PlayLiked { start: usize, shuffle: bool }, CollectionTab(Tab),
LoadLibrary(Tab),
AlbumsLoaded(Result<Vec<AlbumSummary>, Error>),
ArtistsLoaded(Result<Vec<ArtistSummary>, Error>),
PlaylistsLoaded(Result<LibraryPlaylists, Error>),
PageLoaded(Route, Result<Page, Error>),
CoverWanted(String),
CoverLoaded(String, Option<Arc<[u8]>>),
CoversTick,
} }
impl App { impl App {
@@ -71,7 +89,9 @@ impl App {
search: String::new(), search: String::new(),
drawer: None, drawer: None,
player: Player::default(), player: Player::default(),
liked: Liked::NotLoaded, library: Library::default(),
pages: HashMap::new(),
covers: Covers::default(),
}; };
let appearance = iced::system::theme().map(Message::ThemeChanged); let appearance = iced::system::theme().map(Message::ThemeChanged);
@@ -79,7 +99,8 @@ impl App {
if let Some(config) = crate::snapshot::Config::from_env() { if let Some(config) = crate::snapshot::Config::from_env() {
let mut app = app; let mut app = app;
app.session = config.session(); app.session = config.session();
app.liked = Liked::loaded(config.sample_liked(), &Liked::NotLoaded); app.library.liked = Liked::loaded(config.sample_liked(), &Liked::NotLoaded);
app.pages.insert(Route::Album(1), Loadable::Loaded(config.sample_album()));
if let Some(route) = config.route { if let Some(route) = config.route {
app.nav = Navigator::new(route); app.nav = Navigator::new(route);
} }
@@ -110,14 +131,35 @@ impl App {
pub fn subscription(&self) -> Subscription<Message> { pub fn subscription(&self) -> Subscription<Message> {
let appearance = iced::system::theme_changes().map(Message::ThemeChanged); let appearance = iced::system::theme_changes().map(Message::ThemeChanged);
let audio = player::engine::subscription().map(|e| Message::Player(player::Msg::Engine(e))); let audio = player::engine::subscription().map(|e| Message::Player(player::Msg::Engine(e)));
match &self.session { let mut subs = vec![appearance, audio];
Session::SignedOut(sign_in) => Subscription::batch([ if let Session::SignedOut(sign_in) = &self.session {
appearance, subs.push(sign_in.subscription().map(Message::SignIn));
audio,
sign_in.subscription().map(Message::SignIn),
]),
_ => Subscription::batch([appearance, audio]),
} }
// Show arriving covers in batches instead of rebuilding lists for each one.
if self.covers.dirty() {
subs.push(iced::time::every(std::time::Duration::from_millis(150)).map(|_| Message::CoversTick));
}
Subscription::batch(subs)
}
fn client(&self) -> Option<&YmClient> {
match &self.session {
Session::SignedIn { client, .. } => Some(client),
_ => None,
}
}
/// A rejected token ends the session; anything else is logged and shown by the caller.
fn failed(&mut self, what: &str, e: &Error) -> Option<Task<Message>> {
eprintln!("{what}: {e}");
matches!(e, Error::Unauthorized(_)).then(|| self.update(Message::SignOut))
}
fn signed_in(&mut self, client: YmClient, account: Account) -> Task<Message> {
self.nav = Navigator::new(Route::Home);
self.session = Session::SignedIn { client, account };
// Liked tracks drive the hearts; playlists fill the sidebar.
Task::batch([self.update(Message::LoadLiked), self.update(Message::LoadLibrary(Tab::Playlists))])
} }
pub fn update(&mut self, message: Message) -> Task<Message> { pub fn update(&mut self, message: Message) -> Task<Message> {
@@ -129,14 +171,11 @@ impl App {
self.session = Session::Restoring; self.session = Session::Restoring;
return restore(); return restore();
} }
Message::Restored(restored) => { Message::Restored(Restored::SignedIn(client, account)) => {
self.session = match restored { return self.signed_in(client, account);
Restored::SignedIn(client, account) => Session::SignedIn { client, account },
Restored::SignedOut => Session::SignedOut(Box::default()),
Restored::Unreachable => Session::Unreachable,
};
return self.update(Message::LoadLiked);
} }
Message::Restored(Restored::SignedOut) => self.session = Session::SignedOut(Box::default()),
Message::Restored(Restored::Unreachable) => self.session = Session::Unreachable,
Message::SignIn(msg) => { Message::SignIn(msg) => {
let Session::SignedOut(sign_in) = &mut self.session else { let Session::SignedOut(sign_in) = &mut self.session else {
return Task::none(); return Task::none();
@@ -150,11 +189,7 @@ impl App {
} }
} }
} }
Message::Connected(Ok((client, account))) => { Message::Connected(Ok((client, account))) => return self.signed_in(client, account),
self.nav = Navigator::new(Route::Home);
self.session = Session::SignedIn { client, account };
return self.update(Message::LoadLiked);
}
Message::Connected(Err(e)) => { Message::Connected(Err(e)) => {
eprintln!("sign-in: {e}"); eprintln!("sign-in: {e}");
let pasted = matches!(self.session, Session::Connecting { pasted: true }); let pasted = matches!(self.session, Session::Connecting { pasted: true });
@@ -178,31 +213,27 @@ impl App {
self.nav = Navigator::new(Route::Home); self.nav = Navigator::new(Route::Home);
self.drawer = None; self.drawer = None;
self.player.reset(); self.player.reset();
self.liked = Liked::NotLoaded; self.library = Library::default();
self.pages.clear();
} }
Message::Navigate(route) => { Message::Navigate(route) => {
self.nav.go(route); self.nav.go(route);
if route == Route::Collection && matches!(self.liked, Liked::Failed(_)) { return self.on_enter(route);
return self.update(Message::LoadLiked);
}
// Settings shows the subscription, which can change outside the app.
if let (Route::Settings, Session::SignedIn { client, .. }) = (route, &self.session) {
let client = client.clone();
return Task::future(async move { client.account().await })
.map(Message::AccountRefreshed);
}
} }
Message::AccountRefreshed(Ok(fresh)) => { Message::AccountRefreshed(Ok(fresh)) => {
if let Session::SignedIn { account, .. } = &mut self.session { if let Session::SignedIn { account, .. } = &mut self.session {
*account = fresh; *account = fresh;
} }
} }
Message::AccountRefreshed(Err(Error::Unauthorized(e))) => { Message::AccountRefreshed(Err(e)) => {
eprintln!("token rejected: {e}"); if let Some(task) = self.failed("account refresh", &e) {
return self.update(Message::SignOut); return task;
}
}
Message::Back => {
self.nav.back();
return self.on_enter(self.nav.current());
} }
Message::AccountRefreshed(Err(e)) => eprintln!("account refresh: {e}"),
Message::Back => self.nav.back(),
Message::SearchChanged(query) => self.search = query, Message::SearchChanged(query) => self.search = query,
Message::SearchSubmitted => self.nav.go(Route::Search), Message::SearchSubmitted => self.nav.go(Route::Search),
Message::ToggleDrawer(panel) => { Message::ToggleDrawer(panel) => {
@@ -213,37 +244,140 @@ impl App {
let effects = self.player.update(msg); let effects = self.player.update(msg);
return self.run(effects); return self.run(effects);
} }
Message::LoadLiked => { Message::PlayTracks { tracks, start, shuffle } => {
let Session::SignedIn { client, .. } = &self.session else { return Task::none() };
if matches!(self.liked, Liked::Loading) {
return Task::none();
}
self.liked = Liked::Loading;
let client = client.clone();
return Task::future(async move { client.liked_tracks().await }).map(Message::LikedLoaded);
}
Message::LikedLoaded(Ok(tracks)) => self.liked = Liked::loaded(tracks, &self.liked),
Message::LikedLoaded(Err(Error::Unauthorized(e))) => {
eprintln!("token rejected: {e}");
return self.update(Message::SignOut);
}
Message::LikedLoaded(Err(e)) => {
eprintln!("liked tracks: {e}");
self.liked = Liked::Failed(e);
}
Message::PlayLiked { start, shuffle } => {
if let Some(tracks) = self.liked.tracks().cloned() {
return self.update(Message::Player(player::Msg::Play { return self.update(Message::Player(player::Msg::Play {
tracks, tracks,
start, start,
shuffle: shuffle.then_some(true), shuffle: shuffle.then_some(true),
})); }));
} }
Message::LoadLiked => {
let Some(client) = self.client().cloned() else { return Task::none() };
if matches!(self.library.liked, Liked::Loading) {
return Task::none();
} }
self.library.liked = Liked::Loading;
return Task::future(async move { client.liked_tracks().await }).map(Message::LikedLoaded);
}
Message::LikedLoaded(Ok(tracks)) => {
self.library.liked = Liked::loaded(tracks, &self.library.liked);
}
Message::LikedLoaded(Err(e)) => {
if let Some(task) = self.failed("liked tracks", &e) {
return task;
}
self.library.liked = Liked::Failed(e);
}
Message::CollectionTab(tab) => {
self.library.tab = tab;
return self.load_tab(tab);
}
Message::LoadLibrary(tab) => {
return match tab {
Tab::Tracks => self.update(Message::LoadLiked),
_ => self.force_load_tab(tab),
};
}
Message::AlbumsLoaded(result) => {
if let Err(e) = &result
&& let Some(task) = self.failed("liked albums", e)
{
return task;
}
self.library.albums = Loadable::from_result(result);
}
Message::ArtistsLoaded(result) => {
if let Err(e) = &result
&& let Some(task) = self.failed("liked artists", e)
{
return task;
}
self.library.artists = Loadable::from_result(result);
}
Message::PlaylistsLoaded(result) => {
if let Err(e) = &result
&& let Some(task) = self.failed("playlists", e)
{
return task;
}
self.library.playlists = Loadable::from_result(result);
}
Message::PageLoaded(route, result) => {
if let Err(e) = &result
&& let Some(task) = self.failed("page", e)
{
return task;
}
self.pages.insert(route, Loadable::from_result(result));
}
Message::CoverWanted(url) => {
let Some(client) = self.client().cloned() else { return Task::none() };
return self.covers.want(url, &client);
}
Message::CoverLoaded(url, bytes) => self.covers.loaded(url, bytes),
Message::CoversTick => self.covers.flush(),
} }
Task::none() Task::none()
} }
/// Loads what a route shows on first visit, and retries after a failure.
fn on_enter(&mut self, route: Route) -> Task<Message> {
match route {
Route::Collection => {
let retry_liked = matches!(self.library.liked, Liked::Failed(_));
let tab = self.load_tab(self.library.tab);
if retry_liked { Task::batch([tab, self.update(Message::LoadLiked)]) } else { tab }
}
// Settings shows the subscription, which can change outside the app.
Route::Settings => match self.client().cloned() {
Some(client) => {
Task::future(async move { client.account().await }).map(Message::AccountRefreshed)
}
None => Task::none(),
},
Route::Album(_) | Route::Artist(_) | Route::Playlist(_) => {
if self.pages.get(&route).is_some_and(|p| !p.needs_load()) {
return Task::none();
}
let Some(task) = self.client().and_then(|c| detail::load(c, route)) else {
return Task::none();
};
self.pages.insert(route, Loadable::Loading);
task
}
_ => Task::none(),
}
}
fn load_tab(&mut self, tab: Tab) -> Task<Message> {
let needed = match tab {
Tab::Tracks => matches!(self.library.liked, Liked::NotLoaded),
Tab::Albums => self.library.albums.needs_load(),
Tab::Artists => self.library.artists.needs_load(),
Tab::Playlists => self.library.playlists.needs_load(),
};
if needed { self.update(Message::LoadLibrary(tab)) } else { Task::none() }
}
fn force_load_tab(&mut self, tab: Tab) -> Task<Message> {
let Some(client) = self.client().cloned() else { return Task::none() };
match tab {
Tab::Tracks => Task::none(),
Tab::Albums => {
self.library.albums = Loadable::Loading;
Task::future(async move { client.liked_albums().await }).map(Message::AlbumsLoaded)
}
Tab::Artists => {
self.library.artists = Loadable::Loading;
Task::future(async move { client.liked_artists().await }).map(Message::ArtistsLoaded)
}
Tab::Playlists => {
self.library.playlists = Loadable::Loading;
Task::future(async move { client.library_playlists().await }).map(Message::PlaylistsLoaded)
}
}
}
pub fn view(&self) -> Element<'_, Message> { pub fn view(&self) -> Element<'_, Message> {
let t = theme::tokens(&self.theme); let t = theme::tokens(&self.theme);
let page = match &self.session { let page = match &self.session {
@@ -258,16 +392,22 @@ impl App {
fn shell<'a>(&'a self, t: &'static theme::Tokens, account: &'a Account) -> Element<'a, Message> { fn shell<'a>(&'a self, t: &'static theme::Tokens, account: &'a Account) -> Element<'a, Message> {
let route = self.nav.current(); let route = self.nav.current();
let env = Env {
t,
covers: &self.covers,
liked: &self.library.liked,
playing: self.player.track().map(|tr| tr.id.as_str()),
};
let content = column![ let content = column![
topbar::view(t, self.nav.can_go_back(), &self.search), topbar::view(t, self.nav.can_go_back(), &self.search),
scrollable(screens::view(screens::Ctx { scrollable(screens::view(screens::Ctx {
t, env,
route, route,
query: &self.search, query: &self.search,
me: account, me: account,
liked: &self.liked, library: &self.library,
playing: self.player.track().map(|tr| tr.id.as_str()), pages: &self.pages,
})) }))
.height(Fill) .height(Fill)
.style(theme::scroll), .style(theme::scroll),
@@ -275,10 +415,15 @@ impl App {
.width(Fill) .width(Fill)
.height(Fill); .height(Fill);
let mut body = row![sidebar::view(t, route, account), vline(), content].height(Fill); let mut body = row![
sidebar::view(t, route, account, self.library.playlists.get(), &self.covers),
vline(),
content,
]
.height(Fill);
if let Some(panel) = self.drawer { if let Some(panel) = self.drawer {
body = body.push(vline()).push(drawer::view(t, panel, &self.player)); body = body.push(vline()).push(drawer::view(t, panel, &self.player, &self.covers));
} }
let window = column![ let window = column![
@@ -287,8 +432,9 @@ impl App {
container(player_bar::view( container(player_bar::view(
t, t,
&self.player, &self.player,
self.player.track().is_some_and(|tr| self.liked.contains(&tr.id)), self.player.track().is_some_and(|tr| self.library.liked.contains(&tr.id)),
self.drawer, self.drawer,
&self.covers,
)) ))
.height(shell::PLAYER) .height(shell::PLAYER)
.style(theme::panel), .style(theme::panel),
@@ -296,12 +442,10 @@ impl App {
container(window).width(Fill).height(Fill).style(theme::app).into() container(window).width(Fill).height(Fill).style(theme::app).into()
} }
}
impl App {
/// Runs the player's requests against the API. /// Runs the player's requests against the API.
fn run(&self, effects: Vec<Effect>) -> Task<Message> { fn run(&self, effects: Vec<Effect>) -> Task<Message> {
let Session::SignedIn { client, .. } = &self.session else { return Task::none() }; let Some(client) = self.client() else { return Task::none() };
Task::batch(effects.into_iter().map(|effect| match effect { Task::batch(effects.into_iter().map(|effect| match effect {
Effect::Fetch { generation, track_id } => { Effect::Fetch { generation, track_id } => {
let client = client.clone(); let client = client.clone();
+181
View File
@@ -0,0 +1,181 @@
//! Cover art: fetched when a cover scrolls into view, kept in memory for the
//! session and on disk across sessions.
//!
//! Views never wait for images. A missing cover renders its placeholder inside
//! a `sensor`, and showing it sends [`Message::CoverWanted`].
use std::collections::{HashMap, HashSet};
use std::path::PathBuf;
use std::sync::Arc;
use iced::widget::{container, image, sensor, space};
use iced::{Element, Task};
use tokio::sync::Semaphore;
use ym_api::YmClient;
use crate::app::Message;
use crate::ui::theme;
/// Pixel sizes requested from Yandex. Rows and the player bar use `SMALL`,
/// cards and page headers `LARGE`; both cover 2× displays.
pub const SMALL: u32 = 100;
pub const LARGE: u32 = 400;
/// Downloads in flight at once.
const PARALLEL: usize = 8;
pub struct Covers {
images: HashMap<String, image::Handle>,
pending: HashSet<String>,
failed: HashSet<String>,
/// Bumped (debounced) when images arrive, so cached lists rebuild.
version: u64,
dirty: bool,
dir: Option<PathBuf>,
gate: Arc<Semaphore>,
}
impl Default for Covers {
fn default() -> Self {
let dir = directories::ProjectDirs::from("", "", "Musyx").map(|d| d.cache_dir().join("covers"));
Self {
images: HashMap::new(),
pending: HashSet::new(),
failed: HashSet::new(),
version: 0,
dirty: false,
dir,
gate: Arc::new(Semaphore::new(PARALLEL)),
}
}
}
impl Covers {
pub fn get(&self, url: &str) -> Option<image::Handle> {
self.images.get(url).cloned()
}
pub fn version(&self) -> u64 {
self.version
}
/// Whether arrivals are waiting to be shown; the app ticks [`Covers::flush`] meanwhile.
pub fn dirty(&self) -> bool {
self.dirty
}
pub fn flush(&mut self) {
if self.dirty {
self.version += 1;
self.dirty = false;
}
}
/// Starts fetching `url` unless it is known, in flight, or failed before.
pub fn want(&mut self, url: String, client: &YmClient) -> Task<Message> {
if self.images.contains_key(&url) || self.pending.contains(&url) || self.failed.contains(&url) {
return Task::none();
}
self.pending.insert(url.clone());
let (client, dir, gate) = (client.clone(), self.dir.clone(), self.gate.clone());
Task::future(async move {
let bytes = load(&client, &url, dir, &gate).await;
Message::CoverLoaded(url, bytes)
})
}
pub fn loaded(&mut self, url: String, bytes: Option<Arc<[u8]>>) {
self.pending.remove(&url);
match bytes {
Some(bytes) => {
self.images.insert(url, image::Handle::from_bytes(bytes.to_vec()));
self.dirty = true;
}
None => {
self.failed.insert(url);
}
}
}
}
async fn load(client: &YmClient, url: &str, dir: Option<PathBuf>, gate: &Semaphore) -> Option<Arc<[u8]>> {
let path = dir.as_ref().map(|d| d.join(file_name(url)));
if let Some(path) = &path
&& let Ok(bytes) = tokio::fs::read(path).await
{
return Some(bytes.into());
}
let _permit = gate.acquire().await.ok()?;
let bytes = match client.image(url).await {
Ok(bytes) if !bytes.is_empty() => bytes,
Ok(_) => return None,
Err(e) => {
eprintln!("cover {url}: {e}");
return None;
}
};
if let (Some(dir), Some(path)) = (&dir, &path) {
// A failed cache write only costs a re-download next time.
let _ = tokio::fs::create_dir_all(dir).await;
let _ = tokio::fs::write(path, &bytes).await;
}
Some(bytes.into())
}
/// A stable, filesystem-safe name for a URL (64-bit FNV-1a).
fn file_name(url: &str) -> String {
let hash = url.bytes().fold(0xcbf2_9ce4_8422_2325_u64, |h, b| (h ^ u64::from(b)).wrapping_mul(0x0100_0000_01b3));
format!("{hash:016x}.img")
}
/// A square cover: the image when cached, otherwise placeholder art that asks
/// for the image once it is (nearly) on screen.
pub fn view(
covers: &Covers,
url: Option<String>,
hues: (f32, f32),
size: f32,
corner: f32,
) -> Element<'static, Message> {
if let Some(handle) = url.as_deref().and_then(|u| covers.get(u)) {
return image(handle).width(size).height(size).border_radius(corner).into();
}
let placeholder = container(space()).width(size).height(size).style(theme::cover(hues.0, hues.1, corner));
match url {
Some(url) => sensor(placeholder)
.on_show(move |_| Message::CoverWanted(url.clone()))
.anticipate(300)
.into(),
None => placeholder.into(),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn file_names_are_stable_and_distinct() {
let a = file_name("https://avatars.yandex.net/get-music-content/1/100x100");
assert_eq!(a, file_name("https://avatars.yandex.net/get-music-content/1/100x100"));
assert_ne!(a, file_name("https://avatars.yandex.net/get-music-content/1/400x400"));
assert!(a.ends_with(".img") && a.len() == 20);
}
#[test]
fn arrivals_bump_version_only_on_flush() {
let mut covers = Covers { dir: None, ..Covers::default() };
covers.pending.insert("u".into());
covers.loaded("u".into(), Some(Arc::from(vec![1u8, 2, 3])));
assert!(covers.dirty());
assert_eq!(covers.version(), 0);
covers.flush();
assert_eq!(covers.version(), 1);
assert!(covers.get("u").is_some());
covers.loaded("bad".into(), None);
assert!(covers.failed.contains("bad"));
covers.flush();
assert_eq!(covers.version(), 1, "a failure changes nothing on screen");
}
}
+1
View File
@@ -1,4 +1,5 @@
mod app; mod app;
mod covers;
mod player; mod player;
mod route; mod route;
mod screens; mod screens;
+11
View File
@@ -1,6 +1,8 @@
//! Every place the content area can show. Detail pages (album, artist, playlist) //! Every place the content area can show. Detail pages (album, artist, playlist)
//! join this enum once they carry ids from the API. //! join this enum once they carry ids from the API.
use ym_api::PlaylistId;
use crate::ui::icons::Icon; use crate::ui::icons::Icon;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -11,6 +13,9 @@ pub enum Route {
Collection, Collection,
Podcasts, Podcasts,
Settings, Settings,
Album(i64),
Artist(i64),
Playlist(PlaylistId),
} }
impl Route { impl Route {
@@ -26,6 +31,9 @@ impl Route {
Route::Collection => "Collection", Route::Collection => "Collection",
Route::Podcasts => "Podcasts", Route::Podcasts => "Podcasts",
Route::Settings => "Settings", Route::Settings => "Settings",
Route::Album(_) => "Album",
Route::Artist(_) => "Artist",
Route::Playlist(_) => "Playlist",
} }
} }
@@ -37,6 +45,9 @@ impl Route {
Route::Collection => Icon::Library, Route::Collection => Icon::Library,
Route::Podcasts => Icon::Podcast, Route::Podcasts => Icon::Podcast,
Route::Settings => Icon::Settings, Route::Settings => Icon::Settings,
Route::Album(_) => Icon::Disc,
Route::Artist(_) => Icon::Wave,
Route::Playlist(_) => Icon::Queue,
} }
} }
} }
+264 -80
View File
@@ -1,20 +1,24 @@
//! Collection: for now the liked tracks list, which is also the first thing //! Collection: liked tracks, albums, artists, and playlists (own and liked).
//! you can play.
use std::collections::HashSet; use std::collections::HashSet;
use std::sync::Arc; use std::sync::Arc;
use iced::widget::{Column, button, column, lazy, row}; use iced::widget::{button, column, container, row, space};
use iced::{Alignment, Element, Fill}; use iced::{Alignment, Element, Fill};
use ym_api::{Error, Track}; use ym_api::{AlbumSummary, ArtistSummary, Error, LibraryPlaylists, PlaylistSummary, Track};
use super::Loadable;
use crate::app::Message; use crate::app::Message;
use crate::covers::{self, Covers};
use crate::route::Route;
use crate::ui::icons::{Icon, icon}; use crate::ui::icons::{Icon, icon};
use crate::ui::theme::{self, Tokens, size}; use crate::ui::theme::{self, Tokens, size};
use crate::ui::{line, para}; use crate::ui::{duration_words, line, para, tracks_word};
use crate::widgets::track_row; use crate::widgets::card::{self, Card};
use crate::widgets::track_list::{self, Env};
use crate::widgets::track_row::Columns;
/// The liked-tracks list as the app holds it. /// The liked-tracks list as the app holds it. Also answers "is this track liked?".
#[derive(Debug, Default)] #[derive(Debug, Default)]
pub enum Liked { pub enum Liked {
#[default] #[default]
@@ -23,7 +27,7 @@ pub enum Liked {
Loaded { Loaded {
tracks: Arc<[Track]>, tracks: Arc<[Track]>,
ids: HashSet<String>, ids: HashSet<String>,
/// Bumped on every reload so the cached rows rebuild. /// Bumped on every reload so cached rows rebuild.
version: u64, version: u64,
}, },
Failed(Error), Failed(Error),
@@ -31,10 +35,7 @@ pub enum Liked {
impl Liked { impl Liked {
pub fn loaded(tracks: Vec<Track>, previous: &Liked) -> Self { pub fn loaded(tracks: Vec<Track>, previous: &Liked) -> Self {
let version = match previous { let version = previous.version() + 1;
Liked::Loaded { version, .. } => version + 1,
_ => 0,
};
let ids = tracks.iter().map(|t| t.id.clone()).collect(); let ids = tracks.iter().map(|t| t.id.clone()).collect();
Liked::Loaded { tracks: tracks.into(), ids, version } Liked::Loaded { tracks: tracks.into(), ids, version }
} }
@@ -49,26 +50,259 @@ impl Liked {
_ => None, _ => None,
} }
} }
pub fn version(&self) -> u64 {
match self {
Liked::Loaded { version, .. } => *version,
_ => 0,
}
}
} }
/// What makes the list look different; anything else reuses the built rows. #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[derive(Hash)] pub enum Tab {
struct ListKey { #[default]
version: u64, Tracks,
playing: Option<String>, Albums,
dark: bool, Artists,
Playlists,
} }
pub fn view<'a>(t: &'static Tokens, liked: &'a Liked, playing: Option<&'a str>) -> Element<'a, Message> { impl Tab {
let title = line("Collection", theme::DISPLAY, size::DISPLAY_S, t.fg); const ALL: [Tab; 4] = [Tab::Tracks, Tab::Albums, Tab::Artists, Tab::Playlists];
let body: Element<'a, Message> = match liked { fn label(self) -> &'static str {
match self {
Tab::Tracks => "Liked tracks",
Tab::Albums => "Albums",
Tab::Artists => "Artists",
Tab::Playlists => "Playlists",
}
}
}
/// Everything Collection shows. Parts load on first visit to their tab.
#[derive(Debug, Default)]
pub struct Library {
pub tab: Tab,
pub liked: Liked,
pub albums: Loadable<Vec<AlbumSummary>>,
pub artists: Loadable<Vec<ArtistSummary>>,
pub playlists: Loadable<LibraryPlaylists>,
}
impl Library {
fn count(&self, tab: Tab) -> Option<usize> {
match tab {
Tab::Tracks => self.liked.tracks().map(|t| t.len()),
Tab::Albums => self.albums.get().map(Vec::len),
Tab::Artists => self.artists.get().map(Vec::len),
Tab::Playlists => self.playlists.get().map(|p| p.own.len() + p.liked.len()),
}
}
}
pub fn view<'a>(env: Env<'a>, library: &'a Library) -> Element<'a, Message> {
let t = env.t;
let tabs = row(Tab::ALL.map(|tab| tab_button(t, tab, library))).spacing(4);
let body: Element<'a, Message> = match library.tab {
Tab::Tracks => liked_tracks(env, &library.liked),
Tab::Albums => match &library.albums {
Loadable::Loaded(albums) if albums.is_empty() => {
empty(t, "No liked albums yet. Like an album and it lands here.")
}
Loadable::Loaded(albums) => card::grid(albums.iter().map(|a| album_card(t, env.covers, a))),
other => status(t, other.state(), "albums", Message::LoadLibrary(Tab::Albums)),
},
Tab::Artists => match &library.artists {
Loadable::Loaded(artists) if artists.is_empty() => {
empty(t, "No liked artists yet. Like an artist and they land here.")
}
Loadable::Loaded(artists) => card::grid(artists.iter().map(|a| artist_card(t, env.covers, a))),
other => status(t, other.state(), "artists", Message::LoadLibrary(Tab::Artists)),
},
Tab::Playlists => match &library.playlists {
Loadable::Loaded(p) if p.own.is_empty() && p.liked.is_empty() => {
empty(t, "No playlists yet. Playlists you make or like show up here.")
}
Loadable::Loaded(p) => {
let mut sections = column![].spacing(28);
if !p.own.is_empty() {
sections = sections.push(section(
t,
"Your playlists",
p.own.iter().map(|pl| playlist_card(t, env.covers, pl)),
));
}
if !p.liked.is_empty() {
sections = sections.push(section(
t,
"Liked playlists",
p.liked.iter().map(|pl| playlist_card(t, env.covers, pl)),
));
}
sections.into()
}
other => status(t, other.state(), "playlists", Message::LoadLibrary(Tab::Playlists)),
},
};
column![line("Collection", theme::DISPLAY, size::DISPLAY_S, t.fg), tabs, body]
.spacing(24)
.width(Fill)
.into()
}
fn tab_button<'a>(t: &'static Tokens, tab: Tab, library: &Library) -> Element<'a, Message> {
let on = library.tab == tab;
let mut label = row![line(tab.label(), theme::MEDIUM, size::BODY, if on { t.fg } else { t.muted })]
.spacing(6)
.align_y(Alignment::Center);
if let Some(n) = library.count(tab) {
label = label.push(line(n.to_string(), theme::BODY, size::SMALL, t.muted));
}
button(
column![label, container(space()).width(Fill).height(2).style(theme::tab_underline(on))]
.spacing(7)
.width(iced::Shrink),
)
.padding([6, 10])
.style(theme::tab(on))
.on_press(Message::CollectionTab(tab))
.into()
}
fn liked_tracks<'a>(env: Env<'a>, liked: &'a Liked) -> Element<'a, Message> {
let t = env.t;
match liked {
Liked::NotLoaded | Liked::Loading => para("Loading your liked tracks…", size::BODY, t.muted).into(), Liked::NotLoaded | Liked::Loading => para("Loading your liked tracks…", size::BODY, t.muted).into(),
Liked::Failed(err) => column![ Liked::Failed(e) => status(t, LoadState::Failed(e), "liked tracks", Message::LoadLiked),
Liked::Loaded { tracks, .. } if tracks.is_empty() => {
empty(t, "No liked tracks yet. Tap the heart on any track and it lands here.")
}
Liked::Loaded { tracks, .. } => {
let total = tracks.iter().map(|t| t.duration).sum();
column![
play_bar(t, format!("{} · {}", tracks_word(tracks.len()), duration_words(total)), tracks),
track_list::view(env, tracks, Columns::FULL),
]
.spacing(22)
.into()
}
}
}
/// Play and Shuffle buttons with a summary on the left. Shared by every page with tracks.
pub fn play_bar<'a>(t: &'static Tokens, summary: String, tracks: &Arc<[Track]>) -> Element<'a, Message> {
let has_tracks = !tracks.is_empty();
let pill = |glyph: Icon,
label: &'static str,
ink,
style: fn(&iced::Theme, button::Status) -> button::Style,
msg| {
button(
row![icon(glyph, ink), line(label, theme::SEMIBOLD, size::BODY, ink)]
.spacing(8)
.align_y(Alignment::Center),
)
.padding([10, 18])
.style(style)
.on_press_maybe(has_tracks.then_some(msg))
};
row![
container(line(summary, theme::BODY, size::META, t.muted)).width(Fill),
pill(
Icon::Play,
"Play",
t.accent_ink,
theme::primary,
Message::PlayTracks { tracks: tracks.clone(), start: 0, shuffle: false },
),
pill(
Icon::Shuffle,
"Shuffle",
t.fg,
theme::ghost,
Message::PlayTracks { tracks: tracks.clone(), start: 0, shuffle: true },
),
]
.spacing(10)
.align_y(Alignment::Center)
.into()
}
pub fn album_card<'a>(t: &'static Tokens, covers: &Covers, a: &AlbumSummary) -> Element<'a, Message> {
card::view(
t,
covers,
Card {
title: a.full_title(),
subtitle: a.subtitle(),
cover: a.cover_url(covers::LARGE),
hues: a.hues(),
round: false,
on_press: Message::Navigate(Route::Album(a.id)),
},
)
}
pub fn artist_card<'a>(t: &'static Tokens, covers: &Covers, a: &ArtistSummary) -> Element<'a, Message> {
card::view(
t,
covers,
Card {
title: a.name.clone(),
subtitle: a.genres.first().cloned().unwrap_or_else(|| "Artist".into()),
cover: a.cover_url(covers::LARGE),
hues: a.hues(),
round: true,
on_press: Message::Navigate(Route::Artist(a.id)),
},
)
}
pub fn playlist_card<'a>(t: &'static Tokens, covers: &Covers, p: &PlaylistSummary) -> Element<'a, Message> {
card::view(
t,
covers,
Card {
title: p.title.clone(),
subtitle: p.subtitle(),
cover: p.cover_url(covers::LARGE),
hues: p.hues(),
round: false,
on_press: Message::Navigate(Route::Playlist(p.id)),
},
)
}
pub fn section<'a>(
t: &'static Tokens,
heading: &'a str,
cards: impl IntoIterator<Item = Element<'a, Message>>,
) -> Element<'a, Message> {
column![line(heading, theme::SEMIBOLD, size::SECTION, t.fg), card::grid(cards)]
.spacing(14)
.into()
}
pub enum LoadState<'a> {
Loading,
Failed(&'a Error),
}
/// Loading text, or a failure with a retry button.
pub fn status<'a>(t: &'static Tokens, state: LoadState<'_>, what: &str, retry: Message) -> Element<'a, Message> {
match state {
LoadState::Loading => para(format!("Loading your {what}…"), size::BODY, t.muted).into(),
LoadState::Failed(e) => column![
para( para(
match err { match e {
Error::Network(_) => "Couldn't load your liked tracks. Check your connection and try again.", Error::Network(_) => {
_ => "Couldn't load your liked tracks. Try again in a moment.", format!("Couldn't load your {what}. Check your connection and try again.")
}
_ => format!("Couldn't load your {what}. Try again in a moment."),
}, },
size::BODY, size::BODY,
t.muted, t.muted,
@@ -76,63 +310,15 @@ pub fn view<'a>(t: &'static Tokens, liked: &'a Liked, playing: Option<&'a str>)
button(line("Try again", theme::SEMIBOLD, size::BODY, t.accent_ink)) button(line("Try again", theme::SEMIBOLD, size::BODY, t.accent_ink))
.padding([11, 18]) .padding([11, 18])
.style(theme::primary) .style(theme::primary)
.on_press(Message::LoadLiked), .on_press(retry),
] ]
.spacing(16) .spacing(16)
.into(), .into(),
Liked::Loaded { tracks, .. } if tracks.is_empty() => para(
"No liked tracks yet. Tap the heart on any track and it lands here.",
size::BODY,
t.muted,
)
.into(),
Liked::Loaded { tracks, version, .. } => {
let key = ListKey { version: *version, playing: playing.map(str::to_owned), dark: t == &theme::DARK };
let tracks = tracks.clone();
let list = lazy(key, move |key: &ListKey| {
let rows = tracks.iter().enumerate().map(|(i, track)| {
let now = key.playing.as_deref() == Some(track.id.as_str());
track_row::view(t, i, track, now, true, Message::PlayLiked { start: i, shuffle: false })
});
Column::with_children(std::iter::once(track_row::header(t)).chain(rows)).spacing(2)
});
column![header(t, liked), list].spacing(22).into()
} }
};
column![title, body].spacing(28).width(Fill).into()
} }
fn header<'a>(t: &'static Tokens, liked: &Liked) -> Element<'a, Message> { fn empty<'a>(t: &'static Tokens, text: &'static str) -> Element<'a, Message> {
let count = liked.tracks().map_or(0, |t| t.len()); para(text, size::BODY, t.muted).into()
let total: u64 = liked.tracks().map_or(0, |ts| ts.iter().map(|t| t.duration.as_secs()).sum());
let summary = format!(
"{} {} · {}",
count,
if count == 1 { "track" } else { "tracks" },
if total >= 3600 { format!("{} h {} min", total / 3600, (total % 3600) / 60) } else { format!("{} min", total / 60) },
);
let pill = |glyph: Icon, label: &'static str, ink, style: fn(&iced::Theme, button::Status) -> button::Style, msg| {
button(row![icon(glyph, ink), line(label, theme::SEMIBOLD, size::BODY, ink)].spacing(8).align_y(Alignment::Center))
.padding([10, 18])
.style(style)
.on_press(msg)
};
row![
column![
line("Liked tracks", theme::SEMIBOLD, size::SECTION, t.fg),
line(summary, theme::BODY, size::META, t.muted),
]
.spacing(4)
.width(Fill),
pill(Icon::Play, "Play", t.accent_ink, theme::primary, Message::PlayLiked { start: 0, shuffle: false }),
pill(Icon::Shuffle, "Shuffle", t.fg, theme::ghost, Message::PlayLiked { start: 0, shuffle: true }),
]
.spacing(10)
.align_y(Alignment::Center)
.into()
} }
#[cfg(test)] #[cfg(test)]
@@ -147,11 +333,9 @@ mod tests {
fn reload_bumps_version_and_indexes_ids() { fn reload_bumps_version_and_indexes_ids() {
let first = Liked::loaded(vec![track("1"), track("2")], &Liked::Loading); let first = Liked::loaded(vec![track("1"), track("2")], &Liked::Loading);
assert!(first.contains("2") && !first.contains("3")); assert!(first.contains("2") && !first.contains("3"));
assert_eq!(first.version(), 1);
let second = Liked::loaded(vec![track("3")], &first); let second = Liked::loaded(vec![track("3")], &first);
match second { assert_eq!(second.version(), 2);
Liked::Loaded { version, .. } => assert_eq!(version, 1),
_ => unreachable!(),
}
assert!(!Liked::Failed(Error::Denied).contains("1")); assert!(!Liked::Failed(Error::Denied).contains("1"));
} }
} }
+229
View File
@@ -0,0 +1,229 @@
//! Album, artist and playlist pages: a cover header, then tracks and cards.
use std::sync::Arc;
use iced::widget::{Row, button, column, container, row, text};
use iced::{Alignment, Element, Fill, Task};
use ym_api::{AlbumPage, ArtistPage, ArtistRef, Error, PlaylistPage, Track, YmClient};
use super::Loadable;
use super::collection::{LoadState, album_card, artist_card, play_bar, section, status};
use crate::app::Message;
use crate::covers;
use crate::route::Route;
use crate::ui::theme::{self, size};
use crate::ui::{compact, duration_words, line, para, tracks_word};
use crate::widgets::track_list::{self, Env};
use crate::widgets::track_row::Columns;
/// A loaded page. Tracks are split out as `Arc<[Track]>` so playing them shares the list.
#[derive(Debug, Clone)]
pub enum Page {
Album { info: AlbumPage, tracks: Arc<[Track]> },
Artist { info: ArtistPage, popular: Arc<[Track]> },
Playlist { info: PlaylistPage, tracks: Arc<[Track]> },
}
/// Fetches whatever `route` shows. Non-detail routes load nothing.
pub fn load(client: &YmClient, route: Route) -> Option<Task<Message>> {
let client = client.clone();
let task = match route {
Route::Album(id) => Task::future(async move {
client.album(id).await.map(|mut info| {
let tracks = std::mem::take(&mut info.tracks).into();
Page::Album { info, tracks }
})
}),
Route::Artist(id) => Task::future(async move {
client.artist(id).await.map(|mut info| {
let popular = std::mem::take(&mut info.popular).into();
Page::Artist { info, popular }
})
}),
Route::Playlist(id) => Task::future(async move {
client.playlist(id).await.map(|mut info| {
let tracks = std::mem::take(&mut info.tracks).into();
Page::Playlist { info, tracks }
})
}),
_ => return None,
};
Some(task.map(move |result| Message::PageLoaded(route, result)))
}
pub fn view<'a>(env: Env<'a>, route: Route, page: &'a Loadable<Page>) -> Element<'a, Message> {
let t = env.t;
let what = match route {
Route::Album(_) => "album",
Route::Artist(_) => "artist",
_ => "playlist",
};
match page {
Loadable::Loaded(Page::Album { info, tracks }) => album(env, info, tracks),
Loadable::Loaded(Page::Artist { info, popular }) => artist(env, info, popular),
Loadable::Loaded(Page::Playlist { info, tracks }) => playlist(env, info, tracks),
Loadable::Failed(e) => not_found_or_retry(env, e, what, route),
Loadable::NotLoaded | Loadable::Loading => {
para(format!("Loading the {what}…"), size::BODY, t.muted).into()
}
}
}
fn not_found_or_retry<'a>(env: Env<'a>, e: &'a Error, what: &str, route: Route) -> Element<'a, Message> {
if let Error::Api(m) = e
&& m.contains("not found")
{
return para(format!("This {what} isn't available on Yandex Music any more."), size::BODY, env.t.muted)
.into();
}
status(env.t, LoadState::Failed(e), what, Message::Navigate(route))
}
struct Head<'a> {
cover: Option<String>,
hues: (f32, f32),
round: bool,
kind: String,
title: String,
by: Option<Element<'a, Message>>,
meta: String,
}
fn head<'a>(env: Env<'a>, h: Head<'a>) -> Element<'a, Message> {
let t = env.t;
let size_px = 200.0;
let corner = if h.round { size_px / 2.0 } else { theme::radius::COVER };
row![
covers::view(env.covers, h.cover, h.hues, size_px, corner),
column![
line(h.kind, theme::BODY, size::META, t.muted),
text(h.title).font(theme::DISPLAY).size(size::DISPLAY_L).line_height(1.08).color(t.fg),
]
.push(h.by)
.push(line(h.meta, theme::BODY, size::META, t.muted))
.spacing(8)
.width(Fill),
]
.spacing(28)
.align_y(Alignment::End)
.into()
}
/// Artist names as links to their pages.
fn artist_links<'a>(env: Env<'a>, artists: &[ArtistRef]) -> Element<'a, Message> {
let t = env.t;
Row::with_children(artists.iter().map(|a| {
let label = line(a.name.clone(), theme::MEDIUM, size::BODY, t.fg);
match a.id {
Some(id) => button(label)
.padding(0)
.style(theme::tab(true))
.on_press(Message::Navigate(Route::Artist(id)))
.into(),
None => label.into(),
}
}))
.spacing(12)
.into()
}
fn album<'a>(env: Env<'a>, info: &'a AlbumPage, tracks: &'a Arc<[Track]>) -> Element<'a, Message> {
let a = &info.album;
let kind = match a.year {
Some(year) => format!("{} · {year}", a.kind.label()),
None => a.kind.label().to_owned(),
};
// `info.tracks` was moved into `tracks`, so measure the list itself.
let length = format!("{} · {}", tracks_word(tracks.len()), duration_words(tracks.iter().map(|tr| tr.duration).sum()));
let meta = match &info.label {
Some(label) => format!("{length} · {label}"),
None => length,
};
column![
head(env, Head {
cover: a.cover_url(covers::LARGE),
hues: a.hues(),
round: false,
kind,
title: a.full_title(),
by: Some(artist_links(env, &a.artists)),
meta,
}),
play_bar(env.t, String::new(), tracks),
track_list::view(env, tracks, Columns::ALBUM_PAGE),
]
.spacing(28)
.into()
}
fn artist<'a>(env: Env<'a>, info: &'a ArtistPage, popular: &'a Arc<[Track]>) -> Element<'a, Message> {
let t = env.t;
let a = &info.artist;
let kind = if a.genres.is_empty() { "Artist".to_owned() } else { format!("Artist · {}", a.genres.join(", ")) };
let meta = info
.monthly_listeners
.map(|n| format!("{} listeners a month", compact(n)))
.or_else(|| a.likes.map(|n| format!("{} likes", compact(n))))
.unwrap_or_default();
let mut page = column![
head(env, Head {
cover: a.cover_url(covers::LARGE),
hues: a.hues(),
round: true,
kind,
title: a.name.clone(),
by: None,
meta,
}),
]
.spacing(34);
if !popular.is_empty() {
page = page.push(
column![
line("Popular tracks", theme::SEMIBOLD, size::SECTION, t.fg),
play_bar(t, String::new(), popular),
track_list::view(env, popular, Columns::FULL),
]
.spacing(14),
);
}
if !info.albums.is_empty() {
page = page.push(section(t, "Albums", info.albums.iter().map(|al| album_card(t, env.covers, al))));
}
if !info.also_albums.is_empty() {
page = page.push(section(t, "Appears on", info.also_albums.iter().map(|al| album_card(t, env.covers, al))));
}
if !info.similar.is_empty() {
page = page.push(section(t, "Similar artists", info.similar.iter().map(|ar| artist_card(t, env.covers, ar))));
}
page.into()
}
fn playlist<'a>(env: Env<'a>, info: &'a PlaylistPage, tracks: &'a Arc<[Track]>) -> Element<'a, Message> {
let t = env.t;
let p = &info.playlist;
let total = tracks.iter().map(|tr| tr.duration).sum();
let mut page = column![
head(env, Head {
cover: p.cover_url(covers::LARGE),
hues: p.hues(),
round: false,
kind: format!("Playlist · {}", if p.public { "Public" } else { "Private" }),
title: p.title.clone(),
by: Some(line(p.owner_name.clone(), theme::MEDIUM, size::BODY, t.fg).into()),
meta: format!("{} · {}", tracks_word(tracks.len()), duration_words(total)),
}),
]
.spacing(28);
if let Some(description) = &info.description {
page = page.push(container(para(description.clone(), size::BODY, t.muted)).max_width(640));
}
if tracks.is_empty() {
return page.push(para("This playlist is empty.", size::BODY, t.muted)).into();
}
page.push(play_bar(t, String::new(), tracks))
.push(track_list::view(env, tracks, Columns::FULL))
.into()
}
+52 -6
View File
@@ -1,11 +1,14 @@
//! Content for each route, plus the full-window screens shown outside a session. //! Content for each route, plus the full-window screens shown outside a session.
pub mod collection; pub mod collection;
pub mod detail;
pub mod sign_in; pub mod sign_in;
use iced::widget::{Column, button, column, container, row, space}; use iced::widget::{Column, button, column, container, row, space};
use iced::{Alignment, Element, Fill, Padding}; use iced::{Alignment, Element, Fill, Padding};
use ym_api::Account; use std::collections::HashMap;
use ym_api::{Account, Error};
use crate::app::Message; use crate::app::Message;
use crate::route::Route; use crate::route::Route;
@@ -13,19 +16,59 @@ use crate::ui::icons::{Icon, icon, sized};
use crate::ui::theme::{self, Tokens, radius, size, space as sp}; use crate::ui::theme::{self, Tokens, radius, size, space as sp};
use crate::ui::{line, para}; use crate::ui::{line, para};
use crate::widgets::sidebar; use crate::widgets::sidebar;
use crate::widgets::track_list::Env;
/// Something fetched from the API: not asked for yet, on its way, here, or failed.
#[derive(Debug, Default)]
pub enum Loadable<T> {
#[default]
NotLoaded,
Loading,
Loaded(T),
Failed(Error),
}
impl<T> Loadable<T> {
pub fn get(&self) -> Option<&T> {
match self {
Loadable::Loaded(v) => Some(v),
_ => None,
}
}
/// Not loaded yet, or failed: worth (re)requesting.
pub fn needs_load(&self) -> bool {
matches!(self, Loadable::NotLoaded | Loadable::Failed(_))
}
pub fn state(&self) -> collection::LoadState<'_> {
match self {
Loadable::Failed(e) => collection::LoadState::Failed(e),
_ => collection::LoadState::Loading,
}
}
pub fn from_result(result: Result<T, Error>) -> Self {
match result {
Ok(v) => Loadable::Loaded(v),
Err(e) => Loadable::Failed(e),
}
}
}
/// Everything a routed screen may need from app state. /// Everything a routed screen may need from app state.
pub struct Ctx<'a> { pub struct Ctx<'a> {
pub t: &'static Tokens, pub env: Env<'a>,
pub route: Route, pub route: Route,
pub query: &'a str, pub query: &'a str,
pub me: &'a Account, pub me: &'a Account,
pub liked: &'a collection::Liked, pub library: &'a collection::Library,
pub playing: Option<&'a str>, pub pages: &'a HashMap<Route, Loadable<detail::Page>>,
} }
pub fn view<'a>(ctx: Ctx<'a>) -> Element<'a, Message> { pub fn view<'a>(ctx: Ctx<'a>) -> Element<'a, Message> {
let Ctx { t, route, query, me, liked, playing } = ctx; let Ctx { env, route, query, me, library, pages } = ctx;
let t = env.t;
let content: Column<'a, Message> = match route { let content: Column<'a, Message> = match route {
Route::Home => column![ Route::Home => column![
wave_hero(t), wave_hero(t),
@@ -43,7 +86,10 @@ pub fn view<'a>(ctx: Ctx<'a>) -> Element<'a, Message> {
}), }),
upcoming(t, Icon::Search, "Search the whole catalogue", "Tracks, albums, artists, playlists and podcasts."), upcoming(t, Icon::Search, "Search the whole catalogue", "Tracks, albums, artists, playlists and podcasts."),
], ],
Route::Collection => column![collection::view(t, liked, playing)], Route::Collection => column![collection::view(env, library)],
Route::Album(_) | Route::Artist(_) | Route::Playlist(_) => {
column![detail::view(env, route, pages.get(&route).unwrap_or(&Loadable::Loading))]
}
Route::Podcasts => column![ Route::Podcasts => column![
title(t, "Podcasts and books"), title(t, "Podcasts and books"),
upcoming(t, Icon::Podcast, "Pick up where you left off", "Podcasts and audiobooks you follow."), upcoming(t, Icon::Podcast, "Pick up where you left off", "Podcasts and audiobooks you follow."),
+23
View File
@@ -42,6 +42,7 @@ impl Config {
"collection" => Route::Collection, "collection" => Route::Collection,
"podcasts" => Route::Podcasts, "podcasts" => Route::Podcasts,
"settings" => Route::Settings, "settings" => Route::Settings,
"album" => Route::Album(1),
_ => return None, _ => return None,
}) })
}); });
@@ -97,6 +98,28 @@ impl Config {
.collect() .collect()
} }
/// A sample album page for `MUSYX_SNAPSHOT_ROUTE=album`.
pub fn sample_album(&self) -> crate::screens::detail::Page {
let tracks: Vec<String> = [
("Группа крови", 286), ("Закрой за мной дверь, я ухожу", 256), ("Война", 274),
("Попробуй спеть вместе со мной", 283), ("Звезда по имени Солнце", 225), ("Спокойная ночь", 366),
]
.iter()
.enumerate()
.map(|(i, (title, secs))| {
format!(r#"{{"id":{},"title":"{title}","durationMs":{},"artists":[{{"id":1,"name":"Кино"}}]}}"#, i + 1, secs * 1000)
})
.collect();
let json = format!(
r#"{{"id":1,"title":"Группа крови","year":1988,"artists":[{{"id":1,"name":"Кино"}}],
"labels":["Мелодия"],"volumes":[[{}]]}}"#,
tracks.join(",")
);
let mut info = ym_api::AlbumPage::from_json(&json).expect("sample album");
let tracks = std::mem::take(&mut info.tracks).into();
crate::screens::detail::Page::Album { info, tracks }
}
/// Waits for fonts and the first frames, captures the window, writes the PNG, exits. /// Waits for fonts and the first frames, captures the window, writes the PNG, exits.
pub fn capture<M: Send + 'static>(self) -> Task<M> { pub fn capture<M: Send + 'static>(self) -> Task<M> {
Task::future(tokio::time::sleep(Duration::from_millis(1500))) Task::future(tokio::time::sleep(Duration::from_millis(1500)))
+40
View File
@@ -14,3 +14,43 @@ pub fn line<'a>(content: impl text::IntoFragment<'a>, font: Font, size: f32, col
pub fn para<'a>(content: impl text::IntoFragment<'a>, size: f32, color: Color) -> Text<'a> { pub fn para<'a>(content: impl text::IntoFragment<'a>, size: f32, color: Color) -> Text<'a> {
text(content).font(theme::BODY).size(size).color(color).line_height(1.45) text(content).font(theme::BODY).size(size).color(color).line_height(1.45)
} }
/// "47 min" or "1 h 12 min".
pub fn duration_words(d: std::time::Duration) -> String {
let mins = d.as_secs() / 60;
if mins >= 60 { format!("{} h {} min", mins / 60, mins % 60) } else { format!("{mins} min") }
}
/// "1 track", "12 tracks".
pub fn tracks_word(n: usize) -> String {
if n == 1 { "1 track".into() } else { format!("{n} tracks") }
}
/// "4.1M", "830K", "912".
pub fn compact(n: i64) -> String {
match n {
n if n >= 1_000_000 => format!("{:.1}M", n as f64 / 1e6).replace(".0M", "M"),
n if n >= 10_000 => format!("{}K", n / 1000),
n if n >= 1_000 => format!("{:.1}K", n as f64 / 1e3).replace(".0K", "K"),
n => n.to_string(),
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::time::Duration;
#[test]
fn words() {
assert_eq!(duration_words(Duration::from_secs(47 * 60 + 5)), "47 min");
assert_eq!(duration_words(Duration::from_secs(72 * 60)), "1 h 12 min");
assert_eq!(tracks_word(1), "1 track");
assert_eq!(tracks_word(12), "12 tracks");
assert_eq!(compact(4_100_000), "4.1M");
assert_eq!(compact(2_000_000), "2M");
assert_eq!(compact(830_412), "830K");
assert_eq!(compact(1_250), "1.2K");
assert_eq!(compact(912), "912");
}
}
+48
View File
@@ -0,0 +1,48 @@
//! Cover cards for albums, artists and playlists, laid out in wrapping rows.
use iced::widget::{Row, button, column, container};
use iced::{Element, Padding};
use crate::app::Message;
use crate::covers::{self, Covers};
use crate::ui::line;
use crate::ui::theme::{self, Tokens, radius, size};
/// Card width; covers are square at this size.
pub const WIDTH: f32 = 168.0;
pub struct Card {
pub title: String,
pub subtitle: String,
pub cover: Option<String>,
pub hues: (f32, f32),
/// Artists get a round cover.
pub round: bool,
pub on_press: Message,
}
pub fn view<'a>(t: &'static Tokens, covers: &Covers, card: Card) -> Element<'a, Message> {
let corner = if card.round { WIDTH / 2.0 } else { radius::COVER };
button(
column![
covers::view(covers, card.cover, card.hues, WIDTH, corner),
column![
line(card.title, theme::MEDIUM, size::BODY, t.fg),
line(card.subtitle, theme::BODY, size::META, t.muted),
]
.spacing(2)
.width(WIDTH)
.clip(true),
]
.spacing(9),
)
.padding(Padding::from(6))
.style(theme::nav_item(false))
.on_press(card.on_press)
.into()
}
/// Cards in rows that wrap to the available width.
pub fn grid<'a>(cards: impl IntoIterator<Item = Element<'a, Message>>) -> Element<'a, Message> {
container(Row::with_children(cards).spacing(12).wrap().vertical_spacing(14)).into()
}
+5 -5
View File
@@ -5,6 +5,7 @@ use ym_api::Track;
use iced::{Alignment, Element, Fill, Padding}; use iced::{Alignment, Element, Fill, Padding};
use crate::app::Message; use crate::app::Message;
use crate::covers::{self, Covers};
use crate::player::{Msg, Player, Queue}; use crate::player::{Msg, Player, Queue};
use crate::ui::icons::{Icon, icon}; use crate::ui::icons::{Icon, icon};
use crate::ui::theme::{self, Tokens, radius, shell, size}; use crate::ui::theme::{self, Tokens, radius, shell, size};
@@ -26,7 +27,7 @@ impl Panel {
} }
} }
pub fn view<'a>(t: &'static Tokens, panel: Panel, player: &'a Player) -> Element<'a, Message> { pub fn view<'a>(t: &'static Tokens, panel: Panel, player: &'a Player, covers: &Covers) -> Element<'a, Message> {
let tabs = row![tab(t, Panel::Queue, panel), tab(t, Panel::Lyrics, panel)].spacing(4); let tabs = row![tab(t, Panel::Queue, panel), tab(t, Panel::Lyrics, panel)].spacing(4);
let head = row![ let head = row![
@@ -41,7 +42,7 @@ pub fn view<'a>(t: &'static Tokens, panel: Panel, player: &'a Player) -> Element
.padding(Padding::default().top(14).bottom(8).left(18).right(14)); .padding(Padding::default().top(14).bottom(8).left(18).right(14));
let body: Element<'a, Message> = match (panel, player.queue()) { let body: Element<'a, Message> = match (panel, player.queue()) {
(Panel::Queue, Some(queue)) => queue_list(t, queue), (Panel::Queue, Some(queue)) => queue_list(t, queue, covers),
(Panel::Queue, None) => container(para( (Panel::Queue, None) => container(para(
"Nothing queued yet. Tracks you play, and the ones lined up after them, show up here.", "Nothing queued yet. Tracks you play, and the ones lined up after them, show up here.",
size::META, size::META,
@@ -68,15 +69,14 @@ pub fn view<'a>(t: &'static Tokens, panel: Panel, player: &'a Player) -> Element
/// Upcoming items shown at once; a long liked list would otherwise build thousands of rows. /// Upcoming items shown at once; a long liked list would otherwise build thousands of rows.
const SHOWN: usize = 100; const SHOWN: usize = 100;
fn queue_list<'a>(t: &'static Tokens, queue: &'a Queue<Track>) -> Element<'a, Message> { fn queue_list<'a>(t: &'static Tokens, queue: &'a Queue<Track>, covers: &Covers) -> Element<'a, Message> {
let heading = |s: String| { let heading = |s: String| {
container(line(s, theme::MEDIUM, size::SMALL, t.muted)).padding(Padding::default().top(14).bottom(8).left(8)) container(line(s, theme::MEDIUM, size::SMALL, t.muted)).padding(Padding::default().top(14).bottom(8).left(8))
}; };
let item = |track: &Track, now: bool, msg: Option<Message>| { let item = |track: &Track, now: bool, msg: Option<Message>| {
let (h1, h2) = track.hues();
button( button(
row![ row![
container(space()).width(40).height(40).style(theme::cover(h1, h2, radius::SMALL_COVER)), covers::view(covers, track.cover_url(covers::SMALL), track.hues(), 40.0, radius::SMALL_COVER),
column![ column![
line(track.full_title(), theme::MEDIUM, size::BODY, if now { t.accent } else { t.fg }), line(track.full_title(), theme::MEDIUM, size::BODY, if now { t.accent } else { t.fg }),
line(track.artist_line(), theme::BODY, size::SMALL, t.muted), line(track.artist_line(), theme::BODY, size::SMALL, t.muted),
+2
View File
@@ -1,5 +1,7 @@
pub mod card;
pub mod drawer; pub mod drawer;
pub mod player_bar; pub mod player_bar;
pub mod sidebar; pub mod sidebar;
pub mod topbar; pub mod topbar;
pub mod track_list;
pub mod track_row; pub mod track_row;
+11 -5
View File
@@ -4,6 +4,7 @@ use iced::widget::{button, column, container, row, slider, space};
use iced::{Alignment, Element, Fill, Length}; use iced::{Alignment, Element, Fill, Length};
use crate::app::Message; use crate::app::Message;
use crate::covers::{self, Covers};
use crate::player::{Msg, Player, Repeat, Status}; use crate::player::{Msg, Player, Repeat, Status};
use crate::ui::icons::{Icon, icon, sized}; use crate::ui::icons::{Icon, icon, sized};
use crate::ui::line; use crate::ui::line;
@@ -14,9 +15,15 @@ fn send(msg: Msg) -> Message {
Message::Player(msg) Message::Player(msg)
} }
pub fn view<'a>(t: &'static Tokens, p: &'a Player, liked: bool, drawer: Option<Panel>) -> Element<'a, Message> { pub fn view<'a>(
t: &'static Tokens,
p: &'a Player,
liked: bool,
drawer: Option<Panel>,
covers: &Covers,
) -> Element<'a, Message> {
row![ row![
container(now_playing(t, p, liked)).width(Length::FillPortion(2)), container(now_playing(t, p, liked, covers)).width(Length::FillPortion(2)),
container(transport(t, p)).width(Length::FillPortion(3)).center_x(Fill), container(transport(t, p)).width(Length::FillPortion(3)).center_x(Fill),
container(extras(t, p, drawer)).width(Length::FillPortion(2)).align_right(Fill), container(extras(t, p, drawer)).width(Length::FillPortion(2)).align_right(Fill),
] ]
@@ -27,7 +34,7 @@ pub fn view<'a>(t: &'static Tokens, p: &'a Player, liked: bool, drawer: Option<P
.into() .into()
} }
fn now_playing<'a>(t: &'static Tokens, p: &'a Player, liked: bool) -> Element<'a, Message> { fn now_playing<'a>(t: &'static Tokens, p: &'a Player, liked: bool, covers: &Covers) -> Element<'a, Message> {
let Some(track) = p.track() else { let Some(track) = p.track() else {
let blank = container(space()).width(52).height(52).style(move |_| container::Style { let blank = container(space()).width(52).height(52).style(move |_| container::Style {
background: Some(t.raised.into()), background: Some(t.raised.into()),
@@ -52,8 +59,7 @@ fn now_playing<'a>(t: &'static Tokens, p: &'a Player, liked: bool) -> Element<'a
.into(); .into();
}; };
let (h1, h2) = track.hues(); let cover = covers::view(covers, track.cover_url(covers::SMALL), track.hues(), 52.0, radius::CONTROL);
let cover = container(space()).width(52).height(52).style(theme::cover(h1, h2, radius::CONTROL));
// A problem with the previous track shows in place of the artist line until the next one loads. // A problem with the previous track shows in place of the artist line until the next one loads.
let (sub, sub_colour) = match (&p.notice, p.status()) { let (sub, sub_colour) = match (&p.notice, p.status()) {
+43 -12
View File
@@ -1,17 +1,24 @@
//! Left column: wordmark, main navigation, playlists and the account chip. //! Left column: wordmark, main navigation, playlists and the account chip.
use iced::widget::{Column, button, column, container, row, space}; use iced::widget::{Column, button, column, container, row, scrollable, space};
use iced::{Alignment, Element, Fill, Padding}; use iced::{Alignment, Element, Fill, Padding};
use ym_api::Account; use ym_api::{Account, LibraryPlaylists};
use crate::app::Message; use crate::app::Message;
use crate::covers::{self, Covers};
use crate::route::Route; use crate::route::Route;
use crate::ui::icons::{Icon, icon}; use crate::ui::icons::{Icon, icon};
use crate::ui::theme::{self, Tokens, shell, size}; use crate::ui::theme::{self, Tokens, radius, shell, size};
use crate::ui::{line, para}; use crate::ui::{line, para};
pub fn view<'a>(t: &'static Tokens, current: Route, me: &'a Account) -> Element<'a, Message> { pub fn view<'a>(
t: &'static Tokens,
current: Route,
me: &'a Account,
playlists: Option<&'a LibraryPlaylists>,
covers: &Covers,
) -> Element<'a, Message> {
let nav = Column::with_children(Route::NAV.map(|route| nav_item(t, route, route == current))) let nav = Column::with_children(Route::NAV.map(|route| nav_item(t, route, route == current)))
.spacing(2); .spacing(2);
@@ -25,18 +32,42 @@ pub fn view<'a>(t: &'static Tokens, current: Route, me: &'a Account) -> Element<
.align_y(Alignment::Center) .align_y(Alignment::Center)
.padding(Padding::default().left(10).right(2)); .padding(Padding::default().left(10).right(2));
let playlists = container(para( let list: Element<'a, Message> = match playlists {
"Your playlists will be listed here.", Some(p) if !p.own.is_empty() || !p.liked.is_empty() => {
size::META, let items = p.own.iter().chain(&p.liked).map(|pl| {
t.muted, let route = Route::Playlist(pl.id);
)) let active = route == current;
.padding(Padding::default().left(10).right(10)); button(
row![
covers::view(covers, pl.cover_url(covers::SMALL), pl.hues(), 30.0, radius::SMALL_COVER),
line(pl.title.clone(), theme::BODY, size::BODY, if active { t.fg } else { t.muted }),
]
.spacing(10)
.align_y(Alignment::Center),
)
.width(Fill)
.padding([5, 10])
.style(theme::nav_item(active))
.on_press(Message::Navigate(route))
.into()
});
scrollable(Column::with_children(items).spacing(1))
.height(Fill)
.style(theme::scroll)
.into()
}
Some(_) => container(para("Playlists you make or like show up here.", size::META, t.muted))
.padding(Padding::default().left(10).right(10))
.into(),
None => container(para("Loading playlists…", size::META, t.muted))
.padding(Padding::default().left(10).right(10))
.into(),
};
column![ column![
wordmark(t), wordmark(t),
nav, nav,
column![playlists_head, playlists].spacing(6), column![playlists_head, list].spacing(6).height(Fill),
space().height(Fill),
account(t, current, me), account(t, current, me),
] ]
.spacing(22) .spacing(22)
+70
View File
@@ -0,0 +1,70 @@
//! A whole track list, built once and reused (`lazy`) until something it
//! shows changes. Position ticks four times a second must not rebuild 1000 rows.
use std::sync::Arc;
use iced::widget::{Column, lazy};
use iced::Element;
use ym_api::Track;
use crate::app::Message;
use crate::covers::{self, Covers};
use crate::screens::collection::Liked;
use crate::ui::theme::{self, Tokens, radius};
use crate::widgets::track_row::{self, Columns};
/// What every list needs from app state.
#[derive(Clone, Copy)]
pub struct Env<'a> {
pub t: &'static Tokens,
pub covers: &'a Covers,
pub liked: &'a Liked,
pub playing: Option<&'a str>,
}
#[derive(Hash)]
struct Key {
/// Identity of the list contents: the slice address and length.
list: (usize, usize),
columns: Columns,
playing: Option<String>,
covers: u64,
liked: u64,
dark: bool,
}
pub fn view<'a>(env: Env<'a>, tracks: &Arc<[Track]>, columns: Columns) -> Element<'a, Message> {
let Env { t, covers, liked, playing } = env;
let key = Key {
list: (tracks.as_ptr() as usize, tracks.len()),
columns,
// Only matters when the playing track is in this list.
playing: playing.filter(|id| tracks.iter().any(|tr| tr.id == *id)).map(str::to_owned),
covers: if columns.cover { covers.version() } else { 0 },
liked: liked.version(),
dark: t == &theme::DARK,
};
let tracks = tracks.clone();
lazy(key, move |key: &Key| {
let rows = tracks.iter().enumerate().map(|(index, track)| {
let cover = columns.cover.then(|| {
covers::view(covers, track.cover_url(covers::SMALL), track.hues(), 40.0, radius::SMALL_COVER)
});
track_row::view(
t,
track_row::Row {
index,
track,
playing: key.playing.as_deref() == Some(track.id.as_str()),
liked: liked.contains(&track.id),
cover,
columns,
on_press: Message::PlayTracks { tracks: tracks.clone(), start: index, shuffle: false },
},
)
});
Column::with_children(std::iter::once(track_row::header(t, columns)).chain(rows)).spacing(2)
})
.into()
}
+69 -38
View File
@@ -5,37 +5,60 @@ use iced::widget::{button, column, container, row, space};
use iced::{Alignment, Element, Fill, Length}; use iced::{Alignment, Element, Fill, Length};
use ym_api::Track; use ym_api::Track;
use crate::app::Message;
use crate::ui::icons::{Icon, icon, sized}; use crate::ui::icons::{Icon, icon, sized};
use crate::ui::line; use crate::ui::line;
use crate::ui::theme::{self, Tokens, radius, size}; use crate::ui::theme::{self, Tokens, size};
use crate::widgets::player_bar::clock; use crate::widgets::player_bar::clock;
pub const HEIGHT: f32 = 52.0; pub const HEIGHT: f32 = 52.0;
/// Builds an owned (`'static`) row so lists can sit inside `lazy`. /// Which columns a list shows. Album pages drop the cover and album.
pub fn view<M: Clone + 'static>( #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
t: &'static Tokens, pub struct Columns {
index: usize, pub cover: bool,
track: &Track, pub album: bool,
playing: bool, }
liked: bool,
on_press: M,
) -> Element<'static, M> {
let (h1, h2) = track.hues();
let accent = |c| if playing { t.accent } else { c };
let number: Element<'static, M> = if playing { impl Columns {
pub const FULL: Columns = Columns { cover: true, album: true };
pub const ALBUM_PAGE: Columns = Columns { cover: false, album: false };
}
pub struct Row<'a> {
pub index: usize,
pub track: &'a Track,
pub playing: bool,
pub liked: bool,
pub cover: Option<Element<'static, Message>>,
pub columns: Columns,
pub on_press: Message,
}
/// Builds an owned (`'static`) row so lists can sit inside `lazy`.
pub fn view(t: &'static Tokens, r: Row<'_>) -> Element<'static, Message> {
let track = r.track;
let number: Element<'static, Message> = if r.playing {
sized(Icon::Wave, 16.0, t.accent).into() sized(Icon::Wave, 16.0, t.accent).into()
} else { } else {
line((index + 1).to_string(), theme::BODY, size::META, t.muted).into() line((r.index + 1).to_string(), theme::BODY, size::META, t.muted).into()
}; };
let unavailable = !track.available; let unavailable = !track.available;
let title_colour = if unavailable { t.muted } else { accent(t.fg) }; let title_colour = match (unavailable, r.playing) {
(true, _) => t.muted,
(false, true) => t.accent,
(false, false) => t.fg,
};
let content = row![ let mut content = row![container(number).width(36).center_x(36)]
container(number).width(36).center_x(36), .spacing(12)
container(space()).width(40).height(40).style(theme::cover(h1, h2, radius::SMALL_COVER)), .align_y(Alignment::Center)
.height(HEIGHT);
if r.columns.cover {
content = content.push(r.cover.unwrap_or_else(|| space().width(40).into()));
}
content = content.push(
column![ column![
line(track.full_title(), theme::MEDIUM, size::BODY, title_colour), line(track.full_title(), theme::MEDIUM, size::BODY, title_colour),
line(track.artist_line(), theme::BODY, size::META, t.muted), line(track.artist_line(), theme::BODY, size::META, t.muted),
@@ -43,6 +66,9 @@ pub fn view<M: Clone + 'static>(
.spacing(1) .spacing(1)
.width(Length::FillPortion(22)) .width(Length::FillPortion(22))
.clip(true), .clip(true),
);
if r.columns.album {
content = content.push(
container(line( container(line(
track.album.as_ref().map(|a| a.title.clone()).unwrap_or_default(), track.album.as_ref().map(|a| a.title.clone()).unwrap_or_default(),
theme::BODY, theme::BODY,
@@ -51,45 +77,50 @@ pub fn view<M: Clone + 'static>(
)) ))
.width(Length::FillPortion(14)) .width(Length::FillPortion(14))
.clip(true), .clip(true),
);
}
content = content
.push(
container(icon( container(icon(
if liked { Icon::HeartFilled } else { Icon::Heart }, if r.liked { Icon::HeartFilled } else { Icon::Heart },
if liked { t.like } else { t.muted.scale_alpha(0.0) }, if r.liked { t.like } else { t.muted.scale_alpha(0.0) },
)) ))
.width(34) .width(34)
.center_x(34), .center_x(34),
)
.push(
container(line(clock(track.duration.as_secs_f32()), theme::BODY, size::META, t.muted)) container(line(clock(track.duration.as_secs_f32()), theme::BODY, size::META, t.muted))
.width(52) .width(52)
.align_right(52), .align_right(52),
] );
.spacing(12)
.align_y(Alignment::Center)
.height(HEIGHT);
button(content) button(content)
.width(Fill) .width(Fill)
.padding([0, 10]) .padding([0, 10])
.style(theme::nav_item(false)) .style(theme::nav_item(false))
.on_press_maybe((!unavailable).then_some(on_press)) .on_press_maybe((!unavailable).then_some(r.on_press))
.into() .into()
} }
/// Column headings above a track list, aligned with [`view`]. /// Column headings above a track list, aligned with [`view`].
pub fn header<M: 'static>(t: &'static Tokens) -> Element<'static, M> { pub fn header(t: &'static Tokens, columns: Columns) -> Element<'static, Message> {
let label = |s: &'static str| line(s, theme::BODY, size::SMALL, t.muted); let label = |s: &'static str| line(s, theme::BODY, size::SMALL, t.muted);
column![ let mut heads = row![container(label("#")).width(36).center_x(36)]
row![
container(label("#")).width(36).center_x(36),
space().width(40),
container(label("Title")).width(Length::FillPortion(22)),
container(label("Album")).width(Length::FillPortion(14)),
space().width(34),
container(icon(Icon::Clock, t.muted)).width(52).align_right(52),
]
.spacing(12) .spacing(12)
.align_y(Alignment::Center) .align_y(Alignment::Center)
.padding([0, 10]), .padding([0, 10]);
container(space()).width(Fill).height(1).style(theme::divider), if columns.cover {
] heads = heads.push(space().width(40));
}
heads = heads.push(container(label("Title")).width(Length::FillPortion(22)));
if columns.album {
heads = heads.push(container(label("Album")).width(Length::FillPortion(14)));
}
heads = heads
.push(space().width(34))
.push(container(icon(Icon::Clock, t.muted)).width(52).align_right(52));
column![heads, container(space()).width(Fill).height(1).style(theme::divider)]
.spacing(8) .spacing(8)
.into() .into()
} }
+100
View File
@@ -1,6 +1,10 @@
use std::sync::Arc; use std::sync::Arc;
use crate::auth::Credentials; use crate::auth::Credentials;
use crate::library::{
AlbumPage, AlbumSummary, ArtistPage, ArtistSummary, LibraryPlaylists, PlaylistId, PlaylistPage,
PlaylistSummary,
};
use crate::models::{Stream, Track, best_variant}; use crate::models::{Stream, Track, best_variant};
use crate::{Error, Result}; use crate::{Error, Result};
@@ -118,6 +122,102 @@ impl YmClient {
Ok(bytes.into()) Ok(bytes.into())
} }
/// Albums the user liked, newest first, with full details.
pub async fn liked_albums(&self) -> Result<Vec<AlbumSummary>> {
let likes = self.inner.liked_albums(None).await?;
let ids: Vec<i64> = likes
.into_iter()
.filter_map(|like| like.album.and_then(|a| a.id).or_else(|| like.id.and_then(|i| i.as_number())))
.collect();
if ids.is_empty() {
return Ok(Vec::new());
}
let albums = self.inner.albums(&ids).await?;
Ok(albums.into_iter().filter_map(AlbumSummary::from_yamuse).collect())
}
pub async fn liked_artists(&self) -> Result<Vec<ArtistSummary>> {
let artists = self.inner.liked_artists(None).await?;
Ok(artists.into_iter().filter_map(ArtistSummary::from_yamuse).collect())
}
/// Playlists the user owns, and ones they liked.
pub async fn library_playlists(&self) -> Result<LibraryPlaylists> {
let own = self.inner.user_playlists_list(None).await?;
let likes = self.inner.liked_playlists(None).await?;
let liked_ids: Vec<String> = likes
.iter()
.filter_map(|like| {
let p = like.playlist.as_ref()?;
let owner = p.uid.or_else(|| p.owner.as_ref().and_then(|o| o.uid))?;
Some(format!("{owner}:{}", p.kind?))
})
.collect();
let liked = if liked_ids.is_empty() {
Vec::new()
} else {
self.inner.playlists_list(&liked_ids).await?
};
Ok(LibraryPlaylists {
own: own.iter().filter_map(PlaylistSummary::from_yamuse).collect(),
liked: liked.iter().filter_map(PlaylistSummary::from_yamuse).collect(),
})
}
pub async fn album(&self, id: i64) -> Result<AlbumPage> {
let album = self.inner.album_with_tracks(id).await?;
AlbumPage::from_yamuse(album).ok_or_else(|| Error::Api(format!("album {id} has no id")))
}
pub async fn artist(&self, id: i64) -> Result<ArtistPage> {
let brief = self.inner.artist_brief_info(id).await?;
ArtistPage::from_yamuse(brief).ok_or_else(|| Error::Api(format!("artist {id} not found")))
}
/// A playlist with all its tracks. Tracks the response didn't embed are looked up.
pub async fn playlist(&self, id: PlaylistId) -> Result<PlaylistPage> {
let raw = self.inner.user_playlist(id.kind, Some(id.owner)).await?;
let playlist = PlaylistSummary::from_yamuse(&raw)
.ok_or_else(|| Error::Api(format!("playlist {}:{} incomplete", id.owner, id.kind)))?;
let mut tracks: Vec<Option<Track>> = Vec::with_capacity(raw.tracks.len());
let mut missing = Vec::new();
for (i, short) in raw.tracks.into_iter().enumerate() {
match short.track.and_then(Track::from_yamuse) {
Some(track) => tracks.push(Some(track)),
None => {
if let Some(id) = short.id {
let id = match id {
yamuse::models::Id::Number(n) => n.to_string(),
yamuse::models::Id::Text(s) => s,
};
missing.push((i, id));
}
tracks.push(None);
}
}
}
if !missing.is_empty() {
let fetched = self.tracks(missing.iter().map(|(_, id)| id.clone()).collect()).await?;
for ((slot, _), track) in missing.iter().zip(fetched) {
tracks[*slot] = Some(track);
}
}
Ok(PlaylistPage {
playlist,
description: raw.description.filter(|d| !d.trim().is_empty()),
tracks: tracks.into_iter().flatten().collect(),
})
}
/// Downloads an image (covers are a few kilobytes).
pub async fn image(&self, url: &str) -> Result<Vec<u8>> {
Ok(yamuse::download::Downloader::new(self.inner.transport(), [url.to_owned()])
.to_bytes()
.await?)
}
/// Re-reads the account, e.g. after a subscription may have changed. /// Re-reads the account, e.g. after a subscription may have changed.
pub async fn account(&self) -> Result<Account> { pub async fn account(&self) -> Result<Account> {
let status = self.inner.refresh_account().await?; let status = self.inner.refresh_account().await?;
+5
View File
@@ -6,8 +6,13 @@
pub mod auth; pub mod auth;
mod client; mod client;
mod error; mod error;
mod library;
mod models; mod models;
pub use client::{Account, YmClient}; pub use client::{Account, YmClient};
pub use library::{
AlbumKind, AlbumPage, AlbumSummary, ArtistPage, ArtistSummary, LibraryPlaylists, PlaylistId,
PlaylistPage, PlaylistSummary,
};
pub use models::{AlbumRef, ArtistRef, Stream, Track}; pub use models::{AlbumRef, ArtistRef, Stream, Track};
pub use error::{Error, Result}; pub use error::{Error, Result};
+329
View File
@@ -0,0 +1,329 @@
//! Albums, artists and playlists, as cards and as full pages.
use std::time::Duration;
use yamuse::models as y;
use crate::models::{ArtistRef, Track, cover_url, hues_for};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AlbumKind {
Album,
Single,
Compilation,
Podcast,
Audiobook,
}
impl AlbumKind {
fn from_api(meta_type: Option<&str>, kind: Option<&str>) -> Self {
match (meta_type, kind) {
(Some("podcast"), _) | (_, Some("podcast")) => AlbumKind::Podcast,
(_, Some("audiobook")) | (Some("audiobook"), _) => AlbumKind::Audiobook,
(_, Some("single")) => AlbumKind::Single,
(_, Some("compilation")) => AlbumKind::Compilation,
_ => AlbumKind::Album,
}
}
pub fn label(self) -> &'static str {
match self {
AlbumKind::Album => "Album",
AlbumKind::Single => "Single",
AlbumKind::Compilation => "Compilation",
AlbumKind::Podcast => "Podcast",
AlbumKind::Audiobook => "Audiobook",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AlbumSummary {
pub id: i64,
pub title: String,
pub version: Option<String>,
pub artists: Vec<ArtistRef>,
pub year: Option<i32>,
pub track_count: u32,
pub kind: AlbumKind,
cover_uri: Option<String>,
}
impl AlbumSummary {
pub(crate) fn from_yamuse(a: y::Album) -> Option<Self> {
Some(Self {
id: a.id?,
title: a.title.unwrap_or_else(|| "Untitled".into()),
version: a.version.filter(|v| !v.trim().is_empty()),
artists: artist_refs(a.artists),
year: a.year.and_then(|y| i32::try_from(y).ok()),
track_count: a.track_count.unwrap_or(0).max(0) as u32,
kind: AlbumKind::from_api(a.meta_type.as_deref(), a.r#type.as_deref()),
cover_uri: a.cover_uri.or_else(|| a.cover.and_then(|c| c.uri)),
})
}
pub fn full_title(&self) -> String {
match &self.version {
Some(v) => format!("{} ({v})", self.title),
None => self.title.clone(),
}
}
pub fn artist_line(&self) -> String {
join_names(&self.artists)
}
/// "Кино · 1988", the line under a card.
pub fn subtitle(&self) -> String {
match self.year {
Some(year) => format!("{} · {year}", self.artist_line()),
None => self.artist_line(),
}
}
pub fn cover_url(&self, size: u32) -> Option<String> {
cover_url(self.cover_uri.as_deref(), size)
}
pub fn hues(&self) -> (f32, f32) {
hues_for(self.id as u64)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ArtistSummary {
pub id: i64,
pub name: String,
pub genres: Vec<String>,
pub likes: Option<i64>,
cover_uri: Option<String>,
}
impl ArtistSummary {
pub(crate) fn from_yamuse(a: y::Artist) -> Option<Self> {
Some(Self {
id: a.id.and_then(|i| i.as_number())?,
name: a.name.unwrap_or_else(|| "Unknown artist".into()),
genres: a.genres,
likes: a.likes_count,
cover_uri: a.cover.and_then(|c| c.uri).or(a.og_image),
})
}
pub fn cover_url(&self, size: u32) -> Option<String> {
cover_url(self.cover_uri.as_deref(), size)
}
pub fn hues(&self) -> (f32, f32) {
hues_for(self.id as u64 ^ 0x5bd1_e995)
}
}
/// A playlist is addressed by its owner and a per-owner number ("kind").
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct PlaylistId {
pub owner: i64,
pub kind: i64,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PlaylistSummary {
pub id: PlaylistId,
pub title: String,
pub owner_name: String,
pub track_count: u32,
pub duration: Duration,
pub public: bool,
cover_uri: Option<String>,
}
impl PlaylistSummary {
pub(crate) fn from_yamuse(p: &y::Playlist) -> Option<Self> {
let owner = p.owner.as_ref();
let id = PlaylistId { owner: p.uid.or_else(|| owner.and_then(|o| o.uid))?, kind: p.kind? };
let cover = p.cover.as_ref().and_then(|c| c.uri.clone().or_else(|| c.items_uri.first().cloned()));
Some(Self {
id,
title: p.title.clone().unwrap_or_else(|| "Untitled playlist".into()),
owner_name: owner
.and_then(|o| o.name.clone().or_else(|| o.login.clone()))
.unwrap_or_default(),
track_count: p.track_count.unwrap_or(0).max(0) as u32,
duration: Duration::from_millis(p.duration_ms.unwrap_or(0).max(0) as u64),
public: p.visibility.as_deref() == Some("public"),
cover_uri: cover.or_else(|| p.og_image.clone()),
})
}
pub fn cover_url(&self, size: u32) -> Option<String> {
cover_url(self.cover_uri.as_deref(), size)
}
pub fn hues(&self) -> (f32, f32) {
hues_for((self.id.owner as u64).wrapping_mul(1_000_003) ^ self.id.kind as u64)
}
pub fn subtitle(&self) -> String {
let count = match self.track_count {
1 => "1 track".to_owned(),
n => format!("{n} tracks"),
};
if self.owner_name.is_empty() { count } else { format!("{} · {count}", self.owner_name) }
}
}
/// The user's playlists for the sidebar and Collection.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct LibraryPlaylists {
pub own: Vec<PlaylistSummary>,
pub liked: Vec<PlaylistSummary>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AlbumPage {
pub album: AlbumSummary,
pub tracks: Vec<Track>,
pub release_date: Option<String>,
pub label: Option<String>,
pub likes: Option<i64>,
}
impl AlbumPage {
pub(crate) fn from_yamuse(a: y::Album) -> Option<Self> {
let tracks = a
.volumes
.iter()
.flatten()
.cloned()
.filter_map(Track::from_yamuse)
.collect();
let release_date = a.release_date.clone();
let label = a.labels.first().and_then(|l| l.name()).map(str::to_owned);
let likes = a.likes_count;
Some(Self { album: AlbumSummary::from_yamuse(a)?, tracks, release_date, label, likes })
}
pub fn duration(&self) -> Duration {
self.tracks.iter().map(|t| t.duration).sum()
}
/// Decodes an album (with `volumes`) from the API's JSON, e.g. a recorded fixture.
pub fn from_json(json: &str) -> crate::Result<Self> {
let raw = serde_json::from_str(json).map_err(|e| crate::Error::Api(e.to_string()))?;
Self::from_yamuse(raw).ok_or_else(|| crate::Error::Api("album has no id".into()))
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ArtistPage {
pub artist: ArtistSummary,
pub popular: Vec<Track>,
pub albums: Vec<AlbumSummary>,
/// Compilations and features the artist appears on.
pub also_albums: Vec<AlbumSummary>,
pub similar: Vec<ArtistSummary>,
pub monthly_listeners: Option<i64>,
}
impl ArtistPage {
pub(crate) fn from_yamuse(b: y::BriefInfo) -> Option<Self> {
let monthly_listeners = b.stats.as_ref().and_then(|s| s.last_month_listeners);
Some(Self {
artist: ArtistSummary::from_yamuse(b.artist?)?,
popular: b.popular_tracks.into_iter().filter_map(Track::from_yamuse).collect(),
albums: b.albums.into_iter().filter_map(AlbumSummary::from_yamuse).collect(),
also_albums: b.also_albums.into_iter().filter_map(AlbumSummary::from_yamuse).collect(),
similar: b.similar_artists.into_iter().filter_map(ArtistSummary::from_yamuse).collect(),
monthly_listeners,
})
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PlaylistPage {
pub playlist: PlaylistSummary,
pub description: Option<String>,
pub tracks: Vec<Track>,
}
fn artist_refs(artists: Vec<y::Artist>) -> Vec<ArtistRef> {
artists
.into_iter()
.filter_map(|a| Some(ArtistRef { id: a.id.and_then(|i| i.as_number()), name: a.name? }))
.collect()
}
pub(crate) fn join_names(artists: &[ArtistRef]) -> String {
if artists.is_empty() {
return "Unknown artist".into();
}
artists.iter().map(|a| a.name.as_str()).collect::<Vec<_>>().join(", ")
}
#[cfg(test)]
mod tests {
use super::*;
fn album(json: &str) -> y::Album {
serde_json::from_str(json).unwrap()
}
#[test]
fn album_page_flattens_volumes() {
let page = AlbumPage::from_yamuse(album(
r#"{"id":5,"title":"Группа крови","year":1988,"type":"","artists":[{"id":1,"name":"Кино"}],
"coverUri":"a/%%","labels":[{"name":"Мелодия"}],
"volumes":[[{"id":1,"title":"A","durationMs":1000}],[{"id":2,"title":"B","durationMs":2000}]]}"#,
))
.unwrap();
assert_eq!(page.tracks.len(), 2);
assert_eq!(page.duration(), Duration::from_secs(3));
assert_eq!(page.album.subtitle(), "Кино · 1988");
assert_eq!(page.album.kind, AlbumKind::Album);
assert_eq!(page.label.as_deref(), Some("Мелодия"));
assert_eq!(page.album.cover_url(100).as_deref(), Some("https://a/100x100"));
}
#[test]
fn album_kinds() {
assert_eq!(AlbumKind::from_api(None, Some("single")), AlbumKind::Single);
assert_eq!(AlbumKind::from_api(Some("podcast"), None), AlbumKind::Podcast);
assert_eq!(AlbumKind::from_api(None, Some("audiobook")), AlbumKind::Audiobook);
assert_eq!(AlbumKind::from_api(Some("music"), None), AlbumKind::Album);
}
#[test]
fn playlist_needs_owner_and_kind_and_uses_mosaic_cover() {
let p: y::Playlist = serde_json::from_str(
r#"{"owner":{"uid":9,"name":"Юрий"},"kind":1003,"title":"Дорога","trackCount":14,
"visibility":"private","cover":{"type":"mosaic","itemsUri":["m/%%"]}}"#,
)
.unwrap();
let s = PlaylistSummary::from_yamuse(&p).unwrap();
assert_eq!(s.id, PlaylistId { owner: 9, kind: 1003 });
assert!(!s.public);
assert_eq!(s.subtitle(), "Юрий · 14 tracks");
assert_eq!(s.cover_url(200).as_deref(), Some("https://m/200x200"));
let orphan: y::Playlist = serde_json::from_str(r#"{"title":"x"}"#).unwrap();
assert!(PlaylistSummary::from_yamuse(&orphan).is_none());
}
#[test]
fn artist_page_from_brief_info() {
let b: y::BriefInfo = serde_json::from_str(
r#"{"artist":{"id":3,"name":"Земфира","genres":["rock"],"cover":{"uri":"z/%%"}},
"popularTracks":[{"id":10,"title":"Хочешь?"}],
"albums":[{"id":20,"title":"Вендетта","year":2005}],
"similarArtists":[{"id":4,"name":"Сплин"}],
"stats":{"lastMonthListeners":4100000}}"#,
)
.unwrap();
let page = ArtistPage::from_yamuse(b).unwrap();
assert_eq!(page.artist.name, "Земфира");
assert_eq!(page.popular.len(), 1);
assert_eq!(page.albums[0].year, Some(2005));
assert_eq!(page.similar[0].name, "Сплин");
assert_eq!(page.monthly_listeners, Some(4_100_000));
}
}
+15 -9
View File
@@ -72,10 +72,7 @@ impl Track {
/// "Artist A, Artist B", or "Unknown artist". /// "Artist A, Artist B", or "Unknown artist".
pub fn artist_line(&self) -> String { pub fn artist_line(&self) -> String {
if self.artists.is_empty() { crate::library::join_names(&self.artists)
return "Unknown artist".into();
}
self.artists.iter().map(|a| a.name.as_str()).collect::<Vec<_>>().join(", ")
} }
/// Title with its version: "Song (Live)". /// Title with its version: "Song (Live)".
@@ -88,20 +85,29 @@ impl Track {
/// Absolute cover URL at `size`×`size` pixels. /// Absolute cover URL at `size`×`size` pixels.
pub fn cover_url(&self, size: u32) -> Option<String> { pub fn cover_url(&self, size: u32) -> Option<String> {
let uri = self.cover_uri.as_deref()?; cover_url(self.cover_uri.as_deref(), size)
Some(yamuse::models::normalize_image_url(uri, &format!("{size}x{size}")))
} }
/// Two stable hues for placeholder art, derived from the album (or track) id. /// Two stable hues for placeholder art, derived from the album (or track) id.
pub fn hues(&self) -> (f32, f32) { pub fn hues(&self) -> (f32, f32) {
let seed = self.album.as_ref().map_or_else( hues_for(self.album.as_ref().map_or_else(
|| self.id.bytes().fold(7u64, |h, b| h.wrapping_mul(31).wrapping_add(u64::from(b))), || self.id.bytes().fold(7u64, |h, b| h.wrapping_mul(31).wrapping_add(u64::from(b))),
|a| a.id as u64, |a| a.id as u64,
); ))
((seed.wrapping_mul(47) % 360) as f32, (seed.wrapping_mul(131).wrapping_add(90) % 360) as f32)
} }
} }
/// Absolute URL for a `%%`-templated image uri at `size`×`size` pixels.
pub(crate) fn cover_url(uri: Option<&str>, size: u32) -> Option<String> {
let uri = uri.filter(|u| !u.is_empty())?;
Some(yamuse::models::normalize_image_url(uri, &format!("{size}x{size}")))
}
/// Two hues for placeholder art; equal seeds give equal art.
pub(crate) fn hues_for(seed: u64) -> (f32, f32) {
((seed.wrapping_mul(47) % 360) as f32, (seed.wrapping_mul(131).wrapping_add(90) % 360) as f32)
}
/// Where a track's audio comes from. /// Where a track's audio comes from.
#[derive(Debug, Clone, PartialEq, Eq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub struct Stream { pub struct Stream {