Struct SuspenderSynchronousProxy

pub struct SuspenderSynchronousProxy { /* private fields */ }

Implementations

impl SuspenderSynchronousProxy

pub fn new(channel: Channel) -> Self

pub fn into_channel(self) -> Channel

pub fn wait_for_event( &self, deadline: MonotonicInstant, ) -> Result<SuspenderEvent, Error>

Waits until an event arrives and returns it. It is safe for other threads to make concurrent requests while waiting for an event.

pub fn get_suspend_states( &self, ___deadline: MonotonicInstant, ) -> Result<SuspenderGetSuspendStatesResult, Error>

Returns a list of [fuchsia.hardware.suspend/SuspendState] supported. by the system. The system must return at least 1 suspend state which corresponds to the “suspend-to-idle” state but may return up to [fuchsia.hardware.suspend/MAX_SUSPEND_STATES] states. The suspend states must be ordered in order of decreasing resume_latency (and thereby increasing power consumption). A particular build of the system must always return the same set of suspend states.

pub fn suspend( &self, payload: &SuspenderSuspendRequest, ___deadline: MonotonicInstant, ) -> Result<SuspenderSuspendResult, Error>

Instruct the system to suspend. This call may return a ZX_ERR_* if the system was unable to suspend. If the call succeeds, it will not return until the system has resumed. Being interrupted while suspending and resuming before fully suspending is not an error however suspend_duration must be None if the suspend was interrupted.

Trait Implementations

impl Debug for SuspenderSynchronousProxy

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

Formats the value using the given formatter.

impl SynchronousProxy for SuspenderSynchronousProxy

type Proxy = SuspenderProxy

The async proxy for the same protocol.

type Protocol = SuspenderMarker

The protocol which this Proxy controls.

fn from_channel(inner: Channel) -> Self

Create a proxy over the given channel.

fn into_channel(self) -> Channel

Convert the proxy back into a channel.

fn as_channel(&self) -> &Channel

Get a reference to the proxy’s underlying channel.

fn is_closed(&self) -> Result<bool, Status>

Returns true if the proxy has received the PEER_CLOSED signal.