Struct SessionProxy 

pub struct SessionProxy { /* private fields */ }

Implementations

impl SessionProxy

pub fn new(channel: AsyncChannel) -> Self

Create a new Proxy for fuchsia.driver.lab/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 read32( &self, resource: u32, offset: u64, ) -> QueryResponseFut<SessionRead32Result, DefaultFuchsiaResourceDialect>

One policy-checked, audited 32-bit read.

pub fn snapshot( &self, items: &[SnapshotItem], ) -> QueryResponseFut<SessionSnapshotResult, DefaultFuchsiaResourceDialect>

Bounded snapshot: every item is validated before the first read.

pub fn read_audit( &self, cursor: u64, limit: u32, ) -> QueryResponseFut<(Vec<AuditEntry>, bool, u64, u64), DefaultFuchsiaResourceDialect>

Reads a bounded audit page so the host can drain incrementally and detect gaps.

pub fn write32( &self, resource: u32, offset: u64, value: u32, write_mask: u32, precondition: Option<&WritePrecondition>, readback: bool, ) -> QueryResponseFut<SessionWrite32Result, DefaultFuchsiaResourceDialect>

One policy-checked, audited 32-bit write with optional precondition, read-modify-write, barrier, and readback.

pub fn poll32( &self, resource: u32, offset: u64, expected: u32, mask: u32, interval_ns: i64, timeout_ns: i64, ) -> QueryResponseFut<SessionPoll32Result, DefaultFuchsiaResourceDialect>

Repeated bounded read until (value & mask) == (expected & mask) or timeout. Uses asynchronous timers on the driver dispatcher.

pub fn execute_sequence( &self, items: &[SequenceItem], ) -> QueryResponseFut<SessionExecuteSequenceResult, DefaultFuchsiaResourceDialect>

Bounded ordered sequence of operations. Whole-sequence validation occurs before any hardware operation begins.

pub fn gpio_read( &self, resource: u32, ) -> QueryResponseFut<SessionGpioReadResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited GPIO read.

pub fn gpio_write( &self, resource: u32, value: bool, ) -> QueryResponseFut<SessionGpioWriteResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited GPIO write. Requires mutation lease.

pub fn i2c_transfer( &self, resource: u32, write_data: &[u8], read_length: u32, ) -> QueryResponseFut<SessionI2cTransferResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited I2C transfer. Non-empty write requires mutation lease.

pub fn spi_transmit( &self, resource: u32, tx_data: &[u8], ) -> QueryResponseFut<SessionSpiTransmitResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited SPI transmit. Requires mutation lease.

pub fn open_gpio( &self, resource: u32, endpoint: ServerEnd<GpioEndpointMarker>, ) -> QueryResponseFut<SessionOpenGpioResult, DefaultFuchsiaResourceDialect>

Opens a typed GPIO endpoint bound to this session.

pub fn open_i2c( &self, resource: u32, endpoint: ServerEnd<I2cEndpointMarker>, ) -> QueryResponseFut<SessionOpenI2cResult, DefaultFuchsiaResourceDialect>

Opens a typed I2C endpoint bound to this session.

pub fn open_spi( &self, resource: u32, endpoint: ServerEnd<SpiEndpointMarker>, ) -> QueryResponseFut<SessionOpenSpiResult, DefaultFuchsiaResourceDialect>

Opens a typed SPI endpoint bound to this session.

pub fn wait_for_interrupt( &self, resource: u32, after_sequence: u64, timeout_ns: i64, ) -> QueryResponseFut<SessionWaitForInterruptResult, DefaultFuchsiaResourceDialect>

Observes an interrupt event. Bounded hanging request that yields when the interrupt sequence exceeds after_sequence or upon timeout.

pub fn clock_enable( &self, resource: u32, ) -> QueryResponseFut<SessionClockEnableResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited Clock enable. Requires mutation lease.

pub fn clock_disable( &self, resource: u32, ) -> QueryResponseFut<SessionClockDisableResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited Clock disable. Requires mutation lease.

pub fn clock_is_enabled( &self, resource: u32, ) -> QueryResponseFut<SessionClockIsEnabledResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited Clock is_enabled query.

pub fn clock_set_rate( &self, resource: u32, hz: u64, ) -> QueryResponseFut<SessionClockSetRateResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited Clock set_rate. Requires mutation lease.

pub fn clock_query_rate( &self, resource: u32, hz_in: u64, ) -> QueryResponseFut<SessionClockQueryRateResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited Clock query_supported_rate query.

pub fn clock_get_rate( &self, resource: u32, ) -> QueryResponseFut<SessionClockGetRateResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited Clock get_rate query.

pub fn reset_assert( &self, resource: u32, ) -> QueryResponseFut<SessionResetAssertResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited Reset assert. Requires mutation lease.

pub fn reset_deassert( &self, resource: u32, ) -> QueryResponseFut<SessionResetDeassertResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited Reset deassert. Requires mutation lease.

pub fn reset_toggle( &self, resource: u32, ) -> QueryResponseFut<SessionResetToggleResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited Reset toggle. Requires mutation lease.

pub fn reset_status( &self, resource: u32, ) -> QueryResponseFut<SessionResetStatusResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited Reset status query.

pub fn serial_read( &self, resource: u32, ) -> QueryResponseFut<SessionSerialReadResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited Serial read.

pub fn serial_write( &self, resource: u32, data: &[u8], ) -> QueryResponseFut<SessionSerialWriteResult, DefaultFuchsiaResourceDialect>

