Delphi RawInput WinAPI:GetRawInputBuffer（）和消息处理

为什么
我正在尝试从条形码扫描仪获取输入到我的（视觉）应用程序。我希望忽略来自其他设备的输入，即使应用程序失去焦点也能获得输入。为了实现这一点，我在SO和其他地方找到了推荐的RawInputAPI

我的重点是读取输入，因为我预计每秒扫描2次，每次扫描都会触发700个事件（按键向下/按键向上）（假设扫描仪用作键盘）。文档中提到使用GetRawInputBuffer（）“用于能够产生大量原始输入的设备”。我不知道上面的内容是否符合

问题
我已经成功地收到了输入数据，但我一定是做错了什么（可能是根本的…），因为我无法找到一个好方法来获得一致的结果。原始数据似乎很快就“消失”了，而且我经常得不到任何数据。关于GetRawInputBuffer（）也存在类似的问题，但这些问题到目前为止还没有解决。。。一些注意事项：

• 我使用来自的“unRawInput.pas”
• 我使用AllocateHwnd（）创建一个窗口句柄，并将其注册为原始输入

（编辑）问题
如何/何时（正确地）在可视化应用程序中调用GetRawInputBuffer（）以获得一致的结果，例如，自上次调用以来的所有关键事件？或者：如何/为什么事件似乎在调用之间被“丢弃”，我如何防止它

代码
下面的代码是一个64位控制台应用程序，展示了我迄今为止尝试过的3种方法及其问题（如主begin-end.-块的代码注释中所述的取消注释/注释掉方法）

• 方法#1：在输入发生时执行Sleep（），然后立即读取缓冲区。我从中得到了Sleep（）的想法，它工作得非常好，因为它似乎可以获得所有的输入，但我认为这并不实用，因为我的应用程序需要保持响应
• 方法#2：使用GetMessage（）-通常，这不会产生任何数据，除非您非常快速地键入（例如，mash键），即使如此，它也可能占输入的50%，最多
• 方法3：使用peek message（）和PM#u NOREMOVE-这似乎可以非常一致地获得输入，但会使线程最大化

程序读取缓冲区；
{$APPTYPE控制台}
{$R*.res}
使用
WinAPI.Windows，
WinAPI.Messages，
系统,班级,，
System.SysUtils，
URawInput输入“..\URawInput.pas”；//发件人：https://github.com/lhengen/RawInput
类型
TGetInput=class
严格保密
fRawInputStructureSize:UINT；
fRawInputHeaderSize:UINT；
fRawInputBufferSize：基数；
fRawInputDevice:RAWINPUTDEVICE；
fRawInputBuffer:PravinPut；
程序RawInputWndProc（var-aMsg:TMessage）；
公众的
FrawinPutHND:HWND；
函数ReadInputBuffer（）：字符串；
构造函数Create（）；
析构函数Destroy（）；推翻
结束；
构造函数TGetInput.Create（）；
开始
继承；
fRawInputStructureSize:=SizeOf（RAWINPUT）；
fRawInputHeaderSize:=SizeOf（RAWINPUTHEADER）；
//创建缓冲区
fRawInputBufferSize:=40*16；
GetMem（fRawInputBuffer，fRawInputBufferSize）；
//为原始（键盘）输入创建句柄和寄存器
fRawInputWindowHnd:=AllocateHWnd（RawInputWndProc）；
fRawInputDevice.UsuseSagePage:=$1；
fRawInputDevice.usage:=6美元；
fRawInputDevice.dwFlags:=RIDEV_INPUTSINK；
fRawInputDevice.hwndTarget:=fRawInputWindowHnd；
如果注册了WinputDevices（@fRawInputDevice，1，SizeOf（RAWINPUTDEVICE）），则
WriteLn（'已注册设备；开始键入…'）
其他的
WriteLn（'注册设备时出错：'+GetLastError（）.ToString（））；
结束；
析构函数TGetInput.Destroy（）；
开始
如果已分配（fRawInputBuffer），则
FreeMem（fRawInputBuffer）；
DeallocateHWnd（FrawinPutHnd）；
继承；
结束；
函数TGetInput.ReadInputBuffer（）：字符串；
变量
pcbSizeT，pcbSizeT:UINT；
numberOfStructs:UINT；
pRI：PRAWINPUT；
开始
结果：=字符串。空；
PCB尺寸：=0；
pcbSizeT:=0；
numberOfStructs:=GetRawInputBuffer（零、pcbSize、fRawInputHeaderSize）；
如果（numberOfStructs=0），则
开始
//docs.microsoft.com对“nil”调用说：“以字节为单位的所需最小缓冲区以*pcbSize为单位返回”
//虽然可能是多余的，但我想检查一下也无妨：
如果（fRawInputBufferSize0）和（numberOfStructs<900000）），则
开始
{$POINTERMATH ON}
pRI:=fRawInputBuffer；
对于变量i:=0到（numberOfStructs-1）do
开始
如果（pRI.keyboard.Flags=RI\u KEY\u MAKE），则
结果：=Result+pRI.keyboard.VKey.ToHexString（）+#32；
pRI:=NEXTRAWINPUTBLOCK（pRI）；
结束；
{$POINTERMATH OFF}
//DefRawInputProc（）；//什么都不做？http://blog.airesoft.co.uk/2014/04/defrawinputproc-rastinating-away/
结束
其他的
打破
直到错误；
结束
结束；
程序TGetInput.RawInputWndProc（var-aMsg:TMessage）；
开始
//注释掉Sleep（）方法的案例块；保留最后一行DefWindowProc（）
//为GetMessage（）/PeekMessage（）-方法保留案例块；注释掉最后一行DefWindowProc（）
//案例aMsg.Msg
//WM_输入：
//开始
//写入（ReadInputBuffer（），“-”）；
//aMsg.结果：=0；
//结束
//否则
//aMsg.Result:=DefWindowProc（fRawInputWindowHnd，aMsg.Msg，aMsg.WParam，aMsg.LParam）；
//结束；
//注释掉GetMessage（）/PeekMessage（）-方法
aMsg.Result:=deffwindowp
program readrawbuffer;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  WinAPI.Windows,
  WinAPI.Messages,
  System.Classes,
  System.SysUtils,
  URawInput in '..\URawInput.pas';       // from: https://github.com/lhengen/RawInput

