通过InjectTouchInput API模拟触屏操作

    本文通过对InjectTouchInput API的封装，实现模拟触屏操作。微软官方文档说明，在调用InjectTouchInput API之前，需要调用InitializeTouchInjection API来配置触摸注入的上下文。下面直接上代码：

class InputInjector
    {
        public static void InitTouchInjection()
        {
            if (!InitializeTouchInjection())
            {
                var errorCode = Marshal.GetLastWin32Error();
                throw new Win32Exception(errorCode);
            }
        }

        public static bool InjectTouchDown(Point position, out int win32ErrorCode)
        {
            var touchDownOperation = InputPointerOptions.InRange | InputPointerOptions.InContact | InputPointerOptions.PointerDown;
            var contact = CreatePointerTouchInfo(position, touchDownOperation);
            return InjectTouchInput(1, new[] { contact }, out win32ErrorCode);
        }

        public static bool InjectTouchMove(Point position, out int win32ErrorCode)
        {
            var touchMoveOperation = InputPointerOptions.InRange | InputPointerOptions.InContact | InputPointerOptions.Update;
            var contact = CreatePointerTouchInfo(position, touchMoveOperation);
            return InjectTouchInput(1, new[] { contact }, out win32ErrorCode);
        }

        public static bool InjectTouchUp(Point position, out int win32ErrorCode)
        {
            var touchUpOperation = InputPointerOptions.InRange | InputPointerOptions.InContact | InputPointerOptions.PointerUp;
            var contact = CreatePointerTouchInfo(position, touchUpOperation);
            return InjectTouchInput(1, new[] { contact }, out win32ErrorCode);
        }

        public static bool InjectTouchInput(uint count, IEnumerable<PointerTouchInfo> contacts, out int win32ErrorCode)
        {
            win32ErrorCode = 0;
            var isOk = InjectTouchInput(count, contacts.ToArray());
            if (!isOk)
            {
                win32ErrorCode = Marshal.GetLastWin32Error();
            }

            return isOk;
        }

        private static PointerTouchInfo CreatePointerTouchInfo(Point position, InputPointerOptions operations)
        {
            PointerTouchInfo contact = new PointerTouchInfo();
            contact.PointerInfo.PointerType = PointerInputType.Touch;
            contact.PointerInfo.PointerId = 1;
            contact.PointerInfo.PointerFlags = operations;
            contact.PointerInfo.PixelLocation.X = (int)position.X;
            contact.PointerInfo.PixelLocation.Y = (int)position.Y;
            contact.TouchFlags = TouchFlags.None;
            contact.TouchMask = TouchMaskFlags.ContactArea | TouchMaskFlags.Orientation | TouchMaskFlags.Pressure;
            //contact.Orientation = 0;
            //contact.Pressure = 512;
            contact.ContactArea.Left = (int)position.X - 5;
            contact.ContactArea.Top = (int)position.Y - 5;
            contact.ContactArea.Right = (int)position.X + 5;
            contact.ContactArea.Bottom = (int)position.Y + 5;

            return contact;
        }

        [DllImport("user32.dll", SetLastError = true)]
        private extern static bool InitializeTouchInjection(uint maxCount = 256, int dwMode = (int)TouchFeedback.Default);

        [DllImport("user32.dll", SetLastError = true)]
        private extern static bool InjectTouchInput(uint count, PointerTouchInfo[] contacts);

        enum TouchFeedback
        {
            Default = 1,
            Indirect = 2,
            None = 3
        }
    }

    enum TouchOperation
    {
        None = 0,
        TouchDown,
        TouchMove,
        TouchUp,
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct PointerTouchInfo
    {
        public InputPointerInfo PointerInfo;
        public TouchFlags TouchFlags;
        public TouchMaskFlags TouchMask;
        public InputRectangle ContactArea;
        public InputRectangle rawContactArea;
        public uint Orientation;
        public uint Pressure;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct InputRectangle
    {
        public int Left;
        public int Right;
        public int Top;
        public int Bottom;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct InputPointerInfo
    {
        public PointerInputType PointerType;
        public uint PointerId;
        public uint FrameId;
        public InputPointerOptions PointerFlags;
        public IntPtr SourceDevice;
        public IntPtr HwndTarget;
        public InputPoint PixelLocation;
        public InputPoint HimetricLocation;
        public InputPoint PixelLocationRaw;
        public InputPoint HimetricLocationRaw;
        public int TimeOffsetInMilliseconds;
        public uint HistoryCount;
        public int InputData;
        public int KeyStates;
        public ulong PerformanceCount;
        public PointerButtonChangeType ButtonChangeType;
    }

    public enum PointerInputType
    {
        Pointer = 1,
        Touch,
        Pen,
        Mouse,
        TouchPad,
    }

    [Flags]
    public enum InputPointerOptions : uint
    {
        /// <summary>
        /// No pointer modifier. Default.
        /// </summary> 
        None = 0x0u,
        /// <summary>
        /// Indicates the arrival of a new pointer.
        /// </summary>
        New = 0x1u,
        /// <summary>
        /// Indicates that the pointer continues to exist. When this flag is not set, 
        /// it indicates the pointer has left detection range.
        /// </summary>
        InRange = 0x2u,
        /// <summary>
        /// Indicates that the pointer is in contact with the digitizer surface or area.
        /// When this flag is not set, it indicates a hovering pointer.
        /// </summary>
        InContact = 0x4u,
        /// <summary>
        /// Indicates a primary action.
        /// </summary>
        FirstButton = 0x10u,
        /// <summary>
        /// Indicates a secondary action.
        /// </summary>
        SecondButton = 0x20u,
        /// <summary>
        /// Indicates that the pointer can perform actions beyond those available to non-primary pointers. 
        /// For example, when a primary pointer makes contact with a window’s surface,
        /// it might provide the window an opportunity to activate.
        /// </summary>
        Primary = 0x2000u,
        /// <summary>
        /// Indicates a suggestion from the source device about whether the pointer represents 
        /// an intended or accidental interaction, which is especially relevant for touch 
        /// pointers where an accidental interaction (such as with the palm of the hand) 
        /// can trigger input. The presence of this flag indicates that the source device 
        /// has high confidence that this input is part of an intended interaction.
        /// </summary>
        Confidence = 0x4000u,
        /// <summary>
        /// Indicates that the pointer is departing in an abnormal manner, such as when the
        /// system receives invalid input for the pointer or when a device with active pointers
        /// departs abruptly. If the application receiving the input is in a position to
        /// do so, it should treat the interaction as not completed and reverse any effects
        /// of the pointer.
        /// </summary>
        Canceled = 0x8000u,
        /// <summary>
        /// Indicates that this pointer made contact with the digitizer surface. A touch
        /// pointer has this flag set when it is in contact with the digitizer surface.
        /// </summary>
        PointerDown = 0x10000u,
        /// <summary>
        /// Indicates a simple update that does not include pointer state changes.
        /// </summary>
        Update = 0x20000u,
        /// <summary>
        /// Indicates that this pointer ended contact with the digitizer surface. A touch
        /// pointer has this flag set when it ends contact with the digitizer surface.
        /// </summary>
        PointerUp = 0x40000u,
        /// <summary>
        /// Indicates that this pointer was captured by (associated with) another element
        /// and the original element has lost capture.
        /// </summary>
        CaptureChanged = 0x200000u
    }

    /// <summary>
    /// Contains the screen coordinates of the pointer in device-independent pixel (DIP).
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct InputPoint
    {
        /// <summary>
        /// The x-coordinate of the pointer in device-independent pixel (DIP).
        /// </summary>
        public int X;
        /// <summary>
        /// The y-coordinate of the pointer in device-independent pixel (DIP).
        /// </summary>
        public int Y;
    }

    public enum PointerButtonChangeType
    {
        None,
        FirstButtonDown,
        FirstButtonUp,
        SecondButtonDown,
        SecondButtonUp,
        ThirdButtonDown,
        ThirdButtonUp,
        FourthButtonDown,
        FourthButtonUp,
        FifthButtonDown,
        FifthButtonUp,
    }

    [Flags]
    public enum TouchFlags : uint
    {
        None = 0,
    }

    [Flags]
    public enum TouchMaskFlags : uint
    {
        None = 0,
        ContactArea = 1,
        Orientation = 2,
        Pressure = 4,
    }
}

参考：

1.https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-injecttouchinput

2.UWP: https://docs.microsoft.com/zh-cn/uwp/api/windows.ui.input.preview.injection.inputinjector.uninitializetouchinjection?view=winrt-22621