input_synthesis/
synthesizer.rs

1// Copyright 2020 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::derive_key_sequence;
6use anyhow::{ensure, Error};
7use async_trait::async_trait;
8use fidl_fuchsia_input_report::MouseInputReport;
9use fidl_fuchsia_ui_input::{KeyboardReport, Touch};
10use log::debug;
11use serde::{Deserialize, Deserializer};
12use std::thread;
13use std::time::Duration;
14use {fidl_fuchsia_input as input, fidl_fuchsia_ui_input3 as input3, fuchsia_async as fasync};
15
16// Abstracts over input injection services (which are provided by input device registries).
17pub trait InputDeviceRegistry {
18    fn add_touchscreen_device(
19        &mut self,
20        width: u32,
21        height: u32,
22    ) -> Result<Box<dyn InputDevice>, Error>;
23    fn add_keyboard_device(&mut self) -> Result<Box<dyn InputDevice>, Error>;
24    fn add_media_buttons_device(&mut self) -> Result<Box<dyn InputDevice>, Error>;
25    fn add_mouse_device(&mut self, width: u32, height: u32) -> Result<Box<dyn InputDevice>, Error>;
26}
27
28// Abstracts over the various interactions that a user might have with an input device.
29// Note that the input-synthesis crate deliberately chooses not to "sub-type" input devices.
30// This avoids additional code complexity, and allows the crate to support tests that
31// deliberately send events that do not match the expected event type for a device.
32#[async_trait(?Send)]
33pub trait InputDevice {
34    /// Sends a media buttons report with the specified buttons pressed.
35    fn media_buttons(&mut self, pressed_buttons: Vec<MediaButton>, time: u64) -> Result<(), Error>;
36
37    /// Sends a keyboard report with keys defined mostly in terms of USB HID usage
38    /// page 7. This is sufficient for keyboard keys, but does not cover the full
39    /// extent of keys that Fuchsia supports. As result, the KeyboardReport is converted
40    /// internally into Fuchsia's encoding before being forwarded.
41    fn key_press(&mut self, keyboard: KeyboardReport, time: u64) -> Result<(), Error>;
42
43    /// Sends a keyboard report using the whole range of key codes. Key codes provided
44    /// are not modified or mapped in any way.
45    /// This differs from `key_press`, which performs special mapping for key codes
46    /// from USB HID Page 0x7.
47    fn key_press_raw(&mut self, keyboard: KeyboardReport, time: u64) -> Result<(), Error>;
48    fn key_press_usage(&mut self, usage: Option<u32>, time: u64) -> Result<(), Error>;
49    fn tap(&mut self, pos: Option<(u32, u32)>, time: u64) -> Result<(), Error>;
50    fn multi_finger_tap(&mut self, fingers: Option<Vec<Touch>>, time: u64) -> Result<(), Error>;
51
52    /// Sends a mouse report with the specified relative cursor movement and buttons pressed.
53    fn mouse(&mut self, report: MouseInputReport, time: u64) -> Result<(), Error>;
54
55    // Returns a `Future` which resolves when all input reports for this device
56    // have been sent to the FIDL peer, or when an error occurs.
57    //
58    // The possible errors are implementation-specific, but may include:
59    // * Errors reading from the FIDL peer
60    // * Errors writing to the FIDL peer
61    //
62    // # Resolves to
63    // * `Ok(())` if all reports were written successfully
64    // * `Err` otherwise
65    //
66    // # Note
67    // When the future resolves, input reports may still be sitting unread in the
68    // channel to the FIDL peer.
69    async fn flush(self: Box<Self>) -> Result<(), Error>;
70}
71
72/// The buttons supported by `media_button_event()`.
73#[derive(PartialOrd, PartialEq, Ord, Eq)]
74pub enum MediaButton {
75    VolumeUp,
76    VolumeDown,
77    MicMute,
78    FactoryReset,
79    Pause,
80    CameraDisable,
81}
82
83fn monotonic_nanos() -> Result<u64, Error> {
84    u64::try_from(zx::MonotonicInstant::get().into_nanos()).map_err(Into::into)
85}
86
87async fn repeat_with_delay(
88    times: usize,
89    delay: Duration,
90    device: &mut dyn InputDevice,
91    f1: impl Fn(usize, &mut dyn InputDevice) -> Result<(), Error>,
92    f2: impl Fn(usize, &mut dyn InputDevice) -> Result<(), Error>,
93) -> Result<(), Error> {
94    for i in 0..times {
95        f1(i, device)?;
96        fasync::Timer::new(fasync::MonotonicInstant::after(delay.into())).await;
97        f2(i, device)?;
98    }
99
100    Ok(())
101}
102
103/// Sends a media buttons report with the specified buttons pressed.
104pub async fn media_button_event<I: IntoIterator<Item = MediaButton>>(
105    pressed_buttons: I,
106    registry: &mut dyn InputDeviceRegistry,
107) -> Result<(), Error> {
108    let mut input_device = registry.add_media_buttons_device()?;
109    input_device.media_buttons(pressed_buttons.into_iter().collect(), monotonic_nanos()?)?;
110    input_device.flush().await
111}
112
113/// A single key event to be replayed by `dispatch_key_events_async`.
114///
115/// See [crate::dispatch_key_events] for details of the key event type and the event timing.
116///
117/// For example, a key press like this:
118///
119/// ```ignore
120/// Key1: _________/"""""""""""""""\\___________
121///                ^               ^--- key released
122///                `------------------- key pressed
123///       |<------>|  <-- duration_since_start (50ms)
124///       |<---------------------->| duration_since_start (100ms)
125/// ```
126///
127/// would be described with a sequence of two `TimedKeyEvent`s (pseudo-code):
128///
129/// ```
130/// [
131///    { Key1,  50ms, PRESSED  },
132///    { Key1, 100ms, RELEASED },
133/// ]
134/// ```
135///
136/// This is not overly useful in the case of a single key press, but is useful to model multiple
137/// concurrent keypresses, while allowing an arbitrary interleaving of key events.
138///
139/// Consider a more complicated timing diagram like this one:
140///
141/// ```ignore
142/// Key1: _________/"""""""""""""""\\_____________
143/// Key2: ____/"""""""""""""""\\__________________
144/// Key3: ______/"""""""""""""""\\________________
145/// Key4: _____________/"""""""""""""""\\_________
146/// Key5: ________________ __/""""""\\____________
147/// Key6: ________/""""""\\_______________________
148/// ```
149///
150/// It then becomes obvious how modeling individual events allows us to express this interaction.
151/// Furthermore anchoring `duration_since_start` to the beginning of the key sequence (instead of,
152/// for example, specifying the duration of each key press) gives a common time reference and makes
153/// it fairly easy to express the intended key interaction in terms of a `TimedKeyEvent` sequence.
154#[derive(Debug, Clone, Eq, PartialEq)]
155pub struct TimedKeyEvent {
156    /// The [input::Key] which changed state.
157    pub key: input::Key,
158    /// The duration of time,  relative to the start of the key event sequence that this `TimedKeyEvent`
159    /// is part of, at which this event happened at.
160    pub duration_since_start: Duration,
161    /// The type of state change that happened to `key`.  Was it pressed, released or something
162    /// else.
163    pub event_type: input3::KeyEventType,
164}
165
166impl TimedKeyEvent {
167    /// Creates a new [TimedKeyEvent] to inject into the input pipeline.  `key` is
168    /// the key to be pressed (using Fuchsia HID-like encoding), `type_` is the
169    /// event type (Pressed, or Released etc), and `duration_since_start` is the
170    /// duration since the start of the entire event sequence that the key event
171    /// should be scheduled at.
172    pub fn new(
173        key: input::Key,
174        type_: input3::KeyEventType,
175        duration_since_start: Duration,
176    ) -> Self {
177        Self { key, duration_since_start, event_type: type_ }
178    }
179
180    /// Deserializes a vector of `TimedKeyEvent`.
181    /// A custom deserializer is used because Vec<_> does not work
182    /// with serde, and the [TimedKeyEvent] has constituents that don't
183    /// have a derived serde representation.
184    /// See: https://github.com/serde-rs/serde/issues/723#issuecomment-382501277
185    pub fn vec<'de, D>(deserializer: D) -> Result<Vec<TimedKeyEvent>, D::Error>
186    where
187        D: Deserializer<'de>,
188    {
189        // Should correspond to TimedKeyEvent, except all fields are described by their underlying
190        // primitive values.
191        #[derive(Deserialize, Debug)]
192        struct TimedKeyEventDes {
193            // The Fuchsia encoded USB HID key, per input::Key.
194            key: u32,
195            // A Duration.
196            duration_millis: u64,
197            // An input3::TimedKeyEventType.
198            #[serde(rename = "type")]
199            type_: u32,
200        }
201
202        impl Into<TimedKeyEvent> for TimedKeyEventDes {
203            /// Reconstructs the typed elements of [TimedKeyEvent] from primitives.
204            fn into(self) -> TimedKeyEvent {
205                TimedKeyEvent::new(
206                    input::Key::from_primitive(self.key)
207                        .unwrap_or_else(|| panic!("Key::from_primitive failed on: {:?}", &self)),
208                    input3::KeyEventType::from_primitive(self.type_).unwrap_or_else(|| {
209                        panic!("KeyEventType::from_primitive failed on: {:?}", &self)
210                    }),
211                    Duration::from_millis(self.duration_millis),
212                )
213            }
214        }
215
216        let v = Vec::deserialize(deserializer)?;
217        Ok(v.into_iter().map(|a: TimedKeyEventDes| a.into()).collect())
218    }
219}
220
221/// Replays the sequence of events (see [Replayer::replay]) with the correct timing.
222struct Replayer<'a> {
223    // Invariant: pressed_keys.iter() must use ascending iteration
224    // ordering.
225    pressed_keys: std::collections::BTreeSet<input::Key>,
226    // The input device registry to use.
227    registry: &'a mut dyn InputDeviceRegistry,
228}
229
230impl<'a> Replayer<'a> {
231    fn new(registry: &'a mut dyn InputDeviceRegistry) -> Self {
232        Replayer { pressed_keys: std::collections::BTreeSet::new(), registry }
233    }
234
235    /// Replays the given sequence of key events with the correct timing spacing
236    /// between the events.
237    ///
238    /// All timing in [TimedKeyEvent] is relative to the instance in the monotonic clock base at which
239    /// we started replaying the entire event sequence.  The replay returns an error in case
240    /// the events are not sequenced with strictly increasing timestamps.
241    async fn replay<'b: 'a>(&mut self, events: &'b [TimedKeyEvent]) -> Result<(), Error> {
242        let mut last_key_event_at = Duration::from_micros(0);
243
244        // Verify that the key events are scheduled in a nondecreasing timestamp sequence.
245        for key_event in events {
246            if key_event.duration_since_start < last_key_event_at {
247                return Err(anyhow::anyhow!(
248                    concat!(
249                        "TimedKeyEvent was requested out of sequence: ",
250                        "TimedKeyEvent: {:?}, low watermark for duration_since_start: {:?}"
251                    ),
252                    &key_event,
253                    last_key_event_at
254                ));
255            }
256            if key_event.duration_since_start == last_key_event_at {
257                // If you see this error message, read the documentation for how to send key events
258                // correctly in the TimedKeyEvent documentation.
259                return Err(anyhow::anyhow!(
260                    concat!(
261                        "TimedKeyEvent was requested at the same time instant as a previous event. ",
262                        "This is not allowed, each key event must happen at a distinct timestamp: ",
263                        "TimedKeyEvent: {:?}, low watermark for duration_since_start: {:?}"
264                    ),
265                    &key_event,
266                    last_key_event_at
267                ));
268            }
269            last_key_event_at = key_event.duration_since_start;
270        }
271
272        let mut input_device = self.registry.add_keyboard_device()?;
273        let started_at = monotonic_nanos()?;
274        for key_event in events {
275            use input3::KeyEventType;
276            match key_event.event_type {
277                KeyEventType::Pressed | KeyEventType::Sync => {
278                    self.pressed_keys.insert(key_event.key.clone());
279                }
280                KeyEventType::Released | KeyEventType::Cancel => {
281                    self.pressed_keys.remove(&key_event.key);
282                }
283            }
284
285            // The sequence below should be an async task.  The complicating factor is that
286            // input_device lifetime needs to be 'static for this to be schedulable on a
287            // fuchsia::async::Task. So for the time being, we skip that part.
288            let processed_at = Duration::from_nanos(monotonic_nanos()? - started_at);
289            let desired_at = &key_event.duration_since_start;
290            if processed_at < *desired_at {
291                fasync::Timer::new(fasync::MonotonicInstant::after(
292                    (*desired_at - processed_at).into(),
293                ))
294                .await;
295            }
296            input_device.key_press_raw(self.make_input_report(), monotonic_nanos()?)?;
297        }
298
299        input_device.flush().await
300    }
301
302    /// Creates a keyboard report based on the keys that are currently pressed.
303    ///
304    /// The pressed keys are always reported in the nondecreasing order of their respective key
305    /// codes, so a single distinct key chord will be always reported as a single distinct
306    /// `KeyboardReport`.
307    fn make_input_report(&self) -> KeyboardReport {
308        KeyboardReport {
309            pressed_keys: self.pressed_keys.iter().map(|k| k.into_primitive()).collect(),
310        }
311    }
312}
313
314/// Dispatches the supplied `events` into  a keyboard device registered into `registry`, honoring
315/// the timing sequence that is described in them to the extent that they are possible to schedule.
316pub(crate) async fn dispatch_key_events_async(
317    events: &[TimedKeyEvent],
318    registry: &mut dyn InputDeviceRegistry,
319) -> Result<(), Error> {
320    Replayer::new(registry).replay(events).await
321}
322
323pub(crate) async fn keyboard_event(
324    usage: u32,
325    duration: Duration,
326    registry: &mut dyn InputDeviceRegistry,
327) -> Result<(), Error> {
328    let mut input_device = registry.add_keyboard_device()?;
329
330    repeat_with_delay(
331        1,
332        duration,
333        input_device.as_mut(),
334        |_i, device| {
335            // Key pressed.
336            device.key_press_usage(Some(usage), monotonic_nanos()?)
337        },
338        |_i, device| {
339            // Key released.
340            device.key_press_usage(None, monotonic_nanos()?)
341        },
342    )
343    .await?;
344
345    input_device.flush().await
346}
347
348/// Simulates `input` being typed on a keyboard, with `key_event_duration` between key events.
349///
350/// # Requirements
351/// * `input` must be non-empty
352/// * `input` must only contain characters representable using the current keyboard layout
353///    and locale. (At present, it is assumed that the current layout and locale are
354///   `US-QWERTY` and `en-US`, respectively.)
355///
356/// # Resolves to
357/// * `Ok(())` if the arguments met the requirements above, and the events were successfully
358///   injected.
359/// * `Err(Error)` otherwise.
360///
361/// # Corner case handling
362/// * `key_event_duration` of zero is permitted, and will result in events being generated as
363///    quickly as possible.
364pub async fn text(
365    input: String,
366    key_event_duration: Duration,
367    registry: &mut dyn InputDeviceRegistry,
368) -> Result<(), Error> {
369    let mut input_device = registry.add_keyboard_device()?;
370    let key_sequence = derive_key_sequence(&keymaps::US_QWERTY, &input)
371        .ok_or_else(|| anyhow::format_err!("Cannot translate text to key sequence"))?;
372
373    debug!(input:% = input, key_sequence:?, key_event_duration:?; "synthesizer::text");
374    let mut key_iter = key_sequence.into_iter().peekable();
375    while let Some(keyboard) = key_iter.next() {
376        input_device.key_press(keyboard, monotonic_nanos()?)?;
377        if key_iter.peek().is_some() {
378            thread::sleep(key_event_duration);
379        }
380    }
381
382    input_device.flush().await
383}
384
385pub async fn tap_event(
386    x: u32,
387    y: u32,
388    width: u32,
389    height: u32,
390    tap_event_count: usize,
391    duration: Duration,
392    registry: &mut dyn InputDeviceRegistry,
393) -> Result<(), Error> {
394    let mut input_device = registry.add_touchscreen_device(width, height)?;
395    let tap_duration = duration / tap_event_count as u32;
396
397    repeat_with_delay(
398        tap_event_count,
399        tap_duration,
400        input_device.as_mut(),
401        |_i, device| {
402            // Touch down.
403            device.tap(Some((x, y)), monotonic_nanos()?)
404        },
405        |_i, device| {
406            // Touch up.
407            device.tap(None, monotonic_nanos()?)
408        },
409    )
410    .await?;
411
412    input_device.flush().await
413}
414
415pub(crate) async fn multi_finger_tap_event(
416    fingers: Vec<Touch>,
417    width: u32,
418    height: u32,
419    tap_event_count: usize,
420    duration: Duration,
421    registry: &mut dyn InputDeviceRegistry,
422) -> Result<(), Error> {
423    let mut input_device = registry.add_touchscreen_device(width, height)?;
424    let multi_finger_tap_duration = duration / tap_event_count as u32;
425
426    repeat_with_delay(
427        tap_event_count,
428        multi_finger_tap_duration,
429        input_device.as_mut(),
430        |_i, device| {
431            // Touch down.
432            device.multi_finger_tap(Some(fingers.clone()), monotonic_nanos()?)
433        },
434        |_i, device| {
435            // Touch up.
436            device.multi_finger_tap(None, monotonic_nanos()?)
437        },
438    )
439    .await?;
440
441    input_device.flush().await
442}
443
444pub(crate) async fn swipe(
445    x0: u32,
446    y0: u32,
447    x1: u32,
448    y1: u32,
449    width: u32,
450    height: u32,
451    move_event_count: usize,
452    duration: Duration,
453    registry: &mut dyn InputDeviceRegistry,
454) -> Result<(), Error> {
455    multi_finger_swipe(
456        vec![(x0, y0)],
457        vec![(x1, y1)],
458        width,
459        height,
460        move_event_count,
461        duration,
462        registry,
463    )
464    .await
465}
466
467pub(crate) async fn multi_finger_swipe(
468    start_fingers: Vec<(u32, u32)>,
469    end_fingers: Vec<(u32, u32)>,
470    width: u32,
471    height: u32,
472    move_event_count: usize,
473    duration: Duration,
474    registry: &mut dyn InputDeviceRegistry,
475) -> Result<(), Error> {
476    ensure!(
477        start_fingers.len() == end_fingers.len(),
478        "start_fingers.len() != end_fingers.len() ({} != {})",
479        start_fingers.len(),
480        end_fingers.len()
481    );
482    ensure!(
483        u32::try_from(start_fingers.len() + 1).is_ok(),
484        "fingers exceed capacity of `finger_id`!"
485    );
486
487    let mut input_device = registry.add_touchscreen_device(width, height)?;
488
489    // Note: coordinates are coverted to `f64` before subtraction, because u32 subtraction
490    // would overflow when swiping from higher coordinates to lower coordinates.
491    let finger_delta_x = start_fingers
492        .iter()
493        .zip(end_fingers.iter())
494        .map(|((start_x, _start_y), (end_x, _end_y))| {
495            (*end_x as f64 - *start_x as f64) / std::cmp::max(move_event_count, 1) as f64
496        })
497        .collect::<Vec<_>>();
498    let finger_delta_y = start_fingers
499        .iter()
500        .zip(end_fingers.iter())
501        .map(|((_start_x, start_y), (_end_x, end_y))| {
502            (*end_y as f64 - *start_y as f64) / std::cmp::max(move_event_count, 1) as f64
503        })
504        .collect::<Vec<_>>();
505
506    let swipe_event_delay = if move_event_count > 1 {
507        // We have move_event_count + 2 events:
508        //   DOWN
509        //   MOVE x move_event_count
510        //   UP
511        // so we need (move_event_count + 1) delays.
512        duration / (move_event_count + 1) as u32
513    } else {
514        duration
515    };
516
517    repeat_with_delay(
518        move_event_count + 2, // +2 to account for DOWN and UP events
519        swipe_event_delay,
520        input_device.as_mut(),
521        |i, device| {
522            let time = monotonic_nanos()?;
523            match i {
524                // DOWN
525                0 => device.multi_finger_tap(
526                    Some(
527                        start_fingers
528                            .iter()
529                            .enumerate()
530                            .map(|(finger_index, (x, y))| Touch {
531                                finger_id: (finger_index + 1) as u32,
532                                x: *x as i32,
533                                y: *y as i32,
534                                width: 0,
535                                height: 0,
536                            })
537                            .collect(),
538                    ),
539                    time,
540                ),
541                // MOVE
542                i if i <= move_event_count => device.multi_finger_tap(
543                    Some(
544                        start_fingers
545                            .iter()
546                            .enumerate()
547                            .map(|(finger_index, (x, y))| Touch {
548                                finger_id: (finger_index + 1) as u32,
549                                x: (*x as f64 + (i as f64 * finger_delta_x[finger_index]).round())
550                                    as i32,
551                                y: (*y as f64 + (i as f64 * finger_delta_y[finger_index]).round())
552                                    as i32,
553                                width: 0,
554                                height: 0,
555                            })
556                            .collect(),
557                    ),
558                    time,
559                ),
560                // UP
561                i if i == (move_event_count + 1) => device.multi_finger_tap(None, time),
562                i => panic!("unexpected loop iteration {}", i),
563            }
564        },
565        |_, _| Ok(()),
566    )
567    .await?;
568
569    input_device.flush().await
570}
571
572/// The buttons supported by `mouse()`.
573pub type MouseButton = u8;
574
575pub async fn add_mouse_device(
576    width: u32,
577    height: u32,
578    registry: &mut dyn InputDeviceRegistry,
579) -> Result<Box<dyn InputDevice>, Error> {
580    registry.add_mouse_device(width, height)
581}
582
583#[cfg(test)]
584mod tests {
585    use super::*;
586    use anyhow::Context as _;
587    use fuchsia_async as fasync;
588    use serde::Deserialize;
589
590    #[derive(Deserialize, Debug, Eq, PartialEq)]
591    struct KeyEventsRequest {
592        #[serde(default, deserialize_with = "TimedKeyEvent::vec")]
593        pub key_events: Vec<TimedKeyEvent>,
594    }
595
596    #[test]
597    fn deserialize_key_event() -> Result<(), Error> {
598        let request_json = r#"{
599          "key_events": [
600            {
601              "key": 458756,
602              "duration_millis": 100,
603              "type": 1
604            }
605          ]
606        }"#;
607        let event: KeyEventsRequest = serde_json::from_str(&request_json)?;
608        assert_eq!(
609            event,
610            KeyEventsRequest {
611                key_events: vec![TimedKeyEvent {
612                    key: input::Key::A,
613                    duration_since_start: Duration::from_millis(100),
614                    event_type: input3::KeyEventType::Pressed,
615                },],
616            }
617        );
618        Ok(())
619    }
620
621    #[test]
622    fn deserialize_key_event_maformed_input() {
623        let tests: Vec<&'static str> = vec![
624            // "type" has a wrong value.
625            r#"{
626              "key_events": [
627                {
628                  "key": 458756,
629                  "duration_millis": 100,
630                  "type": 99999,
631                }
632              ]
633            }"#,
634            // "key" has a value that is too small.
635            r#"{
636              "key_events": [
637                {
638                  "key": 12,
639                  "duration_millis": 100,
640                  "type": 1,
641                }
642              ]
643            }"#,
644            // "type" is missing.
645            r#"{
646              "key_events": [
647                {
648                  "key": 12,
649                  "duration_millis": 100,
650                }
651              ]
652            }"#,
653            // "duration" is missing.
654            r#"{
655              "key_events": [
656                {
657                  "key": 458756,
658                  "type": 1
659                }
660              ]
661            }"#,
662            // "key" is missing.
663            r#"{
664              "key_events": [
665                {
666                  "duration_millis": 100,
667                  "type": 1
668                }
669              ]
670            }"#,
671        ];
672        for test in tests.iter() {
673            serde_json::from_str::<KeyEventsRequest>(test)
674                .expect_err(&format!("malformed input should not parse: {}", &test));
675        }
676    }
677
678    mod event_synthesis {
679        use super::*;
680        use fidl::endpoints;
681        use fidl_fuchsia_input_report::MOUSE_MAX_NUM_BUTTONS;
682        use fidl_fuchsia_ui_input::{
683            InputDeviceMarker, InputDeviceProxy as FidlInputDeviceProxy, InputDeviceRequest,
684            InputDeviceRequestStream, InputReport, MediaButtonsReport, MouseReport,
685            TouchscreenReport,
686        };
687        use futures::stream::StreamExt;
688        use std::collections::HashSet;
689
690        // Like `InputReport`, but with the `Box`-ed items inlined.
691        struct InlineInputReport {
692            event_time: u64,
693            keyboard: Option<KeyboardReport>,
694            media_buttons: Option<MediaButtonsReport>,
695            touchscreen: Option<TouchscreenReport>,
696            mouse: Option<MouseReport>,
697        }
698
699        impl InlineInputReport {
700            fn new(input_report: InputReport) -> Self {
701                Self {
702                    event_time: input_report.event_time,
703                    keyboard: input_report.keyboard.map(|boxed| *boxed),
704                    media_buttons: input_report.media_buttons.map(|boxed| *boxed),
705                    touchscreen: input_report.touchscreen.map(|boxed| *boxed),
706                    mouse: input_report.mouse.map(|boxed| *boxed),
707                }
708            }
709        }
710
711        // An `impl InputDeviceRegistry` which provides access to the `InputDeviceRequest`s sent to
712        // the device registered with the `InputDeviceRegistry`. Assumes that only one device is
713        // registered.
714        struct FakeInputDeviceRegistry {
715            event_stream: Option<InputDeviceRequestStream>,
716        }
717
718        impl InputDeviceRegistry for FakeInputDeviceRegistry {
719            fn add_touchscreen_device(
720                &mut self,
721                _width: u32,
722                _height: u32,
723            ) -> Result<Box<dyn InputDevice>, Error> {
724                self.add_device()
725            }
726
727            fn add_keyboard_device(&mut self) -> Result<Box<dyn InputDevice>, Error> {
728                self.add_device()
729            }
730
731            fn add_media_buttons_device(&mut self) -> Result<Box<dyn InputDevice>, Error> {
732                self.add_device()
733            }
734
735            fn add_mouse_device(
736                &mut self,
737                _width: u32,
738                _height: u32,
739            ) -> Result<Box<dyn InputDevice>, Error> {
740                self.add_device()
741            }
742        }
743
744        impl FakeInputDeviceRegistry {
745            fn new() -> Self {
746                Self { event_stream: None }
747            }
748
749            async fn get_events(self: Self) -> Vec<Result<InlineInputReport, String>> {
750                match self.event_stream {
751                    Some(event_stream) => {
752                        event_stream
753                            .map(|fidl_result| match fidl_result {
754                                Ok(InputDeviceRequest::DispatchReport { report, .. }) => {
755                                    Ok(InlineInputReport::new(report))
756                                }
757                                Err(fidl_error) => Err(format!("FIDL error: {}", fidl_error)),
758                            })
759                            .collect()
760                            .await
761                    }
762                    None => vec![Err(format!(
763                        "called get_events() on InputDeviceRegistry with no `event_stream`"
764                    ))],
765                }
766            }
767
768            fn add_device(&mut self) -> Result<Box<dyn InputDevice>, Error> {
769                let (proxy, event_stream) =
770                    endpoints::create_proxy_and_stream::<InputDeviceMarker>();
771                self.event_stream = Some(event_stream);
772                Ok(Box::new(FakeInputDevice::new(proxy)))
773            }
774        }
775
776        /// Returns a u32 representation of `buttons`, where each u8 of `buttons` is an id of a button and
777        /// indicates the position of a bit to set.
778        ///
779        /// This supports hashsets containing numbers from 1 to fidl_input_report::MOUSE_MAX_NUM_BUTTONS.
780        ///
781        /// # Parameters
782        /// - `buttons`: The hashset containing the position of bits to be set.
783        ///
784        /// # Example
785        /// ```
786        /// let bits = get_u32_from_buttons(&HashSet::from_iter(vec![1, 3, 5]).into_iter());
787        /// assert_eq!(bits, 21 /* ...00010101 */)
788        /// ```
789        pub fn get_u32_from_buttons(buttons: &HashSet<MouseButton>) -> u32 {
790            let mut bits: u32 = 0;
791            for button in buttons {
792                if *button > 0 && *button <= MOUSE_MAX_NUM_BUTTONS as u8 {
793                    bits = ((1 as u32) << *button - 1) | bits;
794                }
795            }
796
797            bits
798        }
799
800        // Provides an `impl InputDevice` which forwards requests to a `FidlInputDeviceProxy`.
801        // Useful when a test wants to inspect the requests to an `InputDevice`.
802        struct FakeInputDevice {
803            fidl_proxy: FidlInputDeviceProxy,
804        }
805
806        #[async_trait(?Send)]
807        impl InputDevice for FakeInputDevice {
808            fn media_buttons(
809                &mut self,
810                pressed_buttons: Vec<MediaButton>,
811                time: u64,
812            ) -> Result<(), Error> {
813                self.fidl_proxy
814                    .dispatch_report(&InputReport {
815                        event_time: time,
816                        keyboard: None,
817                        media_buttons: Some(Box::new(MediaButtonsReport {
818                            volume_up: pressed_buttons.contains(&MediaButton::VolumeUp),
819                            volume_down: pressed_buttons.contains(&MediaButton::VolumeDown),
820                            mic_mute: pressed_buttons.contains(&MediaButton::MicMute),
821                            reset: pressed_buttons.contains(&MediaButton::FactoryReset),
822                            pause: pressed_buttons.contains(&MediaButton::Pause),
823                            camera_disable: pressed_buttons.contains(&MediaButton::CameraDisable),
824                        })),
825                        mouse: None,
826                        stylus: None,
827                        touchscreen: None,
828                        sensor: None,
829                        trace_id: 0,
830                    })
831                    .map_err(Into::into)
832            }
833
834            fn key_press(&mut self, keyboard: KeyboardReport, time: u64) -> Result<(), Error> {
835                self.key_press_raw(keyboard, time)
836            }
837
838            fn key_press_raw(&mut self, keyboard: KeyboardReport, time: u64) -> Result<(), Error> {
839                self.fidl_proxy
840                    .dispatch_report(&InputReport {
841                        event_time: time,
842                        keyboard: Some(Box::new(keyboard)),
843                        media_buttons: None,
844                        mouse: None,
845                        stylus: None,
846                        touchscreen: None,
847                        sensor: None,
848                        trace_id: 0,
849                    })
850                    .map_err(Into::into)
851            }
852
853            fn key_press_usage(&mut self, usage: Option<u32>, time: u64) -> Result<(), Error> {
854                self.key_press(
855                    KeyboardReport {
856                        pressed_keys: match usage {
857                            Some(usage) => vec![usage],
858                            None => vec![],
859                        },
860                    },
861                    time,
862                )
863                .map_err(Into::into)
864            }
865
866            fn tap(&mut self, pos: Option<(u32, u32)>, time: u64) -> Result<(), Error> {
867                match pos {
868                    Some((x, y)) => self.multi_finger_tap(
869                        Some(vec![Touch {
870                            finger_id: 1,
871                            x: x as i32,
872                            y: y as i32,
873                            width: 0,
874                            height: 0,
875                        }]),
876                        time,
877                    ),
878                    None => self.multi_finger_tap(None, time),
879                }
880                .map_err(Into::into)
881            }
882
883            fn multi_finger_tap(
884                &mut self,
885                fingers: Option<Vec<Touch>>,
886                time: u64,
887            ) -> Result<(), Error> {
888                self.fidl_proxy
889                    .dispatch_report(&InputReport {
890                        event_time: time,
891                        keyboard: None,
892                        media_buttons: None,
893                        mouse: None,
894                        stylus: None,
895                        touchscreen: Some(Box::new(TouchscreenReport {
896                            touches: match fingers {
897                                Some(fingers) => fingers,
898                                None => vec![],
899                            },
900                        })),
901                        sensor: None,
902                        trace_id: 0,
903                    })
904                    .map_err(Into::into)
905            }
906
907            fn mouse(&mut self, report: MouseInputReport, time: u64) -> Result<(), Error> {
908                self.fidl_proxy
909                    .dispatch_report(&InputReport {
910                        event_time: time,
911                        keyboard: None,
912                        media_buttons: None,
913                        mouse: Some(Box::new(MouseReport {
914                            rel_x: report.movement_x.unwrap() as i32,
915                            rel_y: report.movement_y.unwrap() as i32,
916                            rel_hscroll: report.scroll_h.unwrap_or(0) as i32,
917                            rel_vscroll: report.scroll_v.unwrap_or(0) as i32,
918                            pressed_buttons: match report.pressed_buttons {
919                                Some(buttons) => {
920                                    get_u32_from_buttons(&HashSet::from_iter(buttons.into_iter()))
921                                }
922                                None => 0,
923                            },
924                        })),
925                        stylus: None,
926                        touchscreen: None,
927                        sensor: None,
928                        trace_id: 0,
929                    })
930                    .map_err(Into::into)
931            }
932
933            async fn flush(self: Box<Self>) -> Result<(), Error> {
934                Ok(())
935            }
936        }
937
938        impl FakeInputDevice {
939            fn new(fidl_proxy: FidlInputDeviceProxy) -> Self {
940                Self { fidl_proxy }
941            }
942        }
943
944        /// Transforms an `IntoIterator<Item = Result<InlineInputReport, _>>` into a
945        /// `Vec<Result</* $field-specific-type */, _>>`, by projecting `$field` out of the
946        /// `InlineInputReport`s.
947        macro_rules! project {
948            ( $events:expr, $field:ident ) => {
949                $events
950                    .into_iter()
951                    .map(|result| result.map(|report| report.$field))
952                    .collect::<Vec<_>>()
953            };
954        }
955
956        #[fasync::run_singlethreaded(test)]
957        async fn media_event_report() -> Result<(), Error> {
958            let mut fake_event_listener = FakeInputDeviceRegistry::new();
959            media_button_event(
960                vec![
961                    MediaButton::VolumeUp,
962                    MediaButton::MicMute,
963                    MediaButton::Pause,
964                    MediaButton::CameraDisable,
965                ],
966                &mut fake_event_listener,
967            )
968            .await?;
969            assert_eq!(
970                project!(fake_event_listener.get_events().await, media_buttons),
971                [Ok(Some(MediaButtonsReport {
972                    volume_up: true,
973                    volume_down: false,
974                    mic_mute: true,
975                    reset: false,
976                    pause: true,
977                    camera_disable: true,
978                }))]
979            );
980            Ok(())
981        }
982
983        #[fasync::run_singlethreaded(test)]
984        async fn keyboard_event_report() -> Result<(), Error> {
985            let mut fake_event_listener = FakeInputDeviceRegistry::new();
986            keyboard_event(40, Duration::from_millis(0), &mut fake_event_listener).await?;
987            assert_eq!(
988                project!(fake_event_listener.get_events().await, keyboard),
989                [
990                    Ok(Some(KeyboardReport { pressed_keys: vec![40] })),
991                    Ok(Some(KeyboardReport { pressed_keys: vec![] }))
992                ]
993            );
994            Ok(())
995        }
996
997        #[fasync::run_singlethreaded(test)]
998        async fn dispatch_key_events() -> Result<(), Error> {
999            let mut fake_event_listener = FakeInputDeviceRegistry::new();
1000
1001            // Configures a two-key chord:
1002            // A: _/^^^^^\___
1003            // B: __/^^^\____
1004            dispatch_key_events_async(
1005                &vec![
1006                    TimedKeyEvent::new(
1007                        input::Key::A,
1008                        input3::KeyEventType::Pressed,
1009                        Duration::from_millis(10),
1010                    ),
1011                    TimedKeyEvent::new(
1012                        input::Key::B,
1013                        input3::KeyEventType::Pressed,
1014                        Duration::from_millis(20),
1015                    ),
1016                    TimedKeyEvent::new(
1017                        input::Key::B,
1018                        input3::KeyEventType::Released,
1019                        Duration::from_millis(50),
1020                    ),
1021                    TimedKeyEvent::new(
1022                        input::Key::A,
1023                        input3::KeyEventType::Released,
1024                        Duration::from_millis(60),
1025                    ),
1026                ],
1027                &mut fake_event_listener,
1028            )
1029            .await?;
1030            assert_eq!(
1031                project!(fake_event_listener.get_events().await, keyboard),
1032                [
1033                    Ok(Some(KeyboardReport { pressed_keys: vec![input::Key::A.into_primitive()] })),
1034                    Ok(Some(KeyboardReport {
1035                        pressed_keys: vec![
1036                            input::Key::A.into_primitive(),
1037                            input::Key::B.into_primitive()
1038                        ]
1039                    })),
1040                    Ok(Some(KeyboardReport { pressed_keys: vec![input::Key::A.into_primitive()] })),
1041                    Ok(Some(KeyboardReport { pressed_keys: vec![] }))
1042                ]
1043            );
1044            Ok(())
1045        }
1046
1047        #[fasync::run_singlethreaded(test)]
1048        async fn dispatch_key_events_in_wrong_sequence() -> Result<(), Error> {
1049            let mut fake_event_listener = FakeInputDeviceRegistry::new();
1050
1051            // Configures a two-key chord in the wrong temporal order.
1052            let result = dispatch_key_events_async(
1053                &vec![
1054                    TimedKeyEvent::new(
1055                        input::Key::A,
1056                        input3::KeyEventType::Pressed,
1057                        Duration::from_millis(20),
1058                    ),
1059                    TimedKeyEvent::new(
1060                        input::Key::B,
1061                        input3::KeyEventType::Pressed,
1062                        Duration::from_millis(10),
1063                    ),
1064                ],
1065                &mut fake_event_listener,
1066            )
1067            .await;
1068            match result {
1069                Err(_) => Ok(()),
1070                Ok(_) => Err(anyhow::anyhow!("expected error but got Ok")),
1071            }
1072        }
1073
1074        #[fasync::run_singlethreaded(test)]
1075        async fn dispatch_key_events_with_same_timestamp() -> Result<(), Error> {
1076            let mut fake_event_listener = FakeInputDeviceRegistry::new();
1077
1078            // Configures a two-key chord in the wrong temporal order.
1079            let result = dispatch_key_events_async(
1080                &vec![
1081                    TimedKeyEvent::new(
1082                        input::Key::A,
1083                        input3::KeyEventType::Pressed,
1084                        Duration::from_millis(20),
1085                    ),
1086                    TimedKeyEvent::new(
1087                        input::Key::B,
1088                        input3::KeyEventType::Pressed,
1089                        Duration::from_millis(20),
1090                    ),
1091                ],
1092                &mut fake_event_listener,
1093            )
1094            .await;
1095            match result {
1096                Err(_) => Ok(()),
1097                Ok(_) => Err(anyhow::anyhow!("expected error but got Ok")),
1098            }
1099        }
1100
1101        #[fasync::run_singlethreaded(test)]
1102        async fn text_event_report() -> Result<(), Error> {
1103            let mut fake_event_listener = FakeInputDeviceRegistry::new();
1104            text("A".to_string(), Duration::from_millis(0), &mut fake_event_listener).await?;
1105            assert_eq!(
1106                project!(fake_event_listener.get_events().await, keyboard),
1107                [
1108                    Ok(Some(KeyboardReport { pressed_keys: vec![225] })),
1109                    Ok(Some(KeyboardReport { pressed_keys: vec![4, 225] })),
1110                    Ok(Some(KeyboardReport { pressed_keys: vec![] })),
1111                ]
1112            );
1113            Ok(())
1114        }
1115
1116        #[fasync::run_singlethreaded(test)]
1117        async fn multi_finger_tap_event_report() -> Result<(), Error> {
1118            let mut fake_event_listener = FakeInputDeviceRegistry::new();
1119            let fingers = vec![
1120                Touch { finger_id: 1, x: 0, y: 0, width: 0, height: 0 },
1121                Touch { finger_id: 2, x: 20, y: 20, width: 0, height: 0 },
1122                Touch { finger_id: 3, x: 40, y: 40, width: 0, height: 0 },
1123                Touch { finger_id: 4, x: 60, y: 60, width: 0, height: 0 },
1124            ];
1125            multi_finger_tap_event(
1126                fingers,
1127                1000,
1128                1000,
1129                1,
1130                Duration::from_millis(0),
1131                &mut fake_event_listener,
1132            )
1133            .await?;
1134            assert_eq!(
1135                project!(fake_event_listener.get_events().await, touchscreen),
1136                [
1137                    Ok(Some(TouchscreenReport {
1138                        touches: vec![
1139                            Touch { finger_id: 1, x: 0, y: 0, width: 0, height: 0 },
1140                            Touch { finger_id: 2, x: 20, y: 20, width: 0, height: 0 },
1141                            Touch { finger_id: 3, x: 40, y: 40, width: 0, height: 0 },
1142                            Touch { finger_id: 4, x: 60, y: 60, width: 0, height: 0 },
1143                        ],
1144                    })),
1145                    Ok(Some(TouchscreenReport { touches: vec![] })),
1146                ]
1147            );
1148            Ok(())
1149        }
1150
1151        #[fasync::run_singlethreaded(test)]
1152        async fn tap_event_report() -> Result<(), Error> {
1153            let mut fake_event_listener = FakeInputDeviceRegistry::new();
1154            tap_event(10, 10, 1000, 1000, 1, Duration::from_millis(0), &mut fake_event_listener)
1155                .await?;
1156            assert_eq!(
1157                project!(fake_event_listener.get_events().await, touchscreen),
1158                [
1159                    Ok(Some(TouchscreenReport {
1160                        touches: vec![Touch { finger_id: 1, x: 10, y: 10, width: 0, height: 0 }]
1161                    })),
1162                    Ok(Some(TouchscreenReport { touches: vec![] })),
1163                ]
1164            );
1165            Ok(())
1166        }
1167
1168        #[fasync::run_singlethreaded(test)]
1169        async fn swipe_event_report() -> Result<(), Error> {
1170            let mut fake_event_listener = FakeInputDeviceRegistry::new();
1171            swipe(
1172                10,
1173                10,
1174                100,
1175                100,
1176                1000,
1177                1000,
1178                2,
1179                Duration::from_millis(0),
1180                &mut fake_event_listener,
1181            )
1182            .await?;
1183            assert_eq!(
1184                project!(fake_event_listener.get_events().await, touchscreen),
1185                [
1186                    Ok(Some(TouchscreenReport {
1187                        touches: vec![Touch { finger_id: 1, x: 10, y: 10, width: 0, height: 0 }],
1188                    })),
1189                    Ok(Some(TouchscreenReport {
1190                        touches: vec![Touch { finger_id: 1, x: 55, y: 55, width: 0, height: 0 }],
1191                    })),
1192                    Ok(Some(TouchscreenReport {
1193                        touches: vec![Touch { finger_id: 1, x: 100, y: 100, width: 0, height: 0 }],
1194                    })),
1195                    Ok(Some(TouchscreenReport { touches: vec![] })),
1196                ]
1197            );
1198            Ok(())
1199        }
1200
1201        #[fasync::run_singlethreaded(test)]
1202        async fn swipe_event_report_inverted() -> Result<(), Error> {
1203            let mut fake_event_listener = FakeInputDeviceRegistry::new();
1204            swipe(
1205                100,
1206                100,
1207                10,
1208                10,
1209                1000,
1210                1000,
1211                2,
1212                Duration::from_millis(0),
1213                &mut fake_event_listener,
1214            )
1215            .await?;
1216            assert_eq!(
1217                project!(fake_event_listener.get_events().await, touchscreen),
1218                [
1219                    Ok(Some(TouchscreenReport {
1220                        touches: vec![Touch { finger_id: 1, x: 100, y: 100, width: 0, height: 0 }],
1221                    })),
1222                    Ok(Some(TouchscreenReport {
1223                        touches: vec![Touch { finger_id: 1, x: 55, y: 55, width: 0, height: 0 }],
1224                    })),
1225                    Ok(Some(TouchscreenReport {
1226                        touches: vec![Touch { finger_id: 1, x: 10, y: 10, width: 0, height: 0 }],
1227                    })),
1228                    Ok(Some(TouchscreenReport { touches: vec![] })),
1229                ]
1230            );
1231            Ok(())
1232        }
1233
1234        #[fasync::run_singlethreaded(test)]
1235        async fn multi_finger_swipe_event_report() -> Result<(), Error> {
1236            let mut fake_event_listener = FakeInputDeviceRegistry::new();
1237            multi_finger_swipe(
1238                vec![(10, 10), (20, 20), (30, 30)],
1239                vec![(100, 100), (120, 120), (150, 150)],
1240                1000,
1241                1000,
1242                2,
1243                Duration::from_millis(0),
1244                &mut fake_event_listener,
1245            )
1246            .await?;
1247            assert_eq!(
1248                project!(fake_event_listener.get_events().await, touchscreen),
1249                [
1250                    Ok(Some(TouchscreenReport {
1251                        touches: vec![
1252                            Touch { finger_id: 1, x: 10, y: 10, width: 0, height: 0 },
1253                            Touch { finger_id: 2, x: 20, y: 20, width: 0, height: 0 },
1254                            Touch { finger_id: 3, x: 30, y: 30, width: 0, height: 0 }
1255                        ],
1256                    })),
1257                    Ok(Some(TouchscreenReport {
1258                        touches: vec![
1259                            Touch { finger_id: 1, x: 55, y: 55, width: 0, height: 0 },
1260                            Touch { finger_id: 2, x: 70, y: 70, width: 0, height: 0 },
1261                            Touch { finger_id: 3, x: 90, y: 90, width: 0, height: 0 }
1262                        ],
1263                    })),
1264                    Ok(Some(TouchscreenReport {
1265                        touches: vec![
1266                            Touch { finger_id: 1, x: 100, y: 100, width: 0, height: 0 },
1267                            Touch { finger_id: 2, x: 120, y: 120, width: 0, height: 0 },
1268                            Touch { finger_id: 3, x: 150, y: 150, width: 0, height: 0 }
1269                        ],
1270                    })),
1271                    Ok(Some(TouchscreenReport { touches: vec![] })),
1272                ]
1273            );
1274            Ok(())
1275        }
1276
1277        #[fasync::run_singlethreaded(test)]
1278        async fn multi_finger_swipe_event_report_inverted() -> Result<(), Error> {
1279            let mut fake_event_listener = FakeInputDeviceRegistry::new();
1280            multi_finger_swipe(
1281                vec![(100, 100), (120, 120), (150, 150)],
1282                vec![(10, 10), (20, 20), (30, 30)],
1283                1000,
1284                1000,
1285                2,
1286                Duration::from_millis(0),
1287                &mut fake_event_listener,
1288            )
1289            .await?;
1290            assert_eq!(
1291                project!(fake_event_listener.get_events().await, touchscreen),
1292                [
1293                    Ok(Some(TouchscreenReport {
1294                        touches: vec![
1295                            Touch { finger_id: 1, x: 100, y: 100, width: 0, height: 0 },
1296                            Touch { finger_id: 2, x: 120, y: 120, width: 0, height: 0 },
1297                            Touch { finger_id: 3, x: 150, y: 150, width: 0, height: 0 }
1298                        ],
1299                    })),
1300                    Ok(Some(TouchscreenReport {
1301                        touches: vec![
1302                            Touch { finger_id: 1, x: 55, y: 55, width: 0, height: 0 },
1303                            Touch { finger_id: 2, x: 70, y: 70, width: 0, height: 0 },
1304                            Touch { finger_id: 3, x: 90, y: 90, width: 0, height: 0 }
1305                        ],
1306                    })),
1307                    Ok(Some(TouchscreenReport {
1308                        touches: vec![
1309                            Touch { finger_id: 1, x: 10, y: 10, width: 0, height: 0 },
1310                            Touch { finger_id: 2, x: 20, y: 20, width: 0, height: 0 },
1311                            Touch { finger_id: 3, x: 30, y: 30, width: 0, height: 0 }
1312                        ],
1313                    })),
1314                    Ok(Some(TouchscreenReport { touches: vec![] })),
1315                ]
1316            );
1317            Ok(())
1318        }
1319
1320        #[fasync::run_singlethreaded(test)]
1321        async fn multi_finger_swipe_event_zero_move_events() -> Result<(), Error> {
1322            let mut fake_event_listener = FakeInputDeviceRegistry::new();
1323            multi_finger_swipe(
1324                vec![(10, 10), (20, 20), (30, 30)],
1325                vec![(100, 100), (120, 120), (150, 150)],
1326                1000,
1327                1000,
1328                0,
1329                Duration::from_millis(0),
1330                &mut fake_event_listener,
1331            )
1332            .await?;
1333            assert_eq!(
1334                project!(fake_event_listener.get_events().await, touchscreen),
1335                [
1336                    Ok(Some(TouchscreenReport {
1337                        touches: vec![
1338                            Touch { finger_id: 1, x: 10, y: 10, width: 0, height: 0 },
1339                            Touch { finger_id: 2, x: 20, y: 20, width: 0, height: 0 },
1340                            Touch { finger_id: 3, x: 30, y: 30, width: 0, height: 0 }
1341                        ],
1342                    })),
1343                    Ok(Some(TouchscreenReport { touches: vec![] })),
1344                ]
1345            );
1346            Ok(())
1347        }
1348
1349        #[fasync::run_singlethreaded(test)]
1350        async fn mouse_event_report() -> Result<(), Error> {
1351            let mut fake_event_listener = FakeInputDeviceRegistry::new();
1352            add_mouse_device(100, 100, &mut fake_event_listener).await?.mouse(
1353                MouseInputReport {
1354                    movement_x: Some(10),
1355                    movement_y: Some(15),
1356                    ..Default::default()
1357                },
1358                monotonic_nanos()?,
1359            )?;
1360            assert_eq!(
1361                project!(fake_event_listener.get_events().await, mouse),
1362                [Ok(Some(MouseReport {
1363                    rel_x: 10,
1364                    rel_y: 15,
1365                    pressed_buttons: 0,
1366                    rel_hscroll: 0,
1367                    rel_vscroll: 0
1368                })),]
1369            );
1370            Ok(())
1371        }
1372
1373        #[fasync::run_singlethreaded(test)]
1374        async fn events_use_monotonic_time() -> Result<(), Error> {
1375            let mut fake_event_listener = FakeInputDeviceRegistry::new();
1376            let synthesis_start_time = monotonic_nanos()?;
1377            media_button_event(
1378                vec![
1379                    MediaButton::VolumeUp,
1380                    MediaButton::MicMute,
1381                    MediaButton::Pause,
1382                    MediaButton::CameraDisable,
1383                ],
1384                &mut fake_event_listener,
1385            )
1386            .await?;
1387
1388            let synthesis_end_time = monotonic_nanos()?;
1389            let fidl_result = fake_event_listener
1390                .get_events()
1391                .await
1392                .into_iter()
1393                .nth(0)
1394                .expect("received 0 events");
1395            let timestamp =
1396                fidl_result.map_err(anyhow::Error::msg).context("fidl call")?.event_time;
1397
1398            // Note well: neither condition is sufficient on its own, to verify that
1399            // `synthesizer` has used the correct clock. For example:
1400            //
1401            // * `timestamp >= synthesis_start_time` would be true for a `UNIX_EPOCH` clock
1402            //   with the correct time, since the elapsed time from 1970-01-01T00:00:00+00:00
1403            //   to now is (much) larger than the elapsed time from boot to `synthesis_start_time`
1404            // * `timestamp <= synthesis_end_time` would be true for a `UNIX_EPOCH` clock
1405            //   has been recently set to 0, because `synthesis_end_time` is highly unlikely to
1406            //   be near 0 (as it is monotonic from boot)
1407            //
1408            // By bracketing between monotonic clock reads before and after the event generation,
1409            // this test avoids the hazards above. The test also avoids the hazard of using a
1410            // fixed offset from the start time (which could flake on a slow builder).
1411            assert!(
1412                timestamp >= synthesis_start_time,
1413                "timestamp={} should be >= start={}",
1414                timestamp,
1415                synthesis_start_time
1416            );
1417            assert!(
1418                timestamp <= synthesis_end_time,
1419                "timestamp={} should be <= end={}",
1420                timestamp,
1421                synthesis_end_time
1422            );
1423            Ok(())
1424        }
1425    }
1426
1427    mod device_registration {
1428        use super::*;
1429        use assert_matches::assert_matches;
1430
1431        #[derive(Debug)]
1432        enum DeviceType {
1433            Keyboard,
1434            MediaButtons,
1435            Touchscreen,
1436            Mouse,
1437        }
1438
1439        // An `impl InputDeviceRegistry` which provides access to the `DeviceType`s which have been
1440        // registered with the `InputDeviceRegistry`.
1441        struct FakeInputDeviceRegistry {
1442            device_types: Vec<DeviceType>,
1443        }
1444
1445        impl InputDeviceRegistry for FakeInputDeviceRegistry {
1446            fn add_touchscreen_device(
1447                &mut self,
1448                _width: u32,
1449                _height: u32,
1450            ) -> Result<Box<dyn InputDevice>, Error> {
1451                self.add_device(DeviceType::Touchscreen)
1452            }
1453
1454            fn add_keyboard_device(&mut self) -> Result<Box<dyn InputDevice>, Error> {
1455                self.add_device(DeviceType::Keyboard)
1456            }
1457
1458            fn add_media_buttons_device(&mut self) -> Result<Box<dyn InputDevice>, Error> {
1459                self.add_device(DeviceType::MediaButtons)
1460            }
1461
1462            fn add_mouse_device(
1463                &mut self,
1464                _width: u32,
1465                _height: u32,
1466            ) -> Result<Box<dyn InputDevice>, Error> {
1467                self.add_device(DeviceType::Mouse)
1468            }
1469        }
1470
1471        impl FakeInputDeviceRegistry {
1472            fn new() -> Self {
1473                Self { device_types: vec![] }
1474            }
1475
1476            fn add_device(
1477                &mut self,
1478                device_type: DeviceType,
1479            ) -> Result<Box<dyn InputDevice>, Error> {
1480                self.device_types.push(device_type);
1481                Ok(Box::new(FakeInputDevice))
1482            }
1483        }
1484
1485        // Provides an `impl InputDevice` which always returns `Ok(())`. Useful when the
1486        // events themselves are not important to the test.
1487        struct FakeInputDevice;
1488
1489        #[async_trait(?Send)]
1490        impl InputDevice for FakeInputDevice {
1491            fn media_buttons(
1492                &mut self,
1493                _pressed_buttons: Vec<MediaButton>,
1494                _time: u64,
1495            ) -> Result<(), Error> {
1496                Ok(())
1497            }
1498
1499            fn key_press(&mut self, _keyboard: KeyboardReport, _time: u64) -> Result<(), Error> {
1500                Ok(())
1501            }
1502
1503            fn key_press_raw(
1504                &mut self,
1505                _keyboard: KeyboardReport,
1506                _time: u64,
1507            ) -> Result<(), Error> {
1508                Ok(())
1509            }
1510
1511            fn key_press_usage(&mut self, _usage: Option<u32>, _time: u64) -> Result<(), Error> {
1512                Ok(())
1513            }
1514
1515            fn tap(&mut self, _pos: Option<(u32, u32)>, _time: u64) -> Result<(), Error> {
1516                Ok(())
1517            }
1518
1519            fn multi_finger_tap(
1520                &mut self,
1521                _fingers: Option<Vec<Touch>>,
1522                _time: u64,
1523            ) -> Result<(), Error> {
1524                Ok(())
1525            }
1526
1527            fn mouse(&mut self, _report: MouseInputReport, _time: u64) -> Result<(), Error> {
1528                Ok(())
1529            }
1530
1531            async fn flush(self: Box<Self>) -> Result<(), Error> {
1532                Ok(())
1533            }
1534        }
1535
1536        #[fasync::run_until_stalled(test)]
1537        async fn media_button_event_registers_media_buttons_device() -> Result<(), Error> {
1538            let mut registry = FakeInputDeviceRegistry::new();
1539            media_button_event(vec![], &mut registry).await?;
1540            assert_matches!(registry.device_types.as_slice(), [DeviceType::MediaButtons]);
1541            Ok(())
1542        }
1543
1544        #[fasync::run_singlethreaded(test)]
1545        async fn keyboard_event_registers_keyboard() -> Result<(), Error> {
1546            let mut registry = FakeInputDeviceRegistry::new();
1547            keyboard_event(40, Duration::from_millis(0), &mut registry).await?;
1548            assert_matches!(registry.device_types.as_slice(), [DeviceType::Keyboard]);
1549            Ok(())
1550        }
1551
1552        #[fasync::run_until_stalled(test)]
1553        async fn text_event_registers_keyboard() -> Result<(), Error> {
1554            let mut registry = FakeInputDeviceRegistry::new();
1555            text("A".to_string(), Duration::from_millis(0), &mut registry).await?;
1556            assert_matches!(registry.device_types.as_slice(), [DeviceType::Keyboard]);
1557            Ok(())
1558        }
1559
1560        #[fasync::run_singlethreaded(test)]
1561        async fn multi_finger_tap_event_registers_touchscreen() -> Result<(), Error> {
1562            let mut registry = FakeInputDeviceRegistry::new();
1563            multi_finger_tap_event(vec![], 1000, 1000, 1, Duration::from_millis(0), &mut registry)
1564                .await?;
1565            assert_matches!(registry.device_types.as_slice(), [DeviceType::Touchscreen]);
1566            Ok(())
1567        }
1568
1569        #[fasync::run_singlethreaded(test)]
1570        async fn tap_event_registers_touchscreen() -> Result<(), Error> {
1571            let mut registry = FakeInputDeviceRegistry::new();
1572            tap_event(0, 0, 1000, 1000, 1, Duration::from_millis(0), &mut registry).await?;
1573            assert_matches!(registry.device_types.as_slice(), [DeviceType::Touchscreen]);
1574            Ok(())
1575        }
1576
1577        #[fasync::run_singlethreaded(test)]
1578        async fn swipe_registers_touchscreen() -> Result<(), Error> {
1579            let mut registry = FakeInputDeviceRegistry::new();
1580            swipe(0, 0, 1, 1, 1000, 1000, 1, Duration::from_millis(0), &mut registry).await?;
1581            assert_matches!(registry.device_types.as_slice(), [DeviceType::Touchscreen]);
1582            Ok(())
1583        }
1584
1585        #[fasync::run_singlethreaded(test)]
1586        async fn multi_finger_swipe_registers_touchscreen() -> Result<(), Error> {
1587            let mut registry = FakeInputDeviceRegistry::new();
1588            multi_finger_swipe(
1589                vec![],
1590                vec![],
1591                1000,
1592                1000,
1593                1,
1594                Duration::from_millis(0),
1595                &mut registry,
1596            )
1597            .await?;
1598            assert_matches!(registry.device_types.as_slice(), [DeviceType::Touchscreen]);
1599            Ok(())
1600        }
1601
1602        #[fasync::run_until_stalled(test)]
1603        async fn add_mouse_device_registers_mouse_device() -> Result<(), Error> {
1604            let mut registry = FakeInputDeviceRegistry::new();
1605            add_mouse_device(100, 100, &mut registry).await?;
1606            assert_matches!(registry.device_types.as_slice(), [DeviceType::Mouse]);
1607            Ok(())
1608        }
1609    }
1610}
input_synthesis/synthesizer.rs

input_synthesis/
synthesizer.rs
