Struct tokio_dbus::Client

pub struct Client { /* private fields */ }

An asynchronous D-Bus client.

Implementations

impl Client

pub async fn session_bus() -> Result<Self>

Shorthand for connecting the client to the system bus using the default configuration.

pub async fn system_bus() -> Result<Self>

Shorthand for connecting the client to the system bus using the default configuration.

pub async fn process(&mut self) -> Result<MessageRef, Error>

Process the current connection.

This is the main entry of this connection, and is required to call to have it make progress when passing D-Bus messages.

Examples

use tokio_dbus::{Client, Message};

let mut c = Client::session_bus().await?;

let message = c.process().await?;
let message: Message<'_> = c.read_message(&message)?;

pub async fn flush(&mut self) -> Result<(), Error>

Flush all outgoing messages and return when the send buffer is empty.

Examples

use tokio_dbus::Client;

let mut c = Client::session_bus().await?;
c.flush().await?;

pub fn method_call<'a>( &mut self, path: &'a ObjectPath, member: &'a str ) -> Message<'a>

Construct a new Message corresponding to a method call.

pub fn write_message(&mut self, message: &Message<'_>) -> Result<()>

Write a message to the send buffer.

This can be used to queue messages to be sent during the next call to process(). To both receive and send in parallel, see the buffers() method.

pub fn read_message(&self, message_ref: &MessageRef) -> Result<Message<'_>>

Read a MessageRef into a Message.

Note that if the MessageRef is outdated by calling process again, the behavior of this function is not well-defined (but safe).

Errors

Errors if the message reference is out of date, such as if another message has been received.

pub fn buffers(&mut self) -> (&RecvBuf, &mut SendBuf, &mut BodyBuf)

Access the underlying buffers of the connection.

This is usually needed to solve lifetime issues, such as holding onto a message constructed from a MessageRef while buffering a response.

The RecvBuf is used to translate MessageRef as returned by process() into Message instances and SendBuf is used to queue messages to be sent.

The returned BodyBuf is the internal buffer that the client uses to construct message bodies. It is empty when it’s returned.

pub async fn request_name( &mut self, name: &str, flags: NameFlag ) -> Result<NameReply>

Request the given well-known name.