EventBus subscriber migration: add missing event types and wire dual-fire publishing (#272)

* Initial plan

* Add new EventBus event types, dual-fire publishing, and subscriber migration

Co-authored-by: michaelbeale-IL <63321611+michaelbeale-IL@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: michaelbeale-IL <63321611+michaelbeale-IL@users.noreply.github.com>

Author: Copilot

src/Libraries/ACATCore.Tests.Architecture/EventBusTests.cs

@@ -137,6 +137,93 @@ public void AgentContextChangedEvent_Properties_SetCorrectly()
             Assert.AreSame(ctx, evt.Context);
         }
 
+        [TestMethod]
+        public void AppQuitEvent_ExtendsEventBase_HasTimestamp()
+        {
+            DateTime before = DateTime.UtcNow;
+            var e = new AppQuitEvent();
+            DateTime after = DateTime.UtcNow;
+
+            Assert.IsTrue(e.Timestamp >= before && e.Timestamp <= after);
+        }
+
+        [TestMethod]
+        public void AppQuitEvent_CanBePublishedAndReceived()
+        {
+            var bus = new EventBus();
+            AppQuitEvent received = null;
+
+            bus.Subscribe<AppQuitEvent>(e => received = e);
+            bus.Publish(new AppQuitEvent());
+
+            Assert.IsNotNull(received);
+        }
+
+        [TestMethod]
+        public void CalibrationEndEvent_ExtendsEventBase_HasTimestamp()
+        {
+            DateTime before = DateTime.UtcNow;
+            var e = new CalibrationEndEvent();
+            DateTime after = DateTime.UtcNow;
+
+            Assert.IsTrue(e.Timestamp >= before && e.Timestamp <= after);
+        }
+
+        [TestMethod]
+        public void CalibrationEndEvent_CanBePublishedAndReceived()
+        {
+            var bus = new EventBus();
+            CalibrationEndEvent received = null;
+
+            bus.Subscribe<CalibrationEndEvent>(e => received = e);
+            bus.Publish(new CalibrationEndEvent());
+
+            Assert.IsNotNull(received);
+        }
+
+        [TestMethod]
+        public void DisplaySettingsChangedEvent_ExtendsEventBase_HasTimestamp()
+        {
+            DateTime before = DateTime.UtcNow;
+            var e = new DisplaySettingsChangedEvent();
+            DateTime after = DateTime.UtcNow;
+
+            Assert.IsTrue(e.Timestamp >= before && e.Timestamp <= after);
+        }
+
+        [TestMethod]
+        public void DisplaySettingsChangedEvent_CanBePublishedAndReceived()
+        {
+            var bus = new EventBus();
+            DisplaySettingsChangedEvent received = null;
+
+            bus.Subscribe<DisplaySettingsChangedEvent>(e => received = e);
+            bus.Publish(new DisplaySettingsChangedEvent());
+
+            Assert.IsNotNull(received);
+        }
+
+        [TestMethod]
+        public void WordPredictionContextChangedEvent_Context_IsPreserved()
+        {
+            var ctx = new object();
+            var e = new WordPredictionContextChangedEvent(ctx);
+
+            Assert.AreSame(ctx, e.Context);
+        }
+
+        [TestMethod]
+        public void WordPredictionContextChangedEvent_CanBePublishedAndReceived()
+        {
+            var bus = new EventBus();
+            WordPredictionContextChangedEvent received = null;
+
+            bus.Subscribe<WordPredictionContextChangedEvent>(e => received = e);
+            bus.Publish(new WordPredictionContextChangedEvent(null));
+
+            Assert.IsNotNull(received);
+        }
+
         // -----------------------------------------------------------------------
         // Null guards
         // -----------------------------------------------------------------------

src/Libraries/ACATCore.Tests/EventBusTests.cs

@@ -248,6 +248,93 @@ public void ConfigurationChangedEvent_Properties_ArePreserved()
             Assert.Equal("Dark", e.NewValue);
         }
 
