Struct dbus::blocking::Proxy

pub struct Proxy<'a, C> {
    pub destination: BusName<'a>,
    pub path: Path<'a>,
    pub timeout: Duration,
    pub connection: C,
}

A struct that wraps a connection, destination and path.

A D-Bus "Proxy" is a client-side object that corresponds to a remote object on the server side. Calling methods on the proxy object calls methods on the remote object. Read more in the D-Bus tutorial

Fields

destination: BusName<'a>

Destination, i e what D-Bus service you're communicating with

path: Path<'a>

Object path on the destination

timeout: Duration

Timeout for method calls

connection: C

Some way to send and/or receive messages, either blocking or non-blocking.

Implementations

impl<'a, C> Proxy<'a, C>

pub fn new<D: Into<BusName<'a>>, P: Into<Path<'a>>>(
    dest: D,
    path: P,
    timeout: Duration,
    connection: C
) -> Self

Creates a new proxy struct.

impl<'a, T: BlockingSender, C: Deref<Target = T>> Proxy<'a, C>

pub fn method_call<'i, 'm, R: ReadAll, A: AppendAll, I: Into<Interface<'i>>, M: Into<Member<'m>>>(
    &self,
    i: I,
    m: M,
    args: A
) -> Result<R, Error>

Make a method call using typed input and output arguments, then block waiting for a reply.

Example

use dbus::blocking::{Connection, Proxy};

let conn = Connection::new_session()?;
let proxy = Proxy::new("org.freedesktop.DBus", "/", std::time::Duration::from_millis(5000), &conn);
let (has_owner,): (bool,) = proxy.method_call("org.freedesktop.DBus", "NameHasOwner", ("dummy.name.without.owner",))?;
assert_eq!(has_owner, false);

pub fn match_start(
    &self,
    mr: MatchRule<'static>,
    call_add_match: bool,
    f: <T as MatchingReceiver>::F
) -> Result<Token, Error> where
    T: MatchingReceiver, 

Starts matching incoming messages on this destination and path.

For matching signals, match_signal might be more convenient.

The match rule will be modified to include this path and destination only.

If call_add_match is true, will notify the D-Bus server that matching should start.

pub fn match_stop(
    &self,
    id: Token,
    call_remove_match: bool
) -> Result<(), Error> where
    T: MatchingReceiver, 

Stops matching a signal added with match_start or match_signal.

If call_remove_match is true, will notify the D-Bus server that matching should stop, this should be true in case match_signal was used.

pub fn match_signal<S: SignalArgs + ReadAll, F>(
    &self,
    f: F
) -> Result<Token, Error> where
    T: MatchingReceiver,
    F: MakeSignal<<T as MatchingReceiver>::F, S, T>, 

Sets up an incoming signal match, that calls the supplied callback every time the signal is received.

The returned value can be used to remove the match. The match is also removed if the callback returns "false".

Trait Implementations

impl<'a, C: Clone> Clone for Proxy<'a, C>

fn clone(&self) -> Proxy<'a, C>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, C: Debug> Debug for Proxy<'a, C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, T: BlockingSender, C: Deref<Target = T>> Introspectable for Proxy<'a, C>

fn introspect(&self) -> Result<String, Error>

impl<'a, T: BlockingSender, C: Deref<Target = T>> ObjectManager for Proxy<'a, C>

fn get_managed_objects(
    &self
) -> Result<HashMap<Path<'static>, HashMap<String, PropMap>>, Error>

impl<'a, T: BlockingSender, C: Deref<Target = T>> Peer for Proxy<'a, C>

fn ping(&self) -> Result<(), Error>

fn get_machine_id(&self) -> Result<String, Error>

impl<'a, T: BlockingSender, C: Deref<Target = T>> Properties for Proxy<'a, C>

fn get<R0: for<'b> Get<'b> + 'static>(
    &self,
    interface_name: &str,
    property_name: &str
) -> Result<R0, Error>

fn get_all(&self, interface_name: &str) -> Result<PropMap, Error>

fn set<I2: Arg + Append>(
    &self,
    interface_name: &str,
    property_name: &str,
    value: I2
) -> Result<(), Error>