Compare commits

..
11 Commits
Author SHA1 Message Date
Ansho Rei 5bb42ba834 feat: log out of or forget a saved server, and pick one on the login screen
The queue button on a server row in Settings opens a prompt with Cancel,
Log out and Forget, replacing the double-press Remove. Log out keeps the
address and username without credentials; Forget also deletes the
server's saved queue and cover cache. The login screen lists the saved
servers beside the form, and a saved login the server turns down at
startup is logged out and opens the login screen prefilled.

Bumps the version to 0.10.0.
2026-11-06 23:34:30 +01:00
Ansho Rei 07214f1827 chore: bump the version to 0.9.1 for the fullscreen dev script steps 2026-11-06 20:28:50 +01:00
Ansho Rei 885ca01ff7 chore: drive and log the fullscreen toggle from the dev script
Adds a fullscreen step that runs the toggle action and a key:f11 step
that sends F11 through the Slint window, plus a debug log of the state
each toggle starts from. A scripted run could not reproduce F11 failing
to re-enter fullscreen on COSMIC, so the log is there for a manual run.
2026-11-06 20:27:29 +01:00
Ansho Rei 768ef0f919 chore: bump the version to 0.9.0 for shuffle 2026-11-05 19:29:17 +01:00
Ansho Rei 26d8bc417c feat: show the shuffle mode beside the queue on the now-playing screen
The hint bar names the mode too, but it can be turned off.
2026-11-05 19:22:54 +01:00
Ansho Rei 0200e73ba3 feat: shuffle the whole library from the Random section
Shuffle all, the first tile of the Random section, plays random tracks
from getRandomSongs and fetches another batch when fewer than five are
left. Played tracks past the last fifty are dropped, so the queue stays
small. Tracks queued meanwhile play after the playing track and after
anything queued before them, ahead of the random ones. Playing anything
else ends it, and it carries on after a restart.
2026-11-05 19:07:01 +01:00
Ansho Rei e11d95daa5 feat: shuffle play an album, artist or playlist with a long press
Holding South on a row, or shift+s on the keyboard, plays its tracks in
random order with track shuffle on, so turning shuffle off goes back to
their own order. On a song row it shuffles the page the song is on. An
artist plays every track of every album, fetched a few albums at a time.

South now acts on release, so a long press can mean something else. A
long press on a row with nothing to shuffle activates as before.
2026-11-05 19:04:08 +01:00
Ansho Rei 3d91739447 feat: cycle the queue through track shuffle, album shuffle and off
North on the now-playing screen, or s anywhere, shuffles what has not
played yet. Off goes back to the order the tracks were queued in and
carries on after the playing track. Tracks queued while shuffled go to
random positions, an album as one block under album shuffle.

