nikau 0.3.3

Linux network KVM for Wayland/X11/Console
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use std::collections::{HashMap, HashSet};
use std::path::{Path, PathBuf};

use anyhow::{Context, Result};
use evdev::{Device, EventStream, Key};
use tokio::sync::broadcast;
use tokio::task;
use tracing::debug;

use crate::device;
use crate::device::util;

pub struct DeviceHandle {
    pub handle: task::JoinHandle<()>,
}

/// Trait for watching the addition and removal of devices from the machine
pub trait DeviceHandler: Send + 'static {
    fn handle_device_stream(
        &mut self,
        events: EventStream,
        grab_rx: Option<broadcast::Receiver<device::GrabEvent>>,
        device_info: util::DeviceInfo,
    ) -> Result<DeviceHandle>;
}

pub struct DeviceHandles<H: DeviceHandler> {
    /// Devices which support one or more keys specified in client switch key combos.
    /// These devices are always grabbed at the server so that we can consistently
    /// grab/"swallow" the key combo input when the local server is the active target.
    always_grabbed_devices: HashMap<PathBuf, DeviceHandle>,

    /// Devices which don't support one or more key combo keys, such as mice.
    /// When the local server is the active target, nikau ungrabs the device and allows
    /// its input to pass through directly.
    toggled_devices: HashMap<PathBuf, DeviceHandle>,

    handler: H,

    /// Method for subscribing devices to grab events
    grab_tx: broadcast::Sender<device::GrabEvent>,

    /// All distinct keys used in client switch key combos, for internal accounting.
    all_combo_keys: HashSet<Key>,
}

impl<H: DeviceHandler> DeviceHandles<H> {
    pub fn new(
        handler: H,
        grab_tx: broadcast::Sender<device::GrabEvent>,
        all_combo_keys: HashSet<Key>,
    ) -> DeviceHandles<H> {
        DeviceHandles {
            always_grabbed_devices: HashMap::<PathBuf, DeviceHandle>::new(),
            toggled_devices: HashMap::<PathBuf, DeviceHandle>::new(),
            handler,
            grab_tx,
            all_combo_keys,
        }
    }

    pub(crate) fn add(&mut self, path: &PathBuf, device: Device) -> Result<()> {
        let device_info = util::DeviceInfo::new(&device, false);
        util::log_device_info(&device, &path, &device_info, "Listening to device", true);
        let supports_any_keys = supports_any_keys(&device, &self.all_combo_keys);
        if supports_any_keys {
            debug!(
                "Device supports one or more configured combo keys: {}",
                device.name().unwrap_or("(Unnamed device)")
            );
        }
        if supports_any_keys {
            // This device supports one or more keys configured for client switch key combinations.
            // We should grab/route its input via nikau so that we can omit keypresses from the combos.
            let join_handle = self.handler.handle_device_stream(
                start_device_stream(device, path)?,
                None,
                device_info,
            )?;
            self.always_grabbed_devices
                .insert(path.clone(), join_handle);
        } else {
            // This device doesn't support keys used in key combinations (e.g. a mouse).
            // When the server is the active input, we can ungrab the device,
            // letting its input pass through directly.
            let join_handle = self.handler.handle_device_stream(
                start_device_stream(device, path)?,
                Some(self.grab_tx.subscribe()),
                device_info,
            )?;
            self.toggled_devices.insert(path.clone(), join_handle);
        }
        Ok(())
    }

    pub(crate) fn remove(&mut self, path: &PathBuf) -> Option<DeviceHandle> {
        if let Some(handle) = self.always_grabbed_devices.remove(path) {
            return Some(handle);
        }
        self.toggled_devices.remove(path)
    }

    pub(crate) fn is_empty(&self) -> bool {
        self.always_grabbed_devices.is_empty() && self.toggled_devices.is_empty()
    }
}

fn supports_any_keys(d: &Device, all_combo_keys: &HashSet<Key>) -> bool {
    if let Some(device_keys) = d.supported_keys() {
        for key in all_combo_keys.iter() {
            if device_keys.contains(*key) {
                return true;
            }
        }
    }
    false
}

fn start_device_stream(device: Device, path: &Path) -> Result<EventStream> {
    device.into_event_stream().with_context(|| {
        format!(
            "Failed to initialize async fd for device: {}",
            path.to_string_lossy()
        )
    })
}