feat: playback of liked tracks with audio engine, queue and player bar

- ym-api: Track/Stream models, liked tracks, signed download URLs (full MP3
  over AAC over previews, highest bitrate) and in-memory fetch
- Audio thread on rodio, driven by commands and reporting through an iced
  subscription; generation ids drop stale events
- Opens the default output with a buffer clamped to the device's range:
  rodio's 2048-frame default fails on Bluetooth headphones that cap at 1024
- Queue with shuffle, repeat off/all/one, back/advance and jump; player
  state machine with prefetch of the next track, replay from memory, and
  skipping unplayable tracks (stops after three in a row)
- Working player bar (seek, volume, mute, quality badge), queue drawer,
  Collection screen with a lazily built liked-tracks list
- audio_probe example lists and test-opens output devices
This commit is contained in:
Yuriy Panov committed 2026-10-15 14:38:33 +06:00
1 parent 43e8f86a5d
commit b73af1f870
20 files changed
+2141 -202

No files matched your search

+3 -1
View File
@@ -8,8 +8,10 @@ publish.workspace = true
[dependencies]
ym-api = { path = "../ym-api" }
iced = { version = "0.14.0", features = ["svg", "image", "tokio", "advanced", "qr_code"] }
iced = { version = "0.14.0", features = ["svg", "image", "tokio", "advanced", "qr_code", "lazy"] }
keyring = "4.2.0"
rodio = { version = "0.23.0", default-features = false, features = ["playback", "mp3", "mp4", "flac"] }
rand = "0.9"
open = "5.4.4"
serde_json = "1"
tokio = { version = "1", features = ["time", "rt"] }
+23
View File
@@ -0,0 +1,23 @@
//! Lists output devices and tries to open each one: `cargo run -p musyx --example audio_probe`.
use rodio::DeviceSinkBuilder;
use rodio::cpal::traits::{DeviceTrait, HostTrait};
fn main() {
let host = rodio::cpal::default_host();
let default = host.default_output_device();
println!("default: {:?}", default.as_ref().and_then(|d| d.description().ok()).map(|d| d.name().to_string()));
for device in host.output_devices().expect("devices") {
let name = device.description().map(|d| d.name().to_string()).unwrap_or_default();
let config = device.default_output_config();
println!("\n{name}\n default config: {config:?}");
match DeviceSinkBuilder::from_device(device.clone()).map(|b| b.open_stream()) {
Ok(Ok(_)) => println!(" open (rodio defaults): ok"),
Ok(Err(e)) => println!(" open (rodio defaults): {e:?}"),
Err(e) => println!(" builder: {e:?}"),
}
if let Ok(config) = config {
let r = DeviceSinkBuilder::default().with_device(device.clone()).with_supported_config(&config).open_stream();
println!(" open (device default buffer): {:?}", r.map(|_| "ok"));
}
}
}
+101 -13
View File
@@ -6,12 +6,14 @@ use iced::{Element, Fill, Subscription, Task, Theme};
use ym_api::auth::Credentials;
use ym_api::{Account, Error, YmClient};
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::session::{self, Restored};
use crate::ui::theme::{self, shell};
use crate::widgets::drawer::{self, Panel};
use crate::widgets::player_bar::{self, PlayerUi};
use crate::widgets::player_bar;
use crate::widgets::{sidebar, topbar};
/// Where sign-in stands. Everything but `SignedIn` takes the whole window.
@@ -33,7 +35,8 @@ pub struct App {
nav: Navigator,
search: String,
drawer: Option<Panel>,
player: PlayerUi,
player: Player,
liked: Liked,
}
#[derive(Debug, Clone)]
@@ -52,7 +55,10 @@ pub enum Message {
SearchSubmitted,
ToggleDrawer(Panel),
CloseDrawer,
Player(player_bar::Action),
Player(player::Msg),
LoadLiked,
LikedLoaded(Result<Vec<ym_api::Track>, Error>),
PlayLiked { start: usize, shuffle: bool },
}
impl App {
@@ -64,7 +70,8 @@ impl App {
nav: Navigator::new(Route::Home),
search: String::new(),
drawer: None,
player: PlayerUi::default(),
player: Player::default(),
liked: Liked::NotLoaded,
};
let appearance = iced::system::theme().map(Message::ThemeChanged);
@@ -72,6 +79,7 @@ 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);
if let Some(route) = config.route {
app.nav = Navigator::new(route);
}
@@ -101,11 +109,14 @@ 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, sign_in.subscription().map(Message::SignIn)])
}
_ => appearance,
Session::SignedOut(sign_in) => Subscription::batch([
appearance,
audio,
sign_in.subscription().map(Message::SignIn),
]),
_ => Subscription::batch([appearance, audio]),
}
}
@@ -124,6 +135,7 @@ impl App {
Restored::SignedOut => Session::SignedOut(Box::default()),
Restored::Unreachable => Session::Unreachable,
};
return self.update(Message::LoadLiked);
}
Message::SignIn(msg) => {
let Session::SignedOut(sign_in) = &mut self.session else {
@@ -141,6 +153,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(Err(e)) => {
eprintln!("sign-in: {e}");
@@ -164,10 +177,14 @@ impl App {
self.session = Session::SignedOut(Box::default());
self.nav = Navigator::new(Route::Home);
self.drawer = None;
self.player = PlayerUi::default();
self.player.reset();
self.liked = Liked::NotLoaded;
}
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();
@@ -192,7 +209,37 @@ impl App {
self.drawer = if self.drawer == Some(panel) { None } else { Some(panel) };
}
Message::CloseDrawer => self.drawer = None,
Message::Player(action) => self.player.apply(action),
Message::Player(msg) => {
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() {
return self.update(Message::Player(player::Msg::Play {
tracks,
start,
shuffle: shuffle.then_some(true),
}));
}
}
}
Task::none()
}
@@ -214,7 +261,14 @@ impl App {
let content = column![
topbar::view(t, self.nav.can_go_back(), &self.search),
scrollable(screens::view(t, route, &self.search, account))
scrollable(screens::view(screens::Ctx {
t,
route,
query: &self.search,
me: account,
liked: &self.liked,
playing: self.player.track().map(|tr| tr.id.as_str()),
}))
.height(Fill)
.style(theme::scroll),
]
@@ -224,13 +278,18 @@ impl App {
let mut body = row![sidebar::view(t, route, account), vline(), content].height(Fill);
if let Some(panel) = self.drawer {
body = body.push(vline()).push(drawer::view(t, panel));
body = body.push(vline()).push(drawer::view(t, panel, &self.player));
}
let window = column![
body,
hline(),
container(player_bar::view(t, &self.player, self.drawer))
container(player_bar::view(
t,
&self.player,
self.player.track().is_some_and(|tr| self.liked.contains(&tr.id)),
self.drawer,
))
.height(shell::PLAYER)
.style(theme::panel),
];
@@ -239,6 +298,35 @@ impl App {
}
}
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() };
Task::batch(effects.into_iter().map(|effect| match effect {
Effect::Fetch { generation, track_id } => {
let client = client.clone();
Task::future(async move { fetch_audio(&client, &track_id).await })
.map(move |result| Message::Player(player::Msg::Fetched { generation, result }))
}
Effect::Prefetch { track_id } => {
let client = client.clone();
Task::future(async move {
let result = fetch_audio(&client, &track_id).await;
(track_id, result)
})
.map(|(track_id, result)| Message::Player(player::Msg::Prefetched { track_id, result }))
}
Effect::SignedOut => Task::done(Message::SignOut),
}))
}
}
async fn fetch_audio(client: &YmClient, track_id: &str) -> Result<Audio, Error> {
let stream = client.stream(track_id).await?;
let bytes = client.fetch(&stream).await?;
Ok(Audio { stream, bytes })
}
fn restore() -> Task<Message> {
Task::future(session::restore()).map(Message::Restored)
}
+1
View File
@@ -1,4 +1,5 @@
mod app;
mod player;
mod route;
mod screens;
mod session;
+215
View File
@@ -0,0 +1,215 @@
//! The audio thread. It owns the output device and a rodio `Player`, takes
//! [`Command`]s over a channel and reports [`Event`]s through an iced subscription.
//!
//! Everything here is about one loaded item at a time; the queue and fetching
//! live in the UI state. Each load carries a `generation` so stale events from a
//! previous track can be told apart.
use std::io::Cursor;
use std::sync::Arc;
use std::sync::mpsc::{self, RecvTimeoutError};
use std::time::Duration;
use iced::Subscription;
use iced::futures::{SinkExt, Stream};
use rodio::{Decoder, DeviceSinkBuilder, MixerDeviceSink, Player, Source};
/// How often position is reported while playing.
const TICK: Duration = Duration::from_millis(250);
pub enum Command {
Load { generation: u64, bytes: Arc<[u8]>, hint: String, play: bool },
Play,
Pause,
Seek(Duration),
Volume(f32),
Stop,
}
/// A cheap handle the UI keeps to send commands.
#[derive(Clone)]
pub struct Handle(mpsc::Sender<Command>);
impl std::fmt::Debug for Handle {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("engine::Handle")
}
}
impl Handle {
pub fn send(&self, command: Command) {
// The thread only stops with the subscription, i.e. when the app exits.
let _ = self.0.send(command);
}
}
#[derive(Debug, Clone)]
pub enum Event {
Ready(Handle),
Loaded { generation: u64, duration: Option<Duration> },
Position { generation: u64, position: Duration },
Ended { generation: u64 },
/// The bytes didn't decode (corrupt download, unsupported codec).
DecodeFailed { generation: u64, reason: String },
/// No output device, or it went away.
NoOutput(String),
}
pub fn subscription() -> Subscription<Event> {
Subscription::run(events)
}
fn events() -> impl Stream<Item = Event> {
iced::stream::channel(64, async |mut output| {
let (commands, inbox) = mpsc::channel();
let (events, mut outbox) = tokio::sync::mpsc::unbounded_channel();
std::thread::Builder::new()
.name("musyx-audio".into())
.spawn(move || run(inbox, events))
.expect("spawn audio thread");
let _ = output.send(Event::Ready(Handle(commands))).await;
while let Some(event) = outbox.recv().await {
if output.send(event).await.is_err() {
break;
}
}
})
}
/// Opens the system's default output device.
///
/// rodio's own `open_default_sink` asks for a 50 ms buffer (2048 frames at
/// 44.1 kHz), which Bluetooth headphones that cap at 1024 frames reject, and its
/// fallback then filters out every macOS device. So pick the buffer here,
/// clamped to what the device says it supports.
fn open_output() -> Result<MixerDeviceSink, String> {
use rodio::cpal::traits::{DeviceTrait, HostTrait};
use rodio::cpal::{BufferSize, SupportedBufferSize};
let device = rodio::cpal::default_host()
.default_output_device()
.ok_or_else(|| "no default output device".to_owned())?;
let config = device.default_output_config().map_err(|e| e.to_string())?;
let buffer = match config.buffer_size() {
SupportedBufferSize::Range { min, max } => {
BufferSize::Fixed(buffer_frames(config.sample_rate(), *min, *max))
}
SupportedBufferSize::Unknown => BufferSize::Default,
};
DeviceSinkBuilder::default()
.with_device(device)
.with_supported_config(&config)
.with_buffer_size(buffer)
.open_stream()
.or_else(|first| DeviceSinkBuilder::open_default_sink().map_err(|_| first.to_string()))
}
/// About 50 ms of audio, rounded to a power of two, within the device's limits.
fn buffer_frames(sample_rate: u32, min: u32, max: u32) -> u32 {
(sample_rate / 20).next_power_of_two().clamp(min, max.max(min))
}
fn run(inbox: mpsc::Receiver<Command>, events: tokio::sync::mpsc::UnboundedSender<Event>) {
let emit = |e: Event| {
let _ = events.send(e);
};
// The device sink must outlive the player: dropping it silences everything.
let sink = match open_output() {
Ok(mut sink) => {
sink.log_on_drop(false);
sink
}
Err(e) => {
emit(Event::NoOutput(e));
// Keep draining so senders never block or error; nothing can play.
while inbox.recv().is_ok() {}
return;
}
};
let player = Player::connect_new(sink.mixer());
let mut loaded: Option<u64> = None;
let mut ended_sent = false;
let mut last_reported = None;
loop {
match inbox.recv_timeout(TICK) {
Ok(Command::Load { generation, bytes, hint, play }) => {
player.clear();
let len = bytes.len() as u64;
let decoder = Decoder::builder()
.with_data(Cursor::new(bytes))
.with_byte_len(len)
.with_hint(&hint)
.with_seekable(true)
.with_gapless(true)
.build();
match decoder {
Ok(source) => {
let duration = source.total_duration();
player.append(source);
if play {
player.play();
}
loaded = Some(generation);
ended_sent = false;
last_reported = None;
emit(Event::Loaded { generation, duration });
}
Err(e) => {
loaded = None;
emit(Event::DecodeFailed { generation, reason: e.to_string() });
}
}
}
Ok(Command::Play) => player.play(),
Ok(Command::Pause) => player.pause(),
Ok(Command::Seek(to)) => {
if let Some(generation) = loaded {
// A failed seek leaves playback where it was; the next tick reports that.
if player.try_seek(to).is_ok() {
emit(Event::Position { generation, position: player.get_pos() });
}
}
}
Ok(Command::Volume(v)) => player.set_volume(v.clamp(0.0, 1.0)),
Ok(Command::Stop) => {
player.clear();
loaded = None;
}
Err(RecvTimeoutError::Timeout) => {}
Err(RecvTimeoutError::Disconnected) => break,
}
let Some(generation) = loaded else { continue };
if player.empty() {
if !ended_sent {
ended_sent = true;
emit(Event::Ended { generation });
}
} else if !player.is_paused() {
let position = player.get_pos();
// Whole-tick resolution is plenty for a progress bar.
let bucket = position.as_millis() / TICK.as_millis();
if last_reported != Some(bucket) {
last_reported = Some(bucket);
emit(Event::Position { generation, position });
}
}
}
}
#[cfg(test)]
mod tests {
use super::buffer_frames;
#[test]
fn buffer_fits_bluetooth_limits() {
assert_eq!(buffer_frames(44_100, 14, 1024), 1024);
assert_eq!(buffer_frames(48_000, 15, 4096), 4096);
assert_eq!(buffer_frames(8_000, 512, 4096), 512);
assert_eq!(buffer_frames(44_100, 100, 50), 100, "a bogus range still yields the minimum");
}
}
+557
View File
@@ -0,0 +1,557 @@
//! Playback state: the queue, what's loaded, and the rules for moving between
//! tracks. Network work is described as [`Effect`]s for the app to run, so this
//! module stays free of the API client and can be tested on its own.
pub mod engine;
pub mod queue;
use std::sync::Arc;
use std::time::Duration;
use ym_api::{Error, Stream, Track};
use engine::{Command, Event};
pub use queue::{Queue, Repeat};
/// Give up after this many unplayable tracks in a row instead of skipping forever.
const MAX_SKIPS: u8 = 3;
/// "Previous" restarts the current track once it has played this long.
const RESTART_AFTER: Duration = Duration::from_secs(3);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Status {
Loading,
Playing,
Paused,
/// The queue ran out with repeat off. Play starts the last track again.
Ended,
}
/// Audio for one track, ready to hand to the engine.
#[derive(Debug, Clone)]
pub struct Audio {
pub stream: Stream,
pub bytes: Arc<[u8]>,
}
#[derive(Debug, Clone)]
pub enum Msg {
Engine(Event),
/// Replace the queue. `shuffle` sets shuffle first; with it on, `start` is ignored.
Play { tracks: Arc<[Track]>, start: usize, shuffle: Option<bool> },
Toggle,
Next,
Previous,
ToggleShuffle,
CycleRepeat,
/// The seek bar is being dragged; only the bar moves.
SeekPreview(f32),
SeekCommit,
SetVolume(f32),
ToggleMute,
JumpTo(usize),
Fetched { generation: u64, result: Result<Audio, Error> },
Prefetched { track_id: String, result: Result<Audio, Error> },
}
/// Work the app has to do on the player's behalf.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Effect {
Fetch { generation: u64, track_id: String },
Prefetch { track_id: String },
/// The token stopped working mid-session.
SignedOut,
}
pub struct Player {
engine: Option<engine::Handle>,
queue: Option<Queue<Track>>,
pub repeat: Repeat,
shuffle: bool,
pub volume: f32,
pub muted: bool,
generation: u64,
status: Status,
position: Duration,
duration: Duration,
current: Option<Audio>,
/// Which track `current` holds, so a replay can reuse it.
current_track_id: Option<String>,
prefetched: Option<(String, Audio)>,
skips: u8,
seeking: Option<f32>,
/// One line for the player bar when something went wrong.
pub notice: Option<String>,
}
impl Default for Player {
fn default() -> Self {
Self {
engine: None,
queue: None,
repeat: Repeat::Off,
shuffle: false,
volume: 0.7,
muted: false,
generation: 0,
status: Status::Paused,
position: Duration::ZERO,
duration: Duration::ZERO,
current: None,
current_track_id: None,
prefetched: None,
skips: 0,
seeking: None,
notice: None,
}
}
}
impl Player {
/// Stops playback and forgets the queue (sign-out). The device and volume stay.
pub fn reset(&mut self) {
self.send(Command::Stop);
*self = Self { engine: self.engine.take(), volume: self.volume, muted: self.muted, ..Self::default() };
}
pub fn track(&self) -> Option<&Track> {
self.queue.as_ref().map(Queue::current)
}
pub fn queue(&self) -> Option<&Queue<Track>> {
self.queue.as_ref()
}
pub fn status(&self) -> Status {
self.status
}
pub fn shuffle(&self) -> bool {
self.shuffle
}
/// Where the seek bar should sit: the drag position while dragging.
pub fn position(&self) -> Duration {
self.seeking.map_or(self.position, Duration::from_secs_f32)
}
pub fn duration(&self) -> Duration {
self.duration
}
pub fn stream(&self) -> Option<&Stream> {
self.current.as_ref().map(|a| &a.stream)
}
fn send(&self, command: Command) {
if let Some(engine) = &self.engine {
engine.send(command);
}
}
fn effective_volume(&self) -> f32 {
if self.muted { 0.0 } else { self.volume }
}
pub fn update(&mut self, msg: Msg) -> Vec<Effect> {
match msg {
Msg::Engine(event) => return self.on_engine(event),
Msg::Play { tracks, start, shuffle } => {
if let Some(on) = shuffle {
self.shuffle = on;
}
let start = if shuffle == Some(true) && !tracks.is_empty() {
rand::random_range(0..tracks.len())
} else {
start
};
self.queue = Queue::new(tracks.to_vec(), start, self.shuffle);
self.skips = 0;
self.notice = None;
return self.load_current();
}
Msg::Toggle => match self.status {
Status::Playing => {
self.send(Command::Pause);
self.status = Status::Paused;
}
Status::Paused if self.current.is_some() => {
self.send(Command::Play);
self.status = Status::Playing;
}
Status::Paused if self.queue.is_some() => return self.load_current(),
Status::Ended => return self.load_current(),
Status::Paused | Status::Loading => {}
},
Msg::Next => return self.step(true, false),
Msg::Previous => {
if self.position >= RESTART_AFTER || !self.can_go_back() {
self.seek(Duration::ZERO);
} else if let Some(queue) = &mut self.queue {
queue.back(self.repeat);
return self.load_current();
}
}
Msg::ToggleShuffle => {
self.shuffle = !self.shuffle;
if let Some(queue) = &mut self.queue {
queue.set_shuffle(self.shuffle);
}
return self.prefetch_next();
}
Msg::CycleRepeat => {
self.repeat = self.repeat.next();
return self.prefetch_next();
}
Msg::SeekPreview(secs) => self.seeking = Some(secs),
Msg::SeekCommit => {
if let Some(secs) = self.seeking.take() {
self.seek(Duration::from_secs_f32(secs.max(0.0)));
}
}
Msg::SetVolume(v) => {
self.volume = v.clamp(0.0, 1.0);
self.muted = self.volume == 0.0;
self.send(Command::Volume(self.effective_volume()));
}
Msg::ToggleMute => {
self.muted = !self.muted;
if !self.muted && self.volume == 0.0 {
self.volume = 0.5;
}
self.send(Command::Volume(self.effective_volume()));
}
Msg::JumpTo(pos) => {
if let Some(queue) = &mut self.queue {
queue.jump(pos);
return self.load_current();
}
}
Msg::Fetched { generation, result } => {
if generation != self.generation {
return vec![];
}
match result {
Ok(audio) => self.start(audio),
Err(Error::Unauthorized(_)) => return vec![Effect::SignedOut],
Err(e) => {
eprintln!("fetch: {e}");
return self.skip_unplayable();
}
}
}
Msg::Prefetched { track_id, result } => match result {
Ok(audio) => self.prefetched = Some((track_id, audio)),
Err(e) => eprintln!("prefetch {track_id}: {e}"),
},
}
vec![]
}
fn on_engine(&mut self, event: Event) -> Vec<Effect> {
match event {
Event::Ready(handle) => {
handle.send(Command::Volume(self.effective_volume()));
self.engine = Some(handle);
}
Event::NoOutput(reason) => {
eprintln!("audio output: {reason}");
self.notice = Some(
"No sound output found. Connect speakers or headphones, then restart Musyx."
.into(),
);
}
Event::Loaded { generation, duration } if generation == self.generation => {
if let Some(d) = duration.filter(|d| !d.is_zero()) {
self.duration = d;
}
self.status = Status::Playing;
self.skips = 0;
return self.prefetch_next();
}
Event::Position { generation, position } if generation == self.generation => {
self.position = position;
}
Event::Ended { generation } if generation == self.generation => {
return self.step(false, true);
}
Event::DecodeFailed { generation, reason } if generation == self.generation => {
eprintln!("decode: {reason}");
return self.skip_unplayable();
}
_ => {}
}
vec![]
}
fn can_go_back(&self) -> bool {
self.queue.as_ref().is_some_and(|q| q.len() > 1)
}
fn seek(&mut self, to: Duration) {
let to = to.min(self.duration);
self.position = to;
if self.status == Status::Ended {
// The player is empty after the end; reload and play from `to`.
if let Some(audio) = self.current.clone() {
self.load_audio(audio, true);
self.send(Command::Seek(to));
}
} else {
self.send(Command::Seek(to));
}
}
/// Next track. `finished` distinguishes a natural end (repeat-one replays)
/// from a skip; `user` skips always move on.
fn step(&mut self, user: bool, finished: bool) -> Vec<Effect> {
let Some(queue) = &mut self.queue else { return vec![] };
if queue.advance(self.repeat, finished && !user) {
self.load_current()
} else {
self.status = Status::Ended;
self.position = self.duration;
vec![]
}
}
fn load_current(&mut self) -> Vec<Effect> {
let Some(track) = self.track().cloned() else { return vec![] };
self.generation += 1;
self.position = Duration::ZERO;
self.duration = track.duration;
self.seeking = None;
// Replaying the same track (repeat one, play after the end) reuses its bytes.
let reuse = match (&self.current, self.prefetched.take()) {
(_, Some((id, audio))) if id == track.id => Some(audio),
(Some(audio), other) => {
self.prefetched = other;
self.current_is(&track).then(|| audio.clone())
}
(None, other) => {
self.prefetched = other;
None
}
};
match reuse {
Some(audio) => {
self.start(audio);
vec![]
}
None => {
self.status = Status::Loading;
self.current = None;
vec![Effect::Fetch { generation: self.generation, track_id: track.id }]
}
}
}
fn current_is(&self, track: &Track) -> bool {
self.current_track_id.as_deref() == Some(track.id.as_str())
}
fn start(&mut self, audio: Audio) {
self.load_audio(audio, true);
}
fn load_audio(&mut self, audio: Audio, play: bool) {
self.current_track_id = self.track().map(|t| t.id.clone());
self.status = Status::Loading;
self.send(Command::Load {
generation: self.generation,
bytes: audio.bytes.clone(),
hint: audio.stream.codec.clone(),
play,
});
self.current = Some(audio);
}
fn prefetch_next(&mut self) -> Vec<Effect> {
let Some(queue) = &self.queue else { return vec![] };
let Some(next) = queue.peek_next(self.repeat) else { return vec![] };
if self.current_is(next) {
return vec![];
}
if self.prefetched.as_ref().is_some_and(|(id, _)| *id == next.id) {
return vec![];
}
self.prefetched = None;
vec![Effect::Prefetch { track_id: next.id.clone() }]
}
fn skip_unplayable(&mut self) -> Vec<Effect> {
let title = self.track().map(Track::full_title).unwrap_or_default();
self.skips += 1;
self.current = None;
if self.skips >= MAX_SKIPS {
self.status = Status::Paused;
self.notice = Some("Several tracks in a row couldn't be played. Check your connection and try again.".into());
return vec![];
}
self.notice = Some(format!("Couldn't play “{title}”, so it was skipped."));
self.step(true, false)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn track(id: &str, secs: u64) -> Track {
let json = format!(r#"{{"id":"{id}","title":"T{id}","durationMs":{}}}"#, secs * 1000);
Track::from_json(&json).unwrap()
}
fn audio() -> Audio {
Audio {
stream: Stream { url: "u".into(), codec: "mp3".into(), bitrate_kbps: 320, preview: false },
bytes: Arc::from(vec![0u8; 4]),
}
}
fn playing(n: usize, start: usize) -> Player {
let mut p = Player::default();
let tracks: Arc<[Track]> = (0..n).map(|i| track(&i.to_string(), 100)).collect();
let effects = p.update(Msg::Play { tracks, start, shuffle: None });
let Some(Effect::Fetch { generation, .. }) = effects.first().cloned() else {
panic!("expected fetch, got {effects:?}");
};
p.update(Msg::Fetched { generation, result: Ok(audio()) });
p.update(Msg::Engine(Event::Loaded { generation, duration: None }));
p
}
#[test]
fn play_fetches_then_plays_and_prefetches_next() {
let mut p = Player::default();
let tracks: Arc<[Track]> = vec![track("a", 10), track("b", 20)].into();
let effects = p.update(Msg::Play { tracks, start: 0, shuffle: None });
assert_eq!(effects, vec![Effect::Fetch { generation: 1, track_id: "a".into() }]);
assert_eq!(p.status(), Status::Loading);
assert!(p.update(Msg::Fetched { generation: 1, result: Ok(audio()) }).is_empty());
let effects = p.update(Msg::Engine(Event::Loaded { generation: 1, duration: None }));
assert_eq!(p.status(), Status::Playing);
assert_eq!(p.duration(), Duration::from_secs(10));
assert_eq!(effects, vec![Effect::Prefetch { track_id: "b".into() }]);
}
#[test]
fn prefetched_audio_is_used_without_another_fetch() {
let mut p = playing(3, 0);
p.update(Msg::Prefetched { track_id: "1".into(), result: Ok(audio()) });
let generation = p.generation;
let effects = p.update(Msg::Engine(Event::Ended { generation }));
assert!(!effects.iter().any(|e| matches!(e, Effect::Fetch { .. })), "{effects:?}");
assert_eq!(p.track().unwrap().id, "1");
}
#[test]
fn stale_events_are_ignored() {
let mut p = playing(3, 0);
let old = p.generation;
p.update(Msg::Next);
p.update(Msg::Engine(Event::Position { generation: old, position: Duration::from_secs(50) }));
assert_eq!(p.position(), Duration::ZERO);
assert!(p.update(Msg::Fetched { generation: old, result: Ok(audio()) }).is_empty());
}
#[test]
fn end_of_queue_stops_and_play_restarts_last_track() {
let mut p = playing(1, 0);
let generation = p.generation;
assert!(p.update(Msg::Engine(Event::Ended { generation })).is_empty());
assert_eq!(p.status(), Status::Ended);
let effects = p.update(Msg::Toggle);
assert!(effects.is_empty(), "replay comes from memory: {effects:?}");
assert_eq!(p.status(), Status::Loading);
}
#[test]
fn repeat_one_replays_from_memory() {
let mut p = playing(3, 1);
p.update(Msg::CycleRepeat);
p.update(Msg::CycleRepeat);
assert_eq!(p.repeat, Repeat::One);
let generation = p.generation;
let effects = p.update(Msg::Engine(Event::Ended { generation }));
assert!(effects.is_empty(), "{effects:?}");
assert_eq!(p.track().unwrap().id, "1");
}
#[test]
fn previous_restarts_after_three_seconds() {
let mut p = playing(3, 1);
let generation = p.generation;
p.update(Msg::Engine(Event::Position { generation, position: Duration::from_secs(10) }));
p.update(Msg::Previous);
assert_eq!(p.track().unwrap().id, "1");
assert_eq!(p.position(), Duration::ZERO);
p.update(Msg::Previous);
assert_eq!(p.track().unwrap().id, "0");
}
#[test]
fn unplayable_tracks_are_skipped_then_given_up_on() {
let mut p = playing(5, 0);
for expected_skips in 1..MAX_SKIPS {
p.update(Msg::Next);
let generation = p.generation;
p.update(Msg::Fetched { generation, result: Err(Error::Api("gone".into())) });
assert_eq!(p.skips, expected_skips);
assert!(p.notice.as_deref().unwrap().contains("skipped"));
}
let generation = p.generation;
let effects = p.update(Msg::Fetched { generation, result: Err(Error::Api("gone".into())) });
assert!(effects.is_empty());
assert!(p.notice.as_deref().unwrap().contains("Several tracks"));
}
#[test]
fn expired_token_signs_out() {
let mut p = Player::default();
let tracks: Arc<[Track]> = vec![track("a", 10)].into();
p.update(Msg::Play { tracks, start: 0, shuffle: None });
let effects =
p.update(Msg::Fetched { generation: 1, result: Err(Error::Unauthorized("401".into())) });
assert_eq!(effects, vec![Effect::SignedOut]);
}
#[test]
fn seek_preview_moves_bar_until_commit() {
let mut p = playing(1, 0);
p.update(Msg::SeekPreview(42.0));
assert_eq!(p.position(), Duration::from_secs(42));
p.update(Msg::SeekCommit);
assert_eq!(p.position(), Duration::from_secs(42));
assert!(p.seeking.is_none());
}
#[test]
fn shuffle_play_turns_shuffle_on() {
let mut p = Player::default();
let tracks: Arc<[Track]> = (0..20).map(|i| track(&i.to_string(), 10)).collect();
p.update(Msg::Play { tracks, start: 0, shuffle: Some(true) });
assert!(p.shuffle());
assert_eq!(p.queue().unwrap().upcoming().count(), 19);
}
#[test]
fn reset_keeps_volume_but_drops_queue() {
let mut p = playing(3, 0);
p.update(Msg::SetVolume(0.3));
p.reset();
assert!(p.track().is_none());
assert_eq!(p.volume, 0.3);
}
#[test]
fn mute_and_volume() {
let mut p = Player::default();
p.update(Msg::SetVolume(0.0));
assert!(p.muted);
p.update(Msg::ToggleMute);
assert!(!p.muted);
assert_eq!(p.volume, 0.5);
}
}
+218
View File
@@ -0,0 +1,218 @@
//! Play order over a fixed list of items: shuffle, repeat, next/previous.
//!
//! Generic so the rules can be tested with plain numbers; the app uses `Track`.
use rand::seq::SliceRandom;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Repeat {
#[default]
Off,
All,
One,
}
impl Repeat {
pub fn next(self) -> Self {
match self {
Repeat::Off => Repeat::All,
Repeat::All => Repeat::One,
Repeat::One => Repeat::Off,
}
}
}
#[derive(Debug, Clone)]
pub struct Queue<T> {
items: Vec<T>,
/// Indices into `items` in play order.
order: Vec<usize>,
/// Position in `order` of the current item.
pos: usize,
shuffle: bool,
}
impl<T> Queue<T> {
/// A queue over `items` starting at `start`. Returns `None` for an empty list.
pub fn new(items: Vec<T>, start: usize, shuffle: bool) -> Option<Self> {
if items.is_empty() {
return None;
}
let start = start.min(items.len() - 1);
let mut queue = Self { order: (0..items.len()).collect(), items, pos: start, shuffle: false };
if shuffle {
queue.set_shuffle(true);
}
Some(queue)
}
pub fn current(&self) -> &T {
&self.items[self.order[self.pos]]
}
/// Moves on after a track. `finished` is true when it played to the end, in
/// which case `Repeat::One` replays it; a skip always advances. Returns
/// `false` at the end of the queue with repeat off.
pub fn advance(&mut self, repeat: Repeat, finished: bool) -> bool {
if finished && repeat == Repeat::One {
return true;
}
if self.pos + 1 < self.order.len() {
self.pos += 1;
true
} else if repeat != Repeat::Off {
self.pos = 0;
true
} else {
false
}
}
/// Steps back one item, wrapping when repeat is on. Returns `false` at the start.
pub fn back(&mut self, repeat: Repeat) -> bool {
if self.pos > 0 {
self.pos -= 1;
true
} else if repeat != Repeat::Off {
self.pos = self.order.len() - 1;
true
} else {
false
}
}
/// The item that `advance(repeat, true)` would move to, without moving.
pub fn peek_next(&self, repeat: Repeat) -> Option<&T> {
match repeat {
Repeat::One => Some(self.current()),
_ if self.pos + 1 < self.order.len() => Some(&self.items[self.order[self.pos + 1]]),
Repeat::All => Some(&self.items[self.order[0]]),
Repeat::Off => None,
}
}
/// Items after the current one, in play order (no wrap-around).
pub fn upcoming(&self) -> impl Iterator<Item = (usize, &T)> {
self.order[self.pos + 1..].iter().enumerate().map(move |(i, &ix)| (self.pos + 1 + i, &self.items[ix]))
}
/// Jumps to a play-order position from [`Queue::upcoming`].
pub fn jump(&mut self, order_pos: usize) {
if order_pos < self.order.len() {
self.pos = order_pos;
}
}
/// Turning shuffle on keeps the current item and shuffles everything after it;
/// turning it off restores list order at the current item.
pub fn set_shuffle(&mut self, on: bool) {
if on == self.shuffle {
return;
}
let current = self.order[self.pos];
if on {
let mut rest: Vec<usize> = (0..self.items.len()).filter(|&i| i != current).collect();
rest.shuffle(&mut rand::rng());
self.order = std::iter::once(current).chain(rest).collect();
self.pos = 0;
} else {
self.order = (0..self.items.len()).collect();
self.pos = current;
}
self.shuffle = on;
}
pub fn len(&self) -> usize {
self.items.len()
}
}
#[cfg(test)]
mod tests {
use super::*;
fn q(n: usize, start: usize) -> Queue<usize> {
Queue::new((0..n).collect(), start, false).unwrap()
}
#[test]
fn empty_list_has_no_queue() {
assert!(Queue::<u8>::new(vec![], 0, false).is_none());
}
#[test]
fn start_is_clamped() {
assert_eq!(*q(3, 99).current(), 2);
}
#[test]
fn advance_stops_at_end_without_repeat() {
let mut q = q(2, 0);
assert!(q.advance(Repeat::Off, true));
assert_eq!(*q.current(), 1);
assert!(!q.advance(Repeat::Off, true));
assert_eq!(*q.current(), 1);
}
#[test]
fn repeat_all_wraps_both_ways() {
let mut q = q(3, 2);
assert!(q.advance(Repeat::All, true));
assert_eq!(*q.current(), 0);
assert!(q.back(Repeat::All));
assert_eq!(*q.current(), 2);
}
#[test]
fn repeat_one_replays_on_finish_but_skip_moves_on() {
let mut q = q(3, 1);
assert!(q.advance(Repeat::One, true));
assert_eq!(*q.current(), 1);
assert!(q.advance(Repeat::One, false));
assert_eq!(*q.current(), 2);
}
#[test]
fn back_stops_at_start_without_repeat() {
let mut q = q(3, 0);
assert!(!q.back(Repeat::Off));
assert_eq!(*q.current(), 0);
}
#[test]
fn peek_matches_advance() {
for repeat in [Repeat::Off, Repeat::All, Repeat::One] {
for start in 0..3 {
let mut q = q(3, start);
let peeked = q.peek_next(repeat).copied();
let moved = q.advance(repeat, true);
assert_eq!(peeked, moved.then(|| *q.current()), "{repeat:?} from {start}");
}
}
}
#[test]
fn shuffle_keeps_current_and_covers_everything() {
let mut q = q(50, 17);
q.set_shuffle(true);
assert_eq!(*q.current(), 17);
let mut seen: Vec<usize> = std::iter::once(17).chain(q.upcoming().map(|(_, &x)| x)).collect();
seen.sort_unstable();
assert_eq!(seen, (0..50).collect::<Vec<_>>());
q.advance(Repeat::Off, false);
let now = *q.current();
q.set_shuffle(false);
assert_eq!(*q.current(), now, "unshuffling keeps the current item");
assert_eq!(q.upcoming().count(), 49 - now);
}
#[test]
fn jump_moves_to_upcoming_position() {
let mut q = q(5, 0);
let (pos, &item) = q.upcoming().nth(2).unwrap();
q.jump(pos);
assert_eq!(*q.current(), item);
q.jump(99);
assert_eq!(*q.current(), item);
}
}
+157
View File
@@ -0,0 +1,157 @@
//! Collection: for now the liked tracks list, which is also the first thing
//! you can play.
use std::collections::HashSet;
use std::sync::Arc;
use iced::widget::{Column, button, column, lazy, row};
use iced::{Alignment, Element, Fill};
use ym_api::{Error, Track};
use crate::app::Message;
use crate::ui::icons::{Icon, icon};
use crate::ui::theme::{self, Tokens, size};
use crate::ui::{line, para};
use crate::widgets::track_row;
/// The liked-tracks list as the app holds it.
#[derive(Debug, Default)]
pub enum Liked {
#[default]
NotLoaded,
Loading,
Loaded {
tracks: Arc<[Track]>,
ids: HashSet<String>,
/// Bumped on every reload so the cached rows rebuild.
version: u64,
},
Failed(Error),
}
impl Liked {
pub fn loaded(tracks: Vec<Track>, previous: &Liked) -> Self {
let version = match previous {
Liked::Loaded { version, .. } => version + 1,
_ => 0,
};
let ids = tracks.iter().map(|t| t.id.clone()).collect();
Liked::Loaded { tracks: tracks.into(), ids, version }
}
pub fn contains(&self, track_id: &str) -> bool {
matches!(self, Liked::Loaded { ids, .. } if ids.contains(track_id))
}
pub fn tracks(&self) -> Option<&Arc<[Track]>> {
match self {
Liked::Loaded { tracks, .. } => Some(tracks),
_ => None,
}
}
}
/// What makes the list look different; anything else reuses the built rows.
#[derive(Hash)]
struct ListKey {
version: u64,
playing: Option<String>,
dark: bool,
}
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);
let body: Element<'a, Message> = match liked {
Liked::NotLoaded | Liked::Loading => para("Loading your liked tracks…", size::BODY, t.muted).into(),
Liked::Failed(err) => 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.",
},
size::BODY,
t.muted,
),
button(line("Try again", theme::SEMIBOLD, size::BODY, t.accent_ink))
.padding([11, 18])
.style(theme::primary)
.on_press(Message::LoadLiked),
]
.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()
}
#[cfg(test)]
mod tests {
use super::*;
fn track(id: &str) -> Track {
Track::from_json(&format!(r#"{{"id":"{id}","title":"T"}}"#)).unwrap()
}
#[test]
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"));
let second = Liked::loaded(vec![track("3")], &first);
match second {
Liked::Loaded { version, .. } => assert_eq!(version, 1),
_ => unreachable!(),
}
assert!(!Liked::Failed(Error::Denied).contains("1"));
}
}
+14 -5
View File
@@ -1,5 +1,6 @@
//! Content for each route, plus the full-window screens shown outside a session.
pub mod collection;
pub mod sign_in;
use iced::widget::{Column, button, column, container, row, space};
@@ -13,7 +14,18 @@ use crate::ui::theme::{self, Tokens, radius, size, space as sp};
use crate::ui::{line, para};
use crate::widgets::sidebar;
pub fn view<'a>(t: &'static Tokens, route: Route, query: &str, me: &'a Account) -> Element<'a, Message> {
/// Everything a routed screen may need from app state.
pub struct Ctx<'a> {
pub t: &'static Tokens,
pub route: Route,
pub query: &'a str,
pub me: &'a Account,
pub liked: &'a collection::Liked,
pub playing: Option<&'a str>,
}
pub fn view<'a>(ctx: Ctx<'a>) -> Element<'a, Message> {
let Ctx { t, route, query, me, liked, playing } = ctx;
let content: Column<'a, Message> = match route {
Route::Home => column![
wave_hero(t),
@@ -31,10 +43,7 @@ pub fn view<'a>(t: &'static Tokens, route: Route, query: &str, me: &'a Account)
}),
upcoming(t, Icon::Search, "Search the whole catalogue", "Tracks, albums, artists, playlists and podcasts."),
],
Route::Collection => column![
title(t, "Collection"),
upcoming(t, Icon::HeartFilled, "Everything you've liked", "Liked tracks, albums, artists and playlists."),
],
Route::Collection => column![collection::view(t, liked, playing)],
Route::Podcasts => column![
title(t, "Podcasts and books"),
upcoming(t, Icon::Podcast, "Pick up where you left off", "Podcasts and audiobooks you follow."),
+22
View File
@@ -75,6 +75,28 @@ impl Config {
}
}
/// Sample liked tracks so the Collection list has rows.
pub fn sample_liked(&self) -> Vec<ym_api::Track> {
[
("1", "Звезда по имени Солнце", "Кино", 7, "Звезда по имени Солнце", 225),
("2", "Хочешь?", "Земфира", 3, "Прости меня моя любовь", 225),
("3", "Выхода нет", "Сплин", 25, "Гранатовый альбом", 230),
("4", "Полковнику никто не пишет", "Би-2", 280, "Би-2", 285),
("5", "Владивосток 2000", "Мумий Тролль", 185, "Морская", 165),
("6", "Город золотой", "Аквариум", 48, "Десять стрел", 205),
]
.into_iter()
.map(|(id, title, artist, album, album_title, secs)| {
ym_api::Track::from_json(&format!(
r#"{{"id":"{id}","title":"{title}","durationMs":{ms},"artists":[{{"name":"{artist}"}}],
"albums":[{{"id":{album},"title":"{album_title}"}}]}}"#,
ms = secs * 1000
))
.expect("sample track")
})
.collect()
}
/// 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)))
+71 -10
View File
@@ -1,11 +1,14 @@
//! Right-hand panel with the play queue and lyrics.
use iced::widget::{button, column, container, row, space};
use iced::widget::{button, column, container, row, scrollable, space};
use ym_api::Track;
use iced::{Alignment, Element, Fill, Padding};
use crate::app::Message;
use crate::player::{Msg, Player, Queue};
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::widgets::player_bar::clock;
use crate::ui::{line, para};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -23,7 +26,7 @@ impl Panel {
}
}
pub fn view<'a>(t: &'static Tokens, panel: Panel) -> Element<'a, Message> {
pub fn view<'a>(t: &'static Tokens, panel: Panel, player: &'a Player) -> Element<'a, Message> {
let tabs = row![tab(t, Panel::Queue, panel), tab(t, Panel::Lyrics, panel)].spacing(4);
let head = row![
@@ -37,26 +40,84 @@ pub fn view<'a>(t: &'static Tokens, panel: Panel) -> Element<'a, Message> {
.align_y(Alignment::Center)
.padding(Padding::default().top(14).bottom(8).left(18).right(14));
let body = match panel {
Panel::Queue => para(
let body: Element<'a, Message> = match (panel, player.queue()) {
(Panel::Queue, Some(queue)) => queue_list(t, queue),
(Panel::Queue, None) => container(para(
"Nothing queued yet. Tracks you play, and the ones lined up after them, show up here.",
size::META,
t.muted,
),
Panel::Lyrics => para(
"Play a track to see its lyrics. Synced lyrics follow playback, and clicking a line jumps to it.",
))
.padding([4, 20])
.into(),
(Panel::Lyrics, _) => container(para(
"Synced lyrics arrive in a later update. They'll follow playback, and clicking a line will jump to it.",
size::META,
t.muted,
),
))
.padding([4, 20])
.into(),
};
container(column![head, container(body).padding([4, 20])])
container(column![head, body])
.width(shell::DRAWER)
.height(Fill)
.style(theme::panel)
.into()
}
/// 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> {
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)),
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),
]
.spacing(1)
.width(Fill)
.clip(true),
line(clock(track.duration.as_secs_f32()), theme::BODY, size::SMALL, t.muted),
]
.spacing(10)
.align_y(Alignment::Center),
)
.width(Fill)
.padding([6, 8])
.style(theme::nav_item(false))
.on_press_maybe(msg)
};
let remaining = queue.upcoming().count();
let mut list = column![heading("Now playing".into()), item(queue.current(), true, None)];
list = list.push(heading(if remaining == 0 {
"Nothing after this".into()
} else {
format!("Next up · {remaining}")
}));
for (pos, track) in queue.upcoming().take(SHOWN) {
list = list.push(item(track, false, Some(Message::Player(Msg::JumpTo(pos)))));
}
if remaining > SHOWN {
list = list.push(
container(line(format!("and {} more", remaining - SHOWN), theme::BODY, size::SMALL, t.muted))
.padding([10, 8]),
);
}
scrollable(list.padding(Padding::default().left(10).right(10).bottom(18)))
.height(Fill)
.style(theme::scroll)
.into()
}
fn tab<'a>(t: &'static Tokens, panel: Panel, selected: Panel) -> Element<'a, Message> {
let on = panel == selected;
button(
+1
View File
@@ -2,3 +2,4 @@ pub mod drawer;
pub mod player_bar;
pub mod sidebar;
pub mod topbar;
pub mod track_row;
+90 -169
View File
@@ -1,88 +1,22 @@
//! The persistent bar along the bottom: now playing, transport, extras.
//!
//! Until the audio engine lands the bar only knows its own toggles; `now` stays
//! `None`, so the transport renders disabled and the seek bar is static.
use iced::widget::{button, column, container, row, slider, space};
use iced::{Alignment, Element, Fill, Length};
use crate::app::Message;
use crate::player::{Msg, Player, Repeat, Status};
use crate::ui::icons::{Icon, icon, sized};
use crate::ui::line;
use crate::ui::theme::{self, Tokens, radius, size};
use crate::widgets::drawer::Panel;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Repeat {
#[default]
Off,
All,
One,
fn send(msg: Msg) -> Message {
Message::Player(msg)
}
impl Repeat {
fn next(self) -> Self {
match self {
Repeat::Off => Repeat::All,
Repeat::All => Repeat::One,
Repeat::One => Repeat::Off,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct NowPlaying {
pub title: String,
pub artists: String,
pub position: f32,
pub duration: f32,
pub playing: bool,
pub liked: bool,
pub quality: String,
/// Placeholder cover hues until artwork loads.
pub hues: (f32, f32),
}
#[derive(Debug, Clone, PartialEq)]
pub struct PlayerUi {
pub now: Option<NowPlaying>,
pub shuffle: bool,
pub repeat: Repeat,
pub volume: f32,
pub muted: bool,
}
impl Default for PlayerUi {
fn default() -> Self {
Self { now: None, shuffle: false, repeat: Repeat::Off, volume: 0.7, muted: false }
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Action {
ToggleShuffle,
CycleRepeat,
SetVolume(f32),
ToggleMute,
}
impl PlayerUi {
pub fn apply(&mut self, action: Action) {
match action {
Action::ToggleShuffle => self.shuffle = !self.shuffle,
Action::CycleRepeat => self.repeat = self.repeat.next(),
Action::SetVolume(v) => {
self.volume = v.clamp(0.0, 1.0);
self.muted = self.volume == 0.0;
}
Action::ToggleMute => self.muted = !self.muted,
}
}
}
pub fn view<'a>(t: &'static Tokens, p: &'a PlayerUi, drawer: Option<Panel>) -> Element<'a, Message> {
pub fn view<'a>(t: &'static Tokens, p: &'a Player, liked: bool, drawer: Option<Panel>) -> Element<'a, Message> {
row![
container(now_playing(t, p.now.as_ref())).width(Length::FillPortion(2)),
container(now_playing(t, p, liked)).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),
]
@@ -93,48 +27,54 @@ pub fn view<'a>(t: &'static Tokens, p: &'a PlayerUi, drawer: Option<Panel>) -> E
.into()
}
fn now_playing<'a>(t: &'static Tokens, now: Option<&'a NowPlaying>) -> Element<'a, Message> {
let cover = container(space())
.width(52)
.height(52)
.style(move |th| match now {
Some(n) => theme::cover(n.hues.0, n.hues.1, radius::CONTROL)(th),
None => iced::widget::container::Style {
background: Some(t.raised.into()),
border: iced::Border { radius: radius::CONTROL.into(), ..Default::default() },
..Default::default()
},
fn now_playing<'a>(t: &'static Tokens, p: &'a Player, liked: bool) -> 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()),
border: iced::Border { radius: radius::CONTROL.into(), ..Default::default() },
..Default::default()
});
let Some(now) = now else {
let (title, sub) = match &p.notice {
Some(notice) => ("Can't play", notice.as_str()),
None => ("Nothing playing", "Pick a track to start"),
};
return row![
cover,
blank,
column![
line("Nothing playing", theme::MEDIUM, size::BODY, t.fg),
line("Pick a track to start", theme::BODY, size::META, t.muted),
line(title, theme::MEDIUM, size::BODY, t.fg),
line(sub, theme::BODY, size::META, t.muted),
]
.spacing(2),
]
.spacing(12)
.align_y(Alignment::Center)
.clip(true)
.into();
};
let (h1, h2) = track.hues();
let cover = container(space()).width(52).height(52).style(theme::cover(h1, h2, radius::CONTROL));
// A problem with the previous track shows in place of the artist line until the next one loads.
let (sub, sub_colour) = match (&p.notice, p.status()) {
(Some(notice), Status::Loading | Status::Paused) => (notice.clone(), t.like),
_ => (track.artist_line(), t.muted),
};
row![
cover,
column![
line(&now.title, theme::MEDIUM, size::BODY, t.fg),
line(&now.artists, theme::BODY, size::META, t.muted),
line(track.full_title(), theme::MEDIUM, size::BODY, t.fg),
line(sub, theme::BODY, size::META, sub_colour),
]
.spacing(2)
.width(Length::Shrink),
button(icon(
if now.liked { Icon::HeartFilled } else { Icon::Heart },
if now.liked { t.like } else { t.muted },
// Liking from here arrives with collection editing; the heart shows the current state.
container(icon(
if liked { Icon::HeartFilled } else { Icon::Heart },
if liked { t.like } else { t.muted },
))
.padding(8)
.style(theme::icon_button(None)),
button(icon(Icon::Dislike, t.muted)).padding(8).style(theme::icon_button(None)),
.padding(8),
]
.spacing(12)
.align_y(Alignment::Center)
@@ -142,81 +82,83 @@ fn now_playing<'a>(t: &'static Tokens, now: Option<&'a NowPlaying>) -> Element<'
.into()
}
fn transport<'a>(t: &'static Tokens, p: &'a PlayerUi) -> Element<'a, Message> {
let has_track = p.now.is_some();
let playing = p.now.as_ref().is_some_and(|n| n.playing);
fn transport<'a>(t: &'static Tokens, p: &'a Player) -> Element<'a, Message> {
let has_track = p.track().is_some();
let toggle = |glyph: Icon, on: bool, action: Action| {
let toggle = |glyph: Icon, on: bool, msg: Msg| {
button(icon(glyph, if on { t.accent } else { t.muted }))
.padding(8)
.style(theme::icon_button(on.then_some(t.accent)))
.on_press(Message::Player(action))
.on_press(send(msg))
};
let skip = |glyph: Icon| {
let skip = |glyph: Icon, msg: Msg| {
button(icon(glyph, if has_track { t.fg } else { t.muted.scale_alpha(0.45) }))
.padding(8)
.style(theme::icon_button(None))
.on_press_maybe(has_track.then_some(send(msg)))
};
let disc_tint = if has_track { t.bg } else { t.muted };
let disc = button(
container(sized(if playing { Icon::Pause } else { Icon::Play }, 18.0, disc_tint)).center(40),
)
.width(40)
.height(40)
.padding(0)
.style(theme::play_disc);
let (glyph, tint) = match p.status() {
_ if !has_track => (Icon::Play, t.muted),
Status::Playing => (Icon::Pause, t.bg),
Status::Loading => (Icon::Pause, t.bg.scale_alpha(0.5)),
Status::Paused | Status::Ended => (Icon::Play, t.bg),
};
let disc = button(container(sized(glyph, 18.0, tint)).center(40))
.width(40)
.height(40)
.padding(0)
.style(theme::play_disc)
.on_press_maybe(has_track.then_some(send(Msg::Toggle)));
let ctrls = row![
toggle(Icon::Shuffle, p.shuffle, Action::ToggleShuffle),
skip(Icon::Previous),
toggle(Icon::Shuffle, p.shuffle(), Msg::ToggleShuffle),
skip(Icon::Previous, Msg::Previous),
disc,
skip(Icon::Next),
skip(Icon::Next, Msg::Next),
toggle(
if p.repeat == Repeat::One { Icon::RepeatOne } else { Icon::Repeat },
p.repeat != Repeat::Off,
Action::CycleRepeat,
Msg::CycleRepeat,
),
]
.spacing(8)
.align_y(Alignment::Center);
let (pos, dur) = p.now.as_ref().map_or((0.0, 0.0), |n| (n.position, n.duration));
let fraction = if dur > 0.0 { (pos / dur).clamp(0.0, 1.0) } else { 0.0 };
let duration = p.duration().as_secs_f32();
let position = p.position().as_secs_f32().min(duration);
let bar: Element<'a, Message> = if has_track && duration > 0.0 {
slider(0.0..=duration, position, |v| send(Msg::SeekPreview(v)))
.on_release(send(Msg::SeekCommit))
.step(0.5_f32)
.width(Fill)
.style(theme::seek_bar)
.into()
} else {
container(space())
.width(Fill)
.height(4)
.style(move |_| container::Style {
background: Some(t.raised.into()),
border: iced::Border { radius: 2.0.into(), ..Default::default() },
..Default::default()
})
.into()
};
let seek = row![
container(line(clock(pos), theme::BODY, 12.0, t.muted)).width(42).align_right(42),
static_bar(t, fraction),
container(line(clock(dur), theme::BODY, 12.0, t.muted)).width(42),
container(line(clock(position), theme::BODY, 12.0, t.muted)).width(42).align_right(42),
bar,
container(line(clock(duration), theme::BODY, 12.0, t.muted)).width(42),
]
.spacing(10)
.align_y(Alignment::Center)
.width(Fill);
column![ctrls, seek]
.spacing(4)
.align_x(Alignment::Center)
.max_width(560)
.into()
column![ctrls, seek].spacing(4).align_x(Alignment::Center).max_width(560).into()
}
/// Seek bar while there is nothing to seek; becomes a slider with the engine.
fn static_bar<'a>(t: &'static Tokens, fraction: f32) -> Element<'a, Message> {
let part = |portion: f32, colour: iced::Color| {
container(space())
.width(Length::FillPortion((portion * 1000.0).round().max(0.0) as u16))
.height(4)
.style(move |_| iced::widget::container::Style {
background: Some(colour.into()),
border: iced::Border { radius: 2.0.into(), ..Default::default() },
..Default::default()
})
};
if fraction <= 0.0 {
return part(1.0, t.raised).width(Fill).into();
}
row![part(fraction, t.accent), part(1.0 - fraction, t.raised)].width(Fill).into()
}
fn extras<'a>(t: &'static Tokens, p: &'a PlayerUi, drawer: Option<Panel>) -> Element<'a, Message> {
fn extras<'a>(t: &'static Tokens, p: &'a Player, drawer: Option<Panel>) -> Element<'a, Message> {
let panel_button = |glyph: Icon, panel: Panel| {
let on = drawer == Some(panel);
button(icon(glyph, if on { t.accent } else { t.muted }))
@@ -226,11 +168,10 @@ fn extras<'a>(t: &'static Tokens, p: &'a PlayerUi, drawer: Option<Panel>) -> Ele
};
let mut items = row![].spacing(4).align_y(Alignment::Center);
if let Some(now) = &p.now {
if let Some(stream) = p.stream() {
let label = if stream.preview { "Preview".to_owned() } else { stream.label() };
items = items.push(
container(line(&now.quality, theme::MEDIUM, 11.5, t.muted))
.padding([2, 6])
.style(theme::badge),
container(line(label, theme::MEDIUM, 11.5, t.muted)).padding([2, 6]).style(theme::badge),
);
}
@@ -242,10 +183,10 @@ fn extras<'a>(t: &'static Tokens, p: &'a PlayerUi, drawer: Option<Panel>) -> Ele
button(icon(if p.muted { Icon::Muted } else { Icon::Volume }, t.muted))
.padding(8)
.style(theme::icon_button(None))
.on_press(Message::Player(Action::ToggleMute)),
.on_press(send(Msg::ToggleMute)),
)
.push(
slider(0.0..=1.0, volume, |v| Message::Player(Action::SetVolume(v)))
slider(0.0..=1.0, volume, |v| send(Msg::SetVolume(v)))
.step(0.01_f32)
.width(96)
.style(theme::volume_bar),
@@ -262,7 +203,7 @@ pub fn clock(seconds: f32) -> String {
#[cfg(test)]
mod tests {
use super::*;
use super::clock;
#[test]
fn clock_formats() {
@@ -272,24 +213,4 @@ mod tests {
assert_eq!(clock(3725.0), "1:02:05");
assert_eq!(clock(-3.0), "0:00");
}
#[test]
fn repeat_cycles_off_all_one() {
let mut p = PlayerUi::default();
p.apply(Action::CycleRepeat);
assert_eq!(p.repeat, Repeat::All);
p.apply(Action::CycleRepeat);
assert_eq!(p.repeat, Repeat::One);
p.apply(Action::CycleRepeat);
assert_eq!(p.repeat, Repeat::Off);
}
#[test]
fn volume_is_clamped_and_zero_means_muted() {
let mut p = PlayerUi::default();
p.apply(Action::SetVolume(1.4));
assert_eq!(p.volume, 1.0);
p.apply(Action::SetVolume(0.0));
assert!(p.muted);
}
}
+95
View File
@@ -0,0 +1,95 @@
//! One row in a track list: number (or a playing marker), cover, title and
//! artists, album, like state, duration. Clicking anywhere plays it.
use iced::widget::{button, column, container, row, space};
use iced::{Alignment, Element, Fill, Length};
use ym_api::Track;
use crate::ui::icons::{Icon, icon, sized};
use crate::ui::line;
use crate::ui::theme::{self, Tokens, radius, 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 };
let number: Element<'static, M> = if playing {
sized(Icon::Wave, 16.0, t.accent).into()
} else {
line((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 content = row![
container(number).width(36).center_x(36),
container(space()).width(40).height(40).style(theme::cover(h1, h2, radius::SMALL_COVER)),
column![
line(track.full_title(), theme::MEDIUM, size::BODY, title_colour),
line(track.artist_line(), theme::BODY, size::META, t.muted),
]
.spacing(1)
.width(Length::FillPortion(22))
.clip(true),
container(line(
track.album.as_ref().map(|a| a.title.clone()).unwrap_or_default(),
theme::BODY,
size::META,
t.muted,
))
.width(Length::FillPortion(14))
.clip(true),
container(icon(
if liked { Icon::HeartFilled } else { Icon::Heart },
if liked { t.like } else { t.muted.scale_alpha(0.0) },
))
.width(34)
.center_x(34),
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))
.into()
}
/// Column headings above a track list, aligned with [`view`].
pub fn header<M: 'static>(t: &'static Tokens) -> Element<'static, M> {
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),
]
.spacing(12)
.align_y(Alignment::Center)
.padding([0, 10]),
container(space()).width(Fill).height(1).style(theme::divider),
]
.spacing(8)
.into()
}
+1 -1
View File
@@ -10,9 +10,9 @@ publish.workspace = true
yamuse = "0.3.2"
serde = { version = "1", features = ["derive"] }
thiserror = "2"
serde_json = "1"
[dev-dependencies]
serde_json = "1"
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
[lints]
+57 -3
View File
@@ -1,5 +1,8 @@
use crate::Result;
use std::sync::Arc;
use crate::auth::Credentials;
use crate::models::{Stream, Track, best_variant};
use crate::{Error, Result};
/// The signed-in user as the UI needs them.
#[derive(Debug, Clone, PartialEq, Eq)]
@@ -55,7 +58,7 @@ impl YmClient {
let inner = yamuse::Client::builder().token(&credentials.access_token).build()?;
let status = inner.refresh_account().await?;
let account = Account::from_status(status)
.ok_or_else(|| crate::Error::Unauthorized("account status has no user".into()))?;
.ok_or_else(|| Error::Unauthorized("account status has no user".into()))?;
Ok((Self { inner }, account))
}
@@ -64,11 +67,62 @@ impl YmClient {
Ok(Self { inner: yamuse::Client::anonymous()? })
}
/// The user's liked tracks, newest like first, with full metadata.
pub async fn liked_tracks(&self) -> Result<Vec<Track>> {
let list = self.inner.liked_tracks(None).await?;
let ids: Vec<String> = list
.tracks
.into_iter()
.filter_map(|short| {
let id = match short.id? {
yamuse::models::Id::Number(n) => n.to_string(),
yamuse::models::Id::Text(s) => s,
};
Some(match short.album_id {
Some(album) if !id.contains(':') => format!("{id}:{album}"),
_ => id,
})
})
.collect();
self.tracks(ids).await
}
/// Full metadata for `ids` (`"trackId"` or `"trackId:albumId"`), in the given order.
pub async fn tracks(&self, ids: Vec<String>) -> Result<Vec<Track>> {
if ids.is_empty() {
return Ok(Vec::new());
}
let tracks = self.inner.tracks(&ids).await?;
Ok(tracks.into_iter().filter_map(Track::from_yamuse).collect())
}
/// Resolves a signed, short-lived audio URL for a track.
pub async fn stream(&self, track_id: &str) -> Result<Stream> {
let variants = self.inner.track_download_info(track_id).await?;
let variant = best_variant(&variants)
.ok_or_else(|| Error::Api(format!("no playable variant for track {track_id}")))?;
let url = variant.direct_link(self.inner.transport()).await?;
Ok(Stream {
url,
codec: variant.codec.clone().unwrap_or_default(),
bitrate_kbps: variant.bitrate_in_kbps.unwrap_or(0).max(0) as u32,
preview: variant.preview.unwrap_or(false),
})
}
/// Downloads a whole stream into memory (a 320 kbps track is about 10 MB).
pub async fn fetch(&self, stream: &Stream) -> Result<Arc<[u8]>> {
let bytes = yamuse::download::Downloader::new(self.inner.transport(), [stream.url.clone()])
.to_bytes()
.await?;
Ok(bytes.into())
}
/// 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?;
Account::from_status(status)
.ok_or_else(|| crate::Error::Unauthorized("account status has no user".into()))
.ok_or_else(|| Error::Unauthorized("account status has no user".into()))
}
}
+2
View File
@@ -6,6 +6,8 @@
pub mod auth;
mod client;
mod error;
mod models;
pub use client::{Account, YmClient};
pub use models::{AlbumRef, ArtistRef, Stream, Track};
pub use error::{Error, Result};
+204
View File
@@ -0,0 +1,204 @@
//! The app-facing shapes of API objects. Converted from `yamuse` models,
//! keeping only what the UI uses and resolving every `Option` once, here.
use std::time::Duration;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ArtistRef {
pub id: Option<i64>,
pub name: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AlbumRef {
pub id: i64,
pub title: String,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Track {
/// Numeric track id as a string; user-uploaded tracks use non-numeric ids.
pub id: String,
pub title: String,
/// "Remastered 2011", "Live" and the like.
pub version: Option<String>,
pub artists: Vec<ArtistRef>,
pub album: Option<AlbumRef>,
pub duration: Duration,
/// `%%`-templated image uri; see [`Track::cover_url`].
cover_uri: Option<String>,
/// False for tracks removed from the catalogue or blocked in the region.
pub available: bool,
pub explicit: bool,
pub lyrics_available: bool,
}
impl Track {
pub(crate) fn from_yamuse(t: yamuse::models::Track) -> Option<Self> {
let id = match t.id? {
yamuse::models::Id::Number(n) => n.to_string(),
yamuse::models::Id::Text(s) if !s.is_empty() => s,
yamuse::models::Id::Text(_) => return None,
};
let album = t.albums.into_iter().find_map(|a| {
Some(AlbumRef { id: a.id?, title: a.title.unwrap_or_default() })
});
Some(Self {
id,
title: t.title.unwrap_or_else(|| "Untitled".into()),
version: t.version.filter(|v| !v.trim().is_empty()),
artists: t
.artists
.into_iter()
.filter_map(|a| {
Some(ArtistRef { id: a.id.and_then(|i| i.as_number()), name: a.name? })
})
.collect(),
album,
duration: Duration::from_millis(t.duration_ms.unwrap_or(0).max(0) as u64),
cover_uri: t.cover_uri.or(t.og_image),
available: t.available.unwrap_or(true),
explicit: t.explicit.unwrap_or(false)
|| t.content_warning.as_deref() == Some("explicit"),
lyrics_available: t.lyrics_available.unwrap_or(false),
})
}
/// Decodes a track 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("track has no id".into()))
}
/// "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(", ")
}
/// Title with its version: "Song (Live)".
pub fn full_title(&self) -> String {
match &self.version {
Some(v) => format!("{} ({v})", self.title),
None => self.title.clone(),
}
}
/// 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}")))
}
/// 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(
|| 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)
}
}
/// Where a track's audio comes from.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Stream {
pub url: String,
/// "mp3" or "aac".
pub codec: String,
pub bitrate_kbps: u32,
/// True when only a 30-second preview is available (no Plus).
pub preview: bool,
}
impl Stream {
/// "MP3 320", shown in the player bar.
pub fn label(&self) -> String {
format!("{} {}", self.codec.to_ascii_uppercase(), self.bitrate_kbps)
}
}
/// Picks the variant to play: full tracks over previews, MP3 over AAC (MP3 seeks
/// reliably), then the highest bitrate.
pub(crate) fn best_variant(
variants: &[yamuse::models::DownloadInfo],
) -> Option<&yamuse::models::DownloadInfo> {
variants
.iter()
.filter(|v| v.download_info_url.is_some())
.filter(|v| matches!(v.codec.as_deref(), Some("mp3" | "aac")))
.max_by_key(|v| {
(
!v.preview.unwrap_or(false),
v.codec.as_deref() == Some("mp3"),
v.bitrate_in_kbps.unwrap_or(0),
)
})
}
#[cfg(test)]
mod tests {
use super::*;
fn track(json: &str) -> Track {
Track::from_yamuse(serde_json::from_str(json).unwrap()).unwrap()
}
#[test]
fn track_converts_with_artists_album_and_cover() {
let t = track(
r#"{"id":"12345","title":"Звезда по имени Солнце","durationMs":225000,
"artists":[{"id":1,"name":"Кино"}],
"albums":[{"id":77,"title":"Звезда по имени Солнце"}],
"coverUri":"avatars.yandex.net/get-music-content/x/%%","lyricsAvailable":true}"#,
);
assert_eq!(t.id, "12345");
assert_eq!(t.artist_line(), "Кино");
assert_eq!(t.album.as_ref().unwrap().id, 77);
assert_eq!(t.duration, Duration::from_secs(225));
assert_eq!(
t.cover_url(200).as_deref(),
Some("https://avatars.yandex.net/get-music-content/x/200x200")
);
assert!(t.available && t.lyrics_available && !t.explicit);
}
#[test]
fn numeric_ids_and_versions() {
let t = track(r#"{"id":42,"title":"Song","version":"Live","artists":[]}"#);
assert_eq!(t.id, "42");
assert_eq!(t.full_title(), "Song (Live)");
assert_eq!(t.artist_line(), "Unknown artist");
assert!(Track::from_yamuse(serde_json::from_str(r#"{"title":"no id"}"#).unwrap()).is_none());
}
#[test]
fn hues_are_stable_and_in_range() {
let a = track(r#"{"id":1,"albums":[{"id":5}]}"#);
let b = track(r#"{"id":2,"albums":[{"id":5}]}"#);
assert_eq!(a.hues(), b.hues(), "same album, same art");
let (h1, h2) = a.hues();
assert!((0.0..360.0).contains(&h1) && (0.0..360.0).contains(&h2));
}
#[test]
fn best_variant_prefers_full_mp3_at_top_bitrate() {
let v: Vec<yamuse::models::DownloadInfo> = serde_json::from_str(
r#"[{"codec":"aac","bitrateInKbps":256,"downloadInfoUrl":"a"},
{"codec":"mp3","bitrateInKbps":192,"downloadInfoUrl":"b"},
{"codec":"mp3","bitrateInKbps":320,"downloadInfoUrl":"c"},
{"codec":"mp3","bitrateInKbps":320,"downloadInfoUrl":"p","preview":true},
{"codec":"flac","bitrateInKbps":900,"downloadInfoUrl":"f"}]"#,
)
.unwrap();
assert_eq!(best_variant(&v).unwrap().download_info_url.as_deref(), Some("c"));
let previews: Vec<yamuse::models::DownloadInfo> = serde_json::from_str(
r#"[{"codec":"mp3","bitrateInKbps":128,"downloadInfoUrl":"p","preview":true}]"#,
)
.unwrap();
assert!(best_variant(&previews).unwrap().preview.unwrap());
assert!(best_variant(&[]).is_none());
}
}