The player reorders its own list under its lock and keeps a track it
already handed to playbin next, so playback stays gapless. Each reorder
bumps a queue generation that track and picture events carry, and the
app drops an event sent before the last reorder. The saved queue keeps
the original order and the mode; older files load unshuffled.
2026-11-05 18:57:56 +01:00
Ansho Rei 7b2fe7c84e feat: add track, album and insert shuffle orders
Each function returns positions in the new play order, so the queue,
the original order and the player's URLs can be reordered by the same
list. Nothing calls them yet.
2026-11-05 18:39:03 +01:00
Ansho Rei 10710c1755 feat: read a song's album id and fetch random songs from the server
Album shuffle groups tracks by album id, since the album name alone
merges different albums with the same title. Library shuffle tops up
the queue with getRandomSongs.
2026-11-05 18:39:03 +01:00
Ansho Rei bce0d68442 feat: show a track's own cover on its album page row
A track whose cover is a different picture from the album's now shows
that cover in its row instead of the track number. Pictures are compared
decoded, since Navidrome gives every track its own cover id even when it
is the album's image. The number column is as wide as the cover, so rows
with and without one line up.
2026-11-04 22:09:32 +01:00
18 changed files with 1894 additions and 187 deletions
+32
View File
@@ -2,6 +2,38 @@
One section per version, newest first.
## v0.10.0 (2026-11-06)
### Features
- A saved server in Settings can be logged out of or forgotten. The queue button opens a prompt naming the server, with Cancel selected. Log out drops the token or password and keeps the address and username. Forget removes the server, its saved queue and its cached covers. Both replace the double-press Remove.
- The login screen lists the saved servers beside the form. Picking one fills in its address and username and moves to the password. Selecting a logged-out server in Settings opens the same prefilled form, and logging in again reuses its entry.
- A saved login that the server turns down at startup is logged out, and the login screen opens prefilled with it instead of showing load errors.
### Bug fixes
- An http and an https login to the same host and user are labelled apart: the scheme is shown for http.
## v0.9.1 (2026-11-06)
### Features
- The dev script (REMUS_DEV_SCRIPT) has a fullscreen step that toggles fullscreen and a key:f11 step that presses F11. With RUST_LOG=remus=debug, each toggle logs whether the window was fullscreen and its size.
## v0.9.0 (2026-11-05)
### Features
- The queue can be shuffled from the now-playing screen. The queue button, or S on the keyboard, cycles through shuffling by track, shuffling by album and off. Album shuffle finishes the playing album first. Off goes back to the order the tracks were queued in and carries on after the playing track. Tracks queued while shuffled go to random places among those still to play. The mode shows beside the queue and comes back after a restart.
- Holding the activate button on an album, artist or playlist, or pressing Shift+S, plays it shuffled. On a track it shuffles the page the track is on. The activate button now acts when it is released.
- Shuffle all, the first tile in Random, plays random tracks from the whole library and keeps fetching more. Tracks queued meanwhile play next, ahead of the random ones.
## v0.8.7 (2026-11-04)
### Features
- On an album page, a track whose cover is a different picture from the album's shows its cover instead of its track number. Only servers that give tracks their own art, such as Navidrome, can show this; Nextcloud Music gives every track the album's cover.
## v0.8.6 (2026-11-04)
### Bug fixes
Generated
+2 -1
View File
@@ -4385,11 +4385,12 @@ checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
[[package]]
name = "remus"
version = "0.8.6"
version = "0.10.0"
dependencies = [
"anyhow",
"directories",
"env_logger",
"fastrand",
"fontique",
"gilrs",
"gstreamer",
+2 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "remus"
version = "0.8.6"
version = "0.10.0"
edition = "2024"
license = "MIT"
@@ -8,6 +8,7 @@ license = "MIT"
anyhow = "1.0.104"
directories = "6.0.0"
env_logger = "0.11.11"
fastrand = "2.5.0"
fontique = { version = "0.11", default-features = false, features = ["fontconfig-dlopen"] }
gilrs = "0.11.2"
gstreamer = "0.25.4"
+1 -1
View File
@@ -17,7 +17,7 @@ cargo run --release # fullscreen
cargo run --release -- --windowed
```
On first start remus asks for the server address, username and password. It stores the address, the username and an auth token (md5 of password + salt) in `~/.config/remus/config.toml`, mode 0600. The token is enough to log in to that server, so treat the file as a credential. Delete it to log in again.
On first start remus asks for the server address, username and password. It stores the address, the username and an auth token (md5 of password + salt) in `~/.config/remus/config.toml`, mode 0600. The token is enough to log in to that server, so treat the file as a credential. To log in again, or to remove a server, select it under Settings and press the queue button (Y on a controller, Q on a keyboard). Log out drops the token and keeps the address and username, so the login screen lists the server and only asks for the password. Forget removes the server along with its saved queue and cached covers. If the server stops accepting the saved token, remus logs it out at startup and asks for the password.
Some servers refuse token logins (Subsonic error 41), Nextcloud Music among them. For those remus logs in with the password itself and stores that in `config.toml` instead of a token, still mode 0600. Nextcloud Music wants the API password generated in its Music settings, not the Nextcloud login password.
@@ -20,6 +20,10 @@
</supports>
<content_rating type="oars-1.1"/>
<releases>
<release version="0.10.0" date="2026-11-06"/>
<release version="0.9.1" date="2026-11-06"/>
<release version="0.9.0" date="2026-11-05"/>
<release version="0.8.7" date="2026-11-04"/>
<release version="0.8.6" date="2026-11-04"/>
<release version="0.8.5" date="2026-11-04"/>
<release version="0.8.4" date="2026-11-04"/>
+681 -49
View File
File diff suppressed because it is too large Load Diff
+138 -6
View File
@@ -11,7 +11,8 @@ use crate::subsonic::{Auth, Client};
/// Server credentials, written 0600. Either a token, md5(password + salt),
/// which is not the password but is enough to log in to this server; or, for
/// a server that refuses tokens, the password itself.
/// a server that refuses tokens, the password itself. Neither means logged
/// out: the server and username are kept for logging in again.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Config {
pub url: String,
@@ -39,6 +40,17 @@ impl Config {
}
}
pub fn logged_in(&self) -> bool {
self.password.is_some() || !self.token.is_empty()
}
/// Drops the credentials, keeping the server and username.
pub fn log_out(&mut self) {
self.salt.clear();
self.token.clear();
self.password = None;
}
pub fn client(&self) -> Client {
let auth = match &self.password {
Some(p) => Auth::Password(p.clone()),
@@ -72,8 +84,7 @@ pub fn state_dir() -> Option<PathBuf> {
impl Config {
/// Names the server and user, as the sidebar shows them.
pub fn label(&self) -> String {
let host = self.url.split("://").nth(1).unwrap_or(&self.url);
format!("{} on {}", self.username, host.trim_end_matches('/'))
server_label(&self.url, &self.username)
}
fn same_login(&self, other: &Config) -> bool {
@@ -81,10 +92,21 @@ impl Config {
}
}
/// "user on host". The scheme is left out for https only, so an http and an
/// https login to the same host can be told apart.
pub fn server_label(url: &str, username: &str) -> String {
let host = match url.split_once("://") {
Some(("https", rest)) => rest,
_ => url,
};
format!("{} on {}", username, host.trim_end_matches('/'))
}
/// Every saved login, and which one is browsed.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Logins {
/// Index into `servers`.
/// Index into `servers`. Points at a logged-in server whenever there is
/// one.
#[serde(default)]
pub active: usize,
/// `[[server]]` tables in the file.
@@ -93,8 +115,22 @@ pub struct Logins {
}
impl Logins {
/// The server being browsed, or none when every saved one is logged out.
pub fn active(&self) -> Option<&Config> {
self.servers.get(self.active)
self.servers.get(self.active).filter(|c| c.logged_in())
}
/// Moves `active` off a server that is gone or logged out, to the first
/// logged-in one.
fn settle_active(&mut self) {
if self.active().is_none() {
self.active = self.servers.iter().position(Config::logged_in).unwrap_or(0);
}
}
/// The saved entry for this server and user, logged in or not.
pub fn find(&self, url: &str, username: &str) -> Option<usize> {
self.servers.iter().position(|s| s.url == url && s.username == username)
}
/// Adds a login, or refreshes the saved one for the same server and user,
@@ -113,7 +149,7 @@ impl Logins {
}
/// Removes a login. The active one stays the same server where it can;
/// removing it makes the first remaining login active.
/// removing it makes the first remaining logged-in server active.
pub fn remove(&mut self, i: usize) {
if i >= self.servers.len() {
return;
@@ -124,6 +160,16 @@ impl Logins {
} else if i == self.active {
self.active = 0;
}
self.settle_active();
}
/// Logs out of a server, keeping its entry. Logging out of the active one
/// makes the first logged-in server active.
pub fn log_out(&mut self, i: usize) {
if let Some(s) = self.servers.get_mut(i) {
s.log_out();
self.settle_active();
}
}
}
@@ -143,6 +189,7 @@ fn parse_logins(text: &str) -> Result<Logins> {
if l.active >= l.servers.len() {
l.active = 0;
}
l.settle_active();
l
}
Stored::One(c) => Logins {
@@ -362,6 +409,91 @@ mod tests {
assert_eq!(parse_logins(text).unwrap().active, 0);
}
#[test]
fn a_logged_out_login_keeps_its_server_and_round_trips() {
let mut l = Logins::default();
l.add(login(
"https://a",
"u",
Auth::Token {
salt: "s".into(),
token: "t".into(),
},
));
l.add(login("https://b", "v", Auth::Password("p".into())));
l.log_out(0);
l.log_out(1);
let text = toml::to_string(&l).unwrap();
assert!(
!text.contains("salt") && !text.contains("token") && !text.contains("password"),
"{text}"
);
let back = parse_logins(&text).unwrap();
assert_eq!(back, l);
assert_eq!(back.servers.len(), 2);
assert!(back.servers.iter().all(|s| !s.logged_in()));
assert_eq!(back.servers[1].url, "https://b");
assert_eq!(back.servers[1].username, "v");
assert!(back.active().is_none());
}
#[test]
fn the_active_login_skips_logged_out_servers() {
let mut l = Logins::default();
for host in ["https://a", "https://b", "https://c"] {
l.add(login(host, "u", Auth::Password("p".into())));
}
l.active = 0;
l.log_out(1);
assert_eq!(l.active().unwrap().url, "https://a");
l.log_out(0);
assert_eq!(l.active().unwrap().url, "https://c");
l.log_out(2);
assert!(l.active().is_none());
// Logging in again reuses the entry and makes it active.
l.add(login("https://b", "u", Auth::Password("p".into())));
assert_eq!(l.servers.len(), 3);
assert_eq!(l.active().unwrap().url, "https://b");
}
#[test]
fn a_saved_active_index_on_a_logged_out_server_moves_to_a_logged_in_one() {
let text = "active = 0\n[[server]]\nurl = \"https://a\"\nusername = \"u\"\n\
[[server]]\nurl = \"https://b\"\nusername = \"u\"\npassword = \"p\"\n";
let l = parse_logins(text).unwrap();
assert_eq!(l.active, 1);
assert_eq!(l.active().unwrap().url, "https://b");
}
#[test]
fn removing_the_active_login_skips_logged_out_servers() {
let mut l = Logins::default();
for host in ["https://a", "https://b", "https://c"] {
l.add(login(host, "u", Auth::Password("p".into())));
}
l.log_out(0);
l.active = 1;
l.remove(1);
assert_eq!(l.active().unwrap().url, "https://c");
}
#[test]
fn a_login_list_from_v0_8_0_loads_logged_in() {
let text = "active = 1\n\
[[server]]\nurl = \"https://a\"\nusername = \"u\"\nsalt = \"s\"\ntoken = \"t\"\n\
[[server]]\nurl = \"https://b\"\nusername = \"v\"\npassword = \"p\"\n";
let l = parse_logins(text).unwrap();
assert_eq!(l.servers.len(), 2);
assert!(l.servers.iter().all(Config::logged_in));
assert_eq!(l.active().unwrap().url, "https://b");
}
#[test]
fn labels_tell_http_and_https_apart() {
assert_eq!(server_label("https://h/", "u"), "u on h");
assert_eq!(server_label("http://h", "u"), "u on http://h");
}
#[test]
fn settings_default_when_fields_are_missing() {
let s: Settings = toml::from_str("").unwrap();
+11
View File
@@ -56,6 +56,13 @@ fn step(ui: slint::Weak<AppWindow>, steps: Vec<String>, i: usize) {
Err(e) => log::error!("snapshot failed: {e}"),
}
}
Some(("key", "f11")) => {
use slint::platform::{Key, WindowEvent};
let text: slint::SharedString = Key::F11.into();
win.window()
.dispatch_event(WindowEvent::KeyPressed { text: text.clone() });
win.window().dispatch_event(WindowEvent::KeyReleased { text });
}
Some(("prompts", kind)) => {
use crate::prompts::Family;
let family = match kind {
@@ -95,6 +102,10 @@ fn step(ui: slint::Weak<AppWindow>, steps: Vec<String>, i: usize) {
"volume-up" => Action::VolumeUp,
"volume-down" => Action::VolumeDown,
"mute" => Action::ToggleMute,
"cycle-shuffle" => Action::CycleShuffle,
"shuffle" => Action::Shuffle,
"hold-activate" => Action::HoldActivate,
"fullscreen" => Action::ToggleFullscreen,
other => {
log::warn!("unknown dev script step {other}");
Action::None
+36 -2
View File
@@ -27,6 +27,8 @@ const REPEAT_DELAY: Duration = Duration::from_millis(380);
const REPEAT_SLOW: Duration = Duration::from_millis(110);
const REPEAT_FAST: Duration = Duration::from_millis(45);
const FAST_AFTER: Duration = Duration::from_millis(1500);
/// How long South is held before it counts as a long press.
const LONG_PRESS: Duration = Duration::from_millis(500);
const STICK_ON: f32 = 0.55;
const STICK_OFF: f32 = 0.35;
@@ -37,6 +39,14 @@ enum Source {
RightStick,
}
/// South acts on release, so a long press can mean something else.
struct SouthPress {
family: Family,
since: Instant,
/// Sent as a long press already, so the release sends nothing.
long: bool,
}
struct Held {
source: Source,
action: Action,
@@ -66,6 +76,7 @@ pub fn spawn_gamepad(emit: impl Fn(PadEvent) + Send + 'static) {
}
emit(PadEvent::Present(present(&gilrs, &mut families)));
let mut held: Option<Held> = None;
let mut south: Option<SouthPress> = None;
loop {
while let Some(ev) = gilrs.next_event_blocking(Some(Duration::from_millis(15))) {
if matches!(ev.event, EventType::Connected | EventType::Disconnected) {
@@ -77,6 +88,20 @@ pub fn spawn_gamepad(emit: impl Fn(PadEvent) + Send + 'static) {
}
let family = families.family(&gilrs, ev.id);
match ev.event {
EventType::ButtonPressed(Button::South, _) => {
south = Some(SouthPress {
family,
since: Instant::now(),
long: false,
});
}
EventType::ButtonReleased(Button::South, _) => {
if let Some(p) = south.take()
&& !p.long
{
emit(PadEvent::Action(Action::Activate, p.family));
}
}
EventType::ButtonPressed(b, _) => {
if let Some(a) = dpad_action(b) {
held = Some(start_hold(Source::DPad, a, family));
@@ -108,10 +133,20 @@ pub fn spawn_gamepad(emit: impl Fn(PadEvent) + Send + 'static) {
_ => {}
}
}
EventType::Disconnected => held = None,
EventType::Disconnected => {
held = None;
south = None;
}
_ => {}
}
}
if let Some(p) = south.as_mut()
&& !p.long
&& p.since.elapsed() >= LONG_PRESS
{
p.long = true;
emit(PadEvent::Action(Action::HoldActivate, p.family));
}
if let Some(h) = held.as_mut() {
let now = Instant::now();
if now >= h.next {
@@ -216,7 +251,6 @@ fn dpad_action(b: Button) -> Option<Action> {
fn button_action(b: Button) -> Option<Action> {
Some(match b {
Button::South => Action::Activate,
Button::East => Action::Back,
Button::West => Action::PlayPause,
Button::North => Action::Queue,
+1
View File
@@ -10,6 +10,7 @@ mod palette;
mod player;
mod prompts;
mod saved_queue;
mod shuffle;
mod subsonic;
use std::time::Duration;
+179 -36
View File
@@ -17,12 +17,30 @@ pub enum PlayerEvent {
Position(f64),
Duration(f64),
Paused(bool),
/// Index into the queue, None when playback has stopped.
Track(Option<usize>),
/// The picture embedded in a track's file, or None once it is clear the
/// file has none. Sent once per track started, after its `Track`. A
/// picture that turns up late is still sent, after the None.
Art(usize, Option<Vec<u8>>),
/// Index into the queue, None when playback has stopped. An index is
/// only valid for the queue `generation` it was sent from: see `reorder`.
Track {
index: Option<usize>,
generation: u64,
},
/// The picture embedded in the playing track's file, or None once it is
/// clear the file has none. Sent once per track started, after its
/// `Track`. A picture that turns up late is still sent, after the None.
Art {
index: usize,
generation: u64,
picture: Option<Vec<u8>>,
},
}
/// The queue after `reorder`.
#[derive(Debug, Clone, PartialEq)]
pub struct Reordered {
/// The new order, as positions in the old one.
pub perm: Vec<usize>,
pub current: Option<usize>,
pub pending: Option<usize>,
pub generation: u64,
}
#[derive(Default)]
@@ -36,6 +54,8 @@ struct Queue {
hold: bool,
/// Seconds to seek to once the paused track has prerolled.
seek_to: Option<f64>,
/// Bumped by every reorder, so an index sent before one is recognised.
generation: u64,
}
/// Pictures found in the files being decoded, by URI.
@@ -112,6 +132,28 @@ impl Player {
self.play_index(start);
}
/// Reorders the queue without interrupting the playing track. `arrange`
/// gets the playing position and the one already handed to playbin, and
/// returns the new order as positions in the old one; a position it
/// leaves out is dropped. It runs under the queue lock, so no track
/// starts in between: keep the handed-over track right after the playing
/// one, or the queue jumps to wherever it went once it starts.
pub fn reorder(&self, arrange: impl FnOnce(Option<usize>, Option<usize>) -> Vec<usize>) -> Reordered {
let mut q = lock(&self.queue);
let perm = arrange(q.current, q.pending);
let moved = |i: Option<usize>| i.and_then(|i| perm.iter().position(|&p| p == i));
q.current = moved(q.current);
q.pending = moved(q.pending);
q.urls = perm.iter().filter_map(|&p| q.urls.get(p).cloned()).collect();
q.generation += 1;
Reordered {
current: q.current,
pending: q.pending,
generation: q.generation,
perm,
}
}
/// Adds to the end of the queue, starting playback if it had stopped.
pub fn append(&self, url: &str) {
let start = {
@@ -162,7 +204,12 @@ impl Player {
/// Stops playback and forgets the queue, as when switching server. Going
/// to Null flushes the bus, so nothing from the old track reports later.
pub fn stop(&self) {
*lock(&self.queue) = Queue::default();
let mut q = lock(&self.queue);
*q = Queue {
generation: q.generation,
..Queue::default()
};
drop(q);
lock(&self.pictures).clear();
let _ = self.playbin.set_state(gst::State::Null);
}
@@ -273,7 +320,7 @@ fn watch_pictures(playbin: &gst::Element, pictures: &Pictures) {
/// The track whose picture is still being looked for.
struct ArtWait {
index: usize,
url: String,
since: Instant,
/// Already reported as without a picture; one turning up later is still sent.
told_none: bool,
@@ -320,12 +367,13 @@ fn watch_bus(
let mut duration = 0.0;
// playbin can post stream-start more than once for one track, so a repeat
// of the last report is dropped. A track that was just started is always
// reported, even at the same index: a new queue, or the same track again.
let mut last_track: Option<Option<usize>> = None;
let mut report_track = |t: Option<usize>, started: bool| {
if started || last_track != Some(t) {
last_track = Some(t);
emit(PlayerEvent::Track(t));
// reported, even the same one: a new queue, or the same track again. By
// URL, since a reorder moves the track without restarting it.
let mut last_track: Option<Option<String>> = None;
let mut report_track = |index: Option<usize>, url: Option<String>, generation: u64, started: bool| {
if started || last_track.as_ref() != Some(&url) {
last_track = Some(url);
emit(PlayerEvent::Track { index, generation });
emit(PlayerEvent::Position(0.0));
true
} else {
@@ -338,7 +386,7 @@ fn watch_bus(
use gst::MessageView;
match msg.view() {
MessageView::StreamStart(_) => {
let (current, started) = {
let (current, url, generation, started) = {
let mut q = lock(queue);
let started = match q.pending.take() {
Some(p) => {
@@ -347,12 +395,13 @@ fn watch_bus(
}
None => false,
};
(q.current, started)
let url = q.current.and_then(|i| q.urls.get(i).cloned());
(q.current, url, q.generation, started)
};
duration = 0.0;
if report_track(current, started) {
art_wait = current.map(|index| ArtWait {
index,
if report_track(current, url.clone(), generation, started) {
art_wait = url.map(|url| ArtWait {
url,
since: Instant::now(),
told_none: false,
});
@@ -390,8 +439,9 @@ fn watch_bus(
q.current = None;
q.pending = None;
}
let generation = lock(queue).generation;
let _ = playbin.set_state(gst::State::Ready);
report_track(None, false);
report_track(None, None, generation, false);
art_wait = None;
}
// A failing source posts several errors. Once the first has moved
@@ -424,8 +474,9 @@ fn watch_bus(
start(playbin, &url);
}
} else {
let generation = lock(queue).generation;
let _ = playbin.set_state(gst::State::Ready);
report_track(None, false);
report_track(None, None, generation, false);
art_wait = None;
}
}
@@ -433,14 +484,32 @@ fn watch_bus(
}
}
if let Some(w) = &mut art_wait {
let url = lock(queue).urls.get(w.index).cloned();
let picture = url.and_then(|u| lock(pictures).get(&u).cloned());
if picture.is_some() {
emit(PlayerEvent::Art(w.index, picture));
art_wait = None;
} else if !w.told_none && w.since.elapsed() >= ART_WAIT {
w.told_none = true;
emit(PlayerEvent::Art(w.index, None));
// Where the track is now, since a reorder may have moved it.
let (index, generation) = {
let q = lock(queue);
let index = q.current.filter(|&i| q.urls.get(i) == Some(&w.url));
(index, q.generation)
};
let picture = lock(pictures).get(&w.url).cloned();
match index {
None => art_wait = None,
Some(index) if picture.is_some() => {
emit(PlayerEvent::Art {
index,
generation,
picture,
});
art_wait = None;
}
Some(index) if !w.told_none && w.since.elapsed() >= ART_WAIT => {
w.told_none = true;
emit(PlayerEvent::Art {
index,
generation,
picture: None,
});
}
Some(_) => {}
}
}
if last_tick.elapsed() >= TICK {
@@ -580,8 +649,8 @@ mod tests {
let (tx, rx) = mpsc::channel();
let player = Player::spawn(move |ev| {
if let PlayerEvent::Art(i, bytes) = ev {
let _ = tx.send((i, bytes));
if let PlayerEvent::Art { index, picture, .. } = ev {
let _ = tx.send((index, picture));
}
})
.unwrap();
@@ -604,8 +673,8 @@ mod tests {
let (tx, rx) = mpsc::channel();
let player = Player::spawn(move |ev| {
if let PlayerEvent::Track(t) = ev {
let _ = tx.send(t);
if let PlayerEvent::Track { index, .. } = ev {
let _ = tx.send(index);
}
})
.unwrap();
@@ -635,8 +704,8 @@ mod tests {
let (tx, rx) = mpsc::channel();
let player = Player::spawn(move |ev| {
if let PlayerEvent::Track(t) = ev {
let _ = tx.send(t);
if let PlayerEvent::Track { index, .. } = ev {
let _ = tx.send(index);
}
})
.unwrap();
@@ -681,7 +750,7 @@ mod tests {
let deadline = Instant::now() + Duration::from_secs(2);
while let Some(left) = deadline.checked_duration_since(Instant::now()) {
match rx.recv_timeout(left) {
Ok(PlayerEvent::Track(t)) => track = t,
Ok(PlayerEvent::Track { index, .. }) => track = index,
Ok(PlayerEvent::Paused(false)) => started = true,
Ok(PlayerEvent::Position(p)) if p > 0.0 => started = true,
Ok(_) => {}
@@ -722,4 +791,78 @@ mod tests {
drop(player);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_reorder_keeps_the_track_playing_and_plays_the_new_order() {
// SAFETY: set before any thread reads the environment in this test.
unsafe { std::env::set_var("REMUS_AUDIO_SINK", "fakesink") };
let dir = std::env::temp_dir().join(format!("remus-player-reorder-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let urls = vec![
silent_wav(&dir, "a.wav", 0.8),
silent_wav(&dir, "b.wav", 0.6),
silent_wav(&dir, "c.wav", 0.6),
];
let (tx, rx) = mpsc::channel();
let player = Player::spawn(move |ev| {
if let PlayerEvent::Track { index, generation } = ev {
let _ = tx.send((index, generation));
}
})
.unwrap();
player.play_list(&urls, 0);
assert_eq!(rx.recv_timeout(Duration::from_secs(5)), Ok((Some(0), 0)));
let r = player.reorder(|current, pending| {
assert_eq!((current, pending), (Some(0), None));
vec![0, 2, 1]
});
assert_eq!((r.current, r.pending, r.generation), (Some(0), None, 1));
let mut tracks = Vec::new();
let mut played = Vec::new();
while let Ok((t, generation)) = rx.recv_timeout(Duration::from_secs(5)) {
assert_eq!(generation, 1);
tracks.push(t);
played.extend(t.map(|i| lock(&player.queue).urls[i].clone()));
if t.is_none() {
break;
}
}
drop(player);
let _ = std::fs::remove_dir_all(&dir);
assert_eq!(tracks, vec![Some(1), Some(2), None], "a did not start again");
assert_eq!(played, vec![urls[2].clone(), urls[1].clone()]);
}
#[test]
fn a_reorder_can_drop_tracks_before_the_playing_one() {
// SAFETY: set before any thread reads the environment in this test.
unsafe { std::env::set_var("REMUS_AUDIO_SINK", "fakesink") };
let dir = std::env::temp_dir().join(format!("remus-player-trim-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let urls: Vec<String> = ["a", "b", "c"]
.iter()
.map(|n| silent_wav(&dir, &format!("{n}.wav"), 10.0))
.collect();
let (tx, rx) = mpsc::channel();
let player = Player::spawn(move |ev| {
if let PlayerEvent::Track { index, .. } = ev {
let _ = tx.send(index);
}
})
.unwrap();
player.play_list(&urls, 1);
assert_eq!(rx.recv_timeout(Duration::from_secs(3)), Ok(Some(1)));
let r = player.reorder(|_, _| vec![1, 2]);
assert_eq!(r.current, Some(0));
player.next();
assert_eq!(rx.recv_timeout(Duration::from_secs(3)), Ok(Some(1)));
assert_eq!(lock(&player.queue).urls, urls[1..]);
drop(player);
let _ = std::fs::remove_dir_all(&dir);
}
}
+18 -1
View File
@@ -35,6 +35,11 @@ pub enum Control {
Seek,
Volume,
Mute,
/// Cycles the shuffle mode on now playing: the queue button on a
/// controller, a key of its own on the keyboard.
Shuffle,
/// Shuffle play on a row: a long press of activate on a controller.
ShufflePlay,
/// Steam + X brings up Steam's on-screen keyboard. Nothing to show for a
/// real keyboard.
OnScreenKeyboard,
@@ -42,7 +47,7 @@ pub enum Control {
#[cfg(test)]
impl Control {
pub const ALL: [Control; 12] = [
pub const ALL: [Control; 14] = [
Control::Activate,
Control::Back,
Control::PlayPause,
@@ -54,6 +59,8 @@ impl Control {
Control::Seek,
Control::Volume,
Control::Mute,
Control::Shuffle,
Control::ShufflePlay,
Control::OnScreenKeyboard,
];
}
@@ -81,13 +88,17 @@ pub fn icons(prompts: Prompts, control: Control) -> &'static [&'static [u8]] {
Seek => &[icon!("keyboard", "keyboard_arrows_horizontal")],
Volume => &[icon!("keyboard", "keyboard_minus"), icon!("keyboard", "keyboard_plus")],
Mute => &[icon!("keyboard", "keyboard_m")],
Shuffle => &[icon!("keyboard", "keyboard_s")],
ShufflePlay => &[icon!("keyboard", "keyboard_shift"), icon!("keyboard", "keyboard_s")],
OnScreenKeyboard => &[],
},
Prompts::Pad(Family::Xbox) => match control {
Activate => &[icon!("xbox", "xbox_button_color_a")],
ShufflePlay => &[icon!("xbox", "xbox_button_color_a")],
Back => &[icon!("xbox", "xbox_button_color_b")],
PlayPause => &[icon!("xbox", "xbox_button_color_x")],
Queue => &[icon!("xbox", "xbox_button_color_y")],
Shuffle => &[icon!("xbox", "xbox_button_color_y")],
Skip => &[icon!("xbox", "xbox_lb"), icon!("xbox", "xbox_rb")],
Sections => &[icon!("xbox", "xbox_lt"), icon!("xbox", "xbox_rt")],
Search => &[icon!("xbox", "xbox_button_view")],
@@ -99,9 +110,11 @@ pub fn icons(prompts: Prompts, control: Control) -> &'static [&'static [u8]] {
},
Prompts::Pad(Family::PlayStation) => match control {
Activate => &[icon!("playstation", "playstation_button_color_cross")],
ShufflePlay => &[icon!("playstation", "playstation_button_color_cross")],
Back => &[icon!("playstation", "playstation_button_color_circle")],
PlayPause => &[icon!("playstation", "playstation_button_color_square")],
Queue => &[icon!("playstation", "playstation_button_color_triangle")],
Shuffle => &[icon!("playstation", "playstation_button_color_triangle")],
Skip => &[
icon!("playstation", "playstation_trigger_l1"),
icon!("playstation", "playstation_trigger_r1"),
@@ -124,9 +137,11 @@ pub fn icons(prompts: Prompts, control: Control) -> &'static [&'static [u8]] {
// By position, as gilrs reports buttons: the bottom face button is B on a Switch.
Prompts::Pad(Family::Switch) => match control {
Activate => &[icon!("switch", "switch_button_b")],
ShufflePlay => &[icon!("switch", "switch_button_b")],
Back => &[icon!("switch", "switch_button_a")],
PlayPause => &[icon!("switch", "switch_button_y")],
Queue => &[icon!("switch", "switch_button_x")],
Shuffle => &[icon!("switch", "switch_button_x")],
Skip => &[icon!("switch", "switch_button_l"), icon!("switch", "switch_button_r")],
Sections => &[icon!("switch", "switch_button_zl"), icon!("switch", "switch_button_zr")],
Search => &[icon!("switch", "switch_button_minus")],
@@ -141,9 +156,11 @@ pub fn icons(prompts: Prompts, control: Control) -> &'static [&'static [u8]] {
},
Prompts::Pad(Family::SteamDeck) => match control {
Activate => &[icon!("steamdeck", "steamdeck_button_a")],
ShufflePlay => &[icon!("steamdeck", "steamdeck_button_a")],
Back => &[icon!("steamdeck", "steamdeck_button_b")],
PlayPause => &[icon!("steamdeck", "steamdeck_button_x")],
Queue => &[icon!("steamdeck", "steamdeck_button_y")],
Shuffle => &[icon!("steamdeck", "steamdeck_button_y")],
Skip => &[
icon!("steamdeck", "steamdeck_button_l1"),
icon!("steamdeck", "steamdeck_button_r1"),
+55 -1
View File
@@ -12,13 +12,23 @@ use anyhow::Result;
use serde::{Deserialize, Serialize};
use crate::config;
use crate::shuffle::{Library, Mode};
use crate::subsonic::{Client, Song};
const VERSION: u32 = 1;
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SavedQueue {
/// In the order they play.
pub songs: Vec<Song>,
/// Each song's position in the order it was queued. Empty in files from
/// before shuffle, which were saved in that order.
#[serde(default)]
pub order: Vec<usize>,
#[serde(default)]
pub shuffle: Mode,
#[serde(default)]
pub library: Option<Library>,
pub current: Option<usize>,
/// Seconds into the current song.
pub position: f64,
@@ -47,12 +57,22 @@ impl SavedQueues {
pub fn set(&mut self, client: &Client, queue: SavedQueue) {
self.servers.insert(key(client), queue);
}
/// Drops the queue of a forgotten server, by its address as
/// `Client::base` gives it. Returns whether there was one.
pub fn forget(&mut self, base: &str, user: &str) -> bool {
self.servers.remove(&key_of(base, user)).is_some()
}
}
/// Song ids are only unique within one server, and two users of a server
/// have their own queues.
fn key(client: &Client) -> String {
format!("{}@{}", client.user(), client.base())
key_of(client.base(), client.user())
}
fn key_of(base: &str, user: &str) -> String {
format!("{user}@{base}")
}
pub fn path() -> Option<PathBuf> {
@@ -121,6 +141,9 @@ mod tests {
let mut queues = SavedQueues::default();
let a = SavedQueue {
songs: vec![song("1"), song("2")],
order: vec![1, 0],
shuffle: Mode::Tracks,
library: Some(Library { added_end: 1 }),
current: Some(1),
position: 93.5,
};
@@ -128,6 +151,7 @@ mod tests {
songs: vec![song("9")],
current: None,
position: 0.0,
..SavedQueue::default()
};
queues.set(&home, a.clone());
queues.set(&other, b.clone());
@@ -142,6 +166,36 @@ mod tests {
let _ = fs::remove_dir_all(path.parent().unwrap());
}
#[test]
fn forgetting_a_server_drops_only_its_queue() {
let home = Client::new("https://home", "u", Auth::Password("p".into()));
let other = Client::new("https://other", "u", Auth::Password("p".into()));
let mut queues = SavedQueues::default();
queues.set(&home, SavedQueue::default());
queues.set(&other, SavedQueue::default());
assert!(queues.forget(home.base(), home.user()));
assert!(!queues.forget(home.base(), home.user()));
assert!(queues.get(&home).is_none());
assert!(queues.get(&other).is_some());
}
#[test]
fn a_queue_saved_before_shuffle_loads_unshuffled() {
let path = temp("before-shuffle");
fs::create_dir_all(path.parent().unwrap()).unwrap();
let client = Client::new("https://h", "u", Auth::Password("p".into()));
let text = r#"{"version": 1, "servers": {"u@https://h": {
"songs": [{"id": "1", "title": "One"}], "current": 0, "position": 12.0}}}"#;
fs::write(&path, text).unwrap();
let q = load(&path).get(&client).cloned().expect("the queue");
assert_eq!(
(q.songs.len(), q.order, q.shuffle, q.library),
(1, vec![], Mode::Off, None)
);
assert_eq!(q.songs[0].album_id, None);
let _ = fs::remove_dir_all(path.parent().unwrap());
}
#[test]
fn an_unreadable_file_loads_as_empty() {
let path = temp("unreadable");
+348
View File
@@ -0,0 +1,348 @@
//! Shuffled play orders. Every function returns a permutation: positions into
//! the queue as it plays now, in the order it should play next. The caller
//! applies the same permutation to the songs, to their original positions and
//! to the player's URLs, so the three never disagree.
//!
//! `fixed` is how many tracks at the head of the queue stay where they are:
//! those played, the one playing and one already handed to playbin.
use std::collections::HashMap;
use fastrand::Rng;
use serde::{Deserialize, Serialize};
use crate::subsonic::Song;
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Mode {
#[default]
Off,
Tracks,
Albums,
}
impl Mode {
pub fn next(self) -> Mode {
match self {
Mode::Off => Mode::Tracks,
Mode::Tracks => Mode::Albums,
Mode::Albums => Mode::Off,
}
}
}
/// Library shuffle: the queue is topped up with random tracks from the
/// server as it runs low.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Library {
/// Where the random tracks carry on after those queued by hand, which go
/// after the playing track and after any queued before them.
pub added_end: usize,
}
/// Which album a song belongs to. The album name alone would merge different
/// albums of the same title, so it is only the fallback for songs saved
/// without an album id. A song with neither is an album of its own.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
enum AlbumKey<'a> {
Id(&'a str),
Name(&'a str, Option<&'a str>),
Alone(usize),
}
fn album_key(song: &Song, pos: usize) -> AlbumKey<'_> {
match (&song.album_id, &song.album) {
(Some(id), _) => AlbumKey::Id(id),
(None, Some(name)) if !name.is_empty() => AlbumKey::Name(name, song.artist.as_deref()),
_ => AlbumKey::Alone(pos),
}
}
/// Keeps the first `fixed` tracks and shuffles the rest.
pub fn tracks(rng: &mut Rng, len: usize, fixed: usize) -> Vec<usize> {
let fixed = fixed.min(len);
let mut perm: Vec<usize> = (0..len).collect();
rng.shuffle(&mut perm[fixed..]);
perm
}
/// Keeps the first `fixed` tracks, then plays the rest of the playing track's
/// album, then the other albums in random order. Each album plays in disc and
/// track order, and tracks without numbers keep their original order.
/// `original` holds each track's position in the original order.
pub fn albums(rng: &mut Rng, songs: &[Song], original: &[usize], playing: Option<usize>, fixed: usize) -> Vec<usize> {
let fixed = fixed.min(songs.len());
let mut groups = album_groups(songs, original, fixed..songs.len());
let first = playing
.and_then(|p| songs.get(p).map(|s| album_key(s, p)))
.and_then(|key| groups.iter().position(|(k, _)| *k == key))
.map(|i| groups.remove(i));
rng.shuffle(&mut groups);
(0..fixed)
.chain(first.into_iter().chain(groups).flat_map(|(_, g)| g))
.collect()
}
/// The tracks in `range` grouped by album, in the order each album first
/// appears, each sorted by disc and track.
fn album_groups<'a>(
songs: &'a [Song],
original: &[usize],
range: std::ops::Range<usize>,
) -> Vec<(AlbumKey<'a>, Vec<usize>)> {
let mut groups: Vec<(AlbumKey<'a>, Vec<usize>)> = Vec::new();
let mut index: HashMap<AlbumKey<'a>, usize> = HashMap::new();
for pos in range {
let key = album_key(&songs[pos], pos);
let i = *index.entry(key.clone()).or_insert_with(|| {
groups.push((key, Vec::new()));
groups.len() - 1
});
groups[i].1.push(pos);
}
for (_, g) in &mut groups {
g.sort_by_key(|&p| {
let s = &songs[p];
(
s.disc_number.unwrap_or(0),
s.track.unwrap_or(0),
original.get(p).copied().unwrap_or(p),
)
});
}
groups
}
/// Places the tracks from `added` on (just appended to the queue) at random
/// positions after the first `fixed`. Under album shuffle each added album
/// goes in as one block, and only between albums, never inside one.
pub fn insert(rng: &mut Rng, mode: Mode, songs: &[Song], original: &[usize], fixed: usize, added: usize) -> Vec<usize> {
let added = added.min(songs.len());
let fixed = fixed.min(added);
let mut tail: Vec<usize> = (fixed..added).collect();
if mode == Mode::Albums {
let mut blocks: Vec<Vec<usize>> = Vec::new();
for pos in tail {
let key = album_key(&songs[pos], pos);
match blocks.last_mut() {
Some(b) if album_key(&songs[b[0]], b[0]) == key => b.push(pos),
_ => blocks.push(vec![pos]),
}
}
// The rest of the album playing now still plays first.
let lo = match (fixed.checked_sub(1), blocks.first()) {
(Some(last), Some(b)) if album_key(&songs[last], last) == album_key(&songs[b[0]], b[0]) => 1,
_ => 0,
};
for (_, g) in album_groups(songs, original, added..songs.len()) {
let at = rng.usize(lo..=blocks.len());
blocks.insert(at, g);
}
tail = blocks.concat();
} else {
for pos in added..songs.len() {
let at = rng.usize(..=tail.len());
tail.insert(at, pos);
}
}
(0..fixed).chain(tail).collect()
}
/// Back to the original order, given each track's original position. A
/// `pinned` track (handed to playbin already) is moved to play right after
/// `playing`, so the track that plays next is the one the player expects.
pub fn unshuffle(original: &[usize], playing: Option<usize>, pinned: Option<usize>) -> Vec<usize> {
let mut perm: Vec<usize> = (0..original.len()).collect();
perm.sort_by_key(|&p| original[p]);
if let (Some(playing), Some(pinned)) = (playing, pinned)
&& playing != pinned
&& let Some(from) = perm.iter().position(|&p| p == pinned)
{
perm.remove(from);
let at = perm.iter().position(|&p| p == playing).map_or(perm.len(), |i| i + 1);
perm.insert(at, pinned);
}
perm
}
/// `items` reordered by `perm`.
pub fn apply<T: Clone>(items: &[T], perm: &[usize]) -> Vec<T> {
perm.iter().map(|&p| items[p].clone()).collect()
}
#[cfg(test)]
mod tests {
use super::*;
fn song(id: &str, album: Option<&str>, track: u32) -> Song {
serde_json::from_value(serde_json::json!({
"id": id, "title": id, "album": album.map(|a| format!("Album {a}")),
"albumId": album, "artist": "A", "track": track,
}))
.unwrap()
}
fn is_permutation(perm: &[usize], len: usize) -> bool {
let mut sorted = perm.to_vec();
sorted.sort();
sorted == (0..len).collect::<Vec<_>>()
}
#[test]
fn tracks_keeps_the_fixed_head_and_plays_the_rest_once() {
let mut rng = Rng::with_seed(1);
for fixed in [0, 1, 3, 10, 12] {
let perm = tracks(&mut rng, 10, fixed);
assert!(is_permutation(&perm, 10));
let fixed = fixed.min(10);
assert_eq!(perm[..fixed], (0..fixed).collect::<Vec<_>>()[..]);
}
}
#[test]
fn tracks_actually_shuffles() {
let mut rng = Rng::with_seed(7);
let perm = tracks(&mut rng, 50, 1);
assert_ne!(perm, (0..50).collect::<Vec<_>>());
}
#[test]
fn albums_finish_the_playing_album_then_play_whole_albums_in_track_order() {
// Track shuffled already: b2, a1, b1 | a2, c1, b3, a3, c2.
let songs = vec![
song("b2", Some("b"), 2),
song("a1", Some("a"), 1),
song("b1", Some("b"), 1),
song("a2", Some("a"), 2),
song("c2", Some("c"), 2),
song("b3", Some("b"), 3),
song("a3", Some("a"), 3),
song("c1", Some("c"), 1),
];
let original: Vec<usize> = (0..songs.len()).collect();
for seed in 0..20 {
let mut rng = Rng::with_seed(seed);
let perm = albums(&mut rng, &songs, &original, Some(0), 3);
assert!(is_permutation(&perm, songs.len()));
let ids: Vec<&str> = perm.iter().map(|&p| songs[p].id.as_str()).collect();
assert_eq!(ids[..3], ["b2", "a1", "b1"]);
assert_eq!(ids[3], "b3", "the playing album goes on first");
let rest = &ids[4..];
assert!(
rest == ["a2", "a3", "c1", "c2"] || rest == ["c1", "c2", "a2", "a3"],
"seed {seed}: {rest:?}"
);
}
}
#[test]
fn albums_with_the_same_name_stay_apart_and_saved_songs_fall_back_to_the_name() {
let mut same_name = song("x1", Some("x"), 1);
same_name.album = Some("Album y".into());
let mut saved = song("y2", None, 2);
saved.album = Some("Album y".into());
let mut saved1 = song("y1", None, 1);
saved1.album = Some("Album y".into());
let songs = vec![song("p", Some("p"), 1), saved, same_name, saved1];
let original: Vec<usize> = (0..songs.len()).collect();
let mut rng = Rng::with_seed(3);
let perm = albums(&mut rng, &songs, &original, Some(0), 1);
let ids: Vec<&str> = perm.iter().map(|&p| songs[p].id.as_str()).collect();
let y = ids.iter().position(|&i| i == "y1").unwrap();
assert_eq!(ids[y + 1], "y2", "{ids:?}");
assert!(ids.contains(&"x1"));
}
#[test]
fn tracks_without_numbers_keep_their_original_order() {
let mut songs: Vec<Song> = ["a", "b", "c"].iter().map(|id| song(id, Some("al"), 0)).collect();
for s in &mut songs {
s.track = None;
}
// Played as c, a, b; originally a, b, c.
let songs = vec![songs[2].clone(), songs[0].clone(), songs[1].clone()];
let original = vec![2, 0, 1];
let mut rng = Rng::with_seed(0);
let perm = albums(&mut rng, &songs, &original, None, 0);
let ids: Vec<&str> = perm.iter().map(|&p| songs[p].id.as_str()).collect();
assert_eq!(ids, ["a", "b", "c"]);
}
#[test]
fn insert_scatters_added_tracks_after_the_fixed_head() {
let songs: Vec<Song> = (0..20).map(|i| song(&i.to_string(), None, 0)).collect();
let original: Vec<usize> = (0..20).collect();
let mut rng = Rng::with_seed(5);
let perm = insert(&mut rng, Mode::Tracks, &songs, &original, 2, 15);
assert!(is_permutation(&perm, 20));
assert_eq!(perm[..2], [0, 1]);
let old: Vec<usize> = perm.iter().copied().filter(|&p| p < 15).collect();
assert_eq!(old, (0..15).collect::<Vec<_>>(), "the queued tracks keep their order");
assert_ne!(perm[15..], [15, 16, 17, 18, 19], "added tracks are not all at the end");
}
#[test]
fn insert_under_album_shuffle_adds_whole_albums_between_albums() {
let songs = vec![
song("p1", Some("p"), 1),
song("q1", Some("q"), 1),
song("q2", Some("q"), 2),
song("r1", Some("r"), 1),
song("r2", Some("r"), 2),
song("n2", Some("n"), 2),
song("n1", Some("n"), 1),
];
let original: Vec<usize> = (0..songs.len()).collect();
for seed in 0..20 {
let mut rng = Rng::with_seed(seed);
let perm = insert(&mut rng, Mode::Albums, &songs, &original, 1, 5);
let ids: Vec<&str> = perm.iter().map(|&p| songs[p].id.as_str()).collect();
let n = ids.iter().position(|&i| i == "n1").unwrap();
assert_eq!(ids[n + 1], "n2", "seed {seed}: {ids:?}");
assert!(
n >= 1 && ids[n - 1] != "q1" && ids[n - 1] != "r1",
"seed {seed}: {ids:?}"
);
}
}
#[test]
fn insert_under_album_shuffle_leaves_the_playing_album_first() {
let songs = vec![
song("p1", Some("p"), 1),
song("p2", Some("p"), 2),
song("q1", Some("q"), 1),
song("n1", Some("n"), 1),
];
let original: Vec<usize> = (0..songs.len()).collect();
for seed in 0..20 {
let mut rng = Rng::with_seed(seed);
let perm = insert(&mut rng, Mode::Albums, &songs, &original, 1, 3);
assert_eq!(perm[1], 1, "seed {seed}: {perm:?}");
}
}
#[test]
fn unshuffle_restores_the_original_order() {
let original = vec![3, 0, 4, 1, 2];
let perm = unshuffle(&original, Some(0), None);
assert_eq!(apply(&original, &perm), [0, 1, 2, 3, 4]);
}
#[test]
fn unshuffle_plays_the_pinned_track_next() {
// Playing original 3, playbin already has original 0.
let original = vec![1, 3, 0, 4, 2];
let perm = unshuffle(&original, Some(1), Some(2));
assert_eq!(apply(&original, &perm), [1, 2, 3, 0, 4]);
}
#[test]
fn modes_cycle_off_tracks_albums() {
assert_eq!(Mode::Off.next(), Mode::Tracks);
assert_eq!(Mode::Tracks.next(), Mode::Albums);
assert_eq!(Mode::Albums.next(), Mode::Off);
}
}
+100
View File
@@ -212,6 +212,28 @@ impl Client {
Ok(r.artist)
}
/// Every song on the artist's albums, album by album. A few albums are
/// fetched at a time, so an artist with dozens does not flood the server.
pub async fn artist_songs(&self, id: &str) -> Result<Vec<Song>> {
let albums = self.artist(id).await?.album;
let limit = std::sync::Arc::new(tokio::sync::Semaphore::new(4));
let tasks: Vec<_> = albums
.into_iter()
.map(|a| {
let (client, limit) = (self.clone(), limit.clone());
tokio::spawn(async move {
let _permit = limit.acquire_owned().await?;
anyhow::Ok(client.album(&a.id).await?.song)
})
})
.collect();
let mut songs = Vec::new();
for t in tasks {
songs.extend(t.await??);
}
Ok(songs)
}
pub async fn album(&self, id: &str) -> Result<AlbumDetail> {
#[derive(Deserialize)]
struct R {
@@ -265,6 +287,23 @@ impl Client {
Ok(r.result)
}
/// Up to `size` random songs from the whole library. Servers cap `size`
/// at 500.
pub async fn random_songs(&self, size: u32) -> Result<Vec<Song>> {
#[derive(Deserialize)]
struct R {
#[serde(rename = "randomSongs", default)]
list: Songs,
}
#[derive(Deserialize, Default)]
struct Songs {
#[serde(default)]
song: Vec<Song>,
}
let r: R = self.call("getRandomSongs", &[("size", size.to_string())]).await?;
Ok(r.list.song)
}
pub async fn scrobble(&self, id: &str, submission: bool) -> Result<()> {
let _: serde_json::Value = self
.call("scrobble", &[("id", id.into()), ("submission", submission.to_string())])
@@ -426,6 +465,9 @@ pub struct Song {
pub artist: Option<String>,
#[serde(default)]
pub album: Option<String>,
/// None in queues saved before it was kept, and from servers that leave it out.
#[serde(default, deserialize_with = "de_opt_id")]
pub album_id: Option<String>,
#[serde(default, deserialize_with = "de_opt_id")]
pub cover_art: Option<String>,
#[serde(default)]
@@ -489,6 +531,56 @@ mod tests {
let a: Album = serde_json::from_str(r#"{"id": 42, "name": "X", "coverArt": 7}"#).unwrap();
assert_eq!(a.id, "42");
assert_eq!(a.cover_art.as_deref(), Some("7"));
let s: Song = serde_json::from_str(r#"{"id": 1, "albumId": 42}"#).unwrap();
assert_eq!(s.album_id.as_deref(), Some("42"));
let s: Song = serde_json::from_str(r#"{"id": 1}"#).unwrap();
assert_eq!(s.album_id, None);
}
/// A loopback HTTP server that answers every request with `body` and
/// sends each request line back.
fn fake_server(body: &'static str) -> (String, std::sync::mpsc::Receiver<String>) {
use std::io::{BufRead, BufReader, Write};
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
let (tx, rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
for stream in listener.incoming() {
let Ok(mut stream) = stream else { continue };
let mut line = String::new();
let _ = BufReader::new(stream.try_clone().unwrap()).read_line(&mut line);
let _ = tx.send(line);
let _ = write!(
stream,
"HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: close\r\n\r\n{body}",
body.len()
);
}
});
(format!("http://{addr}"), rx)
}
#[tokio::test]
async fn random_songs_asks_for_the_size_and_reads_the_songs() {
let (base, requests) = fake_server(
r#"{"subsonic-response":{"status":"ok","randomSongs":{"song":[
{"id":"s1","title":"One","albumId":"al-1"},{"id":"s2","title":"Two"}]}}}"#,
);
let c = Client::new(&base, "u", Auth::Password("sesame".into()));
let songs = c.random_songs(50).await.unwrap();
let ids: Vec<_> = songs.iter().map(|s| s.id.as_str()).collect();
assert_eq!(ids, ["s1", "s2"]);
assert_eq!(songs[0].album_id.as_deref(), Some("al-1"));
let line = requests.recv().unwrap();
assert!(line.contains("/rest/getRandomSongs?"), "{line}");
assert!(line.contains("size=50"), "{line}");
}
#[tokio::test]
async fn random_songs_from_an_empty_library_is_empty() {
let (base, _) = fake_server(r#"{"subsonic-response":{"status":"ok","randomSongs":{}}}"#);
let c = Client::new(&base, "u", Auth::Password("sesame".into()));
assert!(c.random_songs(50).await.unwrap().is_empty());
}
/// Exercises every endpoint against a real server:
@@ -514,6 +606,7 @@ mod tests {
assert!(!albums.is_empty(), "no albums");
let album = c.album(&albums[0].id).await.unwrap();
assert!(!album.song.is_empty(), "album has no songs");
assert_eq!(album.song[0].album_id.as_deref(), Some(albums[0].id.as_str()));
println!(
"album: {} by {:?}, {} songs",
album.name,
@@ -530,6 +623,9 @@ mod tests {
assert!(!artists.is_empty(), "no artists");
let artist = c.artist(&artists[0].id).await.unwrap();
println!("artist: {} with {} albums", artist.name, artist.album.len());
let songs = c.artist_songs(&artists[0].id).await.unwrap();
assert!(!songs.is_empty(), "artist has no songs");
println!("artist songs: {}", songs.len());
let playlists = c.playlists().await.unwrap();
if let Some(p) = playlists.first() {
@@ -537,6 +633,10 @@ mod tests {
println!("playlist: {} with {} entries", p.name, p.entry.len());
}
let random = c.random_songs(20).await.unwrap();
assert!(!random.is_empty(), "no random songs");
println!("random: {} songs", random.len());
let found = c.search(&album.name).await.unwrap();
assert!(!found.album.is_empty(), "search found nothing for {}", album.name);
+268 -89
View File
@@ -9,7 +9,7 @@ export enum Action {
none, up, down, left, right, page-up, page-down, activate, back,
play-pause, next, prev, queue, section-next, section-prev,
now-playing, search, seek-forward, seek-back, toggle-fullscreen, quit,
volume-up, volume-down, toggle-mute,
volume-up, volume-down, toggle-mute, cycle-shuffle, shuffle, hold-activate,
}
export enum Screen { login, browse, now-playing }
@@ -48,6 +48,9 @@ export struct Header {
export struct Hint { icons: [image], label: string }
// A saved server on the login screen: its label, and "Logged out" or nothing.
export struct KnownServer { label: string, note: string }
export global Theme {
in-out property <float> s: 1.0;
// The brand palette: warm darks and cream text, from the logo's maroon
@@ -213,8 +216,10 @@ component Row inherits Rectangle {
round: root.item.round;
}
}
// As wide as the art, so a row with a cover and a row with a number
// line up, as on an album where some tracks have their own cover.
if !root.item.show-art: Text {
width: 34px * Theme.s;
width: 46px * Theme.s;
text: root.item.playing ? "▶" : root.item.number;
font-size: 15px * Theme.s;
color: root.item.playing ? Theme.highlight : Theme.faint;
@@ -617,6 +622,71 @@ component VolumeLevel inherits HorizontalLayout {
}
// The level after a volume change, faded out again by the app after a moment.
// Asks before doing something that cannot be undone from where it is asked.
// The choices sit in a row; the app moves the selection and starts with the
// first, which is Cancel.
component ConfirmDialog inherits Rectangle {
in property <string> title;
in property <string> message;
in property <[string]> choices;
in property <int> selected;
callback clicked(int);
background: #00000099;
// Keeps clicks from reaching the page behind.
TouchArea { }
Rectangle {
width: min(620px * Theme.s, parent.width - 40px * Theme.s);
height: col.preferred-height;
border-radius: 18px * Theme.s;
background: Theme.panel;
border-width: 1px * Theme.s;
border-color: Theme.line;
drop-shadow-blur: 30px * Theme.s;
drop-shadow-color: #00000080;
col := VerticalLayout {
padding: 34px * Theme.s;
spacing: 18px * Theme.s;
Text {
text: root.title;
font-size: 24px * Theme.s;
font-family: Theme.serif;
font-weight: 600;
color: Theme.text;
wrap: word-wrap;
}
Text {
text: root.message;
font-size: 16px * Theme.s;
color: Theme.muted;
wrap: word-wrap;
}
HorizontalLayout {
spacing: 12px * Theme.s;
padding-top: 6px * Theme.s;
for label[i] in root.choices: Rectangle {
height: 50px * Theme.s;
border-radius: 12px * Theme.s;
background: i == root.selected ? Theme.accent : Theme.raised;
border-width: 2px * Theme.s;
border-color: i == root.selected ? Theme.focus : transparent;
Text {
text: label;
font-size: 18px * Theme.s;
font-weight: i == root.selected ? 700 : 500;
color: i == root.selected ? Theme.on-accent : Theme.text;
}
TouchArea {
clicked => { root.clicked(i); }
}
}
}
}
}
}
component VolumeOverlay inherits Rectangle {
in property <bool> shown;
in property <int> level;
@@ -891,9 +961,13 @@ component LoginView inherits Rectangle {
in property <bool> busy;
// Adding a server from inside the app: the bottom button goes back.
in property <bool> can-cancel;
// Saved servers above the form, and which one has focus, -1 for none.
in property <[KnownServer]> known;
in property <int> known-selected: -1;
callback submit;
callback exit;
callback field-clicked(int);
callback known-clicked(int);
public function focus-field(i: int) {
if (i == 0) {
f0.focus-input();
@@ -906,90 +980,155 @@ component LoginView inherits Rectangle {
background: @radial-gradient(circle, Theme.login-glow 0%, Theme.bg 70%);
Rectangle {
width: min(560px * Theme.s, parent.width - 40px * Theme.s);
height: col.preferred-height;
border-radius: 18px * Theme.s;
background: Theme.panel;
// Saved servers in a card of their own beside the form, so the form is
// as tall as without them and still fits an 800 px high screen.
HorizontalLayout {
alignment: center;
spacing: 24px * Theme.s;
padding: 20px * Theme.s;
col := VerticalLayout {
padding: 40px * Theme.s;
spacing: 20px * Theme.s;
if root.known.length > 0: VerticalLayout {
alignment: center;
Rectangle {
preferred-width: 400px * Theme.s;
min-width: 240px * Theme.s;
border-radius: 18px * Theme.s;
background: Theme.panel;
VerticalLayout {
padding: 28px * Theme.s;
spacing: 10px * Theme.s;
Text {
text: "Saved servers";
font-size: 22px * Theme.s;
font-family: Theme.serif;
font-weight: 600;
color: Theme.text;
}
Text {
text: "Pick one to fill in its address and username.";
font-size: 14px * Theme.s;
color: Theme.muted;
wrap: word-wrap;
}
for k[i] in root.known: Rectangle {
height: 58px * Theme.s;
border-radius: 10px * Theme.s;
background: i == root.known-selected ? Theme.raised : transparent;
border-width: 2px * Theme.s;
border-color: i == root.known-selected ? Theme.focus : Theme.line;
VerticalLayout {
padding-left: 16px * Theme.s;
padding-right: 16px * Theme.s;
alignment: center;
Text {
text: k.label;
font-size: 17px * Theme.s;
color: Theme.text;
overflow: elide;
}
if k.note != "": Text {
text: k.note;
font-size: 13px * Theme.s;
color: Theme.faint;
}
}
TouchArea {
clicked => { root.known-clicked(i); }
}
}
}
}
}
HorizontalLayout {
alignment: center;
Image {
source: @image-url("../branding/svg/remus-logo.svg");
height: 68px * Theme.s;
// The lockup's aspect ratio, so the image box hugs the logo.
width: self.height * 2.93;
}
}
Text {
text: "Connect to your Subsonic server";
font-size: 17px * Theme.s;
color: Theme.muted;
}
f0 := Field {
label: "Server address";
text <=> root.server;
highlighted: root.focus-index == 0;
accepted => { root.field-clicked(1); }
}
f1 := Field {
label: "Username";
text <=> root.username;
highlighted: root.focus-index == 1;
accepted => { root.field-clicked(2); }
}
f2 := Field {
label: "Password";
text <=> root.password;
password: true;
shown <=> root.password-shown;
highlighted: root.focus-index == 2;
accepted => { root.submit(); }
}
VerticalLayout {
alignment: center;
Rectangle {
height: 54px * Theme.s;
border-radius: 12px * Theme.s;
background: root.focus-index == 3 ? Theme.accent : Theme.raised;
Text {
text: root.busy ? "Connecting…" : "Connect";
font-size: 19px * Theme.s;
font-weight: 700;
color: root.focus-index == 3 ? Theme.on-accent : Theme.text;
preferred-width: 560px * Theme.s;
min-width: 320px * Theme.s;
height: col.preferred-height;
border-radius: 18px * Theme.s;
background: Theme.panel;
col := VerticalLayout {
padding: 40px * Theme.s;
spacing: 20px * Theme.s;
HorizontalLayout {
alignment: center;
Image {
source: @image-url("../branding/svg/remus-logo.svg");
height: 68px * Theme.s;
// The lockup's aspect ratio, so the image box hugs the logo.
width: self.height * 2.93;
}
}
Text {
text: "Connect to your Subsonic server";
font-size: 17px * Theme.s;
color: Theme.muted;
}
f0 := Field {
label: "Server address";
text <=> root.server;
highlighted: root.focus-index == 0;
accepted => { root.field-clicked(1); }
}
f1 := Field {
label: "Username";
text <=> root.username;
highlighted: root.focus-index == 1;
accepted => { root.field-clicked(2); }
}
f2 := Field {
label: "Password";
text <=> root.password;
password: true;
shown <=> root.password-shown;
highlighted: root.focus-index == 2;
accepted => { root.submit(); }
}
Rectangle {
height: 54px * Theme.s;
border-radius: 12px * Theme.s;
background: root.focus-index == 3 ? Theme.accent : Theme.raised;
Text {
text: root.busy ? "Connecting…" : "Connect";
font-size: 19px * Theme.s;
font-weight: 700;
color: root.focus-index == 3 ? Theme.on-accent : Theme.text;
}
TouchArea {
clicked => { root.submit(); }
}
}
// Secondary to Connect: outlined, no fill, and only lit when focused.
Rectangle {
height: 46px * Theme.s;
border-radius: 12px * Theme.s;
border-width: 2px * Theme.s;
border-color: root.focus-index == 4 ? Theme.focus : Theme.line;
Text {
text: root.can-cancel ? "Cancel" : "Exit";
font-size: 17px * Theme.s;
color: root.focus-index == 4 ? Theme.text : Theme.muted;
}
TouchArea {
clicked => { root.exit(); }
}
}
if root.error != "": Text {
text: root.error;
font-size: 15px * Theme.s;
color: Theme.error;
wrap: word-wrap;
}
Text {
text: "On a Steam Deck, press Steam + X to bring up the keyboard.";
font-size: 13px * Theme.s;
color: Theme.faint;
wrap: word-wrap;
}
}
TouchArea {
clicked => { root.submit(); }
}
}
// Secondary to Connect: outlined, no fill, and only lit when focused.
Rectangle {
height: 46px * Theme.s;
border-radius: 12px * Theme.s;
border-width: 2px * Theme.s;
border-color: root.focus-index == 4 ? Theme.focus : Theme.line;
Text {
text: root.can-cancel ? "Cancel" : "Exit";
font-size: 17px * Theme.s;
color: root.focus-index == 4 ? Theme.text : Theme.muted;
}
TouchArea {
clicked => { root.exit(); }
}
}
if root.error != "": Text {
text: root.error;
font-size: 15px * Theme.s;
color: Theme.error;
wrap: word-wrap;
}
Text {
text: "On a Steam Deck, press Steam + X to bring up the keyboard.";
font-size: 13px * Theme.s;
color: Theme.faint;
wrap: word-wrap;
}
}
}
@@ -1021,6 +1160,8 @@ component NowPlayingView inherits Rectangle {
in property <[Item]> queue;
in property <int> queue-count;
in property <int> queue-selected;
// How the queue is shuffled, empty when it plays in order.
in property <string> shuffle;
callback queue-clicked(int);
callback queue-wheel(int);
// From the scale, not our own size: a layout child sized from its parent loops.
@@ -1132,12 +1273,23 @@ component NowPlayingView inherits Rectangle {
VerticalLayout {
spacing: 14px * Theme.s;
horizontal-stretch: 1;
Text {
text: "Queue";
font-size: 28px * Theme.s;
font-family: Theme.serif;
font-weight: 600;
color: Theme.text;
HorizontalLayout {
spacing: 16px * Theme.s;
Text {
text: "Queue";
font-size: 28px * Theme.s;
font-family: Theme.serif;
font-weight: 600;
color: Theme.text;
}
Text {
horizontal-stretch: 1;
text: root.shuffle;
font-size: 16px * Theme.s;
color: Theme.muted;
vertical-alignment: center;
overflow: elide;
}
}
ItemView {
vertical-stretch: 1;
@@ -1185,6 +1337,8 @@ export component AppWindow inherits Window {
callback search-accepted(string);
callback login-submit();
callback login-field-clicked(int);
callback login-known-clicked(int);
callback confirm-clicked(int);
callback layout-changed();
in property <Screen> screen: Screen.login;
@@ -1199,6 +1353,8 @@ export component AppWindow inherits Window {
in property <bool> login-busy;
in property <bool> login-can-cancel;
in-out property <bool> login-password-shown;
in property <[KnownServer]> login-known;
in property <int> login-known-selected: -1;
// Browse
in property <[string]> sections;
@@ -1230,6 +1386,7 @@ export component AppWindow inherits Window {
in property <string> np-position;
in property <string> np-duration;
in property <bool> np-paused;
in property <string> np-shuffle;
in property <bool> np-flip-out;
in property <float> np-backdrop-opacity: 0.16;
in property <float> np-backdrop-left: 0.67;
@@ -1248,6 +1405,13 @@ export component AppWindow inherits Window {
in property <string> version;
in property <bool> show-hint-bar: true;
// The confirmation prompt, over everything else while shown.
in property <bool> confirm-shown;
in property <string> confirm-title;
in property <string> confirm-message;
in property <[string]> confirm-choices;
in property <int> confirm-selected;
public function focus-main() {
fs.focus();
}
@@ -1255,7 +1419,8 @@ export component AppWindow inherits Window {
search.focus-input();
}
public function focus-login(i: int) {
if (i >= 3) {
// Below 0 is a saved server, above 2 a button: keys go to the scope.
if (i >= 3 || i < 0) {
fs.focus();
} else {
login.focus-field(i);
@@ -1303,6 +1468,8 @@ export component AppWindow inherits Window {
if (e.text == "+" || e.text == "=") { root.action(Action.volume-up); return accept; }
if (e.text == "-") { root.action(Action.volume-down); return accept; }
if (e.text == "m") { root.action(Action.toggle-mute); return accept; }
if (e.text == "s") { root.action(Action.cycle-shuffle); return accept; }
if (e.text == "S") { root.action(Action.shuffle); return accept; }
reject
}
@@ -1326,6 +1493,9 @@ export component AppWindow inherits Window {
can-cancel: root.login-can-cancel;
exit => { root.action(root.login-can-cancel ? Action.back : Action.quit); }
field-clicked(i) => { root.login-field-clicked(i); }
known: root.login-known;
known-selected: root.login-known-selected;
known-clicked(i) => { root.login-known-clicked(i); }
}
Rectangle {
@@ -1415,6 +1585,7 @@ export component AppWindow inherits Window {
queue: root.queue-items;
queue-count: root.queue-count;
queue-selected: root.queue-selected;
shuffle: root.np-shuffle;
queue-clicked(i) => { root.queue-clicked(i); }
queue-wheel(d) => { root.queue-wheel(d); }
}
@@ -1437,6 +1608,14 @@ export component AppWindow inherits Window {
}
}
if root.confirm-shown: ConfirmDialog {
title: root.confirm-title;
message: root.confirm-message;
choices: root.confirm-choices;
selected: root.confirm-selected;
clicked(i) => { root.confirm-clicked(i); }
}
VolumeOverlay {
x: (parent.width - self.width) / 2;
y: parent.height - self.height - 32px * Theme.s;
+9
View File
@@ -0,0 +1,9 @@
<svg width="64" height="64" xmlns="http://www.w3.org/2000/svg">
<defs>
<mask id="letter">
<rect width="64" height="64" fill="#FFFFFF"/>
<path fill="none" stroke="#000000" stroke-width="4" stroke-linecap="square" d="M38 25.5 Q36.5 24 32 24 Q26 24 26 28 Q26 32 32 32 Q38 32 38 36 Q38 40 32 40 Q27.5 40 26 38.5"/>
</mask>
</defs>
<path stroke="none" fill="#FFFFFF" mask="url(#letter)" d="M16 8 L48 8 Q56 8 56 16 L56 48 Q56 56 48 56 L16 56 Q8 56 8 48 L8 16 Q8 8 16 8"/>
</svg>

After

Width:  |  Height:  |  Size: 499 B

+9
View File
@@ -0,0 +1,9 @@
<svg width="64" height="64" xmlns="http://www.w3.org/2000/svg">
<defs>
<mask id="glyph">
<rect width="64" height="64" fill="#FFFFFF"/>
<path fill="none" stroke="#000000" stroke-width="3.5" stroke-linejoin="round" d="M32 21 L42 32 L36.5 32 L36.5 42 L27.5 42 L27.5 32 L22 32 Z"/>
</mask>
</defs>
<path stroke="none" fill="#FFFFFF" mask="url(#glyph)" d="M16 8 L48 8 Q56 8 56 16 L56 48 Q56 56 48 56 L16 56 Q8 56 8 48 L8 16 Q8 8 16 8"/>
</svg>

After

Width:  |  Height:  |  Size: 465 B