Struct SessionProxy

pub struct SessionProxy { /* private fields */ }

Implementations

impl SessionProxy

pub fn new(channel: AsyncChannel) -> Self

Create a new Proxy for fuchsia.hardware.network/Session.

pub fn take_event_stream(&self) -> SessionEventStream

Get a Stream of events from the remote end of the protocol.

Panics

Panics if the event stream was already taken.

pub fn attach( &self, port: &PortId, rx_frames: &[FrameType], ) -> QueryResponseFut<SessionAttachResult, DefaultFuchsiaResourceDialect>

Attaches the session to port.

Once attached, the session starts to receive the subscribed frames over the data FIFOs and it may send frames destined to the specified port.

• request port port to subscribe to.
• request rx_frames Frame types of interest on the port.

• error ZX_ERR_NOT_FOUND if port is not valid.
• error ZX_ERR_INVALID_ARGS if rx_frames is not a subset of the port’s supported frames.
• error ZX_ERR_ALREADY_BOUND if port is already attached.

pub fn detach( &self, port: &PortId, ) -> QueryResponseFut<SessionDetachResult, DefaultFuchsiaResourceDialect>

Detaches the session from port.

Once detached, the session stops receiving frames from port. Frames sent to a detached port may be returned with an error. It is not necessary to call Detach on ports that are removed from the device, doing so causes ZX_ERR_NOT_FOUND to be returned.

• request port port to subscribe to.

• error ZX_ERR_NOT_FOUND if the session is not currently attached to the port.

pub fn close(&self) -> Result<(), Error>

Cleanly closes a session.

This will cause the session to send a ZX_ERR_CANCELLED epitaph and proceed to close the Session channel. Clients may only assume that they own all the buffers that are currently owned by the session (sent over either the rx or tx FIFOs) once the epitaph is received. Closing the rx or tx FIFO is equivalent to calling Close.

pub fn watch_delegated_rx_lease( &self, ) -> QueryResponseFut<DelegatedRxLease, DefaultFuchsiaResourceDialect>

Watchers for delegated receive wakeup leases.

Calls block until a lease is delegated by the device. If a call to WatchDelegatedRxLease is made while a previous call is blocking, the session is closed with ZX_ERR_BAD_STATE. Will never yield any values for sessions created without [SessionFlags.RECEIVE_RX_POWER_LEASES].

Given a single lease is assumed sufficient to keep the system awake, the server only keeps a single lease in its buffer. If a new delegated lease becomes available and the client hasn’t popped the previous one with a call to WatchDelegatedRxLease, the server drops the previously pending lease.

See DelegatedRxLease for how to handle delegated leases.

Trait Implementations

impl Clone for SessionProxy

fn clone(&self) -> SessionProxy

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SessionProxy

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

Formats the value using the given formatter.

impl Proxy for SessionProxy

type Protocol = SessionMarker

The protocol which this Proxy controls.

fn from_channel(inner: AsyncChannel) -> Self

Create a proxy over the given channel.

fn into_channel(self) -> Result<AsyncChannel, Self>

Attempt to convert the proxy back into a channel.

fn as_channel(&self) -> &AsyncChannel

Get a reference to the proxy’s underlying channel.

fn into_client_end(self) -> Result<ClientEnd<Self::Protocol>, Self>

Attempt to convert the proxy back into a client end.

fn is_closed(&self) -> bool

Returns true if the proxy has received the PEER_CLOSED signal.

fn on_closed(&self) -> OnSignals<'_, Unowned<'_, Handle>>

Returns a future that completes when the proxy receives the PEER_CLOSED signal.

impl SessionProxyInterface for SessionProxy

type AttachResponseFut = QueryResponseFut<Result<(), i32>>

type DetachResponseFut = QueryResponseFut<Result<(), i32>>

type WatchDelegatedRxLeaseResponseFut = QueryResponseFut<DelegatedRxLease>

fn attach( &self, port: &PortId, rx_frames: &[FrameType], ) -> Self::AttachResponseFut

fn detach(&self, port: &PortId) -> Self::DetachResponseFut

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

fn watch_delegated_rx_lease(&self) -> Self::WatchDelegatedRxLeaseResponseFut