【XInput】手柄模拟鼠标运作之 .NET P/Invoke 和 UWP-API 方案

宝塔镇蛇妖

上一篇中，老周简单肤浅地介绍了 XInput API 的使用，并模拟了鼠标移动，左、右键单击和滚轮。本篇，咱们用 .NET 代码来完成相同的效果。
说起来也是倒霉，博文写了一半，电脑忽然断电了。不知道什么原因，可能是 UPS 电源出故障。重新开机进来一看，博文没有自动保存到草稿箱。我记得以前是有自动保存这功能的。很无奈，只好重写了。
在 dll 导入的时，容易出问题的是 INPUT 结构体，因为这货有 union 成员。不知各位还记不记得。

1. typedef struct tagINPUT {
2.     DWORD   type;
4.     union
5.     {
6.         MOUSEINPUT      mi;
7.         KEYBDINPUT      ki;
8.         HARDWAREINPUT   hi;
9.     } DUMMYUNIONNAME;
10. } INPUT, *PINPUT, FAR* LPINPUT;

复制代码

 导入代码网上一搜一大把，然而，那些代码都是恐龙时代的，在 32 位平台上是没问题的，但在 64 位平台上会无法正常用的。伙伴们可能会说，如果不自定义各种属性，运行时不是自动处理的吗？对的，如果应用在字段成员上的各种特性（如 [StructLayout(LayoutKind.Sequential)]）是会自动对齐字节的。
而 INPUT 结构体特别啊，在 type 后面的三个字段是共享内存的，所以，必须明确设置字节偏移。这个结构体在 32 位系统中是 4 字节对齐的，大小为 28；而在 64 位系统上是 8 字节对齐的，大小是 40 字节。type 字段占 4 字节，这个不变，但如果 8 字节对齐，那么，type 后面还要额外填充 4 个字节，即 mi、ki 等成员的偏移是从第 9 个字节开始的，索引是 8。如果你抄网上的代码，offset = 4，在 64 位系统上运行，是无效的。
解决这个核心问题，dll 导入就很顺利了。

1. public enum InputType : uint
2. {
3.     INPUT_MOUSE = 0,
4.     INPUT_KEYBOARD = 1,
5.     INPUT_HARDWARE = 2
6. }
8. [Flags]
9. public enum MouseEventFlags : uint
10. {
11.      MOUSEEVENTF_MOVE = 0x0001,
12.      MOUSEEVENTF_LEFTDOWN = 0x0002,
13.      MOUSEEVENTF_LEFTUP = 0x0004,
14.      MOUSEEVENTF_RIGHTDOWN = 0x0008,
15.      MOUSEEVENTF_RIGHTUP = 0x0010,
16.      MOUSEEVENTF_ABSOLUTE = 0x8000
17. }
19. [Flags]
20. public enum KeyboardEventFlags : uint
21. {
22.      KEYEVENTF_KEYDOWN = 0x0000,
23.      KEYEVENTF_EXTENDEDKEY = 0x0001,
24.      KEYEVENTF_KEYUP = 0x0002,
25.      KEYEVENTF_UNICODE = 0x0004,
26.      KEYEVENTF_SCANCODE = 0x0008
27. }

复制代码

这些在头文件中本来是宏定义的，我全定义为枚举，用起来方便几个档次。

1. [StructLayout(LayoutKind.Sequential)]
2. public struct MOUSEINPUT
3. {
4.     public int dx;
5.     public int dy;
6.     public uint MouseData;
7.     public MouseEventFlags Flags;
8.     public uint Time;
9.     public nuint ExtraInfo;
10. }
12. [StructLayout(LayoutKind.Sequential)]
13. public struct KEYBDINPUT
14. {
15.     public ushort Vk;
16.     public ushort Scan;
17.     public KeyboardEventFlags Flags;
18.     public uint Time;
19.     public nuint ExtraInfo;
20. }

复制代码

