feat: Integrate BroadcastCenter and DisplayManager with event handling in nswindow_example

Author: lijy91

examples/nswindow_example/main.mm

@@ -3,6 +3,11 @@
 #include <iostream>
 #include "nativeapi.h"
 
+using nativeapi::BroadcastCenter;
+using nativeapi::BroadcastEventHandler;
+using nativeapi::Display;
+using nativeapi::DisplayEventHandler;
+using nativeapi::DisplayManager;
 using nativeapi::Tray;
 using nativeapi::TrayManager;
 using nativeapi::Window;
@@ -36,6 +41,32 @@ - (void)applicationDidFinishLaunching:(NSNotification*)notification {
     NSLog(@"所有窗口: %@", NSApp.windows);
   });
 
+
+  DisplayManager displayManager = DisplayManager();
+
+  DisplayEventHandler displayEventHandler = DisplayEventHandler(
+      [](const Display& display) {
+        std::cout << "Display added: " << display.id << std::endl;
+      },
+      [](const Display& display) {
+        std::cout << "Display removed: " << display.id << std::endl;
+      });
+  displayManager.AddListener(&displayEventHandler);
+
+  std::shared_ptr<BroadcastCenter> broadcastCenter = std::make_shared<BroadcastCenter>();
+
+  BroadcastEventHandler broadcastEventHandler =
+      BroadcastEventHandler([](const std::string& message) {
+        std::cout << "Received broadcast: " << message << std::endl;
+      });
+
+  broadcastCenter->RegisterReceiver("com.example.myNotification", &broadcastEventHandler);
+
+  //  broadcastCenter.RegisterReceiver(
+  //      BroadcastEventHandler ([&](const std::string& message) {
+  //        std::cout << "Received broadcast: " << message << std::endl;
+  //      }));
+
   [[NSNotificationCenter defaultCenter]
       addObserverForName:NSWindowDidBecomeMainNotification
                   object:nil
@@ -71,18 +102,17 @@ - (void)applicationDidFinishLaunching:(NSNotification*)notification {
                             << std::endl;
                 }
 
+                TrayManager trayManager = TrayManager();
 
-    TrayManager trayManager = TrayManager();
-
-    std::shared_ptr<Tray> newTrayPtr = trayManager.Create();
-    if (newTrayPtr != nullptr) {
-      Tray& newTray = *newTrayPtr;
-      newTray.SetTitle("Hello, World!");
-      std::cout << "Tray ID: " << newTray.id << std::endl;
-      std::cout << "Tray Title: " << newTray.GetTitle() << std::endl;
-    } else {
-      std::cerr << "Failed to create tray." << std::endl;
-    }
+                std::shared_ptr<Tray> newTrayPtr = trayManager.Create();
+                if (newTrayPtr != nullptr) {
+                  Tray& newTray = *newTrayPtr;
+                  newTray.SetTitle("Hello, World!");
+                  std::cout << "Tray ID: " << newTray.id << std::endl;
+                  std::cout << "Tray Title: " << newTray.GetTitle() << std::endl;
+                } else {
+                  std::cerr << "Failed to create tray." << std::endl;
+                }
               }];
 }
 

include/nativeapi.h

@@ -1,8 +1,10 @@
 #pragma once
 
+#include "../src/broadcast_center.h"
 #include "../src/display.h"
 #include "../src/display_manager.h"
 #include "../src/geometry.h"
+#include "../src/menu.h"
 #include "../src/tray.h"
 #include "../src/tray_manager.h"
 #include "../src/window.h"

src/broadcast_center.cpp

