Skip to content

Your Android phone and your Windows PC, working as one. Local-first, end-to-end encrypted, no account.

46.6 KB
Raw Blame
// SPDX-License-Identifier: GPL-3.0-or-later
//! What plays on this PC, for paired phones (`docs/protocol/media.md`): active
//! MPRIS2 media sessions on Linux via native in-process `zbus` D-Bus queries
//! and signal subscriptions (`PropertiesChanged`, `Seeked`, `NameOwnerChanged`),
//! artwork resolution/caching, and remote transport commands.
//!
//! NectarLink's own MPRIS session (`org.mpris.MediaPlayer2.nectarlink`) is
//! excluded so a phone never gets its own music echoed back.

use std::collections::HashMap;
use std::fs;
use std::path::PathBuf;
use std::process::Command;
use std::sync::{Mutex, OnceLock, mpsc};
use std::time::{Duration, Instant};

use nectarlink_core::{MediaAction, MediaError, MediaPlayer};
use zbus::zvariant::{ObjectPath, OwnedValue};

/// Maximum inline artwork payload (256 KiB); larger covers are scaled and JPEG-encoded.
const ART_BYTES: u64 = 256 * 1024;
const ACTIVE_REFRESH_INTERVAL: Duration = Duration::from_secs(3);
const IDLE_REFRESH_INTERVAL: Duration = Duration::from_secs(10);
const SIGNAL_COALESCE_WINDOW: Duration = Duration::from_millis(60);
const CALL_PAUSE_TTL: Duration = Duration::from_secs(60 * 30);

const PLAYERCTL_FORMAT: &str = "{{playerName}}\t{{status}}\t{{mpris:trackid}}\t{{xesam:title}}\t{{xesam:artist}}\t{{xesam:album}}\t{{mpris:length}}\t{{position}}\t{{mpris:artUrl}}";

type OnChange = Box<dyn Fn(Vec<MediaPlayer>) + Send + Sync>;

static STARTED: OnceLock<()> = OnceLock::new();
static PAUSED_FOR_CALL: Mutex<Option<PausedForCall>> = Mutex::new(None);
static CALL_MEDIA: Mutex<()> = Mutex::new(());

#[derive(Debug)]
struct PausedForCall {
    players: Vec<String>,
    paused_at: Instant,
}

impl PausedForCall {
    fn take_valid(&mut self, now: Instant) -> Vec<String> {
        let taken = std::mem::take(&mut self.players);
        if now.saturating_duration_since(self.paused_at) <= CALL_PAUSE_TTL { taken } else { Vec::new() }
    }

    fn observe_playing(&mut self, id: &str, now: Instant) {
        if now.saturating_duration_since(self.paused_at) >= Duration::from_millis(600) {
            self.players.retain(|p| p != id);
        }
    }
}

/// Whether the MPRIS session for `id` corresponds to a video player or browser.
pub fn says_video(id: &str) -> bool {
    let lower = id.trim().to_ascii_lowercase();
    for needle in [
        "vlc",
        "mpv",
        "totem",
        "celluloid",
        "haruna",
        "dragon",
        "smplayer",
        "kodi",
        "chrome",
        "chromium",
        "firefox",
        "brave",
        "vivaldi",
        "opera",
        "msedge",
        "zen",
    ] {
        if lower.contains(needle) {
            return true;
        }
    }
    false
}

/// Raw MPRIS player record before artwork bytes are loaded.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct RawMprisPlayer {
    pub id: String,
    pub app: String,
    pub title: String,
    pub artist: Option<String>,
    pub album: Option<String>,
    pub playing: bool,
    pub duration: Option<u64>,
    pub position: Option<u64>,
    pub actions: Vec<String>,
    pub art_url: Option<String>,
}

/// Caches resolved artwork bytes by URL so repeated polls do not re-read disk.
#[derive(Default)]
struct ArtCache {
    by_url: HashMap<String, Option<(String, Vec<u8>)>>,
}

impl ArtCache {
    fn resolve(&mut self, art_url: Option<&str>) -> Option<(String, Vec<u8>)> {
        let url = art_url?.trim();
        if url.is_empty() {
            return None;
        }
        if let Some(cached) = self.by_url.get(url) {
            return cached.clone();
        }
        if self.by_url.len() > 64 {
            self.by_url.clear();
        }
        let loaded = load_art_from_url(url);
        self.by_url.insert(url.to_owned(), loaded.clone());
        loaded
    }
}

fn fnv(bytes: &[u8]) -> u64 {
    bytes.iter().fold(0xcbf2_9ce4_8422_2325_u64, |h, b| (h ^ u64::from(*b)).wrapping_mul(0x0100_0000_01b3))
}

fn percent_decode(input: &str) -> String {
    let bytes = input.as_bytes();
    let mut out = Vec::with_capacity(bytes.len());
    let mut i = 0;
    while i < bytes.len() {
        if bytes[i] == b'%'
            && i + 2 < bytes.len()
            && let (Some(hi), Some(lo)) =
                ((bytes[i + 1] as char).to_digit(16), (bytes[i + 2] as char).to_digit(16))
        {
            out.push(((hi << 4) | lo) as u8);
            i += 3;
            continue;
        }
        out.push(bytes[i]);
        i += 1;
    }
    String::from_utf8_lossy(&out).into_owned()
}

/// Resolves a `file://` MPRIS `artUrl` (with percent-encoding) to a local filesystem path.
pub(crate) fn resolve_art_file_url(art_url: &str) -> Option<PathBuf> {
    let trimmed = art_url.trim().trim_matches('\'').trim_matches('"').trim();
    let rest = trimmed.strip_prefix("file://")?;
    let decoded = percent_decode(rest);
    if decoded.trim().is_empty() { None } else { Some(PathBuf::from(decoded)) }
}

fn load_art_from_url(art_url: &str) -> Option<(String, Vec<u8>)> {
    let path = resolve_art_file_url(art_url)?;
    let bytes = fs::read(path).ok().filter(|b| !b.is_empty())?;
    let is_png_or_jpeg = bytes.starts_with(b"\x89PNG") || bytes.starts_with(b"\xFF\xD8\xFF");
    if is_png_or_jpeg && (bytes.len() as u64) <= ART_BYTES {
        let key = format!("{:016x}", fnv(&bytes));
        return Some((key, bytes));
    }
    let bitmap = super::image::decode(&bytes).ok()?;
    for max_side in [360, 280, 220, 160] {
        let scaled = super::image::scale_to(&bitmap, max_side);
        if let Ok(jpeg) = super::image::encode_jpeg(&scaled, 85)
            && (jpeg.len() as u64) <= ART_BYTES
        {
            let key = format!("{:016x}", fnv(&jpeg));
            return Some((key, jpeg));
        }
    }
    None
}

