Skip to content

Your Android phone and your Windows PC, working as one. Local-first, end-to-end encrypted, no account.

14.2 KB
Raw Blame
// SPDX-License-Identifier: GPL-3.0-or-later
//! Synthesizes mouse and keyboard input on Windows (`SendInput`) for a paired
//! phone acting as a touchpad, keyboard or presentation remote
//! (`docs/protocol/remote.md`).

use std::sync::Mutex;

use nectarlink_core::{ButtonAction, KeyMod, MouseButton, PowerAction, SlideAction, TouchAction};
use windows::Win32::UI::{
    Input::KeyboardAndMouse::{
        INPUT, INPUT_0, INPUT_KEYBOARD, INPUT_MOUSE, KEYBD_EVENT_FLAGS, KEYBDINPUT, KEYEVENTF_EXTENDEDKEY,
        KEYEVENTF_KEYUP, KEYEVENTF_UNICODE, MOUSE_EVENT_FLAGS, MOUSEEVENTF_ABSOLUTE, MOUSEEVENTF_HWHEEL,
        MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_LEFTUP, MOUSEEVENTF_MIDDLEDOWN, MOUSEEVENTF_MIDDLEUP,
        MOUSEEVENTF_MOVE, MOUSEEVENTF_RIGHTDOWN, MOUSEEVENTF_RIGHTUP, MOUSEEVENTF_WHEEL, MOUSEINPUT,
        SendInput, VIRTUAL_KEY, VK_A, VK_B, VK_BACK, VK_C, VK_CONTROL, VK_DELETE, VK_DOWN, VK_END, VK_ESCAPE,
        VK_F1, VK_F5, VK_HOME, VK_INSERT, VK_LEFT, VK_LWIN, VK_MEDIA_NEXT_TRACK, VK_MEDIA_PLAY_PAUSE,
        VK_MEDIA_PREV_TRACK, VK_MENU, VK_NEXT, VK_PRIOR, VK_RETURN, VK_RIGHT, VK_SHIFT, VK_SPACE, VK_TAB,
        VK_UP, VK_V, VK_VOLUME_DOWN, VK_VOLUME_MUTE, VK_VOLUME_UP, VK_X, VK_Y, VK_Z,
    },
    WindowsAndMessaging::WHEEL_DELTA,
};

/// Fractional remainders for sub-pixel pointer motion and sub-notch scrolling,
/// plus which mouse buttons are currently held down by remote input.
#[derive(Default)]
struct InputState {
    move_rem_x: f32,
    move_rem_y: f32,
    scroll_rem_x: f32,
    scroll_rem_y: f32,
    held_left: bool,
    held_right: bool,
    held_middle: bool,
}

static STATE: Mutex<InputState> = Mutex::new(InputState {
    move_rem_x: 0.0,
    move_rem_y: 0.0,
    scroll_rem_x: 0.0,
    scroll_rem_y: 0.0,
    held_left: false,
    held_right: false,
    held_middle: false,
});

fn send_inputs(inputs: &[INPUT]) {
    if inputs.is_empty() {
        return;
    }
    // SAFETY: `inputs` is a valid slice of `INPUT` structs.
    unsafe {
        let _ = SendInput(inputs, std::mem::size_of::<INPUT>() as i32);
    }
}

fn mouse_input(dx: i32, dy: i32, mouse_data: i32, flags: MOUSE_EVENT_FLAGS) -> INPUT {
    INPUT {
        r#type: INPUT_MOUSE,
        Anonymous: INPUT_0 {
            mi: MOUSEINPUT { dx, dy, mouseData: mouse_data as u32, dwFlags: flags, time: 0, dwExtraInfo: 0 },
        },
    }
}

fn vk_input(vk: VIRTUAL_KEY, extended: bool, up: bool) -> INPUT {
    let mut flags = KEYBD_EVENT_FLAGS(0);
    if extended {
        flags |= KEYEVENTF_EXTENDEDKEY;
    }
    if up {
        flags |= KEYEVENTF_KEYUP;
    }
    INPUT {
        r#type: INPUT_KEYBOARD,
        Anonymous: INPUT_0 { ki: KEYBDINPUT { wVk: vk, wScan: 0, dwFlags: flags, time: 0, dwExtraInfo: 0 } },
    }
}

fn unicode_input(unit: u16, up: bool) -> INPUT {
    let mut flags = KEYEVENTF_UNICODE;
    if up {
        flags |= KEYEVENTF_KEYUP;
    }
    INPUT {
        r#type: INPUT_KEYBOARD,
        Anonymous: INPUT_0 {
            ki: KEYBDINPUT { wVk: VIRTUAL_KEY(0), wScan: unit, dwFlags: flags, time: 0, dwExtraInfo: 0 },
        },
    }
}

