130 lines
4.1 KiB
Rust
130 lines
4.1 KiB
Rust
use log::info;
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
use dbus::{
|
|
channel::{MatchingReceiver, Sender},
|
|
message::MatchRule,
|
|
nonblock::SyncConnection,
|
|
Path,
|
|
};
|
|
use dbus_crossroads::Crossroads;
|
|
|
|
#[derive(Clone)]
|
|
pub struct DbusRegistry {
|
|
connection: Arc<SyncConnection>,
|
|
crossroads: Arc<Mutex<Crossroads>>,
|
|
message_handler_started: Arc<Mutex<bool>>,
|
|
}
|
|
|
|
impl DbusRegistry {
|
|
pub fn new(connection: Arc<SyncConnection>) -> Self {
|
|
let mut cr = Crossroads::new();
|
|
// Enable async support for the crossroads instance.
|
|
// (Currently irrelevant since dbus generates sync code)
|
|
cr.set_async_support(Some((
|
|
connection.clone(),
|
|
Box::new(|x| {
|
|
tokio::spawn(x);
|
|
}),
|
|
)));
|
|
|
|
Self {
|
|
connection,
|
|
crossroads: Arc::new(Mutex::new(cr)),
|
|
message_handler_started: Arc::new(Mutex::new(false)),
|
|
}
|
|
}
|
|
|
|
pub fn register_object<T, F, R>(&self, path: &str, implementation: T, register_fn: F)
|
|
where
|
|
T: Send + Clone + 'static,
|
|
F: Fn(&mut Crossroads) -> R,
|
|
R: IntoIterator<Item = dbus_crossroads::IfaceToken<T>>,
|
|
{
|
|
let dbus_path = String::from(path);
|
|
|
|
let mut cr = self.crossroads.lock().unwrap();
|
|
let tokens: Vec<_> = register_fn(&mut cr).into_iter().collect();
|
|
cr.insert(dbus_path, &tokens, implementation);
|
|
|
|
// Start message handler if not already started
|
|
let mut handler_started = self.message_handler_started.lock().unwrap();
|
|
if !*handler_started {
|
|
let crossroads_clone = self.crossroads.clone();
|
|
self.connection.start_receive(
|
|
MatchRule::new_method_call(),
|
|
Box::new(move |msg, conn| {
|
|
let mut cr = crossroads_clone.lock().unwrap();
|
|
cr.handle_message(msg, conn).is_ok()
|
|
}),
|
|
);
|
|
*handler_started = true;
|
|
info!(target: "dbus", "Started D-Bus message handler");
|
|
}
|
|
|
|
info!(target: "dbus", "Registered object at {} with {} interfaces", path, tokens.len());
|
|
}
|
|
|
|
pub fn send_signal<S>(&self, path: &str, signal: S) -> Result<u32, ()>
|
|
where
|
|
S: dbus::message::SignalArgs + dbus::arg::AppendAll,
|
|
{
|
|
let message = signal.to_emit_message(&Path::new(path).unwrap());
|
|
self.connection.send(message)
|
|
}
|
|
}
|
|
|
|
// Keep the old Endpoint struct for backward compatibility during transition
|
|
#[derive(Clone)]
|
|
pub struct Endpoint<T: Send + Clone + 'static> {
|
|
connection: Arc<SyncConnection>,
|
|
implementation: T,
|
|
}
|
|
|
|
impl<T: Send + Clone + 'static> Endpoint<T> {
|
|
pub fn new(connection: Arc<SyncConnection>, implementation: T) -> Self {
|
|
Self {
|
|
connection,
|
|
implementation,
|
|
}
|
|
}
|
|
|
|
pub async fn register_object<F, R>(&self, path: &str, register_fn: F)
|
|
where
|
|
F: Fn(&mut Crossroads) -> R,
|
|
R: IntoIterator<Item = dbus_crossroads::IfaceToken<T>>,
|
|
{
|
|
let dbus_path = String::from(path);
|
|
|
|
// Enable async support for the crossroads instance.
|
|
// (Currently irrelevant since dbus generates sync code)
|
|
let mut cr = Crossroads::new();
|
|
cr.set_async_support(Some((
|
|
self.connection.clone(),
|
|
Box::new(|x| {
|
|
tokio::spawn(x);
|
|
}),
|
|
)));
|
|
|
|
// Register the daemon as a D-Bus object with multiple interfaces
|
|
let tokens: Vec<_> = register_fn(&mut cr).into_iter().collect();
|
|
cr.insert(dbus_path, &tokens, self.implementation.clone());
|
|
|
|
// Start receiving messages.
|
|
self.connection.start_receive(
|
|
MatchRule::new_method_call(),
|
|
Box::new(move |msg, conn| cr.handle_message(msg, conn).is_ok()),
|
|
);
|
|
|
|
info!(target: "dbus", "Registered endpoint at {} with {} interfaces", path, tokens.len());
|
|
}
|
|
|
|
pub fn send_signal<S>(&self, path: &str, signal: S) -> Result<u32, ()>
|
|
where
|
|
S: dbus::message::SignalArgs + dbus::arg::AppendAll,
|
|
{
|
|
let message = signal.to_emit_message(&Path::new(path).unwrap());
|
|
self.connection.send(message)
|
|
}
|
|
}
|