如何在Windows后台进程中读取USB HID条码扫描器输入并转发数据？

Hey Ivan, great question—dealing with USB HID barcode scanners in background processes on Windows can be tricky, but let’s break down your options clearly, especially since you mentioned the common background window approach you’ve researched.

Most HID barcode scanners emulate a standard keyboard, so they send keystroke messages to the active foreground window. To capture this in the background, a hidden window with a message loop is the go-to trick because it can listen for these keystroke events even when it’s not in focus.

Pros & Cons #

• Pros: Super straightforward, no need to mess with low-level HID APIs, works with almost all keyboard-emulating scanners.
• Cons: Relies on keyboard message routing (could conflict with other input if the scanner shares keystroke space), and won’t work if your scanner sends raw HID reports instead of keyboard emulation.

Quick C# Example (Hidden Listener Window) #

using System;
using System.Windows.Forms;

public class ScannerBackgroundListener : Form
{
    private const int WM_KEYDOWN = 0x0100;
    private string _currentScan = string.Empty;

    public ScannerBackgroundListener()
    {
        // Hide the window completely from the user
        this.ShowInTaskbar = false;
        this.WindowState = FormWindowState.Minimized;
        this.FormBorderStyle = FormBorderStyle.None;
        this.Size = new System.Drawing.Size(0, 0);
    }

    protected override void WndProc(ref Message m)
    {
        if (m.Msg == WM_KEYDOWN)
        {
            var pressedKey = (Keys)m.WParam;
            
            // Most scanners send an Enter key as a scan terminator—adjust if yours uses something else
            if (pressedKey == Keys.Enter)
            {
                if (!string.IsNullOrWhiteSpace(_currentScan))
                {
                    // Replace this with your network send logic (TCP/UDP client, etc.)
                    Console.WriteLine($"Captured scan: {_currentScan}");
                    _currentScan = string.Empty;
                }
            }
            else
            {
                // Handle shift/modifiers if your scanner sends uppercase/special chars
                _currentScan += pressedKey.ToString();
            }
        }
        base.WndProc(ref m);
    }

    [STAThread]
    public static void Main()
    {
        // Run the hidden window in the background
        Application.Run(new ScannerBackgroundListener());
    }
}

If you want to avoid keyboard message dependencies, you can talk directly to the HID scanner via Windows’ native HID APIs. This skips the keyboard emulation layer entirely, making it more robust for background tasks.

Pros & Cons #

• Pros: No conflict with other input, works with scanners that send raw HID reports, full control over device interaction.
• Cons: Requires knowing your scanner’s Vendor ID (VID) and Product ID (PID), plus parsing its specific HID report format (check your scanner’s manual for this), and may need admin privileges to access the device.

C++ Example (Basic HID Device Enumeration & Reading) #

#include <windows.h>
#include <setupapi.h>
#include <hidclass.h>
#include <hidsdi.h>
#include <string>

// Replace these with your scanner's VID/PID
const USHORT SCANNER_VID = 0x1234;
const USHORT SCANNER_PID = 0x5678;

HANDLE OpenScannerDevice()
{
    HDEVINFO deviceSet = SetupDiGetClassDevs(&GUID_DEVINTERFACE_HID, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
    if (deviceSet == INVALID_HANDLE_VALUE) return NULL;

    SP_DEVICE_INTERFACE_DATA interfaceData = {0};
    interfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);

    for (DWORD i = 0; SetupDiEnumDeviceInterfaces(deviceSet, NULL, &GUID_DEVINTERFACE_HID, i, &interfaceData); i++)
    {
        DWORD detailSize = 0;
        SetupDiGetDeviceInterfaceDetail(deviceSet, &interfaceData, NULL, 0, &detailSize, NULL);
        
        PSP_DEVICE_INTERFACE_DETAIL_DATA detailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(detailSize);
        detailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
        
        SP_DEVINFO_DATA devInfo = {0};
        devInfo.cbSize = sizeof(SP_DEVINFO_DATA);

        if (SetupDiGetDeviceInterfaceDetail(deviceSet, &interfaceData, detailData, detailSize, NULL, &devInfo))
        {
            HANDLE deviceHandle = CreateFile(
                detailData->DevicePath,
                GENERIC_READ,
                FILE_SHARE_READ | FILE_SHARE_WRITE,
                NULL,
                OPEN_EXISTING,
                0,
                NULL
            );

            if (deviceHandle != INVALID_HANDLE_VALUE)
            {
                HIDD_ATTRIBUTES attrs = {0};
                attrs.Size = sizeof(HIDD_ATTRIBUTES);
                
                if (HidD_GetAttributes(deviceHandle, &attrs) && attrs.VendorID == SCANNER_VID && attrs.ProductID == SCANNER_PID)
                {
                    free(detailData);
                    SetupDiDestroyDeviceInfoList(deviceSet);
                    return deviceHandle;
                }
                CloseHandle(deviceHandle);
            }
        }
        free(detailData);
    }

    SetupDiDestroyDeviceInfoList(deviceSet);
    return NULL;
}

void ReadScannerReports(HANDLE deviceHandle)
{
    BYTE reportBuffer[64]; // Adjust based on your scanner's report size
    DWORD bytesRead;

    while (ReadFile(deviceHandle, reportBuffer, sizeof(reportBuffer), &bytesRead, NULL))
    {
        // Parse the HID report into usable barcode data
        // You'll need to map the report bytes to characters using your scanner's documentation
        std::string barcode = ParseHidReport(reportBuffer, bytesRead);
        
        if (!barcode.empty())
        {
            // Send the barcode over your network here
            SendBarcodeToServer(barcode);
        }
    }
}

• Permissions: Direct HID access may require admin rights. If you want to avoid this, you can set up a registry entry to grant non-admin access to your scanner’s VID/PID.
• Network Sending: Always use asynchronous network calls (e.g., Task.Run() in C#, overlapped I/O in C++) so scanning isn’t blocked while sending data.
• Device Sharing: When opening the HID device, use FILE_SHARE_READ | FILE_SHARE_WRITE so your existing software can still access the scanner alongside the background process.

Hope this gives you a solid starting point—feel free to follow up if you need help with report parsing or network implementation specifics!

内容的提问来源于stack exchange，提问作者Ivan P.