Complete generic event system with integration examples and demo

Co-authored-by: lijy91 <3889523+lijy91@users.noreply.github.com>

Author: Copilot

.gitignore

@@ -2,4 +2,11 @@
 .vs/
 .vscode/
 build/
-cmake-build-debug/
+cmake-build-debug/
+
+# Generated test binaries and object files
+*.o
+*_test
+callback_test
+simple_test
+event_test

src/callback_test

@@ -0,0 +1,164 @@
+#include "event_system.h"
+#include "common_events.h"
+#include "event_integration_example.h"
+#include <iostream>
+#include <thread>
+#include <chrono>
+
+/**
+ * Complete demonstration of the generic event system capabilities
+ */
+namespace nativeapi {
+
+void DemonstrateGenericEventSystem() {
+  std::cout << "=== Generic Event System Demonstration ===" << std::endl;
+  
+  // Get global event dispatcher
+  auto& dispatcher = GetGlobalEventDispatcher();
+  
+  std::cout << "\n1. Setting up event listeners..." << std::endl;
+  
+  // Example 1: Type-specific callback listeners
+  auto key_listener = AddScopedListener<KeyPressedEvent>(dispatcher, 
+      [](const KeyPressedEvent& event) {
+        std::cout << "🎹 Key pressed: " << event.GetKeycode() << std::endl;
+      });
+  
+  auto display_listener = AddScopedListener<DisplayAddedEvent>(dispatcher,
+      [](const DisplayAddedEvent& event) {
+        std::cout << "🖥️ Display added" << std::endl;
+      });
+  
+  // Example 2: Multi-event observer
+  UnifiedSystemEventHandler system_handler;
+  auto key_pressed_id = dispatcher.AddListener<KeyPressedEvent>(&system_handler);
+  auto key_released_id = dispatcher.AddListener<KeyReleasedEvent>(&system_handler);
+  auto display_added_id = dispatcher.AddListener<DisplayAddedEvent>(&system_handler);
+  auto display_removed_id = dispatcher.AddListener<DisplayRemovedEvent>(&system_handler);
+  auto app_started_id = dispatcher.AddListener<ApplicationStartedEvent>(&system_handler);
+  
+  // Example 3: Application lifecycle listeners
+  auto app_exit_listener = AddScopedListener<ApplicationExitingEvent>(dispatcher,
+      [](const ApplicationExitingEvent& event) {
+        std::cout << "🚪 Application exiting with code: " << event.GetExitCode() << std::endl;
+      });
+  
+  std::cout << "Total listeners registered: " << dispatcher.GetTotalListenerCount() << std::endl;
+  
+  // Example 4: Start async processing
+  std::cout << "\n2. Starting asynchronous event processing..." << std::endl;
+  dispatcher.Start();
+  
+  // Example 5: Synchronous event dispatch
+  std::cout << "\n3. Dispatching synchronous events..." << std::endl;
+  
+  dispatcher.DispatchSync<ApplicationStartedEvent>();
+  
+  // Create dummy display for demonstration
+  Display dummy_display; // Assuming Display has default constructor
+  dispatcher.DispatchSync<DisplayAddedEvent>(dummy_display);
+  
+  dispatcher.DispatchSync<KeyPressedEvent>(65);  // 'A'
+  dispatcher.DispatchSync<KeyReleasedEvent>(65);
+  
+  // Example 6: Asynchronous event dispatch
+  std::cout << "\n4. Dispatching asynchronous events..." << std::endl;
+  
+  dispatcher.DispatchAsync<KeyPressedEvent>(66);  // 'B'
+  dispatcher.DispatchAsync<KeyPressedEvent>(67);  // 'C'
+  dispatcher.DispatchAsync<KeyReleasedEvent>(66);
+  dispatcher.DispatchAsync<KeyReleasedEvent>(67);
+  
+  dispatcher.DispatchAsync<DisplayRemovedEvent>(dummy_display);
+  
+  // Wait for async events to process
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  
+  // Example 7: Custom event with complex data
+  std::cout << "\n5. Custom complex event..." << std::endl;
+  
+  class CustomUserEvent : public TypedEvent<CustomUserEvent> {
+   public:
+    CustomUserEvent(const std::string& action, int user_id, bool success)
+        : action_(action), user_id_(user_id), success_(success) {}
+    
+    const std::string& GetAction() const { return action_; }
+    int GetUserId() const { return user_id_; }
+    bool IsSuccess() const { return success_; }
+    
+   private:
+    std::string action_;
+    int user_id_;
+    bool success_;
+  };
+  
+  auto custom_listener = AddScopedListener<CustomUserEvent>(dispatcher,
+      [](const CustomUserEvent& event) {
+        std::cout << "👤 User " << event.GetUserId() 
+                  << " " << event.GetAction()
+                  << " - " << (event.IsSuccess() ? "success" : "failed") << std::endl;
+      });
+  
+  dispatcher.DispatchSync<CustomUserEvent>("login", 123, true);
+  dispatcher.DispatchAsync<CustomUserEvent>("logout", 123, true);
+  
+  // Wait for final async event
+  std::this_thread::sleep_for(std::chrono::milliseconds(50));
+  
+  // Example 8: Event timestamping
+  std::cout << "\n6. Event timestamping demonstration..." << std::endl;
+  
+  auto timestamp_listener = AddScopedListener<ApplicationExitingEvent>(dispatcher,
+      [](const ApplicationExitingEvent& event) {
+        auto now = std::chrono::steady_clock::now();
+        auto event_time = event.GetTimestamp();
+        auto diff = std::chrono::duration_cast<std::chrono::microseconds>(now - event_time);
+        std::cout << "⏱️ Event processed " << diff.count() << " microseconds after creation" << std::endl;
+      });
+  
+  dispatcher.DispatchSync<ApplicationExitingEvent>(0);
+  
+  // Example 9: Cleanup demonstration
+  std::cout << "\n7. Cleanup and listener management..." << std::endl;
+  
+  std::cout << "Listeners before cleanup: " << dispatcher.GetTotalListenerCount() << std::endl;
+  
+  // Remove some specific listeners
+  dispatcher.RemoveListener(key_pressed_id);
+  dispatcher.RemoveListener(display_added_id);
+  
+  std::cout << "Listeners after removing 2: " << dispatcher.GetTotalListenerCount() << std::endl;
+  
+  // Scoped listeners will be automatically removed when they go out of scope
+  
+  // Stop async processing
+  std::cout << "\n8. Stopping async processing..." << std::endl;
+  dispatcher.Stop();
+  
+  std::cout << "\n=== Demonstration Complete ===" << std::endl;
+  std::cout << "The generic event system provides:" << std::endl;
+  std::cout << "✓ Type-safe event handling" << std::endl;
+  std::cout << "✓ Both observer and callback patterns" << std::endl;
+  std::cout << "✓ Synchronous and asynchronous dispatch" << std::endl;
+  std::cout << "✓ Thread-safe operations" << std::endl;
+  std::cout << "✓ Automatic memory management" << std::endl;
+  std::cout << "✓ Event timestamping" << std::endl;
+  std::cout << "✓ Exception safety" << std::endl;
+  std::cout << "✓ RAII-based cleanup" << std::endl;
+  
+  // Clean up remaining listeners
+  dispatcher.RemoveListener(key_released_id);
+  dispatcher.RemoveListener(display_removed_id);
+  dispatcher.RemoveListener(app_started_id);
+  
+  std::cout << "\nFinal listener count: " << dispatcher.GetTotalListenerCount() << std::endl;
+}
+
+}  // namespace nativeapi
+
+#ifdef DEMO_MAIN
+int main() {
+  nativeapi::DemonstrateGenericEventSystem();
+  return 0;
+}
+#endif

