Struct Registry 

pub struct Registry;

The type corresponding to the Registry protocol. A coordination mechanism to clearly define the injecting of pointer events into the scene (injection policy, injection context, etc), for dispatching pointer events to UI clients (referenced by |fuchsia.ui.views.ViewRef|).

NOTE WELL! ONLY COMPONENTS IN THE TRUSTED COMPUTING BASE SHOULD BE GRANTED ACCESS TO THIS PROTOCOL. (1) The injector device acts with the user’s authority. UI clients cannot tell the difference between a real user and an injector device. (2) The context is self-specified when registering the injector device. An injector device that gains access to a sensitive context will operate in that scope. (3) The injected events may be arbitrary. An injector device can inject whatever it wants to the clients it can reach.

This protocol defines the context and target for an injector |Device|, places a viewport in spatial relation to the target, and connects the |Device| to the viewport. These parameters are set up in the |Config|. A |Device| may inject pointer events on the viewport, but the dispatch of pointer events to UI clients in the target will depend on the dispatch policy and the scene topology.

A |Device| operates within a context, and it serves two purposes: (1) Scoping. It confirms the |Device|’s authority to inject pointer events on the specified target. (2) Coordinate system. It provides the reference coordinate system to define the viewport’s position and size, relative to the target.

Guarantees. A |Device| is directed at a specified target in the scene, and such a target is afforded some guarantees against snooping and interference from UI clients outside the target’s view tree (“non-target clients”). Non-target clients never have injected events dispatched to them: a |Device| preserves confidentiality for target clients. Non-target clients never block injected events from reaching the target on injection, or from reaching target clients on dispatch: a |Device| preserves integrity and availability for target clients. However, the |Device| itself is subject to disruption by ancestor views of the target (see connectivity invariant).

Note. This protocol, and its policies, are not a sufficient guard against UI redress attacks! The confidentiality, integrity, and availability guarantees apply only with respect to non-target clients. Within a target, UI redress attacks can still happen, between target clients.

Connectivity invariant. A |Device| operates in a stable view tree that is connected to the root view. When either the target, or both context and target, are disconnected from the view tree by a UI client, the |Device| channel is closed. If an event stream was in flight, the server dispatches a final CANCEL event following channel closure; this CANCEL event is then propagated according to dispatch policy.

Trait Implementations

impl Debug for Registry

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

Formats the value using the given formatter.

impl Discoverable for Registry

const PROTOCOL_NAME: &'static str = "fuchsia.ui.pointerinjector.Registry"

The service name to use to connect to this discoverable protocol.

impl<___H, ___T> DispatchClientMessage<___H, ___T> for Registry

where ___H: RegistryClientHandler<___T> + Send, ___T: Transport,

async fn on_event( handler: &mut ___H, ordinal: u64, flexibility: Flexibility, body: Body<___T>, ) -> Result<(), ProtocolError<___T::Error>>

Handles a received client event with the given handler.

impl<___H, ___T> DispatchLocalClientMessage<___H, ___T> for Registry

where ___H: RegistryLocalClientHandler<___T>, ___T: Transport,

async fn on_event( handler: &mut ___H, ordinal: u64, flexibility: Flexibility, body: Body<___T>, ) -> Result<(), ProtocolError<___T::Error>>

Handles a received client event with the given handler.

impl<___H, ___T> DispatchLocalServerMessage<___H, ___T> for Registry

where ___H: RegistryLocalServerHandler<___T>, ___T: Transport, for<'de> RegistryRegisterRequest<'de>: Decode<<<___T as Transport>::RecvBuffer as AsDecoder<'de>>::Decoder, Constraint = ()>,

async fn on_one_way( handler: &mut ___H, ordinal: u64, flexibility: Flexibility, body: Body<___T>, ) -> Result<(), ProtocolError<<___T as Transport>::Error>>

Handles a received server one-way message with the given handler.

async fn on_two_way( handler: &mut ___H, ordinal: u64, flexibility: Flexibility, body: Body<___T>, responder: Responder<___T>, ) -> Result<(), ProtocolError<<___T as Transport>::Error>>

Handles a received server two-way message with the given handler.

impl<___H, ___T> DispatchServerMessage<___H, ___T> for Registry

where ___H: RegistryServerHandler<___T> + Send, ___T: Transport, for<'de> RegistryRegisterRequest<'de>: Decode<<<___T as Transport>::RecvBuffer as AsDecoder<'de>>::Decoder, Constraint = ()>,

async fn on_one_way( handler: &mut ___H, ordinal: u64, flexibility: Flexibility, body: Body<___T>, ) -> Result<(), ProtocolError<<___T as Transport>::Error>>

Handles a received server one-way message with the given handler.

async fn on_two_way( handler: &mut ___H, ordinal: u64, flexibility: Flexibility, body: Body<___T>, responder: Responder<___T>, ) -> Result<(), ProtocolError<<___T as Transport>::Error>>

Handles a received server two-way message with the given handler.

impl<___T> HasConnectionHandles<___T> for Registry

where ___T: Transport,

type Client = RegistryClient<___T>

The client for the protocol. It must be a #[repr(transparent)] wrapper around Client<T>.

type Server = RegistryServer<___T>

The server for the protocol. It must be a #[repr(transparent)] wrapper around Server<T>.

impl HasTransport for Registry

Available on Fuchsia only.

type Transport = Channel

The default transport type for this protocol.

impl PartialEq for Registry

fn eq(&self, other: &Registry) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Registry