如何在Windows低级键盘钩子中仅放行Win+H，拦截其他Win组合键？

我们开发了一款自助服务终端（kiosk）应用，希望允许使用Win + H热键唤起语音输入功能，但需拦截其他Win + ...组合键及单独按下的Win键。

已通过SetWindowsHookEx(WH_KEYBOARD_LL, callback, hInstance, 0);设置钩子，按下Win + H的按键日志如下：

// w = bool, GetAsyncKeyState for left and right windows keys
// h = bool, ...for "h" key
// key = KBDLLHOOKSTRUCT* pkh->vkCode,  72 = h, 91 = left Windows key
// flags = KBDLLHOOKSTRUCT* pkh->flags
// pressed Windows, then H, then released
w=0  h=0  key= 91  flags = 1
w=-1  h=0  key= 91  flags = 1
... repeats ....
w=-1  h=0  key= 91  flags = 1
w=-1  h=0  key= 72  flags = 0 
w=-1  h=-1  key= 72  flags = 80
w=-1  h=0  key= 91  flags = 81

在回调函数中尝试多种代码组合时，出现以下问题：要么无按键响应，要么仅输入普通的h（无法唤起语音输入），要么所有Win + ...组合键都被放行。

尝试的代码1（仅输入普通h）：

if (nCode == HC_ACTION) 
{
    BOOL bWinKeyDown = (GetAsyncKeyState(VK_LWIN) >> 15) | (GetAsyncKeyState(VK_RWIN) >> 15);
    if (pkh->vkCode == 'H')
    {
        // w=-1  h=0  key= 72  flags = 0 
        // w=-1  h=-1  key= 72  flags = 80
        return CallNextHookEx(g_hHookKbdLL, nCode, wp, lp);
    }
    else if ((pkh->vkCode == VK_LWIN || pkh->vkCode == VK_RWIN))
    {
        // also just "h" if we allow through the w=-1  h=0  key= 91  flags = 1 events
        // if ((bWinKeyDown && (pkh->flags == 1))   )
        //    return CallNextHookEx(g_hHookKbdLL, nCode, wp, lp);
        //  else
        return -1;
    }
}
return CallNextHookEx(g_hHookKbdLL, nCode, wp, lp);

尝试的代码2（放行所有Win组合键）：

if (nCode == HC_ACTION)
{
    BOOL bWinKeyDown = (GetAsyncKeyState(VK_LWIN) >> 15) | (GetAsyncKeyState(VK_RWIN) >> 15);
    if (pkh->vkCode == 'H')
    {
        // w=-1  h=0  key= 72  flags = 0 
        // w=-1  h=-1  key= 72  flags = 80
        return CallNextHookEx(g_hHookKbdLL, nCode, wp, lp);
    }
    else if ((pkh->vkCode == VK_LWIN || pkh->vkCode == VK_RWIN))
    {
        if ((!bWinKeyDown && (pkh->flags == 1))) // // w=0  h=0  key= 91  flags = 1 - first event in log
            return CallNextHookEx(g_hHookKbdLL, nCode, wp, lp);
        else
            return -1;
    }
}

请问是否有方法可以拦截所有Win + ...组合键，仅放行Win + H？

要实现仅放行Win + H、拦截其他Win组合键及单独Win键的需求，核心是跟踪Win键的状态，并仅在Win键按住且按下H时放行完整的组合键事件，同时拦截其他场景下的Win键事件。

关键逻辑 #

1. 用全局变量记录左/右Win键的按下状态，避免依赖GetAsyncKeyState的瞬时状态导致判断偏差。
2. Win键按下时先放行，让系统感知按键状态；如果Win键单独释放（未触发Win+H），则拦截该释放事件，避免唤起开始菜单。
3. H键事件仅在Win键按住时放行，确保系统识别Win+H组合；单独的H键可根据终端需求选择拦截或放行。
4. Win键按住时，拦截所有其他按键事件，阻断非Win+H的组合键。

实现代码 #

#include <windows.h>

// 全局变量：记录左/右Win键的按下状态
BOOL g_bLWinDown = FALSE;
BOOL g_bRWinDown = FALSE;
HHOOK g_hHookKbdLL = NULL;

LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wp, LPARAM lp)
{
    if (nCode == HC_ACTION)
    {
        KBDLLHOOKSTRUCT* pkh = (KBDLLHOOKSTRUCT*)lp;
        BOOL isKeyDown = (wp == WM_KEYDOWN || wp == WM_SYSKEYDOWN);
        BOOL isKeyUp = (wp == WM_KEYUP || wp == WM_SYSKEYUP);

        // 处理左Win键
        if (pkh->vkCode == VK_LWIN)
        {
            if (isKeyDown)
            {
                g_bLWinDown = TRUE;
                return CallNextHookEx(g_hHookKbdLL, nCode, wp, lp);
            }
            else if (isKeyUp)
            {
                // 单独释放Win键则拦截
                if (!g_bRWinDown)
                {
                    g_bLWinDown = FALSE;
                    return -1;
                }
                g_bLWinDown = FALSE;
            }
        }
        // 处理右Win键
        else if (pkh->vkCode == VK_RWIN)
        {
            if (isKeyDown)
            {
                g_bRWinDown = TRUE;
                return CallNextHookEx(g_hHookKbdLL, nCode, wp, lp);
            }
            else if (isKeyUp)
            {
                if (!g_bLWinDown)
                {
                    g_bRWinDown = FALSE;
                    return -1;
                }
                g_bRWinDown = FALSE;
            }
        }
        // 处理H键
        else if (pkh->vkCode == 'H' || pkh->vkCode == 'h')
        {
            BOOL bWinDown = g_bLWinDown || g_bRWinDown;
            if (bWinDown)
            {
                return CallNextHookEx(g_hHookKbdLL, nCode, wp, lp);
            }
            else
            {
                // 自助终端不需要单独H键则拦截，可根据需求修改
                return -1;
            }
        }
        // 处理其他按键
        else
        {
            BOOL bWinDown = g_bLWinDown || g_bRWinDown;
            if (bWinDown && isKeyDown)
            {
                // Win键按住时拦截其他按键
                return -1;
            }
            return CallNextHookEx(g_hHookKbdLL, nCode, wp, lp);
        }
    }
    return CallNextHookEx(g_hHookKbdLL, nCode, wp, lp);
}

// 安装钩子示例
void InstallKeyboardHook()
{
    g_hHookKbdLL = SetWindowsHookEx(WH_KEYBOARD_LL, LowLevelKeyboardProc, GetModuleHandle(NULL), 0);
}

// 卸载钩子示例
void UninstallKeyboardHook()
{
    if (g_hHookKbdLL)
    {
        UnhookWindowsHookEx(g_hHookKbdLL);
        g_hHookKbdLL = NULL;
    }
}

补充说明 #

• 全局变量精准跟踪Win键状态，避免GetAsyncKeyState可能的状态延迟问题。
• Win键按下先放行是为了让系统感知按键，后续按下H时才能正确识别组合；单独释放Win键时拦截，防止唤起开始菜单。
• 其他按键在Win键按住时被拦截，确保只有Win+H能生效。

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