keyboard_identifier 0.2.0

Async keyboard enumeration and hotplug events for Linux, Windows, and macOS
Documentation
mod key_mapping;
use super::{Keyboard, KeyboardEvent, KeyboardID, KeyboardSource, PortID};
use evdev::{Device as EvdevDevice, KeyCode};
use key_mapping::*;
use keyboard_types::{KeyboardEvent as KeyEvent, Modifiers};
use std::{collections::HashMap, io, path::PathBuf, sync::Arc};
use tokio::{
    io::unix::AsyncFd,
    sync::{broadcast, mpsc},
    task::JoinHandle,
};
use tracing::error;
use udev::{Device as UdevDevice, Enumerator, EventType, MonitorBuilder, MonitorSocket};

const ENODEV: i32 = 19;

pub struct LinuxKeyboardSource {
    receiver: mpsc::Receiver<Result<KeyboardEvent, io::Error>>,
    shutdown: broadcast::Sender<()>,
}

impl KeyboardSource for LinuxKeyboardSource {
    async fn new() -> io::Result<Self> {
        let monitor = AsyncFd::new(create_monitor()?)?;

        let (sender, receiver) = mpsc::channel(128);
        let (shutdown, _) = broadcast::channel(1);

        tokio::spawn(udev_loop(monitor, sender, shutdown.subscribe()));

        Ok(Self { receiver, shutdown })
    }

    async fn receive_event(&mut self) -> Result<KeyboardEvent, io::Error> {
        match self.receiver.recv().await {
            Some(result) => result,

            None => Err(io::Error::new(
                io::ErrorKind::UnexpectedEof,
                "Linux device event channel closed",
            )),
        }
    }

    fn enumerate_keyboards(&self) -> Vec<Keyboard> {
        match enumerate_keyboards() {
            Ok(keyboards) => keyboards
                .into_iter()
                .map(|(_, keyboard)| (*keyboard).clone())
                .collect(),

            Err(error) => {
                error!(
                    error = %error,
                    "Failed to enumerate Linux keyboards"
                );

                Vec::new()
            }
        }
    }
}

impl Drop for LinuxKeyboardSource {
    fn drop(&mut self) {
        let _ = self.shutdown.send(());
    }
}

async fn udev_loop(
    monitor: AsyncFd<MonitorSocket>,
    sender: mpsc::Sender<Result<KeyboardEvent, io::Error>>,
    mut shutdown: broadcast::Receiver<()>,
) {
    let mut keyboards: HashMap<PathBuf, (Arc<Keyboard>, JoinHandle<()>)> = HashMap::new();

    match enumerate_keyboards() {
        Ok(initial_keyboards) => {
            for (devnode, keyboard) in initial_keyboards {
                spawn_evdev(&mut keyboards, devnode, keyboard, &sender);
            }
        }

        Err(error) => {
            if sender.send(Err(error)).await.is_err() {
                shutdown_evdev_tasks(keyboards);
                return;
            }
        }
    }

    loop {
        tokio::select! {
            biased;

            _ = shutdown.recv() => {
                break;
            }

            result = monitor.readable() => {
                let mut guard = match result {
                    Ok(guard) => guard,

                    Err(error) => {
                        let _ = sender.send(Err(error)).await;
                        break;
                    }
                };

                for event in guard.get_inner().iter() {
                    handle_udev_event(
                        event,
                        &mut keyboards,
                        &sender,
                    )
                    .await;
                }

                guard.clear_ready();
            }
        }
    }

    shutdown_evdev_tasks(keyboards);
}

fn shutdown_evdev_tasks(keyboards: HashMap<PathBuf, (Arc<Keyboard>, JoinHandle<()>)>) {
    for (_, (_, handle)) in keyboards {
        handle.abort();
    }
}

fn create_monitor() -> io::Result<MonitorSocket> {
    MonitorBuilder::new()?.match_subsystem("input")?.listen()
}

async fn handle_udev_event(
    event: udev::Event,
    keyboards: &mut HashMap<PathBuf, (Arc<Keyboard>, JoinHandle<()>)>,
    sender: &mpsc::Sender<Result<KeyboardEvent, io::Error>>,
) {
    let dev = event.device();

    let Some(devnode) = dev.devnode().map(PathBuf::from) else {
        return;
    };

    match event.event_type() {
        EventType::Add => {
            if dev.property_value("ID_INPUT_KEYBOARD").is_none() {
                return;
            }

            let Some(keyboard) = map_to_keyboard(&dev).map(Arc::new) else {
                return;
            };

            if keyboards.contains_key(&devnode) {
                return;
            }

            if sender
                .send(Ok(KeyboardEvent::Plugged(keyboard.clone())))
                .await
                .is_err()
            {
                return;
            }

            spawn_evdev(keyboards, devnode, keyboard, sender);
        }

        EventType::Remove => {
            if let Some((keyboard, handle)) = keyboards.remove(&devnode) {
                handle.abort();

                let _ = sender.send(Ok(KeyboardEvent::Unplugged(keyboard))).await;
            }
        }

        _ => {}
    }
}

