feat: music player island with MPRIS and PipeWire

[nongio]

Summary

Adds a music player island to otto-islands with MPRIS player control, PipeWire audio visualization, and a polished layout/animation system.

Music island

• MPRIS monitoring via playerctl — track info, album art, playback state
• PipeWire audio level capture for real-time EQ bar animation
• Three display modes: Mini (animated EQ bars), Compact (album art + title + controls), Expanded (full player with progress bar and seek)
• Interactive controls: play/pause, skip forward/back, seek via progress bar
• Album art loading (including remote fetch for Spotify) with accent color extraction for dynamic theming
• 3-second grace period when track disappears to avoid flicker on track changes
• Music island only appears when player app loses focus

Layout and animation

• Fixed-width island layer (900px) with manual centering — eliminates Wayland layer re-centering jank during animations
• Two-zone layout: notifications on the left, priority islands (music) on the right
• Cascade slide animations radiating from the island that changed most (epicenter)
• Focus bias: content pulls 15% toward the clicked pill for visual feedback
• New islands appear small and bounce-animate to their target size
• Smooth animations for all mode transitions (Mini ↔ Compact ↔ Expanded)
• Click on empty space dismisses expanded islands
• Centralized focus/mode management with unit tests

Performance

• EQ bars rendered as child subsurface — only EQ redraws at 24fps, not the full pill
• Split redraw: fast EQ tick (~24fps) and slow full redraw (1fps for progress bar)
• PipeWire level updates throttled to ~15fps
• Partial EQ redraw — only clear and damage the equalizer region

Try it out

# Terminal 1: run Otto
cargo run -- --winit

# Terminal 2: run otto-islands
WAYLAND_DISPLAY=wayland-1 cargo run -p otto-islands

# Terminal 3: play music in any MPRIS-compatible player
spotify &
# or: vlc music.mp3 &

The music island appears automatically when playback starts and the player app loses focus.

Test plan

• cargo build -p otto-islands passes
• Play music in Spotify/VLC — music island appears when player loses focus
• Click play/pause, skip controls work
• Expanded mode shows progress bar, clicking seeks
• Stop music — island disappears after 3s grace period
• Music island coexists with notification islands (two-zone layout)
• Notifications cascade-animate when islands are added/removed
• Click empty space to dismiss expanded islands
• New islands appear small and animate to target size

[Copilot]

Pull request overview

Adds a new “music player island” to otto-islands, integrating MPRIS-based playback metadata/control (via playerctl) and PipeWire-based audio level sampling to drive an animated EQ UI across mini/compact/expanded presentation modes.

Changes:

• Introduces music.rs implementing the music activity renderer, MPRIS polling, PipeWire capture, and control actions (play/pause/skip/seek).
• Wires music monitoring and rendering into the main island lifecycle, layout, input handling, and tick scheduling (30fps when playing).
• Adds the pipewire dependency to the otto-islands crate.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated 7 comments.

File	Description
components/otto-islands/src/music.rs	New music island renderer + background monitors for playerctl and PipeWire, plus playback control actions.
components/otto-islands/src/main.rs	Integrates the music island into island detection, layout/draw loop, input hit-testing, and tick cadence.
components/otto-islands/Cargo.toml	Adds PipeWire crate dependency for audio level capture.

[Copilot]

position and length appear to be in different units: mpris:length is microseconds, while {{position}} from playerctl is typically seconds. Computing progress = position / length will then be near-zero (or otherwise wrong). Consider normalizing to the same unit (e.g., convert length to seconds and compute position_secs / duration_secs, or fetch position in microseconds).

Suggested change

	let progress = if length > 0.0 {
	(position / length).clamp(0.0, 1.0) as f32
	} else {
	0.0
	};
	// length is in microseconds from MPRIS
	let duration_secs = (length / 1_000_000.0) as f32;
	// length is in microseconds from MPRIS; convert to seconds to match {{position}}
	let duration_secs = (length / 1_000_000.0) as f32;
	let progress = if duration_secs > 0.0 {
	(position / duration_secs as f64).clamp(0.0, 1.0) as f32
	} else {
	0.0
	};

[Copilot]

When playerctl metadata mpris:length fails, length falls back to 1.0, which can make progress clamp to 1.0 and duration_secs become ~0, producing misleading UI. Prefer treating missing/invalid length as 0.0 (or None) and set progress/duration_secs accordingly so the progress bar/time labels don’t jump to a completed state.

[Copilot]

PodSerializer::serialize(...) is followed by unwrap(). If serialization fails (unexpected PipeWire/SPA state), this will panic and kill the monitoring thread. Prefer returning the error (or logging and disabling levels) instead of panicking here.

