How to use the mouse hook in C# to record and play back the mouse events and sequences of human operations

How to use the mouse hook in C# to record and play back the mouse events and sequences of human operations
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;

public class RecordForm : Form
{
    private delegate IntPtr LowLevelMouseProc(int nCode, IntPtr wParam, IntPtr lParam);

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern IntPtr SetWindowsHookEx(int idHook, LowLevelMouseProc lpfn, IntPtr hMod, uint dwThreadId);

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool UnhookWindowsHookEx(IntPtr hhk);

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern uint SendInput(uint nInputs, INPUT[] pInputs, int cbSize);

    private const int WH_MOUSE_LL = 14;
    private LowLevelMouseProc _proc;
    private IntPtr _hookID = IntPtr.Zero;

    private List<MouseEvent> mouseEvents = new List<MouseEvent>();
    private Stopwatch stopwatch = new Stopwatch();

    public RecordForm()
    {
        _proc = HookCallback;
    }

    protected override void OnLoad(EventArgs e)
    {
        base.OnLoad(e);
        _hookID = SetHook(_proc);
    }

    protected override void OnClosed(EventArgs e)
    {
        base.OnClosed(e);
        UnhookWindowsHookEx(_hookID);
    }

    protected override void OnMouseDown(MouseEventArgs e)
    {
        base.OnMouseDown(e);
        if (e.Button == MouseButtons.Right)
        {
            stopwatch.Reset();
            mouseEvents.Clear();
            stopwatch.Start();
        }
        else if (e.Button == MouseButtons.Left)
        {
            stopwatch.Stop();
            Playback();
        }
    }

    private IntPtr SetHook(LowLevelMouseProc proc)
    {
        using (var curProcess = System.Diagnostics.Process.GetCurrentProcess())
        using (var curModule = curProcess.MainModule)
        {
            return SetWindowsHookEx(WH_MOUSE_LL, proc, Marshal.GetHINSTANCE(curModule.ModuleName), 0);
        }
    }

    private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
    {
        if (nCode >= 0 && stopwatch.IsRunning)
        {
            MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
            mouseEvents.Add(new MouseEvent(hookStruct.pt, (MouseMessages)wParam, stopwatch.ElapsedMilliseconds));
        }
        return CallNextHookEx(_hookID, nCode, wParam, lParam);
    }

    private void Playback()
    {
        long previousTime = 0;
        foreach (var mouseEvent in mouseEvents)
        {
            Thread.Sleep((int)(mouseEvent.Time - previousTime));
            previousTime = mouseEvent.Time;

            INPUT input = new INPUT();
            input.type = INPUT_MOUSE;
            input.U.mi.dx = mouseEvent.Location.X * (65536 / Screen.PrimaryScreen.Bounds.Width); // x being coord in pixels
            input.U.mi.dy = mouseEvent.Location.Y * (65536 / Screen.PrimaryScreen.Bounds.Height); // y being coord in pixels
            input.U.mi.mouseData = 0;

            switch (mouseEvent.Message)
            {
                case MouseMessages.WM_LBUTTONDOWN:
                    input.U.mi.dwFlags = MOUSEEVENTF_LEFTDOWN;
                    break;
                case MouseMessages.WM_LBUTTONUP:
                    input.U.mi.dwFlags = MOUSEEVENTF_LEFTUP;
                    break;
                case MouseMessages.WM_MOUSEMOVE:
                    input.U.mi.dwFlags = MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE;
                    break;
                case MouseMessages.WM_MOUSEWHEEL:
                    input.U.mi.dwFlags = MOUSEEVENTF_WHEEL;
                    break;
                case MouseMessages.WM_RBUTTONDOWN:
                    input.U.mi.dwFlags = MOUSEEVENTF_RIGHTDOWN;
                    break;
                case MouseMessages.WM_RBUTTONUP:
                    input.U.mi.dwFlags = MOUSEEVENTF_RIGHTUP;
                    break;
            }

            SendInput(1, new INPUT[] { input }, Marshal.SizeOf(typeof(INPUT)));
        }
    }

    private const int INPUT_MOUSE = 0;

    private const uint MOUSEEVENTF_MOVE = 0x0001;
    private const uint MOUSEEVENTF_LEFTDOWN = 0x0002;
    private const uint MOUSEEVENTF_LEFTUP = 0x0004;
    private const uint MOUSEEVENTF_RIGHTDOWN = 0x0008;
    private const uint MOUSEEVENTF_RIGHTUP = 0x0010;
    private const uint MOUSEEVENTF_ABSOLUTE = 0x8000;
    private const uint MOUSEEVENTF_WHEEL = 0x0800;

    private struct INPUT
    {
        public int type;
        public InputUnion U;
    }

    [StructLayout(LayoutKind.Explicit)]
    private struct InputUnion
    {
        [FieldOffset(0)]
        public MOUSEINPUT mi;
    }

    private struct POINT
    {
        public int x;
        public int y;
    }

    private struct MOUSEINPUT
    {
        public int dx;
        public int dy;
        public uint mouseData;
        public uint dwFlags;
        public uint time;
        public IntPtr dwExtraInfo;
    }

    private struct MSLLHOOKSTRUCT
    {
        public POINT pt;
        public uint mouseData;
        public uint flags;
        public uint time;
        public IntPtr dwExtraInfo;
    }

    private enum MouseMessages
    {
        WM_LBUTTONDOWN = 0x0201,
        WM_LBUTTONUP = 0x0202,
        WM_MOUSEMOVE = 0x0200,
        WM_MOUSEWHEEL = 0x020A,
        WM_RBUTTONDOWN = 0x0204,
        WM_RBUTTONUP = 0x0205,
        WM_LBUTTONDBLCLK = 0x0203,
        WM_RBUTTONDBLCLK = 0x0206
    }

    private class MouseEvent
    {
        public Point Location { get; }
        public MouseMessages Message { get; }
        public long Time { get; }

        public MouseEvent(Point location, MouseMessages message, long time)
        {
            Location = location;
            Message = message;
            Time = time;
        }
    }

    [STAThread]
    public static void Main()
    {
        Application.Run(new RecordForm());
    }
}
#ç1/4c ̈#