Struct 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

source

pub async fn at<'p, P, I>(&self, path: P, iface: I) -> Result<bool>
where I: Interface, P: TryInto<ObjectPath<'p>>, P::Error: Into<Error>,

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.

source

pub async fn remove<'p, I, P>(&self, path: P) -> Result<bool>
where I: Interface, P: TryInto<ObjectPath<'p>>, P::Error: Into<Error>,

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.

source

pub async fn interface<'p, P, I>(&self, path: P) -> Result<InterfaceRef>
where I: Interface, P: TryInto<ObjectPath<'p>>, P::Error: Into<Error>,

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?;