fn spawn_evdev(
    keyboards: &mut HashMap<PathBuf, (Arc<Keyboard>, JoinHandle<()>)>,
    devnode: PathBuf,
    keyboard: Arc<Keyboard>,
    sender: &mpsc::Sender<Result<KeyboardEvent, io::Error>>,
) {
    if keyboards.contains_key(&devnode) {
        return;
    }

    let sender = sender.clone();
    let keyboard_for_task = keyboard.clone();
    let devnode_for_task = devnode.clone();

    let handle = tokio::spawn(async move {
        evdev_loop(devnode_for_task, keyboard_for_task, sender).await;
    });

    keyboards.insert(devnode, (keyboard, handle));
}

async fn evdev_loop(
    devnode: PathBuf,
    keyboard: Arc<Keyboard>,
    sender: mpsc::Sender<Result<KeyboardEvent, io::Error>>,
) {
    let mut stream = match EvdevDevice::open(&devnode).and_then(|device| device.into_event_stream())
    {
        Ok(stream) => stream,

        Err(error) => {
            let _ = sender.send(Err(error)).await;
            return;
        }
    };

    let mut modifiers = Modifiers::empty();

    loop {
        let event = match stream.next_event().await {
            Ok(event) => event,

            Err(error) => {
                if error.raw_os_error() != Some(ENODEV) {
                    error!(
                        error = %error,
                        devnode = ?devnode,
                        "evdev error",
                    );
                }

                break;
            }
        };

        if event.event_type() != evdev::EventType::KEY {
            continue;
        }

        let key_code = evdev::KeyCode::new(event.code());

        let Some((state, repeat)) = evdev_to_key_state(event.value()) else {
            continue;
        };

        let modifier = modifier_for_key(key_code);

        let is_lock_key = matches!(
            key_code,
            KeyCode::KEY_CAPSLOCK | KeyCode::KEY_NUMLOCK | KeyCode::KEY_SCROLLLOCK
        );

        let event_modifiers = match state {
            keyboard_types::KeyState::Down => {
                if let Some(modifier) = modifier {
                    if is_lock_key && !repeat {
                        modifiers.toggle(modifier); // Toggle only on initial press
                    } else if !is_lock_key {
                        modifiers.insert(modifier);
                    }
                }
                modifiers
            }
            keyboard_types::KeyState::Up => {
                if !is_lock_key {
                    if let Some(modifier) = modifier {
                        modifiers.remove(modifier);
                    }
                }
                modifiers
            }
        };

        let key_event = KeyEvent {
            state,
            key: evdev_to_key(key_code),
            code: evdev_to_code(key_code),
            location: evdev_to_location(key_code),
            modifiers: event_modifiers,
            repeat,
            is_composing: false,
        };

        if sender
            .send(Ok(KeyboardEvent::KeyAction(keyboard.clone(), key_event)))
            .await
            .is_err()
        {
            break;
        }

        if state == keyboard_types::KeyState::Up {
            if let Some(modifier) = modifier {
                modifiers.remove(modifier);
            }
        }
    }
}

fn enumerate_keyboards() -> Result<Vec<(PathBuf, Arc<Keyboard>)>, io::Error> {
    let mut enumerator = Enumerator::new()?;

    enumerator.match_subsystem("input")?;

    Ok(enumerator
        .scan_devices()?
        .filter(|device| device.property_value("ID_INPUT_KEYBOARD").is_some())
        .filter_map(|device| {
            let devnode = device.devnode().map(PathBuf::from)?;

            let keyboard = Arc::new(map_to_keyboard(&device)?);

            Some((devnode, keyboard))
        })
        .collect())
}

fn map_to_keyboard(udev_dev: &UdevDevice) -> Option<Keyboard> {
    let devnode = udev_dev.devnode()?;

    let evdev = match EvdevDevice::open(devnode) {
        Ok(device) => device,

        Err(error) => {
            error!(
                error = %error,
                devnode = ?devnode,
                "failed open evdev device error",
            );

            return None;
        }
    };

    let input_id = evdev.input_id();

    let name = udev_dev
        .property_value("ID_MODEL_FROM_DATABASE")
        .or_else(|| udev_dev.property_value("ID_MODEL"))
        .and_then(|value| value.to_str().map(str::to_owned))
        .or_else(|| evdev.name().map(str::to_owned));

    let serial = udev_dev
        .property_value("ID_SERIAL_SHORT")
        .and_then(|value| value.to_str())
        .filter(|value| !value.is_empty() && !value.eq_ignore_ascii_case("noserial"))
        .map(str::to_owned);

    let physical_path = udev_dev
        .property_value("ID_PATH")
        .and_then(|value| value.to_str())
        .map(str::to_owned)
        .or_else(|| udev_dev.syspath().to_str().map(str::to_owned));

    Some(Keyboard {
        keyboard_id: KeyboardID {
            name,
            vendor_id: Some(format!("{:04x}", input_id.vendor())),
            product_id: Some(format!("{:04x}", input_id.product())),
            serial,
        },

        port_id: PortID { physical_path },
    })
}