以上两个结构体无需特殊处理，就按常规就行。但下面的 INPUT 结构体就要注意了。

1. public enum InputType : uint
2. {
3.     INPUT_MOUSE = 0,
4.     INPUT_KEYBOARD = 1,
5.     INPUT_HARDWARE = 2
6. }
8. [StructLayout(LayoutKind.Explicit)]
9. public struct INPUT
10. {
11.     [FieldOffset(0)]
12.     public InputType Type;
13.     [FieldOffset(8)]
14.     public MOUSEINPUT mi;
15.     [FieldOffset(8)]
16.     public KEYBDINPUT ki;
17. }

复制代码

 StructLayoutAttribute 特性类在应用时，目标结构体的成员排列要设置为 Explicit。即由咱们手动指定各个成员的偏移字节。记住，在 64 位系统中，偏移量是 8（鉴于现在很多人都用 64 位了，所以我这里就不设置条件编译了，如果你要兼容，可以设定条件编译，32 位的偏移量是 4，64位的是 8）。
 上面那一大堆东西弄好，SendInput 函数就可以导入了。

1. [DllImport("user32.dll")]
2. public static extern uint SendInput(
3.     uint Inputs,
4.     [MarshalAs(UnmanagedType.LPArray)] INPUT[] inputs,
5.     int size);

复制代码

然后是 XInput 的函数，这个就按常规方式导入即可（熟悉的配方，熟悉的味道）。

1. [Flags]
2. public enum GamePadButtons : ushort
3. {
4.     XINPUT_GAMEPAD_DPAD_UP = 0x0001,
5.     XINPUT_GAMEPAD_DPAD_DOWN = 0x0002,
6.     XINPUT_GAMEPAD_DPAD_LEFT = 0x0004,
7.     XINPUT_GAMEPAD_DPAD_RIGHT = 0x0008,
8.     XINPUT_GAMEPAD_START = 0x0010,
9.     XINPUT_GAMEPAD_BACK = 0x0020,
10.     XINPUT_GAMEPAD_LEFT_THUMB = 0x0040,
11.     XINPUT_GAMEPAD_RIGHT_THUMB = 0x0080,
12.     XINPUT_GAMEPAD_LEFT_SHOULDER = 0x0100,
13.     XINPUT_GAMEPAD_RIGHT_SHOULDER = 0x0200,
14.     XINPUT_GAMEPAD_A = 0x1000,
15.     XINPUT_GAMEPAD_B = 0x2000,
16.     XINPUT_GAMEPAD_X = 0x4000,
17.     XINPUT_GAMEPAD_Y = 0x8000
18. }
20. [StructLayout(LayoutKind.Sequential)]
21. public struct XINPUT_GAMEPAD
22. {
23.     public GamePadButtons Buttons;
24.     public byte LeftTrigger;
25.     public byte RightTrigger;
26.     public short ThumbLX;
27.     public short ThumbLY;
28.     public short ThumbRX;
29.     public short ThumbRY;
30. }
32. [StructLayout(LayoutKind.Sequential)]
33. public struct XINPUT_STATE
34. {
35.     public uint PacketNumber;
36.     public XINPUT_GAMEPAD GamePad;
37. }

复制代码

 导入 XInputGetState 函数。

1. [DllImport("Xinput1_4.dll")]
2. public static extern uint XInputGetState(
3.     uint UserIndex,
4.     ref XINPUT_STATE State);

复制代码

 
两个 API 咱们封装到一个类中。

1. static class WinApi
2. {
3.      [DllImport("user32.dll")]
4.      public static extern uint SendInput(
5.          uint Inputs,
6.          [MarshalAs(UnmanagedType.LPArray)] INPUT[] inputs,
7.          int size);
9.      [DllImport("Xinput1_4.dll")]
10.      public static extern uint XInputGetState(
11.          uint UserIndex,
12.          ref XINPUT_STATE State);
13. }

