Replace WindowProcDelegateManager with WindowMessageDispatcher

Removed window_proc_delegate_manager.* and introduced window_message_dispatcher.* for improved window message handling. Updated tray_icon_windows.cpp to use the new dispatcher, simplifying handler registration and cleanup. This refactor provides more flexible and robust message dispatching for Windows platform code.

Author: lijy91

src/platform/windows/tray_icon_windows.cpp

@@ -15,7 +15,7 @@
 #include "../../tray_icon.h"
 #include "../../tray_icon_event.h"
 #include "string_utils_windows.h"
-#include "window_proc_delegate_manager.h"
+#include "window_message_dispatcher.h"
 
 namespace nativeapi {
 
@@ -57,15 +57,14 @@ class TrayIcon::Impl {
     nid_.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
     nid_.uCallbackMessage = WM_USER + 1;  // Custom message for tray icon events
 
-    window_proc_id_ = WindowProcDelegateManager::GetInstance().RegisterDelegate(
+    window_proc_handle_ = WindowMessageDispatcher::GetInstance().RegisterGlobalHandler(
         [this](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
           return HandleWindowProc(hwnd, message, wparam, lparam);
         });
   }
 
   ~Impl() {
-    WindowProcDelegateManager::GetInstance().UnregisterDelegate(
-        window_proc_id_);
+    // window_proc_handle_ automatically unregisters when destroyed
     if (hwnd_) {
       Shell_NotifyIconW(NIM_DELETE, &nid_);
       // Destroy the window if we own it
@@ -112,7 +111,7 @@ class TrayIcon::Impl {
     return std::nullopt;  // Let default window procedure handle it
   }
 
-  int window_proc_id_;
+  WindowMessageDispatcher::Handle window_proc_handle_;
   HWND hwnd_;
   NOTIFYICONDATAW nid_;
   std::shared_ptr<Menu> context_menu_;
@@ -142,8 +141,8 @@ TrayIcon::TrayIcon(void* native_tray_icon) {
 
     if (!class_registered) {
       WNDCLASSW wc = {};
-      // Use WindowProcDelegateManager to route messages to registered delegates
-      wc.lpfnWndProc = WindowProcDelegateManager::InternalWindowProc;
+      // Use WindowMessageDispatcher to route messages to registered handlers
+      wc.lpfnWndProc = WindowMessageDispatcher::DispatchWindowProc;
       wc.hInstance = hInstance;
       wc.lpszClassName = class_name.c_str();
 

src/platform/windows/window_message_dispatcher.cpp

@@ -0,0 +1,308 @@
+#include "window_message_dispatcher.h"
+
+#include <windows.h>
+#include <algorithm>
+#include <iostream>
+
+namespace nativeapi {
+
+WindowMessageDispatcher& WindowMessageDispatcher::GetInstance() {
+  static WindowMessageDispatcher instance;
+  return instance;
+}
+
+WindowMessageDispatcher::~WindowMessageDispatcher() {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  // Clean up all window contexts
+  for (auto& pair : window_contexts_) {
+    if (pair.second) {
+      pair.second->UninstallHook();
+    }
+  }
+  window_contexts_.clear();
+  handlers_.clear();
+}
+
+WindowMessageDispatcher::Handle WindowMessageDispatcher::RegisterGlobalHandler(
+    WindowMessageHandler handler) {
+  int id = RegisterHandler(std::move(handler), true, nullptr);
+  return (id != -1) ? Handle(id) : Handle(-1);
+}
+
+WindowMessageDispatcher::Handle WindowMessageDispatcher::RegisterWindowHandler(
+    HWND hwnd,
+    WindowMessageHandler handler) {
+  int id = RegisterHandler(std::move(handler), false, hwnd);
+  return (id != -1) ? Handle(id) : Handle(-1);
+}
+
+int WindowMessageDispatcher::RegisterHandler(WindowMessageHandler handler,
+                                             bool is_global,
+                                             HWND target_hwnd) {
+  if (!handler) {
+    return -1;
+  }
+
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  int id = next_id_++;
+  handlers_[id] = {id, std::move(handler), is_global, target_hwnd};
+
+  // For window-specific handlers, install hook if needed
+  if (!is_global && target_hwnd) {
+    if (!InstallWindowHook(target_hwnd)) {
+      handlers_.erase(id);
+      return -1;
+    }
+  }
+
+  return id;
+}
+
+bool WindowMessageDispatcher::UnregisterHandler(int id) {
+  if (id < 0) {
+    return false;
+  }
+
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  auto it = handlers_.find(id);
+  if (it == handlers_.end()) {
+    return false;
+  }
+
+  const HandlerInfo& info = it->second;
+
+  // For window-specific handlers, check if we need to uninstall hook
+  if (!info.is_global && info.target_hwnd) {
+    // Check if any other handlers exist for this window
+    bool has_other_handlers = false;
+    for (const auto& pair : handlers_) {
+      if (pair.first != id && !pair.second.is_global &&
+          pair.second.target_hwnd == info.target_hwnd) {
+        has_other_handlers = true;
+        break;
+      }
+    }
+
+    if (!has_other_handlers) {
+      UninstallWindowHook(info.target_hwnd);
+    }
+  }
+
+  handlers_.erase(it);
+  return true;
+}
+
+bool WindowMessageDispatcher::IsHandlerRegistered(int id) const {
+  std::lock_guard<std::mutex> lock(mutex_);
+  return handlers_.find(id) != handlers_.end();
+}
+
+size_t WindowMessageDispatcher::GetGlobalHandlerCount() const {
+  std::lock_guard<std::mutex> lock(mutex_);
+  return std::count_if(handlers_.begin(), handlers_.end(),
+                       [](const auto& pair) { return pair.second.is_global; });
+}
+
+size_t WindowMessageDispatcher::GetWindowHandlerCount() const {
+  std::lock_guard<std::mutex> lock(mutex_);
+  return std::count_if(handlers_.begin(), handlers_.end(),
+                       [](const auto& pair) { return !pair.second.is_global; });
+}
+
+size_t WindowMessageDispatcher::GetHookedWindowCount() const {
+  std::lock_guard<std::mutex> lock(mutex_);
+  return window_contexts_.size();
+}
+
+LRESULT CALLBACK WindowMessageDispatcher::DispatchWindowProc(HWND hwnd,
+                                                             UINT msg,
+                                                             WPARAM wparam,
+                                                             LPARAM lparam) {
+  WindowMessageDispatcher& dispatcher = Instance();
+
+  // Get window context
+  auto context = dispatcher.GetWindowContext(hwnd);
+  if (!context) {
+    return DefWindowProc(hwnd, msg, wparam, lparam);
+  }
+
+  // Dispatch to window-specific handlers
+  auto result = context->Dispatch(hwnd, msg, wparam, lparam);
+  if (result.has_value()) {
+    return result.value();
+  }
+
+  // Dispatch to global handlers
+  std::vector<WindowMessageHandler> global_handlers;
+  {
+    std::lock_guard<std::mutex> lock(dispatcher.mutex_);
+    for (const auto& pair : dispatcher.handlers_) {
+      if (pair.second.is_global && pair.second.handler) {
+        global_handlers.push_back(pair.second.handler);
+      }
+    }
+  }
+
+  // Call global handlers without holding the lock
+  for (const auto& handler : global_handlers) {
+    auto handler_result = handler(hwnd, msg, wparam, lparam);
+    if (handler_result.has_value()) {
+      return handler_result.value();
+    }
+  }
+
+  // Call original window procedure
+  return context->GetOriginalProc()(hwnd, msg, wparam, lparam);
+}
+
+bool WindowMessageDispatcher::InstallWindowHook(HWND hwnd) {
+  if (!hwnd || !IsWindow(hwnd)) {
+    return false;
+  }
+
+  auto context = GetWindowContext(hwnd);
+  return context && context->InstallHook();
+}
+
+void WindowMessageDispatcher::UninstallWindowHook(HWND hwnd) {
+  auto context = GetWindowContext(hwnd);
+  if (context) {
+    context->UninstallHook();
+  }
+}
+
+std::shared_ptr<WindowMessageDispatcher::WindowContext>
+WindowMessageDispatcher::GetWindowContext(HWND hwnd) {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  auto it = window_contexts_.find(hwnd);
+  if (it != window_contexts_.end()) {
+    return it->second;
+  }
+
+  // Create new context
+  auto context = std::make_shared<WindowContext>(hwnd);
+  window_contexts_[hwnd] = context;
+  return context;
+}
+
+// WindowContext implementation
+void WindowMessageDispatcher::WindowContext::AddHandler(
+    int id,
+    WindowMessageHandler handler) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  handlers_[id] = std::move(handler);
+}
+
+void WindowMessageDispatcher::WindowContext::RemoveHandler(int id) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  handlers_.erase(id);
+}
+
+std::optional<LRESULT> WindowMessageDispatcher::WindowContext::Dispatch(
+    HWND hwnd,
+    UINT msg,
+    WPARAM wparam,
+    LPARAM lparam) {
+  // Copy handlers while holding the lock
+  std::vector<WindowMessageHandler> handlers_copy;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    handlers_copy.reserve(handlers_.size());
+    for (const auto& pair : handlers_) {
+      if (pair.second) {
+        handlers_copy.push_back(pair.second);
+      }
+    }
+  }
+
+  // Call handlers without holding the lock
+  for (const auto& handler : handlers_copy) {
+    auto result = handler(hwnd, msg, wparam, lparam);
+    if (result.has_value()) {
+      return result;
+    }
+  }
+
+  return std::nullopt;
+}
+
+bool WindowMessageDispatcher::WindowContext::InstallHook() {
+  if (is_hooked_) {
+    return true;
+  }
+
+  if (!hwnd_ || !IsWindow(hwnd_)) {
+    return false;
+  }
+
+  // Store original window procedure
+  original_proc_ =
+      reinterpret_cast<WNDPROC>(GetWindowLongPtr(hwnd_, GWLP_WNDPROC));
+  if (!original_proc_) {
+    std::cerr << "Failed to get original WindowProc for HWND: " << hwnd_
+              << std::endl;
+    return false;
+  }
+
+  // Set our hooked window procedure
+  if (SetWindowLongPtr(hwnd_, GWLP_WNDPROC,
+                       reinterpret_cast<LONG_PTR>(HookedWindowProc)) == 0) {
+    DWORD error = GetLastError();
+    std::cerr << "Failed to set hooked WindowProc. Error: " << error
+              << std::endl;
+    return false;
+  }
+
+  is_hooked_ = true;
+  return true;
+}
+
+void WindowMessageDispatcher::WindowContext::UninstallHook() {
+  if (!is_hooked_ || !hwnd_ || !original_proc_) {
+    return;
+  }
+
+  // Restore original window procedure
+  if (SetWindowLongPtr(hwnd_, GWLP_WNDPROC,
+                       reinterpret_cast<LONG_PTR>(original_proc_)) == 0) {
+    DWORD error = GetLastError();
+    std::cerr << "Failed to restore original WindowProc. Error: " << error
+              << std::endl;
+  }
+
+  is_hooked_ = false;
+  original_proc_ = nullptr;
+}
+
+LRESULT CALLBACK
+WindowMessageDispatcher::WindowContext::HookedWindowProc(HWND hwnd,
+                                                         UINT msg,
+                                                         WPARAM wparam,
+                                                         LPARAM lparam) {
+  // Get the context from the dispatcher
+  WindowMessageDispatcher& dispatcher = WindowMessageDispatcher::Instance();
+  auto context = dispatcher.GetWindowContext(hwnd);
+
+  if (!context) {
+    return DefWindowProc(hwnd, msg, wparam, lparam);
+  }
+
+  // Dispatch to window-specific handlers
+  auto result = context->Dispatch(hwnd, msg, wparam, lparam);
+  if (result.has_value()) {
+    return result.value();
+  }
+
+  // Call original window procedure
+  return context->original_proc_(hwnd, msg, wparam, lparam);
+}
+
+WNDPROC WindowMessageDispatcher::WindowContext::GetOriginalProc() const {
+  return original_proc_ ? original_proc_ : DefWindowProc;
+}
+
+}  // namespace nativeapi