YukiNative 踩坑记——Windows 的消息队列

1
import * as ffi from 'ffi'
2

3
const user32 = ffi.Library('user32.dll', {
4
  SetWinEventHook: ['uint32', ['uint32', 'uint32', 'uint32', 'pointer', 'uint32', 'uint32', 'uint32']],
5
  UnhookWinEvent: ['bool', ['uint32']]
6
})
7

8
const EVENT_SYSTEM_MINIMIZESTART = 0x0016
9
const EVENT_SYSTEM_MINIMIZEEND = 0x0017
10

11
export function registerWindowMinimizeStartCallback(
12
  handle: number,
13
  callback: () => void
14
): boolean {
15
  return doRegisterEventHook(EVENT_SYSTEM_MINIMIZESTART, handle, callback)
16
}
17

18
export function registerWindowMinimizeEndCallback(
19
  handle: number,
20
  callback: () => void
21
): boolean {
22
  return doRegisterEventHook(EVENT_SYSTEM_MINIMIZEEND, handle, callback)
23
}
24

25
function doRegisterEventHook(
26
  event: number,
27
  handle: number,
28
  callback: () => void
29
): boolean {
30
  const eventProc = ffi.Callback('void',
31
    [ffi.types.ulong, ffi.types.ulong, ffi.types.int32, ffi.types.long, ffi.types.long, ffi.types.ulong, ffi.types.ulong],
32
    (hook: number, event: number, hwnd: number, obj: number, child: number, thread: number, time: number) => {
33
      callback()
34
    })
35

36
  const num = user32.SetWinEventHook(event, event, 0, eventProc, handle, 0, 0)
37
  process.on('exit', () => {
38
    if (num !== 0) {
39
      user32.UnhookWinEvent(num);
40
    }
41
    eventProc;
42
  })
43

44
  return num !== 0
45
}

1
    public static class MessageLoop {
2
      private static readonly Queue<Tuple<Events, uint, Action<int>>> Tasks =
3
        new Queue<Tuple<Events, uint, Action<int>>>();
4

5
      public static TaskCompletionSource<int> AddHook(Events @event, uint pid) {
6
        var promise = new TaskCompletionSource<int>();
7
        Tasks.Enqueue(new Tuple<Events, uint, Action<int>>(@event, pid, i => promise.TrySetResult(i)));
8
        return promise;
9
      }
10

11
      public static void Run() {
12
        while (true) {
13
          if (PeekMessage(out var msg, 0, 0, 0, 1)) {
14
            Console.WriteLine(msg);
15

16
            if (msg.Message == WmQuit)
17
              break;
18
            TranslateMessage(ref msg);
19
            DispatchMessage(ref msg);
20
          }
21
          else if (Tasks.Count > 0) {
22
            while (Tasks.Count > 0) {
23
              var task = Tasks.Dequeue();
24
              var hook = SetWinEventHook(
25
                task.Item1,
26
                task.Item1,
27
                IntPtr.Zero,
28
                WinEventCallback,
29
                task.Item2,
30
                0,
31
                0);
32
              task.Item3(hook);
33
            }
34
          }
35

36
          Thread.Sleep(0);
37
        }
38
      }
39

40
      const uint WmQuit = 0x0012;
41

42
      [StructLayout(LayoutKind.Sequential)]
43
      private struct MSG {
44
        IntPtr Hwnd;
45
        public uint Message;
46
        IntPtr WParam;
47
        IntPtr LParam;
48
        uint Time;
49
        POINT Point;
50
      }
51

52
      [StructLayout(LayoutKind.Sequential)]
53
      private struct POINT {
54
        long x;
55
        long y;
56
      }
57

58
      [DllImport("user32.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
59
      private static extern bool GetMessage(ref MSG msg, int hWnd, uint wMsgFilterMin, uint wMsgFilterMax);
60

61
      [DllImport("user32.dll")]
62
      private static extern bool PeekMessage(out MSG msg, int hWnd, uint wMsgFilterMin, uint wMsgFilterMax,
63
        uint wRemoveMsg);
64

65
      [DllImport("user32.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
66
      private static extern bool TranslateMessage(ref MSG msg);
67

68
      [DllImport("user32.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
69
      private static extern IntPtr DispatchMessage(ref MSG msg);
70

71
      [DllImport("user32.dll", SetLastError = true)]
72
      private static extern int SetWinEventHook(Events eventMin, Events eventMax, IntPtr hmodWinEventProc,
73
        WinEventProc lpfnWinEventProc, uint idProcess, uint idThread, uint dwflags);
74

75
      [DllImport("user32.dll", SetLastError = true)]
76
      private static extern int UnhookWinEvent(int hWinEventHook);
77
    }
78
  }