/// Watches this PC's active MPRIS2 media sessions on a background thread;
/// `on_change` is invoked whenever the player list or playback state meaningfully changes.
pub fn start<F>(on_change: F)
where
    F: Fn(Vec<MediaPlayer>) + Send + Sync + 'static,
{
    if STARTED.set(()).is_err() {
        return;
    }
    let on_change: OnChange = Box::new(on_change);
    let spawned = std::thread::Builder::new().name("media-sessions".into()).spawn(move || run(&on_change));
    if let Err(e) = spawned {
        tracing::warn!(error = %e, "can't spawn Linux media-sessions watcher");
    }
}

fn run(on_change: &OnChange) {
    let (wake_tx, wake_rx) = mpsc::channel::<()>();
    spawn_dbus_signal_watchers(wake_tx);

    let mut art_cache = ArtCache::default();
    let mut last: Option<(Vec<MediaPlayer>, Instant)> = None;
    loop {
        let players = snapshot(&mut art_cache);
        let any_playing = players.iter().any(|p| p.playing);
        let should_emit = match &last {
            None => true,
            Some((prev, prev_at)) => players_meaningfully_changed(prev, &players, prev_at.elapsed()),
        };
        if should_emit {
            on_change(players.clone());
            last = Some((players, Instant::now()));
        }
        let wait_timeout = if any_playing { ACTIVE_REFRESH_INTERVAL } else { IDLE_REFRESH_INTERVAL };
        if wake_rx.recv_timeout(wait_timeout).is_ok() {
            while wake_rx.recv_timeout(SIGNAL_COALESCE_WINDOW).is_ok() {}
        }
    }
}

fn spawn_dbus_signal_watchers(wake_tx: mpsc::Sender<()>) {
    let tx_props = wake_tx.clone();
    let _ = std::thread::Builder::new().name("mpris-props-watch".into()).spawn(move || {
        loop {
            let Ok(conn) = zbus::blocking::Connection::session() else {
                std::thread::sleep(Duration::from_secs(5));
                continue;
            };
            let Ok(rule) = zbus::MatchRule::builder()
                .msg_type(zbus::message::Type::Signal)
                .path("/org/mpris/MediaPlayer2")
                .map(|b| b.build())
            else {
                return;
            };
            let Ok(iter) = zbus::blocking::MessageIterator::for_match_rule(rule, &conn, None) else {
                std::thread::sleep(Duration::from_secs(5));
                continue;
            };
            for msg in iter {
                let Ok(msg) = msg else { break };
                let hdr = msg.header();
                let member = hdr.member().map(|m| m.as_str()).unwrap_or("");
                if matches!(member, "PropertiesChanged" | "Seeked") && tx_props.send(()).is_err() {
                    return;
                }
            }
            std::thread::sleep(Duration::from_secs(2));
        }
    });

    let _ = std::thread::Builder::new().name("mpris-owner-watch".into()).spawn(move || {
        loop {
            let Ok(conn) = zbus::blocking::Connection::session() else {
                std::thread::sleep(Duration::from_secs(5));
                continue;
            };
            let Ok(rule) = zbus::MatchRule::builder()
                .msg_type(zbus::message::Type::Signal)
                .interface("org.freedesktop.DBus")
                .and_then(|b| b.member("NameOwnerChanged"))
                .map(|b| b.build())
            else {
                return;
            };
            let Ok(iter) = zbus::blocking::MessageIterator::for_match_rule(rule, &conn, None) else {
                std::thread::sleep(Duration::from_secs(5));
                continue;
            };
            for msg in iter {
                let Ok(msg) = msg else { break };
                if let Ok((name, _old_owner, _new_owner)) =
                    msg.body().deserialize::<(String, String, String)>()
                    && let Some(suffix) = name.strip_prefix("org.mpris.MediaPlayer2.")
                    && !is_excluded_player(suffix)
                    && wake_tx.send(()).is_err()
                {
                    return;
                }
            }
            std::thread::sleep(Duration::from_secs(2));
        }
    });
}

/// Compares two snapshots of [`MediaPlayer`]s while ignoring normal linear playback
/// position progression so periodic polling does not trigger spurious UI/network updates.
pub(crate) fn players_meaningfully_changed(
    old: &[MediaPlayer],
    new: &[MediaPlayer],
    elapsed: Duration,
) -> bool {
    if old.len() != new.len() {
        return true;
    }
    let elapsed_ms = elapsed.as_millis() as u64;
    for (a, b) in old.iter().zip(new.iter()) {
        if a.id != b.id
            || a.app != b.app
            || a.title != b.title
            || a.artist != b.artist
            || a.album != b.album
            || a.playing != b.playing
            || a.duration != b.duration
            || a.actions != b.actions
            || a.art_key != b.art_key
            || a.art.is_some() != b.art.is_some()
        {
            return true;
        }
        match (a.position, b.position) {
            (None, None) => {}
            (Some(_), None) | (None, Some(_)) => return true,
            (Some(old_pos), Some(new_pos)) => {
                let expected = if a.playing {
                    old_pos.saturating_add(elapsed_ms).min(a.duration.unwrap_or(u64::MAX))
                } else {
                    old_pos
                };
                if new_pos.abs_diff(expected) > 1500 {
                    return true;
                }
            }
        }
    }
    false
}

fn snapshot(art_cache: &mut ArtCache) -> Vec<MediaPlayer> {
    let raw_players = query_raw_players();
    let now = Instant::now();
    let mut players = Vec::with_capacity(raw_players.len());
    for raw in raw_players {
        if raw.playing
            && let Ok(mut guard) = PAUSED_FOR_CALL.lock()
            && let Some(state) = guard.as_mut()
        {
            state.observe_playing(&raw.id, now);
        }
        let (art_key, art) = art_cache.resolve(raw.art_url.as_deref()).unzip();
        players.push(MediaPlayer {
            app: raw.app,
            id: raw.id,
            title: Some(raw.title),
            artist: raw.artist,
            album: raw.album,
            playing: raw.playing,
            duration: raw.duration,
            position: raw.position,
            actions: raw.actions,
            art_key,
            art,
        });
    }
    players.sort_by_key(|p| !p.playing);
    players
}

