| // Copyright 2022 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 { |
| crate::{ |
| input_device, |
| input_handler::{InputHandlerStatus, UnhandledInputHandler}, |
| metrics, mouse_binding, |
| utils::Position, |
| }, |
| anyhow::{format_err, Error}, |
| async_trait::async_trait, |
| derivative::Derivative, |
| fuchsia_inspect::health::Reporter, |
| metrics_registry::*, |
| std::rc::Rc, |
| }; |
| |
| // TODO(https://fxbug.dev/42172817) Add trackpad support |
| #[derive(Derivative)] |
| #[derivative(Debug, PartialEq)] |
| pub struct PointerDisplayScaleHandler { |
| /// The amount by which motion will be scaled up. E.g., a `scale_factor` |
| /// of 2 means that all motion will be multiplied by 2. |
| scale_factor: f32, |
| |
| /// The inventory of this handler's Inspect status. |
| pub inspect_status: InputHandlerStatus, |
| |
| /// The metrics logger. |
| #[derivative(Debug = "ignore", PartialEq = "ignore")] |
| metrics_logger: metrics::MetricsLogger, |
| } |
| |
| #[async_trait(?Send)] |
| impl UnhandledInputHandler for PointerDisplayScaleHandler { |
| async fn handle_unhandled_input_event( |
| self: Rc<Self>, |
| unhandled_input_event: input_device::UnhandledInputEvent, |
| ) -> Vec<input_device::InputEvent> { |
| match unhandled_input_event.clone() { |
| input_device::UnhandledInputEvent { |
| device_event: |
| input_device::InputDeviceEvent::Mouse(mouse_binding::MouseEvent { |
| location: |
| mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation { |
| millimeters: raw_mm, |
| }), |
| wheel_delta_v, |
| wheel_delta_h, |
| // Only the `Move` phase carries non-zero motion. |
| phase: phase @ mouse_binding::MousePhase::Move, |
| affected_buttons, |
| pressed_buttons, |
| is_precision_scroll, |
| }), |
| device_descriptor: device_descriptor @ input_device::InputDeviceDescriptor::Mouse(_), |
| event_time, |
| trace_id: _, |
| } => { |
| self.inspect_status |
| .count_received_event(input_device::InputEvent::from(unhandled_input_event)); |
| let scaled_mm = self.scale_motion(raw_mm); |
| let input_event = input_device::InputEvent { |
| device_event: input_device::InputDeviceEvent::Mouse( |
| mouse_binding::MouseEvent { |
| location: mouse_binding::MouseLocation::Relative( |
| mouse_binding::RelativeLocation { millimeters: scaled_mm }, |
| ), |
| wheel_delta_v, |
| wheel_delta_h, |
| phase, |
| affected_buttons, |
| pressed_buttons, |
| is_precision_scroll, |
| }, |
| ), |
| device_descriptor, |
| event_time, |
| handled: input_device::Handled::No, |
| trace_id: None, |
| }; |
| vec![input_event] |
| } |
| input_device::UnhandledInputEvent { |
| device_event: |
| input_device::InputDeviceEvent::Mouse(mouse_binding::MouseEvent { |
| location, |
| wheel_delta_v, |
| wheel_delta_h, |
| phase: phase @ mouse_binding::MousePhase::Wheel, |
| affected_buttons, |
| pressed_buttons, |
| is_precision_scroll, |
| }), |
| device_descriptor: device_descriptor @ input_device::InputDeviceDescriptor::Mouse(_), |
| event_time, |
| trace_id: _, |
| } => { |
| self.inspect_status |
| .count_received_event(input_device::InputEvent::from(unhandled_input_event)); |
| let scaled_wheel_delta_v = self.scale_wheel_delta(wheel_delta_v); |
| let scaled_wheel_delta_h = self.scale_wheel_delta(wheel_delta_h); |
| let input_event = input_device::InputEvent { |
| device_event: input_device::InputDeviceEvent::Mouse( |
| mouse_binding::MouseEvent { |
| location, |
| wheel_delta_v: scaled_wheel_delta_v, |
| wheel_delta_h: scaled_wheel_delta_h, |
| phase, |
| affected_buttons, |
| pressed_buttons, |
| is_precision_scroll, |
| }, |
| ), |
| device_descriptor, |
| event_time, |
| handled: input_device::Handled::No, |
| trace_id: None, |
| }; |
| vec![input_event] |
| } |
| _ => vec![input_device::InputEvent::from(unhandled_input_event)], |
| } |
| } |
| |
| fn set_handler_healthy(self: std::rc::Rc<Self>) { |
| self.inspect_status.health_node.borrow_mut().set_ok(); |
| } |
| |
| fn set_handler_unhealthy(self: std::rc::Rc<Self>, msg: &str) { |
| self.inspect_status.health_node.borrow_mut().set_unhealthy(msg); |
| } |
| } |
| |
| impl PointerDisplayScaleHandler { |
| /// Creates a new [`PointerMotionDisplayScaleHandler`]. |
| /// |
| /// Returns |
| /// * `Ok(Rc<Self>)` if `scale_factor` is finite and >= 1.0, and |
| /// * `Err(Error)` otherwise. |
| pub fn new( |
| scale_factor: f32, |
| input_handlers_node: &fuchsia_inspect::Node, |
| metrics_logger: metrics::MetricsLogger, |
| ) -> Result<Rc<Self>, Error> { |
| tracing::debug!("scale_factor={}", scale_factor); |
| use std::num::FpCategory; |
| let inspect_status = InputHandlerStatus::new( |
| input_handlers_node, |
| "pointer_display_scale_handler", |
| /* generates_events */ false, |
| ); |
| match scale_factor.classify() { |
| FpCategory::Nan | FpCategory::Infinite | FpCategory::Zero | FpCategory::Subnormal => { |
| Err(format_err!( |
| "scale_factor {} is not a `Normal` floating-point value", |
| scale_factor |
| )) |
| } |
| FpCategory::Normal => { |
| if scale_factor < 0.0 { |
| Err(format_err!("Inverting motion is not supported")) |
| } else if scale_factor < 1.0 { |
| Err(format_err!("Down-scaling motion is not supported")) |
| } else { |
| Ok(Rc::new(Self { scale_factor, inspect_status, metrics_logger })) |
| } |
| } |
| } |
| } |
| |
| /// Scales `motion`, using the configuration in `self`. |
| fn scale_motion(self: &Rc<Self>, motion: Position) -> Position { |
| motion * self.scale_factor |
| } |
| |
| /// Scales `wheel_delta`, using the configuration in `self`. |
| fn scale_wheel_delta( |
| self: &Rc<Self>, |
| wheel_delta: Option<mouse_binding::WheelDelta>, |
| ) -> Option<mouse_binding::WheelDelta> { |
| match wheel_delta { |
| None => None, |
| Some(delta) => Some(mouse_binding::WheelDelta { |
| raw_data: delta.raw_data, |
| physical_pixel: match delta.physical_pixel { |
| None => { |
| // this should never reach as pointer_sensor_scale_handler should |
| // fill this field. |
| self.metrics_logger.log_error( |
| InputPipelineErrorMetricDimensionEvent::PointerDisplayScaleNoPhysicalPixel, |
| "physical_pixel is none", |
| ); |
| None |
| } |
| Some(pixel) => Some(self.scale_factor * pixel), |
| }, |
| }), |
| } |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use { |
| super::*, |
| crate::input_handler::InputHandler, |
| crate::testing_utilities, |
| assert_matches::assert_matches, |
| fuchsia_async as fasync, fuchsia_zircon as zx, |
| maplit::hashset, |
| std::{cell::Cell, collections::HashSet, ops::Add}, |
| test_case::test_case, |
| }; |
| |
| const COUNTS_PER_MM: f32 = 12.0; |
| const DEVICE_DESCRIPTOR: input_device::InputDeviceDescriptor = |
| input_device::InputDeviceDescriptor::Mouse(mouse_binding::MouseDeviceDescriptor { |
| device_id: 0, |
| absolute_x_range: None, |
| absolute_y_range: None, |
| wheel_v_range: None, |
| wheel_h_range: None, |
| buttons: None, |
| counts_per_mm: COUNTS_PER_MM as u32, |
| }); |
| |
| std::thread_local! {static NEXT_EVENT_TIME: Cell<i64> = Cell::new(0)} |
| |
| fn make_unhandled_input_event( |
| mouse_event: mouse_binding::MouseEvent, |
| ) -> input_device::UnhandledInputEvent { |
| let event_time = NEXT_EVENT_TIME.with(|t| { |
| let old = t.get(); |
| t.set(old + 1); |
| old |
| }); |
| input_device::UnhandledInputEvent { |
| device_event: input_device::InputDeviceEvent::Mouse(mouse_event), |
| device_descriptor: DEVICE_DESCRIPTOR.clone(), |
| event_time: zx::Time::from_nanos(event_time), |
| trace_id: None, |
| } |
| } |
| |
| #[test_case(f32::NAN => matches Err(_); "yields err for NaN scale")] |
| #[test_case(f32::INFINITY => matches Err(_); "yields err for pos infinite scale")] |
| #[test_case(f32::NEG_INFINITY => matches Err(_); "yields err for neg infinite scale")] |
| #[test_case( -1.0 => matches Err(_); "yields err for neg scale")] |
| #[test_case( 0.0 => matches Err(_); "yields err for pos zero scale")] |
| #[test_case( -0.0 => matches Err(_); "yields err for neg zero scale")] |
| #[test_case( 0.5 => matches Err(_); "yields err for downscale")] |
| #[test_case( 1.0 => matches Ok(_); "yields handler for unit scale")] |
| #[test_case( 1.5 => matches Ok(_); "yields handler for upscale")] |
| fn new(scale_factor: f32) -> Result<Rc<PointerDisplayScaleHandler>, Error> { |
| let inspector = fuchsia_inspect::Inspector::default(); |
| let test_node = inspector.root().create_child("test_node"); |
| PointerDisplayScaleHandler::new(scale_factor, &test_node, metrics::MetricsLogger::default()) |
| } |
| |
| #[fuchsia::test(allow_stalls = false)] |
| async fn applies_scale_mm() { |
| let inspector = fuchsia_inspect::Inspector::default(); |
| let test_node = inspector.root().create_child("test_node"); |
| let handler = |
| PointerDisplayScaleHandler::new(2.0, &test_node, metrics::MetricsLogger::default()) |
| .expect("failed to make handler"); |
| let input_event = make_unhandled_input_event(mouse_binding::MouseEvent { |
| location: mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation { |
| millimeters: Position { x: 1.5, y: 4.5 }, |
| }), |
| wheel_delta_v: None, |
| wheel_delta_h: None, |
| phase: mouse_binding::MousePhase::Move, |
| affected_buttons: hashset! {}, |
| pressed_buttons: hashset! {}, |
| is_precision_scroll: None, |
| }); |
| assert_matches!( |
| handler.clone().handle_unhandled_input_event(input_event).await.as_slice(), |
| [input_device::InputEvent { |
| device_event: |
| input_device::InputDeviceEvent::Mouse(mouse_binding::MouseEvent { |
| location: |
| mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation {millimeters: Position { x, y }}), |
| .. |
| }), |
| .. |
| }] if *x == 3.0 && *y == 9.0 |
| ); |
| } |
| |
| #[test_case( |
| mouse_binding::MouseEvent { |
| location: mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation { |
| millimeters: Position { |
| x: 1.5 / COUNTS_PER_MM, |
| y: 4.5 / COUNTS_PER_MM }, |
| }), |
| wheel_delta_v: None, |
| wheel_delta_h: None, |
| phase: mouse_binding::MousePhase::Move, |
| affected_buttons: hashset! {}, |
| pressed_buttons: hashset! {}, |
| is_precision_scroll: None, |
| }; "move event")] |
| #[test_case( |
| mouse_binding::MouseEvent { |
| location: mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation { |
| millimeters: Position::zero(), |
| }), |
| wheel_delta_v: Some(mouse_binding::WheelDelta { |
| raw_data: mouse_binding::RawWheelDelta::Ticks(1), |
| physical_pixel: Some(1.0), |
| }), |
| wheel_delta_h: None, |
| phase: mouse_binding::MousePhase::Wheel, |
| affected_buttons: hashset! {}, |
| pressed_buttons: hashset! {}, |
| is_precision_scroll: None, |
| }; "wheel event")] |
| #[fuchsia::test(allow_stalls = false)] |
| async fn does_not_consume(event: mouse_binding::MouseEvent) { |
| let inspector = fuchsia_inspect::Inspector::default(); |
| let test_node = inspector.root().create_child("test_node"); |
| let handler = |
| PointerDisplayScaleHandler::new(2.0, &test_node, metrics::MetricsLogger::default()) |
| .expect("failed to make handler"); |
| let input_event = make_unhandled_input_event(event); |
| assert_matches!( |
| handler.clone().handle_unhandled_input_event(input_event).await.as_slice(), |
| [input_device::InputEvent { handled: input_device::Handled::No, .. }] |
| ); |
| } |
| |
| #[test_case(hashset! { }; "empty buttons")] |
| #[test_case(hashset! { 1}; "one button")] |
| #[test_case(hashset! {1, 2, 3}; "multiple buttons")] |
| #[fuchsia::test(allow_stalls = false)] |
| async fn preserves_buttons_move_event(input_buttons: HashSet<u8>) { |
| let inspector = fuchsia_inspect::Inspector::default(); |
| let test_node = inspector.root().create_child("test_node"); |
| let handler = |
| PointerDisplayScaleHandler::new(2.0, &test_node, metrics::MetricsLogger::default()) |
| .expect("failed to make handler"); |
| let input_event = make_unhandled_input_event(mouse_binding::MouseEvent { |
| location: mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation { |
| millimeters: Position { x: 1.5 / COUNTS_PER_MM, y: 4.5 / COUNTS_PER_MM }, |
| }), |
| wheel_delta_v: None, |
| wheel_delta_h: None, |
| phase: mouse_binding::MousePhase::Move, |
| affected_buttons: input_buttons.clone(), |
| pressed_buttons: input_buttons.clone(), |
| is_precision_scroll: None, |
| }); |
| assert_matches!( |
| handler.clone().handle_unhandled_input_event(input_event).await.as_slice(), |
| [input_device::InputEvent { |
| device_event: |
| input_device::InputDeviceEvent::Mouse(mouse_binding::MouseEvent { affected_buttons, pressed_buttons, ..}), |
| .. |
| }] if *affected_buttons == input_buttons && *pressed_buttons == input_buttons |
| ); |
| } |
| |
| #[test_case(hashset! { }; "empty buttons")] |
| #[test_case(hashset! { 1}; "one button")] |
| #[test_case(hashset! {1, 2, 3}; "multiple buttons")] |
| #[fuchsia::test(allow_stalls = false)] |
| async fn preserves_buttons_wheel_event(input_buttons: HashSet<u8>) { |
| let inspector = fuchsia_inspect::Inspector::default(); |
| let test_node = inspector.root().create_child("test_node"); |
| let handler = |
| PointerDisplayScaleHandler::new(2.0, &test_node, metrics::MetricsLogger::default()) |
| .expect("failed to make handler"); |
| let input_event = make_unhandled_input_event(mouse_binding::MouseEvent { |
| location: mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation { |
| millimeters: Position::zero(), |
| }), |
| wheel_delta_v: Some(mouse_binding::WheelDelta { |
| raw_data: mouse_binding::RawWheelDelta::Ticks(1), |
| physical_pixel: Some(1.0), |
| }), |
| wheel_delta_h: None, |
| phase: mouse_binding::MousePhase::Wheel, |
| affected_buttons: input_buttons.clone(), |
| pressed_buttons: input_buttons.clone(), |
| is_precision_scroll: None, |
| }); |
| assert_matches!( |
| handler.clone().handle_unhandled_input_event(input_event).await.as_slice(), |
| [input_device::InputEvent { |
| device_event: |
| input_device::InputDeviceEvent::Mouse(mouse_binding::MouseEvent { affected_buttons, pressed_buttons, ..}), |
| .. |
| }] if *affected_buttons == input_buttons && *pressed_buttons == input_buttons |
| ); |
| } |
| |
| #[test_case( |
| mouse_binding::MouseEvent { |
| location: mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation { |
| millimeters: Position { |
| x: 1.5 / COUNTS_PER_MM, |
| y: 4.5 / COUNTS_PER_MM }, |
| }), |
| wheel_delta_v: None, |
| wheel_delta_h: None, |
| phase: mouse_binding::MousePhase::Move, |
| affected_buttons: hashset! {}, |
| pressed_buttons: hashset! {}, |
| is_precision_scroll: None, |
| }; "move event")] |
| #[test_case( |
| mouse_binding::MouseEvent { |
| location: mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation { |
| millimeters: Position::zero(), |
| }), |
| wheel_delta_v: Some(mouse_binding::WheelDelta { |
| raw_data: mouse_binding::RawWheelDelta::Ticks(1), |
| physical_pixel: Some(1.0), |
| }), |
| wheel_delta_h: None, |
| phase: mouse_binding::MousePhase::Wheel, |
| affected_buttons: hashset! {}, |
| pressed_buttons: hashset! {}, |
| is_precision_scroll: None, |
| }; "wheel event")] |
| #[fuchsia::test(allow_stalls = false)] |
| async fn preserves_descriptor(event: mouse_binding::MouseEvent) { |
| let inspector = fuchsia_inspect::Inspector::default(); |
| let test_node = inspector.root().create_child("test_node"); |
| let handler = |
| PointerDisplayScaleHandler::new(2.0, &test_node, metrics::MetricsLogger::default()) |
| .expect("failed to make handler"); |
| let input_event = make_unhandled_input_event(event); |
| assert_matches!( |
| handler.clone().handle_unhandled_input_event(input_event).await.as_slice(), |
| [input_device::InputEvent { device_descriptor: DEVICE_DESCRIPTOR, .. }] |
| ); |
| } |
| |
| #[test_case( |
| mouse_binding::MouseEvent { |
| location: mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation { |
| millimeters: Position { |
| x: 1.5 / COUNTS_PER_MM, |
| y: 4.5 / COUNTS_PER_MM }, |
| }), |
| wheel_delta_v: None, |
| wheel_delta_h: None, |
| phase: mouse_binding::MousePhase::Move, |
| affected_buttons: hashset! {}, |
| pressed_buttons: hashset! {}, |
| is_precision_scroll: None, |
| }; "move event")] |
| #[test_case( |
| mouse_binding::MouseEvent { |
| location: mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation { |
| millimeters: Position::zero(), |
| }), |
| wheel_delta_v: Some(mouse_binding::WheelDelta { |
| raw_data: mouse_binding::RawWheelDelta::Ticks(1), |
| physical_pixel: Some(1.0), |
| }), |
| wheel_delta_h: None, |
| phase: mouse_binding::MousePhase::Wheel, |
| affected_buttons: hashset! {}, |
| pressed_buttons: hashset! {}, |
| is_precision_scroll: None, |
| }; "wheel event")] |
| #[fuchsia::test(allow_stalls = false)] |
| async fn preserves_event_time(event: mouse_binding::MouseEvent) { |
| let inspector = fuchsia_inspect::Inspector::default(); |
| let test_node = inspector.root().create_child("test_node"); |
| let handler = |
| PointerDisplayScaleHandler::new(2.0, &test_node, metrics::MetricsLogger::default()) |
| .expect("failed to make handler"); |
| let mut input_event = make_unhandled_input_event(event); |
| const EVENT_TIME: zx::Time = zx::Time::from_nanos(42); |
| input_event.event_time = EVENT_TIME; |
| assert_matches!( |
| handler.clone().handle_unhandled_input_event(input_event).await.as_slice(), |
| [input_device::InputEvent { event_time: EVENT_TIME, .. }] |
| ); |
| } |
| |
| #[test_case( |
| mouse_binding::MouseEvent { |
| location: mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation { |
| millimeters: Position::zero(), |
| }), |
| wheel_delta_v: Some(mouse_binding::WheelDelta { |
| raw_data: mouse_binding::RawWheelDelta::Ticks(1), |
| physical_pixel: Some(1.0), |
| }), |
| wheel_delta_h: None, |
| phase: mouse_binding::MousePhase::Wheel, |
| affected_buttons: hashset! {}, |
| pressed_buttons: hashset! {}, |
| is_precision_scroll: Some(mouse_binding::PrecisionScroll::No), |
| } => matches input_device::InputEvent { |
| device_event: input_device::InputDeviceEvent::Mouse(mouse_binding::MouseEvent { |
| is_precision_scroll: Some(mouse_binding::PrecisionScroll::No), |
| .. |
| }), |
| .. |
| }; "no")] |
| #[test_case( |
| mouse_binding::MouseEvent { |
| location: mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation { |
| millimeters: Position::zero(), |
| }), |
| wheel_delta_v: Some(mouse_binding::WheelDelta { |
| raw_data: mouse_binding::RawWheelDelta::Ticks(1), |
| physical_pixel: Some(1.0), |
| }), |
| wheel_delta_h: None, |
| phase: mouse_binding::MousePhase::Wheel, |
| affected_buttons: hashset! {}, |
| pressed_buttons: hashset! {}, |
| is_precision_scroll: Some(mouse_binding::PrecisionScroll::Yes), |
| } => matches input_device::InputEvent { |
| device_event: input_device::InputDeviceEvent::Mouse(mouse_binding::MouseEvent { |
| is_precision_scroll: Some(mouse_binding::PrecisionScroll::Yes), |
| .. |
| }), |
| .. |
| }; "yes")] |
| #[fuchsia::test(allow_stalls = false)] |
| async fn preserves_is_precision_scroll( |
| event: mouse_binding::MouseEvent, |
| ) -> input_device::InputEvent { |
| let inspector = fuchsia_inspect::Inspector::default(); |
| let test_node = inspector.root().create_child("test_node"); |
| let handler = |
| PointerDisplayScaleHandler::new(2.0, &test_node, metrics::MetricsLogger::default()) |
| .expect("failed to make handler"); |
| let input_event = make_unhandled_input_event(event); |
| |
| handler.clone().handle_unhandled_input_event(input_event).await[0].clone() |
| } |
| |
| #[test_case( |
| Some(mouse_binding::WheelDelta { |
| raw_data: mouse_binding::RawWheelDelta::Ticks(1), |
| physical_pixel: Some(1.0), |
| }), |
| None => (Some(2.0), None); "v tick h none" |
| )] |
| #[test_case( |
| None, Some(mouse_binding::WheelDelta { |
| raw_data: mouse_binding::RawWheelDelta::Ticks(1), |
| physical_pixel: Some(1.0), |
| }) => (None, Some(2.0)); "v none h tick" |
| )] |
| #[test_case( |
| Some(mouse_binding::WheelDelta { |
| raw_data: mouse_binding::RawWheelDelta::Millimeters(1.0), |
| physical_pixel: Some(1.0), |
| }), |
| None => (Some(2.0), None); "v mm h none" |
| )] |
| #[test_case( |
| None, Some(mouse_binding::WheelDelta { |
| raw_data: mouse_binding::RawWheelDelta::Millimeters(1.0), |
| physical_pixel: Some(1.0), |
| }) => (None, Some(2.0)); "v none h mm" |
| )] |
| #[fuchsia::test(allow_stalls = false)] |
| async fn applied_scale_scroll_event( |
| wheel_delta_v: Option<mouse_binding::WheelDelta>, |
| wheel_delta_h: Option<mouse_binding::WheelDelta>, |
| ) -> (Option<f32>, Option<f32>) { |
| let inspector = fuchsia_inspect::Inspector::default(); |
| let test_node = inspector.root().create_child("test_node"); |
| let handler = |
| PointerDisplayScaleHandler::new(2.0, &test_node, metrics::MetricsLogger::default()) |
| .expect("failed to make handler"); |
| let input_event = make_unhandled_input_event(mouse_binding::MouseEvent { |
| location: mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation { |
| millimeters: Position::zero(), |
| }), |
| wheel_delta_v, |
| wheel_delta_h, |
| phase: mouse_binding::MousePhase::Wheel, |
| affected_buttons: hashset! {}, |
| pressed_buttons: hashset! {}, |
| is_precision_scroll: None, |
| }); |
| let events = handler.clone().handle_unhandled_input_event(input_event).await; |
| assert_matches!( |
| events.as_slice(), |
| [input_device::InputEvent { |
| device_event: input_device::InputDeviceEvent::Mouse( |
| mouse_binding::MouseEvent { .. } |
| ), |
| .. |
| }] |
| ); |
| if let input_device::InputEvent { |
| device_event: |
| input_device::InputDeviceEvent::Mouse(mouse_binding::MouseEvent { |
| wheel_delta_v, |
| wheel_delta_h, |
| .. |
| }), |
| .. |
| } = events[0].clone() |
| { |
| match (wheel_delta_v, wheel_delta_h) { |
| (None, None) => return (None, None), |
| (None, Some(delta_h)) => return (None, delta_h.physical_pixel), |
| (Some(delta_v), None) => return (delta_v.physical_pixel, None), |
| (Some(delta_v), Some(delta_h)) => { |
| return (delta_v.physical_pixel, delta_h.physical_pixel) |
| } |
| } |
| } else { |
| unreachable!(); |
| } |
| } |
| |
| #[fuchsia::test] |
| fn pointer_display_scale_handler_initialized_with_inspect_node() { |
| let inspector = fuchsia_inspect::Inspector::default(); |
| let fake_handlers_node = inspector.root().create_child("input_handlers_node"); |
| let _handler = PointerDisplayScaleHandler::new( |
| 1.0, |
| &fake_handlers_node, |
| metrics::MetricsLogger::default(), |
| ); |
| diagnostics_assertions::assert_data_tree!(inspector, root: { |
| input_handlers_node: { |
| pointer_display_scale_handler: { |
| events_received_count: 0u64, |
| events_handled_count: 0u64, |
| last_received_timestamp_ns: 0u64, |
| "fuchsia.inspect.Health": { |
| status: "STARTING_UP", |
| // Timestamp value is unpredictable and not relevant in this context, |
| // so we only assert that the property is present. |
| start_timestamp_nanos: diagnostics_assertions::AnyProperty |
| }, |
| } |
| } |
| }); |
| } |
| |
| #[fasync::run_singlethreaded(test)] |
| async fn pointer_display_scale_handler_inspect_counts_events() { |
| let inspector = fuchsia_inspect::Inspector::default(); |
| let fake_handlers_node = inspector.root().create_child("input_handlers_node"); |
| let handler = PointerDisplayScaleHandler::new( |
| 1.0, |
| &fake_handlers_node, |
| metrics::MetricsLogger::default(), |
| ) |
| .expect("failed to make handler"); |
| |
| let event_time1 = zx::Time::get_monotonic(); |
| let event_time2 = event_time1.add(fuchsia_zircon::Duration::from_micros(1)); |
| let event_time3 = event_time2.add(fuchsia_zircon::Duration::from_micros(1)); |
| |
| let input_events = vec![ |
| testing_utilities::create_mouse_event( |
| mouse_binding::MouseLocation::Absolute(Position { x: 0.0, y: 0.0 }), |
| None, /* wheel_delta_v */ |
| None, /* wheel_delta_h */ |
| None, /* is_precision_scroll */ |
| mouse_binding::MousePhase::Wheel, |
| hashset! {}, |
| hashset! {}, |
| event_time1, |
| &DEVICE_DESCRIPTOR, |
| ), |
| testing_utilities::create_mouse_event( |
| mouse_binding::MouseLocation::Relative(mouse_binding::RelativeLocation { |
| millimeters: Position { x: 1.5 / COUNTS_PER_MM, y: 4.5 / COUNTS_PER_MM }, |
| }), |
| None, /* wheel_delta_v */ |
| None, /* wheel_delta_h */ |
| None, /* is_precision_scroll */ |
| mouse_binding::MousePhase::Move, |
| hashset! {}, |
| hashset! {}, |
| event_time2, |
| &DEVICE_DESCRIPTOR, |
| ), |
| // Should not count non-mouse input events. |
| testing_utilities::create_fake_input_event(event_time2), |
| // Should not count received events that have already been handled. |
| testing_utilities::create_mouse_event_with_handled( |
| mouse_binding::MouseLocation::Absolute(Position { x: 0.0, y: 0.0 }), |
| None, /* wheel_delta_v */ |
| None, /* wheel_delta_h */ |
| None, /* is_precision_scroll */ |
| mouse_binding::MousePhase::Wheel, |
| hashset! {}, |
| hashset! {}, |
| event_time3, |
| &DEVICE_DESCRIPTOR, |
| input_device::Handled::Yes, |
| ), |
| ]; |
| |
| for input_event in input_events { |
| let _ = handler.clone().handle_input_event(input_event).await; |
| } |
| |
| let last_received_event_time: u64 = event_time2.into_nanos().try_into().unwrap(); |
| |
| diagnostics_assertions::assert_data_tree!(inspector, root: { |
| input_handlers_node: { |
| pointer_display_scale_handler: { |
| events_received_count: 2u64, |
| events_handled_count: 0u64, |
| last_received_timestamp_ns: last_received_event_time, |
| "fuchsia.inspect.Health": { |
| status: "STARTING_UP", |
| // Timestamp value is unpredictable and not relevant in this context, |
| // so we only assert that the property is present. |
| start_timestamp_nanos: diagnostics_assertions::AnyProperty |
| }, |
| } |
| } |
| }); |
| } |
| } |
