Struct DisplayOwnership 

pub struct DisplayOwnership { /* private fields */ }

A handler that turns the input pipeline off or on based on whether Scenic and ViewTree grant input ownership to the platform.

This allows us to pause input processing when the user switches away from the product (e.g. terminal) into virtual console or when a client view (such as Starnix) has direct hardware input ownership.

See the README.md file in this crate for details.

Safety and Concurrency

This struct uses RefCell to manage internal state. While DisplayOwnership logic is split between multiple tasks (handle_ownership_change and handle_unhandled_input_event), safety is maintained because:

1. The pipeline runs on a single-threaded LocalExecutor.
2. Borrows of RefCells (like ownership and key_state) are never held across await points.

If asynchronous calls are added to critical sections in the future, ensure that all borrows are dropped before the await.

Implementations

impl DisplayOwnership

pub fn new( display_ownership_event: impl AsHandleRef + 'static, input_handlers_node: &Node, metrics_logger: MetricsLogger, ) -> Rc<Self>

Creates a new handler that watches display_ownership_event for events.

The display_ownership_event is assumed to be an [Event] obtained from fuchsia.ui.input.internal.InputOwnership/GetEvent.

pub fn set_ownership_change_callback( &self, callback: impl Fn(bool) -> LocalBoxFuture<'static, ()> + 'static, )

Registers a callback to be invoked whenever ownership transitions. The callback receives true when platform ownership is gained, and false when platform ownership is lost.

pub fn is_display_ownership_lost(&self) -> bool

Returns true if the platform does not currently own input.

pub async fn handle_ownership_change( self: &Rc<Self>, output: UnboundedSender<Vec<InputEvent>>, ) -> Result<()>

Watches for display ownership changes and sends cancel/sync events.

NOTE: RefCell safety relies on the single-threaded nature of the executor. No borrows of ownership or key_state must be held across the await below to avoid panics if handle_unhandled_input_event runs while this task is suspended.

Trait Implementations

impl Handler for DisplayOwnership

fn set_handler_healthy(self: Rc<Self>)

fn set_handler_unhealthy(self: Rc<Self>, msg: &str)

fn get_name(&self) -> &'static str

Returns the name of the input handler.

fn interest(&self) -> Vec<InputEventType>

Returns the types of input events this handler is interested in.

impl UnhandledInputHandler for DisplayOwnership

fn handle_unhandled_input_event<'async_trait>( self: Rc<Self>, unhandled_input_event: UnhandledInputEvent, ) -> Pin<Box<dyn Future<Output = Vec<InputEvent>> + 'async_trait>>

where Self: 'async_trait,

Returns a vector of InputEvents to propagate to the next InputHandler.