diff --git a/README.md b/README.md
index 42a58aa..4f976b9 100644
--- a/README.md
+++ b/README.md
@@ -47,6 +47,11 @@ MUSYX_SNAPSHOT=design/shots/home.png MUSYX_SNAPSHOT_ROUTE=home MUSYX_SNAPSHOT_TH
`MUSYX_SNAPSHOT_ROUTE` takes home, wave, search, collection, podcasts, settings or signin. Every
route except signin renders with a sample signed-in account, so no network or keychain is needed.
`MUSYX_SNAPSHOT_DRAWER` takes queue or lyrics. `MUSYX_SNAPSHOT_THEME` takes light or dark.
+`MUSYX_SNAPSHOT_LIVE=1` signs in with the account stored in the keychain instead of using sample
+data. Set `MUSYX_SNAPSHOT_DELAY` (ms) to wait longer for slow pages.
+
+`cargo run -p musyx --example api_probe` calls the discovery endpoints with the stored account
+(read-only) and prints what came back.
### Audio
diff --git a/crates/musyx/Cargo.toml b/crates/musyx/Cargo.toml
index fb4eee0..a5807a8 100644
--- a/crates/musyx/Cargo.toml
+++ b/crates/musyx/Cargo.toml
@@ -18,6 +18,9 @@ tokio = { version = "1", features = ["time", "rt", "fs", "sync"] }
directories = "6.0.0"
png = { version = "0.18.1", optional = true }
+[dev-dependencies]
+tokio = { version = "1", features = ["macros", "rt"] }
+
[features]
# `MUSYX_SNAPSHOT=out.png cargo run --features snapshot` renders one screen to a PNG and exits.
snapshot = ["dep:png"]
diff --git a/crates/musyx/assets/icons/chevron-right.svg b/crates/musyx/assets/icons/chevron-right.svg
new file mode 100644
index 0000000..54f2be6
--- /dev/null
+++ b/crates/musyx/assets/icons/chevron-right.svg
@@ -0,0 +1,15 @@
+
+
diff --git a/crates/musyx/assets/icons/trending-up.svg b/crates/musyx/assets/icons/trending-up.svg
new file mode 100644
index 0000000..6ee61e2
--- /dev/null
+++ b/crates/musyx/assets/icons/trending-up.svg
@@ -0,0 +1,16 @@
+
+
diff --git a/crates/musyx/examples/api_probe.rs b/crates/musyx/examples/api_probe.rs
new file mode 100644
index 0000000..213cda3
--- /dev/null
+++ b/crates/musyx/examples/api_probe.rs
@@ -0,0 +1,54 @@
+//! Read-only check of the discovery endpoints with the signed-in account:
+//! `cargo run -p musyx --example api_probe`. Prints counts and a few titles.
+use ym_api::auth::Credentials;
+use ym_api::{SearchKind, YmClient};
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() {
+ let raw = keyring::Entry::new("musyx", "yandex-music")
+ .and_then(|e| e.get_password())
+ .expect("sign in with Musyx first");
+ let credentials: Credentials = serde_json::from_str(&raw).expect("stored credentials");
+ let (client, account) = YmClient::connect(&credentials).await.expect("connect");
+ println!("account: {} (plus: {})", account.login, account.has_plus);
+
+ match client.home().await {
+ Ok(h) => println!(
+ "home: {} personal {:?}, {} chart, {} new releases, {} new playlists",
+ h.personal.len(),
+ h.personal.iter().map(|p| p.playlist.title.as_str()).collect::>(),
+ h.chart.len(),
+ h.new_releases.len(),
+ h.new_playlists.len()
+ ),
+ Err(e) => println!("home: ERROR {e}"),
+ }
+ match client.genres().await {
+ Ok(g) => {
+ println!("genres: {} {:?}", g.len(), g.iter().take(8).map(|g| (&g.id, &g.title)).collect::>());
+ for genre in g.iter().skip(1).take(4) {
+ match client.tag_playlists(&genre.id).await {
+ Ok(p) => println!("tag {}: {} playlists {:?}", genre.id, p.len(), p.iter().take(2).map(|p| &p.title).collect::>()),
+ Err(e) => println!("tag {}: ERROR {e}", genre.id),
+ }
+ }
+ }
+ Err(e) => println!("genres: ERROR {e}"),
+ }
+ match client.featured_podcasts().await {
+ Ok(p) => println!("podcasts: {} {:?}", p.len(), p.iter().take(3).map(|a| &a.title).collect::>()),
+ Err(e) => println!("podcasts: ERROR {e}"),
+ }
+ match client.search("земфира", SearchKind::All, 0).await {
+ Ok(r) => println!(
+ "search: best {:?}, {} tracks ({}), {} albums, {} artists, {} playlists, {} podcasts",
+ r.best.as_ref().map(|b| format!("{b:?}").chars().take(60).collect::()),
+ r.tracks.len(), r.totals.tracks, r.albums.len(), r.artists.len(), r.playlists.len(), r.podcasts.len()
+ ),
+ Err(e) => println!("search: ERROR {e}"),
+ }
+ match client.suggest("зем").await {
+ Ok(s) => println!("suggest: {:?}", s.iter().take(5).collect::>()),
+ Err(e) => println!("suggest: ERROR {e}"),
+ }
+}
diff --git a/crates/musyx/src/app.rs b/crates/musyx/src/app.rs
index 40f095b..b3cf849 100644
--- a/crates/musyx/src/app.rs
+++ b/crates/musyx/src/app.rs
@@ -4,15 +4,20 @@ use std::collections::HashMap;
use std::sync::Arc;
use iced::theme::Mode;
-use iced::widget::{column, container, row, scrollable, space};
+use iced::widget::{column, container, row, scrollable, space, stack};
use iced::{Element, Fill, Subscription, Task, Theme};
use ym_api::auth::Credentials;
-use ym_api::{Account, AlbumSummary, ArtistSummary, Error, LibraryPlaylists, Track, YmClient};
+use ym_api::{
+ Account, AlbumSummary, ArtistSummary, Error, Genre, Home, LibraryPlaylists, PlaylistSummary, Track,
+ YmClient,
+};
use crate::covers::Covers;
use crate::player::{self, Audio, Effect, Player};
use crate::route::{Navigator, Route};
+use crate::screens::browse::{self, Discover, HomeData};
use crate::screens::collection::{Library, Liked, Tab};
+use crate::screens::search::{self, Search};
use crate::screens::detail::{self, Page};
use crate::screens::{self, Loadable, sign_in};
use crate::session::{self, Restored};
@@ -39,13 +44,18 @@ pub struct App {
forced_mode: Option,
session: Session,
nav: Navigator,
- search: String,
+ search: Search,
drawer: Option,
player: Player,
library: Library,
/// Album, artist and playlist pages visited this session.
pages: HashMap>,
+ discover: Discover,
+ genre_playlists: HashMap>>,
covers: Covers,
+ /// A live snapshot run opens this route once signed in.
+ #[cfg(feature = "snapshot")]
+ snapshot_route: Option,
}
#[derive(Debug, Clone)]
@@ -60,8 +70,7 @@ pub enum Message {
SignedOut,
Navigate(Route),
Back,
- SearchChanged(String),
- SearchSubmitted,
+ Search(search::Msg),
ToggleDrawer(Panel),
CloseDrawer,
Player(player::Msg),
@@ -74,6 +83,13 @@ pub enum Message {
ArtistsLoaded(Result, Error>),
PlaylistsLoaded(Result),
PageLoaded(Route, Result),
+ LoadHome,
+ HomeLoaded(Result),
+ LoadGenres,
+ GenresLoaded(Result, Error>),
+ GenreLoaded(usize, Result, Error>),
+ LoadPodcasts,
+ PodcastsLoaded(Result, Error>),
CoverWanted(String),
CoverLoaded(String, Option>),
CoversTick,
@@ -86,29 +102,37 @@ impl App {
forced_mode: None,
session: Session::Restoring,
nav: Navigator::new(Route::Home),
- search: String::new(),
+ search: Search::default(),
drawer: None,
player: Player::default(),
library: Library::default(),
pages: HashMap::new(),
+ discover: Discover::default(),
+ genre_playlists: HashMap::new(),
covers: Covers::default(),
+ #[cfg(feature = "snapshot")]
+ snapshot_route: None,
};
let appearance = iced::system::theme().map(Message::ThemeChanged);
#[cfg(feature = "snapshot")]
if let Some(config) = crate::snapshot::Config::from_env() {
let mut app = app;
+ app.drawer = config.drawer;
+ app.forced_mode = config.mode;
+ if let Some(mode) = config.mode {
+ app.theme = theme::for_mode(mode);
+ }
+ if config.live {
+ app.snapshot_route = config.route;
+ return (app, Task::batch([appearance, restore(), config.capture()]));
+ }
app.session = config.session();
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);
}
- app.drawer = config.drawer;
- app.forced_mode = config.mode;
- if let Some(mode) = config.mode {
- app.theme = theme::for_mode(mode);
- }
return (app, Task::batch([appearance, config.capture()]));
}
@@ -158,8 +182,19 @@ impl App {
fn signed_in(&mut self, client: YmClient, account: Account) -> Task {
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))])
+ // Liked tracks drive the hearts; playlists fill the sidebar; Home is the first page.
+ #[allow(unused_mut)]
+ let mut first = Route::Home;
+ #[cfg(feature = "snapshot")]
+ if let Some(route) = self.snapshot_route {
+ self.nav = Navigator::new(route);
+ first = route;
+ }
+ Task::batch([
+ self.update(Message::LoadLiked),
+ self.update(Message::LoadLibrary(Tab::Playlists)),
+ self.on_enter(first),
+ ])
}
pub fn update(&mut self, message: Message) -> Task {
@@ -215,10 +250,14 @@ impl App {
self.player.reset();
self.library = Library::default();
self.pages.clear();
+ self.discover = Discover::default();
+ self.genre_playlists.clear();
+ self.search = Search::default();
}
Message::Navigate(route) => {
self.nav.go(route);
- return self.on_enter(route);
+ let (close, _) = self.search.update(search::Msg::CloseSuggestions, None);
+ return Task::batch([close, self.on_enter(route)]);
}
Message::AccountRefreshed(Ok(fresh)) => {
if let Session::SignedIn { account, .. } = &mut self.session {
@@ -234,8 +273,15 @@ impl App {
self.nav.back();
return self.on_enter(self.nav.current());
}
- Message::SearchChanged(query) => self.search = query,
- Message::SearchSubmitted => self.nav.go(Route::Search),
+ Message::Search(msg) => {
+ let client = self.client().cloned();
+ let (task, after) = self.search.update(msg, client.as_ref());
+ if let search::After::ShowResults = after {
+ self.nav.go(Route::Search);
+ return Task::batch([task, self.on_enter(Route::Search)]);
+ }
+ return task;
+ }
Message::ToggleDrawer(panel) => {
self.drawer = if self.drawer == Some(panel) { None } else { Some(panel) };
}
@@ -310,6 +356,54 @@ impl App {
}
self.pages.insert(route, Loadable::from_result(result));
}
+ Message::LoadHome => {
+ let Some(client) = self.client().cloned() else { return Task::none() };
+ self.discover.home = Loadable::Loading;
+ return Task::future(async move { client.home().await }).map(Message::HomeLoaded);
+ }
+ Message::HomeLoaded(result) => {
+ if let Err(e) = &result
+ && let Some(task) = self.failed("home", e)
+ {
+ return task;
+ }
+ self.discover.home = Loadable::from_result(result.map(HomeData::new));
+ }
+ Message::LoadGenres => {
+ let Some(client) = self.client().cloned() else { return Task::none() };
+ self.discover.genres = Loadable::Loading;
+ return Task::future(async move { client.genres().await }).map(Message::GenresLoaded);
+ }
+ Message::GenresLoaded(result) => {
+ if let Err(e) = &result
+ && let Some(task) = self.failed("genres", e)
+ {
+ return task;
+ }
+ self.discover.genres = Loadable::from_result(result.map(browse::flatten));
+ }
+ Message::GenreLoaded(index, result) => {
+ if let Err(e) = &result
+ && let Some(task) = self.failed("genre playlists", e)
+ {
+ return task;
+ }
+ self.genre_playlists.insert(index, Loadable::from_result(result));
+ }
+ Message::LoadPodcasts => {
+ let Some(client) = self.client().cloned() else { return Task::none() };
+ self.discover.podcasts = Loadable::Loading;
+ return Task::future(async move { client.featured_podcasts().await })
+ .map(Message::PodcastsLoaded);
+ }
+ Message::PodcastsLoaded(result) => {
+ if let Err(e) = &result
+ && let Some(task) = self.failed("podcasts", e)
+ {
+ return task;
+ }
+ self.discover.podcasts = Loadable::from_result(result);
+ }
Message::CoverWanted(url) => {
let Some(client) = self.client().cloned() else { return Task::none() };
return self.covers.want(url, &client);
@@ -335,6 +429,32 @@ impl App {
}
None => Task::none(),
},
+ Route::Home => {
+ let home = if self.discover.home.needs_load() { self.update(Message::LoadHome) } else { Task::none() };
+ Task::batch([home, self.genres_if_needed()])
+ }
+ Route::Search => self.genres_if_needed(),
+ Route::Chart if self.discover.home.needs_load() => self.update(Message::LoadHome),
+ Route::Genre(index) => {
+ if self.genre_playlists.get(&index).is_some_and(|p| !p.needs_load()) {
+ return Task::none();
+ }
+ let (Some(client), Some(genre)) = (
+ self.client().cloned(),
+ self.discover.genres.get().and_then(|g| g.get(index)).cloned(),
+ ) else {
+ return Task::none();
+ };
+ self.genre_playlists.insert(index, Loadable::Loading);
+ Task::future(async move { client.tag_playlists(&genre.id).await })
+ .map(move |r| Message::GenreLoaded(index, r))
+ }
+ Route::Podcasts => {
+ let featured =
+ if self.discover.podcasts.needs_load() { self.update(Message::LoadPodcasts) } else { Task::none() };
+ // "Yours" comes from liked albums.
+ Task::batch([featured, self.load_tab(Tab::Albums)])
+ }
Route::Album(_) | Route::Artist(_) | Route::Playlist(_) => {
if self.pages.get(&route).is_some_and(|p| !p.needs_load()) {
return Task::none();
@@ -349,6 +469,10 @@ impl App {
}
}
+ fn genres_if_needed(&mut self) -> Task {
+ if self.discover.genres.needs_load() { self.update(Message::LoadGenres) } else { Task::none() }
+ }
+
fn load_tab(&mut self, tab: Tab) -> Task {
let needed = match tab {
Tab::Tracks => matches!(self.library.liked, Liked::NotLoaded),
@@ -399,21 +523,33 @@ impl App {
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 {
- env,
- route,
- query: &self.search,
- me: account,
- library: &self.library,
- pages: &self.pages,
- }))
- .height(Fill)
- .style(theme::scroll),
- ]
- .width(Fill)
- .height(Fill);
+ let page = scrollable(screens::view(screens::Ctx {
+ env,
+ route,
+ search: &self.search,
+ me: account,
+ library: &self.library,
+ pages: &self.pages,
+ discover: &self.discover,
+ genre_playlists: &self.genre_playlists,
+ }))
+ .height(Fill)
+ .style(theme::scroll);
+
+ // Suggestions float over the page, lined up under the search field.
+ let page: Element<'a, Message> = match self.search.suggestions() {
+ Some(list) => stack![
+ page,
+ container(search::suggestions(t, list))
+ .padding(iced::Padding::default().left(theme::space::GUTTER + 44.0)),
+ ]
+ .into(),
+ None => page.into(),
+ };
+
+ let content = column![topbar::view(t, self.nav.can_go_back(), &self.search.text), page]
+ .width(Fill)
+ .height(Fill);
let mut body = row![
sidebar::view(t, route, account, self.library.playlists.get(), &self.covers),
diff --git a/crates/musyx/src/route.rs b/crates/musyx/src/route.rs
index 91b9766..629185b 100644
--- a/crates/musyx/src/route.rs
+++ b/crates/musyx/src/route.rs
@@ -16,6 +16,9 @@ pub enum Route {
Album(i64),
Artist(i64),
Playlist(PlaylistId),
+ Chart,
+ /// Index into the app's flattened genre list.
+ Genre(usize),
}
impl Route {
@@ -34,6 +37,8 @@ impl Route {
Route::Album(_) => "Album",
Route::Artist(_) => "Artist",
Route::Playlist(_) => "Playlist",
+ Route::Chart => "Chart",
+ Route::Genre(_) => "Genre",
}
}
@@ -48,6 +53,8 @@ impl Route {
Route::Album(_) => Icon::Disc,
Route::Artist(_) => Icon::Wave,
Route::Playlist(_) => Icon::Queue,
+ Route::Chart => Icon::Chart,
+ Route::Genre(_) => Icon::Library,
}
}
}
diff --git a/crates/musyx/src/screens/browse.rs b/crates/musyx/src/screens/browse.rs
new file mode 100644
index 0000000..bb23f87
--- /dev/null
+++ b/crates/musyx/src/screens/browse.rs
@@ -0,0 +1,321 @@
+//! Discovery: Home, the chart, genres and podcasts.
+
+use std::sync::Arc;
+
+use iced::widget::{Row, button, column, container, row};
+use iced::{Alignment, Color, Element, Fill};
+use ym_api::{AlbumKind, AlbumSummary, ChartEntry, Genre, Home, PlaylistSummary, Track};
+
+use super::Loadable;
+use super::collection::{LoadState, album_card, play_bar, playlist_card, section, status};
+use crate::app::Message;
+use crate::covers;
+use crate::route::Route;
+use crate::ui::theme::{self, Tokens, radius, size};
+use crate::ui::{line, para};
+use crate::widgets::card::{self, Card};
+use crate::widgets::track_list::{self, Env};
+use crate::widgets::track_row::Columns;
+
+/// Chart rows shown on Home before "Show all".
+const HOME_CHART: usize = 10;
+/// Cards per Home row.
+const HOME_CARDS: usize = 12;
+
+/// Home data with the chart split out as a playable list.
+#[derive(Debug)]
+pub struct HomeData {
+ pub home: Home,
+ pub chart: Arc<[Track]>,
+ pub shifts: Arc<[i32]>,
+ /// The first rows of the chart for Home, built once so the cached list stays valid.
+ top: Arc<[Track]>,
+ top_shifts: Arc<[i32]>,
+}
+
+impl HomeData {
+ pub fn new(mut home: Home) -> Self {
+ let entries = std::mem::take(&mut home.chart);
+ let (chart, shifts): (Vec