fn query_raw_players() -> Vec<RawMprisPlayer> {
    if let Some(players) = query_via_zbus() {
        return players;
    }
    if let Some(players) = query_via_playerctl() {
        return players;
    }
    query_via_gdbus().unwrap_or_default()
}

fn deserialize_string_list(msg: &zbus::message::Message) -> Option<Vec<String>> {
    let body = msg.body();
    body.deserialize::<Vec<String>>().ok().or_else(|| body.deserialize::<(Vec<String>,)>().ok().map(|(v,)| v))
}

fn deserialize_properties_map(msg: &zbus::message::Message) -> Option<HashMap<String, OwnedValue>> {
    let body = msg.body();
    body.deserialize::<HashMap<String, OwnedValue>>()
        .ok()
        .or_else(|| body.deserialize::<(HashMap<String, OwnedValue>,)>().ok().map(|(m,)| m))
}

fn deserialize_property_value(msg: &zbus::message::Message) -> Option<OwnedValue> {
    let body = msg.body();
    body.deserialize::<OwnedValue>().ok().or_else(|| body.deserialize::<(OwnedValue,)>().ok().map(|(v,)| v))
}

fn val_as_str(v: &OwnedValue) -> Option<String> {
    if let Ok(s) = <&str>::try_from(v) {
        let trimmed = s.trim();
        if !trimmed.is_empty() {
            return Some(trimmed.to_owned());
        }
    }
    if let Ok(op) = <ObjectPath<'_>>::try_from(&**v) {
        let s = op.as_str().trim();
        if !s.is_empty() {
            return Some(s.to_owned());
        }
    }
    None
}

fn val_as_artist(v: &OwnedValue) -> Option<String> {
    if let Some(s) = val_as_str(v) {
        return Some(s);
    }
    if let Ok(cloned) = v.try_clone()
        && let Ok(list) = Vec::<String>::try_from(cloned)
    {
        let joined: Vec<&str> =
            list.iter().map(String::as_str).map(str::trim).filter(|s| !s.is_empty()).collect();
        if !joined.is_empty() {
            return Some(joined.join(", "));
        }
    }
    None
}

fn val_as_i64(v: &OwnedValue) -> Option<i64> {
    i64::try_from(v)
        .ok()
        .or_else(|| u64::try_from(v).ok().and_then(|u| i64::try_from(u).ok()))
        .or_else(|| i32::try_from(v).ok().map(i64::from))
        .or_else(|| u32::try_from(v).ok().map(i64::from))
        .or_else(|| f64::try_from(v).ok().filter(|f| f.is_finite()).map(|f| f as i64))
}

fn val_as_bool(v: &OwnedValue) -> Option<bool> {
    bool::try_from(v).ok()
}

fn val_as_dict(v: &OwnedValue) -> Option<HashMap<String, OwnedValue>> {
    let cloned = v.try_clone().ok()?;
    HashMap::<String, OwnedValue>::try_from(cloned).ok()
}

pub(crate) fn parse_zbus_player_properties(
    bus_name: &str,
    root_props: Option<&HashMap<String, OwnedValue>>,
    player_props: &HashMap<String, OwnedValue>,
) -> Option<RawMprisPlayer> {
    let short_id = bus_name.strip_prefix("org.mpris.MediaPlayer2.").unwrap_or(bus_name);
    if is_excluded_player(short_id) {
        return None;
    }

    let metadata = player_props.get("Metadata").and_then(val_as_dict)?;
    let raw_title = metadata.get("xesam:title").and_then(val_as_str)?;
    let status = player_props.get("PlaybackStatus").and_then(val_as_str).unwrap_or_default();
    let artist = metadata.get("xesam:artist").and_then(val_as_artist);
    let album = metadata.get("xesam:album").and_then(val_as_str);
    let art_url = metadata.get("mpris:artUrl").and_then(val_as_str);
    let duration_us = metadata.get("mpris:length").and_then(val_as_i64).filter(|&v| v > 0);
    let position_us = player_props.get("Position").and_then(val_as_i64).filter(|&v| v >= 0);

    let duration = duration_us.map(|us| (us as u64) / 1000).filter(|&ms| ms > 0);
    let position = position_us.map(|us| {
        let ms = (us as u64) / 1000;
        duration.map_or(ms, |d| ms.min(d))
    });

    let identity = root_props.and_then(|r| {
        r.get("Identity").and_then(val_as_str).or_else(|| r.get("DesktopEntry").and_then(val_as_str))
    });
    let mut app = identity.unwrap_or_else(|| readable_player_app(short_id));
    let mut title = raw_title;
    if (says_video(short_id) || says_video(&app))
        && let Some((clean, site)) = title.rsplit_once(" on ")
    {
        let site = site.trim();
        let clean = clean.trim();
        if !site.is_empty() && !clean.is_empty() && site.len() <= 28 {
            app = site.to_owned();
            title = clean.to_owned();
        }
    }

    let mut actions = Vec::new();
    if player_props.get("CanPlay").and_then(val_as_bool).unwrap_or(true) {
        actions.push("play".to_owned());
    }
    if player_props.get("CanPause").and_then(val_as_bool).unwrap_or(true) {
        actions.push("pause".to_owned());
    }
    if player_props.get("CanGoNext").and_then(val_as_bool).unwrap_or(true) {
        actions.push("next".to_owned());
    }
    if player_props.get("CanGoPrevious").and_then(val_as_bool).unwrap_or(true) {
        actions.push("previous".to_owned());
    }
    if player_props.get("CanSeek").and_then(val_as_bool).unwrap_or(duration.is_some()) {
        actions.push("seek".to_owned());
    }

    Some(RawMprisPlayer {
        id: short_id.to_owned(),
        app,
        title,
        artist,
        album,
        playing: status.eq_ignore_ascii_case("Playing"),
        duration,
        position,
        actions,
        art_url,
    })
}

