Musyx Mobile: Android TV player for Yandex Music

Kotlin, Compose for TV and Media3 port of the desktop Musyx, with
device-code sign-in, Home, My Wave, search, collection, detail pages,
Now Playing with queue and lyrics, and settings for streaming quality,
appearance, font size (small, medium, large) and language.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
yuriy.pandClaude Opus 5.5 committed 2026-10-16 22:14:54 +06:00
commit 46610d95fa
217 files changed
+26144

No files matched your search

+297
View File
@@ -0,0 +1,297 @@
//! Changing things: likes, dislikes, playlist edits, plus lyrics and the
//! server-side queue. Every change is shown at once and undone if Yandex refuses.
use crate::i18n::{tr, trf};
use std::sync::Arc;
use std::time::{Duration, Instant};
use iced::Task;
use ym_api::{Error, PlaylistId};
use super::{App, Message};
use crate::player;
use crate::route::Route;
use crate::screens::Loadable;
use crate::screens::collection::Liked;
use crate::widgets::sheet::Sheet;
/// How long a status message stays up.
const TOAST: Duration = Duration::from_secs(4);
/// What to reload after an edit lands.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Refresh {
Playlist(PlaylistId),
Playlists,
Liked,
LikedIds,
}
/// The outcome of a change sent to Yandex.
#[derive(Debug, Clone)]
pub struct Edited {
pub result: Result<(), Error>,
/// Shown when it worked.
pub done: String,
/// Shown when it didn't.
pub failed: String,
pub refresh: Vec<Refresh>,
}
impl App {
pub(super) fn toast(&mut self, text: impl Into<String>) {
self.toast = Some((text.into(), Instant::now()));
}
/// Sends a change, then reports and refreshes through [`Message::Edited`].
fn send_edit<F>(&self, change: F, done: String, failed: String, refresh: Vec<Refresh>) -> Task<Message>
where
F: std::future::Future<Output = Result<(), Error>> + Send + 'static,
{
Task::future(change).map(move |result| {
Message::Edited(Box::new(Edited { result, done: done.clone(), failed: failed.clone(), refresh: refresh.clone() }))
})
}
pub(super) fn update_edit(&mut self, message: Message) -> Task<Message> {
let Some(client) = self.client().cloned() else { return Task::none() };
match message {
Message::LikeTrack(track, on) => {
self.library.liked = self.library.liked.with(&track, on);
if on {
self.likes.disliked_tracks.remove(&track.id);
}
let id = track.full_id();
let c = client.clone();
self.send_edit(
async move { c.set_track_liked(&id, on).await },
if on { tr("Added to Liked tracks") } else { tr("Removed from Liked tracks") }.into(),
tr("Couldn't change the like. Try again.").into(),
vec![],
)
}
Message::DislikeTrack(track, on) => {
if on {
self.likes.disliked_tracks.insert(track.id.clone());
self.library.liked = self.library.liked.with(&track, false);
} else {
self.likes.disliked_tracks.remove(&track.id);
}
// Not hearing it again starts now.
let skip = if on && self.player.track().is_some_and(|t| t.id == track.id) {
self.update(Message::Player(player::Msg::Next))
} else {
Task::none()
};
let id = track.full_id();
let c = client.clone();
Task::batch([
skip,
self.send_edit(
async move { c.set_track_disliked(&id, on).await },
if on { tr("You won't be recommended this track") } else { tr("Recommendations for this track restored") }.into(),
tr("Couldn't change that. Try again.").into(),
vec![],
),
])
}
Message::LikeAlbum(id, on) => {
toggle(&mut self.likes.albums, id, on);
self.library.albums = Loadable::NotLoaded;
self.send_edit(
async move { client.set_album_liked(id, on).await },
if on { tr("Album added to your collection") } else { tr("Album removed from your collection") }.into(),
tr("Couldn't change the like. Try again.").into(),
vec![Refresh::LikedIds],
)
}
Message::LikeArtist(id, on) => {
toggle(&mut self.likes.artists, id, on);
self.library.artists = Loadable::NotLoaded;
self.send_edit(
async move { client.set_artist_liked(id, on).await },
if on { tr("Artist added to your collection") } else { tr("Artist removed from your collection") }.into(),
tr("Couldn't change the like. Try again.").into(),
vec![Refresh::LikedIds],
)
}
Message::LikePlaylist(id, on) => {
toggle(&mut self.likes.playlists, id, on);
self.send_edit(
async move { client.set_playlist_liked(id, on).await },
if on { tr("Playlist added to your collection") } else { tr("Playlist removed from your collection") }.into(),
tr("Couldn't change the like. Try again.").into(),
vec![Refresh::Playlists, Refresh::LikedIds],
)
}
Message::LikeClip(clip, on) => {
toggle(&mut self.likes.clips, clip.id, on);
if let Loadable::Loaded(clips) = &mut self.library.clips {
clips.retain(|c| c.id != clip.id);
if on {
clips.insert(0, clip.clone());
}
}
self.send_edit(
async move { client.set_clip_liked(clip.id, on).await },
if on { tr("Clip added to your collection") } else { tr("Clip removed from your collection") }.into(),
tr("Couldn't change the like. Try again.").into(),
vec![],
)
}
Message::AddToPlaylist(id, track) => {
self.sheet = None;
let title = self.playlist_title(id);
self.send_edit(
async move { client.add_to_playlist(id, &track).await },
trf("Added to “{}”", &[&title]),
trf("Couldn't add to “{}”. Try again.", &[&title]),
vec![Refresh::Playlist(id), Refresh::Playlists],
)
}
Message::CreatePlaylist => {
let Some(Sheet::NewPlaylist { name, add }) = self.sheet.take() else { return Task::none() };
let name = name.trim().to_owned();
if name.is_empty() {
return Task::none();
}
let done = match &add {
Some(_) => trf("Created “{}” with the track", &[&name]),
None => trf("Created “{}”", &[&name]),
};
self.send_edit(
async move {
let created = client.create_playlist(&name, false).await?;
if let Some(track) = add {
client.add_to_playlist(created.id, &track).await?;
}
Ok(())
},
done,
tr("Couldn't create the playlist. Try again.").into(),
vec![Refresh::Playlists],
)
}
Message::RenamePlaylist => {
let Some(Sheet::Rename { id, name }) = self.sheet.take() else { return Task::none() };
let name = name.trim().to_owned();
if name.is_empty() {
return Task::none();
}
let done = trf("Renamed to “{}”", &[&name]);
self.send_edit(
async move { client.rename_playlist(id, &name).await },
done,
tr("Couldn't rename the playlist. Try again.").into(),
vec![Refresh::Playlist(id), Refresh::Playlists],
)
}
Message::SetPlaylistPublic(id, public) => self.send_edit(
async move { client.set_playlist_public(id, public).await },
if public { tr("Anyone with the link can now see this playlist") } else { tr("Only you can see this playlist now") }.into(),
tr("Couldn't change who can see it. Try again.").into(),
vec![Refresh::Playlist(id), Refresh::Playlists],
),
Message::DeletePlaylist(id) => {
self.sheet = None;
let title = self.playlist_title(id);
if self.nav.current() == Route::Playlist(id) {
self.nav.back();
}
self.pages.remove(&Route::Playlist(id));
self.send_edit(
async move { client.delete_playlist(id).await },
trf("Deleted “{}”", &[&title]),
trf("Couldn't delete “{}”. Try again.", &[&title]),
vec![Refresh::Playlists],
)
}
Message::RemoveFromPlaylist(id, index) => {
self.sheet = None;
self.send_edit(
async move { client.remove_from_playlist(id, index).await },
tr("Removed from the playlist").into(),
tr("Couldn't remove the track. Try again.").into(),
vec![Refresh::Playlist(id), Refresh::Playlists],
)
}
Message::MovePlaylistTrack { id, track, from, to } => {
self.sheet = None;
self.send_edit(
async move { client.move_in_playlist(id, &track, from, to).await },
tr("Moved").into(),
tr("Couldn't move the track. Try again.").into(),
vec![Refresh::Playlist(id)],
)
}
Message::Edited(edited) => {
let Edited { result, done, failed, refresh } = *edited;
match result {
Ok(()) => {
self.toast(done);
Task::batch(refresh.into_iter().map(|r| self.refresh(r)))
}
Err(e) => {
if let Some(task) = self.failed("edit", &e) {
return task;
}
self.toast(failed);
// The optimistic change may be wrong now; re-read the truth.
Task::batch([self.refresh(Refresh::Liked), self.refresh(Refresh::LikedIds)])
}
}
}
_ => Task::none(),
}
}
fn playlist_title(&self, id: PlaylistId) -> String {
self.library
.playlists
.get()
.and_then(|p| p.own.iter().chain(&p.liked).find(|pl| pl.id == id))
.map_or_else(|| tr("the playlist").to_owned(), |p| p.title.clone())
}
pub(super) fn refresh(&mut self, what: Refresh) -> Task<Message> {
match what {
Refresh::Playlist(id) => {
let route = Route::Playlist(id);
self.pages.remove(&route);
if self.nav.current() == route { self.on_enter(route) } else { Task::none() }
}
Refresh::Playlists => self.update(Message::LoadLibrary(crate::screens::collection::Tab::Playlists)),
Refresh::Liked => {
self.library.liked = Liked::NotLoaded;
self.update(Message::LoadLiked)
}
Refresh::LikedIds => self.update(Message::LoadLikedIds),
}
}
/// Lyrics for the playing track, fetched once per track while the panel is open.
pub(super) fn want_lyrics(&mut self) -> Task<Message> {
let (Some(client), Some(track)) = (self.client().cloned(), self.player.track()) else { return Task::none() };
if self.drawer != Some(crate::widgets::drawer::Panel::Lyrics) || self.lyrics.contains_key(&track.id) {
return Task::none();
}
let id = track.id.clone();
self.lyrics.insert(id.clone(), Loadable::Loading);
Task::future(async move {
let result = client.lyrics(&id).await.map(|l| l.map(Arc::new));
Message::LyricsLoaded(id, result)
})
}
pub(super) fn toast_expired(&self) -> bool {
self.toast.as_ref().is_some_and(|(_, at)| at.elapsed() >= TOAST)
}
}
fn toggle<T: std::hash::Hash + Eq>(set: &mut std::collections::HashSet<T>, item: T, on: bool) {
if on {
set.insert(item);
} else {
set.remove(&item);
}
}