input_pipeline/
touch_binding.rs

1// Copyright 2019 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::input_device::{self, Handled, InputDeviceBinding, InputDeviceStatus, InputEvent};
6use crate::utils::{Position, Size};
7use crate::{metrics, mouse_binding};
8use anyhow::{format_err, Context, Error};
9use async_trait::async_trait;
10use fidl_fuchsia_input_report::{InputDeviceProxy, InputReport};
11use fuchsia_inspect::health::Reporter;
12use fuchsia_inspect::ArrayProperty;
13use futures::channel::mpsc::{UnboundedReceiver, UnboundedSender};
14use maplit::hashmap;
15use metrics_registry::*;
16use std::collections::{HashMap, HashSet};
17use {
18    fidl_fuchsia_input_report as fidl_input_report, fidl_fuchsia_ui_input as fidl_ui_input,
19    fidl_fuchsia_ui_pointerinjector as pointerinjector,
20};
21
22/// A [`TouchScreenEvent`] represents a set of contacts and the phase those contacts are in.
23///
24/// For example, when a user touches a touch screen with two fingers, there will be two
25/// [`TouchContact`]s. When a user removes one finger, there will still be two contacts
26/// but one will be reported as removed.
27///
28/// The expected sequence for any given contact is:
29/// 1. [`fidl_fuchsia_ui_input::PointerEventPhase::Add`]
30/// 2. [`fidl_fuchsia_ui_input::PointerEventPhase::Down`]
31/// 3. 0 or more [`fidl_fuchsia_ui_input::PointerEventPhase::Move`]
32/// 4. [`fidl_fuchsia_ui_input::PointerEventPhase::Up`]
33/// 5. [`fidl_fuchsia_ui_input::PointerEventPhase::Remove`]
34///
35/// Additionally, a [`fidl_fuchsia_ui_input::PointerEventPhase::Cancel`] may be sent at any time
36/// signalling that the event is no longer directed towards the receiver.
37#[derive(Clone, Debug, PartialEq)]
38pub struct TouchScreenEvent {
39    /// Deprecated. To be removed with https://fxbug.dev/42155652.
40    /// The contacts associated with the touch event. For example, a two-finger touch would result
41    /// in one touch event with two [`TouchContact`]s.
42    ///
43    /// Contacts are grouped based on their current phase (e.g., down, move).
44    pub contacts: HashMap<fidl_ui_input::PointerEventPhase, Vec<TouchContact>>,
45
46    /// The contacts associated with the touch event. For example, a two-finger touch would result
47    /// in one touch event with two [`TouchContact`]s.
48    ///
49    /// Contacts are grouped based on their current phase (e.g., add, change).
50    pub injector_contacts: HashMap<pointerinjector::EventPhase, Vec<TouchContact>>,
51}
52
53impl TouchScreenEvent {
54    pub fn record_inspect(&self, node: &fuchsia_inspect::Node) {
55        let contacts_clone = self.injector_contacts.clone();
56        node.record_child("injector_contacts", move |contacts_node| {
57            for (phase, contacts) in contacts_clone.iter() {
58                let phase_str = match phase {
59                    pointerinjector::EventPhase::Add => "add",
60                    pointerinjector::EventPhase::Change => "change",
61                    pointerinjector::EventPhase::Remove => "remove",
62                    pointerinjector::EventPhase::Cancel => "cancel",
63                };
64                contacts_node.record_child(phase_str, move |phase_node| {
65                    for contact in contacts.iter() {
66                        phase_node.record_child(contact.id.to_string(), move |contact_node| {
67                            contact_node
68                                .record_double("position_x_mm", f64::from(contact.position.x));
69                            contact_node
70                                .record_double("position_y_mm", f64::from(contact.position.y));
71                            if let Some(pressure) = contact.pressure {
72                                contact_node.record_int("pressure", pressure);
73                            }
74                            if let Some(contact_size) = contact.contact_size {
75                                contact_node.record_double(
76                                    "contact_width_mm",
77                                    f64::from(contact_size.width),
78                                );
79                                contact_node.record_double(
80                                    "contact_height_mm",
81                                    f64::from(contact_size.height),
82                                );
83                            }
84                        });
85                    }
86                });
87            }
88        });
89    }
90}
91
92/// A [`TouchpadEvent`] represents a set of contacts.
93///
94/// For example, when a user touches a touch screen with two fingers, there will be two
95/// [`TouchContact`]s in the vector.
96#[derive(Clone, Debug, PartialEq)]
97pub struct TouchpadEvent {
98    /// The contacts associated with the touch event. For example, a two-finger touch would result
99    /// in one touch event with two [`TouchContact`]s.
100    pub injector_contacts: Vec<TouchContact>,
101
102    /// The complete button state including this event.
103    pub pressed_buttons: HashSet<mouse_binding::MouseButton>,
104}
105
106impl TouchpadEvent {
107    pub fn record_inspect(&self, node: &fuchsia_inspect::Node) {
108        let pressed_buttons_node =
109            node.create_uint_array("pressed_buttons", self.pressed_buttons.len());
110        self.pressed_buttons.iter().enumerate().for_each(|(i, button)| {
111            pressed_buttons_node.set(i, *button);
112        });
113        node.record(pressed_buttons_node);
114
115        // Populate TouchpadEvent contact details.
116        let contacts_clone = self.injector_contacts.clone();
117        node.record_child("injector_contacts", move |contacts_node| {
118            for contact in contacts_clone.iter() {
119                contacts_node.record_child(contact.id.to_string(), move |contact_node| {
120                    contact_node.record_double("position_x_mm", f64::from(contact.position.x));
121                    contact_node.record_double("position_y_mm", f64::from(contact.position.y));
122                    if let Some(pressure) = contact.pressure {
123                        contact_node.record_int("pressure", pressure);
124                    }
125                    if let Some(contact_size) = contact.contact_size {
126                        contact_node
127                            .record_double("contact_width_mm", f64::from(contact_size.width));
128                        contact_node
129                            .record_double("contact_height_mm", f64::from(contact_size.height));
130                    }
131                })
132            }
133        });
134    }
135}
136
137/// [`TouchDeviceType`] indicates the type of touch device. Both Touch Screen and Windows Precision
138/// Touchpad send touch event from driver but need different process inside input pipeline.
139#[derive(Clone, Copy, Debug, Eq, PartialEq)]
140pub enum TouchDeviceType {
141    TouchScreen,
142    WindowsPrecisionTouchpad,
143}
144
145/// A [`TouchContact`] represents a single contact (e.g., one touch of a multi-touch gesture) related
146/// to a touch event.
147#[derive(Clone, Copy, Debug, PartialEq)]
148pub struct TouchContact {
149    /// The identifier of the contact. Unique per touch device.
150    pub id: u32,
151
152    /// The position of the touch event, in the units of the associated
153    /// [`ContactDeviceDescriptor`]'s `range`.
154    pub position: Position,
155
156    /// The pressure associated with the contact, in the units of the associated
157    /// [`ContactDeviceDescriptor`]'s `pressure_range`.
158    pub pressure: Option<i64>,
159
160    /// The size of the touch event, in the units of the associated
161    /// [`ContactDeviceDescriptor`]'s `range`.
162    pub contact_size: Option<Size>,
163}
164
165impl Eq for TouchContact {}
166
167impl From<&fidl_fuchsia_input_report::ContactInputReport> for TouchContact {
168    fn from(fidl_contact: &fidl_fuchsia_input_report::ContactInputReport) -> TouchContact {
169        let contact_size =
170            if fidl_contact.contact_width.is_some() && fidl_contact.contact_height.is_some() {
171                Some(Size {
172                    width: fidl_contact.contact_width.unwrap() as f32,
173                    height: fidl_contact.contact_height.unwrap() as f32,
174                })
175            } else {
176                None
177            };
178
179        TouchContact {
180            id: fidl_contact.contact_id.unwrap_or_default(),
181            position: Position {
182                x: fidl_contact.position_x.unwrap_or_default() as f32,
183                y: fidl_contact.position_y.unwrap_or_default() as f32,
184            },
185            pressure: fidl_contact.pressure,
186            contact_size,
187        }
188    }
189}
190
191#[derive(Clone, Debug, Eq, PartialEq)]
192pub struct TouchScreenDeviceDescriptor {
193    /// The id of the connected touch screen input device.
194    pub device_id: u32,
195
196    /// The descriptors for the possible contacts associated with the device.
197    pub contacts: Vec<ContactDeviceDescriptor>,
198}
199
200#[derive(Clone, Debug, Eq, PartialEq)]
201pub struct TouchpadDeviceDescriptor {
202    /// The id of the connected touchpad input device.
203    pub device_id: u32,
204
205    /// The descriptors for the possible contacts associated with the device.
206    pub contacts: Vec<ContactDeviceDescriptor>,
207}
208
209#[derive(Clone, Debug, Eq, PartialEq)]
210enum TouchDeviceDescriptor {
211    TouchScreen(TouchScreenDeviceDescriptor),
212    Touchpad(TouchpadDeviceDescriptor),
213}
214
215/// A [`ContactDeviceDescriptor`] describes the possible values touch contact properties can take on.
216///
217/// This descriptor can be used, for example, to determine where on a screen a touch made contact.
218///
219/// # Example
220///
221/// ```
222/// // Determine the scaling factor between the display and the touch device's x range.
223/// let scaling_factor =
224///     display_width / (contact_descriptor._x_range.end - contact_descriptor._x_range.start);
225/// // Use the scaling factor to scale the contact report's x position.
226/// let hit_location =
227///     scaling_factor * (contact_report.position_x - contact_descriptor._x_range.start);
228#[derive(Clone, Debug, Eq, PartialEq)]
229pub struct ContactDeviceDescriptor {
230    /// The range of possible x values for this touch contact.
231    pub x_range: fidl_input_report::Range,
232
233    /// The range of possible y values for this touch contact.
234    pub y_range: fidl_input_report::Range,
235
236    /// The unit of measure for `x_range`.
237    pub x_unit: fidl_input_report::Unit,
238
239    /// The unit of measure for `y_range`.
240    pub y_unit: fidl_input_report::Unit,
241
242    /// The range of possible pressure values for this touch contact.
243    pub pressure_range: Option<fidl_input_report::Range>,
244
245    /// The range of possible widths for this touch contact.
246    pub width_range: Option<fidl_input_report::Range>,
247
248    /// The range of possible heights for this touch contact.
249    pub height_range: Option<fidl_input_report::Range>,
250}
251
252/// A [`TouchBinding`] represents a connection to a touch input device.
253///
254/// The [`TouchBinding`] parses and exposes touch descriptor properties (e.g., the range of
255/// possible x values for touch contacts) for the device it is associated with.
256/// It also parses [`InputReport`]s from the device, and sends them to the device binding owner over
257/// `event_sender`.
258pub struct TouchBinding {
259    /// The channel to stream InputEvents to.
260    event_sender: UnboundedSender<InputEvent>,
261
262    /// Holds information about this device.
263    device_descriptor: TouchDeviceDescriptor,
264
265    /// Touch device type of the touch device.
266    touch_device_type: TouchDeviceType,
267
268    /// Proxy to the device.
269    device_proxy: InputDeviceProxy,
270}
271
272#[async_trait]
273impl input_device::InputDeviceBinding for TouchBinding {
274    fn input_event_sender(&self) -> UnboundedSender<InputEvent> {
275        self.event_sender.clone()
276    }
277
278    fn get_device_descriptor(&self) -> input_device::InputDeviceDescriptor {
279        match self.device_descriptor.clone() {
280            TouchDeviceDescriptor::TouchScreen(desc) => {
281                input_device::InputDeviceDescriptor::TouchScreen(desc)
282            }
283            TouchDeviceDescriptor::Touchpad(desc) => {
284                input_device::InputDeviceDescriptor::Touchpad(desc)
285            }
286        }
287    }
288}
289
290impl TouchBinding {
291    /// Creates a new [`InputDeviceBinding`] from the `device_proxy`.
292    ///
293    /// The binding will start listening for input reports immediately and send new InputEvents
294    /// to the device binding owner over `input_event_sender`.
295    ///
296    /// # Parameters
297    /// - `device_proxy`: The proxy to bind the new [`InputDeviceBinding`] to.
298    /// - `device_id`: The id of the connected touch device.
299    /// - `input_event_sender`: The channel to send new InputEvents to.
300    /// - `device_node`: The inspect node for this device binding
301    /// - `metrics_logger`: The metrics logger.
302    ///
303    /// # Errors
304    /// If there was an error binding to the proxy.
305    pub async fn new(
306        device_proxy: InputDeviceProxy,
307        device_id: u32,
308        input_event_sender: UnboundedSender<input_device::InputEvent>,
309        device_node: fuchsia_inspect::Node,
310        metrics_logger: metrics::MetricsLogger,
311    ) -> Result<Self, Error> {
312        let (device_binding, mut inspect_status) =
313            Self::bind_device(device_proxy.clone(), device_id, input_event_sender, device_node)
314                .await?;
315        device_binding
316            .set_touchpad_mode(true)
317            .await
318            .with_context(|| format!("enabling touchpad mode for device {}", device_id))?;
319        inspect_status.health_node.set_ok();
320        input_device::initialize_report_stream(
321            device_proxy,
322            device_binding.get_device_descriptor(),
323            device_binding.input_event_sender(),
324            inspect_status,
325            metrics_logger,
326            Self::process_reports,
327        );
328
329        Ok(device_binding)
330    }
331
332    /// Binds the provided input device to a new instance of `Self`.
333    ///
334    /// # Parameters
335    /// - `device`: The device to use to initialize the binding.
336    /// - `device_id`: The id of the connected touch device.
337    /// - `input_event_sender`: The channel to send new InputEvents to.
338    /// - `device_node`: The inspect node for this device binding
339    ///
340    /// # Errors
341    /// If the device descriptor could not be retrieved, or the descriptor could not be parsed
342    /// correctly.
343    async fn bind_device(
344        device_proxy: InputDeviceProxy,
345        device_id: u32,
346        input_event_sender: UnboundedSender<input_device::InputEvent>,
347        device_node: fuchsia_inspect::Node,
348    ) -> Result<(Self, InputDeviceStatus), Error> {
349        let mut input_device_status = InputDeviceStatus::new(device_node);
350        let device_descriptor: fidl_input_report::DeviceDescriptor = match device_proxy
351            .get_descriptor()
352            .await
353        {
354            Ok(descriptor) => descriptor,
355            Err(_) => {
356                input_device_status.health_node.set_unhealthy("Could not get device descriptor.");
357                return Err(format_err!("Could not get descriptor for device_id: {}", device_id));
358            }
359        };
360
361        let touch_device_type = get_device_type(&device_proxy).await;
362
363        match device_descriptor.touch {
364            Some(fidl_fuchsia_input_report::TouchDescriptor {
365                input:
366                    Some(fidl_fuchsia_input_report::TouchInputDescriptor {
367                        contacts: Some(contact_descriptors),
368                        max_contacts: _,
369                        touch_type: _,
370                        buttons: _,
371                        ..
372                    }),
373                ..
374            }) => Ok((
375                TouchBinding {
376                    event_sender: input_event_sender,
377                    device_descriptor: match touch_device_type {
378                        TouchDeviceType::TouchScreen => {
379                            TouchDeviceDescriptor::TouchScreen(TouchScreenDeviceDescriptor {
380                                device_id,
381                                contacts: contact_descriptors
382                                    .iter()
383                                    .map(TouchBinding::parse_contact_descriptor)
384                                    .filter_map(Result::ok)
385                                    .collect(),
386                            })
387                        }
388                        TouchDeviceType::WindowsPrecisionTouchpad => {
389                            TouchDeviceDescriptor::Touchpad(TouchpadDeviceDescriptor {
390                                device_id,
391                                contacts: contact_descriptors
392                                    .iter()
393                                    .map(TouchBinding::parse_contact_descriptor)
394                                    .filter_map(Result::ok)
395                                    .collect(),
396                            })
397                        }
398                    },
399                    touch_device_type,
400                    device_proxy,
401                },
402                input_device_status,
403            )),
404            descriptor => {
405                input_device_status
406                    .health_node
407                    .set_unhealthy("Touch Device Descriptor failed to parse.");
408                Err(format_err!("Touch Descriptor failed to parse: \n {:?}", descriptor))
409            }
410        }
411    }
412
413    async fn set_touchpad_mode(&self, enable: bool) -> Result<(), Error> {
414        match self.touch_device_type {
415            TouchDeviceType::TouchScreen => Ok(()),
416            TouchDeviceType::WindowsPrecisionTouchpad => {
417                // `get_feature_report` to only modify the input_mode and
418                // keep other feature as is.
419                let mut report = match self.device_proxy.get_feature_report().await? {
420                    Ok(report) => report,
421                    Err(e) => return Err(format_err!("get_feature_report failed: {}", e)),
422                };
423                let mut touch =
424                    report.touch.unwrap_or_else(fidl_input_report::TouchFeatureReport::default);
425                touch.input_mode = match enable {
426                            true => Some(fidl_input_report::TouchConfigurationInputMode::WindowsPrecisionTouchpadCollection),
427                            false => Some(fidl_input_report::TouchConfigurationInputMode::MouseCollection),
428                        };
429                report.touch = Some(touch);
430                match self.device_proxy.set_feature_report(&report).await? {
431                    Ok(()) => {
432                        // TODO(https://fxbug.dev/42056283): Remove log message.
433                        log::info!("touchpad: set touchpad_enabled to {}", enable);
434                        Ok(())
435                    }
436                    Err(e) => Err(format_err!("set_feature_report failed: {}", e)),
437                }
438            }
439        }
440    }
441
442    /// Parses an [`InputReport`] into one or more [`InputEvent`]s.
443    ///
444    /// The [`InputEvent`]s are sent to the device binding owner via [`input_event_sender`].
445    ///
446    /// # Parameters
447    /// - `report`: The incoming [`InputReport`].
448    /// - `previous_report`: The previous [`InputReport`] seen for the same device. This can be
449    ///                    used to determine, for example, which keys are no longer present in
450    ///                    a keyboard report to generate key released events. If `None`, no
451    ///                    previous report was found.
452    /// - `device_descriptor`: The descriptor for the input device generating the input reports.
453    /// - `input_event_sender`: The sender for the device binding's input event stream.
454    ///
455    /// # Returns
456    /// An [`InputReport`] which will be passed to the next call to [`process_reports`], as
457    /// [`previous_report`]. If `None`, the next call's [`previous_report`] will be `None`.
458    /// A [`UnboundedReceiver<InputEvent>`] which will poll asynchronously generated events to be
459    /// recorded by `inspect_status` in `input_device::initialize_report_stream()`. If device
460    /// binding does not generate InputEvents asynchronously, this will be `None`.
461    fn process_reports(
462        report: InputReport,
463        previous_report: Option<InputReport>,
464        device_descriptor: &input_device::InputDeviceDescriptor,
465        input_event_sender: &mut UnboundedSender<InputEvent>,
466        inspect_status: &InputDeviceStatus,
467        metrics_logger: &metrics::MetricsLogger,
468    ) -> (Option<InputReport>, Option<UnboundedReceiver<InputEvent>>) {
469        inspect_status.count_received_report(&report);
470        match device_descriptor {
471            input_device::InputDeviceDescriptor::TouchScreen(_) => process_touch_screen_reports(
472                report,
473                previous_report,
474                device_descriptor,
475                input_event_sender,
476                inspect_status,
477                metrics_logger,
478            ),
479            input_device::InputDeviceDescriptor::Touchpad(_) => process_touchpad_reports(
480                report,
481                device_descriptor,
482                input_event_sender,
483                inspect_status,
484                metrics_logger,
485            ),
486            _ => (None, None),
487        }
488    }
489
490    /// Parses a fidl_input_report contact descriptor into a [`ContactDeviceDescriptor`]
491    ///
492    /// # Parameters
493    /// - `contact_device_descriptor`: The contact descriptor to parse.
494    ///
495    /// # Errors
496    /// If the contact description fails to parse because required fields aren't present.
497    fn parse_contact_descriptor(
498        contact_device_descriptor: &fidl_input_report::ContactInputDescriptor,
499    ) -> Result<ContactDeviceDescriptor, Error> {
500        match contact_device_descriptor {
501            fidl_input_report::ContactInputDescriptor {
502                position_x: Some(x_axis),
503                position_y: Some(y_axis),
504                pressure: pressure_axis,
505                contact_width: width_axis,
506                contact_height: height_axis,
507                ..
508            } => Ok(ContactDeviceDescriptor {
509                x_range: x_axis.range,
510                y_range: y_axis.range,
511                x_unit: x_axis.unit,
512                y_unit: y_axis.unit,
513                pressure_range: pressure_axis.map(|axis| axis.range),
514                width_range: width_axis.map(|axis| axis.range),
515                height_range: height_axis.map(|axis| axis.range),
516            }),
517            descriptor => {
518                Err(format_err!("Touch Contact Descriptor failed to parse: \n {:?}", descriptor))
519            }
520        }
521    }
522}
523
524fn process_touch_screen_reports(
525    report: InputReport,
526    previous_report: Option<InputReport>,
527    device_descriptor: &input_device::InputDeviceDescriptor,
528    input_event_sender: &mut UnboundedSender<InputEvent>,
529    inspect_status: &InputDeviceStatus,
530    metrics_logger: &metrics::MetricsLogger,
531) -> (Option<InputReport>, Option<UnboundedReceiver<InputEvent>>) {
532    fuchsia_trace::duration!(c"input", c"touch-binding-process-report");
533    fuchsia_trace::flow_end!(c"input", c"input_report", report.trace_id.unwrap_or(0).into());
534
535    // Input devices can have multiple types so ensure `report` is a TouchInputReport.
536    let touch_report: &fidl_fuchsia_input_report::TouchInputReport = match &report.touch {
537        Some(touch) => touch,
538        None => {
539            inspect_status.count_filtered_report();
540            return (previous_report, None);
541        }
542    };
543
544    let previous_contacts: HashMap<u32, TouchContact> = previous_report
545        .as_ref()
546        .and_then(|unwrapped_report| unwrapped_report.touch.as_ref())
547        .map(touch_contacts_from_touch_report)
548        .unwrap_or_default();
549    let current_contacts: HashMap<u32, TouchContact> =
550        touch_contacts_from_touch_report(touch_report);
551
552    // Don't send an event if there are no new contacts.
553    if previous_contacts.is_empty() && current_contacts.is_empty() {
554        inspect_status.count_filtered_report();
555        return (Some(report), None);
556    }
557
558    // Contacts which exist only in current.
559    let added_contacts: Vec<TouchContact> = Vec::from_iter(
560        current_contacts
561            .values()
562            .cloned()
563            .filter(|contact| !previous_contacts.contains_key(&contact.id)),
564    );
565    // Contacts which exist in both previous and current.
566    let moved_contacts: Vec<TouchContact> = Vec::from_iter(
567        current_contacts
568            .values()
569            .cloned()
570            .filter(|contact| previous_contacts.contains_key(&contact.id)),
571    );
572    // Contacts which exist only in previous.
573    let removed_contacts: Vec<TouchContact> = Vec::from_iter(
574        previous_contacts
575            .values()
576            .cloned()
577            .filter(|contact| !current_contacts.contains_key(&contact.id)),
578    );
579
580    let trace_id = fuchsia_trace::Id::new();
581    fuchsia_trace::flow_begin!(c"input", c"report-to-event", trace_id);
582    send_touch_screen_event(
583        hashmap! {
584            fidl_ui_input::PointerEventPhase::Add => added_contacts.clone(),
585            fidl_ui_input::PointerEventPhase::Down => added_contacts.clone(),
586            fidl_ui_input::PointerEventPhase::Move => moved_contacts.clone(),
587            fidl_ui_input::PointerEventPhase::Up => removed_contacts.clone(),
588            fidl_ui_input::PointerEventPhase::Remove => removed_contacts.clone(),
589        },
590        hashmap! {
591            pointerinjector::EventPhase::Add => added_contacts,
592            pointerinjector::EventPhase::Change => moved_contacts,
593            pointerinjector::EventPhase::Remove => removed_contacts,
594        },
595        device_descriptor,
596        input_event_sender,
597        trace_id,
598        inspect_status,
599        metrics_logger,
600    );
601
602    (Some(report), None)
603}
604
605fn process_touchpad_reports(
606    report: InputReport,
607    device_descriptor: &input_device::InputDeviceDescriptor,
608    input_event_sender: &mut UnboundedSender<InputEvent>,
609    inspect_status: &InputDeviceStatus,
610    metrics_logger: &metrics::MetricsLogger,
611) -> (Option<InputReport>, Option<UnboundedReceiver<InputEvent>>) {
612    fuchsia_trace::duration!(c"input", c"touch-binding-process-report");
613    fuchsia_trace::flow_end!(c"input", c"input_report", report.trace_id.unwrap_or(0).into());
614
615    // Input devices can have multiple types so ensure `report` is a TouchInputReport.
616    let touch_report: &fidl_fuchsia_input_report::TouchInputReport = match &report.touch {
617        Some(touch) => touch,
618        None => {
619            inspect_status.count_filtered_report();
620            return (None, None);
621        }
622    };
623
624    let current_contacts: Vec<TouchContact> = touch_report
625        .contacts
626        .as_ref()
627        .and_then(|unwrapped_contacts| {
628            // Once the contacts are found, convert them into `TouchContact`s.
629            Some(unwrapped_contacts.iter().map(TouchContact::from).collect())
630        })
631        .unwrap_or_default();
632
633    let buttons: HashSet<mouse_binding::MouseButton> = match &touch_report.pressed_buttons {
634        Some(buttons) => HashSet::from_iter(buttons.iter().cloned()),
635        None => HashSet::new(),
636    };
637
638    let trace_id = fuchsia_trace::Id::new();
639    fuchsia_trace::flow_begin!(c"input", c"report-to-event", trace_id);
640    send_touchpad_event(
641        current_contacts,
642        buttons,
643        device_descriptor,
644        input_event_sender,
645        trace_id,
646        inspect_status,
647        metrics_logger,
648    );
649
650    (Some(report), None)
651}
652
653fn touch_contacts_from_touch_report(
654    touch_report: &fidl_fuchsia_input_report::TouchInputReport,
655) -> HashMap<u32, TouchContact> {
656    // First unwrap all the optionals in the input report to get to the contacts.
657    let contacts: Vec<TouchContact> = touch_report
658        .contacts
659        .as_ref()
660        .and_then(|unwrapped_contacts| {
661            // Once the contacts are found, convert them into `TouchContact`s.
662            Some(unwrapped_contacts.iter().map(TouchContact::from).collect())
663        })
664        .unwrap_or_default();
665
666    contacts.into_iter().map(|contact| (contact.id, contact)).collect()
667}
668
669/// Sends a TouchScreenEvent over `input_event_sender`.
670///
671/// # Parameters
672/// - `contacts`: The contact points relevant to the new TouchScreenEvent.
673/// - `injector_contacts`: The contact points relevant to the new TouchScreenEvent, used to send
674///                        pointer events into Scenic.
675/// - `device_descriptor`: The descriptor for the input device generating the input reports.
676/// - `input_event_sender`: The sender for the device binding's input event stream.
677fn send_touch_screen_event(
678    contacts: HashMap<fidl_ui_input::PointerEventPhase, Vec<TouchContact>>,
679    injector_contacts: HashMap<pointerinjector::EventPhase, Vec<TouchContact>>,
680    device_descriptor: &input_device::InputDeviceDescriptor,
681    input_event_sender: &mut UnboundedSender<input_device::InputEvent>,
682    trace_id: fuchsia_trace::Id,
683    inspect_status: &InputDeviceStatus,
684    metrics_logger: &metrics::MetricsLogger,
685) {
686    let event = input_device::InputEvent {
687        device_event: input_device::InputDeviceEvent::TouchScreen(TouchScreenEvent {
688            contacts,
689            injector_contacts,
690        }),
691        device_descriptor: device_descriptor.clone(),
692        event_time: zx::MonotonicInstant::get(),
693        handled: Handled::No,
694        trace_id: Some(trace_id),
695    };
696
697    match input_event_sender.unbounded_send(event.clone()) {
698        Err(e) => {
699            metrics_logger.log_error(
700                InputPipelineErrorMetricDimensionEvent::TouchFailedToSendTouchScreenEvent,
701                std::format!("Failed to send TouchScreenEvent with error: {:?}", e),
702            );
703        }
704        _ => inspect_status.count_generated_event(event),
705    }
706}
707
708/// Sends a TouchpadEvent over `input_event_sender`.
709///
710/// # Parameters
711/// - `injector_contacts`: The contact points relevant to the new TouchpadEvent.
712/// - `pressed_buttons`: The pressing button of the new TouchpadEvent.
713/// - `device_descriptor`: The descriptor for the input device generating the input reports.
714/// - `input_event_sender`: The sender for the device binding's input event stream.
715fn send_touchpad_event(
716    injector_contacts: Vec<TouchContact>,
717    pressed_buttons: HashSet<mouse_binding::MouseButton>,
718    device_descriptor: &input_device::InputDeviceDescriptor,
719    input_event_sender: &mut UnboundedSender<input_device::InputEvent>,
720    trace_id: fuchsia_trace::Id,
721    inspect_status: &InputDeviceStatus,
722    metrics_logger: &metrics::MetricsLogger,
723) {
724    let event = input_device::InputEvent {
725        device_event: input_device::InputDeviceEvent::Touchpad(TouchpadEvent {
726            injector_contacts,
727            pressed_buttons,
728        }),
729        device_descriptor: device_descriptor.clone(),
730        event_time: zx::MonotonicInstant::get(),
731        handled: Handled::No,
732        trace_id: Some(trace_id),
733    };
734
735    match input_event_sender.unbounded_send(event.clone()) {
736        Err(e) => {
737            metrics_logger.log_error(
738                InputPipelineErrorMetricDimensionEvent::TouchFailedToSendTouchpadEvent,
739                std::format!("Failed to send TouchpadEvent with error: {:?}", e),
740            );
741        }
742        _ => inspect_status.count_generated_event(event),
743    }
744}
745
746/// [`get_device_type`] check if the touch device is a touchscreen or Windows Precision Touchpad.
747///
748/// Windows Precision Touchpad reports `MouseCollection` or `WindowsPrecisionTouchpadCollection`
749/// in `TouchFeatureReport`. Fallback all error responses on `get_feature_report` to TouchScreen
750/// because some touch screen does not report this method.
751async fn get_device_type(input_device: &fidl_input_report::InputDeviceProxy) -> TouchDeviceType {
752    match input_device.get_feature_report().await {
753        Ok(Ok(fidl_input_report::FeatureReport {
754            touch:
755                Some(fidl_input_report::TouchFeatureReport {
756                    input_mode:
757                        Some(
758                            fidl_input_report::TouchConfigurationInputMode::MouseCollection
759                            | fidl_input_report::TouchConfigurationInputMode::WindowsPrecisionTouchpadCollection,
760                        ),
761                    ..
762                }),
763            ..
764        })) => TouchDeviceType::WindowsPrecisionTouchpad,
765        _ => TouchDeviceType::TouchScreen,
766    }
767}
768
769#[cfg(test)]
770mod tests {
771    use super::*;
772    use crate::testing_utilities::{
773        self, create_touch_contact, create_touch_input_report, create_touch_screen_event,
774        create_touchpad_event,
775    };
776    use crate::utils::Position;
777    use assert_matches::assert_matches;
778    use diagnostics_assertions::AnyProperty;
779    use fidl_test_util::spawn_stream_handler;
780    use fuchsia_async as fasync;
781    use futures::StreamExt;
782    use pretty_assertions::assert_eq;
783    use test_case::test_case;
784
785    #[fasync::run_singlethreaded(test)]
786    async fn process_empty_reports() {
787        let previous_report_time = zx::MonotonicInstant::get().into_nanos();
788        let previous_report = create_touch_input_report(
789            vec![],
790            /* pressed_buttons= */ None,
791            previous_report_time,
792        );
793        let report_time = zx::MonotonicInstant::get().into_nanos();
794        let report =
795            create_touch_input_report(vec![], /* pressed_buttons= */ None, report_time);
796
797        let descriptor =
798            input_device::InputDeviceDescriptor::TouchScreen(TouchScreenDeviceDescriptor {
799                device_id: 1,
800                contacts: vec![],
801            });
802        let (mut event_sender, mut event_receiver) = futures::channel::mpsc::unbounded();
803
804        let inspector = fuchsia_inspect::Inspector::default();
805        let test_node = inspector.root().create_child("TestDevice_Touch");
806        let mut inspect_status = InputDeviceStatus::new(test_node);
807        inspect_status.health_node.set_ok();
808
809        let (returned_report, _) = TouchBinding::process_reports(
810            report,
811            Some(previous_report),
812            &descriptor,
813            &mut event_sender,
814            &inspect_status,
815            &metrics::MetricsLogger::default(),
816        );
817        assert!(returned_report.is_some());
818        assert_eq!(returned_report.unwrap().event_time, Some(report_time));
819
820        // Assert there are no pending events on the receiver.
821        let event = event_receiver.try_next();
822        assert!(event.is_err());
823
824        diagnostics_assertions::assert_data_tree!(inspector, root: {
825            "TestDevice_Touch": contains {
826                reports_received_count: 1u64,
827                reports_filtered_count: 1u64,
828                events_generated: 0u64,
829                last_received_timestamp_ns: report_time as u64,
830                last_generated_timestamp_ns: 0u64,
831                "fuchsia.inspect.Health": {
832                    status: "OK",
833                    // Timestamp value is unpredictable and not relevant in this context,
834                    // so we only assert that the property is present.
835                    start_timestamp_nanos: AnyProperty
836                },
837            }
838        });
839    }
840
841    // Tests that a input report with a new contact generates an event with an add and a down.
842    #[fasync::run_singlethreaded(test)]
843    async fn add_and_down() {
844        const TOUCH_ID: u32 = 2;
845
846        let descriptor =
847            input_device::InputDeviceDescriptor::TouchScreen(TouchScreenDeviceDescriptor {
848                device_id: 1,
849                contacts: vec![],
850            });
851        let (event_time_i64, event_time_u64) = testing_utilities::event_times();
852
853        let contact = fidl_fuchsia_input_report::ContactInputReport {
854            contact_id: Some(TOUCH_ID),
855            position_x: Some(0),
856            position_y: Some(0),
857            pressure: None,
858            contact_width: None,
859            contact_height: None,
860            ..Default::default()
861        };
862        let reports = vec![create_touch_input_report(
863            vec![contact],
864            /* pressed_buttons= */ None,
865            event_time_i64,
866        )];
867
868        let expected_events = vec![create_touch_screen_event(
869            hashmap! {
870                fidl_ui_input::PointerEventPhase::Add
871                    => vec![create_touch_contact(TOUCH_ID, Position { x: 0.0, y: 0.0 })],
872                fidl_ui_input::PointerEventPhase::Down
873                    => vec![create_touch_contact(TOUCH_ID, Position { x: 0.0, y: 0.0 })],
874            },
875            event_time_u64,
876            &descriptor,
877        )];
878
879        assert_input_report_sequence_generates_events!(
880            input_reports: reports,
881            expected_events: expected_events,
882            device_descriptor: descriptor,
883            device_type: TouchBinding,
884        );
885    }
886
887    // Tests that up and remove events are sent when a touch is released.
888    #[fasync::run_singlethreaded(test)]
889    async fn up_and_remove() {
890        const TOUCH_ID: u32 = 2;
891
892        let descriptor =
893            input_device::InputDeviceDescriptor::TouchScreen(TouchScreenDeviceDescriptor {
894                device_id: 1,
895                contacts: vec![],
896            });
897        let (event_time_i64, event_time_u64) = testing_utilities::event_times();
898
899        let contact = fidl_fuchsia_input_report::ContactInputReport {
900            contact_id: Some(TOUCH_ID),
901            position_x: Some(0),
902            position_y: Some(0),
903            pressure: None,
904            contact_width: None,
905            contact_height: None,
906            ..Default::default()
907        };
908        let reports = vec![
909            create_touch_input_report(
910                vec![contact],
911                /* pressed_buttons= */ None,
912                event_time_i64,
913            ),
914            create_touch_input_report(vec![], /* pressed_buttons= */ None, event_time_i64),
915        ];
916
917        let expected_events = vec![
918            create_touch_screen_event(
919                hashmap! {
920                    fidl_ui_input::PointerEventPhase::Add
921                        => vec![create_touch_contact(TOUCH_ID, Position { x: 0.0, y: 0.0 })],
922                    fidl_ui_input::PointerEventPhase::Down
923                        => vec![create_touch_contact(TOUCH_ID, Position { x: 0.0, y: 0.0 })],
924                },
925                event_time_u64,
926                &descriptor,
927            ),
928            create_touch_screen_event(
929                hashmap! {
930                    fidl_ui_input::PointerEventPhase::Up
931                        => vec![create_touch_contact(TOUCH_ID, Position { x: 0.0, y: 0.0 })],
932                    fidl_ui_input::PointerEventPhase::Remove
933                        => vec![create_touch_contact(TOUCH_ID, Position { x: 0.0, y: 0.0 })],
934                },
935                event_time_u64,
936                &descriptor,
937            ),
938        ];
939
940        assert_input_report_sequence_generates_events!(
941            input_reports: reports,
942            expected_events: expected_events,
943            device_descriptor: descriptor,
944            device_type: TouchBinding,
945        );
946    }
947
948    // Tests that a move generates the correct event.
949    #[fasync::run_singlethreaded(test)]
950    async fn add_down_move() {
951        const TOUCH_ID: u32 = 2;
952        let first = Position { x: 10.0, y: 30.0 };
953        let second = Position { x: first.x * 2.0, y: first.y * 2.0 };
954
955        let descriptor =
956            input_device::InputDeviceDescriptor::TouchScreen(TouchScreenDeviceDescriptor {
957                device_id: 1,
958                contacts: vec![],
959            });
960        let (event_time_i64, event_time_u64) = testing_utilities::event_times();
961
962        let first_contact = fidl_fuchsia_input_report::ContactInputReport {
963            contact_id: Some(TOUCH_ID),
964            position_x: Some(first.x as i64),
965            position_y: Some(first.y as i64),
966            pressure: None,
967            contact_width: None,
968            contact_height: None,
969            ..Default::default()
970        };
971        let second_contact = fidl_fuchsia_input_report::ContactInputReport {
972            contact_id: Some(TOUCH_ID),
973            position_x: Some(first.x as i64 * 2),
974            position_y: Some(first.y as i64 * 2),
975            pressure: None,
976            contact_width: None,
977            contact_height: None,
978            ..Default::default()
979        };
980
981        let reports = vec![
982            create_touch_input_report(
983                vec![first_contact],
984                /* pressed_buttons= */ None,
985                event_time_i64,
986            ),
987            create_touch_input_report(
988                vec![second_contact],
989                /* pressed_buttons= */ None,
990                event_time_i64,
991            ),
992        ];
993
994        let expected_events = vec![
995            create_touch_screen_event(
996                hashmap! {
997                    fidl_ui_input::PointerEventPhase::Add
998                        => vec![create_touch_contact(TOUCH_ID, first)],
999                    fidl_ui_input::PointerEventPhase::Down
1000                        => vec![create_touch_contact(TOUCH_ID, first)],
1001                },
1002                event_time_u64,
1003                &descriptor,
1004            ),
1005            create_touch_screen_event(
1006                hashmap! {
1007                    fidl_ui_input::PointerEventPhase::Move
1008                        => vec![create_touch_contact(TOUCH_ID, second)],
1009                },
1010                event_time_u64,
1011                &descriptor,
1012            ),
1013        ];
1014
1015        assert_input_report_sequence_generates_events!(
1016            input_reports: reports,
1017            expected_events: expected_events,
1018            device_descriptor: descriptor,
1019            device_type: TouchBinding,
1020        );
1021    }
1022
1023    #[fasync::run_singlethreaded(test)]
1024    async fn sent_event_has_trace_id() {
1025        let previous_report_time = zx::MonotonicInstant::get().into_nanos();
1026        let previous_report = create_touch_input_report(
1027            vec![],
1028            /* pressed_buttons= */ None,
1029            previous_report_time,
1030        );
1031
1032        let report_time = zx::MonotonicInstant::get().into_nanos();
1033        let contact = fidl_fuchsia_input_report::ContactInputReport {
1034            contact_id: Some(222),
1035            position_x: Some(333),
1036            position_y: Some(444),
1037            ..Default::default()
1038        };
1039        let report =
1040            create_touch_input_report(vec![contact], /* pressed_buttons= */ None, report_time);
1041
1042        let descriptor =
1043            input_device::InputDeviceDescriptor::TouchScreen(TouchScreenDeviceDescriptor {
1044                device_id: 1,
1045                contacts: vec![],
1046            });
1047        let (mut event_sender, mut event_receiver) = futures::channel::mpsc::unbounded();
1048
1049        let inspector = fuchsia_inspect::Inspector::default();
1050        let test_node = inspector.root().create_child("TestDevice_Touch");
1051        let mut inspect_status = InputDeviceStatus::new(test_node);
1052        inspect_status.health_node.set_ok();
1053
1054        let _ = TouchBinding::process_reports(
1055            report,
1056            Some(previous_report),
1057            &descriptor,
1058            &mut event_sender,
1059            &inspect_status,
1060            &metrics::MetricsLogger::default(),
1061        );
1062        assert_matches!(event_receiver.try_next(), Ok(Some(InputEvent { trace_id: Some(_), .. })));
1063    }
1064
1065    #[fuchsia::test(allow_stalls = false)]
1066    async fn enables_touchpad_mode_automatically() {
1067        let (set_feature_report_sender, set_feature_report_receiver) =
1068            futures::channel::mpsc::unbounded();
1069        let input_device_proxy = spawn_stream_handler(move |input_device_request| {
1070            let set_feature_report_sender = set_feature_report_sender.clone();
1071            async move {
1072                match input_device_request {
1073                    fidl_input_report::InputDeviceRequest::GetDescriptor { responder } => {
1074                        let _ = responder.send(&get_touchpad_device_descriptor(
1075                            true, /* has_mouse_descriptor */
1076                        ));
1077                    }
1078                    fidl_input_report::InputDeviceRequest::GetFeatureReport { responder } => {
1079                        let _ = responder.send(Ok(&fidl_input_report::FeatureReport {
1080                            touch: Some(fidl_input_report::TouchFeatureReport {
1081                                input_mode: Some(
1082                                    fidl_input_report::TouchConfigurationInputMode::MouseCollection,
1083                                ),
1084                                ..Default::default()
1085                            }),
1086                            ..Default::default()
1087                        }));
1088                    }
1089                    fidl_input_report::InputDeviceRequest::SetFeatureReport {
1090                        responder,
1091                        report,
1092                    } => {
1093                        match set_feature_report_sender.unbounded_send(report) {
1094                            Ok(_) => {
1095                                let _ = responder.send(Ok(()));
1096                            }
1097                            Err(e) => {
1098                                panic!("try_send set_feature_report_request failed: {}", e);
1099                            }
1100                        };
1101                    }
1102                    fidl_input_report::InputDeviceRequest::GetInputReportsReader { .. } => {
1103                        // Do not panic as `initialize_report_stream()` will call this protocol.
1104                    }
1105                    r => panic!("unsupported request {:?}", r),
1106                }
1107            }
1108        });
1109
1110        let (device_event_sender, _) = futures::channel::mpsc::unbounded();
1111
1112        // Create a test inspect node as required by TouchBinding::new()
1113        let inspector = fuchsia_inspect::Inspector::default();
1114        let test_node = inspector.root().create_child("test_node");
1115
1116        // Create a `TouchBinding` to exercise its call to `SetFeatureReport`. But drop
1117        // the binding immediately, so that `set_feature_report_receiver.collect()`
1118        // does not hang.
1119        TouchBinding::new(
1120            input_device_proxy,
1121            0,
1122            device_event_sender,
1123            test_node,
1124            metrics::MetricsLogger::default(),
1125        )
1126        .await
1127        .unwrap();
1128        assert_matches!(
1129            set_feature_report_receiver.collect::<Vec<_>>().await.as_slice(),
1130            [fidl_input_report::FeatureReport {
1131                touch: Some(fidl_input_report::TouchFeatureReport {
1132                    input_mode: Some(
1133                        fidl_input_report::TouchConfigurationInputMode::WindowsPrecisionTouchpadCollection
1134                    ),
1135                    ..
1136                }),
1137                ..
1138            }]
1139        );
1140    }
1141
1142    #[test_case(true, None, TouchDeviceType::TouchScreen; "touch screen")]
1143    #[test_case(false, None, TouchDeviceType::TouchScreen; "no mouse descriptor, no touch_input_mode")]
1144    #[test_case(true, Some(fidl_input_report::TouchConfigurationInputMode::MouseCollection), TouchDeviceType::WindowsPrecisionTouchpad; "touchpad in mouse mode")]
1145    #[test_case(true, Some(fidl_input_report::TouchConfigurationInputMode::WindowsPrecisionTouchpadCollection), TouchDeviceType::WindowsPrecisionTouchpad; "touchpad in touchpad mode")]
1146    #[fuchsia::test(allow_stalls = false)]
1147    async fn identifies_correct_touch_device_type(
1148        has_mouse_descriptor: bool,
1149        touch_input_mode: Option<fidl_input_report::TouchConfigurationInputMode>,
1150        expect_touch_device_type: TouchDeviceType,
1151    ) {
1152        let input_device_proxy = spawn_stream_handler(move |input_device_request| async move {
1153            match input_device_request {
1154                fidl_input_report::InputDeviceRequest::GetDescriptor { responder } => {
1155                    let _ = responder.send(&get_touchpad_device_descriptor(has_mouse_descriptor));
1156                }
1157                fidl_input_report::InputDeviceRequest::GetFeatureReport { responder } => {
1158                    let _ = responder.send(Ok(&fidl_input_report::FeatureReport {
1159                        touch: Some(fidl_input_report::TouchFeatureReport {
1160                            input_mode: touch_input_mode,
1161                            ..Default::default()
1162                        }),
1163                        ..Default::default()
1164                    }));
1165                }
1166                fidl_input_report::InputDeviceRequest::SetFeatureReport { responder, .. } => {
1167                    let _ = responder.send(Ok(()));
1168                }
1169                r => panic!("unsupported request {:?}", r),
1170            }
1171        });
1172
1173        let (device_event_sender, _) = futures::channel::mpsc::unbounded();
1174
1175        // Create a test inspect node as required by TouchBinding::new()
1176        let inspector = fuchsia_inspect::Inspector::default();
1177        let test_node = inspector.root().create_child("test_node");
1178
1179        let binding = TouchBinding::new(
1180            input_device_proxy,
1181            0,
1182            device_event_sender,
1183            test_node,
1184            metrics::MetricsLogger::default(),
1185        )
1186        .await
1187        .unwrap();
1188        pretty_assertions::assert_eq!(binding.touch_device_type, expect_touch_device_type);
1189    }
1190
1191    /// Returns an |fidl_fuchsia_input_report::DeviceDescriptor| for
1192    /// touchpad related tests.
1193    fn get_touchpad_device_descriptor(
1194        has_mouse_descriptor: bool,
1195    ) -> fidl_fuchsia_input_report::DeviceDescriptor {
1196        fidl_input_report::DeviceDescriptor {
1197            mouse: match has_mouse_descriptor {
1198                true => Some(fidl_input_report::MouseDescriptor::default()),
1199                false => None,
1200            },
1201            touch: Some(fidl_input_report::TouchDescriptor {
1202                input: Some(fidl_input_report::TouchInputDescriptor {
1203                    contacts: Some(vec![fidl_input_report::ContactInputDescriptor {
1204                        position_x: Some(fidl_input_report::Axis {
1205                            range: fidl_input_report::Range { min: 1, max: 2 },
1206                            unit: fidl_input_report::Unit {
1207                                type_: fidl_input_report::UnitType::None,
1208                                exponent: 0,
1209                            },
1210                        }),
1211                        position_y: Some(fidl_input_report::Axis {
1212                            range: fidl_input_report::Range { min: 2, max: 3 },
1213                            unit: fidl_input_report::Unit {
1214                                type_: fidl_input_report::UnitType::Other,
1215                                exponent: 100000,
1216                            },
1217                        }),
1218                        pressure: Some(fidl_input_report::Axis {
1219                            range: fidl_input_report::Range { min: 3, max: 4 },
1220                            unit: fidl_input_report::Unit {
1221                                type_: fidl_input_report::UnitType::Grams,
1222                                exponent: -991,
1223                            },
1224                        }),
1225                        contact_width: Some(fidl_input_report::Axis {
1226                            range: fidl_input_report::Range { min: 5, max: 6 },
1227                            unit: fidl_input_report::Unit {
1228                                type_: fidl_input_report::UnitType::EnglishAngularVelocity,
1229                                exponent: 123,
1230                            },
1231                        }),
1232                        contact_height: Some(fidl_input_report::Axis {
1233                            range: fidl_input_report::Range { min: 7, max: 8 },
1234                            unit: fidl_input_report::Unit {
1235                                type_: fidl_input_report::UnitType::Pascals,
1236                                exponent: 100,
1237                            },
1238                        }),
1239                        ..Default::default()
1240                    }]),
1241                    ..Default::default()
1242                }),
1243                ..Default::default()
1244            }),
1245            ..Default::default()
1246        }
1247    }
1248
1249    #[fasync::run_singlethreaded(test)]
1250    async fn send_touchpad_event_button() {
1251        const TOUCH_ID: u32 = 1;
1252        const PRIMARY_BUTTON: u8 = 1;
1253
1254        let descriptor = input_device::InputDeviceDescriptor::Touchpad(TouchpadDeviceDescriptor {
1255            device_id: 1,
1256            contacts: vec![],
1257        });
1258        let (event_time_i64, event_time_u64) = testing_utilities::event_times();
1259
1260        let contact = fidl_fuchsia_input_report::ContactInputReport {
1261            contact_id: Some(TOUCH_ID),
1262            position_x: Some(0),
1263            position_y: Some(0),
1264            pressure: None,
1265            contact_width: None,
1266            contact_height: None,
1267            ..Default::default()
1268        };
1269        let reports = vec![create_touch_input_report(
1270            vec![contact],
1271            Some(vec![PRIMARY_BUTTON]),
1272            event_time_i64,
1273        )];
1274
1275        let expected_events = vec![create_touchpad_event(
1276            vec![create_touch_contact(TOUCH_ID, Position { x: 0.0, y: 0.0 })],
1277            vec![PRIMARY_BUTTON].into_iter().collect(),
1278            event_time_u64,
1279            &descriptor,
1280        )];
1281
1282        assert_input_report_sequence_generates_events!(
1283            input_reports: reports,
1284            expected_events: expected_events,
1285            device_descriptor: descriptor,
1286            device_type: TouchBinding,
1287        );
1288    }
1289
1290    #[fasync::run_singlethreaded(test)]
1291    async fn send_touchpad_event_2_fingers_down_up() {
1292        const TOUCH_ID_1: u32 = 1;
1293        const TOUCH_ID_2: u32 = 2;
1294
1295        let descriptor = input_device::InputDeviceDescriptor::Touchpad(TouchpadDeviceDescriptor {
1296            device_id: 1,
1297            contacts: vec![],
1298        });
1299        let (event_time_i64, event_time_u64) = testing_utilities::event_times();
1300
1301        let contact1 = fidl_fuchsia_input_report::ContactInputReport {
1302            contact_id: Some(TOUCH_ID_1),
1303            position_x: Some(0),
1304            position_y: Some(0),
1305            pressure: None,
1306            contact_width: None,
1307            contact_height: None,
1308            ..Default::default()
1309        };
1310        let contact2 = fidl_fuchsia_input_report::ContactInputReport {
1311            contact_id: Some(TOUCH_ID_2),
1312            position_x: Some(10),
1313            position_y: Some(10),
1314            pressure: None,
1315            contact_width: None,
1316            contact_height: None,
1317            ..Default::default()
1318        };
1319        let reports = vec![
1320            create_touch_input_report(
1321                vec![contact1, contact2],
1322                /* pressed_buttons= */ None,
1323                event_time_i64,
1324            ),
1325            create_touch_input_report(vec![], /* pressed_buttons= */ None, event_time_i64),
1326        ];
1327
1328        let expected_events = vec![
1329            create_touchpad_event(
1330                vec![
1331                    create_touch_contact(TOUCH_ID_1, Position { x: 0.0, y: 0.0 }),
1332                    create_touch_contact(TOUCH_ID_2, Position { x: 10.0, y: 10.0 }),
1333                ],
1334                HashSet::new(),
1335                event_time_u64,
1336                &descriptor,
1337            ),
1338            create_touchpad_event(vec![], HashSet::new(), event_time_u64, &descriptor),
1339        ];
1340
1341        assert_input_report_sequence_generates_events!(
1342            input_reports: reports,
1343            expected_events: expected_events,
1344            device_descriptor: descriptor,
1345            device_type: TouchBinding,
1346        );
1347    }
1348
1349    #[test_case(Position{x: 0.0, y: 0.0}, Position{x: 5.0, y: 5.0}; "down move")]
1350    #[test_case(Position{x: 0.0, y: 0.0}, Position{x: 0.0, y: 0.0}; "down hold")]
1351    #[fasync::run_singlethreaded(test)]
1352    async fn send_touchpad_event_1_finger(p0: Position, p1: Position) {
1353        const TOUCH_ID: u32 = 1;
1354
1355        let descriptor = input_device::InputDeviceDescriptor::Touchpad(TouchpadDeviceDescriptor {
1356            device_id: 1,
1357            contacts: vec![],
1358        });
1359        let (event_time_i64, event_time_u64) = testing_utilities::event_times();
1360
1361        let contact1 = fidl_fuchsia_input_report::ContactInputReport {
1362            contact_id: Some(TOUCH_ID),
1363            position_x: Some(p0.x as i64),
1364            position_y: Some(p0.y as i64),
1365            pressure: None,
1366            contact_width: None,
1367            contact_height: None,
1368            ..Default::default()
1369        };
1370        let contact2 = fidl_fuchsia_input_report::ContactInputReport {
1371            contact_id: Some(TOUCH_ID),
1372            position_x: Some(p1.x as i64),
1373            position_y: Some(p1.y as i64),
1374            pressure: None,
1375            contact_width: None,
1376            contact_height: None,
1377            ..Default::default()
1378        };
1379        let reports = vec![
1380            create_touch_input_report(
1381                vec![contact1],
1382                /* pressed_buttons= */ None,
1383                event_time_i64,
1384            ),
1385            create_touch_input_report(
1386                vec![contact2],
1387                /* pressed_buttons= */ None,
1388                event_time_i64,
1389            ),
1390        ];
1391
1392        let expected_events = vec![
1393            create_touchpad_event(
1394                vec![create_touch_contact(TOUCH_ID, p0)],
1395                HashSet::new(),
1396                event_time_u64,
1397                &descriptor,
1398            ),
1399            create_touchpad_event(
1400                vec![create_touch_contact(TOUCH_ID, p1)],
1401                HashSet::new(),
1402                event_time_u64,
1403                &descriptor,
1404            ),
1405        ];
1406
1407        assert_input_report_sequence_generates_events!(
1408            input_reports: reports,
1409            expected_events: expected_events,
1410            device_descriptor: descriptor,
1411            device_type: TouchBinding,
1412        );
1413    }
1414}
input_pipeline/touch_binding.rs

input_pipeline/
touch_binding.rs