type
  TGetInput = class
  strict private
    fRawInputStructureSize: UINT;
    fRawInputHeaderSize: UINT;
    fRawInputBufferSize: Cardinal;
    fRawInputDevice: RAWINPUTDEVICE;
    fRawInputBuffer: PRAWINPUT;
    procedure RawInputWndProc(var aMsg: TMessage);
  public
    fRawInputWindowHnd: HWND;
    function ReadInputBuffer(): String;
    constructor Create();
    destructor Destroy(); override;
  end;

  constructor TGetInput.Create();
  begin
    inherited;
    fRawInputStructureSize := SizeOf(RAWINPUT);
    fRawInputHeaderSize := SizeOf(RAWINPUTHEADER);
    // create buffer
    fRawInputBufferSize := 40 * 16;
    GetMem(fRawInputBuffer, fRawInputBufferSize);
    // create handle and register for raw (keyboard) input
    fRawInputWindowHnd := AllocateHWnd(RawInputWndProc);
    fRawInputDevice.usUsagePage := $1;
    fRawInputDevice.usUsage := $6;
    fRawInputDevice.dwFlags := RIDEV_INPUTSINK;
    fRawInputDevice.hwndTarget := fRawInputWindowHnd;
    if RegisterRawInputDevices(@fRawInputDevice, 1, SizeOf(RAWINPUTDEVICE)) then
      WriteLn('device(s) registered; start typing...')
    else
      WriteLn('error registering device(s): ' + GetLastError().ToString());
  end;

  destructor TGetInput.Destroy();
  begin
    if Assigned(fRawInputBuffer) then
      FreeMem(fRawInputBuffer);

    DeallocateHWnd(fRawInputWindowHnd);
    inherited;
  end;

  function TGetInput.ReadInputBuffer(): String;
  var
    pcbSize, pcbSizeT: UINT;
    numberOfStructs: UINT;
    pRI: PRAWINPUT;

  begin
    Result := String.Empty;
    pcbSize := 0;
    pcbSizeT := 0;

    numberOfStructs := GetRawInputBuffer(nil, pcbSize, fRawInputHeaderSize);
    if (numberOfStructs = 0) then
    begin
      // docs.microsoft.com says for 'nil'-call: "minimum required buffer, in bytes, is returned in *pcbSize"
      // though probably redundant, I guess it can't hurt to check:
      if (fRawInputBufferSize < pcbSize) then
      begin
        fRawInputBufferSize := pcbSize * 16;
        ReallocMem(fRawInputBuffer, fRawInputBufferSize);
      end;

      repeat
        pcbSizeT := fRawInputBufferSize;
        numberOfStructs := GetRawInputBuffer(fRawInputBuffer, pcbSizeT, fRawInputHeaderSize);
        if ((numberOfStructs > 0) and (numberOfStructs < 900000)) then
        begin
          {$POINTERMATH ON}
          pRI := fRawInputBuffer;

          for var i := 0 to (numberOfStructs - 1) do
          begin
            if (pRI.keyboard.Flags = RI_KEY_MAKE) then
              Result := Result + pRI.keyboard.VKey.ToHexString() + #32;

            pRI := NEXTRAWINPUTBLOCK(pRI);
          end;
          {$POINTERMATH OFF}
          // DefRawInputProc();   // doesn't do anything? http://blog.airesoft.co.uk/2014/04/defrawinputproc-rastinating-away/
        end
        else
          Break;
      until False;

    end
  end;

  procedure TGetInput.RawInputWndProc(var aMsg: TMessage);
  begin
    // comment-out case block for Sleep() approach; leave last DefWindowProc() line
    // leave case block for GetMessage() / PeekMessage() -approaches; comment-out last DefWindowProc() line
