Refactor EventEmitter to use Emit instead of EmitSync

Replaces all usages of EmitSync with Emit in EventEmitter and across platform-specific event emission code for Linux, macOS, and Windows. Removes unused callback listener storage and event definition macros from EventEmitter. Also updates window procedure delegate handling to avoid holding locks during delegate execution and improves tray icon window handle acquisition on Windows.

Author: lijy91

src/foundation/event_emitter.cpp

@@ -52,10 +52,9 @@ void EventEmitter::RemoveAllListeners(std::type_index event_type) {
 void EventEmitter::RemoveAllListeners() {
   std::lock_guard<std::mutex> lock(listeners_mutex_);
   listeners_.clear();
-  callback_listeners_.clear();
 }
 
-void EventEmitter::EmitSync(const Event& event) {
+void EventEmitter::Emit(const Event& event) {
   std::type_index event_type = typeid(event);
   std::vector<EventListenerBase*> listeners_copy;
 
@@ -175,9 +174,9 @@ void EventEmitter::ProcessAsyncEvents() {
 
     // Dispatch the event if we have one
     if (event) {
-      EmitSync(*event);
+      Emit(*event);
     }
   }
 }
 
-}  // namespace nativeapi
+}  // namespace nativeapi

src/foundation/event_emitter.h

