Add event listener lifecycle management hooks

Introduces startEventListening and stopEventListening hooks to EventEmitter and implements them in Menu, MenuItem, and TrayIcon for proper native event listener registration and cleanup. This improves resource management and ensures native listeners are only active when needed. Also adds the 'meta' package dependency for @Protected annotations and removes unused imports from the tray_icon_example.

Author: lijy91

examples/tray_icon_example/lib/main.dart

@@ -1,10 +1,5 @@
 import 'package:flutter/material.dart' hide Image;
-import 'package:flutter/services.dart';
 import 'package:nativeapi/nativeapi.dart';
-import 'dart:convert';
-
-import 'package:path/path.dart' as path;
-import 'dart:io';
 
 class TrayIconData {
   final int id;

packages/nativeapi/lib/src/foundation/event_emitter.dart

@@ -1,15 +1,31 @@
 import 'dart:async';
 
+import 'package:meta/meta.dart';
+
 import 'event.dart';
 
-/// Mixin that provides event emission capabilities.
+/// Mixin that provides event emission capabilities with lifecycle management.
 /// Classes that use this mixin can easily add listener management
 /// and event dispatching functionality.
 ///
-/// Example usage:
+/// The mixin automatically manages event listening lifecycle:
+/// - `startEventListening()` is called when the first listener is added
+/// - `stopEventListening()` is called when the last listener is removed
+///
+/// Subclasses can override these methods to manage platform-specific resources:
 ///
 /// ```dart
 /// class MyClass with EventEmitter {
+///   @override
+///   void startEventListening() {
+///     // Start platform event monitoring
+///   }
+///
+///   @override
+///   void stopEventListening() {
+///     // Stop platform event monitoring
+///   }
+///
 ///   void doSomething() {
 ///     // Emit an event synchronously
 ///     emitSync(MyEvent("some data"));
@@ -35,16 +51,34 @@ mixin EventEmitter {
   /// Counter for generating unique listener IDs
   int _nextListenerId = 0;
 
+  /// Called when the first listener is added.
+  /// Subclasses can override this to start platform-specific event monitoring.
+  @protected
+  void startEventListening() {}
+
+  /// Called when the last listener is removed.
+  /// Subclasses can override this to stop platform-specific event monitoring.
+  @protected
+  void stopEventListening() {}
+
   /// Add a typed event listener for a specific event type.
   ///
   /// Returns a unique listener ID that can be used to remove the listener.
   int addListener<T extends Event>(EventListener<T> listener) {
     final eventType = T;
     final listenerId = _nextListenerId++;
 
+    // Check if this is the first listener
+    final wasEmpty = totalListenerCount == 0;
+
     _listeners.putIfAbsent(eventType, () => <int, EventListener>{});
     _listeners[eventType]![listenerId] = listener;
 
+    // Call hook when transitioning from 0 to 1+ listeners
+    if (wasEmpty) {
+      startEventListening();
+    }
+
     return listenerId;
   }
 
@@ -61,6 +95,10 @@ mixin EventEmitter {
   bool removeListener(int listenerId) {
     for (final eventListeners in _listeners.values) {
       if (eventListeners.remove(listenerId) != null) {
+        // Check if this was the last listener
+        if (totalListenerCount == 0) {
+          stopEventListening();
+        }
         return true;
       }
     }
@@ -81,6 +119,8 @@ mixin EventEmitter {
   /// emitter.removeAllListeners(MyCustomEvent);
   /// ```
   void removeAllListeners<T extends Event>([Type? eventType]) {
+    final hadListeners = totalListenerCount > 0;
+
     if (eventType != null) {
       final listeners = _listeners[eventType];
       if (listeners != null) {
@@ -92,6 +132,11 @@ mixin EventEmitter {
       }
       _listeners.clear();
     }
+
+    // Call hook if we had listeners and now have none
+    if (hadListeners && totalListenerCount == 0) {
+      stopEventListening();
+    }
   }
 
   /// Get the number of listeners registered for a specific event type.
@@ -159,8 +204,15 @@ mixin EventEmitter {
   /// Dispose of the event emitter and clean up resources.
   /// Classes using this mixin should call this method when disposing.
   void disposeEventEmitter() {
+    final hadListeners = totalListenerCount > 0;
+    
     // Clear all listeners
     _listeners.clear();
+    
+    // Call hook if we had listeners
+    if (hadListeners) {
+      stopEventListening();
+    }
   }
 }
 

packages/nativeapi/lib/src/menu.dart

@@ -30,6 +30,11 @@ class MenuItem
   static bool _callbacksInitialized = false;
 
   late final native_menu_item_t _nativeHandle;
+  
+  // Store listener IDs for cleanup
+  int? _clickedListenerId;
+  int? _submenuOpenedListenerId;
+  int? _submenuClosedListenerId;
 
   MenuItem(String label, [MenuItemType type = MenuItemType.normal]) {
     final labelPtr = label.toNativeUtf8().cast<Char>();
@@ -39,6 +44,12 @@ class MenuItem
     );
     ffi.calloc.free(labelPtr);
 
+    // Store instance in static map using handle address as key
+    _instances[_nativeHandle.address] = this;
+  }
+
+  @override
+  void startEventListening() {
     // Initialize callbacks once
     if (!_callbacksInitialized) {
       _clickedCallback =
@@ -56,30 +67,53 @@ class MenuItem
       _callbacksInitialized = true;
     }
 
-    // Store instance in static map using handle address as key
-    _instances[_nativeHandle.address] = this;
-
-    // Register listeners for each event type with native callbacks
-    bindings.native_menu_item_add_listener(
+    // Register listeners for each event type with native callbacks and store IDs
+    _clickedListenerId = bindings.native_menu_item_add_listener(
       _nativeHandle,
       native_menu_item_event_type_t.NATIVE_MENU_ITEM_EVENT_CLICKED,
       _clickedCallback.nativeFunction,
       _nativeHandle,
     );
-    bindings.native_menu_item_add_listener(
+    _submenuOpenedListenerId = bindings.native_menu_item_add_listener(
       _nativeHandle,
       native_menu_item_event_type_t.NATIVE_MENU_ITEM_EVENT_SUBMENU_OPENED,
       _submenuOpenedCallback.nativeFunction,
       _nativeHandle,
     );
-    bindings.native_menu_item_add_listener(
+    _submenuClosedListenerId = bindings.native_menu_item_add_listener(
       _nativeHandle,
       native_menu_item_event_type_t.NATIVE_MENU_ITEM_EVENT_SUBMENU_CLOSED,
       _submenuClosedCallback.nativeFunction,
       _nativeHandle,
     );
   }
 
+  @override
+  void stopEventListening() {
+    // Remove native listeners using stored IDs
+    if (_clickedListenerId != null) {
+      bindings.native_menu_item_remove_listener(
+        _nativeHandle,
+        _clickedListenerId!,
+      );
+      _clickedListenerId = null;
+    }
+    if (_submenuOpenedListenerId != null) {
+      bindings.native_menu_item_remove_listener(
+        _nativeHandle,
+        _submenuOpenedListenerId!,
+      );
+      _submenuOpenedListenerId = null;
+    }
+    if (_submenuClosedListenerId != null) {
+      bindings.native_menu_item_remove_listener(
+        _nativeHandle,
+        _submenuClosedListenerId!,
+      );
+      _submenuClosedListenerId = null;
+    }
+  }
+
   // Static callback functions for FFI
   static void _nativeOnClickedEvent(
     Pointer<Void> event,
@@ -199,24 +233,7 @@ class MenuItem
     // Remove instance from static map
     _instances.remove(_nativeHandle.address);
 
-    // // Remove native listeners
-    // bindings.native_menu_item_remove_listener(
-    //   _nativeHandle,
-    //   native_menu_item_event_type_t.NATIVE_MENU_ITEM_EVENT_CLICKED,
-    //   _clickedCallback.nativeFunction,
-    // );
-    // bindings.native_menu_item_remove_listener(
-    //   _nativeHandle,
-    //   native_menu_item_event_type_t.NATIVE_MENU_ITEM_EVENT_SUBMENU_OPENED,
-    //   _submenuOpenedCallback.nativeFunction,
-    // );
-    // bindings.native_menu_item_remove_listener(
-    //   _nativeHandle,
-    //   native_menu_item_event_type_t.NATIVE_MENU_ITEM_EVENT_SUBMENU_CLOSED,
-    //   _submenuClosedCallback.nativeFunction,
-    // );
-
-    // Dispose event emitter
+    // Dispose event emitter (will call stopEventListening if needed)
     disposeEventEmitter();
 
     // Destroy native handle
@@ -239,10 +256,20 @@ class Menu
   _closedCallback;
 
   static bool _callbacksInitialized = false;
+  
+  // Store listener IDs for cleanup
+  int? _openedListenerId;
+  int? _closedListenerId;
 
   Menu([native_menu_t? nativeHandle]) {
     _nativeHandle = nativeHandle ?? bindings.native_menu_create();
 
+    // Store instance in static map using handle address as key
+    _instances[_nativeHandle.address] = this;
+  }
+
+  @override
+  void startEventListening() {
     // Initialize callbacks once
     if (!_callbacksInitialized) {
       _openedCallback =
@@ -256,24 +283,40 @@ class Menu
       _callbacksInitialized = true;
     }
 
-    // Store instance in static map using handle address as key
-    _instances[_nativeHandle.address] = this;
-
-    // Register listeners for each event type with native callbacks
-    bindings.native_menu_add_listener(
+    // Register listeners for each event type with native callbacks and store IDs
+    _openedListenerId = bindings.native_menu_add_listener(
       _nativeHandle,
       native_menu_event_type_t.NATIVE_MENU_EVENT_OPENED,
       _openedCallback.nativeFunction,
       _nativeHandle,
     );
-    bindings.native_menu_add_listener(
+    _closedListenerId = bindings.native_menu_add_listener(
       _nativeHandle,
       native_menu_event_type_t.NATIVE_MENU_EVENT_CLOSED,
       _closedCallback.nativeFunction,
       _nativeHandle,
     );
   }
 
+  @override
+  void stopEventListening() {
+    // Remove native listeners using stored IDs
+    if (_openedListenerId != null) {
+      bindings.native_menu_remove_listener(
+        _nativeHandle,
+        _openedListenerId!,
+      );
+      _openedListenerId = null;
+    }
+    if (_closedListenerId != null) {
+      bindings.native_menu_remove_listener(
+        _nativeHandle,
+        _closedListenerId!,
+      );
+      _closedListenerId = null;
+    }
+  }
+
   // Static callback functions for FFI
   static void _nativeOnOpenedEvent(
     Pointer<Void> event,
@@ -374,13 +417,7 @@ class Menu
     // Remove instance from static map
     _instances.remove(_nativeHandle.address);
 
-    // // Remove native listeners
-    // bindings.native_menu_remove_listener(
-    //   _nativeHandle,
-    //   _openedCallback.nativeFunction,
-    // );
-
-    // Dispose event emitter
+    // Dispose event emitter (will call stopEventListening if needed)
     disposeEventEmitter();
 
     // Destroy native handle