@@ -0,0 +1,33 @@
+#include <iostream>
+
+#include "broadcast_center.h"
+
+namespace nativeapi {
+
+BroadcastCenter::BroadcastCenter() {
+  std::cout << "BroadcastCenter::BroadcastCenter()" << std::endl;
+};
+
+BroadcastCenter::~BroadcastCenter() {
+  std::cout << "BroadcastCenter::~BroadcastCenter()" << std::endl;
+};
+
+void BroadcastCenter::NotifyReceivers(
+    const std::string& topic,
+    std::function<void(BroadcastReceiver*)> callback) {
+  for (const auto& receiver : receivers_) {
+    callback(receiver);
+  }
+}
+
+BroadcastEventHandler::BroadcastEventHandler(
+    std::function<void(const std::string& message)> onBroadcastReceivedCallback)
+    : onBroadcastReceivedCallback_(std::move(onBroadcastReceivedCallback)) {}
+
+void BroadcastEventHandler::OnBroadcastReceived(const std::string& message) {
+  if (onBroadcastReceivedCallback_) {
+    onBroadcastReceivedCallback_(message);
+  }
+}
+
+}  // namespace nativeapi

src/broadcast_center.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <vector>
+
+#include "display.h"
+#include "geometry.h"
+
+namespace nativeapi {
+
+// BroadcastReceiver is an interface that can be implemented by classes that
+// want to listen for broadcasts.
+class BroadcastReceiver {
+ public:
+  virtual void OnBroadcastReceived(const std::string& message) = 0;
+};
+
+// BroadcastCenter is a singleton that manages all broadcasts on the system.
+class BroadcastCenter {
+ public:
+  BroadcastCenter();
+  virtual ~BroadcastCenter();
+
+  // Register a receiver to the broadcast center
+  void RegisterReceiver(const std::string& topic, BroadcastReceiver* receiver);
+
+  // Unregister a receiver from the broadcast center
+  void UnregisterReceiver(const std::string& topic,
+                          BroadcastReceiver* receiver);
+
+  // Notify all receivers of a given topic
+  void NotifyReceivers(const std::string& topic,
+                       std::function<void(BroadcastReceiver*)> callback);
+
+ private:
+  std::vector<BroadcastReceiver*> receivers_;
+};
+
+// BroadcastEventHandler is an implementation of BroadcastReceiver that uses
+// callbacks to handle broadcast events.
+class BroadcastEventHandler : public BroadcastReceiver {
+ public:
+  // Constructor that takes callbacks for broadcast events
+  BroadcastEventHandler(std::function<void(const std::string& message)>
+                            onBroadcastReceivedCallback);
+
+  // Implementation of OnBroadcastReceive from BroadcastReceiver interface
+  void OnBroadcastReceived(const std::string& message) override;
+
+ private:
+  std::function<void(const std::string&)> onBroadcastReceivedCallback_;
+};
+
+}  // namespace nativeapi

src/broadcast_center_macos.mm

@@ -0,0 +1,31 @@
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "broadcast_center.h"
+
+// Import Cocoa headers
+#import <Cocoa/Cocoa.h>
+
+namespace nativeapi {
+
+// Static map to store BroadcastCenter instances
+static std::map<BroadcastCenter*, std::string> g_broadcast_centers;
+
+void BroadcastCenter::RegisterReceiver(const std::string& topic, BroadcastReceiver* receiver) {
+  receivers_.push_back(receiver);
+
+  NSDistributedNotificationCenter* center = [NSDistributedNotificationCenter defaultCenter];
+  [center addObserverForName:[NSString stringWithUTF8String:topic.c_str()]
+                      object:nil
+                       queue:[NSOperationQueue mainQueue]
+                  usingBlock:^(NSNotification* notification) {
+                    std::string message = [notification.userInfo[@"message"] UTF8String];
+                    receiver->OnBroadcastReceived(message);
+                  }];
+}
+
+void BroadcastCenter::UnregisterReceiver(const std::string& topic, BroadcastReceiver* receiver) {}
+
+}  // namespace nativeapi

src/menu.h

@@ -0,0 +1,49 @@
+#pragma once
+#include <string>
+#include "geometry.h"
+
+namespace nativeapi {
+
+typedef long MenuItemID;
+
+class MenuItem {
+ public:
+  MenuItem();
+  MenuItem(void* menu_item);
+  virtual ~MenuItem();
+
+  MenuItemID id;
+
+  void SetIcon(std::string icon);
+  std::string GetIcon();
+
+  void SetTitle(std::string title);
+  std::string GetTitle();
+
+  void SetTooltip(std::string tooltip);
+  std::string GetTooltip();
+
+ private:
+  class Impl;
+  Impl* pimpl_;
+};
+
+typedef long MenuID;
+
+class Menu {
+ public:
+  Menu();
+  Menu(void* menu);
+  virtual ~Menu();
+
+  MenuID id;
+
+  void AddItem(MenuItem item);
+  void RemoveItem(MenuItem item);
+
+ private:
+  class Impl;
+  Impl* pimpl_;
+};
+
+}  // namespace nativeapi

