Struct zbus::blocking::object_server::ObjectServer

source ·

pub struct ObjectServer { /* private fields */ }

Expand description

A blocking wrapper of crate::ObjectServer.

§Example

This example exposes the org.myiface.Example.Quit method on the /org/zbus/path path.

use zbus::{blocking::Connection, interface};
use event_listener::{Event, Listener};

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 }
    }
}

#[interface(name = "org.myiface.Example")]
impl Example {
    // This will be the "Quit" D-Bus method.
    fn quit(&mut self) {
        self.quit_event.notify(1);
    }

    // See `interface` documentation to learn
    // how to expose properties & signals as well.
}

let connection = Connection::session()?;

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

quit_listener.wait();

Implementations§

source §

impl ObjectServer

source

pub 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::blocking::connection::Builder::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 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 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 to emit signals outside of a dispatched handler:

struct MyIface;
#[interface(name = "org.myiface.MyIface")]
impl MyIface {
    #[zbus(signal)]
    async fn emit_signal(ctxt: &SignalContext<'_>) -> zbus::Result<()>;
}

let iface_ref = connection
    .object_server()
    .interface::<_, MyIface>(path)?;
block_on(MyIface::emit_signal(iface_ref.signal_context()))?;