Refactor macOS window ID management and registry sync

Replaces static map-based window ID tracking with Objective-C associated objects for NSWindow, ensuring consistent and unique WindowId assignment. Updates window creation, wrapping, and retrieval logic to use associated IDs, and synchronizes the WindowRegistry with all NSWindows. Refactors swizzled NSWindow methods to resolve WindowId via registry, improving reliability and correctness of window event hooks.

Author: lijy91

src/platform/macos/window_macos.mm

@@ -1,6 +1,4 @@
 #include <iostream>
-#include <mutex>
-#include <unordered_map>
 #include "../../foundation/id_allocator.h"
 #include "../../window.h"
 #include "../../window_manager.h"
@@ -9,25 +7,54 @@
 
 // Import Cocoa headers
 #import <Cocoa/Cocoa.h>
+#import <objc/runtime.h>
+
+// Static key for associated objects
+static const void* kWindowIdKey = &kWindowIdKey;
 
 namespace nativeapi {
 
 // Private implementation class
 class Window::Impl {
  public:
-  Impl(NSWindow* window) : ns_window_(window) {}
+  Impl(WindowId id, NSWindow* window) : id_(id), ns_window_(window) {}
+  WindowId id_;
   NSWindow* ns_window_;
 };
 
-Window::Window() {
-  NSWindow* ns_window = [[NSWindow alloc] init];
-  ns_window.styleMask = NSWindowStyleMaskResizable | NSWindowStyleMaskTitled |
-                        NSWindowStyleMaskClosable | NSWindowStyleMaskMiniaturizable;
-  pimpl_ = std::make_unique<Impl>(ns_window);
-}
+Window::Window() : Window(nullptr) {}
+
+Window::Window(void* native_window) {
+  NSWindow* ns_window = nullptr;
+  WindowId id;
+
+  if (native_window == nullptr) {
+    // Create new platform object
+    id = IdAllocator::Allocate<Window>();
+    ns_window = [[NSWindow alloc] init];
+    ns_window.styleMask = NSWindowStyleMaskResizable | NSWindowStyleMaskTitled |
+                          NSWindowStyleMaskClosable | NSWindowStyleMaskMiniaturizable;
+    // Store the ID as associated object
+    objc_setAssociatedObject(ns_window, kWindowIdKey, [NSNumber numberWithUnsignedLongLong:id],
+                             OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+  } else {
+    // Wrap existing platform object - check if it already has an ID
+    ns_window = (__bridge NSWindow*)native_window;
+    NSNumber* existingId = objc_getAssociatedObject(ns_window, kWindowIdKey);
+    if (existingId) {
+      // Use existing ID
+      id = [existingId unsignedLongLongValue];
+    } else {
+      // Allocate new ID and store it
+      id = IdAllocator::Allocate<Window>();
+      objc_setAssociatedObject(ns_window, kWindowIdKey, [NSNumber numberWithUnsignedLongLong:id],
+                               OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    }
+  }
 
-Window::Window(void* native_window)
-    : pimpl_(std::make_unique<Impl>((__bridge NSWindow*)native_window)) {}
+  // All initialization logic in one place
+  pimpl_ = std::make_unique<Impl>(id, ns_window);
+}
 
 Window::~Window() {}
 
@@ -365,37 +392,7 @@
 void Window::StartResizing() {}
 
 WindowId Window::GetId() const {
-  if (!pimpl_ || !pimpl_->ns_window_) {
-    return IdAllocator::kInvalidId;
-  }
-
-  // Store the allocated ID in a static map to ensure consistency
-  // Use void* as key to avoid hash function issues with Objective-C pointers
-  static std::unordered_map<void*, WindowId> window_id_map;
-  static std::mutex map_mutex;
-
-  void* window_ptr = (__bridge void*)pimpl_->ns_window_;
-  std::lock_guard<std::mutex> lock(map_mutex);
-  auto it = window_id_map.find(window_ptr);
-  if (it != window_id_map.end()) {
-    return it->second;
-  }
-
-  // Allocate new ID using the IdAllocator
-  WindowId new_id = IdAllocator::Allocate<Window>();
-  if (new_id != IdAllocator::kInvalidId) {
-    window_id_map[window_ptr] = new_id;
-
-    // Register window in registry (delayed registration)
-    // This requires the Window to be managed by shared_ptr
-    try {
-      WindowRegistry::GetInstance().Add(new_id, const_cast<Window*>(this)->shared_from_this());
-    } catch (const std::bad_weak_ptr&) {
-      // Window not yet managed by shared_ptr, skip registration
-      // Registration will happen when window is properly managed by shared_ptr
-    }
-  }
-  return new_id;
+  return pimpl_->id_;
 }
 
 void* Window::GetNativeObjectInternal() const {

src/platform/macos/window_manager_macos.mm

@@ -46,28 +46,27 @@ - (void)na_swizzled_orderOut:(id)sender;
 @implementation NSWindow (NativeAPISwizzle)
 
 - (void)na_swizzled_makeKeyAndOrderFront:(id)sender {
-  // Invoke hook before showing
-  nativeapi::WindowManager::GetInstance().InvokeWillShowHook([self windowNumber]);
-
-  // Defer calling original to the next runloop turn so Dart hook can run first
-  // Guard with associated flag to avoid multiple schedules for the same call
-  static const void* kNAWillShowScheduledKey = &kNAWillShowScheduledKey;
-  id scheduled = objc_getAssociatedObject(self, kNAWillShowScheduledKey);
-  if (!scheduled) {
-    objc_setAssociatedObject(self, kNAWillShowScheduledKey, @YES,
-                             OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-    dispatch_async(dispatch_get_main_queue(), ^{
-      // Clear flag
-      objc_setAssociatedObject(self, kNAWillShowScheduledKey, nil, OBJC_ASSOCIATION_ASSIGN);
-      // Call original implementation (swapped)
-      [self na_swizzled_makeKeyAndOrderFront:sender];
-    });
-  }
+    // Ensure registry is in sync and then invoke hook with correct WindowId
+    auto windows = nativeapi::WindowManager::GetInstance().GetAll();
+    for (const auto& window : windows) {
+      if (window->GetNativeObject() == (__bridge void*)self) {
+        nativeapi::WindowManager::GetInstance().InvokeWillShowHook(window->GetId());
+        break;
+      }
+    }
+    // First call original implementation so properties like title are up-to-date
+    [self na_swizzled_makeKeyAndOrderFront:sender];
 }
 
 - (void)na_swizzled_orderOut:(id)sender {
-  // Invoke hook before hiding
-  nativeapi::WindowManager::GetInstance().InvokeWillHideHook([self windowNumber]);
+  // Invoke hook before hiding, resolving id via registry without using windowNumber
+  auto windows = nativeapi::WindowManager::GetInstance().GetAll();
+  for (const auto& window : windows) {
+    if (window->GetNativeObject() == (__bridge void*)self) {
+      nativeapi::WindowManager::GetInstance().InvokeWillHideHook(window->GetId());
+      break;
+    }
+  }
   // Call original implementation (swapped)
   [self na_swizzled_orderOut:sender];
 }
@@ -277,48 +276,54 @@ - (void)windowWillClose:(NSNotification*)notification {
 }
 
 std::shared_ptr<Window> WindowManager::Get(WindowId id) {
-  auto cached = WindowRegistry::GetInstance().Get(id);
-  if (cached) {
-    return cached;
-  }
-  NSArray* ns_windows = [[NSApplication sharedApplication] windows];
-  for (NSWindow* ns_window in ns_windows) {
-    if ([ns_window windowNumber] == id) {
-      auto window = std::make_shared<Window>((__bridge void*)ns_window);
-      WindowRegistry::GetInstance().Add(id, window);
-      return window;
-    }
+  // First check if it's already in the registry
+  auto window = WindowRegistry::GetInstance().Get(id);
+  if (window) {
+    return window;
   }
-  return nullptr;
+
+  // If not found, ensure all NSWindows are registered and try again
+  GetAll();
+  return WindowRegistry::GetInstance().Get(id);
 }
 
 std::vector<std::shared_ptr<Window>> WindowManager::GetAll() {
-  std::vector<std::shared_ptr<Window>> windows;
   NSArray* ns_windows = [[NSApplication sharedApplication] windows];
+
+  // First, ensure all NSWindows are registered
   for (NSWindow* ns_window in ns_windows) {
-    WindowId window_id = [ns_window windowNumber];
+    // Create or get Window wrapper - this will handle ID assignment via associated object
+    auto window = std::make_shared<Window>((__bridge void*)ns_window);
+    WindowId window_id = window->GetId();
+    
+    // Add to registry if not already present
     if (!WindowRegistry::GetInstance().Get(window_id)) {
-      auto window = std::make_shared<Window>((__bridge void*)ns_window);
       WindowRegistry::GetInstance().Add(window_id, window);
     }
   }
-  // Merge cached windows from registry to ensure consistency
-  auto cached = WindowRegistry::GetInstance().GetAll();
-  for (const auto& w : cached) {
-    windows.push_back(w);
-  }
-  return windows;
+
+  // Then return all windows from registry (which now includes all NSWindows)
+  return WindowRegistry::GetInstance().GetAll();
 }
 
 std::shared_ptr<Window> WindowManager::GetCurrent() {
   NSApplication* app = [NSApplication sharedApplication];
   NSArray* ns_windows = [[NSApplication sharedApplication] windows];
   NSWindow* ns_window = [app mainWindow];
-  if (ns_window == nil) {
+  if (ns_window == nil && [ns_windows count] > 0) {
     ns_window = [ns_windows objectAtIndex:0];
   }
   if (ns_window != nil) {
-    return Get([ns_window windowNumber]);
+    // Create or get Window wrapper - this will handle ID retrieval via associated object
+    auto window = std::make_shared<Window>((__bridge void*)ns_window);
+    WindowId window_id = window->GetId();
+    
+    // Ensure it's in the registry
+    if (!WindowRegistry::GetInstance().Get(window_id)) {
+      WindowRegistry::GetInstance().Add(window_id, window);
+    }
+    
+    return window;
   }
   return nullptr;
 }