Attribute Macro zbus::dbus_interface

#[dbus_interface]

Attribute macro for implementing a D-Bus interface.

The macro must be applied on an impl T. All methods will be exported, either as methods, properties or signal depending on the item attributes. It will implement the Interface trait for T on your behalf, to handle the message dispatching and introspection support.

The methods accepts the dbus_interface attributes:

• name - override the D-Bus name (pascal case form of the method by default)

• property - expose the method as a property. If the method takes an argument, it must be a setter, with a set_ prefix. Otherwise, it’s a getter.

• signal - the method is a “signal”. It must be a method declaration (without body). Its code block will be expanded to emit the signal from the object path associated with the interface instance.

  You can call a signal method from a an interface method, or from an ObjectServer::with function.

• struct_return - This attribute is depcrecated and a noop. If you want to return a single structure from a method, simply declare it to return a named structure or a tuple with a tuple as the only field.

  Since it is not possible for zbus to differentiate between the case of a single structure being returned from the case of multiple out arguments returned as a named structure, nor to introspect the named structure type, the latter is not supported. you must use tuples for returning multiple values from a method.

• out_args - When returning multiple values from a method, naming the out arguments become important. You can use out_args for specifying names for your out arguments.

Note: a <property_name_in_snake_case>_changed method is generated for each property: this method emits the “PropertiesChanged” signal for the associated property. The setter (if it exists) will automatically call this method. For instance, a property setter named set_foo will be called to set the property “Foo”, and will emit the “PropertiesChanged” signal with the new value for “Foo”. Other changes to the “Foo” property can be signaled manually with the generated foo_changed method.

The method arguments offers some the following zbus attributes:

• object_server - This marks the method argument to receive a reference to the ObjectServer this method was called by.
• header - This marks the method argument to receive the message header associated with the D-Bus method call being handled.
• signal_context - This marks the method argument to receive a zbus::SignalContext instance, which is needed for emitting signals the easy way.

Example

use zbus_macros::dbus_interface;
use zbus::{ObjectServer, SignalContext, MessageHeader};

struct Example {
    some_data: String,
}

#[dbus_interface(name = "org.myservice.Example")]
impl Example {
    // "Quit" method. A method may throw errors.
    async fn quit(
        &self,
        #[zbus(header)]
        hdr: MessageHeader<'_>,
        #[zbus(signal_context)]
        ctxt: SignalContext<'_>,
        #[zbus(object_server)]
        _server: &ObjectServer,
    ) -> zbus::fdo::Result<()> {
        let path = hdr.path()?.unwrap();
        let msg = format!("You are leaving me on the {} path?", path);
        Example::bye(&ctxt, &msg);

        // Do some asynchronous tasks before quitting..

        Ok(())
    }

    // "TheAnswer" property (note: the "name" attribute), with its associated getter.
    // A `the_answer_changed` method has also been generated to emit the
    // "PropertiesChanged" signal for this property.
    #[dbus_interface(property, name = "TheAnswer")]
    fn answer(&self) -> u32 {
        2 * 3 * 7
    }

    // "Bye" signal (note: no implementation body).
    #[dbus_interface(signal)]
    async fn bye(signal_ctxt: &SignalContext<'_>, message: &str) -> zbus::Result<()>;

    #[dbus_interface(out_args("answer", "question"))]
    fn meaning_of_life(&self) -> zbus::fdo::Result<(i32, String)> {
        Ok((42, String::from("Meaning of life")))
    }
}

See also ObjectServer documentation to learn how to export an interface over a Connection.