WinCE下钩子应用（一）——WinCE 下实时捕获键盘消息

通常我们捕获键盘消息会在WindowProc函数种用一个switch来监听WM_KEYUP和WM_KEYDOWN消息，当按下键盘时程序就会收到这个消息。但是，有一个前提是当焦点是在当前窗口时，这个WM_KEYUP和WM_KEYDOWN消息才会被捕获到。如果我们需要在任何情况下使用这个应用程序捕获到键盘的动作就需要使用钩子。

Hook(钩子)是一种在消息到达目标窗口前进行截获的技术。使用钩子主要使用以下三个函数：

SetWindowsHookEx：创建钩子
CallNextHookEx：将消息传给钩子链中的下一个钩子
UnhookWindowsHookEx：释放钩子

   这些函数在windows上面使用没有问题，但是函数说明中可以看到以下文字：Windows CE: Unsupported。也就是说，wince并不支持钩子。
   是不是真的不支持呢？只能说不直接支持钩子，我们可以使用直接获取钩子函数地址，然后调用的方法，来使用钩子。

   具体过程如下：

   第一步：定义以上三个函数的指针

   

1. typedef LRESULT (WINAPI *_CallNextHookEx)(HHOOK, int, WPARAM, LPARAM);
2. typedef LRESULT (WINAPI *_UnhookWindowsHookEx)(HHOOK);
3. typedef LRESULT (CALLBACK* HOOKPROC)(int code, WPARAM wParam, LPARAM lParam);
4. typedef HHOOK   (WINAPI *_SetWindowsHookExW)(int, HOOKPROC, HINSTANCE, DWORD);
6. static _CallNextHookEx          CallNextHookEx; 
7. static _SetWindowsHookExW       SetWindowsHookEx;
8. static _UnhookWindowsHookEx     UnhookWindowsHookEx;

    第二步：创建结构体，这个结构体是这API中的定义，我们只能照搬和使用它。

1. ypedef struct {
2.     DWORD vkCode;
3.     DWORD scanCode;
4.     DWORD flags;
5.     DWORD time;
6.     ULONG_PTR dwExtraInfo;
7. } KBDLLHOOKSTRUCT, *PKBDLLHOOKSTRUCT;

  

   第三步：创建钩子回调函数，我们将在这个函数里处理捕获到的键盘动作。代码如下。

1. LRESULT __declspec(dllexport)__stdcall  CALLBACK KeyboardProc(int nCode,WPARAM wParam, 
2.                                                               LPARAM lParam)     
3. {
4.     //   char ch;     
5.         RETAILMSG(DEBUG_CODE,(L"进入KeyboardProc "));
6.         KBDLLHOOKSTRUCT *pkbhs = (KBDLLHOOKSTRUCT *) lParam;
7.     
8.         
9.         if(wParam == WM_KEYUP)
10.         {
11.             RETAILMSG(DEBUG_CODE,(L"key up/n"));
12.             switch(pkbhs->vkCode)
13.             {
14.             case 0x31:
15.                 RETAILMSG(DEBUG_CODE,(L"1 up /n"));
16.                 break;
17.             case VK_F15:
18.                 RETAILMSG(DEBUG_CODE,(L"pTT up /n"));
19.                 break;
21.             }
22.         }
23.         if(wParam == WM_KEYDOWN)
24.         {
25.             RETAILMSG(DEBUG_CODE,(L"key down/n"));
26.             switch(pkbhs->vkCode)
27.             {
28.             case 0x31:
29.                 RETAILMSG(DEBUG_CODE,(L"1 down /n"));
30.                 break;
31.             case VK_F15:
32.                 RETAILMSG(DEBUG_CODE,(L"pTT down /n"));
33.                 break;
34.             }
35.         }
36.     // LRESULT RetVal = CallNextHookEx( NULL, nCode, wParam, lParam );
37.     return CallNextHookEx(NULL,nCode,wParam,lParam);
38.  }

 

   第四步：创建一个函数ActivateKBHook在这个函数中来使用钩子，当然也可以不在这个函数中使用，创建函数只是为了使代码可读性好一些。具体代码如下：

