Struct zbus::ObjectServer
source · pub struct ObjectServer { /* private fields */ }
Expand description
An object server, holding server-side D-Bus objects & interfaces.
Object servers hold interfaces on various object paths, and expose them over D-Bus.
All object paths will have the standard interfaces implemented on your behalf, such as
org.freedesktop.DBus.Introspectable
or org.freedesktop.DBus.Properties
.
§Example
This example exposes the org.myiface.Example.Quit
method on the /org/zbus/path
path.
use zbus::{Connection, dbus_interface};
use event_listener::Event;
struct Example {
// Interfaces are owned by the ObjectServer. They can have
// `&mut self` methods.
quit_event: Event,
}
impl Example {
fn new(quit_event: Event) -> Self {
Self { quit_event }
}
}
#[dbus_interface(name = "org.myiface.Example")]
impl Example {
// This will be the "Quit" D-Bus method.
async fn quit(&mut self) {
self.quit_event.notify(1);
}
// See `dbus_interface` documentation to learn
// how to expose properties & signals as well.
}
let connection = Connection::session().await?;
let quit_event = Event::new();
let quit_listener = quit_event.listen();
let interface = Example::new(quit_event);
connection
.object_server()
.at("/org/zbus/path", interface)
.await?;
quit_listener.await;
Implementations§
source§impl ObjectServer
impl ObjectServer
sourcepub async fn at<'p, P, I>(&self, path: P, iface: I) -> Result<bool>
pub async fn at<'p, P, I>(&self, path: P, iface: I) -> Result<bool>
Register a D-Bus Interface
at a given path. (see the example above)
Typically you’d want your interfaces to be registered immediately after the associated
connection is established and therefore use zbus::ConnectionBuilder::serve_at
instead.
However, there are situations where you’d need to register interfaces dynamically and that’s
where this method becomes useful.
If the interface already exists at this path, returns false.
sourcepub async fn remove<'p, I, P>(&self, path: P) -> Result<bool>
pub async fn remove<'p, I, P>(&self, path: P) -> Result<bool>
Unregister a D-Bus Interface
at a given path.
If there are no more interfaces left at that path, destroys the object as well. Returns whether the object was destroyed.
sourcepub async fn interface<'p, P, I>(&self, path: P) -> Result<InterfaceRef<I>>
pub async fn interface<'p, P, I>(&self, path: P) -> Result<InterfaceRef<I>>
Get the interface at the given path.
§Errors
If the interface is not registered at the given path, Error::InterfaceNotFound
error is
returned.
§Examples
The typical use of this is property changes outside of a dispatched handler:
struct MyIface(u32);
#[dbus_interface(name = "org.myiface.MyIface")]
impl MyIface {
#[dbus_interface(property)]
async fn count(&self) -> u32 {
self.0
}
}
let iface_ref = connection
.object_server()
.interface::<_, MyIface>(path).await?;
let mut iface = iface_ref.get_mut().await;
iface.0 = 42;
iface.count_changed(iface_ref.signal_context()).await?;