carnelian/
input.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::app::{InternalSender, MessageInternal};
6use crate::geometry::{IntPoint, IntSize};
7use anyhow::{format_err, Error};
8use euclid::default::Transform2D;
9use fidl::endpoints::create_proxy;
10use fidl_fuchsia_input_report as hid_input_report;
11use fuchsia_async::{self as fasync, MonotonicInstant, TimeoutExt};
12use futures::{TryFutureExt, TryStreamExt};
13use keymaps::usages::input3_key_to_hid_usage;
14use std::collections::HashSet;
15use std::fs;
16use std::hash::{Hash, Hasher};
17use std::path::{Path, PathBuf};
18use zx::{self as zx, MonotonicDuration};
19
20#[derive(Debug)]
21pub(crate) enum UserInputMessage {
22    ScenicKeyEvent(fidl_fuchsia_ui_input3::KeyEvent),
23    FlatlandMouseEvents(Vec<fidl_fuchsia_ui_pointer::MouseEvent>),
24    FlatlandTouchEvents(Vec<fidl_fuchsia_ui_pointer::TouchEvent>),
25}
26
27/// A button on a mouse
28#[derive(Clone, Debug, Default, Eq, PartialEq, Hash)]
29pub struct Button(pub u8);
30
31const PRIMARY_BUTTON: u8 = 1;
32
33impl Button {
34    /// Is this the primary button, usually the leftmost button on
35    /// a mouse.
36    pub fn is_primary(&self) -> bool {
37        self.0 == PRIMARY_BUTTON
38    }
39}
40
41/// A set of buttons.
42#[derive(Clone, Debug, Default, PartialEq)]
43pub struct ButtonSet {
44    buttons: HashSet<Button>,
45}
46
47impl ButtonSet {
48    /// Create a new set of buttons from input report flags.
49    pub fn new(buttons: &HashSet<u8>) -> ButtonSet {
50        ButtonSet { buttons: buttons.iter().map(|button| Button(*button)).collect() }
51    }
52
53    /// Create a new set of buttons from scenic flags.
54    pub fn new_from_flags(flags: u32) -> ButtonSet {
55        let buttons: HashSet<u8> = (0..2)
56            .filter_map(|index| {
57                let mask = 1 << index;
58                if flags & mask != 0 {
59                    Some(index + 1)
60                } else {
61                    None
62                }
63            })
64            .collect();
65        ButtonSet::new(&buttons)
66    }
67
68    /// Convenience function for checking if the primary button is down.
69    pub fn primary_button_is_down(&self) -> bool {
70        self.buttons.contains(&Button(PRIMARY_BUTTON))
71    }
72}
73
74/// Keyboard modifier keys.
75#[derive(Debug, Default, PartialEq, Clone, Copy)]
76pub struct Modifiers {
77    /// A shift key is down.
78    pub shift: bool,
79    /// An alt or option key is down.
80    pub alt: bool,
81    /// A control key is down.
82    pub control: bool,
83    /// A caps lock key is down.
84    pub caps_lock: bool,
85}
86
87impl Modifiers {
88    pub(crate) fn from_pressed_keys_3(pressed_keys: &HashSet<fidl_fuchsia_input::Key>) -> Self {
89        Self {
90            shift: pressed_keys.contains(&fidl_fuchsia_input::Key::LeftShift)
91                || pressed_keys.contains(&fidl_fuchsia_input::Key::RightShift),
92            alt: pressed_keys.contains(&fidl_fuchsia_input::Key::LeftAlt)
93                || pressed_keys.contains(&fidl_fuchsia_input::Key::RightAlt),
94            control: pressed_keys.contains(&fidl_fuchsia_input::Key::LeftCtrl)
95                || pressed_keys.contains(&fidl_fuchsia_input::Key::RightCtrl),
96            caps_lock: pressed_keys.contains(&fidl_fuchsia_input::Key::CapsLock),
97        }
98    }
99
100    pub(crate) fn is_modifier(key: &fidl_fuchsia_input::Key) -> bool {
101        match key {
102            fidl_fuchsia_input::Key::LeftShift
103            | fidl_fuchsia_input::Key::RightShift
104            | fidl_fuchsia_input::Key::LeftAlt
105            | fidl_fuchsia_input::Key::RightAlt
106            | fidl_fuchsia_input::Key::LeftCtrl
107            | fidl_fuchsia_input::Key::RightCtrl
108            | fidl_fuchsia_input::Key::CapsLock => true,
109            _ => false,
110        }
111    }
112}
113
114/// Mouse-related items
115pub mod mouse {
116    use super::*;
117    use crate::geometry::IntVector;
118
119    /// Phase of a mouse event.
120    #[derive(Debug, PartialEq, Clone)]
121    pub enum Phase {
122        /// A particular button went down.
123        Down(Button),
124        /// A particular button came up.
125        Up(Button),
126        /// The mouse moved, with or without a change in button state.
127        Moved,
128        /// The mouse wheel changed position.
129        Wheel(IntVector),
130    }
131
132    /// A mouse event.
133    #[derive(Debug, PartialEq, Clone)]
134    pub struct Event {
135        /// Pressed buttons.
136        pub buttons: ButtonSet,
137        /// Event phase.
138        pub phase: Phase,
139        /// Location of the mouse cursor during this event.
140        pub location: IntPoint,
141    }
142
143    pub(crate) fn create_event(
144        event_time: u64,
145        device_id: &DeviceId,
146        button_set: &ButtonSet,
147        cursor_position: IntPoint,
148        transform: &Transform2D<f32>,
149        phase: mouse::Phase,
150    ) -> super::Event {
151        let cursor_position = transform.transform_point(cursor_position.to_f32()).to_i32();
152        let mouse_event =
153            mouse::Event { buttons: button_set.clone(), phase, location: cursor_position };
154        super::Event {
155            event_time,
156            device_id: device_id.clone(),
157            event_type: EventType::Mouse(mouse_event),
158        }
159    }
160}
161
162/// Keyboard-related items.
163pub mod keyboard {
164    use super::*;
165
166    /// Phase of a keyboard event.
167    #[derive(Clone, Copy, Debug, PartialEq)]
168    pub enum Phase {
169        /// A key is pressed.
170        Pressed,
171        /// A key is released.
172        Released,
173        /// A key is no longer pressed without being released.
174        Cancelled,
175        /// A key has been held down long enough to start repeating.
176        Repeat,
177    }
178
179    /// A keyboard event.
180    #[derive(Debug, PartialEq, Clone)]
181    pub struct Event {
182        /// Event phase.
183        pub phase: Phase,
184        /// Unicode code point of the key causing the event, if any.
185        pub code_point: Option<u32>,
186        /// USB HID usage of the key causing the event.
187        pub hid_usage: u32,
188        /// Modifier keys being pressed or held in addition to the key
189        /// causing the event.
190        pub modifiers: Modifiers,
191    }
192}
193
194/// Touch-related items.
195pub mod touch {
196    use super::*;
197
198    #[derive(Debug, Eq)]
199    pub(crate) struct RawContact {
200        pub contact_id: u32,
201        pub position: IntPoint,
202        // TODO(https://fxbug.dev/42165549)
203        #[allow(unused)]
204        pub pressure: Option<i64>,
205        pub contact_size: Option<IntSize>,
206    }
207
208    impl PartialEq for RawContact {
209        fn eq(&self, rhs: &Self) -> bool {
210            self.contact_id == rhs.contact_id
211        }
212    }
213
214    impl Hash for RawContact {
215        fn hash<H: Hasher>(&self, state: &mut H) {
216            self.contact_id.hash(state);
217        }
218    }
219
220    /// ID of a touch contact.
221    #[derive(Clone, Copy, Debug, Eq, Ord, PartialOrd, PartialEq, Hash)]
222    pub struct ContactId(pub u32);
223
224    /// Phase of a touch event.
225    #[derive(Debug, PartialEq, Clone)]
226    pub enum Phase {
227        /// A contact began.
228        Down(IntPoint, IntSize),
229        /// A contact moved.
230        Moved(IntPoint, IntSize),
231        /// A contact ended.
232        Up,
233        /// A contact was removed.
234        Remove,
235        /// A contact was cancelled.
236        Cancel,
237    }
238
239    /// A single contact found in a touch event.
240    #[derive(Debug, Clone, PartialEq)]
241    pub struct Contact {
242        /// ID of this contact
243        pub contact_id: ContactId,
244        /// Phase of this contact
245        pub phase: Phase,
246    }
247
248    /// A touch event.
249    #[derive(Debug, PartialEq, Clone)]
250    pub struct Event {
251        /// All the current contact in this event
252        pub contacts: Vec<Contact>,
253        /// Buttons in this touch event, possible if the touch comes
254        /// from a stylus with buttons.
255        pub buttons: ButtonSet,
256    }
257}
258
259/// Pointer event
260///
261/// Carnelian provides a least-common-denominator pointer event that can be created from
262/// either touch events or mouse events.
263pub mod pointer {
264    use super::*;
265
266    /// Pointer phase.
267    #[derive(Debug, PartialEq, Clone)]
268    pub enum Phase {
269        /// A pointer has gone down.
270        Down(IntPoint),
271        /// A pointer has moved.
272        Moved(IntPoint),
273        /// A pointer has come up.
274        Up,
275        /// A pointer has been removed without coming up.
276        Remove,
277        /// A pointer has been cancelled.
278        Cancel,
279    }
280
281    /// Pointer ID.
282    #[derive(Clone, Debug, Eq, Ord, PartialOrd, PartialEq, Hash)]
283    pub enum PointerId {
284        /// ID from a mouse event.
285        Mouse(DeviceId),
286        /// ID from a contact in a touch event.
287        Contact(touch::ContactId),
288    }
289
290    /// Pointer event.
291    #[derive(Debug, PartialEq, Clone)]
292    pub struct Event {
293        /// Pointer event phase.
294        pub phase: Phase,
295        /// Pointer event pointer ID.
296        pub pointer_id: PointerId,
297    }
298
299    impl Event {
300        /// Create a pointer event from a mouse event.
301        pub fn new_from_mouse_event(
302            device_id: &DeviceId,
303            mouse_event: &mouse::Event,
304        ) -> Option<Self> {
305            match &mouse_event.phase {
306                mouse::Phase::Down(button) => {
307                    if button.is_primary() {
308                        Some(pointer::Phase::Down(mouse_event.location))
309                    } else {
310                        None
311                    }
312                }
313                mouse::Phase::Moved => {
314                    if mouse_event.buttons.primary_button_is_down() {
315                        Some(pointer::Phase::Moved(mouse_event.location))
316                    } else {
317                        None
318                    }
319                }
320                mouse::Phase::Up(button) => {
321                    if button.is_primary() {
322                        Some(pointer::Phase::Up)
323                    } else {
324                        None
325                    }
326                }
327                mouse::Phase::Wheel(_) => None,
328            }
329            .and_then(|phase| Some(Self { phase, pointer_id: PointerId::Mouse(device_id.clone()) }))
330        }
331
332        /// Create a pointer event from a single contact in a touch event.
333        pub fn new_from_contact(contact: &touch::Contact) -> Self {
334            let phase = match contact.phase {
335                touch::Phase::Down(location, ..) => pointer::Phase::Down(location),
336                touch::Phase::Moved(location, ..) => pointer::Phase::Moved(location),
337                touch::Phase::Up => pointer::Phase::Up,
338                touch::Phase::Remove => pointer::Phase::Remove,
339                touch::Phase::Cancel => pointer::Phase::Cancel,
340            };
341            Self { phase, pointer_id: PointerId::Contact(contact.contact_id) }
342        }
343    }
344}
345
346/// Events related to "consumer control" buttons, like volume controls.
347///
348/// These events are separated because they are different devices at the driver
349/// level, but it's not clear this is the right abstraction for Carnelian.
350pub mod consumer_control {
351    use super::*;
352
353    /// Phase of a consumer control event.
354    #[derive(Debug, PartialEq, Clone, Copy)]
355    pub enum Phase {
356        /// Button went down.
357        Down,
358        /// Button came up.
359        Up,
360    }
361
362    /// A consumer control event.
363    #[derive(Debug, PartialEq, Clone)]
364    pub struct Event {
365        /// Phase of event.
366        pub phase: Phase,
367        /// USB HID for key being pressed or released.
368        pub button: hid_input_report::ConsumerControlButton,
369    }
370}
371
372/// Unique identifier for an input device.
373#[derive(Clone, Debug, Default, Eq, PartialEq, Hash, PartialOrd, Ord)]
374pub struct DeviceId(pub String);
375
376/// Enum of all supported user-input events.
377#[derive(Debug, PartialEq, Clone)]
378pub enum EventType {
379    /// Mouse event.
380    Mouse(mouse::Event),
381    /// Keyboard event.
382    Keyboard(keyboard::Event),
383    /// Touch event.
384    Touch(touch::Event),
385    /// Consumer control event.
386    ConsumerControl(consumer_control::Event),
387}
388
389/// Over user-input struct.
390#[derive(Debug, PartialEq, Clone)]
391pub struct Event {
392    /// Time of event.
393    pub event_time: u64,
394    /// Id of device producting this event.
395    pub device_id: DeviceId,
396    /// The event.
397    pub event_type: EventType,
398}
399
400async fn listen_to_path(device_path: &Path, internal_sender: &InternalSender) -> Result<(), Error> {
401    let (client, server) = zx::Channel::create();
402    fdio::service_connect(device_path.to_str().expect("bad path"), server)?;
403    let client = fasync::Channel::from_channel(client);
404    let device = hid_input_report::InputDeviceProxy::new(client);
405    let descriptor = device
406        .get_descriptor()
407        .map_err(|err| format_err!("FIDL error on get_descriptor: {:?}", err))
408        .on_timeout(MonotonicInstant::after(MonotonicDuration::from_millis(200)), || {
409            Err(format_err!("FIDL timeout on get_descriptor"))
410        })
411        .await?;
412    let device_id = device_path.file_name().expect("file_name").to_string_lossy().to_string();
413    internal_sender
414        .unbounded_send(MessageInternal::RegisterDevice(DeviceId(device_id.clone()), descriptor))
415        .expect("unbounded_send");
416    let input_report_sender = internal_sender.clone();
417    let (input_reports_reader_proxy, input_reports_reader_request) = create_proxy();
418    device.get_input_reports_reader(input_reports_reader_request)?;
419    fasync::Task::local(async move {
420        let _device = device;
421        loop {
422            let reports_res = input_reports_reader_proxy.read_input_reports().await;
423            match reports_res {
424                Ok(r) => match r {
425                    Ok(reports) => {
426                        for report in reports {
427                            input_report_sender
428                                .unbounded_send(MessageInternal::InputReport(
429                                    DeviceId(device_id.clone()),
430                                    report,
431                                ))
432                                .expect("unbounded_send");
433                        }
434                    }
435                    Err(err) => {
436                        eprintln!("Error report from read_input_reports: {}: {}", device_id, err);
437                        break;
438                    }
439                },
440                Err(err) => {
441                    eprintln!("Error report from read_input_reports: {}: {}", device_id, err);
442                    break;
443                }
444            }
445        }
446    })
447    .detach();
448    Ok(())
449}
450
451pub(crate) async fn listen_for_user_input(internal_sender: InternalSender) -> Result<(), Error> {
452    let input_devices_directory = "/dev/class/input-report";
453    let watcher_sender = internal_sender.clone();
454    let path = std::path::Path::new(input_devices_directory);
455    let entries = fs::read_dir(path)?;
456    for entry in entries {
457        let entry = entry?;
458        match listen_to_path(&entry.path(), &internal_sender).await {
459            Err(err) => {
460                eprintln!("Error: {}: {}", entry.file_name().to_string_lossy(), err)
461            }
462            _ => (),
463        }
464    }
465    let dir_proxy = fuchsia_fs::directory::open_in_namespace(
466        input_devices_directory,
467        fuchsia_fs::PERM_READABLE,
468    )?;
469    let mut watcher = fuchsia_fs::directory::Watcher::new(&dir_proxy).await?;
470    fasync::Task::local(async move {
471        let input_devices_directory_path = PathBuf::from("/dev/class/input-report");
472        while let Some(msg) = (watcher.try_next()).await.expect("msg") {
473            match msg.event {
474                fuchsia_fs::directory::WatchEvent::ADD_FILE => {
475                    let device_path = input_devices_directory_path.join(msg.filename);
476                    match listen_to_path(&device_path, &watcher_sender).await {
477                        Err(err) => {
478                            eprintln!("Error: {:?}: {}", device_path, err)
479                        }
480                        _ => (),
481                    };
482                }
483                _ => (),
484            }
485        }
486    })
487    .detach();
488
489    Ok(())
490}
491
492pub(crate) mod flatland;
493pub(crate) mod key3;
494pub(crate) mod report;
495
496#[cfg(test)]
497mod tests;
carnelian/input.rs

carnelian/
input.rs