fn list_zbus_mpris_buses(conn: &zbus::blocking::Connection) -> Option<Vec<String>> {
    let reply = conn
        .call_method(
            Some("org.freedesktop.DBus"),
            "/org/freedesktop/DBus",
            Some("org.freedesktop.DBus"),
            "ListNames",
            &(),
        )
        .ok()?;
    let all_names = deserialize_string_list(&reply)?;
    let mut buses = Vec::new();
    for name in all_names {
        let trimmed = name.trim();
        if let Some(suffix) = trimmed.strip_prefix("org.mpris.MediaPlayer2.")
            && !is_excluded_player(suffix)
            && !buses.iter().any(|existing| existing == trimmed)
        {
            buses.push(trimmed.to_owned());
        }
    }
    Some(buses)
}

fn query_via_zbus() -> Option<Vec<RawMprisPlayer>> {
    let conn = zbus::blocking::Connection::session().ok()?;
    let buses = list_zbus_mpris_buses(&conn)?;
    let mut players = Vec::new();
    for bus in buses {
        let root_props = conn
            .call_method(
                Some(bus.as_str()),
                "/org/mpris/MediaPlayer2",
                Some("org.freedesktop.DBus.Properties"),
                "GetAll",
                &("org.mpris.MediaPlayer2",),
            )
            .ok()
            .and_then(|msg| deserialize_properties_map(&msg));
        let Ok(player_msg) = conn.call_method(
            Some(bus.as_str()),
            "/org/mpris/MediaPlayer2",
            Some("org.freedesktop.DBus.Properties"),
            "GetAll",
            &("org.mpris.MediaPlayer2.Player",),
        ) else {
            continue;
        };
        let Some(player_props) = deserialize_properties_map(&player_msg) else {
            continue;
        };
        if let Some(player) = parse_zbus_player_properties(&bus, root_props.as_ref(), &player_props) {
            players.push(player);
        }
    }
    Some(players)
}

fn query_via_playerctl() -> Option<Vec<RawMprisPlayer>> {
    let output = Command::new("playerctl")
        .args(["--all-players", "metadata", "--format", PLAYERCTL_FORMAT])
        .output()
        .ok()?;
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        if stderr.contains("No players found") || output.stdout.is_empty() {
            return Some(Vec::new());
        }
        return None;
    }
    let stdout = String::from_utf8_lossy(&output.stdout);
    Some(stdout.lines().filter_map(parse_playerctl_line).collect())
}

fn is_excluded_player(name: &str) -> bool {
    let lower = name.trim().to_ascii_lowercase();
    lower.is_empty()
        || lower == "nectarlink"
        || lower == "playerctld"
        || lower.starts_with("nectarlink.")
        || lower.ends_with(".nectarlink")
        || lower.ends_with(".playerctld")
}

fn readable_player_app(id: &str) -> String {
    let stripped = id.strip_prefix("org.mpris.MediaPlayer2.").unwrap_or(id);
    let base = stripped.split('.').next().unwrap_or(stripped).trim();
    match base.to_ascii_lowercase().as_str() {
        "" => "Media".to_owned(),
        "spotify" | "spotifymusic" => "Spotify".to_owned(),
        "vlc" => "VLC".to_owned(),
        "firefox" => "Firefox".to_owned(),
        "chromium" => "Chromium".to_owned(),
        "chrome" | "google-chrome" => "Chrome".to_owned(),
        "brave" => "Brave".to_owned(),
        "msedge" | "edge" => "Edge".to_owned(),
        "mpv" => "mpv".to_owned(),
        "rhythmbox" => "Rhythmbox".to_owned(),
        "amberol" => "Amberol".to_owned(),
        "elisa" => "Elisa".to_owned(),
        "audacious" => "Audacious".to_owned(),
        "clementine" => "Clementine".to_owned(),
        "strawberry" => "Strawberry".to_owned(),
        other => {
            let mut chars = other.chars();
            match chars.next() {
                Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
                None => "Media".to_owned(),
            }
        }
    }
}

/// Parses one line of `playerctl --all-players metadata --format ...` output.
pub(crate) fn parse_playerctl_line(line: &str) -> Option<RawMprisPlayer> {
    if line.trim().is_empty() {
        return None;
    }
    let fields: Vec<&str> = line.split('\t').collect();
    if fields.len() < 4 {
        return None;
    }
    let player_name = fields.first().copied().unwrap_or("").trim();
    if is_excluded_player(player_name) {
        return None;
    }
    let status = fields.get(1).copied().unwrap_or("").trim();
    let _track_id = fields.get(2).copied().unwrap_or("").trim();
    let raw_title = fields.get(3).copied().unwrap_or("").trim();
    if raw_title.is_empty() {
        return None;
    }
    let artist = fields.get(4).map(|s| s.trim()).filter(|s| !s.is_empty()).map(str::to_owned);
    let album = fields.get(5).map(|s| s.trim()).filter(|s| !s.is_empty()).map(str::to_owned);
    let duration_us = fields.get(6).and_then(|s| s.trim().parse::<i64>().ok()).filter(|&v| v > 0);
    let position_us = fields.get(7).and_then(|s| s.trim().parse::<i64>().ok()).filter(|&v| v >= 0);
    let art_url = fields.get(8).map(|s| s.trim()).filter(|s| !s.is_empty()).map(str::to_owned);

    let duration = duration_us.map(|us| (us as u64) / 1000).filter(|&ms| ms > 0);
    let position = position_us.map(|us| {
        let ms = (us as u64) / 1000;
        duration.map_or(ms, |d| ms.min(d))
    });

    let mut app = readable_player_app(player_name);
    let mut title = raw_title.to_owned();
    if matches!(app.as_str(), "Firefox" | "Chrome" | "Chromium" | "Brave" | "Edge")
        && let Some((clean, site)) = title.rsplit_once(" on ")
    {
        let site = site.trim();
        let clean = clean.trim();
        if !site.is_empty() && !clean.is_empty() && site.len() <= 28 {
            app = site.to_owned();
            title = clean.to_owned();
        }
    }

    let playing = status.eq_ignore_ascii_case("Playing");
    let mut actions = vec!["play".to_owned(), "pause".to_owned(), "next".to_owned(), "previous".to_owned()];
    if duration.is_some() {
        actions.push("seek".to_owned());
    }

    Some(RawMprisPlayer {
        id: player_name.to_owned(),
        app,
        title,
        artist,
        album,
        playing,
        duration,
        position,
        actions,
        art_url,
    })
}