1. HINSTANCE                       g_hHookApiDLL   = NULL; 
2. HHOOK                           g_hInstalledLLKBDhook = NULL;
3. BOOL ActivateKBHook(HINSTANCE hInstance, HOOKPROC LLKeyboardHookCallbackFunction)
4. {
5.     RETAILMSG(DEBUG_CODE,(L"进入ActivateKBHook/r/n"));
6.     //we need to manually load these standard Win32 API calls
7.     //MSDN states that these aren't supported in WinCE
8.     SetWindowsHookEx        = NULL;
9.     CallNextHookEx          = NULL;
10.     UnhookWindowsHookEx     = NULL;
11.     
12.     //now load the coredll.dll
13.     g_hHookApiDLL = LoadLibrary(_T("coredll.dll"));
14.     if(g_hHookApiDLL == NULL) 
15.     {
16.         //something is awfully wrong
17.         //the dll has to be present
18.         RETAILMSG(DEBUG_CODE,(L"载入coredll.dll失败/r/n"));
19.         return false;
20.     }
21.     else
22.     {
23.         //load the SetWindowsHookEx API call
24.         //the SetWindowsHookEx function installs an application-defined hook procedure into a hook chain. 
25.         //You would install a hook procedure to monitor the system for certain types of events.
26.         //here we use use the hook to monitor kyeboard events
27.         SetWindowsHookEx = (_SetWindowsHookExW)GetProcAddress(g_hHookApiDLL, _T("SetWindowsHookExW"));
28.         if(SetWindowsHookEx == NULL)
29.         {
30.             //this means that MS has really stopped supporting this API in WinCE
31.             RETAILMSG(DEBUG_CODE,(L"获取SetWindowsHookExW地址失败/r/n"));
32.             return false;
33.         }
34.         else
35.         {
36.             //install the KB hook
37.             //the hande needs to be saved for default processing of the events and to uninstall the hook, once we are done with it
38.             g_hInstalledLLKBDhook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardProc, hInstance, 0);
39.             if(g_hInstalledLLKBDhook == NULL)
40.             {
41.                 int re;
42.                 re=GetLastError();
43.                 RETAILMSG(DEBUG_CODE,(L"SetWindowsHookEx失败 %d /r/n",re));
44.                 return false;
45.             }
46.         }
47.         
48.         //load CallNextHookEx() API call
49.         //the CallNextHookEx function passes the hook information to the next hook procedure in the current hook chain. 
50.         //we use this call for default processing of events.
51.         CallNextHookEx = (_CallNextHookEx)GetProcAddress(g_hHookApiDLL, _T("CallNextHookEx"));
52.         if(CallNextHookEx == NULL)
53.         {
54.             RETAILMSG(DEBUG_CODE,(L"获取_CallNextHookEx地址失败/r/n"));
55.             return false;
56.         }
57.         
58.         //load UnhookWindowsHookEx() API
59.         //the UnhookWindowsHookEx function removes a hook procedure installed in a hook chain by the SetWindowsHookEx function.
60.         //we use this call to unistall the hook.
61.         UnhookWindowsHookEx = (_UnhookWindowsHookEx)GetProcAddress(g_hHookApiDLL, _T("UnhookWindowsHookEx"));
62.         if(UnhookWindowsHookEx == NULL) 
63.         {
64.             RETAILMSG(DEBUG_CODE,(L"获取_UnhookWindowsHookEx地址失败/r/n"));
65.             return false;
66.         }
67.     }
68.     
69.     //all the APIs are loaded and the application is hooked
70.     return true;
71.     
72. }

  

   几点说明：

      1、CALLBACK KeyboardProc(int nCode,WPARAM wParam, LPARAM lParam)中，wParam得到的是按下的状态，例如是按下还是抬起，因此wParam会得到WM_KEYUP和WM_KEYDOWN消息。lParam得到的是具体按键的VK值，用来表明是哪个按键被按下。

   2、这里使用的是全局钩子，如果有两个程序使用同样的方式创建钩子，那么只能有一个正常工作。这个问题将在后续的实验中说明。