Suggested change

	let values: Vec<u8> = spa::pod::serialize::PodSerializer::serialize(
	std::io::Cursor::new(Vec::new()),
	&spa::pod::Value::Object(obj),
	)
	.unwrap()
	.0
	.into_inner();
	let mut params = [Pod::from_bytes(&values).unwrap()];
	let values: Vec<u8> = match spa::pod::serialize::PodSerializer::serialize(
	std::io::Cursor::new(Vec::new()),
	&spa::pod::Value::Object(obj),
	) {
	Ok(serialized) => serialized.0.into_inner(),
	Err(err) => {
	eprintln!(
	"otto-islands: failed to serialize PipeWire audio format pod: {err}"
	);
	return Ok(());
	}
	};
	let pod = match Pod::from_bytes(&values) {
	Some(pod) => pod,
	None => {
	eprintln!("otto-islands: failed to parse serialized PipeWire audio format pod");
	return Ok(());
	}
	};
	let mut params = [pod];

[Copilot]

Pod::from_bytes(&values).unwrap() can panic if the serialized SPA pod isn’t accepted/parseable. This should be handled as a recoverable error (return Err / log and exit the PipeWire loop) rather than crashing the thread.

Suggested change

	let mut params = [Pod::from_bytes(&values).unwrap()];
	let pod = match Pod::from_bytes(&values) {
	Ok(pod) => pod,
	Err(err) => {
	eprintln!("Failed to parse PipeWire format pod: {err}");
	return Ok(());
	}
	};
	let mut params = [pod];

[Copilot]

island_size constructs a full MusicActivityRenderer three times just to call size(), and hard-codes levels: [0.0; 8]. This is both repetitive and brittle (if BAR_COUNT changes). Consider exposing size constants or a small helper (e.g., music::music_island_size(mode)) to avoid allocating dummy renderers and duplicating the bar count.

Suggested change

	if island.kind == IslandKind::Music {
	// Use MusicActivityRenderer sizes via the ActivityRenderer trait.
	return match mode {
	IslandMode::Mini => {
	use crate::activity::ActivityRenderer;
	let dummy = music::MusicActivityRenderer {
	title: String::new(),
	artist: String::new(),
	album_art: None,
	is_playing: false,
	progress: 0.0,
	duration_secs: 0.0,
	accent: skia_safe::Color::TRANSPARENT,
	levels: [0.0; 8],
	pressed: None,
	};
	dummy.size(PresentationMode::Minimal)
	}
	IslandMode::Compact => {
	use crate::activity::ActivityRenderer;
	let dummy = music::MusicActivityRenderer {
	title: String::new(),
	artist: String::new(),
	album_art: None,
	is_playing: false,
	progress: 0.0,
	duration_secs: 0.0,
	accent: skia_safe::Color::TRANSPARENT,
	levels: [0.0; 8],
	pressed: None,
	};
	dummy.size(PresentationMode::Compact)
	}
	IslandMode::Expanded => {
	use crate::activity::ActivityRenderer;
	let dummy = music::MusicActivityRenderer {
	title: String::new(),
	artist: String::new(),
	album_art: None,
	is_playing: false,
	progress: 0.0,
	duration_secs: 0.0,
	accent: skia_safe::Color::TRANSPARENT,
	levels: [0.0; 8],
	pressed: None,
	};
	dummy.size(PresentationMode::Expanded)
	}
	};
	let music_island_size = |mode: IslandMode| -> (f32, f32) {
	use crate::activity::ActivityRenderer;
	let presentation_mode = match mode {
	IslandMode::Mini => PresentationMode::Minimal,
	IslandMode::Compact => PresentationMode::Compact,
	IslandMode::Expanded => PresentationMode::Expanded,
	};
	let dummy = music::MusicActivityRenderer {
	title: String::new(),
	artist: String::new(),
	album_art: None,
	is_playing: false,
	progress: 0.0,
	duration_secs: 0.0,
	accent: skia_safe::Color::TRANSPARENT,
	levels: std::array::from_fn(|_| 0.0),
	pressed: None,
	};
	dummy.size(presentation_mode)
	};
	if island.kind == IslandKind::Music {
	// Use MusicActivityRenderer sizes via the ActivityRenderer trait.
	return music_island_size(mode);

[Copilot]

The player monitoring loop spawns multiple playerctl subprocesses every 1.5s (status + several metadata calls). This can be relatively expensive and adds latency/jitter. Consider consolidating into a single playerctl metadata --format ... call (including status/position/title/artist/artUrl), or switching to playerctl --follow/D-Bus events to avoid repeated process creation.

[Copilot]

The PipeWire .process callback runs in the RT thread (StreamFlags::RT_PROCESS), but it takes a std::sync::Mutex lock to publish normalized. Blocking locks in RT callbacks can cause glitches/xruns or priority inversion. Prefer a lock-free handoff (e.g., AtomicU32 storing f32::to_bits, a ringbuffer/channel, or try_lock with drop-on-contention) and consume/smooth on the non-RT side.

Suggested change

	if let Ok(mut level) = user_data.level.lock() {
	if let Ok(mut level) = user_data.level.try_lock() {