+        [Fact]
+        public void AppQuitEvent_ExtendsEventBase_HasTimestamp()
+        {
+            DateTime before = DateTime.UtcNow;
+            var e = new AppQuitEvent();
+            DateTime after = DateTime.UtcNow;
+
+            Assert.InRange(e.Timestamp, before, after);
+        }
+
+        [Fact]
+        public void AppQuitEvent_CanBePublishedAndReceived()
+        {
+            var bus = new EventBus();
+            AppQuitEvent received = null;
+
+            bus.Subscribe<AppQuitEvent>(e => received = e);
+            bus.Publish(new AppQuitEvent());
+
+            Assert.NotNull(received);
+        }
+
+        [Fact]
+        public void CalibrationEndEvent_ExtendsEventBase_HasTimestamp()
+        {
+            DateTime before = DateTime.UtcNow;
+            var e = new CalibrationEndEvent();
+            DateTime after = DateTime.UtcNow;
+
+            Assert.InRange(e.Timestamp, before, after);
+        }
+
+        [Fact]
+        public void CalibrationEndEvent_CanBePublishedAndReceived()
+        {
+            var bus = new EventBus();
+            CalibrationEndEvent received = null;
+
+            bus.Subscribe<CalibrationEndEvent>(e => received = e);
+            bus.Publish(new CalibrationEndEvent());
+
+            Assert.NotNull(received);
+        }
+
+        [Fact]
+        public void DisplaySettingsChangedEvent_ExtendsEventBase_HasTimestamp()
+        {
+            DateTime before = DateTime.UtcNow;
+            var e = new DisplaySettingsChangedEvent();
+            DateTime after = DateTime.UtcNow;
+
+            Assert.InRange(e.Timestamp, before, after);
+        }
+
+        [Fact]
+        public void DisplaySettingsChangedEvent_CanBePublishedAndReceived()
+        {
+            var bus = new EventBus();
+            DisplaySettingsChangedEvent received = null;
+
+            bus.Subscribe<DisplaySettingsChangedEvent>(e => received = e);
+            bus.Publish(new DisplaySettingsChangedEvent());
+
+            Assert.NotNull(received);
+        }
+
+        [Fact]
+        public void WordPredictionContextChangedEvent_Context_IsPreserved()
+        {
+            var ctx = new object();
+            var e = new WordPredictionContextChangedEvent(ctx);
+
+            Assert.Same(ctx, e.Context);
+        }
+
+        [Fact]
+        public void WordPredictionContextChangedEvent_CanBePublishedAndReceived()
+        {
+            var bus = new EventBus();
+            WordPredictionContextChangedEvent received = null;
+
+            bus.Subscribe<WordPredictionContextChangedEvent>(e => received = e);
+            bus.Publish(new WordPredictionContextChangedEvent(null));
+
+            Assert.NotNull(received);
+        }
+
         // ----------------------------------------------------------------
         // Helpers
         // ----------------------------------------------------------------

src/Libraries/ACATCore/ACAT.Core.csproj

@@ -571,6 +571,7 @@
     <Compile Include="EventManagement\EventBase.cs" />
     <Compile Include="EventManagement\IEventBus.cs" />
     <Compile Include="EventManagement\EventBus.cs" />
+    <Compile Include="EventManagement\ApplicationEvents.cs" />
     <Compile Include="EventManagement\PanelEvents.cs" />
     <Compile Include="EventManagement\AgentEvents.cs" />
     <Compile Include="EventManagement\ActuatorEvents.cs" />

src/Libraries/ACATCore/ActuatorManagement/ActuatorManager.cs

@@ -302,7 +302,16 @@ public bool Init(IEnumerable<String> extensionDirs)
 
             _initInProgress = false;
 
-            Context.AppPanelManager.EvtAppQuit += AppPanelManager_EvtAppQuit;
+            if (_eventBus != null)
+            {
+                // Prefer EventBus subscription (new pattern)
+                _eventBus.Subscribe<AppQuitEvent>(OnAppQuit);
+            }
+            else
+            {
+                // Fallback to legacy delegate when EventBus is not available
+                Context.AppPanelManager.EvtAppQuit += AppPanelManager_EvtAppQuit;
+            }
 
             return retVal;
         }
@@ -664,6 +673,7 @@ public void NotifyStartCalibration(CalibrationNotifyEventArgs args)
         public void NotifyEndCalibration()
         {
             EvtCalibrationEndNotify?.Invoke(this, new EventArgs());
+            _eventBus?.Publish(new CalibrationEndEvent());
         }
 
         public IActuator GetKeyboardActuator()
@@ -918,6 +928,17 @@ private void AppPanelManager_EvtAppQuit(object sender, EventArgs e)
             _actuators.OnAppQuit();
         }
 
+        /// <summary>
+        /// EventBus handler for when the application exits.
+        /// Replaces the legacy <see cref="AppPanelManager_EvtAppQuit"/> delegate subscription
+        /// when <see cref="IEventBus"/> is available.
+        /// </summary>
+        /// <param name="evt">The app quit event</param>
+        private void OnAppQuit(AppQuitEvent evt)
+        {
+            _actuators.OnAppQuit();
+        }
+
         /// <summary>
         /// Looks at the queue that has calibration requests and handles
         /// them in the order they were received

src/Libraries/ACATCore/EventManagement/ActuatorEvents.cs

@@ -31,4 +31,12 @@ public ActuatorSwitchActivatedEvent(string switchName)
         /// </summary>
         public string SwitchName { get; }
     }