/// Moves the mouse cursor relatively by `(dx, dy)` pixels, keeping fractions
/// for the next move. Windows applies the user's pointer speed (and "enhance
/// pointer precision") to relative motion itself.
pub fn move_relative(dx: f32, dy: f32) {
    if !dx.is_finite() || !dy.is_finite() {
        return;
    }
    let (ix, iy) = {
        let mut s = STATE.lock().unwrap_or_else(|e| e.into_inner());
        let total_x = s.move_rem_x + dx;
        let total_y = s.move_rem_y + dy;
        let ix = total_x.round() as i32;
        let iy = total_y.round() as i32;
        s.move_rem_x = total_x - (ix as f32);
        s.move_rem_y = total_y - (iy as f32);
        (ix, iy)
    };
    if ix != 0 || iy != 0 {
        send_inputs(&[mouse_input(ix, iy, 0, MOUSEEVENTF_MOVE)]);
    }
}

/// Moves the mouse cursor to normalized coordinates `(x, y)` on the primary
/// display (`0.0..=1.0`).
pub fn move_absolute(x: f32, y: f32) {
    if !x.is_finite() || !y.is_finite() {
        return;
    }
    let ax = (x.clamp(0.0, 1.0) * 65535.0).round() as i32;
    let ay = (y.clamp(0.0, 1.0) * 65535.0).round() as i32;
    send_inputs(&[mouse_input(ax, ay, 0, MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE)]);
}

/// Injects a normalized touch event (`0.0..=1.0`) from reverse PC mirroring as
/// absolute mouse movement + left button press/release.
pub fn mirror_touch(action: TouchAction, x: f32, y: f32) {
    if !x.is_finite() || !y.is_finite() {
        return;
    }
    let ax = (x.clamp(0.0, 1.0) * 65535.0).round() as i32;
    let ay = (y.clamp(0.0, 1.0) * 65535.0).round() as i32;
    let flags = match action {
        TouchAction::Down => {
            if let Ok(mut s) = STATE.lock() {
                s.held_left = true;
            }
            MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_LEFTDOWN
        }
        TouchAction::Move => MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE,
        TouchAction::Up => {
            if let Ok(mut s) = STATE.lock() {
                s.held_left = false;
            }
            MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_LEFTUP
        }
    };
    send_inputs(&[mouse_input(ax, ay, 0, flags)]);
}

/// Presses, releases or clicks a mouse button.
pub fn mouse_button(button: MouseButton, action: ButtonAction) {
    let (down_flag, up_flag) = match button {
        MouseButton::Left => (MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_LEFTUP),
        MouseButton::Right => (MOUSEEVENTF_RIGHTDOWN, MOUSEEVENTF_RIGHTUP),
        MouseButton::Middle => (MOUSEEVENTF_MIDDLEDOWN, MOUSEEVENTF_MIDDLEUP),
    };
    {
        let mut s = STATE.lock().unwrap_or_else(|e| e.into_inner());
        let slot = match button {
            MouseButton::Left => &mut s.held_left,
            MouseButton::Right => &mut s.held_right,
            MouseButton::Middle => &mut s.held_middle,
        };
        *slot = matches!(action, ButtonAction::Down);
    }
    match action {
        ButtonAction::Down => send_inputs(&[mouse_input(0, 0, 0, down_flag)]),
        ButtonAction::Up => send_inputs(&[mouse_input(0, 0, 0, up_flag)]),
        ButtonAction::Click => {
            send_inputs(&[mouse_input(0, 0, 0, down_flag), mouse_input(0, 0, 0, up_flag)]);
        }
    }
}

/// Releases any mouse buttons still held down by remote input.
pub fn release_held_buttons() {
    let (left, right, middle) = {
        let mut s = STATE.lock().unwrap_or_else(|e| e.into_inner());
        let held = (s.held_left, s.held_right, s.held_middle);
        s.held_left = false;
        s.held_right = false;
        s.held_middle = false;
        s.move_rem_x = 0.0;
        s.move_rem_y = 0.0;
        s.scroll_rem_x = 0.0;
        s.scroll_rem_y = 0.0;
        held
    };
    let mut inputs = Vec::new();
    if left {
        inputs.push(mouse_input(0, 0, 0, MOUSEEVENTF_LEFTUP));
    }
    if right {
        inputs.push(mouse_input(0, 0, 0, MOUSEEVENTF_RIGHTUP));
    }
    if middle {
        inputs.push(mouse_input(0, 0, 0, MOUSEEVENTF_MIDDLEUP));
    }
    send_inputs(&inputs);
}

