Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
bce0d68442 | ||
|
|
d77316b5b7 | ||
|
|
5b678d4f1c | ||
|
|
a005c3207a | ||
|
|
6997e7cd93 | ||
|
|
b5ef9fbb13 | ||
|
|
3518462dde | ||
|
|
d4de15acd8 | ||
|
|
0bcba21f1a | ||
|
|
ab42814302 |
@@ -2,6 +2,68 @@
|
||||
|
||||
One section per version, newest first.
|
||||
|
||||
## 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
|
||||
|
||||
- Covers cached by versions before 0.8.0 are deleted on start. They were no longer used but stayed on disk.
|
||||
|
||||
## v0.8.5 (2026-11-04)
|
||||
|
||||
### Bug fixes
|
||||
|
||||
- The README says where the version is shown while the controls bar is hidden: in Settings, as a Version row.
|
||||
|
||||
## v0.8.4 (2026-11-04)
|
||||
|
||||
### Bug fixes
|
||||
|
||||
- While another app or a game is in front, the controller no longer also controls remus. Music keeps playing in the background, and media keys still work.
|
||||
|
||||
## v0.8.3 (2026-11-04)
|
||||
|
||||
### Bug fixes
|
||||
|
||||
- The now-playing cover, its background and the album art colours use the picture embedded in the playing track's file when it has one. Nextcloud Music gives every song of an album the album's cover, so tracks with their own art all showed the same one. Lists and the queue still show the server's cover.
|
||||
|
||||
## v0.8.2 (2026-11-04)
|
||||
|
||||
### Bug fixes
|
||||
|
||||
- On the now-playing screen the play/pause icon and the volume bar sit exactly under the middle of the progress bar. Before, the icon moved with the widths of the two times and the volume bar sat left of centre.
|
||||
|
||||
## v0.8.1 (2026-11-04)
|
||||
|
||||
### Features
|
||||
|
||||
- The password field on the login screen has an eye to show what was typed, and the queue button does the same from a controller while the field is selected. It is hidden again whenever the login screen opens.
|
||||
|
||||
## v0.8.0 (2026-11-04)
|
||||
|
||||
### Features
|
||||
|
||||
- Remus keeps several logins and switches between them from Settings, where the servers are listed first. Add server opens the login form, and Cancel goes back. Each server keeps its own queue: switching away stops it, and switching back brings it back paused where it was. A server is removed by pressing the queue button twice on its row.
|
||||
- The shoulder triggers wrap around the sidebar, so Settings is one press back from Recently added.
|
||||
- An existing login is kept as the first of the list, with nothing to re-enter.
|
||||
|
||||
## v0.7.0 (2026-11-04)
|
||||
|
||||
### Features
|
||||
|
||||
- Remus is an MPRIS player, so media keys, headphone buttons and the desktop's media controls can play, pause and skip, and the desktop shows the track that is playing. Headphone buttons work wherever the system passes them to MPRIS, as KDE does in Desktop Mode.
|
||||
|
||||
## v0.6.8 (2026-11-04)
|
||||
|
||||
### Features
|
||||
|
||||
- Settings has a Show controls bar toggle. Turned off, the bar with the button hints and the version is hidden on the browse and now-playing screens, and Settings lists the version instead. The login screen always shows it.
|
||||
|
||||
## v0.6.7 (2026-11-04)
|
||||
|
||||
### Bug fixes
|
||||
|
||||
Generated
+2
-1
@@ -4385,7 +4385,7 @@ checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
|
||||
|
||||
[[package]]
|
||||
name = "remus"
|
||||
version = "0.6.7"
|
||||
version = "0.8.7"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"directories",
|
||||
@@ -4907,6 +4907,7 @@ dependencies = [
|
||||
"const-field-offset",
|
||||
"i-slint-backend-linuxkms",
|
||||
"i-slint-backend-selector",
|
||||
"i-slint-backend-winit",
|
||||
"i-slint-common",
|
||||
"i-slint-core",
|
||||
"i-slint-core-macros",
|
||||
|
||||
+2
-2
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "remus"
|
||||
version = "0.6.7"
|
||||
version = "0.8.7"
|
||||
edition = "2024"
|
||||
license = "MIT"
|
||||
|
||||
@@ -18,7 +18,7 @@ md5 = "0.8.1"
|
||||
reqwest = { version = "0.13.5", default-features = false, features = ["json", "rustls"] }
|
||||
serde = { version = "1.0.229", features = ["derive"] }
|
||||
serde_json = "1.0.154"
|
||||
slint = "1.18.1"
|
||||
slint = { version = "1.18.1", features = ["unstable-winit-030"] }
|
||||
tokio = { version = "1.54.1", features = ["rt-multi-thread", "sync", "macros", "time"] }
|
||||
toml = "1.1.8"
|
||||
zbus = { version = "5.19.0", default-features = false, features = ["tokio"] }
|
||||
|
||||
@@ -86,7 +86,7 @@ A scripted run starts fullscreen like a normal one, so it also checks that start
|
||||
|
||||
### Versions
|
||||
|
||||
Every finished ticket bumps the version, so a build on the Deck can be matched to what it contains. The running version is shown at the bottom left of every screen.
|
||||
Every finished ticket bumps the version, so a build on the Deck can be matched to what it contains. The running version is shown at the bottom left of the controls bar. With Show controls bar turned off in Settings, it is listed as a Version row in Settings instead. The login screen always shows the bar.
|
||||
|
||||
- `make patch` for a bug fix, `make minor` for a feature, `make major` only when a breaking change has been decided.
|
||||
- Before bumping, add a `## v<new> (<date>)` entry at the top of `CHANGELOG.md`, with `### Features` and `### Bug fixes` subsections (leave out an empty one), and commit it with the change. `make version` prints the current version.
|
||||
|
||||
@@ -20,6 +20,16 @@
|
||||
</supports>
|
||||
<content_rating type="oars-1.1"/>
|
||||
<releases>
|
||||
<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"/>
|
||||
<release version="0.8.3" date="2026-11-04"/>
|
||||
<release version="0.8.2" date="2026-11-04"/>
|
||||
<release version="0.8.1" date="2026-11-04"/>
|
||||
<release version="0.8.0" date="2026-11-04"/>
|
||||
<release version="0.7.0" date="2026-11-04"/>
|
||||
<release version="0.6.8" date="2026-11-04"/>
|
||||
<release version="0.6.7" date="2026-11-04"/>
|
||||
<release version="0.6.6" date="2026-11-04"/>
|
||||
<release version="0.6.5" date="2026-11-04"/>
|
||||
|
||||
@@ -18,6 +18,9 @@ finish-args:
|
||||
# Keeps the screensaver off while music plays, the way Chromium and
|
||||
# Electron apps do. The XDG portal route needs no permission.
|
||||
- --talk-name=org.freedesktop.ScreenSaver
|
||||
# MPRIS, through which the desktop's media keys and headphone buttons
|
||||
# reach the player.
|
||||
- --own-name=org.mpris.MediaPlayer2.remus
|
||||
|
||||
build-options:
|
||||
append-path: /usr/lib/sdk/rust-stable/bin
|
||||
|
||||
+589
-67
File diff suppressed because it is too large
Load Diff
+166
-9
@@ -69,21 +69,104 @@ pub fn state_dir() -> Option<PathBuf> {
|
||||
dirs().map(|d| d.state_dir().unwrap_or(d.data_dir()).to_path_buf())
|
||||
}
|
||||
|
||||
pub fn load() -> Result<Option<Config>> {
|
||||
let Some(path) = config_path() else { return Ok(None) };
|
||||
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('/'))
|
||||
}
|
||||
|
||||
fn same_login(&self, other: &Config) -> bool {
|
||||
self.url == other.url && self.username == other.username
|
||||
}
|
||||
}
|
||||
|
||||
/// Every saved login, and which one is browsed.
|
||||
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
|
||||
pub struct Logins {
|
||||
/// Index into `servers`.
|
||||
#[serde(default)]
|
||||
pub active: usize,
|
||||
/// `[[server]]` tables in the file.
|
||||
#[serde(rename = "server", default)]
|
||||
pub servers: Vec<Config>,
|
||||
}
|
||||
|
||||
impl Logins {
|
||||
pub fn active(&self) -> Option<&Config> {
|
||||
self.servers.get(self.active)
|
||||
}
|
||||
|
||||
/// Adds a login, or refreshes the saved one for the same server and user,
|
||||
/// and makes it the active one.
|
||||
pub fn add(&mut self, cfg: Config) {
|
||||
match self.servers.iter().position(|s| s.same_login(&cfg)) {
|
||||
Some(i) => {
|
||||
self.servers[i] = cfg;
|
||||
self.active = i;
|
||||
}
|
||||
None => {
|
||||
self.servers.push(cfg);
|
||||
self.active = self.servers.len() - 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Removes a login. The active one stays the same server where it can;
|
||||
/// removing it makes the first remaining login active.
|
||||
pub fn remove(&mut self, i: usize) {
|
||||
if i >= self.servers.len() {
|
||||
return;
|
||||
}
|
||||
self.servers.remove(i);
|
||||
if i < self.active {
|
||||
self.active -= 1;
|
||||
} else if i == self.active {
|
||||
self.active = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The single login of earlier versions, or the list. Tried in that order:
|
||||
/// every field of the list has a default, so it would take an old file as an
|
||||
/// empty list, while the old shape needs `url` and `username` at the top.
|
||||
#[derive(Deserialize)]
|
||||
#[serde(untagged)]
|
||||
enum Stored {
|
||||
One(Config),
|
||||
List(Logins),
|
||||
}
|
||||
|
||||
fn parse_logins(text: &str) -> Result<Logins> {
|
||||
Ok(match toml::from_str::<Stored>(text)? {
|
||||
Stored::List(mut l) => {
|
||||
if l.active >= l.servers.len() {
|
||||
l.active = 0;
|
||||
}
|
||||
l
|
||||
}
|
||||
Stored::One(c) => Logins {
|
||||
active: 0,
|
||||
servers: vec![c],
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
pub fn load() -> Result<Logins> {
|
||||
let Some(path) = config_path() else {
|
||||
return Ok(Logins::default());
|
||||
};
|
||||
match fs::read_to_string(&path) {
|
||||
Ok(text) => Ok(Some(
|
||||
toml::from_str(&text).with_context(|| format!("parsing {}", path.display()))?,
|
||||
)),
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
|
||||
Ok(text) => parse_logins(&text).with_context(|| format!("parsing {}", path.display())),
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Logins::default()),
|
||||
Err(e) => Err(e).with_context(|| format!("reading {}", path.display())),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn save(cfg: &Config) -> Result<()> {
|
||||
pub fn save(logins: &Logins) -> Result<()> {
|
||||
let path = config_path().context("no config directory")?;
|
||||
write_atomic(&path, &toml::to_string(cfg)?)?;
|
||||
log::info!("saved login to {}", path.display());
|
||||
write_atomic(&path, &toml::to_string(logins)?)?;
|
||||
log::info!("saved {} login(s) to {}", logins.servers.len(), path.display());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -99,6 +182,9 @@ pub struct Settings {
|
||||
pub volume: u8,
|
||||
/// Muted, keeping `volume` for when it is unmuted.
|
||||
pub muted: bool,
|
||||
/// The bar with the button hints and the version. The login screen shows
|
||||
/// it regardless.
|
||||
pub show_hint_bar: bool,
|
||||
}
|
||||
|
||||
/// The cover backdrop strength that looks like it did before it was a setting.
|
||||
@@ -111,6 +197,7 @@ impl Default for Settings {
|
||||
cover_backdrop: COVER_BACKDROP_DEFAULT,
|
||||
volume: 100,
|
||||
muted: false,
|
||||
show_hint_bar: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -208,6 +295,73 @@ mod tests {
|
||||
assert!(!text.contains("salt") && !text.contains("token"), "{text}");
|
||||
}
|
||||
|
||||
fn login(url: &str, user: &str, auth: Auth) -> Config {
|
||||
Config::from_client(&Client::new(url, user, auth))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_single_login_file_loads_as_the_only_login() {
|
||||
let old = "url = \"https://h\"\nusername = \"u\"\nsalt = \"s\"\ntoken = \"t\"\n";
|
||||
let l = parse_logins(old).unwrap();
|
||||
assert_eq!(l.servers.len(), 1);
|
||||
assert_eq!(l.active, 0);
|
||||
assert_eq!(l.active().unwrap().username, "u");
|
||||
let old = "url = \"https://h\"\nusername = \"u\"\npassword = \"p\"\n";
|
||||
let l = parse_logins(old).unwrap();
|
||||
assert_eq!(*l.active().unwrap().client().auth(), Auth::Password("p".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_login_list_round_trips_with_both_auth_methods() {
|
||||
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())));
|
||||
let text = toml::to_string(&l).unwrap();
|
||||
assert!(text.contains("[[server]]"), "{text}");
|
||||
let back = parse_logins(&text).unwrap();
|
||||
assert_eq!(back, l);
|
||||
assert_eq!(back.active, 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn adding_the_same_login_again_replaces_it() {
|
||||
let mut l = Logins::default();
|
||||
l.add(login("https://a", "u", Auth::Password("old".into())));
|
||||
l.add(login("https://b", "u", Auth::Password("p".into())));
|
||||
l.add(login("https://a", "u", Auth::Password("new".into())));
|
||||
assert_eq!(l.servers.len(), 2);
|
||||
assert_eq!(l.active, 0);
|
||||
assert_eq!(*l.servers[0].client().auth(), Auth::Password("new".into()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn removing_keeps_the_active_server_where_it_can() {
|
||||
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 = 2;
|
||||
l.remove(0);
|
||||
assert_eq!(l.active().unwrap().url, "https://c");
|
||||
l.remove(1);
|
||||
assert_eq!(l.active().unwrap().url, "https://b");
|
||||
l.remove(0);
|
||||
assert!(l.active().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_out_of_range_active_index_falls_back_to_the_first() {
|
||||
let text = "active = 5\n[[server]]\nurl = \"https://a\"\nusername = \"u\"\npassword = \"p\"\n";
|
||||
assert_eq!(parse_logins(text).unwrap().active, 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn settings_default_when_fields_are_missing() {
|
||||
let s: Settings = toml::from_str("").unwrap();
|
||||
@@ -216,6 +370,7 @@ mod tests {
|
||||
assert_eq!(s.cover_backdrop, COVER_BACKDROP_DEFAULT);
|
||||
assert_eq!(s.volume, 100);
|
||||
assert!(!s.muted);
|
||||
assert!(s.show_hint_bar);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -223,6 +378,7 @@ mod tests {
|
||||
let s: Settings = toml::from_str("album_art_colours = true\n").unwrap();
|
||||
assert!(s.album_art_colours);
|
||||
assert_eq!(s.cover_backdrop, COVER_BACKDROP_DEFAULT);
|
||||
assert!(s.show_hint_bar);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -232,6 +388,7 @@ mod tests {
|
||||
cover_backdrop: 70,
|
||||
volume: 35,
|
||||
muted: true,
|
||||
show_hint_bar: false,
|
||||
};
|
||||
let back: Settings = toml::from_str(&toml::to_string(&s).unwrap()).unwrap();
|
||||
assert_eq!(back, s);
|
||||
|
||||
@@ -88,6 +88,7 @@ fn step(ui: slint::Weak<AppWindow>, steps: Vec<String>, i: usize) {
|
||||
"next" => Action::Next,
|
||||
"play-pause" => Action::PlayPause,
|
||||
"section-next" => Action::SectionNext,
|
||||
"section-prev" => Action::SectionPrev,
|
||||
"now-playing" => Action::NowPlaying,
|
||||
"search" => Action::Search,
|
||||
"quit" => Action::Quit,
|
||||
|
||||
+13
@@ -5,6 +5,7 @@ mod config;
|
||||
mod devscript;
|
||||
mod inhibit;
|
||||
mod input;
|
||||
mod mpris;
|
||||
mod palette;
|
||||
mod player;
|
||||
mod prompts;
|
||||
@@ -27,6 +28,18 @@ fn main() -> anyhow::Result<()> {
|
||||
let ui = AppWindow::new()?;
|
||||
ui.set_version(env!("CARGO_PKG_VERSION").into());
|
||||
app::install(&ui, rt.handle().clone());
|
||||
// The controller is read from the device, whichever window is in front, so
|
||||
// the app needs to know when another one is, to leave the presses to it.
|
||||
{
|
||||
use slint::winit_030::{EventResult, WinitWindowAccessor, winit::event::WindowEvent};
|
||||
ui.window().on_winit_window_event(|_, event| {
|
||||
if let WindowEvent::Focused(focused) = *event {
|
||||
log::debug!("window focused: {focused}");
|
||||
app::with_app(move |app| app.set_window_active(focused));
|
||||
}
|
||||
EventResult::Propagate
|
||||
});
|
||||
}
|
||||
input::spawn_gamepad(|ev| {
|
||||
let _ = slint::invoke_from_event_loop(move || {
|
||||
app::with_app(move |app| match ev {
|
||||
|
||||
+368
@@ -0,0 +1,368 @@
|
||||
//! MPRIS on the session bus, so the desktop's media controls and media keys
|
||||
//! can drive playback. Headphone buttons arrive this way too: the desktop
|
||||
//! turns the key events of a headset or a Bluetooth AVRCP device into calls
|
||||
//! on the active MPRIS player. Reading those devices directly is not an
|
||||
//! option, since keyboard-like input devices are root:input and only
|
||||
//! gamepads are opened up to the logged-in user.
|
||||
//!
|
||||
//! A bus that cannot be reached, or a name already taken by another remus,
|
||||
//! is logged once and otherwise ignored.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicI64, Ordering};
|
||||
|
||||
use anyhow::Result;
|
||||
use tokio::runtime::Handle;
|
||||
use tokio::sync::watch;
|
||||
use zbus::interface;
|
||||
use zbus::zvariant::{ObjectPath, OwnedValue, Value};
|
||||
|
||||
const BUS_NAME: &str = "org.mpris.MediaPlayer2.remus";
|
||||
const PATH: &str = "/org/mpris/MediaPlayer2";
|
||||
const DESKTOP_ENTRY: &str = "me.anshorei.Fettleshed.Remus";
|
||||
|
||||
/// What a client asked for.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum Command {
|
||||
PlayPause,
|
||||
Play,
|
||||
Pause,
|
||||
Stop,
|
||||
Next,
|
||||
Previous,
|
||||
Quit,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
pub enum Status {
|
||||
#[default]
|
||||
Stopped,
|
||||
Paused,
|
||||
Playing,
|
||||
}
|
||||
|
||||
impl Status {
|
||||
fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Status::Stopped => "Stopped",
|
||||
Status::Paused => "Paused",
|
||||
Status::Playing => "Playing",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq)]
|
||||
pub struct Track {
|
||||
/// Position in the queue, which makes the track id.
|
||||
pub index: usize,
|
||||
pub title: String,
|
||||
pub artist: Option<String>,
|
||||
pub album: Option<String>,
|
||||
pub seconds: Option<u32>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq)]
|
||||
pub struct NowPlaying {
|
||||
pub status: Status,
|
||||
pub track: Option<Track>,
|
||||
/// 0 to 1, already muted to 0.
|
||||
pub volume: f64,
|
||||
}
|
||||
|
||||
pub struct Mpris {
|
||||
state: watch::Sender<NowPlaying>,
|
||||
position: Arc<AtomicI64>,
|
||||
}
|
||||
|
||||
impl Mpris {
|
||||
pub fn spawn(rt: &Handle, on_command: impl Fn(Command) + Send + Sync + 'static) -> Mpris {
|
||||
let (state, rx) = watch::channel(NowPlaying::default());
|
||||
let position = Arc::new(AtomicI64::new(0));
|
||||
let pos = position.clone();
|
||||
let on_command: Arc<dyn Fn(Command) + Send + Sync> = Arc::new(on_command);
|
||||
rt.spawn(async move {
|
||||
if let Err(e) = run(rx, pos, on_command).await {
|
||||
log::warn!("MPRIS unavailable, media keys will not reach remus: {e:#}");
|
||||
}
|
||||
});
|
||||
Mpris { state, position }
|
||||
}
|
||||
|
||||
/// Publishes what is playing. Clients hear only about what changed.
|
||||
pub fn update(&self, now: NowPlaying) {
|
||||
self.state.send_if_modified(|s| {
|
||||
let changed = *s != now;
|
||||
*s = now;
|
||||
changed
|
||||
});
|
||||
}
|
||||
|
||||
/// Clients read the position when they want it; it sends no signal.
|
||||
pub fn set_position(&self, seconds: f64) {
|
||||
self.position.store((seconds * 1e6) as i64, Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
async fn run(
|
||||
mut rx: watch::Receiver<NowPlaying>,
|
||||
position: Arc<AtomicI64>,
|
||||
on_command: Arc<dyn Fn(Command) + Send + Sync>,
|
||||
) -> Result<()> {
|
||||
let player = Player {
|
||||
now: rx.borrow().clone(),
|
||||
position,
|
||||
on_command: on_command.clone(),
|
||||
};
|
||||
let conn = zbus::connection::Builder::session()?
|
||||
.name(BUS_NAME)?
|
||||
.serve_at(PATH, Root { on_command })?
|
||||
.serve_at(PATH, player)?
|
||||
.build()
|
||||
.await?;
|
||||
log::info!("MPRIS player registered as {BUS_NAME}");
|
||||
let iface = conn.object_server().interface::<_, Player>(PATH).await?;
|
||||
while rx.changed().await.is_ok() {
|
||||
let now = rx.borrow_and_update().clone();
|
||||
let mut p = iface.get_mut().await;
|
||||
let status = p.now.status != now.status;
|
||||
let track = p.now.track != now.track;
|
||||
let volume = p.now.volume != now.volume;
|
||||
p.now = now;
|
||||
let emitter = iface.signal_emitter();
|
||||
if status {
|
||||
p.playback_status_changed(emitter).await?;
|
||||
}
|
||||
if track {
|
||||
p.metadata_changed(emitter).await?;
|
||||
p.can_play_changed(emitter).await?;
|
||||
p.can_pause_changed(emitter).await?;
|
||||
p.can_go_next_changed(emitter).await?;
|
||||
p.can_go_previous_changed(emitter).await?;
|
||||
}
|
||||
if volume {
|
||||
p.volume_changed(emitter).await?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
struct Root {
|
||||
on_command: Arc<dyn Fn(Command) + Send + Sync>,
|
||||
}
|
||||
|
||||
#[interface(name = "org.mpris.MediaPlayer2")]
|
||||
impl Root {
|
||||
fn raise(&self) {}
|
||||
|
||||
fn quit(&self) {
|
||||
(self.on_command)(Command::Quit);
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn can_quit(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn can_raise(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn has_track_list(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn identity(&self) -> &str {
|
||||
"Remus"
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn desktop_entry(&self) -> &str {
|
||||
DESKTOP_ENTRY
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn supported_uri_schemes(&self) -> Vec<String> {
|
||||
Vec::new()
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn supported_mime_types(&self) -> Vec<String> {
|
||||
Vec::new()
|
||||
}
|
||||
}
|
||||
|
||||
struct Player {
|
||||
now: NowPlaying,
|
||||
position: Arc<AtomicI64>,
|
||||
on_command: Arc<dyn Fn(Command) + Send + Sync>,
|
||||
}
|
||||
|
||||
#[interface(name = "org.mpris.MediaPlayer2.Player")]
|
||||
impl Player {
|
||||
fn play_pause(&self) {
|
||||
(self.on_command)(Command::PlayPause);
|
||||
}
|
||||
|
||||
fn play(&self) {
|
||||
(self.on_command)(Command::Play);
|
||||
}
|
||||
|
||||
fn pause(&self) {
|
||||
(self.on_command)(Command::Pause);
|
||||
}
|
||||
|
||||
fn stop(&self) {
|
||||
(self.on_command)(Command::Stop);
|
||||
}
|
||||
|
||||
fn next(&self) {
|
||||
(self.on_command)(Command::Next);
|
||||
}
|
||||
|
||||
fn previous(&self) {
|
||||
(self.on_command)(Command::Previous);
|
||||
}
|
||||
|
||||
// CanSeek is false, so clients do not call these; they are part of the
|
||||
// interface all the same.
|
||||
fn seek(&self, _offset: i64) {}
|
||||
|
||||
fn set_position(&self, _track_id: ObjectPath<'_>, _position: i64) {}
|
||||
|
||||
fn open_uri(&self, _uri: &str) {}
|
||||
|
||||
#[zbus(property)]
|
||||
fn playback_status(&self) -> &str {
|
||||
self.now.status.as_str()
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn rate(&self) -> f64 {
|
||||
1.0
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn minimum_rate(&self) -> f64 {
|
||||
1.0
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn maximum_rate(&self) -> f64 {
|
||||
1.0
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn metadata(&self) -> HashMap<String, OwnedValue> {
|
||||
metadata(self.now.track.as_ref())
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn volume(&self) -> f64 {
|
||||
self.now.volume
|
||||
}
|
||||
|
||||
#[zbus(property(emits_changed_signal = "false"))]
|
||||
fn position(&self) -> i64 {
|
||||
self.position.load(Ordering::Relaxed)
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn can_go_next(&self) -> bool {
|
||||
self.now.track.is_some()
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn can_go_previous(&self) -> bool {
|
||||
self.now.track.is_some()
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn can_play(&self) -> bool {
|
||||
self.now.track.is_some()
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn can_pause(&self) -> bool {
|
||||
self.now.track.is_some()
|
||||
}
|
||||
|
||||
#[zbus(property)]
|
||||
fn can_seek(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
#[zbus(property(emits_changed_signal = "const"))]
|
||||
fn can_control(&self) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
/// The MPRIS metadata map for a track, empty when nothing is loaded.
|
||||
fn metadata(track: Option<&Track>) -> HashMap<String, OwnedValue> {
|
||||
let mut m = HashMap::new();
|
||||
let Some(t) = track else {
|
||||
let none = ObjectPath::from_static_str_unchecked("/org/mpris/MediaPlayer2/TrackList/NoTrack");
|
||||
insert(&mut m, "mpris:trackid", Value::from(none));
|
||||
return m;
|
||||
};
|
||||
// Outside /org/mpris, which the spec reserves.
|
||||
let id = format!("/me/anshorei/Fettleshed/Remus/track/{}", t.index);
|
||||
if let Ok(path) = ObjectPath::try_from(id) {
|
||||
insert(&mut m, "mpris:trackid", Value::from(path));
|
||||
}
|
||||
insert(&mut m, "xesam:title", Value::from(t.title.clone()));
|
||||
if let Some(a) = &t.artist {
|
||||
insert(&mut m, "xesam:artist", Value::from(vec![a.clone()]));
|
||||
}
|
||||
if let Some(a) = &t.album {
|
||||
insert(&mut m, "xesam:album", Value::from(a.clone()));
|
||||
}
|
||||
if let Some(s) = t.seconds {
|
||||
insert(&mut m, "mpris:length", Value::from(s as i64 * 1_000_000));
|
||||
}
|
||||
m
|
||||
}
|
||||
|
||||
fn insert(m: &mut HashMap<String, OwnedValue>, key: &str, value: Value<'_>) {
|
||||
if let Ok(v) = OwnedValue::try_from(value) {
|
||||
m.insert(key.to_string(), v);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn metadata_without_a_track_says_so() {
|
||||
let m = metadata(None);
|
||||
assert_eq!(m.len(), 1);
|
||||
let id: ObjectPath = m["mpris:trackid"].clone().try_into().unwrap();
|
||||
assert_eq!(id.as_str(), "/org/mpris/MediaPlayer2/TrackList/NoTrack");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn metadata_carries_the_track() {
|
||||
let t = Track {
|
||||
index: 3,
|
||||
title: "Feijão".into(),
|
||||
artist: Some("Dr. Quandary".into()),
|
||||
album: None,
|
||||
seconds: Some(218),
|
||||
};
|
||||
let m = metadata(Some(&t));
|
||||
let title: String = m["xesam:title"].clone().try_into().unwrap();
|
||||
assert_eq!(title, "Feijão");
|
||||
let artists: Vec<String> = m["xesam:artist"].clone().try_into().unwrap();
|
||||
assert_eq!(artists, ["Dr. Quandary"]);
|
||||
let length: i64 = m["mpris:length"].clone().try_into().unwrap();
|
||||
assert_eq!(length, 218_000_000);
|
||||
assert!(!m.contains_key("xesam:album"));
|
||||
let id: ObjectPath = m["mpris:trackid"].clone().try_into().unwrap();
|
||||
assert_eq!(id.as_str(), "/me/anshorei/Fettleshed/Remus/track/3");
|
||||
}
|
||||
}
|
||||
+183
-7
@@ -2,6 +2,7 @@
|
||||
//! track can be handed to playbin in `about-to-finish`, which keeps playback
|
||||
//! gapless.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::{Arc, Mutex, MutexGuard};
|
||||
use std::thread::JoinHandle;
|
||||
@@ -11,13 +12,17 @@ use anyhow::{Context, Result};
|
||||
use gstreamer as gst;
|
||||
use gstreamer::prelude::*;
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
#[derive(Debug, Clone)]
|
||||
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>>),
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
@@ -33,14 +38,21 @@ struct Queue {
|
||||
seek_to: Option<f64>,
|
||||
}
|
||||
|
||||
/// Pictures found in the files being decoded, by URI.
|
||||
type Pictures = Arc<Mutex<HashMap<String, Vec<u8>>>>;
|
||||
|
||||
pub struct Player {
|
||||
playbin: gst::Element,
|
||||
queue: Arc<Mutex<Queue>>,
|
||||
pictures: Pictures,
|
||||
stop: Arc<AtomicBool>,
|
||||
bus_thread: Option<JoinHandle<()>>,
|
||||
}
|
||||
|
||||
const TICK: Duration = Duration::from_millis(250);
|
||||
/// How long after a track starts its tags can still bring a picture. Tags
|
||||
/// come ahead of the audio, so this is mostly a slow server's margin.
|
||||
const ART_WAIT: Duration = Duration::from_millis(600);
|
||||
|
||||
impl Player {
|
||||
pub fn spawn(on_event: impl Fn(PlayerEvent) + Send + 'static) -> Result<Player> {
|
||||
@@ -71,15 +83,19 @@ impl Player {
|
||||
None
|
||||
});
|
||||
|
||||
let pictures = Pictures::default();
|
||||
watch_pictures(&playbin, &pictures);
|
||||
|
||||
let stop = Arc::new(AtomicBool::new(false));
|
||||
let bus_thread = std::thread::Builder::new().name("gst-bus".into()).spawn({
|
||||
let (playbin, queue, stop) = (playbin.clone(), queue.clone(), stop.clone());
|
||||
move || watch_bus(&playbin, &queue, &stop, &on_event)
|
||||
let (playbin, queue, pictures, stop) = (playbin.clone(), queue.clone(), pictures.clone(), stop.clone());
|
||||
move || watch_bus(&playbin, &queue, &pictures, &stop, &on_event)
|
||||
})?;
|
||||
|
||||
Ok(Player {
|
||||
playbin,
|
||||
queue,
|
||||
pictures,
|
||||
stop,
|
||||
bus_thread: Some(bus_thread),
|
||||
})
|
||||
@@ -143,6 +159,14 @@ impl Player {
|
||||
start(&self.playbin, &url);
|
||||
}
|
||||
|
||||
/// 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();
|
||||
lock(&self.pictures).clear();
|
||||
let _ = self.playbin.set_state(gst::State::Null);
|
||||
}
|
||||
|
||||
pub fn toggle_pause(&self) {
|
||||
// Toggles where the pipeline is heading, so play pressed while a
|
||||
// paused track is still loading is not lost.
|
||||
@@ -206,8 +230,53 @@ impl Drop for Player {
|
||||
}
|
||||
}
|
||||
|
||||
fn lock(q: &Mutex<Queue>) -> MutexGuard<'_, Queue> {
|
||||
q.lock().unwrap_or_else(|e| e.into_inner())
|
||||
fn lock<T>(m: &Mutex<T>) -> MutexGuard<'_, T> {
|
||||
m.lock().unwrap_or_else(|e| e.into_inner())
|
||||
}
|
||||
|
||||
/// Records the picture in each file playbin decodes, keyed by its URI. Read
|
||||
/// where each file's decoder hands on its stream, because further down the
|
||||
/// tags of a file without a picture still carry the previous file's, once
|
||||
/// playback moves on gaplessly.
|
||||
fn watch_pictures(playbin: &gst::Element, pictures: &Pictures) {
|
||||
let Some(bin) = playbin.downcast_ref::<gst::Bin>() else {
|
||||
return;
|
||||
};
|
||||
let pictures = pictures.clone();
|
||||
bin.connect_deep_element_added(move |_, _, element| {
|
||||
let decoder = element
|
||||
.factory()
|
||||
.is_some_and(|f| matches!(f.name().as_str(), "uridecodebin" | "uridecodebin3"));
|
||||
// playbin adds the same decoder again for later tracks.
|
||||
// SAFETY: the key is only ever set to a bool, here.
|
||||
if !decoder || unsafe { element.data::<bool>("remus-pictures") }.is_some() {
|
||||
return;
|
||||
}
|
||||
unsafe { element.set_data("remus-pictures", true) };
|
||||
let pictures = pictures.clone();
|
||||
element.connect_pad_added(move |decoder, pad| {
|
||||
let decoder = decoder.downgrade();
|
||||
let pictures = pictures.clone();
|
||||
pad.add_probe(gst::PadProbeType::EVENT_DOWNSTREAM, move |_, info| {
|
||||
if let Some(gst::PadProbeData::Event(ev)) = &info.data
|
||||
&& let gst::EventView::Tag(t) = ev.view()
|
||||
&& let Some(bytes) = embedded_picture(t.tag())
|
||||
&& let Some(uri) = decoder.upgrade().and_then(|d| d.property::<Option<String>>("uri"))
|
||||
{
|
||||
lock(&pictures).entry(uri).or_insert(bytes);
|
||||
}
|
||||
gst::PadProbeReturn::Ok
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/// The track whose picture is still being looked for.
|
||||
struct ArtWait {
|
||||
index: usize,
|
||||
since: Instant,
|
||||
/// Already reported as without a picture; one turning up later is still sent.
|
||||
told_none: bool,
|
||||
}
|
||||
|
||||
fn start(playbin: &gst::Element, url: &str) {
|
||||
@@ -239,7 +308,13 @@ fn seek_to(playbin: &gst::Element, seconds: f64) {
|
||||
}
|
||||
}
|
||||
|
||||
fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, emit: &dyn Fn(PlayerEvent)) {
|
||||
fn watch_bus(
|
||||
playbin: &gst::Element,
|
||||
queue: &Mutex<Queue>,
|
||||
pictures: &Pictures,
|
||||
stop: &AtomicBool,
|
||||
emit: &dyn Fn(PlayerEvent),
|
||||
) {
|
||||
let Some(bus) = playbin.bus() else { return };
|
||||
let mut last_tick = Instant::now();
|
||||
let mut duration = 0.0;
|
||||
@@ -252,8 +327,12 @@ fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, em
|
||||
last_track = Some(t);
|
||||
emit(PlayerEvent::Track(t));
|
||||
emit(PlayerEvent::Position(0.0));
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
};
|
||||
let mut art_wait: Option<ArtWait> = None;
|
||||
while !stop.load(Ordering::Relaxed) {
|
||||
if let Some(msg) = bus.timed_pop(gst::ClockTime::from_mseconds(TICK.as_millis() as u64)) {
|
||||
use gst::MessageView;
|
||||
@@ -271,7 +350,24 @@ fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, em
|
||||
(q.current, started)
|
||||
};
|
||||
duration = 0.0;
|
||||
report_track(current, started);
|
||||
if report_track(current, started) {
|
||||
art_wait = current.map(|index| ArtWait {
|
||||
index,
|
||||
since: Instant::now(),
|
||||
told_none: false,
|
||||
});
|
||||
// Keep only what this track and the next may still need.
|
||||
let keep: Vec<String> = {
|
||||
let q = lock(queue);
|
||||
current
|
||||
.into_iter()
|
||||
.flat_map(|i| q.urls.get(i..=i + 1))
|
||||
.flatten()
|
||||
.cloned()
|
||||
.collect()
|
||||
};
|
||||
lock(pictures).retain(|uri, _| keep.contains(uri));
|
||||
}
|
||||
}
|
||||
MessageView::StateChanged(s) if s.src() == Some(playbin.upcast_ref()) => match s.current() {
|
||||
gst::State::Playing => emit(PlayerEvent::Paused(false)),
|
||||
@@ -296,6 +392,7 @@ fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, em
|
||||
}
|
||||
let _ = playbin.set_state(gst::State::Ready);
|
||||
report_track(None, false);
|
||||
art_wait = None;
|
||||
}
|
||||
// A failing source posts several errors. Once the first has moved
|
||||
// on to the next track, the source is out of playbin and the rest
|
||||
@@ -329,11 +426,23 @@ fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, em
|
||||
} else {
|
||||
let _ = playbin.set_state(gst::State::Ready);
|
||||
report_track(None, false);
|
||||
art_wait = None;
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
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));
|
||||
}
|
||||
}
|
||||
if last_tick.elapsed() >= TICK {
|
||||
last_tick = Instant::now();
|
||||
if playbin.current_state() == gst::State::Playing {
|
||||
@@ -351,6 +460,22 @@ fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, em
|
||||
}
|
||||
}
|
||||
|
||||
/// The front cover among the pictures in `tags`, else the first picture.
|
||||
fn embedded_picture(tags: &gst::TagListRef) -> Option<Vec<u8>> {
|
||||
// GST_TAG_IMAGE_TYPE_FRONT_COVER in gst-tag's GstTagImageType.
|
||||
const FRONT_COVER: i32 = 1;
|
||||
let is_front = |s: &gst::Sample| {
|
||||
s.info()
|
||||
.and_then(|i| i.value("image-type").ok())
|
||||
.and_then(|v| gst::glib::EnumValue::from_value(v))
|
||||
.is_some_and(|(_, v)| v.value() == FRONT_COVER)
|
||||
};
|
||||
let pictures: Vec<gst::Sample> = tags.iter_tag::<gst::tags::Image>().map(|v| v.get()).collect();
|
||||
let sample = pictures.iter().find(|s| is_front(s)).or(pictures.first())?;
|
||||
let map = sample.buffer()?.map_readable().ok()?;
|
||||
Some(map.as_slice().to_vec())
|
||||
}
|
||||
|
||||
/// Removes the query string from any URL in `text`. Stream URLs carry the
|
||||
/// Subsonic auth token, and GStreamer's HTTP errors quote the URL.
|
||||
fn strip_queries(text: &str) -> String {
|
||||
@@ -418,6 +543,57 @@ mod tests {
|
||||
format!("file://{}", path.display())
|
||||
}
|
||||
|
||||
/// Puts an ID3v2.3 tag holding `picture` as the front cover before the
|
||||
/// file at `uri`, as a tagged MP3 would carry it.
|
||||
fn with_id3_picture(uri: &str, picture: &[u8]) {
|
||||
let path = uri.strip_prefix("file://").unwrap();
|
||||
let mut body = vec![0u8]; // Latin-1 text
|
||||
body.extend_from_slice(b"image/png\0");
|
||||
body.push(3); // front cover
|
||||
body.push(0); // empty description
|
||||
body.extend_from_slice(picture);
|
||||
let mut frame = b"APIC".to_vec();
|
||||
frame.extend_from_slice(&(body.len() as u32).to_be_bytes());
|
||||
frame.extend_from_slice(&[0, 0]);
|
||||
frame.extend_from_slice(&body);
|
||||
let n = frame.len() as u32;
|
||||
let syncsafe = [(n >> 21) & 0x7f, (n >> 14) & 0x7f, (n >> 7) & 0x7f, n & 0x7f].map(|b| b as u8);
|
||||
let mut tagged = b"ID3\x03\x00\x00".to_vec();
|
||||
tagged.extend_from_slice(&syncsafe);
|
||||
tagged.extend_from_slice(&frame);
|
||||
tagged.extend_from_slice(&std::fs::read(path).unwrap());
|
||||
std::fs::write(path, tagged).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reports_the_picture_in_each_file() {
|
||||
// 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-art-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let urls = vec![silent_wav(&dir, "a.wav", 1.0), silent_wav(&dir, "b.wav", 1.0)];
|
||||
let mut png = Vec::new();
|
||||
image::RgbImage::from_pixel(4, 4, image::Rgb([200, 30, 30]))
|
||||
.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png)
|
||||
.unwrap();
|
||||
with_id3_picture(&urls[0], &png);
|
||||
|
||||
let (tx, rx) = mpsc::channel();
|
||||
let player = Player::spawn(move |ev| {
|
||||
if let PlayerEvent::Art(i, bytes) = ev {
|
||||
let _ = tx.send((i, bytes));
|
||||
}
|
||||
})
|
||||
.unwrap();
|
||||
player.play_list(&urls, 0);
|
||||
let first = rx.recv_timeout(Duration::from_secs(5));
|
||||
let second = rx.recv_timeout(Duration::from_secs(5));
|
||||
drop(player);
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
assert_eq!(first, Ok((0, Some(png))), "the tagged file's picture");
|
||||
assert_eq!(second, Ok((1, None)), "the plain file has none");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plays_a_queue_through_to_the_end() {
|
||||
// SAFETY: set before any thread reads the environment in this test.
|
||||
|
||||
+87
-25
@@ -213,8 +213,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;
|
||||
@@ -572,16 +574,24 @@ component VolumeLevel inherits HorizontalLayout {
|
||||
in property <int> level;
|
||||
in property <bool> muted;
|
||||
in property <length> font-size: 13px * Theme.s;
|
||||
// The speaker gets a box as wide as the number, so the bar is the middle
|
||||
// of the whole and centring the row centres the bar.
|
||||
in property <bool> balanced;
|
||||
// Fixed, so the bar does not shift as the number changes, and wide enough
|
||||
// for "Muted".
|
||||
property <length> label-width: 4.2 * root.font-size;
|
||||
spacing: 10px * Theme.s;
|
||||
// Its own width only, so a stretching row does not hand it the slack.
|
||||
horizontal-stretch: 0;
|
||||
|
||||
VerticalLayout {
|
||||
alignment: center;
|
||||
HorizontalLayout {
|
||||
width: root.balanced ? root.label-width : 14px * Theme.s;
|
||||
alignment: end;
|
||||
Speaker {
|
||||
muted: root.muted || root.level == 0;
|
||||
tint: Theme.muted;
|
||||
size: 14px * Theme.s;
|
||||
y: (parent.height - self.height) / 2;
|
||||
}
|
||||
}
|
||||
VerticalLayout {
|
||||
@@ -600,9 +610,7 @@ component VolumeLevel inherits HorizontalLayout {
|
||||
}
|
||||
}
|
||||
Text {
|
||||
// Fixed, so the bar does not shift as the number changes, and wide
|
||||
// enough for "Muted".
|
||||
width: 4.2 * root.font-size;
|
||||
width: root.label-width;
|
||||
text: root.muted ? "Muted" : root.level;
|
||||
font-size: root.font-size;
|
||||
color: Theme.muted;
|
||||
@@ -801,6 +809,8 @@ component Field inherits VerticalLayout {
|
||||
in property <string> label;
|
||||
in-out property <string> text;
|
||||
in property <bool> password;
|
||||
// A password field shows its text while this is set, toggled by the eye.
|
||||
in-out property <bool> shown;
|
||||
in property <bool> highlighted;
|
||||
callback accepted;
|
||||
public function focus-input() {
|
||||
@@ -821,16 +831,55 @@ component Field inherits VerticalLayout {
|
||||
border-color: input.has-focus || root.highlighted ? Theme.focus : Theme.line;
|
||||
input := TextInput {
|
||||
x: 16px * Theme.s;
|
||||
width: parent.width - 32px * Theme.s;
|
||||
// Leaves room for the eye on a password field.
|
||||
width: parent.width - (root.password ? 64px : 32px) * Theme.s;
|
||||
height: parent.height;
|
||||
text <=> root.text;
|
||||
font-size: 19px * Theme.s;
|
||||
color: Theme.text;
|
||||
vertical-alignment: center;
|
||||
single-line: true;
|
||||
input-type: root.password ? InputType.password : InputType.text;
|
||||
input-type: root.password && !root.shown ? InputType.password : InputType.text;
|
||||
accepted => { root.accepted(); }
|
||||
}
|
||||
if root.password: Rectangle {
|
||||
x: parent.width - self.width - 8px * Theme.s;
|
||||
width: 40px * Theme.s;
|
||||
height: parent.height;
|
||||
// An eye to show the password, struck through to hide it again.
|
||||
Path {
|
||||
width: 22px * Theme.s;
|
||||
height: 22px * Theme.s;
|
||||
viewbox-width: 24;
|
||||
viewbox-height: 24;
|
||||
commands: "M 1.5 12 C 4.5 6.5 8 4.5 12 4.5 C 16 4.5 19.5 6.5 22.5 12 C 19.5 17.5 16 19.5 12 19.5 C 8 19.5 4.5 17.5 1.5 12 Z";
|
||||
stroke: eye-area.has-hover ? Theme.text : Theme.muted;
|
||||
stroke-width: 1.6px * Theme.s;
|
||||
}
|
||||
Path {
|
||||
width: 22px * Theme.s;
|
||||
height: 22px * Theme.s;
|
||||
viewbox-width: 24;
|
||||
viewbox-height: 24;
|
||||
commands: "M 12 8.5 A 3.5 3.5 0 1 1 11.99 8.5 Z";
|
||||
fill: eye-area.has-hover ? Theme.text : Theme.muted;
|
||||
}
|
||||
if root.shown: Path {
|
||||
width: 22px * Theme.s;
|
||||
height: 22px * Theme.s;
|
||||
viewbox-width: 24;
|
||||
viewbox-height: 24;
|
||||
commands: "M 3 21 L 21 3";
|
||||
stroke: eye-area.has-hover ? Theme.text : Theme.muted;
|
||||
stroke-width: 1.8px * Theme.s;
|
||||
}
|
||||
eye-area := TouchArea {
|
||||
clicked => {
|
||||
root.shown = !root.shown;
|
||||
input.focus();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -838,9 +887,12 @@ component LoginView inherits Rectangle {
|
||||
in-out property <string> server;
|
||||
in-out property <string> username;
|
||||
in-out property <string> password;
|
||||
in-out property <bool> password-shown;
|
||||
in property <int> focus-index;
|
||||
in property <string> error;
|
||||
in property <bool> busy;
|
||||
// Adding a server from inside the app: the bottom button goes back.
|
||||
in property <bool> can-cancel;
|
||||
callback submit;
|
||||
callback exit;
|
||||
callback field-clicked(int);
|
||||
@@ -896,6 +948,7 @@ component LoginView inherits Rectangle {
|
||||
label: "Password";
|
||||
text <=> root.password;
|
||||
password: true;
|
||||
shown <=> root.password-shown;
|
||||
highlighted: root.focus-index == 2;
|
||||
accepted => { root.submit(); }
|
||||
}
|
||||
@@ -920,7 +973,7 @@ component LoginView inherits Rectangle {
|
||||
border-width: 2px * Theme.s;
|
||||
border-color: root.focus-index == 4 ? Theme.focus : Theme.line;
|
||||
Text {
|
||||
text: "Exit";
|
||||
text: root.can-cancel ? "Cancel" : "Exit";
|
||||
font-size: 17px * Theme.s;
|
||||
color: root.focus-index == 4 ? Theme.text : Theme.muted;
|
||||
}
|
||||
@@ -1043,35 +1096,37 @@ component NowPlayingView inherits Rectangle {
|
||||
background: Theme.highlight;
|
||||
}
|
||||
}
|
||||
HorizontalLayout {
|
||||
Text {
|
||||
// Placed by hand: the icon on the bar's midpoint whatever the
|
||||
// widths of the two times, which a layout would share out.
|
||||
Rectangle {
|
||||
height: position-text.preferred-height;
|
||||
position-text := Text {
|
||||
x: 0;
|
||||
width: self.preferred-width;
|
||||
text: root.position;
|
||||
font-size: 14px * Theme.s;
|
||||
color: Theme.muted;
|
||||
}
|
||||
// Sized below the time text, so the row keeps the text's height.
|
||||
HorizontalLayout {
|
||||
horizontal-stretch: 1;
|
||||
alignment: center;
|
||||
if root.has-track: VerticalLayout {
|
||||
alignment: center;
|
||||
PlayState {
|
||||
paused: root.paused;
|
||||
size: 11px * Theme.s;
|
||||
}
|
||||
}
|
||||
}
|
||||
Text {
|
||||
x: parent.width - self.width;
|
||||
width: self.preferred-width;
|
||||
text: root.duration;
|
||||
font-size: 14px * Theme.s;
|
||||
color: Theme.muted;
|
||||
}
|
||||
if root.has-track: PlayState {
|
||||
x: (parent.width - self.width) / 2;
|
||||
y: (parent.height - self.height) / 2;
|
||||
paused: root.paused;
|
||||
size: 11px * Theme.s;
|
||||
}
|
||||
}
|
||||
HorizontalLayout {
|
||||
alignment: center;
|
||||
VolumeLevel {
|
||||
level: root.volume;
|
||||
muted: root.muted;
|
||||
balanced: true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1144,6 +1199,8 @@ export component AppWindow inherits Window {
|
||||
in property <int> login-focus;
|
||||
in property <string> login-error;
|
||||
in property <bool> login-busy;
|
||||
in property <bool> login-can-cancel;
|
||||
in-out property <bool> login-password-shown;
|
||||
|
||||
// Browse
|
||||
in property <[string]> sections;
|
||||
@@ -1191,6 +1248,7 @@ export component AppWindow inherits Window {
|
||||
in property <int> volume;
|
||||
in property <bool> muted;
|
||||
in property <string> version;
|
||||
in property <bool> show-hint-bar: true;
|
||||
|
||||
public function focus-main() {
|
||||
fs.focus();
|
||||
@@ -1262,11 +1320,13 @@ export component AppWindow inherits Window {
|
||||
server <=> root.login-server;
|
||||
username <=> root.login-username;
|
||||
password <=> root.login-password;
|
||||
password-shown <=> root.login-password-shown;
|
||||
focus-index: root.login-focus;
|
||||
error: root.login-error;
|
||||
busy: root.login-busy;
|
||||
submit => { root.login-submit(); }
|
||||
exit => { root.action(Action.quit); }
|
||||
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); }
|
||||
}
|
||||
|
||||
@@ -1404,7 +1464,9 @@ export component AppWindow inherits Window {
|
||||
muted: root.muted;
|
||||
}
|
||||
|
||||
HintBar {
|
||||
// Optional, except on the login screen, where the controls are
|
||||
// not known yet and Settings cannot be reached.
|
||||
if root.show-hint-bar || root.screen == Screen.login: HintBar {
|
||||
height: 46px * Theme.s;
|
||||
hints: root.hints;
|
||||
version: root.version;
|
||||
|
||||
Reference in New Issue
Block a user