src/complete_event_demo.cpp

@@ -0,0 +1,148 @@
+#pragma once
+
+/**
+ * Integration Example: Event-Aware Display Manager
+ * 
+ * This example shows how to integrate the generic event system
+ * with existing components like DisplayManager.
+ */
+
+#include "display_manager.h"
+#include "event_system.h"
+#include "common_events.h"
+
+namespace nativeapi {
+
+/**
+ * Extended DisplayManager that uses the generic event system
+ * in addition to the existing listener pattern.
+ * 
+ * This demonstrates how existing code can be enhanced with the
+ * new event system without breaking existing functionality.
+ */
+class EventAwareDisplayManager : public DisplayManager {
+ public:
+  explicit EventAwareDisplayManager(EventDispatcher* dispatcher = nullptr) 
+      : dispatcher_(dispatcher ? dispatcher : &GetGlobalEventDispatcher()) {}
+
+  // Override methods to dispatch events
+  void AddListener(DisplayListener* listener) override {
+    DisplayManager::AddListener(listener);
+    
+    // Also dispatch an event when listeners are added
+    // This allows other parts of the system to react to listener changes
+    if (dispatcher_) {
+      // We could define a ListenerAddedEvent if needed
+    }
+  }
+
+  void RemoveListener(DisplayListener* listener) override {
+    DisplayManager::RemoveListener(listener);
+    
+    // Dispatch event for listener removal if needed
+  }
+
+ protected:
+  /**
+   * Override the notification method to also dispatch generic events.
+   * This is called internally when displays change.
+   */
+  void NotifyListeners(std::function<void(DisplayListener*)> callback) override {
+    // Call the base implementation first
+    DisplayManager::NotifyListeners(callback);
+    
+    // If this was a display added/removed notification, we could
+    // dispatch the corresponding event here. For example:
+    // dispatcher_->DispatchAsync<DisplayChangedEvent>(...);
+  }
+
+  /**
+   * Example method that would be called when a display is actually added.
+   * This would normally be called by the platform-specific implementation.
+   */
+  void OnSystemDisplayAdded(const Display& display) {
+    // Update internal state
+    // ... existing logic ...
+    
+    // Notify existing listeners
+    NotifyListeners([&display](DisplayListener* listener) {
+      listener->OnDisplayAdded(display);
+    });
+    
+    // Dispatch generic event
+    if (dispatcher_) {
+      dispatcher_->DispatchAsync<DisplayAddedEvent>(display);
+    }
+  }
+
+  /**
+   * Example method for display removal
+   */
+  void OnSystemDisplayRemoved(const Display& display) {
+    // Update internal state
+    // ... existing logic ...
+    
+    // Notify existing listeners
+    NotifyListeners([&display](DisplayListener* listener) {
+      listener->OnDisplayRemoved(display);
+    });
+    
+    // Dispatch generic event
+    if (dispatcher_) {
+      dispatcher_->DispatchAsync<DisplayRemovedEvent>(display);
+    }
+  }
+
+ private:
+  EventDispatcher* dispatcher_;
+};
+
+/**
+ * Example of a unified event handler that can handle both
+ * keyboard and display events using the generic event system.
+ */
+class UnifiedSystemEventHandler : public EventListener {
+ public:
+  void OnEvent(const Event& event) override {
+    // Handle different event types
+    if (auto display_added = dynamic_cast<const DisplayAddedEvent*>(&event)) {
+      HandleDisplayAdded(*display_added);
+    } else if (auto display_removed = dynamic_cast<const DisplayRemovedEvent*>(&event)) {
+      HandleDisplayRemoved(*display_removed);
+    } else if (auto key_pressed = dynamic_cast<const KeyPressedEvent*>(&event)) {
+      HandleKeyPressed(*key_pressed);
+    } else if (auto key_released = dynamic_cast<const KeyReleasedEvent*>(&event)) {
+      HandleKeyReleased(*key_released);
+    } else if (auto app_started = dynamic_cast<const ApplicationStartedEvent*>(&event)) {
+      HandleApplicationStarted(*app_started);
+    }
+  }
+
+ private:
+  void HandleDisplayAdded(const DisplayAddedEvent& event) {
+    std::cout << "System: Display added" << std::endl;
+    // Handle display addition...
+  }
+
+  void HandleDisplayRemoved(const DisplayRemovedEvent& event) {
+    std::cout << "System: Display removed" << std::endl;
+    // Handle display removal...
+  }
+
+  void HandleKeyPressed(const KeyPressedEvent& event) {
+    std::cout << "System: Key " << event.GetKeycode() << " pressed" << std::endl;
+    // Handle key press...
+  }
+
+  void HandleKeyReleased(const KeyReleasedEvent& event) {
+    std::cout << "System: Key " << event.GetKeycode() << " released" << std::endl;
+    // Handle key release...
+  }
+
+  void HandleApplicationStarted(const ApplicationStartedEvent& event) {
+    std::cout << "System: Application started, setting up..." << std::endl;
+    // Initialize system components...
+  }
+};
+
+}  // namespace nativeapi