Struct CentralSynchronousProxy

pub struct CentralSynchronousProxy { /* private fields */ }

Implementations

impl CentralSynchronousProxy

pub fn new(channel: Channel) -> Self

pub fn into_channel(self) -> Channel

pub fn wait_for_event( &self, deadline: MonotonicInstant, ) -> Result<CentralEvent, 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 listen_l2cap( &self, payload: ChannelListenerRegistryListenL2capRequest, ___deadline: MonotonicInstant, ) -> Result<ChannelListenerRegistryListenL2capResult, Error>

Register a listener for incoming channels. The registry will assign a PSM value that is unique for the local device, as well as open a [ChannelListener] for accepting incoming channels. In the unlikely event that all PSMs have been assigned, this call will fail with ZX_ERR_NO_RESOURCES.

Note that the method of service discovery or advertising is defined by the service or protocol, so it is the responsibility of the caller to communicate the assigned PSM to any clients.

pub fn scan( &self, options: &ScanOptions, result_watcher: ServerEnd<ScanResultWatcherMarker>, ___deadline: MonotonicInstant, ) -> Result<(), Error>

Scans for nearby LE peripherals and broadcasters. If the scan cannot be initiated, then result_watcher will be closed with an epitaph.

A Central client is allowed to have only one active scan at a time. Accordingly, only one Scan request can be outstanding at a time. Additional calls to Scan will fail.

The lifetime of the scan session is tied to the result_watcher protocol provided. The scan will be stopped if the channel is closed.

Once a scan is started, the [fuchsia.bluetooth.le/ScanResultWatcher] can be used to watch for scan results.

• request options Options used to configure the scan session.
• request result_watcher Protocol that remains valid for the duration of this scan session.

• response An empty response will be sent to acknowledge the scan has stopped.

The following epitaphs may be sent by the server on error:

• error ALREADY_EXISTS: A scan is already in progress. Each Central protocol is only allowed 1 active scan.
• error INVALID_ARGS: Some of the scan options are invalid. See the ScanOptions documentation.
• error INTERNAL: An internal error occurred and a scan could not be started.

pub fn connect( &self, id: &PeerId, options: &ConnectionOptions, handle: ServerEnd<ConnectionMarker>, ) -> Result<(), Error>

Connect to the peer with the given identifier.

The requested [fuchsia.bluetooth.le/Connection] represents the client’s interest on the LE connection to the peer. Closing the channel removes interest, but may not result in disconnection if another client holds a valid [fuchsia.bluetooth.le/Connection] to the same peer.

The [fuchsia.bluetooth.le/Connection] handle will be closed by the system if the connection to the peer is lost or an error occurs.

The following epitaphs may be sent by the server on error:

• INVALID_ARGS: Some of the parameters are invalid.

• ALREADY_BOUND: A Connection to the peer already exists for this Central. The existing Connection should be used.

• NOT_CONNECTED: A connection could not be established.

• CONNECTION_RESET: The peer disconnected.

• request id Identifier of the peer to initiate a connection to.

• request options Options used to configure the connection.

• request handle Handle that remains valid for the duration of this connection.

pub fn get_peripherals( &self, service_uuids: Option<&[String]>, ___deadline: MonotonicInstant, ) -> Result<Vec<RemoteDevice>, Error>

Returns the list of peripherals that are known to the system from previous scan, connection, and/or bonding procedures. The results can be filtered based on service UUIDs that are known to be present on the peripheral.

This method only returns peripherals (i.e. connectable devices).

pub fn get_peripheral( &self, identifier: &str, ___deadline: MonotonicInstant, ) -> Result<Option<Box<RemoteDevice>>, Error>

This method is not implemented by the Fuchsia core stack- TODO(https://fxbug.dev/42087303)

Returns information about a single peripheral that is known to the system from previous scan, connection, and/or bonding procedures based on its unique identifier. Returns null if identifier is not recognized.

pub fn start_scan( &self, filter: Option<&ScanFilter>, ___deadline: MonotonicInstant, ) -> Result<Status, Error>

Initiates a scan session for nearby peripherals and broadcasters. Discovered devices will be reported via CentralDelegate.OnDeviceDiscovered(). If a scan session is already in progress, filter will replace the existing session’s filter.

If filter is null or empty (i.e. none of its fields has been populated) then the delegate will be notified for all discoverable devices that are found. This is not recommended; clients should generally filter results by at least one of filter.service_uuids, filter.service_data, and/or filter.manufacturer_identifier.

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

Terminate a previously started scan session.

pub fn connect_peripheral( &self, identifier: &str, options: &ConnectionOptions, gatt_client: ServerEnd<ClientMarker>, ___deadline: MonotonicInstant, ) -> Result<Status, Error>

Creates a connection to the peripheral device with the given identifier. Returns the status of the operation in status.

On success, gatt_client will be bound and can be used for GATT client role procedures. On failure, gatt_client will be closed and status will indicate an error.

pub fn disconnect_peripheral( &self, identifier: &str, ___deadline: MonotonicInstant, ) -> Result<Status, Error>

Disconnects this Central’s connection to the peripheral with the given identifier.

Trait Implementations

impl Debug for CentralSynchronousProxy

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

Formats the value using the given formatter.

impl SynchronousProxy for CentralSynchronousProxy

type Proxy = CentralProxy

The async proxy for the same protocol.

type Protocol = CentralMarker

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.