One policy-checked, audited Serial write. Requires mutation lease.

Trait Implementations

impl Clone for SessionProxy

fn clone(&self) -> Self

Returns a duplicate 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<'_, NullableHandle>>

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

impl SessionProxyInterface for SessionProxy

type Read32ResponseFut = QueryResponseFut<Result<(u32, u64, i64), OperationError>>

type SnapshotResponseFut = QueryResponseFut<Result<(Vec<SnapshotItemResult>, bool), OperationError>>

type ReadAuditResponseFut = QueryResponseFut<(Vec<AuditEntry>, bool, u64, u64)>

type Write32ResponseFut = QueryResponseFut<Result<(u32, u64, i64), OperationError>>

type Poll32ResponseFut = QueryResponseFut<Result<(u32, u64, i64), OperationError>>

type ExecuteSequenceResponseFut = QueryResponseFut<Result<(Vec<SequenceItemResult>, bool), OperationError>>

type GpioReadResponseFut = QueryResponseFut<Result<(bool, u64, i64), OperationError>>

type GpioWriteResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

type I2cTransferResponseFut = QueryResponseFut<Result<(Vec<u8>, u64, i64), OperationError>>

type SpiTransmitResponseFut = QueryResponseFut<Result<(Vec<u8>, u64, i64), OperationError>>

type OpenGpioResponseFut = QueryResponseFut<Result<(), OperationError>>

type OpenI2cResponseFut = QueryResponseFut<Result<(), OperationError>>

type OpenSpiResponseFut = QueryResponseFut<Result<(), OperationError>>

type WaitForInterruptResponseFut = QueryResponseFut<Result<(u32, u64, u64, i64, u64), OperationError>>

type ClockEnableResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

type ClockDisableResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

type ClockIsEnabledResponseFut = QueryResponseFut<Result<(bool, u64, i64), OperationError>>

type ClockSetRateResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

type ClockQueryRateResponseFut = QueryResponseFut<Result<(u64, u64, i64), OperationError>>

type ClockGetRateResponseFut = QueryResponseFut<Result<(u64, u64, i64), OperationError>>

type ResetAssertResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

type ResetDeassertResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

type ResetToggleResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

type ResetStatusResponseFut = QueryResponseFut<Result<(bool, u64, i64), OperationError>>

type SerialReadResponseFut = QueryResponseFut<Result<(Vec<u8>, u64, i64), OperationError>>

type SerialWriteResponseFut = QueryResponseFut<Result<(u64, i64), OperationError>>

fn read32(&self, resource: u32, offset: u64) -> Self::Read32ResponseFut

fn snapshot(&self, items: &[SnapshotItem]) -> Self::SnapshotResponseFut

fn read_audit(&self, cursor: u64, limit: u32) -> Self::ReadAuditResponseFut

fn write32( &self, resource: u32, offset: u64, value: u32, write_mask: u32, precondition: Option<&WritePrecondition>, readback: bool, ) -> Self::Write32ResponseFut

fn poll32( &self, resource: u32, offset: u64, expected: u32, mask: u32, interval_ns: i64, timeout_ns: i64, ) -> Self::Poll32ResponseFut

fn execute_sequence( &self, items: &[SequenceItem], ) -> Self::ExecuteSequenceResponseFut

fn gpio_read(&self, resource: u32) -> Self::GpioReadResponseFut

fn gpio_write(&self, resource: u32, value: bool) -> Self::GpioWriteResponseFut

fn i2c_transfer( &self, resource: u32, write_data: &[u8], read_length: u32, ) -> Self::I2cTransferResponseFut

fn spi_transmit( &self, resource: u32, tx_data: &[u8], ) -> Self::SpiTransmitResponseFut

fn open_gpio( &self, resource: u32, endpoint: ServerEnd<GpioEndpointMarker>, ) -> Self::OpenGpioResponseFut

fn open_i2c( &self, resource: u32, endpoint: ServerEnd<I2cEndpointMarker>, ) -> Self::OpenI2cResponseFut

fn open_spi( &self, resource: u32, endpoint: ServerEnd<SpiEndpointMarker>, ) -> Self::OpenSpiResponseFut

fn wait_for_interrupt( &self, resource: u32, after_sequence: u64, timeout_ns: i64, ) -> Self::WaitForInterruptResponseFut

fn clock_enable(&self, resource: u32) -> Self::ClockEnableResponseFut

fn clock_disable(&self, resource: u32) -> Self::ClockDisableResponseFut

fn clock_is_enabled(&self, resource: u32) -> Self::ClockIsEnabledResponseFut

fn clock_set_rate( &self, resource: u32, hz: u64, ) -> Self::ClockSetRateResponseFut

fn clock_query_rate( &self, resource: u32, hz_in: u64, ) -> Self::ClockQueryRateResponseFut

fn clock_get_rate(&self, resource: u32) -> Self::ClockGetRateResponseFut

fn reset_assert(&self, resource: u32) -> Self::ResetAssertResponseFut

fn reset_deassert(&self, resource: u32) -> Self::ResetDeassertResponseFut

fn reset_toggle(&self, resource: u32) -> Self::ResetToggleResponseFut

fn reset_status(&self, resource: u32) -> Self::ResetStatusResponseFut

fn serial_read(&self, resource: u32) -> Self::SerialReadResponseFut

fn serial_write( &self, resource: u32, data: &[u8], ) -> Self::SerialWriteResponseFut