复制代码

 
好了，API 已经导入，可以玩了。这一次老周只做了：
1、左边的摇杆负责控制鼠标移动；
2、A 键表示左键单击，B 键表示右键单击。
 下面是示例代码：

1. internal class Program
2. {
3.     // 记录序号，如果序号改变，才表示有新的数据
4.     static uint SerialID = default;
6.     static void Main(string[] args)
7.     {
8.         while (true)
9.         {
10.             Thread.Sleep(80);
11.             // 读取数据
12.             XINPUT_STATE state = default;
13.             if (WinApi.XInputGetState(0, ref state) != 0)
14.             {
15.                 // 返回值不为0，表示不成功，跳过
16.                 continue;
17.             }
18.             // 比较一下序号，看是不是新的数据
19.             if (SerialID == state.PacketNumber)
20.             {
21.                 continue;   // 数据是旧的，不处理
22.             }
23.             // 保存新的序号
24.             SerialID = state.PacketNumber;
25.             // 要发送的输入消息列表
26.             List<INPUT> inputList = new();
27.             // 计算鼠标移动量
28.             int dx = state.GamePad.ThumbLX / 1000;
29.             int dy = -state.GamePad.ThumbLY / 1000;
30.             INPUT mouseMove = new();
31.             mouseMove.Type = InputType.INPUT_MOUSE;     // 消息类型是鼠标
32.             // 设置鼠标事件标志
33.             mouseMove.mi.Flags = MouseEventFlags.MOUSEEVENTF_MOVE;
34.             // 设置移动量
35.             mouseMove.mi.dx = dx;
36.             mouseMove.mi.dy = dy;
37.             inputList.Add(mouseMove);
39.             // 判断按键
40.             if ((state.GamePad.Buttons & GamePadButtons.XINPUT_GAMEPAD_A) == GamePadButtons.XINPUT_GAMEPAD_A)
41.             {
42.                 // 左键按下消息
43.                 INPUT lbpress = new INPUT();
44.                 lbpress.Type = InputType.INPUT_MOUSE;
45.                 lbpress.mi.Flags = MouseEventFlags.MOUSEEVENTF_LEFTDOWN;
46.                 inputList.Add(lbpress);
47.                 // 左键释放
48.                 INPUT lbrelease = new INPUT();
49.                 lbrelease.Type = InputType.INPUT_MOUSE;
50.                 lbrelease.mi.Flags = MouseEventFlags.MOUSEEVENTF_LEFTUP;
51.                 inputList.Add(lbrelease);
52.             }
53.             if ((state.GamePad.Buttons & GamePadButtons.XINPUT_GAMEPAD_B) == GamePadButtons.XINPUT_GAMEPAD_B)
54.             {
55.                 // 右键按下
56.                 INPUT rbpress = new();
57.                 rbpress.Type = InputType.INPUT_MOUSE;
58.                 rbpress.mi.Flags = MouseEventFlags.MOUSEEVENTF_RIGHTDOWN;
59.                 inputList.Add(rbpress);
60.                 // 右键释放
61.                 INPUT rbrelease = new INPUT();
62.                 rbrelease.Type = InputType.INPUT_MOUSE;
63.                 rbrelease.mi.Flags = MouseEventFlags.MOUSEEVENTF_RIGHTUP;
64.                 inputList.Add(rbrelease);
65.             }
66.             // 发送消息
67.             WinApi.SendInput((uint)inputList.Count, inputList.ToArray(), Marshal.SizeOf<INPUT>());
68.         }
69.     }
70. }

复制代码

原理和上一篇中所述一样，先读取手柄数据，然后发送鼠标输入消息。
 
===================================================================================
 微软其实有提供了新的 XInput API，即给 UWP 应用程序使用的，而实际上。.NET 应用项目是可以使用 UWP API 的。毕竟，Win 10/11 是内置了运行库的。
