keyboard_identifier 0.2.0

Async keyboard enumeration and hotplug events for Linux, Windows, and macOS
Documentation
mod device;
mod key_mapping;
mod window;
use crate::keyboard_source::{Keyboard, KeyboardEvent, KeyboardSource};
use device::DeviceEnumerator;
pub use keyboard_types::KeyboardEvent as KeyEvent;
use std::{
    io,
    sync::{
        Arc,
        atomic::{AtomicBool, Ordering},
    },
    thread::{self, JoinHandle},
};
use tokio::sync::{mpsc, oneshot};
use tracing::error;
use window::{MessageOnlyWindow, WindowHandleSlot, WindowState};

pub(crate) fn win32_error(message: &'static str) -> io::Error {
    let code = unsafe { windows::Win32::Foundation::GetLastError().0 as i32 };
    if code == 0 {
        io::Error::other(message)
    } else {
        io::Error::from_raw_os_error(code)
    }
}

pub(crate) fn windows_error(error: windows::core::Error) -> io::Error {
    io::Error::other(error)
}

static RAW_INPUT_OWNER: AtomicBool = AtomicBool::new(false);

pub(crate) struct RawInputOwner;

impl RawInputOwner {
    pub(crate) fn acquire() -> io::Result<Self> {
        if RAW_INPUT_OWNER
            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
            .is_err()
        {
            return Err(io::Error::new(
                io::ErrorKind::AlreadyExists,
                "another WindowsKeyboardSource is already active",
            ));
        }
        Ok(Self)
    }
}

impl Drop for RawInputOwner {
    fn drop(&mut self) {
        RAW_INPUT_OWNER.store(false, Ordering::Release);
    }
}

pub(crate) struct InputThread {
    hwnd: Arc<WindowHandleSlot>,
    thread: Option<JoinHandle<()>>,
}

impl InputThread {
    pub(crate) fn spawn(
        sender: mpsc::Sender<Result<KeyboardEvent, io::Error>>,
        init_sender: oneshot::Sender<io::Result<()>>,
    ) -> Self {
        let hwnd = Arc::new(WindowHandleSlot::new());
        let thread_hwnd = Arc::clone(&hwnd);
        let thread = thread::spawn(move || {
            let result = Self::initialize(sender, Arc::clone(&thread_hwnd));
            match result {
                Ok(window) => {
                    let _ = init_sender.send(Ok(()));
                    window.run_message_loop();
                }
                Err(err) => {
                    let _ = init_sender.send(Err(err));
                }
            }
            thread_hwnd.clear();
        });
        Self {
            hwnd,
            thread: Some(thread),
        }
    }

    fn initialize(
        sender: mpsc::Sender<Result<KeyboardEvent, io::Error>>,
        hwnd_slot: Arc<WindowHandleSlot>,
    ) -> io::Result<MessageOnlyWindow> {
        let instance = unsafe {
            windows::Win32::System::LibraryLoader::GetModuleHandleW(None)
                .map(windows::Win32::Foundation::HINSTANCE::from)
                .map_err(windows_error)?
        };
        let devices = DeviceEnumerator::enumerate_keyboards()?;
        let window = MessageOnlyWindow::create(instance, WindowState::new(sender, devices))
            .map_err(windows_error)?;
        hwnd_slot.store(window.hwnd());
        if let Err(err) = window.register_raw_input() {
            window.destroy();
            hwnd_slot.clear();
            return Err(err);
        }
        Ok(window)
    }
}

impl Drop for InputThread {
    fn drop(&mut self) {
        self.hwnd.close();
        if let Some(thread) = self.thread.take() {
            let _ = thread.join();
        }
    }
}

pub struct WindowsKeyboardSource {
    events: mpsc::Receiver<Result<KeyboardEvent, io::Error>>,
    _owner: RawInputOwner,
    thread: Option<InputThread>,
}

impl KeyboardSource for WindowsKeyboardSource {
    async fn new() -> io::Result<Self> {
        let owner = RawInputOwner::acquire()?;
        let (event_tx, event_rx) = mpsc::channel(128);
        let (init_tx, init_rx) = oneshot::channel::<io::Result<()>>();
        let thread = InputThread::spawn(event_tx, init_tx);

        match init_rx.await {
            Ok(Ok(())) => {}
            Ok(Err(err)) => {
                drop(thread);
                return Err(err);
            }
            Err(_) => {
                drop(thread);
                return Err(io::Error::new(
                    io::ErrorKind::BrokenPipe,
                    "Windows keyboard input thread exited during initialization",
                ));
            }
        }

        Ok(Self {
            events: event_rx,
            _owner: owner,
            thread: Some(thread),
        })
    }

    fn enumerate_keyboards(&self) -> Vec<Keyboard> {
        match DeviceEnumerator::enumerate_keyboards() {
            Ok(devices) => devices.into_iter().map(|d| d.keyboard).collect(),
            Err(err) => {
                error!(error = %err, "Failed to enumerate Windows keyboards");
                Vec::new()
            }
        }
    }

    async fn receive_event(&mut self) -> io::Result<KeyboardEvent> {
        match self.events.recv().await {
            Some(result) => result,
            None => Err(io::Error::new(
                io::ErrorKind::UnexpectedEof,
                "Windows keyboard input thread exited",
            )),
        }
    }
}

impl Drop for WindowsKeyboardSource {
    fn drop(&mut self) {
        self.thread.take();
    }
}