/// Scrolls the mouse wheel smoothly (`dy` > 0 scrolls down, `dx` > 0 scrolls right,
/// in wheel notches of `WHEEL_DELTA = 120`).
pub fn scroll(dx: f32, dy: f32) {
    if !dx.is_finite() || !dy.is_finite() {
        return;
    }
    let delta = WHEEL_DELTA as f32;
    let (wx, wy) = {
        let mut s = STATE.lock().unwrap_or_else(|e| e.into_inner());
        // Protocol: positive dy = scroll down = negative Win32 wheel delta.
        // Protocol: positive dx = scroll right = positive Win32 horizontal wheel delta.
        let total_x = s.scroll_rem_x + dx * delta;
        let total_y = s.scroll_rem_y - dy * delta;
        let wx = total_x.round() as i32;
        let wy = total_y.round() as i32;
        s.scroll_rem_x = total_x - (wx as f32);
        s.scroll_rem_y = total_y - (wy as f32);
        (wx, wy)
    };
    let mut inputs = Vec::with_capacity(2);
    if wy != 0 {
        inputs.push(mouse_input(0, 0, wy, MOUSEEVENTF_WHEEL));
    }
    if wx != 0 {
        inputs.push(mouse_input(0, 0, wx, MOUSEEVENTF_HWHEEL));
    }
    send_inputs(&inputs);
}

/// Types arbitrary Unicode text via `KEYEVENTF_UNICODE` (including surrogate
/// pairs for non-BMP characters like emoji).
pub fn type_text(text: &str) {
    let mut inputs = Vec::with_capacity(text.len() * 2);
    for ch in text.chars() {
        if ch == '\r' {
            continue;
        }
        if ch == '\n' {
            inputs.push(vk_input(VK_RETURN, false, false));
            inputs.push(vk_input(VK_RETURN, false, true));
            continue;
        }
        let mut buf = [0u16; 2];
        let units = ch.encode_utf16(&mut buf);
        for &unit in units.iter() {
            inputs.push(unicode_input(unit, false));
        }
        for &unit in units.iter().rev() {
            inputs.push(unicode_input(unit, true));
        }
    }
    send_inputs(&inputs);
}

/// Resolves a protocol key or shortcut name into `(VIRTUAL_KEY, is_extended, extra_mods)`.
fn resolve_key(key: &str) -> Option<(VIRTUAL_KEY, bool, &'static [KeyMod])> {
    const CTRL: &[KeyMod] = &[KeyMod::Ctrl];
    const WIN: &[KeyMod] = &[KeyMod::Win];
    const NONE: &[KeyMod] = &[];

    Some(match key {
        "copy" => (VK_C, false, CTRL),
        "paste" => (VK_V, false, CTRL),
        "cut" => (VK_X, false, CTRL),
        "undo" => (VK_Z, false, CTRL),
        "redo" => (VK_Y, false, CTRL),
        "select_all" => (VK_A, false, CTRL),
        "task_view" => (VK_TAB, false, WIN),
        "enter" => (VK_RETURN, false, NONE),
        "backspace" => (VK_BACK, false, NONE),
        "tab" => (VK_TAB, false, NONE),
        "escape" => (VK_ESCAPE, false, NONE),
        "space" => (VK_SPACE, false, NONE),
        "delete" => (VK_DELETE, true, NONE),
        "insert" => (VK_INSERT, true, NONE),
        "up" => (VK_UP, true, NONE),
        "down" => (VK_DOWN, true, NONE),
        "left" => (VK_LEFT, true, NONE),
        "right" => (VK_RIGHT, true, NONE),
        "home" => (VK_HOME, true, NONE),
        "end" => (VK_END, true, NONE),
        "page_up" => (VK_PRIOR, true, NONE),
        "page_down" => (VK_NEXT, true, NONE),
        "f1" => (VK_F1, false, NONE),
        "f2" => (VIRTUAL_KEY(VK_F1.0 + 1), false, NONE),
        "f3" => (VIRTUAL_KEY(VK_F1.0 + 2), false, NONE),
        "f4" => (VIRTUAL_KEY(VK_F1.0 + 3), false, NONE),
        "f5" => (VK_F5, false, NONE),
        "f6" => (VIRTUAL_KEY(VK_F1.0 + 5), false, NONE),
        "f7" => (VIRTUAL_KEY(VK_F1.0 + 6), false, NONE),
        "f8" => (VIRTUAL_KEY(VK_F1.0 + 7), false, NONE),
        "f9" => (VIRTUAL_KEY(VK_F1.0 + 8), false, NONE),
        "f10" => (VIRTUAL_KEY(VK_F1.0 + 9), false, NONE),
        "f11" => (VIRTUAL_KEY(VK_F1.0 + 10), false, NONE),
        "f12" => (VIRTUAL_KEY(VK_F1.0 + 11), false, NONE),
        "volume_up" => (VK_VOLUME_UP, true, NONE),
        "volume_down" => (VK_VOLUME_DOWN, true, NONE),
        "volume_mute" => (VK_VOLUME_MUTE, true, NONE),
        "play_pause" => (VK_MEDIA_PLAY_PAUSE, true, NONE),
        "next_track" => (VK_MEDIA_NEXT_TRACK, true, NONE),
        "prev_track" => (VK_MEDIA_PREV_TRACK, true, NONE),
        s if s.len() == 1 => {
            let b = s.as_bytes()[0];
            if b.is_ascii_lowercase() {
                (VIRTUAL_KEY(u16::from(b - b'a' + b'A')), false, NONE)
            } else if b.is_ascii_digit() {
                (VIRTUAL_KEY(u16::from(b)), false, NONE)
            } else {
                return None;
            }
        }
        _ => return None,
    })
}

