如何在无定时器的低级键盘钩子中检测空格键单次按压

胳膊受伤了，正在开发一款Windows平台的单手键盘应用，按住空格键时会镜像键盘布局以实现单手输入。目前已通过定时器实现镜像功能，但效果不佳——反应迟缓，且按住空格后快速按下镜像键时会留下空格。

有没有更好的处理方案？我尝试过使用lParam中KBDLLHOOKSTRUCT结构体的标志，但无法区分单次按键与重复按键。我还试过忽略空格键按下的输入，仅在单次按压时发送输入，但未能成功，可能是因为触发了无限循环。

核心优化思路 #

• 抛弃定时器，用键盘钩子实时处理：利用WH_KEYBOARD_LL钩子的实时性，直接在回调中判断空格状态和处理按键映射，消除延迟。
• 精准区分单次敲击与长按：通过KBDLLHOOKSTRUCT的LLKHF_REPEAT标志过滤重复按键，同时调整长按阈值逻辑，确保短按空格输入正常空格，长按进入镜像模式且不插入空格。
• 避免模拟输入触发钩子循环：添加全局标记，发送模拟按键时跳过钩子处理，彻底解决无限循环问题。

修改后的完整代码 #

#include <windows.h>
#include <iostream>
#include <chrono>
#include <map>

using Clock = std::chrono::high_resolution_clock;
std::chrono::time_point<Clock> spacePressedTime;
bool spaceHeld = false;
bool isSendingInput = false; // 标记模拟输入状态，避免钩子循环
std::map<DWORD, DWORD> keyMappings;

bool SendMirroredKeyPress(UINT vkCode);
void InitializeKeyMappings();

LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
    if (nCode == HC_ACTION && !isSendingInput) {
        auto kbdStruct = *((KBDLLHOOKSTRUCT*)lParam);
        
        // 处理空格键逻辑
        if (kbdStruct.vkCode == VK_SPACE) {
            switch (wParam) {
            case WM_KEYDOWN:
                // 排除重复按键事件，只处理第一次按下
                if (!(kbdStruct.flags & LLKHF_REPEAT) && !spaceHeld) {
                    spacePressedTime = Clock::now();
                    spaceHeld = true;
                }
                return 1; // 阻止原始空格输入
            case WM_KEYUP:
                if (spaceHeld) {
                    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(Clock::now() - spacePressedTime).count();
                    spaceHeld = false;
                    
                    // 短按阈值200ms，发送正常空格
                    if (elapsed < 200) {
                        isSendingInput = true;
                        INPUT input[2] = {};
                        input[0].type = INPUT_KEYBOARD;
                        input[0].ki.wVk = VK_SPACE;
                        input[1].type = INPUT_KEYBOARD;
                        input[1].ki.wVk = VK_SPACE;
                        input[1].ki.dwFlags = KEYEVENTF_KEYUP;
                        SendInput(2, input, sizeof(INPUT));
                        isSendingInput = false;
                        std::cout << "正常输入空格\n";
                    } else {
                        std::cout << "退出镜像模式\n";
                    }
                }
                return 1; // 阻止原始事件
            }
        } else {
            // 镜像模式下处理其他按键
            if (spaceHeld && (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN)) {
                // 只处理单次按键，过滤重复事件
                if (!(kbdStruct.flags & LLKHF_REPEAT)) {
                    isSendingInput = true;
                    bool handled = SendMirroredKeyPress(kbdStruct.vkCode);
                    isSendingInput = false;
                    if (handled) {
                        return 1; // 阻止原始按键输入
                    }
                }
            }
        }
    }
    return CallNextHookEx(NULL, nCode, wParam, lParam);
}

bool SendMirroredKeyPress(UINT vkCode) {
    auto it = keyMappings.find(vkCode);
    if (it != keyMappings.end()) {
        // 发送完整的按下+释放事件，避免按键卡住
        INPUT input[2] = {};
        input[0].type = INPUT_KEYBOARD;
        input[0].ki.wVk = it->second;
        input[1].type = INPUT_KEYBOARD;
        input[1].ki.wVk = it->second;
        input[1].ki.dwFlags = KEYEVENTF_KEYUP;
        
        SendInput(2, input, sizeof(INPUT));
        std::cout << "映射按键: 0x" << std::hex << vkCode << " -> 0x" << it->second << "\n";
        return true;
    }
    return false;
}

static void InitializeKeyMappings() {
    // 示例镜像映射，可根据实际需求扩展
    keyMappings[0x4E] = 0x42; // N -> B
    keyMappings[0x4D] = 0x4E; // M -> N
    keyMappings[0x4B] = 0x4D; // K -> M
    keyMappings[0x4C] = 0x4B; // L -> K
    keyMappings[0x58] = 0x5A; // X -> Z
}

int main() {
    InitializeKeyMappings();

    // 修复钩子初始化，关联当前进程模块
    HHOOK hhkLowLevelKybd = SetWindowsHookEx(WH_KEYBOARD_LL, LowLevelKeyboardProc, GetModuleHandle(NULL), 0);
    if (!hhkLowLevelKybd) {
        std::cout << "钩子设置失败，错误码: " << GetLastError() << "\n";
        return 1;
    }
    
    std::cout << "钩子已设置。长按空格进入镜像模式，短按空格输入正常空格。\n";

    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    UnhookWindowsHookEx(hhkLowLevelKybd);
    return 0;
}

关键优化点说明 #

1. isSendingInput标记：发送模拟按键时跳过钩子回调，彻底避免SendInput触发钩子导致的无限循环。
2. LLKHF_REPEAT过滤：处理WM_KEYDOWN时排除系统发送的重复按键事件，确保只处理一次按键按下动作，避免重复映射或误判长按状态。
3. 完整按键模拟：补充按键释放事件，确保目标按键状态正常，不会出现按键卡住的情况。
4. 钩子初始化修复：将SetWindowsHookEx的模块句柄改为GetModuleHandle(NULL)，确保钩子正确关联到当前进程，避免潜在的钩子失效问题。

内容的提问来源于stack exchange，提问作者Kei