537 lines
19 KiB
Rust
537 lines
19 KiB
Rust
use std::collections::HashMap;
|
|
use std::time::Duration;
|
|
|
|
use calloop::channel::SyncSender;
|
|
use ferese_ipc::{
|
|
Response,
|
|
media::{Playback, now_us},
|
|
};
|
|
use futures_lite::{StreamExt, future, stream};
|
|
use zbus::zvariant::{Array, OwnedObjectPath, OwnedValue, Value};
|
|
use zbus::{Connection, MatchRule, MessageStream};
|
|
|
|
use super::policy::PlayersState;
|
|
use super::{Command, Player, Update};
|
|
|
|
const PREFIX: &str = "org.mpris.MediaPlayer2";
|
|
const PATH: &str = "/org/mpris/MediaPlayer2";
|
|
const PLAYER: &str = "org.mpris.MediaPlayer2.Player";
|
|
const PROPERTIES: &str = "org.freedesktop.DBus.Properties";
|
|
const MAX_PLAYERS: usize = 64;
|
|
type Properties = HashMap<String, OwnedValue>;
|
|
|
|
async fn bus_call<T: serde::de::DeserializeOwned + zbus::zvariant::Type>(
|
|
connection: &Connection,
|
|
member: &str,
|
|
name: &str,
|
|
) -> zbus::Result<T> {
|
|
connection
|
|
.call_method(
|
|
Some("org.freedesktop.DBus"),
|
|
"/org/freedesktop/DBus",
|
|
Some("org.freedesktop.DBus"),
|
|
member,
|
|
&(name,),
|
|
)
|
|
.await?
|
|
.body()
|
|
.deserialize()
|
|
}
|
|
|
|
async fn properties(
|
|
connection: &Connection,
|
|
owner: &str,
|
|
interface: &str,
|
|
) -> zbus::Result<Properties> {
|
|
connection
|
|
.call_method(Some(owner), PATH, Some(PROPERTIES), "GetAll", &(interface,))
|
|
.await?
|
|
.body()
|
|
.deserialize()
|
|
}
|
|
|
|
fn string<'a>(properties: &'a Properties, name: &str) -> Option<&'a str> {
|
|
properties
|
|
.get(name)
|
|
.and_then(|value| <&str>::try_from(value).ok())
|
|
}
|
|
|
|
pub(super) fn clean(value: &str, length: usize) -> String {
|
|
value
|
|
.chars()
|
|
.filter(|character| !character.is_control())
|
|
.take(length)
|
|
.collect::<String>()
|
|
.trim()
|
|
.to_owned()
|
|
}
|
|
|
|
fn boolean(properties: &Properties, name: &str) -> bool {
|
|
properties
|
|
.get(name)
|
|
.and_then(|value| bool::try_from(value).ok())
|
|
.unwrap_or(false)
|
|
}
|
|
|
|
fn integer(properties: &Properties, name: &str) -> Option<u64> {
|
|
properties
|
|
.get(name)
|
|
.and_then(|value| i64::try_from(value).ok())
|
|
.and_then(|value| value.try_into().ok())
|
|
}
|
|
|
|
fn number(properties: &Properties, name: &str) -> Option<f64> {
|
|
properties
|
|
.get(name)
|
|
.and_then(|value| f64::try_from(value).ok())
|
|
.filter(|value| value.is_finite())
|
|
}
|
|
|
|
async fn refresh(connection: &Connection, player: &mut Player, identity: bool) -> zbus::Result<()> {
|
|
let mut fields = properties(connection, &player.owner, PLAYER).await?;
|
|
let view = &mut player.view;
|
|
view.status = match string(&fields, "PlaybackStatus") {
|
|
Some("Playing") => Playback::Playing,
|
|
Some("Paused") => Playback::Paused,
|
|
_ => Playback::Stopped,
|
|
};
|
|
player.playing = view.status == Playback::Playing;
|
|
view.position_us = integer(&fields, "Position");
|
|
view.sampled_at_us = now_us();
|
|
view.rate = number(&fields, "Rate")
|
|
.filter(|rate| *rate != 0.0 && rate.abs() <= 100.0)
|
|
.unwrap_or(1.0);
|
|
view.volume = number(&fields, "Volume").filter(|volume| *volume >= 0.0);
|
|
view.can_control = boolean(&fields, "CanControl");
|
|
view.can_play = boolean(&fields, "CanPlay");
|
|
view.can_pause = boolean(&fields, "CanPause");
|
|
view.can_next = boolean(&fields, "CanGoNext");
|
|
view.can_previous = boolean(&fields, "CanGoPrevious");
|
|
view.can_seek = boolean(&fields, "CanSeek");
|
|
let metadata = fields
|
|
.remove("Metadata")
|
|
.and_then(|value| Properties::try_from(value).ok())
|
|
.unwrap_or_default();
|
|
view.title = clean(string(&metadata, "xesam:title").unwrap_or_default(), 256);
|
|
view.album = clean(string(&metadata, "xesam:album").unwrap_or_default(), 256);
|
|
view.artist = metadata
|
|
.get("xesam:artist")
|
|
.and_then(|value| <&Array>::try_from(value).ok())
|
|
.map(|array| {
|
|
array
|
|
.inner()
|
|
.iter()
|
|
.take(8)
|
|
.filter_map(|value| <&str>::try_from(value).ok())
|
|
.map(|artist| clean(artist, 64))
|
|
.collect::<Vec<_>>()
|
|
.join(", ")
|
|
})
|
|
.unwrap_or_default();
|
|
view.length_us = integer(&metadata, "mpris:length").filter(|length| *length > 0);
|
|
view.track_id = metadata
|
|
.get("mpris:trackid")
|
|
.and_then(|value| <&zbus::zvariant::ObjectPath>::try_from(value).ok())
|
|
.map(|path| path.to_string());
|
|
view.art_url = string(&metadata, "mpris:artUrl")
|
|
.filter(|url| !url.is_empty() && url.len() <= 256 * 1024)
|
|
.map(str::to_owned);
|
|
|
|
if identity || player.pid.is_none() {
|
|
player.pid = bus_call(connection, "GetConnectionUnixProcessID", &player.owner)
|
|
.await
|
|
.ok();
|
|
if let Ok(root) = properties(connection, &player.owner, PREFIX).await {
|
|
view.identity = clean(string(&root, "Identity").unwrap_or(&player.name), 80);
|
|
view.can_raise = boolean(&root, "CanRaise");
|
|
player.desktop_entry = string(&root, "DesktopEntry")
|
|
.map(crate::window_rules::normalize_app_id)
|
|
.filter(|value| !value.is_empty());
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn discover(connection: &Connection, name: String, owner: String) -> Player {
|
|
let mut player = Player {
|
|
view: ferese_ipc::media::Player {
|
|
name: name.clone(),
|
|
owner: owner.clone(),
|
|
identity: clean(&name, 80),
|
|
..Default::default()
|
|
},
|
|
name,
|
|
owner,
|
|
..Default::default()
|
|
};
|
|
let _ = refresh(connection, &mut player, true).await;
|
|
player
|
|
}
|
|
|
|
async fn action(
|
|
connection: &Connection,
|
|
state: &mut PlayersState,
|
|
args: &serde_json::Value,
|
|
) -> Result<(), String> {
|
|
let kind = args["action"].as_str().ok_or("Missing media action")?;
|
|
if kind == "auto" {
|
|
state.pinned = None;
|
|
return Ok(());
|
|
}
|
|
|
|
let player = match args["player"].as_str() {
|
|
Some(name) => state.players.get(name),
|
|
None => state.selected(),
|
|
}
|
|
.cloned()
|
|
.ok_or("No active media player")?;
|
|
if args["owner"]
|
|
.as_str()
|
|
.is_some_and(|owner| owner != player.owner)
|
|
{
|
|
return Err("Media player was replaced".into());
|
|
}
|
|
|
|
match kind {
|
|
"pin" => {
|
|
state.ignored.remove(&player.name);
|
|
state.pinned = Some(player.name);
|
|
return Ok(());
|
|
}
|
|
"ignore" => {
|
|
let ignored = args["ignored"].as_bool().ok_or("Missing ignore state")?;
|
|
if ignored {
|
|
state.ignored.insert(player.name.clone());
|
|
} else {
|
|
state.ignored.remove(&player.name);
|
|
}
|
|
if ignored && state.pinned.as_deref() == Some(&player.name) {
|
|
state.pinned = None;
|
|
}
|
|
return Ok(());
|
|
}
|
|
_ => (),
|
|
}
|
|
|
|
let view = &player.view;
|
|
let supported = match kind {
|
|
"play-pause" => view.can_toggle(),
|
|
"next" => view.can_control && view.can_next,
|
|
"previous" => view.can_control && view.can_previous,
|
|
"raise" => view.can_raise,
|
|
"seek" => view.can_control && view.can_seek && view.track_id.is_some(),
|
|
"volume" => view.can_control && view.volume.is_some(),
|
|
_ => false,
|
|
};
|
|
if !supported {
|
|
return Err("Media action is unavailable for this player".into());
|
|
}
|
|
|
|
let method = match kind {
|
|
"play-pause" => "PlayPause",
|
|
"next" => "Next",
|
|
"previous" => "Previous",
|
|
"raise" => "Raise",
|
|
_ => "",
|
|
};
|
|
let response = match kind {
|
|
"seek" => {
|
|
if args["track_id"].as_str() != view.track_id.as_deref() {
|
|
return Err("Media track changed".into());
|
|
}
|
|
let position = args["position_us"]
|
|
.as_u64()
|
|
.ok_or("Invalid media position")?;
|
|
let position = view
|
|
.length_us
|
|
.map_or(position, |length| position.min(length))
|
|
.min(i64::MAX as u64) as i64;
|
|
let track = OwnedObjectPath::try_from(view.track_id.clone().unwrap())
|
|
.map_err(|error| error.to_string())?;
|
|
connection
|
|
.call_method(
|
|
Some(player.owner.as_str()),
|
|
PATH,
|
|
Some(PLAYER),
|
|
"SetPosition",
|
|
&(track, position),
|
|
)
|
|
.await
|
|
}
|
|
"volume" => {
|
|
let delta = args["delta"]
|
|
.as_f64()
|
|
.filter(|delta| delta.is_finite() && delta.abs() <= 1.0)
|
|
.ok_or("Invalid volume change")?;
|
|
let volume = (view.volume.unwrap() + delta).clamp(0.0, 1.0);
|
|
connection
|
|
.call_method(
|
|
Some(player.owner.as_str()),
|
|
PATH,
|
|
Some(PROPERTIES),
|
|
"Set",
|
|
&(PLAYER, "Volume", Value::F64(volume)),
|
|
)
|
|
.await
|
|
}
|
|
_ => {
|
|
connection
|
|
.call_method(
|
|
Some(player.owner.as_str()),
|
|
PATH,
|
|
Some(if kind == "raise" { PREFIX } else { PLAYER }),
|
|
method,
|
|
&(),
|
|
)
|
|
.await
|
|
}
|
|
};
|
|
response.map_err(|error| error.to_string())?;
|
|
let mut player = player;
|
|
if refresh(connection, &mut player, false).await.is_ok() {
|
|
state.update(player);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn publish(
|
|
state: &PlayersState,
|
|
previous: &mut Option<Update>,
|
|
sender: &SyncSender<Update>,
|
|
) -> bool {
|
|
let update = state.update_snapshot();
|
|
if previous
|
|
.as_ref()
|
|
.is_some_and(|old| old.players == update.players && old.snapshot == update.snapshot)
|
|
{
|
|
return true;
|
|
}
|
|
*previous = Some(Update {
|
|
players: update.players.clone(),
|
|
snapshot: update.snapshot.clone(),
|
|
});
|
|
sender.send(update).is_ok()
|
|
}
|
|
|
|
async fn monitor(
|
|
connection: Connection,
|
|
commands: &async_channel::Receiver<Command>,
|
|
sender: &SyncSender<Update>,
|
|
) -> zbus::Result<()> {
|
|
let properties = MatchRule::builder()
|
|
.msg_type(zbus::message::Type::Signal)
|
|
.path(PATH)?
|
|
.interface(PROPERTIES)?
|
|
.member("PropertiesChanged")?
|
|
.build();
|
|
let owners = MatchRule::builder()
|
|
.msg_type(zbus::message::Type::Signal)
|
|
.sender("org.freedesktop.DBus")?
|
|
.interface("org.freedesktop.DBus")?
|
|
.member("NameOwnerChanged")?
|
|
.arg0ns(PREFIX)?
|
|
.build();
|
|
let seeks = MatchRule::builder()
|
|
.msg_type(zbus::message::Type::Signal)
|
|
.path(PATH)?
|
|
.interface(PLAYER)?
|
|
.member("Seeked")?
|
|
.build();
|
|
let properties = MessageStream::for_match_rule(properties, &connection, Some(128)).await?;
|
|
let owners = MessageStream::for_match_rule(owners, &connection, Some(128)).await?;
|
|
let seeks = MessageStream::for_match_rule(seeks, &connection, Some(64)).await?;
|
|
let mut signals = stream::or(stream::or(properties, owners), seeks);
|
|
let mut state = PlayersState::default();
|
|
let names: Vec<String> = connection
|
|
.call_method(
|
|
Some("org.freedesktop.DBus"),
|
|
"/org/freedesktop/DBus",
|
|
Some("org.freedesktop.DBus"),
|
|
"ListNames",
|
|
&(),
|
|
)
|
|
.await?
|
|
.body()
|
|
.deserialize()?;
|
|
let mut names: Vec<_> = names
|
|
.into_iter()
|
|
.filter(|name| {
|
|
name.strip_prefix(PREFIX)
|
|
.is_some_and(|suffix| suffix.starts_with('.'))
|
|
})
|
|
.collect();
|
|
names.sort_unstable();
|
|
for name in names.into_iter().take(MAX_PLAYERS) {
|
|
if let Ok(owner) = bus_call(&connection, "GetNameOwner", &name).await {
|
|
let player = discover(&connection, name.clone(), owner).await;
|
|
// Existing players have no known start order; bus names break ties.
|
|
state.players.insert(name, player);
|
|
}
|
|
}
|
|
|
|
let mut previous = None;
|
|
if !publish(&state, &mut previous, sender) {
|
|
return Ok(());
|
|
}
|
|
enum Input {
|
|
Signal(Option<zbus::Result<zbus::Message>>),
|
|
Action(Option<Command>),
|
|
}
|
|
loop {
|
|
let input = match commands.try_recv() {
|
|
Ok(command) => Input::Action(Some(command)),
|
|
Err(_) => {
|
|
future::or(async { Input::Signal(signals.next().await) }, async {
|
|
Input::Action(commands.recv().await.ok())
|
|
})
|
|
.await
|
|
}
|
|
};
|
|
match input {
|
|
Input::Action(None) => return Ok(()),
|
|
Input::Signal(None) => {
|
|
return Err(zbus::Error::Failure("MPRIS signal stream ended".into()));
|
|
}
|
|
Input::Action(Some(command)) => {
|
|
let result = if command.sent.elapsed() > Duration::from_secs(2) {
|
|
Err("Media command expired".into())
|
|
} else {
|
|
action(&connection, &mut state, &command.args).await
|
|
};
|
|
if let Some((id, response)) = command.reply {
|
|
let reply = match result {
|
|
Ok(()) => Response::success(id, serde_json::json!({})),
|
|
Err(error) => Response::error(id, "media_unavailable", error),
|
|
};
|
|
let _ = response.try_send(reply);
|
|
}
|
|
}
|
|
Input::Signal(Some(message)) => {
|
|
let message = message?;
|
|
let header = message.header();
|
|
if header
|
|
.member()
|
|
.is_some_and(|member| member.as_str() == "NameOwnerChanged")
|
|
{
|
|
let (name, _, owner): (String, String, String) =
|
|
message.body().deserialize()?;
|
|
if !name
|
|
.strip_prefix(PREFIX)
|
|
.is_some_and(|suffix| suffix.starts_with('.'))
|
|
{
|
|
continue;
|
|
}
|
|
state.remove(&name);
|
|
if !publish(&state, &mut previous, sender) {
|
|
return Ok(());
|
|
}
|
|
if !owner.is_empty() && state.players.len() < MAX_PLAYERS {
|
|
let player = discover(&connection, name, owner).await;
|
|
state.update(player);
|
|
}
|
|
} else if let Some(owner) = header.sender() {
|
|
if header
|
|
.member()
|
|
.is_some_and(|member| member.as_str() == "Seeked")
|
|
{
|
|
let names: Vec<_> = state
|
|
.players
|
|
.values()
|
|
.filter(|player| player.owner == owner.as_str())
|
|
.map(|player| player.name.clone())
|
|
.collect();
|
|
for name in names {
|
|
let mut player = state.players[&name].clone();
|
|
if refresh(&connection, &mut player, false).await.is_ok() {
|
|
state.update(player);
|
|
}
|
|
}
|
|
} else {
|
|
let Ok((interface, changed, invalidated)) =
|
|
message
|
|
.body()
|
|
.deserialize::<(String, Properties, Vec<String>)>()
|
|
else {
|
|
continue;
|
|
};
|
|
let identity = interface == PREFIX
|
|
&& ["Identity", "DesktopEntry", "CanRaise"].iter().any(|key| {
|
|
changed.contains_key(*key)
|
|
|| invalidated.iter().any(|field| field == key)
|
|
});
|
|
let playback = interface == PLAYER
|
|
&& [
|
|
"PlaybackStatus",
|
|
"Metadata",
|
|
"Rate",
|
|
"Volume",
|
|
"CanGoNext",
|
|
"CanGoPrevious",
|
|
"CanPlay",
|
|
"CanPause",
|
|
"CanSeek",
|
|
"CanControl",
|
|
]
|
|
.iter()
|
|
.any(|key| {
|
|
changed.contains_key(*key)
|
|
|| invalidated.iter().any(|field| field == key)
|
|
});
|
|
if !identity && !playback {
|
|
continue;
|
|
}
|
|
let names: Vec<_> = state
|
|
.players
|
|
.values()
|
|
.filter(|player| player.owner == owner.as_str())
|
|
.map(|player| player.name.clone())
|
|
.collect();
|
|
for name in names {
|
|
let mut player = state.players[&name].clone();
|
|
// Re-read after a signal so queued startup messages cannot regress state.
|
|
if refresh(&connection, &mut player, identity).await.is_ok() {
|
|
state.update(player);
|
|
} else {
|
|
player.playing = false;
|
|
player.view.status = Playback::Stopped;
|
|
state.update(player);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if !publish(&state, &mut previous, sender) {
|
|
return Ok(());
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(super) fn run(sender: SyncSender<Update>, commands: async_channel::Receiver<Command>) {
|
|
loop {
|
|
let result = future::block_on(async {
|
|
let connection = zbus::connection::Builder::session()?
|
|
.method_timeout(Duration::from_millis(500))
|
|
.build()
|
|
.await?;
|
|
monitor(connection, &commands, &sender).await
|
|
});
|
|
if matches!(result, Ok(())) || commands.is_closed() {
|
|
break;
|
|
}
|
|
if sender
|
|
.send(PlayersState::default().update_snapshot())
|
|
.is_err()
|
|
{
|
|
break;
|
|
}
|
|
tracing::debug!(
|
|
?result,
|
|
"MPRIS disconnected; clearing playback and retrying"
|
|
);
|
|
std::thread::sleep(Duration::from_secs(5));
|
|
}
|
|
}
|