Struct DeviceProxy

pub struct DeviceProxy { /* private fields */ }

Implementations

impl DeviceProxy

pub fn new(channel: AsyncChannel) -> Self

Create a new Proxy for fuchsia.hardware.input/Device.

pub fn take_event_stream(&self) -> DeviceEventStream

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

Panics

Panics if the event stream was already taken.

pub fn query( &self, ) -> QueryResponseFut<DeviceQueryResult, DefaultFuchsiaResourceDialect>

Obtain information about the hidbus device and supported features.

pub fn get_report_desc( &self, ) -> QueryResponseFut<Vec<u8>, DefaultFuchsiaResourceDialect>

Get the report descriptor

pub fn get_device_reports_reader( &self, reader: ServerEnd<DeviceReportsReaderMarker>, ) -> QueryResponseFut<DeviceGetDeviceReportsReaderResult, DefaultFuchsiaResourceDialect>

Open a new DeviceReportsReader on this device. Opening a DeviceReportsReader allocates a new FIFO for receiving input reports.

pub fn read_report( &self, ) -> QueryResponseFut<DeviceReadReportResult, DefaultFuchsiaResourceDialect>

Read one report out of the report FIFO. Only a single report will be returned in this API. time is the time the report was created, from the view of the monotonic clock. If status is ZX_ERR_SHOULD_WAIT the client can wait on the event from GetReportsEvent.

pub fn read_reports( &self, ) -> QueryResponseFut<DeviceReadReportsResult, DefaultFuchsiaResourceDialect>

Read up to MAX_REPORT_DATA bytes of reports that have been sent from a device. This is the interface that is supposed to be used for continuous polling. Multiple reports can be returned from this API at a time, it is up to the client to do the parsing of the reports with the correct sizes and offset. It is guaranteed that only whole reports will be sent. If there are no reports, this will return ZX_ERR_SHOULD_WAIT, and the client can wait on the event from GetReportsEvent.

pub fn get_reports_event( &self, ) -> QueryResponseFut<DeviceGetReportsEventResult, DefaultFuchsiaResourceDialect>

Receive an event that will signal on ZX_USER_SIGNAL_0 when there are reports in the Device’s report FIFO. This signal will be de-asserted when there are no reports in the Device’s report FIFO. This event can be re-used each time the client wishes to know if there are reports in the FIFO.

pub fn get_report( &self, type_: ReportType, id: u8, ) -> QueryResponseFut<DeviceGetReportResult, DefaultFuchsiaResourceDialect>

Send a request to the hardware for a given report described by type and id. Returns the hardware’s response. This interface is not intended to be used for continuous polling of the reports.

pub fn set_report( &self, type_: ReportType, id: u8, report: &[u8], ) -> QueryResponseFut<DeviceSetReportResult, DefaultFuchsiaResourceDialect>

Set a single report of the given (type, id) pair.

pub fn set_trace_id(&self, id: u32) -> Result<(), Error>

Set the trace ID that is used for HID report flow events.

Trait Implementations

impl Clone for DeviceProxy

fn clone(&self) -> DeviceProxy

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DeviceProxy

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

Formats the value using the given formatter.

impl DeviceProxyInterface for DeviceProxy

type QueryResponseFut = QueryResponseFut<Result<HidInfo, i32>>

type GetReportDescResponseFut = QueryResponseFut<Vec<u8>>

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

type ReadReportResponseFut = QueryResponseFut<Result<Report, i32>>

type ReadReportsResponseFut = QueryResponseFut<Result<Vec<u8>, i32>>

type GetReportsEventResponseFut = QueryResponseFut<Result<Event, i32>>

type GetReportResponseFut = QueryResponseFut<Result<Vec<u8>, i32>>

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

fn query(&self) -> Self::QueryResponseFut

fn get_report_desc(&self) -> Self::GetReportDescResponseFut

fn get_device_reports_reader( &self, reader: ServerEnd<DeviceReportsReaderMarker>, ) -> Self::GetDeviceReportsReaderResponseFut

fn read_report(&self) -> Self::ReadReportResponseFut

fn read_reports(&self) -> Self::ReadReportsResponseFut

fn get_reports_event(&self) -> Self::GetReportsEventResponseFut

fn get_report(&self, type_: ReportType, id: u8) -> Self::GetReportResponseFut

fn set_report( &self, type_: ReportType, id: u8, report: &[u8], ) -> Self::SetReportResponseFut

fn set_trace_id(&self, id: u32) -> Result<(), Error>

impl Proxy for DeviceProxy

type Protocol = DeviceMarker

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.