dbus-async-derive

dbus-async-derive is a proc derive macro to implement the dbus_async::Handler. This crate should be used to create a DBus service.

Usage

Add this to your Cargo.toml: toml [dependencies] dbus-async-derive = "1.0" async-trait = "0.1"

Example

The following example show how to create a DBus sevice with the interface org.example.interface. This interface has a method ExampleMethod and a property ExampleProperty. The object is avaiable at /org/example/object/path. ```rust use dbusasync::{Binder, DBus}; use dbusasyncderive::Handler; use dbusmessage_parser::MessageHeader;

[derive(Handler)]

[interface(

"org.example.interface",
method("ExampleMethod", method),
property("ExampleProperty", "s", get_property = "get", set_property = "set")

)] struct DBusObject { property: String, }

impl DBusObject { async fn method( &mut self, dbus: &DBus, msgheader: &MessageHeader, ) -> Result<(), (String, String)> { // The code of the method println!( "The DBus socket where the message came from: {}", dbus.getsocketpath() ); // ... Ok(()) }

async fn get_property(
    &mut self,
    _dbus: &DBus,
    _msg_header: &MessageHeader,
) -> Result<String, (String, String)> {
    Ok(self.property.clone())
}

async fn set_property(
    &mut self,
    _dbus: &DBus,
    _msg_header: &MessageHeader,
    new_value: String,
) -> Result<(), (String, String)> {
    self.property = new_value;
    Ok(())
}

}

[tokio::main]

async fn main() { let (dbus, connectionjoinhandle) = DBus::session(true) .await .expect("failed to get the DBus object"); // Create the object let dbusobject = DBusObject { property: "".tostring(), }; let objectpath = "/org/example/object/path"; // Bind the same object to the second object path dbusobject .bind(dbus, objectpath) .await .expect("Something went wrong"); } ```