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",
]
[[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]]
name = "dispatch"
version = "0.2.0"
@@ -2860,6 +2881,7 @@ dependencies = [
name = "musyx"
version = "0.1.0"
dependencies = [
"directories",
"iced",
"keyring",
"open",
@@ -3496,6 +3518,12 @@ dependencies = [
"libc",
]
[[package]]
name = "option-ext"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
[[package]]
name = "orbclient"
version = "0.3.55"
@@ -4138,6 +4166,16 @@ dependencies = [
"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]]
name = "regex"
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"
open = "5.4.4"
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 }
[features]
+215 -71
View File
@@ -1,19 +1,25 @@
//! Application state, messages and the window layout.
use std::collections::HashMap;
use std::sync::Arc;
use iced::theme::Mode;
use iced::widget::{column, container, row, scrollable, space};
use iced::{Element, Fill, Subscription, Task, Theme};
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::route::{Navigator, Route};
use crate::screens::collection::Liked;
use crate::screens::{self, sign_in};
use crate::screens::collection::{Library, Liked, Tab};
use crate::screens::detail::{self, Page};
use crate::screens::{self, Loadable, sign_in};
use crate::session::{self, Restored};
use crate::ui::theme::{self, shell};
use crate::widgets::drawer::{self, Panel};
use crate::widgets::player_bar;
use crate::widgets::track_list::Env;
use crate::widgets::{sidebar, topbar};
/// Where sign-in stands. Everything but `SignedIn` takes the whole window.
@@ -36,7 +42,10 @@ pub struct App {
search: String,
drawer: Option<Panel>,
player: Player,
liked: Liked,
library: Library,
/// Album, artist and playlist pages visited this session.
pages: HashMap<Route, Loadable<Page>>,
covers: Covers,
}
#[derive(Debug, Clone)]
@@ -56,9 +65,18 @@ pub enum Message {
ToggleDrawer(Panel),
CloseDrawer,
Player(player::Msg),
PlayTracks { tracks: Arc<[Track]>, start: usize, shuffle: bool },
LoadLiked,
LikedLoaded(Result<Vec<ym_api::Track>, Error>),
PlayLiked { start: usize, shuffle: bool },
LikedLoaded(Result<Vec<Track>, Error>),
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 {
@@ -71,7 +89,9 @@ impl App {
search: String::new(),
drawer: None,
player: Player::default(),
liked: Liked::NotLoaded,
library: Library::default(),
pages: HashMap::new(),
covers: Covers::default(),
};
let appearance = iced::system::theme().map(Message::ThemeChanged);
@@ -79,7 +99,8 @@ impl App {
if let Some(config) = crate::snapshot::Config::from_env() {
let mut app = app;
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 {
app.nav = Navigator::new(route);
}
@@ -110,14 +131,35 @@ impl App {
pub fn subscription(&self) -> Subscription<Message> {
let appearance = iced::system::theme_changes().map(Message::ThemeChanged);
let audio = player::engine::subscription().map(|e| Message::Player(player::Msg::Engine(e)));
match &self.session {
Session::SignedOut(sign_in) => Subscription::batch([
appearance,
audio,
sign_in.subscription().map(Message::SignIn),
]),
_ => Subscription::batch([appearance, audio]),
let mut subs = vec![appearance, audio];
if let Session::SignedOut(sign_in) = &self.session {
subs.push(sign_in.subscription().map(Message::SignIn));
}
// 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> {
@@ -129,14 +171,11 @@ impl App {
self.session = Session::Restoring;
return restore();
}
Message::Restored(restored) => {
self.session = match restored {
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::SignedIn(client, account)) => {
return self.signed_in(client, account);
}
Message::Restored(Restored::SignedOut) => self.session = Session::SignedOut(Box::default()),
Message::Restored(Restored::Unreachable) => self.session = Session::Unreachable,
Message::SignIn(msg) => {
let Session::SignedOut(sign_in) = &mut self.session else {
return Task::none();
@@ -150,11 +189,7 @@ impl App {
}
}
}
Message::Connected(Ok((client, account))) => {
self.nav = Navigator::new(Route::Home);
self.session = Session::SignedIn { client, account };
return self.update(Message::LoadLiked);
}
Message::Connected(Ok((client, account))) => return self.signed_in(client, account),
Message::Connected(Err(e)) => {
eprintln!("sign-in: {e}");
let pasted = matches!(self.session, Session::Connecting { pasted: true });
@@ -178,31 +213,27 @@ impl App {
self.nav = Navigator::new(Route::Home);
self.drawer = None;
self.player.reset();
self.liked = Liked::NotLoaded;
self.library = Library::default();
self.pages.clear();
}
Message::Navigate(route) => {
self.nav.go(route);
if route == Route::Collection && matches!(self.liked, Liked::Failed(_)) {
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);
}
return self.on_enter(route);
}
Message::AccountRefreshed(Ok(fresh)) => {
if let Session::SignedIn { account, .. } = &mut self.session {
*account = fresh;
}
}
Message::AccountRefreshed(Err(Error::Unauthorized(e))) => {
eprintln!("token rejected: {e}");
return self.update(Message::SignOut);
Message::AccountRefreshed(Err(e)) => {
if let Some(task) = self.failed("account refresh", &e) {
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::SearchSubmitted => self.nav.go(Route::Search),
Message::ToggleDrawer(panel) => {
@@ -213,37 +244,140 @@ impl App {
let effects = self.player.update(msg);
return self.run(effects);
}
Message::LoadLiked => {
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() {
Message::PlayTracks { tracks, start, shuffle } => {
return self.update(Message::Player(player::Msg::Play {
tracks,
start,
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()
}
/// 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> {
let t = theme::tokens(&self.theme);
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> {
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![
topbar::view(t, self.nav.can_go_back(), &self.search),
scrollable(screens::view(screens::Ctx {
t,
env,
route,
query: &self.search,
me: account,
liked: &self.liked,
playing: self.player.track().map(|tr| tr.id.as_str()),
library: &self.library,
pages: &self.pages,
}))
.height(Fill)
.style(theme::scroll),
@@ -275,10 +415,15 @@ impl App {
.width(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 {
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![
@@ -287,8 +432,9 @@ impl App {
container(player_bar::view(
t,
&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.covers,
))
.height(shell::PLAYER)
.style(theme::panel),
@@ -296,12 +442,10 @@ impl App {
container(window).width(Fill).height(Fill).style(theme::app).into()
}
}
impl App {
/// Runs the player's requests against the API.
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 {
Effect::Fetch { generation, track_id } => {
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 covers;
mod player;
mod route;
mod screens;
+11
View File
@@ -1,6 +1,8 @@
//! Every place the content area can show. Detail pages (album, artist, playlist)
//! join this enum once they carry ids from the API.
use ym_api::PlaylistId;
use crate::ui::icons::Icon;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -11,6 +13,9 @@ pub enum Route {
Collection,
Podcasts,
Settings,
Album(i64),
Artist(i64),
Playlist(PlaylistId),
}
impl Route {
@@ -26,6 +31,9 @@ impl Route {
Route::Collection => "Collection",
Route::Podcasts => "Podcasts",
Route::Settings => "Settings",
Route::Album(_) => "Album",
Route::Artist(_) => "Artist",
Route::Playlist(_) => "Playlist",
}
}
@@ -37,6 +45,9 @@ impl Route {
Route::Collection => Icon::Library,
Route::Podcasts => Icon::Podcast,
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
//! you can play.
//! Collection: liked tracks, albums, artists, and playlists (own and liked).
use std::collections::HashSet;
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 ym_api::{Error, Track};
use ym_api::{AlbumSummary, ArtistSummary, Error, LibraryPlaylists, PlaylistSummary, Track};
use super::Loadable;
use crate::app::Message;
use crate::covers::{self, Covers};
use crate::route::Route;
use crate::ui::icons::{Icon, icon};
use crate::ui::theme::{self, Tokens, size};
use crate::ui::{line, para};
use crate::widgets::track_row;
use crate::ui::{duration_words, line, para, tracks_word};
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)]
pub enum Liked {
#[default]
@@ -23,7 +27,7 @@ pub enum Liked {
Loaded {
tracks: Arc<[Track]>,
ids: HashSet<String>,
/// Bumped on every reload so the cached rows rebuild.
/// Bumped on every reload so cached rows rebuild.
version: u64,
},
Failed(Error),
@@ -31,10 +35,7 @@ pub enum Liked {
impl Liked {
pub fn loaded(tracks: Vec<Track>, previous: &Liked) -> Self {
let version = match previous {
Liked::Loaded { version, .. } => version + 1,
_ => 0,
};
let version = previous.version() + 1;
let ids = tracks.iter().map(|t| t.id.clone()).collect();
Liked::Loaded { tracks: tracks.into(), ids, version }
}
@@ -49,26 +50,259 @@ impl Liked {
_ => 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(Hash)]
struct ListKey {
version: u64,
playing: Option<String>,
dark: bool,
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Tab {
#[default]
Tracks,
Albums,
Artists,
Playlists,
}
pub fn view<'a>(t: &'static Tokens, liked: &'a Liked, playing: Option<&'a str>) -> Element<'a, Message> {
let title = line("Collection", theme::DISPLAY, size::DISPLAY_S, t.fg);
impl Tab {
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::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(
match err {
Error::Network(_) => "Couldn't load your liked tracks. Check your connection and try again.",
_ => "Couldn't load your liked tracks. Try again in a moment.",
match e {
Error::Network(_) => {
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,
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))
.padding([11, 18])
.style(theme::primary)
.on_press(Message::LoadLiked),
.on_press(retry),
]
.spacing(16)
.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> {
let count = liked.tracks().map_or(0, |t| t.len());
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()
fn empty<'a>(t: &'static Tokens, text: &'static str) -> Element<'a, Message> {
para(text, size::BODY, t.muted).into()
}
#[cfg(test)]
@@ -147,11 +333,9 @@ mod tests {
fn reload_bumps_version_and_indexes_ids() {
let first = Liked::loaded(vec![track("1"), track("2")], &Liked::Loading);
assert!(first.contains("2") && !first.contains("3"));
assert_eq!(first.version(), 1);
let second = Liked::loaded(vec![track("3")], &first);
match second {
Liked::Loaded { version, .. } => assert_eq!(version, 1),
_ => unreachable!(),
}
assert_eq!(second.version(), 2);
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.
pub mod collection;
pub mod detail;
pub mod sign_in;
use iced::widget::{Column, button, column, container, row, space};
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::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::{line, para};
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.
pub struct Ctx<'a> {
pub t: &'static Tokens,
pub env: Env<'a>,
pub route: Route,
pub query: &'a str,
pub me: &'a Account,
pub liked: &'a collection::Liked,
pub playing: Option<&'a str>,
pub library: &'a collection::Library,
pub pages: &'a HashMap<Route, Loadable<detail::Page>>,
}
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 {
Route::Home => column![
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."),
],
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![
title(t, "Podcasts and books"),
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,
"podcasts" => Route::Podcasts,
"settings" => Route::Settings,
"album" => Route::Album(1),
_ => return None,
})
});
@@ -97,6 +98,28 @@ impl Config {
.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.
pub fn capture<M: Send + 'static>(self) -> Task<M> {
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> {
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 crate::app::Message;
use crate::covers::{self, Covers};
use crate::player::{Msg, Player, Queue};
use crate::ui::icons::{Icon, icon};
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 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));
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(
"Nothing queued yet. Tracks you play, and the ones lined up after them, show up here.",
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.
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| {
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 (h1, h2) = track.hues();
button(
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![
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),
+2
View File
@@ -1,5 +1,7 @@
pub mod card;
pub mod drawer;
pub mod player_bar;
pub mod sidebar;
pub mod topbar;
pub mod track_list;
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 crate::app::Message;
use crate::covers::{self, Covers};
use crate::player::{Msg, Player, Repeat, Status};
use crate::ui::icons::{Icon, icon, sized};
use crate::ui::line;
@@ -14,9 +15,15 @@ fn send(msg: Msg) -> Message {
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![
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(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()
}
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 blank = container(space()).width(52).height(52).style(move |_| container::Style {
background: Some(t.raised.into()),
@@ -52,8 +59,7 @@ fn now_playing<'a>(t: &'static Tokens, p: &'a Player, liked: bool) -> Element<'a
.into();
};
let (h1, h2) = track.hues();
let cover = container(space()).width(52).height(52).style(theme::cover(h1, h2, radius::CONTROL));
let cover = covers::view(covers, track.cover_url(covers::SMALL), track.hues(), 52.0, radius::CONTROL);
// 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()) {
+43 -12
View File
@@ -1,17 +1,24 @@
//! 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 ym_api::Account;
use ym_api::{Account, LibraryPlaylists};
use crate::app::Message;
use crate::covers::{self, Covers};
use crate::route::Route;
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};
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)))
.spacing(2);
@@ -25,18 +32,42 @@ pub fn view<'a>(t: &'static Tokens, current: Route, me: &'a Account) -> Element<
.align_y(Alignment::Center)
.padding(Padding::default().left(10).right(2));
let playlists = container(para(
"Your playlists will be listed here.",
size::META,
t.muted,
))
.padding(Padding::default().left(10).right(10));
let list: Element<'a, Message> = match playlists {
Some(p) if !p.own.is_empty() || !p.liked.is_empty() => {
let items = p.own.iter().chain(&p.liked).map(|pl| {
let route = Route::Playlist(pl.id);
let active = route == current;
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![
wordmark(t),
nav,
column![playlists_head, playlists].spacing(6),
space().height(Fill),
column![playlists_head, list].spacing(6).height(Fill),
account(t, current, me),
]
.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 ym_api::Track;
use crate::app::Message;
use crate::ui::icons::{Icon, icon, sized};
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;
pub const HEIGHT: f32 = 52.0;
/// Builds an owned (`'static`) row so lists can sit inside `lazy`.
pub fn view<M: Clone + 'static>(
t: &'static Tokens,
index: usize,
track: &Track,
playing: bool,
liked: bool,
on_press: M,
) -> Element<'static, M> {
let (h1, h2) = track.hues();
let accent = |c| if playing { t.accent } else { c };
/// Which columns a list shows. Album pages drop the cover and album.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Columns {
pub cover: bool,
pub album: bool,
}
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()
} 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 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![
container(number).width(36).center_x(36),
container(space()).width(40).height(40).style(theme::cover(h1, h2, radius::SMALL_COVER)),
let mut content = row![container(number).width(36).center_x(36)]
.spacing(12)
.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![
line(track.full_title(), theme::MEDIUM, size::BODY, title_colour),
line(track.artist_line(), theme::BODY, size::META, t.muted),
@@ -43,6 +66,9 @@ pub fn view<M: Clone + 'static>(
.spacing(1)
.width(Length::FillPortion(22))
.clip(true),
);
if r.columns.album {
content = content.push(
container(line(
track.album.as_ref().map(|a| a.title.clone()).unwrap_or_default(),
theme::BODY,
@@ -51,45 +77,50 @@ pub fn view<M: Clone + 'static>(
))
.width(Length::FillPortion(14))
.clip(true),
);
}
content = content
.push(
container(icon(
if liked { Icon::HeartFilled } else { Icon::Heart },
if liked { t.like } else { t.muted.scale_alpha(0.0) },
if r.liked { Icon::HeartFilled } else { Icon::Heart },
if r.liked { t.like } else { t.muted.scale_alpha(0.0) },
))
.width(34)
.center_x(34),
)
.push(
container(line(clock(track.duration.as_secs_f32()), theme::BODY, size::META, t.muted))
.width(52)
.align_right(52),
]
.spacing(12)
.align_y(Alignment::Center)
.height(HEIGHT);
);
button(content)
.width(Fill)
.padding([0, 10])
.style(theme::nav_item(false))
.on_press_maybe((!unavailable).then_some(on_press))
.on_press_maybe((!unavailable).then_some(r.on_press))
.into()
}
/// 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);
column![
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),
]
let mut heads = row![container(label("#")).width(36).center_x(36)]
.spacing(12)
.align_y(Alignment::Center)
.padding([0, 10]),
container(space()).width(Fill).height(1).style(theme::divider),
]
.padding([0, 10]);
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)
.into()
}
+100
View File
@@ -1,6 +1,10 @@
use std::sync::Arc;
use crate::auth::Credentials;
use crate::library::{
AlbumPage, AlbumSummary, ArtistPage, ArtistSummary, LibraryPlaylists, PlaylistId, PlaylistPage,
PlaylistSummary,
};
use crate::models::{Stream, Track, best_variant};
use crate::{Error, Result};
@@ -118,6 +122,102 @@ impl YmClient {
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.
pub async fn account(&self) -> Result<Account> {
let status = self.inner.refresh_account().await?;
+5
View File
@@ -6,8 +6,13 @@
pub mod auth;
mod client;
mod error;
mod library;
mod models;
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 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".
pub fn artist_line(&self) -> String {
if self.artists.is_empty() {
return "Unknown artist".into();
}
self.artists.iter().map(|a| a.name.as_str()).collect::<Vec<_>>().join(", ")
crate::library::join_names(&self.artists)
}
/// Title with its version: "Song (Live)".
@@ -88,20 +85,29 @@ impl Track {
/// Absolute cover URL at `size`×`size` pixels.
pub fn cover_url(&self, size: u32) -> Option<String> {
let uri = self.cover_uri.as_deref()?;
Some(yamuse::models::normalize_image_url(uri, &format!("{size}x{size}")))
cover_url(self.cover_uri.as_deref(), size)
}
/// Two stable hues for placeholder art, derived from the album (or track) id.
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))),
|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.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Stream {