Struct libpulse_tokio::TokioMain

pub struct TokioMain { /* private fields */ }

An implementation of the pulse Mainloop trait that dispatches through tokio.

Implementations

impl TokioMain

pub fn new() -> Self

pub fn tick(&mut self, ctx: &mut Context<'_>) -> Poll<Option<Retval>>

Run callbacks and register wakers for the pulse mainloop.

This returns Ready if a callback was invoked, or Pending if everything is waiting on timers or I/O. The async run() or wait_for_ready() functions call this function internally.

pub async fn wait_for_ready(&mut self, ctx: &Context) -> Result<State, Retval>

Run the mainloop until the given context is either Ready or Failed/Terminated.

When initializing a single Context object, this can be simpler use than registering a state callback. You will need to call run on another task to actually use the context.

pub async fn run(&mut self) -> Retval

Run the mainloop until a quit is requested through the pulse API

Trait Implementations

impl Debug for TokioMain

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

Formats the value using the given formatter.

impl Drop for TokioMain

fn drop(&mut self)

Executes the destructor for this type.

impl Mainloop for TokioMain

type MI = MainInner

Inner mainloop type.

fn inner(&self) -> Rc<MainInner>

Get inner mainloop.

fn new_io_event( &mut self, fd: i32, events: FlagSet, callback: Box<dyn FnMut(IoEventRef<Self::MI>, i32, FlagSet)> ) -> Option<IoEvent<Self::MI>>

Creates a new IO event.

fn new_timer_event( &mut self, tv: &UnixTs, callback: Box<dyn FnMut(TimeEventRef<Self::MI>)> ) -> Option<TimeEvent<Self::MI>>

Creates a new timer event.

fn new_timer_event_rt( &mut self, t: MonotonicTs, callback: Box<dyn FnMut(TimeEventRef<Self::MI>)> ) -> Option<TimeEvent<Self::MI>>

Creates a new monotonic-based timer event.

fn new_deferred_event( &mut self, callback: Box<dyn FnMut(DeferEventRef<Self::MI>)> ) -> Option<DeferEvent<Self::MI>>

Creates a new deferred event.

fn once_event(&mut self, callback: Box<dyn FnMut()>)

Runs the specified callback once from the main loop using an anonymous defer event.

fn quit(&mut self, retval: Retval)

Calls quit