/// Extracts `org.mpris.MediaPlayer2.*` bus names from `gdbus ListNames` output,
/// excluding `org.mpris.MediaPlayer2.nectarlink` and `playerctld`.
pub(crate) fn parse_mpris_bus_names(gdbus_output: &str) -> Vec<String> {
    let mut names = Vec::new();
    for token in gdbus_output.split(|c: char| {
        c == '\'' || c == '"' || c == ',' || c == '[' || c == ']' || c == '(' || c == ')' || c.is_whitespace()
    }) {
        let trimmed = token.trim();
        if let Some(suffix) = trimmed.strip_prefix("org.mpris.MediaPlayer2.")
            && !is_excluded_player(suffix)
            && !names.iter().any(|existing| existing == trimmed)
        {
            names.push(trimmed.to_owned());
        }
    }
    names
}

fn extract_gvariant_string(text: &str, key: &str) -> Option<String> {
    let pattern = format!("'{key}':");
    let start = text.find(&pattern)? + pattern.len();
    let rest = text[start..].trim_start();
    // Look for `<'value'>` or `<['value']>`
    let open_angle = rest.find('<')?;
    let inside = rest[open_angle + 1..].trim_start();
    let inside = inside.strip_prefix('[').map_or(inside, str::trim_start);
    let quote = inside.chars().next()?;
    if quote != '\'' && quote != '"' {
        return None;
    }
    let after_quote = &inside[quote.len_utf8()..];
    let end_quote = after_quote.find(quote)?;
    let val = after_quote[..end_quote].trim();
    if val.is_empty() { None } else { Some(val.to_owned()) }
}

fn extract_gvariant_i64(text: &str, key: &str) -> Option<i64> {
    let pattern = format!("'{key}':");
    let start = text.find(&pattern)? + pattern.len();
    let rest = text[start..].trim_start();
    let open = rest.find('<')?;
    let close = rest[open + 1..].find('>')?;
    let inner = rest[open + 1..open + 1 + close].trim();
    let num_str = inner.split_whitespace().next_back()?;
    num_str.parse::<i64>().ok()
}

fn extract_gvariant_bool(text: &str, key: &str) -> Option<bool> {
    let pattern = format!("'{key}':");
    let start = text.find(&pattern)? + pattern.len();
    let rest = text[start..].trim_start();
    let open = rest.find('<')?;
    let close = rest[open + 1..].find('>')?;
    match rest[open + 1..open + 1 + close].trim() {
        "true" => Some(true),
        "false" => Some(false),
        _ => None,
    }
}

pub(crate) fn parse_gdbus_player_properties(bus_name: &str, gdbus_output: &str) -> Option<RawMprisPlayer> {
    let short_id = bus_name.strip_prefix("org.mpris.MediaPlayer2.").unwrap_or(bus_name);
    if is_excluded_player(short_id) {
        return None;
    }
    let title = extract_gvariant_string(gdbus_output, "xesam:title")?;
    let status = extract_gvariant_string(gdbus_output, "PlaybackStatus").unwrap_or_default();
    let artist = extract_gvariant_string(gdbus_output, "xesam:artist");
    let album = extract_gvariant_string(gdbus_output, "xesam:album");
    let art_url = extract_gvariant_string(gdbus_output, "mpris:artUrl");
    let duration_us = extract_gvariant_i64(gdbus_output, "mpris:length").filter(|&v| v > 0);
    let position_us = extract_gvariant_i64(gdbus_output, "Position").filter(|&v| v >= 0);

    let duration = duration_us.map(|us| (us as u64) / 1000).filter(|&ms| ms > 0);
    let position = position_us.map(|us| {
        let ms = (us as u64) / 1000;
        duration.map_or(ms, |d| ms.min(d))
    });

    let mut actions = Vec::new();
    if extract_gvariant_bool(gdbus_output, "CanPlay").unwrap_or(true) {
        actions.push("play".to_owned());
    }
    if extract_gvariant_bool(gdbus_output, "CanPause").unwrap_or(true) {
        actions.push("pause".to_owned());
    }
    if extract_gvariant_bool(gdbus_output, "CanGoNext").unwrap_or(true) {
        actions.push("next".to_owned());
    }
    if extract_gvariant_bool(gdbus_output, "CanGoPrevious").unwrap_or(true) {
        actions.push("previous".to_owned());
    }
    if extract_gvariant_bool(gdbus_output, "CanSeek").unwrap_or(duration.is_some()) {
        actions.push("seek".to_owned());
    }

    Some(RawMprisPlayer {
        id: short_id.to_owned(),
        app: readable_player_app(short_id),
        title,
        artist,
        album,
        playing: status.eq_ignore_ascii_case("Playing"),
        duration,
        position,
        actions,
        art_url,
    })
}

fn list_gdbus_mpris_buses() -> Option<Vec<String>> {
    let out = Command::new("gdbus")
        .args([
            "call",
            "--session",
            "--dest",
            "org.freedesktop.DBus",
            "--object-path",
            "/org/freedesktop/DBus",
            "--method",
            "org.freedesktop.DBus.ListNames",
        ])
        .output()
        .ok()?;
    if !out.status.success() {
        return None;
    }
    Some(parse_mpris_bus_names(&String::from_utf8_lossy(&out.stdout)))
}

fn query_via_gdbus() -> Option<Vec<RawMprisPlayer>> {
    let buses = list_gdbus_mpris_buses()?;
    let mut players = Vec::new();
    for bus in buses {
        if let Ok(out) = Command::new("gdbus")
            .args([
                "call",
                "--session",
                "--dest",
                &bus,
                "--object-path",
                "/org/mpris/MediaPlayer2",
                "--method",
                "org.freedesktop.DBus.Properties.GetAll",
                "org.mpris.MediaPlayer2.Player",
            ])
            .output()
            && out.status.success()
        {
            let text = String::from_utf8_lossy(&out.stdout);
            if let Some(player) = parse_gdbus_player_properties(&bus, &text) {
                players.push(player);
            }
        }
    }
    Some(players)
}

