mpris and bar control impl
gitignore fix import error
This commit is contained in:
Samuel Onoja committed
1 parent
73f21e20ce
commit
8a0dd7615e
42 files changed
+4026
-227
No files matched your search
@@ -0,0 +1,492 @@
|
||||
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));
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user