接下来，咱们就用 UWP 方案，这个不需要 Dll 导入，用起来方便多了。
1、像平常一样，创建 .NET 项目。WPF、WinForms 或 UWP App 都无所谓，但不建议控制台，有可能读不到数据。API 文档中说要求是可以 Focus 的窗口才能接收输入；
2、打开系统 CMD 窗口，或任意终端都行。执行 systeminfo

这里能看到 build 版本号，比如老周的是 Win 11，只要记住前两位数字就行了，即 10.0.22000.0。
3、回到开发环境，打开项目文件，找到这一行。

1. <TargetFramework>net8.0</TargetFramework>

复制代码

默认是 net-，表明这个控制台应用是跨平台的，我们把它改为 Windows 特供的。

1. <TargetFramework>net8.0</TargetFramework>-Windows10.0.22000.0

复制代码

保存，关闭文件。此时，你的项目可以用 UWP API 了。
注意：要模拟鼠标动作也是要导入 Win API 的，和前文一样，只是读手柄的API不同罢了。
 
下面的例子，老周就用一个 System.Threading.Timer 来每 100 ms 读取一次数据，并显示在窗口上。窗口的结构如下：

 
主要用到的是 Windows.Gaming.Input 命名空间下的 Gamepad 类，这个类的构造函数不是公共的，不能直接实例化，而是访问它的静态属性 Gamepads。这是一个集合，如果连接了多个手柄，里面会有多个元素。
我在窗口的 Load 事件处理中，开一个 Task 来获取。

1. _ = Task.Run(async () =>
2. {
3.     while (gamePad == null)
4.     {
5.         gamePad = Gamepad.Gamepads.FirstOrDefault();
6.         await Task.Delay(1000);
7.     }
8. });

复制代码

这里假设只连接了一个手柄，所以总是获取集合中的第一个元素。为什么要这样获取呢？因为当应用程序初始化时，访问 Gamepads 集合不一定能获取到手柄（有时候会有一两秒的延时），所以咱们要这样来获取。
本示例中，老周用来读数据的 Timer 是后台线程的。尽量不要用 System.Windows.Forms 下的 Timer，因为那个定时器用的是 UI 线程。在 UI 线程上读数据要把获取数据的一段代码放在 lock 里面，否则读到的全是 0，或者读到错的值。同理，WPF 也不用 DispatcherTimer，那个定时器也是在 UI 线程上运行的。
用非 UI 线程的定时器，在读取数据时可以不进行 lock。下面是定时器使用过程：
1、在窗口类中定义 Timer 为私有字段。

1. private Gamepad? gamePad;
2. private System.Threading.Timer timer;

复制代码

gamepad 也是私有字段，待会儿用于引用 Gamepad 实例。
2、在窗口类的构造函数中，new 一个 Timer 实例，用 Change 方法禁用定时器。

1. public MyWindow()
2. {
3.      InitializeComponent();
4.      Load += OnLoad;
5.      FormClosing += OnClosing;
6.      timer = new System.Threading.Timer(OnTick);
7.      timer.Change(Timeout.Infinite, Timeout.Infinite);
8. }

复制代码

传给 Timer 构造函数的是一个回调委托，这里我绑定的是 OnTick 方法。委托类型接收一个 object 类型的参数，是用户自定义的状态数据，不使用的话可以忽略。这个 Timer 没有 Start、Stop 等方法，用 Change 方法设置超时为永不超时，这样就等于禁用定时器了。
实现 OnTick 方法，循环读取手柄数据，显示在窗口上。