fn mpris_bus_name(player: &str) -> String {
    let trimmed = player.trim();
    if trimmed.starts_with("org.mpris.MediaPlayer2.") {
        trimmed.to_owned()
    } else {
        format!("org.mpris.MediaPlayer2.{trimmed}")
    }
}

fn gdbus_player_call(bus_name: &str, method: &str, extra_args: &[&str]) -> bool {
    let method_full = format!("org.mpris.MediaPlayer2.Player.{method}");
    let mut cmd = Command::new("gdbus");
    cmd.args([
        "call",
        "--session",
        "--dest",
        bus_name,
        "--object-path",
        "/org/mpris/MediaPlayer2",
        "--method",
        &method_full,
    ]);
    cmd.args(extra_args);
    cmd.output().is_ok_and(|o| o.status.success())
}

/// Computes the relative MPRIS2 `Seek(Offset: x)` delta in microseconds from a
/// target position (`target_us`) and current position (`current_us`).
pub(crate) fn compute_seek_offset_us(target_us: i64, current_us: i64) -> i64 {
    target_us.saturating_sub(current_us)
}

fn resolve_zbus_target_bus(conn: &zbus::blocking::Connection, player: &str) -> Option<String> {
    let trimmed = player.trim();
    let buses = list_zbus_mpris_buses(conn).unwrap_or_default();
    if trimmed.is_empty() {
        return buses.into_iter().next();
    }
    let exact = mpris_bus_name(trimmed);
    if buses.iter().any(|b| b == &exact) {
        return Some(exact);
    }
    let prefix = format!("{exact}.");
    if let Some(found) = buses.into_iter().find(|b| b.starts_with(&prefix)) {
        return Some(found);
    }
    Some(exact)
}

fn zbus_player_command(
    conn: &zbus::blocking::Connection,
    bus_name: &str,
    action: MediaAction,
    position: Option<u64>,
) -> bool {
    match action {
        MediaAction::Play => conn
            .call_method(
                Some(bus_name),
                "/org/mpris/MediaPlayer2",
                Some("org.mpris.MediaPlayer2.Player"),
                "Play",
                &(),
            )
            .is_ok(),
        MediaAction::Pause => conn
            .call_method(
                Some(bus_name),
                "/org/mpris/MediaPlayer2",
                Some("org.mpris.MediaPlayer2.Player"),
                "Pause",
                &(),
            )
            .is_ok(),
        MediaAction::Next => conn
            .call_method(
                Some(bus_name),
                "/org/mpris/MediaPlayer2",
                Some("org.mpris.MediaPlayer2.Player"),
                "Next",
                &(),
            )
            .is_ok(),
        MediaAction::Previous => conn
            .call_method(
                Some(bus_name),
                "/org/mpris/MediaPlayer2",
                Some("org.mpris.MediaPlayer2.Player"),
                "Previous",
                &(),
            )
            .is_ok(),
        MediaAction::Seek => {
            let pos_us = i64::try_from(position.unwrap_or(0)).unwrap_or(0).saturating_mul(1000);
            if let Ok(meta_msg) = conn.call_method(
                Some(bus_name),
                "/org/mpris/MediaPlayer2",
                Some("org.freedesktop.DBus.Properties"),
                "Get",
                &("org.mpris.MediaPlayer2.Player", "Metadata"),
            ) && let Some(meta_val) = deserialize_property_value(&meta_msg)
                && let Some(meta_dict) = val_as_dict(&meta_val)
                && let Some(track_id_str) = meta_dict.get("mpris:trackid").and_then(val_as_str)
                && let Ok(track_id) = ObjectPath::try_from(track_id_str.as_str())
                && conn
                    .call_method(
                        Some(bus_name),
                        "/org/mpris/MediaPlayer2",
                        Some("org.mpris.MediaPlayer2.Player"),
                        "SetPosition",
                        &(track_id, pos_us),
                    )
                    .is_ok()
            {
                return true;
            }

            let cur_us = conn
                .call_method(
                    Some(bus_name),
                    "/org/mpris/MediaPlayer2",
                    Some("org.freedesktop.DBus.Properties"),
                    "Get",
                    &("org.mpris.MediaPlayer2.Player", "Position"),
                )
                .ok()
                .and_then(|msg| deserialize_property_value(&msg))
                .and_then(|v| val_as_i64(&v))
                .unwrap_or(0);
            let offset_us = compute_seek_offset_us(pos_us, cur_us);
            conn.call_method(
                Some(bus_name),
                "/org/mpris/MediaPlayer2",
                Some("org.mpris.MediaPlayer2.Player"),
                "Seek",
                &(offset_us,),
            )
            .is_ok()
        }
    }
}

pub fn command(player: &str, action: MediaAction, position: Option<u64>) -> Result<(), MediaError> {
    let trimmed = player.trim();
    if trimmed.starts_with('-') || trimmed.chars().any(char::is_control) {
        return Err(MediaError::Failed("invalid player identifier".into()));
    }

    if super::non_tokio(|| {
        let Ok(conn) = zbus::blocking::Connection::session() else {
            return false;
        };
        let Some(target_bus) = resolve_zbus_target_bus(&conn, trimmed) else {
            return false;
        };
        zbus_player_command(&conn, &target_bus, action, position)
    }) {
        return Ok(());
    }

    let mut cmd = Command::new("playerctl");
    if !trimmed.is_empty() {
        cmd.args(["--player", trimmed]);
    }
    match action {
        MediaAction::Play => {
            cmd.arg("play");
        }
        MediaAction::Pause => {
            cmd.arg("pause");
        }
        MediaAction::Next => {
            cmd.arg("next");
        }
        MediaAction::Previous => {
            cmd.arg("previous");
        }
        MediaAction::Seek => {
            let secs = (position.unwrap_or(0) as f64) / 1000.0;
            cmd.args(["position", &format!("{secs:.2}")]);
        }
    }
    if cmd.status().is_ok_and(|s| s.success()) {
        return Ok(());
    }

    // Fallback to direct `gdbus` MPRIS2 call when D-Bus session or `playerctl` fails.
    let target_bus = if trimmed.is_empty() {
        list_gdbus_mpris_buses().and_then(|mut b| b.drain(..).next()).ok_or(MediaError::NotFound)?
    } else {
        mpris_bus_name(trimmed)
    };

    let ok = match action {
        MediaAction::Play => gdbus_player_call(&target_bus, "Play", &[]),
        MediaAction::Pause => gdbus_player_call(&target_bus, "Pause", &[]),
        MediaAction::Next => gdbus_player_call(&target_bus, "Next", &[]),
        MediaAction::Previous => gdbus_player_call(&target_bus, "Previous", &[]),
        MediaAction::Seek => {
            let target_us = i64::try_from(position.unwrap_or(0)).unwrap_or(0).saturating_mul(1000);
            let offset_str = target_us.to_string();
            gdbus_player_call(&target_bus, "Seek", &[&offset_str])
        }
    };
    if ok {
        Ok(())
    } else {
        Err(MediaError::Failed(format!("MPRIS command {action:?} failed for {target_bus}")))
    }
}

