feat: Enhance keyboard event handling to support modifier key changes in KeyboardEventHandler

Author: lijy91

src/keyboard_monitor.cpp

@@ -4,9 +4,11 @@ namespace nativeapi {
 
 KeyboardEventHandler::KeyboardEventHandler(
     std::function<void(int)> onKeyPressedCallback,
-    std::function<void(int)> onKeyReleasedCallback)
+    std::function<void(int)> onKeyReleasedCallback,
+    std::function<void(uint32_t)> onModifierKeysChangedCallback)
     : onKeyPressedCallback_(onKeyPressedCallback),
-      onKeyReleasedCallback_(onKeyReleasedCallback) {}
+      onKeyReleasedCallback_(onKeyReleasedCallback),
+      onModifierKeysChangedCallback_(onModifierKeysChangedCallback) {}
 
 void KeyboardEventHandler::OnKeyPressed(int keycode) {
   if (onKeyPressedCallback_) {
@@ -20,6 +22,12 @@ void KeyboardEventHandler::OnKeyReleased(int keycode) {
   }
 }
 
+void KeyboardEventHandler::OnModifierKeysChanged(uint32_t modifier_keys) {
+  if (onModifierKeysChangedCallback_) {
+    onModifierKeysChangedCallback_(modifier_keys);
+  }
+}
+
 void KeyboardMonitor::SetEventHandler(KeyboardEventHandler* event_handler) {
   event_handler_ = event_handler;
 }

src/keyboard_monitor.h

@@ -6,22 +6,40 @@
 
 namespace nativeapi {
 
+enum class ModifierKey : uint32_t {
+  None = 0,
+  Shift = 1 << 0,
+  Ctrl = 1 << 1,
+  Alt = 1 << 2,
+  Meta = 1 << 3,  // Windows key or Cmd key
+  Fn = 1 << 4,
+  CapsLock = 1 << 5,
+  NumLock = 1 << 6,
+  ScrollLock = 1 << 7
+};
+
 // KeyboardEventHandler uses callbacks to handle keyboard events.
 class KeyboardEventHandler {
  public:
   // Constructor that takes callbacks for keyboard events
-  KeyboardEventHandler(std::function<void(int)> onKeyPressedCallback,
-                       std::function<void(int)> onKeyReleasedCallback);
+  KeyboardEventHandler(
+      std::function<void(int)> onKeyPressedCallback,
+      std::function<void(int)> onKeyReleasedCallback,
+      std::function<void(uint32_t)> onModifierKeysChangedCallback);
 
   // Handle key pressed event
   void OnKeyPressed(int keycode);
 
   // Handle key released event
   void OnKeyReleased(int keycode);
 
+  // Handle modifier keys changed event
+  void OnModifierKeysChanged(uint32_t modifier_keys);
+
  private:
   std::function<void(int)> onKeyPressedCallback_;
   std::function<void(int)> onKeyReleasedCallback_;
+  std::function<void(uint32_t)> onModifierKeysChangedCallback_;
 };
 
 class KeyboardMonitor {

src/keyboard_monitor_macos.mm

@@ -45,8 +45,32 @@ static CGEventRef keyboardEventCallback(CGEventTapProxy proxy,
     eventHandler->OnKeyPressed(keyCode);
   } else if (type == kCGEventKeyUp) {
     eventHandler->OnKeyReleased(keyCode);
+  } else if (type == kCGEventFlagsChanged) {
+    CGEventFlags flags = CGEventGetFlags(event);
+    uint32_t modifier_keys = static_cast<uint32_t>(ModifierKey::None);
+    if (flags & kCGEventFlagMaskShift) {
+      modifier_keys |= static_cast<uint32_t>(ModifierKey::Shift);
+    }
+    if (flags & kCGEventFlagMaskControl) {
+      modifier_keys |= static_cast<uint32_t>(ModifierKey::Ctrl);
+    }
+    if (flags & kCGEventFlagMaskAlternate) {
+      modifier_keys |= static_cast<uint32_t>(ModifierKey::Alt);
+    }
+    if (flags & kCGEventFlagMaskCommand) {
+      modifier_keys |= static_cast<uint32_t>(ModifierKey::Meta);
+    }
+    if (flags & kCGEventFlagMaskSecondaryFn) {
+      modifier_keys |= static_cast<uint32_t>(ModifierKey::Fn);
+    }
+    if (flags & kCGEventFlagMaskAlphaShift) {
+      modifier_keys |= static_cast<uint32_t>(ModifierKey::CapsLock);
+    }
+    if (flags & kCGEventFlagMaskNumericPad) {
+      modifier_keys |= static_cast<uint32_t>(ModifierKey::NumLock);
+    }
+    eventHandler->OnModifierKeysChanged(modifier_keys);
   }
-
   return event;
 }
 
@@ -55,13 +79,16 @@ static CGEventRef keyboardEventCallback(CGEventTapProxy proxy,
     return;  // Already started
   }
 
+  // Create event mask
+  CGEventMask eventMask =
+      (1 << kCGEventKeyDown) | (1 << kCGEventKeyUp) | (1 << kCGEventFlagsChanged);
+
   // Create event tap for keyboard events
   impl_->eventTap =
       CGEventTapCreate(kCGSessionEventTap,        // Monitor session-wide events
                        kCGHeadInsertEventTap,     // Insert at the head of the event queue
                        kCGEventTapOptionDefault,  // Default options
-                       CGEventMaskBit(kCGEventKeyDown) |
-                           CGEventMaskBit(kCGEventKeyUp),  // Monitor key down and up events
+                       eventMask,                 // Monitor key down, up, and flags changed events
                        keyboardEventCallback,
                        this);  // Pass this pointer as user data