1. private void OnTick(object? state)
2. {
3.     if (gamePad == null) return;
5.     // 读数
6.     GamepadReading data = gamePad.GetCurrentReading();
7.     BeginInvoke(() =>
8.     {
9.         // 左摇杆
10.         txtLeftX.Text = data.LeftThumbstickX.ToString("N4");
11.         txtLeftY.Text = data.LeftThumbstickY.ToString("N4");
13.         // 右摇杆
14.         txtRightX.Text = data.RightThumbstickX.ToString("N4");
15.         txtRightY.Text = data.RightThumbstickY.ToString("N4");
17.         // 左右扳机键
18.         txtLeftTrigger.Text = data.LeftTrigger.ToString("N2");
19.         txtRightTrigger.Text = data.RightTrigger.ToString("N2");
21.         // 检查按键
22.         ckbX.Checked = (data.Buttons & GamepadButtons.X) == GamepadButtons.X;
23.         ckbY.Checked = (data.Buttons & GamepadButtons.Y) == GamepadButtons.Y;
24.         ckbStart.Checked = (data.Buttons & GamepadButtons.Menu) == GamepadButtons.Menu;
25.     });
26. }

复制代码

 调用 GetCurrentReading 方法就可以获取实时读数了。返回的是 GamepadReading 结构体。注意它和 XInput API 的读数范围是不同的。
这个 UWP API 的读范围是 -1 到 1，如果摇杆在中间位置（默认位置），那么读数是 0。读出来的值是 -1 到 1 的小数（含-1 和 1）。
GamepadButtons 枚举定义的是手柄的按键，这个和 XInput API 差不多。

1. public enum GamepadButtons : uint
2. {
3.     // 未按下任何键
4.     None = 0u,
5.     // 菜单键，老周的手柄上是 Start 键
6.     Menu = 1u,
7.    
8.     // 这个不知道是什么
9.     View = 2u,
11.     // A、B、X、Y 按键
12.     A = 4u,
13.     B = 8u,
14.     X = 0x10u,
15.     Y = 0x20u,
17.     // 手柄上的四个方向键
18.     DPadUp = 0x40u,
19.     DPadDown = 0x80u,
20.     DPadLeft = 0x100u,
21.     DPadRight = 0x200u,
22.   
23.     // 这两个是两个肩膀按键
24.     LeftShoulder = 0x400u,
25.     RightShoulder = 0x800u,
27.     // 下面两个指的是摇杆上的按键，摇杆除了可以摇，还可以按下去。
28.     // 其实摇杆中间是一个轻触按钮
29.     LeftThumbstick = 0x1000u,
30.     RightThumbstick = 0x2000u,
32.      // 其他按键
33. }

复制代码

一起来看看效果。

 
最后，共享点猛料给大伙伴。AOSP Android 14 原生系统，树莓派 4 / 5 镜像，都是最新版的。
链接：https://pan.baidu.com/s/1q9xnLh4n7pNBl62djxDNnQ?pwd=1981
提取码：1981
下载后解压出来，直接写入内存卡就行，就跟安装官方系统一样。
把卡插到 Pi 上，第一次运行要用 HDMI 口连显示器，如果显示器不能触控，顺便连上键盘鼠标。如果你有 DSI 接的触控显示屏，需要到 设置 - 系统 - Raspberry Pi 设置中打开 7 寸触控屏选项。不一定要官方的屏幕（很贵），某宝上随便弄的只要是 DSI 排线连接的，多数屏幕是可以用的。DSI 排线要在树莓派关机断电后再连接，不要热插拔。接了触控屏就不要再接 HDMI 口了。
由于是原生系统，时间服务器是不能用的，要自动更新网络时间，需要用 adb 改为国内的 NTP 服务器，方法可以百度，很多教程。
经老周测试，不管是4代还是5代，声音、触控、WiFi、蓝牙、HDMI 音/视频、GPIO 等功能都可正常使用。但是，自己连接到 i2c 上的 MPU6050（重力加速和陀螺仪）不能用。这个是在设置 - 系统 - Raspberry pi 设置中的传感选项中开启的，反正老周买的模块无法正常使用。
另外，把 GPIO 21 接低电平，可以触发电源按钮功能，就像手机上的电源键，可以长按关机/重启、唤醒锁屏等，有键盘的可以按 F5。
 

来源:https://www.cnblogs.com/tcjiaan/p/18048489
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！