pub fn pause_for_call() {
    let _ = std::thread::Builder::new().name("call-media-pause".into()).spawn(pause_for_call_blocking);
}

fn pause_for_call_blocking() {
    let _serial = CALL_MEDIA.lock().unwrap_or_else(|e| e.into_inner());
    let mut paused = Vec::new();

    if let Ok(conn) = zbus::blocking::Connection::session()
        && let Some(buses) = list_zbus_mpris_buses(&conn)
    {
        for bus in buses {
            let is_playing = conn
                .call_method(
                    Some(bus.as_str()),
                    "/org/mpris/MediaPlayer2",
                    Some("org.freedesktop.DBus.Properties"),
                    "Get",
                    &("org.mpris.MediaPlayer2.Player", "PlaybackStatus"),
                )
                .ok()
                .and_then(|msg| deserialize_property_value(&msg))
                .and_then(|v| val_as_str(&v))
                .is_some_and(|s| s.eq_ignore_ascii_case("Playing"));
            if is_playing
                && conn
                    .call_method(
                        Some(bus.as_str()),
                        "/org/mpris/MediaPlayer2",
                        Some("org.mpris.MediaPlayer2.Player"),
                        "Pause",
                        &(),
                    )
                    .is_ok()
            {
                let short_id = bus.strip_prefix("org.mpris.MediaPlayer2.").unwrap_or(&bus).to_owned();
                paused.push(short_id);
            }
        }
    } else if let Ok(out) = Command::new("playerctl")
        .args(["--all-players", "status", "--format", "{{playerName}}\t{{status}}"])
        .output()
        && out.status.success()
    {
        let stdout = String::from_utf8_lossy(&out.stdout);
        for line in stdout.lines() {
            if let Some((name, status)) = line.split_once('\t') {
                let name = name.trim();
                if !is_excluded_player(name) && status.trim().eq_ignore_ascii_case("Playing") {
                    let _ = Command::new("playerctl").args(["--player", name, "pause"]).status();
                    paused.push(name.to_owned());
                }
            }
        }
    } else if let Some(players) = query_via_gdbus() {
        for p in players {
            if p.playing {
                let bus = mpris_bus_name(&p.id);
                if gdbus_player_call(&bus, "Pause", &[]) {
                    paused.push(p.id);
                }
            }
        }
    }

    if !paused.is_empty()
        && let Ok(mut guard) = PAUSED_FOR_CALL.lock()
    {
        *guard = Some(PausedForCall { players: paused, paused_at: Instant::now() });
    }
}

pub fn resume_after_call() {
    let _ = std::thread::Builder::new().name("call-media-resume".into()).spawn(resume_after_call_blocking);
}

