feat: Add KeyboardMonitor

Author: lijy91

include/nativeapi.h

@@ -5,6 +5,7 @@
 #include "../src/display.h"
 #include "../src/display_manager.h"
 #include "../src/geometry.h"
+#include "../src/keyboard_monitor.h"
 #include "../src/menu.h"
 #include "../src/tray.h"
 #include "../src/tray_manager.h"

src/keyboard_monitor.cpp

@@ -0,0 +1,27 @@
+#include "keyboard_monitor.h"
+
+namespace nativeapi {
+
+KeyboardEventHandler::KeyboardEventHandler(
+    std::function<void(const std::string&)> onKeyPressedCallback,
+    std::function<void(const std::string&)> onKeyReleasedCallback)
+    : onKeyPressedCallback_(onKeyPressedCallback),
+      onKeyReleasedCallback_(onKeyReleasedCallback) {}
+
+void KeyboardEventHandler::OnKeyPressed(const std::string& key) {
+  if (onKeyPressedCallback_) {
+    onKeyPressedCallback_(key);
+  }
+}
+
+void KeyboardEventHandler::OnKeyReleased(const std::string& key) {
+  if (onKeyReleasedCallback_) {
+    onKeyReleasedCallback_(key);
+  }
+}
+
+void KeyboardMonitor::SetEventHandler(KeyboardEventHandler* event_handler) {
+  event_handler_ = event_handler;
+}
+
+}  // namespace nativeapi

src/keyboard_monitor.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace nativeapi {
+
+// KeyboardEventHandler uses callbacks to handle keyboard events.
+class KeyboardEventHandler {
+ public:
+  // Constructor that takes callbacks for keyboard events
+  KeyboardEventHandler(
+      std::function<void(const std::string&)> onKeyPressedCallback,
+      std::function<void(const std::string&)> onKeyReleasedCallback);
+
+  // Handle key pressed event
+  void OnKeyPressed(const std::string& key);
+
+  // Handle key released event
+  void OnKeyReleased(const std::string& key);
+
+ private:
+  std::function<void(const std::string&)> onKeyPressedCallback_;
+  std::function<void(const std::string&)> onKeyReleasedCallback_;
+};
+
+class KeyboardMonitor {
+ public:
+  KeyboardMonitor();
+  virtual ~KeyboardMonitor();
+
+  // Set the event handler for the keyboard monitor
+  void SetEventHandler(KeyboardEventHandler* event_handler);
+
+  // Start the keyboard monitor
+  void Start();
+
+  // Stop the keyboard monitor
+  void Stop();
+
+  // Check if the keyboard monitor is monitoring
+  bool IsMonitoring() const;
+
+  // Get the event handler
+  KeyboardEventHandler* GetEventHandler() const { return event_handler_; }
+
+ private:
+  class Impl;
+  std::unique_ptr<Impl> impl_;
+  KeyboardEventHandler* event_handler_;
+};
+
+}  // namespace nativeapi

src/keyboard_monitor_macos.mm

@@ -0,0 +1,119 @@
+#include <cstring>
+#include <iostream>
+#include <string>
+
+#include "keyboard_monitor.h"
+
+// Import Cocoa headers
+#import <Cocoa/Cocoa.h>
+#import <CoreGraphics/CoreGraphics.h>
+
+namespace nativeapi {
+
+class KeyboardMonitor::Impl {
+ public:
+  Impl(KeyboardMonitor* monitor) : monitor_(monitor) {}
+
+  CFMachPortRef eventTap = nullptr;
+  CFRunLoopSourceRef runLoopSource = nullptr;
+  KeyboardMonitor* monitor_;
+};
+
+KeyboardMonitor::KeyboardMonitor() : impl_(std::make_unique<Impl>(this)), event_handler_(nullptr) {}
+
+KeyboardMonitor::~KeyboardMonitor() {
+  Stop();
+}
+
+// Callback function for keyboard events
+static CGEventRef keyboardEventCallback(CGEventTapProxy proxy,
+                                        CGEventType type,
+                                        CGEventRef event,
+                                        void* refcon) {
+  auto* monitor = static_cast<KeyboardMonitor*>(refcon);
+  if (!monitor)
+    return event;
+
+  auto* eventHandler = monitor->GetEventHandler();
+  if (!eventHandler)
+    return event;
+
+  // Get the key code
+  CGKeyCode keyCode = (CGKeyCode)CGEventGetIntegerValueField(event, kCGKeyboardEventKeycode);
+
+  // Convert key code to string representation
+  UniCharCount actualStringLength = 0;
+  UniChar unicodeString[4];
+  CGEventKeyboardGetUnicodeString(event, 4, &actualStringLength, unicodeString);
+
+  if (actualStringLength > 0) {
+    std::string keyStr(actualStringLength, 0);
+    for (UniCharCount i = 0; i < actualStringLength; ++i) {
+      keyStr[i] = static_cast<char>(unicodeString[i]);
+    }
+
+    if (type == kCGEventKeyDown) {
+      eventHandler->OnKeyPressed(keyStr);
+    } else if (type == kCGEventKeyUp) {
+      eventHandler->OnKeyReleased(keyStr);
+    }
+  }
+
+  return event;
+}
+
+void KeyboardMonitor::Start() {
+  if (impl_->eventTap != nullptr) {
+    return;  // Already started
+  }
+
+  // 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
+                       keyboardEventCallback,
+                       this);  // Pass this pointer as user data
+
+  if (impl_->eventTap == nullptr) {
+    std::cerr << "Failed to create event tap" << std::endl;
+    return;
+  }
+
+  // Create a run loop source
+  impl_->runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, impl_->eventTap, 0);
+
+  // Add to the current run loop
+  CFRunLoopAddSource(CFRunLoopGetCurrent(), impl_->runLoopSource, kCFRunLoopCommonModes);
+
+  // Enable the event tap
+  CGEventTapEnable(impl_->eventTap, true);
+}
+
+void KeyboardMonitor::Stop() {
+  if (impl_->eventTap == nullptr) {
+    return;  // Already stopped
+  }
+
+  // Disable the event tap
+  CGEventTapEnable(impl_->eventTap, false);
+
+  // Remove from run loop
+  if (impl_->runLoopSource != nullptr) {
+    CFRunLoopRemoveSource(CFRunLoopGetCurrent(), impl_->runLoopSource, kCFRunLoopCommonModes);
+    CFRelease(impl_->runLoopSource);
+    impl_->runLoopSource = nullptr;
+  }
+
+  // Release the event tap
+  CFRelease(impl_->eventTap);
+  impl_->eventTap = nullptr;
+}
+
+bool KeyboardMonitor::IsMonitoring() const {
+  return impl_->eventTap != nullptr;
+}
+
+}  // namespace nativeapi