//    case aMsg.Msg of
//      WM_INPUT:
//        begin
//          Write(ReadInputBuffer(), '-');
//          aMsg.Result := 0;
//        end
//    else
//      aMsg.Result := DefWindowProc(fRawInputWindowHnd, aMsg.Msg, aMsg.WParam, aMsg.LParam);
//    end;

    // comment-out for GetMessage() / PeekMessage() -approaches
    aMsg.Result := DefWindowProc(fRawInputWindowHnd, aMsg.Msg, aMsg.WParam, aMsg.LParam);
  end;


var
  getInput: TGetInput;
  lpMsg: tagMSG;

begin
  getInput := TGetInput.Create();


////////////////////////////////////////////////////////////////////////////////
// approach #1: Sleep()
// >> comment-out other aproaches; comment-out case block in RawInputWndProc(), leave last DefWindowProc() line

  repeat
    WriteLn('sleeping, type now...');
    Sleep(3000);
    WriteLn('VKeys read: ', getInput.ReadInputBuffer());
  until False;


////////////////////////////////////////////////////////////////////////////////
// approach #2: GetMessage()
// >> comment-out other approaches; comment-out last DefWindowProc() line in RawInputWndProc(), leave case block

//  repeat
//    // docs.microsoft.com: "Use WM_INPUT here and in wMsgFilterMax to specify only the WM_INPUT messages."
//    if GetMessage(lpMsg, getInput.fRawInputWindowHnd, WM_INPUT, WM_INPUT) then
//      DispatchMessage(lpMsg);
//  until False;


////////////////////////////////////////////////////////////////////////////////
// approach #3: PeekMessage()
// >> comment-out other approaches; comment-out last DefWindowProc() line in RawInputWndProc(), leave case block

//  repeat
//    if PeekMessage(lpMsg, getInput.fRawInputWindowHnd, WM_INPUT, WM_INPUT, PM_NOREMOVE) then
//      DispatchMessage(lpMsg);
//
//    if PeekMessage(lpMsg, 0, 0, 0, PM_REMOVE) then
//      DispatchMessage(lpMsg);
//  until False;

  getInput.Free();
end.

repeat
  TThread.Sleep(10);

  while True do
  begin
    if (Not PeekMessage(lpMsg, 0, 0, WM_INPUT - 1, PM_NOYIELD or PM_REMOVE)) then System.Break;
    DefWindowProc(lpMsg.hwnd, lpMsg.message, lpMsg.wParam, lpMsg.lParam);
  end;

  while True do
  begin
    if (Not PeekMessage(lpMsg, 0, WM_INPUT + 1, High(Cardinal), PM_NOYIELD or PM_REMOVE)) then System.Break;
    DefWindowProc(lpMsg.hwnd, lpMsg.message, lpMsg.wParam, lpMsg.lParam);
  end;

  ReadRawInputBuffer();     // shown below; essentially reads out all queued-up input
until SomeCondition;

procedure ReadInputBuffer();
var
  // ...

begin
  // this returns the minimum required buffer size in ```pcbSize```
  numberOfStructs := GetRawInputBuffer(nil, pcbSize, rawInputHeaderSize);
  if (numberOfStructs = 0) then
  begin
    // read out all queued-up data
    repeat
      // ... allocate pBuffer as needed
      numberOfStructs := GetRawInputBuffer(pBuffer, pcbSize, rawInputHeaderSize);
      if ((numberOfStructs > 0) and (numberOfStructs < 900000)) then
        // do something with pBuffer / its data
        // I use a TThreadedQueue<T>; the items/data is worked off outside this thread
      else
        System.Break;
    until False;
  end
end;