+
+    /// <summary>
+    /// Published when actuator calibration ends.
+    /// Replaces the legacy <c>IActuatorManager.EvtCalibrationEndNotify</c> delegate.
+    /// </summary>
+    public class CalibrationEndEvent : EventBase
+    {
+    }
 }

src/Libraries/ACATCore/EventManagement/AgentEvents.cs

@@ -42,4 +42,27 @@ public AgentContextChangedEvent(string agentName, object context)
         /// </summary>
         public object Context { get; }
     }
+
+    /// <summary>
+    /// Published when the word prediction context changes.
+    /// Replaces the legacy word prediction context delegate.
+    /// </summary>
+    public class WordPredictionContextChangedEvent : EventBase
+    {
+        /// <summary>
+        /// Initializes a new instance of <see cref="WordPredictionContextChangedEvent"/>.
+        /// </summary>
+        /// <param name="context">
+        /// Application-defined context object (may be <c>null</c>).
+        /// </param>
+        public WordPredictionContextChangedEvent(object context)
+        {
+            Context = context;
+        }
+
+        /// <summary>
+        /// Gets the application-defined context object for the word prediction context.
+        /// </summary>
+        public object Context { get; }
+    }
 }

src/Libraries/ACATCore/EventManagement/ApplicationEvents.cs

@@ -0,0 +1,22 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright 2013-2019; 2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+//
+// ApplicationEvents.cs
+//
+// Event types for application lifecycle notifications (quit).
+//
+////////////////////////////////////////////////////////////////////////////
+
+namespace ACAT.Core.EventManagement
+{
+    /// <summary>
+    /// Published when the application is about to quit.
+    /// Replaces the legacy <c>IPanelManager.EvtAppQuit</c> delegate.
+    /// </summary>
+    public class AppQuitEvent : EventBase
+    {
+    }
+}

src/Libraries/ACATCore/EventManagement/PanelEvents.cs

@@ -71,4 +71,12 @@ public PanelActivateEvent(string panelClass)
         /// </summary>
         public string PanelClass { get; }
     }
+
+    /// <summary>
+    /// Published when the display settings (e.g. resolution) change.
+    /// Replaces the legacy <c>IPanelManager.EvtDisplaySettingsChanged</c> delegate.
+    /// </summary>
+    public class DisplaySettingsChangedEvent : EventBase
+    {
+    }
 }

src/Libraries/ACATCore/PanelManagement/PanelManager.cs

@@ -442,7 +442,16 @@ public bool Init(IEnumerable<string> extensionDirs)
             }
 
             Context.AppActuatorManager.EvtCalibrationStartNotify += AppActuatorManager_EvtCalibrationStartNotify;
-            Context.AppActuatorManager.EvtCalibrationEndNotify += AppActuatorManager_EvtCalibrationEndNotify;
+            if (_eventBus != null)
+            {
+                // Prefer EventBus subscription for CalibrationEnd (new pattern)
+                _eventBus.Subscribe<CalibrationEndEvent>(OnCalibrationEnd);
+            }
+            else
+            {
+                // Fallback to legacy delegate when EventBus is not available
+                Context.AppActuatorManager.EvtCalibrationEndNotify += AppActuatorManager_EvtCalibrationEndNotify;
+            }
             return retVal;
         }
 
@@ -587,6 +596,7 @@ internal void NotifyPanelPreShow(PanelPreShowEventArg arg)
         internal void NotifyQuitApplication()
         {
             EvtAppQuit?.Invoke(_instance, new EventArgs());
+            _eventBus?.Publish(new AppQuitEvent());
         }
 
         /// <summary>
@@ -637,6 +647,17 @@ private void AppActuatorManager_EvtCalibrationEndNotify(object sender, EventArgs
             //WindowActivityMonitor.GetActiveWindowAsync();
         }
 
+        /// <summary>
+        /// EventBus handler for calibration end.
+        /// Replaces the legacy <see cref="AppActuatorManager_EvtCalibrationEndNotify"/> delegate
+        /// subscription when <see cref="IEventBus"/> is available.
+        /// </summary>
+        /// <param name="evt">The calibration end event</param>
+        private void OnCalibrationEnd(CalibrationEndEvent evt)
+        {
+            AppActuatorManager_EvtCalibrationEndNotify(this, EventArgs.Empty);
+        }
+
         private void AppActuatorManager_EvtCalibrationStartNotify(ActuatorManagement.CalibrationNotifyEventArgs args)
         {
             _actuatorCalibrationInProgress = true;
@@ -772,6 +793,7 @@ private void SystemEvents_DisplaySettingsChanged(object sender, EventArgs e)
             _logger?.LogDebug("Display Resolution changed. Working area is {WorkingArea}", Screen.PrimaryScreen.WorkingArea);
 
             EvtDisplaySettingsChanged?.Invoke(sender, e);
+            _eventBus?.Publish(new DisplaySettingsChangedEvent());
         }
     }
 }