fn resume_after_call_blocking() {
    let _serial = CALL_MEDIA.lock().unwrap_or_else(|e| e.into_inner());
    let players = PAUSED_FOR_CALL
        .lock()
        .ok()
        .and_then(|mut g| g.as_mut().map(|p| p.take_valid(Instant::now())))
        .unwrap_or_default();
    if players.is_empty() {
        return;
    }
    let conn = zbus::blocking::Connection::session().ok();
    for player in players {
        let bus = mpris_bus_name(&player);
        let resumed_via_zbus = conn.as_ref().is_some_and(|c| {
            c.call_method(
                Some(bus.as_str()),
                "/org/mpris/MediaPlayer2",
                Some("org.mpris.MediaPlayer2.Player"),
                "Play",
                &(),
            )
            .is_ok()
        });
        if !resumed_via_zbus {
            let ok = Command::new("playerctl")
                .args(["--player", &player, "play"])
                .status()
                .is_ok_and(|s| s.success());
            if !ok {
                let _ = gdbus_player_call(&bus, "Play", &[]);
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn sample_player(id: &str, playing: bool, position: Option<u64>) -> MediaPlayer {
        MediaPlayer {
            id: id.to_owned(),
            app: "Spotify".to_owned(),
            title: Some("Track 1".to_owned()),
            artist: Some("Artist".to_owned()),
            album: Some("Album".to_owned()),
            playing,
            duration: Some(200_000),
            position,
            actions: vec!["play".to_owned(), "pause".to_owned(), "seek".to_owned()],
            art_key: None,
            art: None,
        }
    }

    #[test]
    fn parses_playerctl_line_and_filters_self_player() {
        let line = "spotify\tPlaying\t/com/spotify/track/123\tMidnight City\tM83\tHurry Up, We're Dreaming\t243000000\t61500000\tfile:///tmp/cover%20art.jpg";
        let parsed = parse_playerctl_line(line).expect("valid playerctl line");
        assert_eq!(parsed.id, "spotify");
        assert_eq!(parsed.app, "Spotify");
        assert_eq!(parsed.title, "Midnight City");
        assert_eq!(parsed.artist.as_deref(), Some("M83"));
        assert_eq!(parsed.album.as_deref(), Some("Hurry Up, We're Dreaming"));
        assert!(parsed.playing);
        assert_eq!(parsed.duration, Some(243_000));
        assert_eq!(parsed.position, Some(61_500));
        assert_eq!(parsed.art_url.as_deref(), Some("file:///tmp/cover%20art.jpg"));

        // Self-player and playerctld must be ignored
        let self_line = "nectarlink\tPlaying\t/1\tPhone Song\tArtist\tAlbum\t1000000\t0\t";
        assert!(parse_playerctl_line(self_line).is_none());
        let daemon_line = "playerctld\tPlaying\t/1\tPhone Song\tArtist\tAlbum\t1000000\t0\t";
        assert!(parse_playerctl_line(daemon_line).is_none());
    }

    #[test]
    fn parses_mpris_bus_names_and_excludes_nectarlink() {
        let gdbus_out = "([':1.0', 'org.freedesktop.DBus', 'org.mpris.MediaPlayer2.spotify', 'org.mpris.MediaPlayer2.nectarlink', 'org.mpris.MediaPlayer2.playerctld', 'org.mpris.MediaPlayer2.vlc.instance42'],)";
        let buses = parse_mpris_bus_names(gdbus_out);
        assert_eq!(
            buses,
            vec![
                "org.mpris.MediaPlayer2.spotify".to_owned(),
                "org.mpris.MediaPlayer2.vlc.instance42".to_owned(),
            ]
        );
    }

    #[test]
    fn parses_gdbus_getall_player_properties() {
        let gdbus_props = "({'PlaybackStatus': <'Playing'>, 'Position': <int64 30000000>, 'Metadata': <{'mpris:length': <int64 180000000>, 'mpris:artUrl': <'file:///home/user/Album%20Cover.png'>, 'xesam:title': <'Starlight'>, 'xesam:artist': <['Muse']>, 'xesam:album': <'Black Holes and Revelations'>}>, 'CanPlay': <true>, 'CanPause': <true>, 'CanSeek': <true>},)";
        let player = parse_gdbus_player_properties("org.mpris.MediaPlayer2.vlc", gdbus_props)
            .expect("parse gdbus properties");
        assert_eq!(player.id, "vlc");
        assert_eq!(player.app, "VLC");
        assert_eq!(player.title, "Starlight");
        assert_eq!(player.artist.as_deref(), Some("Muse"));
        assert_eq!(player.album.as_deref(), Some("Black Holes and Revelations"));
        assert!(player.playing);
        assert_eq!(player.duration, Some(180_000));
        assert_eq!(player.position, Some(30_000));
    }

    #[test]
    fn players_meaningfully_changed_ignores_linear_progress_and_detects_seeks() {
        let old = vec![sample_player("spotify", true, Some(10_000))];
        // 2 seconds later, position is 12_100 ms (within 1500 ms of expected 12_000 ms)
        let normal_tick = vec![sample_player("spotify", true, Some(12_100))];
        assert!(!players_meaningfully_changed(&old, &normal_tick, Duration::from_secs(2)));

        // User seeked forward to 45_000 ms
        let seeked = vec![sample_player("spotify", true, Some(45_000))];
        assert!(players_meaningfully_changed(&old, &seeked, Duration::from_secs(2)));

        // Playback paused
        let paused = vec![sample_player("spotify", false, Some(12_000))];
        assert!(players_meaningfully_changed(&old, &paused, Duration::from_secs(2)));
    }

    #[test]
    fn resolves_art_file_url_with_percent_encoding() {
        assert_eq!(
            resolve_art_file_url("file:///path/with%20spaces/cover%231.png"),
            Some(PathBuf::from("/path/with spaces/cover#1.png"))
        );
        assert!(resolve_art_file_url("https://example.com/cover.jpg").is_none());
        assert!(resolve_art_file_url("").is_none());
    }

    #[test]
    fn paused_for_call_expires_after_ttl() {
        let start = Instant::now();
        let mut state = PausedForCall { players: vec!["spotify".to_string()], paused_at: start };
        let expired = state.take_valid(start + CALL_PAUSE_TTL + Duration::from_secs(1));
        assert!(expired.is_empty());
    }

    #[test]
    fn parses_zbus_getall_player_properties_and_seek_offset() {
        use zbus::zvariant::Value;

        let mut meta: HashMap<&str, Value<'_>> = HashMap::new();
        meta.insert("xesam:title", Value::from("Instant Crush"));
        meta.insert("xesam:artist", Value::from(vec!["Daft Punk", "Julian Casablancas"]));
        meta.insert("xesam:album", Value::from("Random Access Memories"));
        meta.insert("mpris:length", Value::from(337_000_000_i64));
        meta.insert("mpris:artUrl", Value::from("file:///tmp/ram.jpg"));

        let mut player_props: HashMap<String, OwnedValue> = HashMap::new();
        player_props
            .insert("PlaybackStatus".to_owned(), OwnedValue::try_from(Value::from("Playing")).unwrap());
        player_props
            .insert("Position".to_owned(), OwnedValue::try_from(Value::from(45_000_000_i64)).unwrap());
        player_props.insert("Metadata".to_owned(), OwnedValue::try_from(Value::from(meta)).unwrap());
        player_props.insert("CanPlay".to_owned(), OwnedValue::try_from(Value::from(true)).unwrap());
        player_props.insert("CanPause".to_owned(), OwnedValue::try_from(Value::from(true)).unwrap());
        player_props.insert("CanSeek".to_owned(), OwnedValue::try_from(Value::from(true)).unwrap());

        let parsed =
            parse_zbus_player_properties("org.mpris.MediaPlayer2.spotify", None, &player_props).unwrap();
        assert_eq!(parsed.id, "spotify");
        assert_eq!(parsed.app, "Spotify");
        assert_eq!(parsed.title, "Instant Crush");
        assert_eq!(parsed.artist.as_deref(), Some("Daft Punk, Julian Casablancas"));
        assert_eq!(parsed.album.as_deref(), Some("Random Access Memories"));
        assert!(parsed.playing);
        assert_eq!(parsed.duration, Some(337_000));
        assert_eq!(parsed.position, Some(45_000));
        assert_eq!(parsed.art_url.as_deref(), Some("file:///tmp/ram.jpg"));

        assert_eq!(compute_seek_offset_us(60_000_000, 45_000_000), 15_000_000);
        assert_eq!(compute_seek_offset_us(10_000_000, 45_000_000), -35_000_000);
    }

    #[test]
    fn paused_for_call_returns_players_within_ttl() {
        let start = Instant::now();
        let mut state =
            PausedForCall { players: vec!["spotify".to_string(), "vlc".to_string()], paused_at: start };
        let valid = state.take_valid(start + Duration::from_secs(10));
        assert_eq!(valid, vec!["spotify".to_string(), "vlc".to_string()]);
        assert!(state.take_valid(start + Duration::from_secs(11)).is_empty());
    }
}