@@ -28,7 +28,7 @@ namespace nativeapi {
  * public:
  *   void DoSomething() {
  *     // Emit an event synchronously
- *     EmitSync<MyEvent>("some data");
+ *     Emit<MyEvent>("some data");
  *
  *     // Or emit asynchronously
  *     EmitAsync<MyEvent>("some data");
@@ -159,17 +159,17 @@ class EventEmitter {
    *
    * @param event The event to emit
    */
-  void EmitSync(const Event& event);
+  void Emit(const Event& event);
 
  protected:
   /**
    * Emit an event synchronously using perfect forwarding.
    * This creates the event object and emits it immediately.
    */
   template <typename EventType, typename... Args>
-  void EmitSync(Args&&... args) {
+  void Emit(Args&&... args) {
     EventType event(std::forward<Args>(args)...);
-    EmitSync(event);
+    Emit(event);
   }
 
   /**
@@ -213,9 +213,6 @@ class EventEmitter {
   mutable std::mutex listeners_mutex_;
   std::unordered_map<std::type_index, std::vector<ListenerInfo>> listeners_;
 
-  // Storage for callback listeners to manage their lifetime
-  std::vector<std::unique_ptr<EventListenerBase>> callback_listeners_;
-
   // Async event processing
   std::mutex queue_mutex_;
   std::queue<std::unique_ptr<Event>> event_queue_;
@@ -228,46 +225,4 @@ class EventEmitter {
   std::atomic<size_t> next_listener_id_;
 };
 
-/**
- * Convenience macro to define a simple event class.
- *
- * Usage:
- * DEFINE_EVENT(MyEvent) {
- *   std::string message;
- *   int code;
- *   std::string GetTypeName() const override { return "MyEvent"; }
- * };
- */
-#define DEFINE_EVENT(EventName) class EventName : public Event
-
-/**
- * Helper macro to begin defining an event with custom constructor.
- *
- * Usage:
- * DEFINE_EVENT_BEGIN(MyEvent)
- *   std::string message;
- *   int code;
- *   MyEvent(std::string msg, int c) : message(std::move(msg)), code(c) {}
- *   std::string GetTypeName() const override { return "MyEvent"; }
- * DEFINE_EVENT_END();
- */
-#define DEFINE_EVENT_BEGIN(EventName) \
-  class EventName : public Event {    \
-   public:
-
-#define DEFINE_EVENT_END() \
-  }                        \
-  ;
-
-/**
- * Simpler macro for events with basic data members.
- * Creates a constructor that initializes all members.
- * Note: You must implement GetTypeName() in the class body.
- */
-#define SIMPLE_EVENT(EventName, ...) \
-  class EventName : public Event {   \
-   public:                           \
-    __VA_ARGS__                      \
-  };
-
 }  // namespace nativeapi

src/platform/linux/keyboard_monitor_linux.cpp

@@ -162,16 +162,16 @@ void KeyboardMonitor::Impl::MonitoringLoop() {
 
           if (xi_event->evtype == XI_KeyPress) {
             KeyPressedEvent key_event(xi_event->detail);
-            monitor_->EmitSync(key_event);
+            monitor_->Emit(key_event);
 
             ModifierKeysChangedEvent modifier_event(GetModifierState());
-            monitor_->EmitSync(modifier_event);
+            monitor_->Emit(modifier_event);
           } else if (xi_event->evtype == XI_KeyRelease) {
             KeyReleasedEvent key_event(xi_event->detail);
-            monitor_->EmitSync(key_event);
+            monitor_->Emit(key_event);
 
             ModifierKeysChangedEvent modifier_event(GetModifierState());
-            monitor_->EmitSync(modifier_event);
+            monitor_->Emit(modifier_event);
           }
 
           XFreeEventData(display_, &event.xcookie);
@@ -224,4 +224,4 @@ bool KeyboardMonitor::IsMonitoring() const {
   return impl_->monitoring_;
 }
 
-}  // namespace nativeapi
+}  // namespace nativeapi

src/platform/linux/menu_linux.cpp

@@ -23,23 +23,23 @@ static void OnGtkMenuItemActivate(GtkMenuItem* /*item*/, gpointer user_data) {
   if (auto label = menu_item->GetLabel(); label.has_value()) {
     text = *label;
   }
-  menu_item->EmitSync(MenuItemClickedEvent(menu_item->id, text));
+  menu_item->Emit(MenuItemClickedEvent(menu_item->id, text));
 }
 
 static void OnGtkMenuShow(GtkWidget* /*menu*/, gpointer user_data) {
   Menu* menu_obj = static_cast<Menu*>(user_data);
   if (!menu_obj) {
     return;
   }
-  menu_obj->EmitSync(MenuOpenedEvent(menu_obj->id));
+  menu_obj->Emit(MenuOpenedEvent(menu_obj->id));
 }
 
 static void OnGtkMenuHide(GtkWidget* /*menu*/, gpointer user_data) {
   Menu* menu_obj = static_cast<Menu*>(user_data);
   if (!menu_obj) {
     return;
   }
-  menu_obj->EmitSync(MenuClosedEvent(menu_obj->id));
+  menu_obj->Emit(MenuClosedEvent(menu_obj->id));
 }
 
 static void OnGtkSubmenuShow(GtkWidget* /*submenu*/, gpointer user_data) {
@@ -48,7 +48,7 @@ static void OnGtkSubmenuShow(GtkWidget* /*submenu*/, gpointer user_data) {
     return;
   }
   // Emit submenu opened on the item
-  menu_item->EmitSync(MenuItemSubmenuOpenedEvent(menu_item->id));
+  menu_item->Emit(MenuItemSubmenuOpenedEvent(menu_item->id));
 }
 
 static void OnGtkSubmenuHide(GtkWidget* /*submenu*/, gpointer user_data) {
@@ -57,7 +57,7 @@ static void OnGtkSubmenuHide(GtkWidget* /*submenu*/, gpointer user_data) {
     return;
   }
   // Emit submenu closed on the item
-  menu_item->EmitSync(MenuItemSubmenuClosedEvent(menu_item->id));
+  menu_item->Emit(MenuItemSubmenuClosedEvent(menu_item->id));
 }
 
 // Private implementation class for MenuItem

src/platform/linux/window_manager_linux.cpp

@@ -65,7 +65,7 @@ void WindowManager::CleanupEventMonitoring() {
 }
 
 void WindowManager::DispatchWindowEvent(const Event& event) {
-  EmitSync(event);
+  Emit(event);
 }
 
 std::shared_ptr<Window> WindowManager::Get(WindowID id) {
@@ -255,4 +255,4 @@ bool WindowManager::Destroy(WindowID id) {
   return false;
 }
 
-}  // namespace nativeapi
+}  // namespace nativeapi

src/platform/macos/display_manager_macos.mm

@@ -37,7 +37,7 @@ static Display CreateDisplayFromNSScreen(NSScreen* screen, bool isPrimary) {
                   old_ids.insert(d.GetId());
                 for (const auto& d : new_displays) {
                   if (old_ids.find(d.GetId()) == old_ids.end()) {
-                    EmitSync<DisplayAddedEvent>(d);
+                    Emit<DisplayAddedEvent>(d);
                   }
                 }
 
@@ -47,7 +47,7 @@ static Display CreateDisplayFromNSScreen(NSScreen* screen, bool isPrimary) {
                   new_ids.insert(d.GetId());
                 for (const auto& d : old_displays) {
                   if (new_ids.find(d.GetId()) == new_ids.end()) {
-                    EmitSync<DisplayRemovedEvent>(d);
+                    Emit<DisplayRemovedEvent>(d);
                   }
                 }
 

src/platform/macos/keyboard_monitor_macos.mm

@@ -39,10 +39,10 @@ static CGEventRef keyboardEventCallback(CGEventTapProxy proxy,
 
   if (type == kCGEventKeyDown) {
     KeyPressedEvent key_event(keyCode);
-    event_emitter->EmitSync(key_event);
+    event_emitter->Emit(key_event);
   } else if (type == kCGEventKeyUp) {
     KeyReleasedEvent key_event(keyCode);
-    event_emitter->EmitSync(key_event);
+    event_emitter->Emit(key_event);
   } else if (type == kCGEventFlagsChanged) {
     CGEventFlags flags = CGEventGetFlags(event);
     uint32_t modifier_keys = static_cast<uint32_t>(ModifierKey::None);
@@ -68,7 +68,7 @@ static CGEventRef keyboardEventCallback(CGEventTapProxy proxy,
       modifier_keys |= static_cast<uint32_t>(ModifierKey::NumLock);
     }
     ModifierKeysChangedEvent modifier_event(modifier_keys);
-    event_emitter->EmitSync(modifier_event);
+    event_emitter->Emit(modifier_event);
   }
   return event;
 }

src/platform/macos/menu_macos.mm

@@ -280,7 +280,7 @@ - (void)menuDidClose:(NSMenu*)menu {
   // 设置默认的 Block 处理器，直接发送事件
   pimpl_->ns_menu_item_target_.clickedBlock = ^(MenuItemId item_id, const std::string& item_text) {
     try {
-      EmitSync<MenuItemClickedEvent>(item_id, item_text);
+      Emit<MenuItemClickedEvent>(item_id, item_text);
     } catch (...) {
       // Protect against event emission exceptions
     }
@@ -298,7 +298,7 @@ - (void)menuDidClose:(NSMenu*)menu {
   // 设置默认的 Block 处理器，直接发送事件
   pimpl_->ns_menu_item_target_.clickedBlock = ^(MenuItemId item_id, const std::string& item_text) {
     try {
-      EmitSync<MenuItemClickedEvent>(item_id, item_text);
+      Emit<MenuItemClickedEvent>(item_id, item_text);
     } catch (...) {
       // Protect against event emission exceptions
     }
@@ -487,7 +487,7 @@ - (void)menuDidClose:(NSMenu*)menu {
         pimpl_->submenu_opened_listener_id_ = submenu->AddListener<MenuOpenedEvent>(
             [self, menu_item_id](const MenuOpenedEvent& event) {
               try {
-                self->EmitSync<MenuItemSubmenuOpenedEvent>(menu_item_id);
+                self->Emit<MenuItemSubmenuOpenedEvent>(menu_item_id);
               } catch (...) {
                 // Protect against event emission exceptions
               }
@@ -496,7 +496,7 @@ - (void)menuDidClose:(NSMenu*)menu {
         pimpl_->submenu_closed_listener_id_ = submenu->AddListener<MenuClosedEvent>(
             [self, menu_item_id](const MenuClosedEvent& event) {
               try {
-                self->EmitSync<MenuItemSubmenuClosedEvent>(menu_item_id);
+                self->Emit<MenuItemSubmenuClosedEvent>(menu_item_id);
               } catch (...) {
                 // Protect against event emission exceptions
               }
@@ -598,15 +598,15 @@ - (void)menuDidClose:(NSMenu*)menu {
   // 设置默认的 Block 处理器，直接发送事件
   pimpl_->delegate_.openedBlock = ^(MenuId menu_id) {
     try {
-      EmitSync<MenuOpenedEvent>(menu_id);
+      Emit<MenuOpenedEvent>(menu_id);
     } catch (...) {
       // Protect against event emission exceptions
     }
   };
 
   pimpl_->delegate_.closedBlock = ^(MenuId menu_id) {
     try {
-      EmitSync<MenuClosedEvent>(menu_id);
+      Emit<MenuClosedEvent>(menu_id);
     } catch (...) {
       // Protect against event emission exceptions
     }
@@ -623,15 +623,15 @@ - (void)menuDidClose:(NSMenu*)menu {
   // 设置默认的 Block 处理器，直接发送事件
   pimpl_->delegate_.openedBlock = ^(MenuId menu_id) {
     try {
-      EmitSync<MenuOpenedEvent>(menu_id);
+      Emit<MenuOpenedEvent>(menu_id);
     } catch (...) {
       // Protect against event emission exceptions
     }
   };
 
   pimpl_->delegate_.closedBlock = ^(MenuId menu_id) {
     try {
-      EmitSync<MenuClosedEvent>(menu_id);
+      Emit<MenuClosedEvent>(menu_id);
     } catch (...) {
       // Protect against event emission exceptions
     }

src/platform/macos/tray_icon_macos.mm

@@ -136,23 +136,23 @@ - (void)statusItemClicked:(id)sender;
     pimpl_->ns_status_bar_button_target_.leftClickedBlock =
         ^(TrayIconId tray_icon_id, const std::string& button) {
           try {
-            EmitSync<TrayIconClickedEvent>(tray_icon_id, button);
+            Emit<TrayIconClickedEvent>(tray_icon_id, button);
           } catch (...) {
             // Protect against event emission exceptions
           }
         };
 
     pimpl_->ns_status_bar_button_target_.rightClickedBlock = ^(TrayIconId tray_icon_id) {
       try {
-        EmitSync<TrayIconRightClickedEvent>(tray_icon_id);
+        Emit<TrayIconRightClickedEvent>(tray_icon_id);
       } catch (...) {
         // Protect against event emission exceptions
       }
     };
 
     pimpl_->ns_status_bar_button_target_.doubleClickedBlock = ^(TrayIconId tray_icon_id) {
       try {
-        EmitSync<TrayIconDoubleClickedEvent>(tray_icon_id);
+        Emit<TrayIconDoubleClickedEvent>(tray_icon_id);
       } catch (...) {
         // Protect against event emission exceptions
       }

src/platform/macos/window_manager_macos.mm

@@ -193,7 +193,7 @@ - (void)windowWillClose:(NSNotification*)notification {
 }
 
 void WindowManager::DispatchWindowEvent(const Event& event) {
-  EmitSync(event);  // Use Dispatch instead of DispatchSync
+  Emit(event);  // Use Dispatch instead of DispatchSync
 }
 
 // Create a new window with the given options.