Struct zbus::Proxy

pub struct Proxy<'a> { /* fields omitted */ }

A client-side interface proxy.

A Proxy is a helper to interact with an interface on a remote object.

Example

use std::result::Result;
use std::error::Error;
use zbus::{Connection, Proxy};

fn main() -> Result<(), Box<dyn Error>> {
    let connection = Connection::new_session()?;
    let p = Proxy::new(
        &connection,
        "org.freedesktop.DBus",
        "/org/freedesktop/DBus",
        "org.freedesktop.DBus",
    )?;
    // owned return value
    let _id: String = p.call("GetId", &())?;
    // borrowed return value
    let _id: &str = p.call_method("GetId", &())?.body()?;
    Ok(())
}

Note

It is recommended to use the dbus_proxy macro, which provides a more convenient and type-safe façade Proxy derived from a Rust trait.

Current limitations:

At this point, the Proxy is "simple". Notably, it doesn't:

• have any signal handling
• cache properties
• track the current name owner
• prevent auto-launching

Implementations

impl<'a> Proxy<'a>

pub fn new(
    conn: &Connection,
    destination: &'a str,
    path: &'a str,
    interface: &'a str
) -> Result<Self>

Create a new Proxy for the given destination/path/interface.

pub fn new_owned(
    conn: Connection,
    destination: String,
    path: String,
    interface: String
) -> Result<Self>

Create a new Proxy for the given destination/path/interface, taking ownership of all passed arguments.

pub fn introspect(&self) -> Result<String>

Introspect the associated object, and return the XML description.

See the xml module for parsing the result.

pub fn get_property<T>(&self, property_name: &str) -> Result<T> where
    T: TryFrom<OwnedValue>, 

Get the property property_name.

Effectively, call the Get method of the org.freedesktop.DBus.Properties interface.

pub fn set_property<'t, T: 't>(
    &self,
    property_name: &str,
    value: T
) -> Result<()> where
    T: Into<Value<'t>>, 

Set the property property_name.

Effectively, call the Set method of the org.freedesktop.DBus.Properties interface.

pub fn call_method<B>(&self, method_name: &str, body: &B) -> Result<Message> where
    B: Serialize + Type, 

Call a method and return the reply.

Typically, you would want to use call method instead. Use this method if you need to deserialize the reply message manually (this way, you can avoid avoid the memory allocation/copying, by deserializing the reply to an unowned type).

pub fn call<B, R>(&self, method_name: &str, body: &B) -> Result<R> where
    B: Serialize + Type,
    R: DeserializeOwned + Type, 

Call a method and return the reply body.

Use call_method instead if you need to deserialize the reply manually/separately.