Tukukkk

I am making a low level keyboard hook that processes global key presses, forwarding this to the Raw Input API to check what keyboard device it came from.

I do this by using the SendMessage function in my hook that can be received by the API.

My issue is that the API cannot read the buffer of the lParam, returning false

>> Error getting the rawinput buffer

How can I adapt the hook to allow that message's lParam to be successfully decoded by the API?

(I am using the Rawkeyboard struct and I feel like this may not be the correct one to use, I also tried using some others with no luck)

Hook

//^ DLL Imports, SetWindowsHookEx, etc^



public int HookProc(int Code, int wParam, ref CWPRETSTRUCT lParam) {

    if (Code >= 0) {

        // Block

        Rawkeyboard lParamKeyboard = new Rawkeyboard();

        int result = SendMessage(Handle, 0x00FF, wParam, ref lParamKeyboard ); // Send to API

        if (result == 1) {

            return 1;

        }

    }

    // Allow

    return CallNextHookEx(Handle, Code, wParam, ref lParam);

}



[StructLayout(LayoutKind.Sequential)]

public struct Rawkeyboard {

    public ushort Makecode;                 // Scan code from the key depression

    public ushort Flags;                    // One or more of RI_KEY_MAKE, RI_KEY_BREAK, RI_KEY_E0, RI_KEY_E1

    private readonly ushort Reserved;       // Always 0    

    public ushort VKey;                     // Virtual Key Code

    public uint Message;                    // Corresponding Windows message for exmaple (WM_KEYDOWN, WM_SYASKEYDOWN etc)

    public uint ExtraInformation;           // The device-specific addition information for the event (seems to always be zero for keyboards)



    public override string ToString() {

        return string.Format("Rawkeyboardn Makecode: {0}n Makecode(hex) : {0:X}n Flags: {1}n Reserved: {2}n VKeyName: {3}n Message: {4}n ExtraInformation {5}n",

                                            Makecode, Flags, Reserved, VKey, Message, ExtraInformation);

    }

}



[StructLayout(LayoutKind.Sequential)]

public struct CWPRETSTRUCT {

    IntPtr lResult;

    IntPtr lParam;

    IntPtr wParam;

    uint message;

    IntPtr hWnd;

}

API

protected override void WndProc(ref Message message){

        switch (message.Msg){

            // Message Received!

            case 0x00FF:{

                bool result = false;

                hdevice = message.LParam;

                if (_deviceList.Count == 0) return false;

                var dwSize = 0;



                Win32.GetRawInputData(hdevice, DataCommand.RID_INPUT, IntPtr.Zero, ref dwSize, Marshal.SizeOf(typeof(Rawinputheader)));

                if (dwSize != Win32.GetRawInputData(hdevice, DataCommand.RID_INPUT, out _rawBuffer, ref dwSize, Marshal.SizeOf(typeof (Rawinputheader)))){

                    Debug.WriteLine("Error getting the rawinput buffer");

                    result = false;

                }

                else{

                    // Do checks here

                    result = true;

                }

                message.Result = (IntPtr)Convert.ToInt32(result);

            }

            break;

        }

        base.WndProc(ref message);

    }





[StructLayout(LayoutKind.Sequential)]

public struct Rawinputheader

{

    public uint dwType;                     // Type of raw input (RIM_TYPEHID 2, RIM_TYPEKEYBOARD 1, RIM_TYPEMOUSE 0)

    public uint dwSize;                     // Size in bytes of the entire input packet of data. This includes RAWINPUT plus possible extra input reports in the RAWHID variable length array. 

    public IntPtr hDevice;                  // A handle to the device generating the raw input data. 

    public IntPtr wParam;                   // RIM_INPUT 0 if input occurred while application was in the foreground else RIM_INPUTSINK 1 if it was not.



    public override string ToString()

    {

        return string.Format("RawInputHeadern dwType : {0}n dwSize : {1}n hDevice : {2}n wParam : {3}", dwType, dwSize, hDevice, wParam);

    }

}

The type of lParam for HookProc and SendMessage(WM_INPUT) are different.

For HookProc, it's CWPRETSTRUCT structure.

For SendMessage(WM_INPUT), it's RAWINPUT structure.

So you need to create a new RAWINPUT object then pass to the SendMessage method.