src/ui/bin/scene_manager/src/input_pipeline.rs - fuchsia - Git at Google

 // Copyright 2021 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 use {
     ::input_pipeline::{text_settings_handler::TextSettingsHandler, CursorMessage},
     anyhow::{Context, Error},
     fidl_fuchsia_input_injection::InputDeviceRegistryRequestStream,
     fidl_fuchsia_settings as fsettings,
     fidl_fuchsia_ui_input_config::FeaturesRequestStream as InputConfigFeaturesRequestStream,
     fidl_fuchsia_ui_pointerinjector_configuration::SetupProxy,
     fidl_fuchsia_ui_shortcut as ui_shortcut, fuchsia_async as fasync,
     fuchsia_component::client::connect_to_protocol,
     fuchsia_inspect as inspect,
     fuchsia_syslog::{fx_log_err, fx_log_warn},
     fuchsia_zircon as zx,
     futures::{lock::Mutex, StreamExt},
     icu_data,
     input_pipeline::{
         self, dead_keys_handler,
         ime_handler::ImeHandler,
         immersive_mode_shortcut_handler::ImmersiveModeShortcutHandler,
         input_device,
         input_pipeline::{InputDeviceBindingHashMap, InputPipeline, InputPipelineAssembly},
         keymap_handler,
         mouse_injector_handler::MouseInjectorHandler,
         shortcut_handler::ShortcutHandler,
         touch_injector_handler::TouchInjectorHandler,
     },
     scene_management::{self, SceneManager},
     std::sync::Arc,
 };

 /// Begins handling input events. The returned future will complete when
 /// input events are no longer being handled.
 ///
 /// # Parameters
 /// - `scene_manager`: The scene manager used by the session.
 /// - `input_config_request_stream_receiver`:  A receiving end of a MPSC channel for
 ///   `InputConfig` messages.
 /// - `input_device_registry_request_stream_receiver`: A receiving end of a MPSC channel for
 ///   `InputDeviceRegistry` messages.
 /// - `node`: The inspect node to insert individual inspect handler nodes into.
 pub async fn handle_input(
     // If this is false, it means we're using the legacy Scenic Gfx API, instead of the
     // new Flatland API.
     use_flatland: bool,
     scene_manager: Arc<Mutex<Box<dyn SceneManager>>>,
     input_config_request_stream_receiver: futures::channel::mpsc::UnboundedReceiver<
         InputConfigFeaturesRequestStream,
     >,
     input_device_registry_request_stream_receiver: futures::channel::mpsc::UnboundedReceiver<
         InputDeviceRegistryRequestStream,
     >,
     icu_data_loader: icu_data::Loader,
     node: &inspect::Node,
     display_ownership_event: zx::Event,
 ) -> Result<InputPipeline, Error> {
     let input_pipeline = InputPipeline::new(
         vec![
             input_device::InputDeviceType::Mouse,
             input_device::InputDeviceType::Touch,
             input_device::InputDeviceType::Keyboard,
         ],
         build_input_pipeline_assembly(
             use_flatland,
             scene_manager,
             icu_data_loader,
             node,
             display_ownership_event,
         )
         .await,
     )
     .context("Failed to create InputPipeline.")?;

     let input_device_registry_fut = handle_input_device_registry_request_streams(
         input_device_registry_request_stream_receiver,
         input_pipeline.input_device_types().clone(),
         input_pipeline.input_event_sender().clone(),
         input_pipeline.input_device_bindings().clone(),
     );

     fasync::Task::local(input_device_registry_fut).detach();

     let input_config_fut = handle_input_config_request_streams(
         input_config_request_stream_receiver,
         input_pipeline.input_device_bindings().clone(),
     );

     fasync::Task::local(input_config_fut).detach();

     Ok(input_pipeline)
 }

 fn setup_pointer_injector_config_request_stream(
     scene_manager: Arc<Mutex<Box<dyn SceneManager>>>,
 ) -> SetupProxy {
     let (setup_proxy, setup_request_stream) = fidl::endpoints::create_proxy_and_stream::<
         fidl_fuchsia_ui_pointerinjector_configuration::SetupMarker,
     >()
     .expect("Failed to create pointerinjector.configuration.Setup channel.");

     scene_management::handle_pointer_injector_configuration_setup_request_stream(
         setup_request_stream,
         scene_manager,
     );

     setup_proxy
 }

 async fn add_touch_handler(
     scene_manager: Arc<Mutex<Box<dyn SceneManager>>>,
     mut assembly: InputPipelineAssembly,
 ) -> InputPipelineAssembly {
     let setup_proxy = setup_pointer_injector_config_request_stream(scene_manager.clone());
     let size = scene_manager.lock().await.get_pointerinjection_display_size();
     let touch_handler = TouchInjectorHandler::new_with_config_proxy(setup_proxy, size).await;
     match touch_handler {
         Ok(touch_handler) => {
             fasync::Task::local(touch_handler.clone().watch_viewport()).detach();
             assembly = assembly.add_handler(touch_handler);
         }
         Err(e) => fx_log_err!(
             "build_input_pipeline_assembly(): Touch injector handler was not installed: {:?}",
             e
         ),
     };
     assembly
 }

 async fn add_mouse_handler(
     scene_manager: Arc<Mutex<Box<dyn SceneManager>>>,
     mut assembly: InputPipelineAssembly,
     sender: futures::channel::mpsc::Sender<CursorMessage>,
 ) -> InputPipelineAssembly {
     let setup_proxy = setup_pointer_injector_config_request_stream(scene_manager.clone());
     let size = scene_manager.lock().await.get_pointerinjection_display_size();
     let mouse_handler =
         MouseInjectorHandler::new_with_config_proxy(setup_proxy, size, sender).await;
     match mouse_handler {
         Ok(mouse_handler) => {
             fasync::Task::local(mouse_handler.clone().watch_viewport()).detach();
             assembly = assembly.add_handler(mouse_handler);
         }
         Err(e) => fx_log_err!(
             "build_input_pipeline_assembly(): Mouse injector handler was not installed: {:?}",
             e
         ),
     };
     assembly
 }

 // Maximum pointer movement during a clickpad press for the gesture to
 // be guaranteed to be interpreted as a click. For movement greater than
 // this value, upper layers may, e.g., interpret the gesture as a drag.
 //
 // This value has been tuned for Atlas, and may need further tuning or
 // configuration for other devices.
 const CLICK_TO_DRAG_THRESHOLD: f32 = 16.0;

 async fn build_input_pipeline_assembly(
     use_flatland: bool,
     scene_manager: Arc<Mutex<Box<dyn SceneManager>>>,
     icu_data_loader: icu_data::Loader,
     node: &inspect::Node,
     display_ownership_event: zx::Event,
 ) -> InputPipelineAssembly {
     let mut assembly = InputPipelineAssembly::new();
     let (sender, mut receiver) = futures::channel::mpsc::channel(0);
     {
         // Keep this handler first because it keeps performance measurement counters
         // for the rest of the pipeline at entry.
         assembly = add_inspect_handler(node.create_child("input_pipeline_entry"), assembly);
         assembly = assembly.add_display_ownership(display_ownership_event);
         assembly = add_modifier_handler(assembly);
         // Add the text settings handler early in the pipeline to use the
         // keymap settings in the remainder of the pipeline.
         assembly = add_text_settings_handler(assembly);
         assembly = add_keymap_handler(assembly);
         assembly = assembly.add_autorepeater();
         assembly = add_dead_keys_handler(assembly, icu_data_loader);
         assembly = add_immersive_mode_shortcut_handler(assembly);
         // Shortcut needs to go before IME.
         assembly = add_shortcut_handler(assembly).await;
         assembly = add_ime(assembly).await;
         // Add the click-drag handler before the mouse handler, to allow
         // the click-drag handler to filter events seen by the mouse
         // handler.
         assembly = add_click_drag_handler(assembly);

         // Add handler to scale pointer motion based on speed of sensor
         // motion. This allows touchpads and mice to be easily used for
         // both precise pointing, and quick motion across the width
         // (or height) of the screen.
         //
         // This handler must come before the PointerMotionDisplayScaleHandler.
         // Otherwise the display scale will be applied quadratically in some
         // cases.
         assembly = add_pointer_motion_sensor_scale_handler(assembly);

         // Add handler to scale pointer motion on high-DPI displays.
         //
         // * This handler is added _after_ the click-drag handler, since the
         //   motion denoising done by click drag handler is a property solely
         //   of the trackpad, and not of the display.
         //
         // * This handler is added _before_ the mouse handler, since _all_
         //   mouse events should be scaled.
         let pointer_scale =
             scene_manager.lock().await.get_display_metrics().physical_pixel_ratio().max(1.0);
         assembly = add_pointer_motion_display_scale_handler(assembly, pointer_scale);

         assembly = add_touch_handler(scene_manager.clone(), assembly).await;
         if use_flatland {
             assembly = add_mouse_handler(scene_manager.clone(), assembly, sender).await;
         } else {
             // We don't have mouse support for GFX. But that's okay,
             // because the devices still using GFX don't support mice
             // anyway.
         }

         // Keep this handler last because it keeps performance measurement counters
         // for the rest of the pipeline at exit.  We compare these values to the
         // values at entry.
         assembly = add_inspect_handler(node.create_child("input_pipeline_exit"), assembly);

         // Forward focus.
         // This requires `fuchsia.ui.focus.FocusChainListenerRegistry`
         assembly = assembly.add_focus_listener();
     }

     {
         let scene_manager = scene_manager.clone();
         fasync::Task::spawn(async move {
             while let Some(message) = receiver.next().await {
                 let mut scene_manager = scene_manager.lock().await;
                 match message {
                     CursorMessage::SetPosition(position) => {
                         scene_manager.set_cursor_position(position)
                     }
                     CursorMessage::SetVisibility(visible) => {
                         scene_manager.set_cursor_visibility(visible)
                     }
                 }
             }
         })
         .detach();
     }

     assembly
 }

 /// Hooks up the modifier keys handler.
 fn add_modifier_handler(assembly: InputPipelineAssembly) -> InputPipelineAssembly {
     assembly.add_handler(input_pipeline::modifier_handler::ModifierHandler::new())
 }

 /// Hooks up the inspect handler.
 fn add_inspect_handler(
     node: inspect::Node,
     assembly: InputPipelineAssembly,
 ) -> InputPipelineAssembly {
     assembly.add_handler(input_pipeline::inspect_handler::InspectHandler::new(node))
 }

 /// Hooks up the text settings handler.
 fn add_text_settings_handler(assembly: InputPipelineAssembly) -> InputPipelineAssembly {
     let proxy = connect_to_protocol::<fsettings::KeyboardMarker>()
         .expect("needs a connection to fuchsia.settings.Keyboard");
     let text_handler = TextSettingsHandler::new(None, None);
     text_handler.clone().serve(proxy);
     assembly.add_handler(text_handler)
 }

 /// Hooks up the keymapper.  The keymapper requires the text settings handler to
 /// be added as well to support keymapping.  Otherwise, it defaults to applying
 /// the US QWERTY keymap.
 fn add_keymap_handler(assembly: InputPipelineAssembly) -> InputPipelineAssembly {
     assembly.add_handler(keymap_handler::KeymapHandler::new())
 }

 /// Hooks up the dead keys handler. This allows us to input accented characters by composing a
 /// diacritic and a character.
 fn add_dead_keys_handler(
     assembly: InputPipelineAssembly,
     loader: icu_data::Loader,
 ) -> InputPipelineAssembly {
     assembly.add_handler(dead_keys_handler::Handler::new(loader))
 }

 async fn add_shortcut_handler(mut assembly: InputPipelineAssembly) -> InputPipelineAssembly {
     if let Ok(manager) = connect_to_protocol::<ui_shortcut::ManagerMarker>() {
         if let Ok(shortcut_handler) = ShortcutHandler::new(manager) {
             assembly = assembly.add_handler(shortcut_handler);
         }
     }
     assembly
 }

 async fn add_ime(mut assembly: InputPipelineAssembly) -> InputPipelineAssembly {
     if let Ok(ime_handler) = ImeHandler::new().await {
         assembly = assembly.add_handler(ime_handler);
     }
     assembly
 }

 fn add_click_drag_handler(assembly: InputPipelineAssembly) -> InputPipelineAssembly {
     assembly.add_handler(input_pipeline::click_drag_handler::ClickDragHandler::new(
         CLICK_TO_DRAG_THRESHOLD,
     ))
 }

 fn add_pointer_motion_display_scale_handler(
     assembly: InputPipelineAssembly,
     scale_factor: f32,
 ) -> InputPipelineAssembly {
     match input_pipeline::pointer_motion_display_scale_handler::PointerMotionDisplayScaleHandler::new(scale_factor)
     {
         Ok(handler) => assembly.add_handler(handler),
         Err(e) => {
             fx_log_err!("Failed to install pointer scaler: {}", e);
             assembly
         }
     }
 }

 fn add_pointer_motion_sensor_scale_handler(
     assembly: InputPipelineAssembly,
 ) -> InputPipelineAssembly {
     assembly.add_handler(
         input_pipeline::pointer_motion_sensor_scale_handler::PointerMotionSensorScaleHandler::new(),
     )
 }

 fn add_immersive_mode_shortcut_handler(assembly: InputPipelineAssembly) -> InputPipelineAssembly {
     assembly.add_handler(ImmersiveModeShortcutHandler::new())
 }

 pub async fn handle_input_config_request_streams(
     mut stream_receiver: futures::channel::mpsc::UnboundedReceiver<
         InputConfigFeaturesRequestStream,
     >,
     input_device_bindings: InputDeviceBindingHashMap,
 ) {
     while let Some(stream) = stream_receiver.next().await {
         match InputPipeline::handle_input_config_request_stream(stream, &input_device_bindings)
             .await
         {
             Ok(()) => (),
             Err(e) => {
                 fx_log_warn!(
                     "failure while serving InputConfig.Features: {}; \
                      will continue serving other clients",
                     e
                 );
             }
         }
     }
 }

 pub async fn handle_input_device_registry_request_streams(
     mut stream_receiver: futures::channel::mpsc::UnboundedReceiver<
         InputDeviceRegistryRequestStream,
     >,
     input_device_types: Vec<input_device::InputDeviceType>,
     input_event_sender: futures::channel::mpsc::Sender<input_device::InputEvent>,
     input_device_bindings: InputDeviceBindingHashMap,
 ) {
     // Use a high value device id to avoid conflicting device ids.
     let mut device_id = u32::MAX;
     while let Some(stream) = stream_receiver.next().await {
         match InputPipeline::handle_input_device_registry_request_stream(
             stream,
             &input_device_types,
             &input_event_sender,
             &input_device_bindings,
             device_id,
         )
         .await
         {
             Ok(()) => (),
             Err(e) => {
                 fx_log_warn!(
                     "failure while serving InputDeviceRegistry: {}; \
                      will continue serving other clients",
                     e
                 );
             }
         }
         device_id -= 1;
     }
 }

 #[cfg(test)]
 mod tests {
     use fuchsia_async as fasync;

     #[fasync::run_singlethreaded(test)]
     async fn test_placeholder() {
         // TODO(fxb/73643): Add tests that verify the construction of the input pipeline.
     }
 }
	// Copyright 2021 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	use {
	::input_pipeline::{text_settings_handler::TextSettingsHandler, CursorMessage},
	anyhow::{Context, Error},
	fidl_fuchsia_input_injection::InputDeviceRegistryRequestStream,
	fidl_fuchsia_settings as fsettings,
	fidl_fuchsia_ui_input_config::FeaturesRequestStream as InputConfigFeaturesRequestStream,
	fidl_fuchsia_ui_pointerinjector_configuration::SetupProxy,
	fidl_fuchsia_ui_shortcut as ui_shortcut, fuchsia_async as fasync,
	fuchsia_component::client::connect_to_protocol,
	fuchsia_inspect as inspect,
	fuchsia_syslog::{fx_log_err, fx_log_warn},
	fuchsia_zircon as zx,
	futures::{lock::Mutex, StreamExt},
	icu_data,
	input_pipeline::{
	self, dead_keys_handler,
	ime_handler::ImeHandler,
	immersive_mode_shortcut_handler::ImmersiveModeShortcutHandler,
	input_device,
	input_pipeline::{InputDeviceBindingHashMap, InputPipeline, InputPipelineAssembly},
	keymap_handler,
	mouse_injector_handler::MouseInjectorHandler,
	shortcut_handler::ShortcutHandler,
	touch_injector_handler::TouchInjectorHandler,
	},
	scene_management::{self, SceneManager},
	std::sync::Arc,
	};

	/// Begins handling input events. The returned future will complete when
	/// input events are no longer being handled.
	///
	/// # Parameters
	/// - `scene_manager`: The scene manager used by the session.
	/// - `input_config_request_stream_receiver`: A receiving end of a MPSC channel for
	/// `InputConfig` messages.
	/// - `input_device_registry_request_stream_receiver`: A receiving end of a MPSC channel for
	/// `InputDeviceRegistry` messages.
	/// - `node`: The inspect node to insert individual inspect handler nodes into.
	pub async fn handle_input(
	// If this is false, it means we're using the legacy Scenic Gfx API, instead of the
	// new Flatland API.
	use_flatland: bool,
	scene_manager: Arc<Mutex<Box<dyn SceneManager>>>,
	input_config_request_stream_receiver: futures::channel::mpsc::UnboundedReceiver<
	InputConfigFeaturesRequestStream,
	>,
	input_device_registry_request_stream_receiver: futures::channel::mpsc::UnboundedReceiver<
	InputDeviceRegistryRequestStream,
	>,
	icu_data_loader: icu_data::Loader,
	node: &inspect::Node,
	display_ownership_event: zx::Event,
	) -> Result<InputPipeline, Error> {
	let input_pipeline = InputPipeline::new(
	vec![
	input_device::InputDeviceType::Mouse,
	input_device::InputDeviceType::Touch,
	input_device::InputDeviceType::Keyboard,
	],
	build_input_pipeline_assembly(
	use_flatland,
	scene_manager,
	icu_data_loader,
	node,
	display_ownership_event,
	)
	.await,
	)
	.context("Failed to create InputPipeline.")?;

	let input_device_registry_fut = handle_input_device_registry_request_streams(
	input_device_registry_request_stream_receiver,
	input_pipeline.input_device_types().clone(),
	input_pipeline.input_event_sender().clone(),
	input_pipeline.input_device_bindings().clone(),
	);

	fasync::Task::local(input_device_registry_fut).detach();

	let input_config_fut = handle_input_config_request_streams(
	input_config_request_stream_receiver,
	input_pipeline.input_device_bindings().clone(),
	);

	fasync::Task::local(input_config_fut).detach();

	Ok(input_pipeline)
	}

	fn setup_pointer_injector_config_request_stream(
	scene_manager: Arc<Mutex<Box<dyn SceneManager>>>,
	) -> SetupProxy {
	let (setup_proxy, setup_request_stream) = fidl::endpoints::create_proxy_and_stream::<
	fidl_fuchsia_ui_pointerinjector_configuration::SetupMarker,
	>()
	.expect("Failed to create pointerinjector.configuration.Setup channel.");

	scene_management::handle_pointer_injector_configuration_setup_request_stream(
	setup_request_stream,
	scene_manager,
	);

	setup_proxy
	}

	async fn add_touch_handler(
	scene_manager: Arc<Mutex<Box<dyn SceneManager>>>,
	mut assembly: InputPipelineAssembly,
	) -> InputPipelineAssembly {
	let setup_proxy = setup_pointer_injector_config_request_stream(scene_manager.clone());
	let size = scene_manager.lock().await.get_pointerinjection_display_size();
	let touch_handler = TouchInjectorHandler::new_with_config_proxy(setup_proxy, size).await;
	match touch_handler {
	Ok(touch_handler) => {
	fasync::Task::local(touch_handler.clone().watch_viewport()).detach();
	assembly = assembly.add_handler(touch_handler);
	}
	Err(e) => fx_log_err!(
	"build_input_pipeline_assembly(): Touch injector handler was not installed: {:?}",
	e
	),
	};
	assembly
	}

	async fn add_mouse_handler(
	scene_manager: Arc<Mutex<Box<dyn SceneManager>>>,
	mut assembly: InputPipelineAssembly,
	sender: futures::channel::mpsc::Sender<CursorMessage>,
	) -> InputPipelineAssembly {
	let setup_proxy = setup_pointer_injector_config_request_stream(scene_manager.clone());
	let size = scene_manager.lock().await.get_pointerinjection_display_size();
	let mouse_handler =
	MouseInjectorHandler::new_with_config_proxy(setup_proxy, size, sender).await;
	match mouse_handler {
	Ok(mouse_handler) => {
	fasync::Task::local(mouse_handler.clone().watch_viewport()).detach();
	assembly = assembly.add_handler(mouse_handler);
	}
	Err(e) => fx_log_err!(
	"build_input_pipeline_assembly(): Mouse injector handler was not installed: {:?}",
	e
	),
	};
	assembly
	}

	// Maximum pointer movement during a clickpad press for the gesture to
	// be guaranteed to be interpreted as a click. For movement greater than
	// this value, upper layers may, e.g., interpret the gesture as a drag.
	//
	// This value has been tuned for Atlas, and may need further tuning or
	// configuration for other devices.
	const CLICK_TO_DRAG_THRESHOLD: f32 = 16.0;

	async fn build_input_pipeline_assembly(
	use_flatland: bool,
	scene_manager: Arc<Mutex<Box<dyn SceneManager>>>,
	icu_data_loader: icu_data::Loader,
	node: &inspect::Node,
	display_ownership_event: zx::Event,
	) -> InputPipelineAssembly {
	let mut assembly = InputPipelineAssembly::new();
	let (sender, mut receiver) = futures::channel::mpsc::channel(0);
	{
	// Keep this handler first because it keeps performance measurement counters
	// for the rest of the pipeline at entry.
	assembly = add_inspect_handler(node.create_child("input_pipeline_entry"), assembly);
	assembly = assembly.add_display_ownership(display_ownership_event);
	assembly = add_modifier_handler(assembly);
	// Add the text settings handler early in the pipeline to use the
	// keymap settings in the remainder of the pipeline.
	assembly = add_text_settings_handler(assembly);
	assembly = add_keymap_handler(assembly);
	assembly = assembly.add_autorepeater();
	assembly = add_dead_keys_handler(assembly, icu_data_loader);
	assembly = add_immersive_mode_shortcut_handler(assembly);
	// Shortcut needs to go before IME.
	assembly = add_shortcut_handler(assembly).await;
	assembly = add_ime(assembly).await;
	// Add the click-drag handler before the mouse handler, to allow
	// the click-drag handler to filter events seen by the mouse
	// handler.
	assembly = add_click_drag_handler(assembly);

	// Add handler to scale pointer motion based on speed of sensor
	// motion. This allows touchpads and mice to be easily used for
	// both precise pointing, and quick motion across the width
	// (or height) of the screen.
	//
	// This handler must come before the PointerMotionDisplayScaleHandler.
	// Otherwise the display scale will be applied quadratically in some
	// cases.
	assembly = add_pointer_motion_sensor_scale_handler(assembly);

	// Add handler to scale pointer motion on high-DPI displays.
	//
	// * This handler is added _after_ the click-drag handler, since the
	// motion denoising done by click drag handler is a property solely
	// of the trackpad, and not of the display.
	//
	// * This handler is added _before_ the mouse handler, since _all_
	// mouse events should be scaled.
	let pointer_scale =
	scene_manager.lock().await.get_display_metrics().physical_pixel_ratio().max(1.0);
	assembly = add_pointer_motion_display_scale_handler(assembly, pointer_scale);

	assembly = add_touch_handler(scene_manager.clone(), assembly).await;
	if use_flatland {
	assembly = add_mouse_handler(scene_manager.clone(), assembly, sender).await;
	} else {
	// We don't have mouse support for GFX. But that's okay,
	// because the devices still using GFX don't support mice
	// anyway.
	}

	// Keep this handler last because it keeps performance measurement counters
	// for the rest of the pipeline at exit. We compare these values to the
	// values at entry.
	assembly = add_inspect_handler(node.create_child("input_pipeline_exit"), assembly);

	// Forward focus.
	// This requires `fuchsia.ui.focus.FocusChainListenerRegistry`
	assembly = assembly.add_focus_listener();
	}

	{
	let scene_manager = scene_manager.clone();
	fasync::Task::spawn(async move {
	while let Some(message) = receiver.next().await {
	let mut scene_manager = scene_manager.lock().await;
	match message {
	CursorMessage::SetPosition(position) => {
	scene_manager.set_cursor_position(position)
	}
	CursorMessage::SetVisibility(visible) => {
	scene_manager.set_cursor_visibility(visible)
	}
	}
	}
	})
	.detach();
	}

	assembly
	}

	/// Hooks up the modifier keys handler.
	fn add_modifier_handler(assembly: InputPipelineAssembly) -> InputPipelineAssembly {
	assembly.add_handler(input_pipeline::modifier_handler::ModifierHandler::new())
	}

	/// Hooks up the inspect handler.
	fn add_inspect_handler(
	node: inspect::Node,
	assembly: InputPipelineAssembly,
	) -> InputPipelineAssembly {
	assembly.add_handler(input_pipeline::inspect_handler::InspectHandler::new(node))
	}

	/// Hooks up the text settings handler.
	fn add_text_settings_handler(assembly: InputPipelineAssembly) -> InputPipelineAssembly {
	let proxy = connect_to_protocol::<fsettings::KeyboardMarker>()
	.expect("needs a connection to fuchsia.settings.Keyboard");
	let text_handler = TextSettingsHandler::new(None, None);
	text_handler.clone().serve(proxy);
	assembly.add_handler(text_handler)
	}

	/// Hooks up the keymapper. The keymapper requires the text settings handler to
	/// be added as well to support keymapping. Otherwise, it defaults to applying
	/// the US QWERTY keymap.
	fn add_keymap_handler(assembly: InputPipelineAssembly) -> InputPipelineAssembly {
	assembly.add_handler(keymap_handler::KeymapHandler::new())
	}

	/// Hooks up the dead keys handler. This allows us to input accented characters by composing a
	/// diacritic and a character.
	fn add_dead_keys_handler(
	assembly: InputPipelineAssembly,
	loader: icu_data::Loader,
	) -> InputPipelineAssembly {
	assembly.add_handler(dead_keys_handler::Handler::new(loader))
	}

	async fn add_shortcut_handler(mut assembly: InputPipelineAssembly) -> InputPipelineAssembly {
	if let Ok(manager) = connect_to_protocol::<ui_shortcut::ManagerMarker>() {
	if let Ok(shortcut_handler) = ShortcutHandler::new(manager) {
	assembly = assembly.add_handler(shortcut_handler);
	}
	}
	assembly
	}

	async fn add_ime(mut assembly: InputPipelineAssembly) -> InputPipelineAssembly {
	if let Ok(ime_handler) = ImeHandler::new().await {
	assembly = assembly.add_handler(ime_handler);
	}
	assembly
	}

	fn add_click_drag_handler(assembly: InputPipelineAssembly) -> InputPipelineAssembly {
	assembly.add_handler(input_pipeline::click_drag_handler::ClickDragHandler::new(
	CLICK_TO_DRAG_THRESHOLD,
	))
	}

	fn add_pointer_motion_display_scale_handler(
	assembly: InputPipelineAssembly,
	scale_factor: f32,
	) -> InputPipelineAssembly {
	match input_pipeline::pointer_motion_display_scale_handler::PointerMotionDisplayScaleHandler::new(scale_factor)
	{
	Ok(handler) => assembly.add_handler(handler),
	Err(e) => {
	fx_log_err!("Failed to install pointer scaler: {}", e);
	assembly
	}
	}
	}

	fn add_pointer_motion_sensor_scale_handler(
	assembly: InputPipelineAssembly,
	) -> InputPipelineAssembly {
	assembly.add_handler(
	input_pipeline::pointer_motion_sensor_scale_handler::PointerMotionSensorScaleHandler::new(),
	)
	}

	fn add_immersive_mode_shortcut_handler(assembly: InputPipelineAssembly) -> InputPipelineAssembly {
	assembly.add_handler(ImmersiveModeShortcutHandler::new())
	}

	pub async fn handle_input_config_request_streams(
	mut stream_receiver: futures::channel::mpsc::UnboundedReceiver<
	InputConfigFeaturesRequestStream,
	>,
	input_device_bindings: InputDeviceBindingHashMap,
	) {
	while let Some(stream) = stream_receiver.next().await {
	match InputPipeline::handle_input_config_request_stream(stream, &input_device_bindings)
	.await
	{
	Ok(()) => (),
	Err(e) => {
	fx_log_warn!(
	"failure while serving InputConfig.Features: {}; \
	will continue serving other clients",
	e
	);
	}
	}
	}
	}

	pub async fn handle_input_device_registry_request_streams(
	mut stream_receiver: futures::channel::mpsc::UnboundedReceiver<
	InputDeviceRegistryRequestStream,
	>,
	input_device_types: Vec<input_device::InputDeviceType>,
	input_event_sender: futures::channel::mpsc::Sender<input_device::InputEvent>,
	input_device_bindings: InputDeviceBindingHashMap,
	) {
	// Use a high value device id to avoid conflicting device ids.
	let mut device_id = u32::MAX;
	while let Some(stream) = stream_receiver.next().await {
	match InputPipeline::handle_input_device_registry_request_stream(
	stream,
	&input_device_types,
	&input_event_sender,
	&input_device_bindings,
	device_id,
	)
	.await
	{
	Ok(()) => (),
	Err(e) => {
	fx_log_warn!(
	"failure while serving InputDeviceRegistry: {}; \
	will continue serving other clients",
	e
	);
	}
	}
	device_id -= 1;
	}
	}

	#[cfg(test)]
	mod tests {
	use fuchsia_async as fasync;

	#[fasync::run_singlethreaded(test)]
	async fn test_placeholder() {
	// TODO(fxb/73643): Add tests that verify the construction of the input pipeline.
	}
	}