fn mod_vk(m: KeyMod) -> (VIRTUAL_KEY, bool) {
    match m {
        KeyMod::Ctrl => (VK_CONTROL, false),
        KeyMod::Alt => (VK_MENU, false),
        KeyMod::Shift => (VK_SHIFT, false),
        KeyMod::Win => (VK_LWIN, true),
    }
}

/// Presses a named key or shortcut with optional modifiers.
pub fn press_key(key: &str, mods: &[KeyMod]) {
    if key == "lock" {
        let _ = crate::links::power(PowerAction::Lock);
        return;
    }
    let Some((vk, extended, preset_mods)) = resolve_key(key) else {
        return;
    };
    let mut all_mods: Vec<KeyMod> = Vec::with_capacity(4);
    for &m in preset_mods.iter().chain(mods.iter()) {
        if !all_mods.contains(&m) {
            all_mods.push(m);
        }
    }
    let mut inputs = Vec::with_capacity(all_mods.len() * 2 + 2);
    for &m in &all_mods {
        let (mvk, mext) = mod_vk(m);
        inputs.push(vk_input(mvk, mext, false));
    }
    inputs.push(vk_input(vk, extended, false));
    inputs.push(vk_input(vk, extended, true));
    for &m in all_mods.iter().rev() {
        let (mvk, mext) = mod_vk(m);
        inputs.push(vk_input(mvk, mext, true));
    }
    send_inputs(&inputs);
}

/// Executes a presentation slide action.
pub fn slide(action: SlideAction) {
    let (vk, extended) = match action {
        SlideAction::Next => (VK_NEXT, true),
        SlideAction::Previous => (VK_PRIOR, true),
        SlideAction::Start => (VK_F5, false),
        SlideAction::Stop => (VK_ESCAPE, false),
        SlideAction::Black => (VK_B, false),
    };
    send_inputs(&[vk_input(vk, extended, false), vk_input(vk, extended, true)]);
}

#[repr(C)]
struct LastInputInfo {
    cb_size: u32,
    dw_time: u32,
}

unsafe extern "system" {
    fn GetLastInputInfo(plii: *mut LastInputInfo) -> i32;
    fn GetTickCount() -> u32;
}

/// Returns `true` when the user has moved the mouse or pressed a key on this PC
/// within the last `max_idle_ms` milliseconds.
pub fn is_user_active_within_ms(max_idle_ms: u32) -> bool {
    let mut info = LastInputInfo { cb_size: std::mem::size_of::<LastInputInfo>() as u32, dw_time: 0 };
    let ok = unsafe { GetLastInputInfo(&mut info) };
    if ok == 0 {
        return false;
    }
    let now = unsafe { GetTickCount() };
    now.wrapping_sub(info.dw_time) <= max_idle_ms
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn resolves_named_keys_and_shortcuts() {
        assert_eq!(resolve_key("enter"), Some((VK_RETURN, false, &[][..])));
        assert_eq!(resolve_key("up"), Some((VK_UP, true, &[][..])));
        assert_eq!(resolve_key("copy"), Some((VK_C, false, &[KeyMod::Ctrl][..])));
        assert_eq!(resolve_key("paste"), Some((VK_V, false, &[KeyMod::Ctrl][..])));
        assert_eq!(resolve_key("task_view"), Some((VK_TAB, false, &[KeyMod::Win][..])));
        assert_eq!(resolve_key("a"), Some((VK_A, false, &[][..])));
        assert_eq!(resolve_key("f5"), Some((VK_F5, false, &[][..])));
        assert!(resolve_key("unknown_key").is_none());
    }
}