src/menu_macos.mm

@@ -0,0 +1,66 @@
+#include <iostream>
+#include "menu.h"
+
+// Import Cocoa headers
+#import <Cocoa/Cocoa.h>
+
+namespace nativeapi {
+
+// Private implementation class
+class MenuItem::Impl {
+ public:
+  Impl(NSMenuItem* menu_item) : ns_menu_item_(menu_item) {}
+  NSMenuItem* ns_menu_item_;
+};
+
+MenuItem::MenuItem() : pimpl_(new Impl(nil)) {
+  id = -1;
+}
+
+MenuItem::MenuItem(void* menu_item) : pimpl_(new Impl((__bridge NSMenuItem*)menu_item)) {
+  id = 0;
+}
+
+MenuItem::~MenuItem() {
+  delete pimpl_;
+}
+
+void MenuItem::SetTitle(std::string title) {
+  [pimpl_->ns_menu_item_ setTitle:[NSString stringWithUTF8String:title.c_str()]];
+}
+
+std::string MenuItem::GetTitle() {
+  return [[pimpl_->ns_menu_item_ title] UTF8String];
+}
+
+// Private implementation class
+class Menu::Impl {
+ public:
+  Impl(NSMenu* menu) : ns_menu_(menu) {}
+  NSMenu* ns_menu_;
+};
+
+Menu::Menu() : pimpl_(new Impl(nil)) {
+  id = -1;
+}
+
+Menu::Menu(void* menu) : pimpl_(new Impl((__bridge NSMenu*)menu)) {
+  id = 0;
+}
+
+Menu::~Menu() {
+  delete pimpl_;
+}
+
+void Menu::AddItem(MenuItem item) {
+  // NSMenuItem* ns_menu_item = (__bridge NSMenuItem*)item.GetNativeMenuItem();
+  // [pimpl_->ns_menu_ addItem:ns_menu_item];
+}
+
+void Menu::RemoveItem(MenuItem item) {
+  // NSMenuItem* ns_menu_item = (__bridge NSMenuItem*)item.GetNativeMenuItem();
+  // [pimpl_->ns_menu_ removeItem:ns_menu_item];
+}
+
+
+}  // namespace nativeapi

src/tray.h

@@ -1,6 +1,7 @@
 #pragma once
 #include <string>
 #include "geometry.h"
+#include "menu.h"
 
 namespace nativeapi {
 
@@ -22,6 +23,9 @@ class Tray {
   void SetTooltip(std::string tooltip);
   std::string GetTooltip();
 
+  void SetContextMenu(Menu menu);
+  // Menu GetContextMenu();
+
   Rectangle GetBounds();
 
  private:

src/tray_macos.mm

@@ -1,4 +1,5 @@
 #include <iostream>
+#include "menu.h"
 #include "tray.h"
 
 // Import Cocoa headers
@@ -62,7 +63,7 @@
 }
 
 std::string Tray::GetTitle() {
-  return [pimpl_->ns_status_item_.title UTF8String];
+  return [[pimpl_->ns_status_item_.button title] UTF8String];
 }
 
 void Tray::SetTooltip(std::string tooltip) {
@@ -73,4 +74,12 @@
   return [[pimpl_->ns_status_item_.button toolTip] UTF8String];
 }
 
+void Tray::SetContextMenu(Menu menu) {
+  // NSMenu* ns_menu = (__bridge NSMenu*)menu.GetNativeMenu();
+  // [pimpl_->ns_status_item_.button setMenu:ns_menu];
+}
+
+// Menu Tray::GetContextMenu() {
+//   return Menu((__bridge void*)pimpl_->ns_status_item_.button.menu);
+// }
 }  // namespace nativeapi