Struct dbus::nonblock::Connection

pub struct Connection { /* private fields */ }

A connection to D-Bus, async version, which is Send but not Sync.

Implementations

impl Connection

pub fn unique_name(&self) -> BusName<'_>

Get the connection’s unique name.

It’s usually something like “:1.54”

pub async fn request_name<'a, N: Into<BusName<'a>>>(
    &self,
    name: N,
    allow_replacement: bool,
    replace_existing: bool,
    do_not_queue: bool
) -> Result<RequestNameReply, Error>

Request a name on the D-Bus.

For detailed information on the flags and return values, see the libdbus documentation.

pub async fn release_name<'a, N: Into<BusName<'a>>>(
    &self,
    name: N
) -> Result<ReleaseNameReply, Error>

Release a previously requested name on the D-Bus.

pub async fn add_match(
    &self,
    match_rule: MatchRule<'static>
) -> Result<MsgMatch, Error>

Adds a new match to the connection, and sets up a callback when this message arrives.

If multiple MatchRules match the same message, then by default only the first will get the callback. This behaviour can be changed for signal messages by calling set_signal_match_mode.

The returned value can be used to remove the match.

pub async fn add_match_no_cb(&self, match_str: &str) -> Result<(), Error>

Adds a new match to the connection, without setting up a callback when this message arrives.

pub async fn remove_match_no_cb(&self, match_str: &str) -> Result<(), Error>

Removes a match from the connection, without removing any callbacks.

pub async fn remove_match(&self, id: Token) -> Result<(), Error>

Removes a previously added match and callback from the connection.

pub fn set_signal_match_mode(&self, match_all: bool)

If true, configures the connection to send signal messages to all matching MatchRule filters added with add_match rather than just the first one. This comes with the following gotchas:

• The messages might be duplicated, so the message serial might be lost (this is generally not a problem for signals).
• Panicking inside a match callback might mess with other callbacks, causing them to be permanently dropped.
• Removing other matches from inside a match callback is not supported.

This is false by default, for a newly-created connection.

Trait Implementations

impl AsRef<Channel> for Connection

fn as_ref(&self) -> &Channel

Converts this type into a shared reference of the (usually inferred) input type.

impl From<Channel> for Connection

fn from(x: Channel) -> Self

Converts to this type from the input type.

impl MatchingReceiver for Connection

type F = Box<dyn FnMut(Message, &Connection) -> bool + Send + 'static, Global>

Type of callback

fn start_receive(&self, m: MatchRule<'static>, f: Self::F) -> Token

Add a callback to be called in case a message matches.

fn stop_receive(&self, id: Token) -> Option<(MatchRule<'static>, Self::F)>

Remove a previously added callback.

impl NonblockReply for Connection

type F = Box<dyn FnOnce(Message, &Connection) + Send + 'static, Global>

Callback type

fn send_with_reply(&self, msg: Message, f: Self::F) -> Result<Token, ()>

Sends a message and calls the callback when a reply is received.

fn cancel_reply(&self, id: Token) -> Option<Self::F>

Cancels a pending reply.

fn make_f<G: FnOnce(Message, &Self) + Send + 'static>(g: G) -> Self::F

Internal helper function that creates a callback.

fn timeout_maker(&self) -> Option<TimeoutMakerCb>

Get the internal timeout maker

fn set_timeout_maker(
    &mut self,
    f: Option<TimeoutMakerCb>
) -> Option<TimeoutMakerCb>

Set the internal timeout maker

fn set_waker(&mut self, f: Option<WakerCb>) -> Option<WakerCb>

Set the wakeup call

impl Process for Connection

fn process_one(&self, msg: Message)

Dispatches a message.

fn process_all(&self)

Dispatches all pending messages, without blocking.

impl Sender for Connection

fn send(&self, msg: Message) -> Result<u32, ()>

Schedules a message for sending.