Replaced ReportTargetControllerState event with TC command and renamed TargetControllerStateReported event

src/DebugServer/Gdb/GdbRspDebugServer.cpp

@@ -37,6 +37,8 @@ namespace Bloom::DebugServer::Gdb
 
     using CommandPackets::CommandPacket;
 
+    using TargetController::TargetControllerState;
+
     GdbRspDebugServer::GdbRspDebugServer(
         const DebugServerConfig& debugServerConfig,
         EventListener& eventListener,
@@ -108,8 +110,8 @@ namespace Bloom::DebugServer::Gdb
         Logger::info("GDB RSP address: " + this->debugServerConfig.listeningAddress);
         Logger::info("GDB RSP port: " + std::to_string(this->debugServerConfig.listeningPortNumber));
 
-        this->eventListener.registerCallbackForEventType<Events::TargetControllerStateReported>(
+        this->eventListener.registerCallbackForEventType<Events::TargetControllerStateChanged>(
-            std::bind(&GdbRspDebugServer::onTargetControllerStateReported, this, std::placeholders::_1)
+            std::bind(&GdbRspDebugServer::onTargetControllerStateChanged, this, std::placeholders::_1)
         );
 
         this->eventListener.registerCallbackForEventType<Events::TargetExecutionStopped>(
@@ -293,12 +295,9 @@ namespace Bloom::DebugServer::Gdb
         EventManager::triggerEvent(std::make_shared<Events::DebugSessionFinished>());
     }
 
-    void GdbRspDebugServer::onTargetControllerStateReported(const Events::TargetControllerStateReported& event) {
+    void GdbRspDebugServer::onTargetControllerStateChanged(const Events::TargetControllerStateChanged& event) {
-        if (
+        if (event.state == TargetControllerState::SUSPENDED && this->activeDebugSession.has_value()) {
-            event.state == TargetController::TargetControllerState::SUSPENDED
+            Logger::warning("TargetController suspended unexpectedly - terminating debug session");
-            && this->activeDebugSession.has_value()
-        ) {
-            Logger::warning("Terminating debug session - TargetController suspended unexpectedly");
             this->terminateActiveDebugSession();
         }
     }

src/DebugServer/Gdb/GdbRspDebugServer.hpp

@@ -23,7 +23,7 @@
 #include "Feature.hpp"
 #include "CommandPackets/CommandPacket.hpp"
 
-#include "src/EventManager/Events/TargetControllerStateReported.hpp"
+#include "src/EventManager/Events/TargetControllerStateChanged.hpp"
 #include "src/EventManager/Events/TargetExecutionStopped.hpp"
 
 namespace Bloom::DebugServer::Gdb
@@ -186,7 +186,7 @@ namespace Bloom::DebugServer::Gdb
          *
          * @param event
          */
-        void onTargetControllerStateReported(const Events::TargetControllerStateReported& event);
+        void onTargetControllerStateChanged(const Events::TargetControllerStateChanged& event);
 
         /**
          * If the GDB client is currently waiting for the target execution to stop, this event handler will issue

src/EventManager/Events/Event.hpp

@@ -19,8 +19,7 @@ namespace Bloom::Events
         DEBUG_SESSION_STARTED,
         DEBUG_SESSION_FINISHED,
         TARGET_CONTROLLER_THREAD_STATE_CHANGED,
-        REPORT_TARGET_CONTROLLER_STATE,
+        TARGET_CONTROLLER_STATE_CHANGED,
-        TARGET_CONTROLLER_STATE_REPORTED,
         SHUTDOWN_TARGET_CONTROLLER,
         TARGET_CONTROLLER_ERROR_OCCURRED,
         SHUTDOWN_APPLICATION,

src/EventManager/Events/Events.hpp

@@ -6,8 +6,7 @@
 #include "DebugSessionStarted.hpp"
 #include "DebugSessionFinished.hpp"
 #include "TargetControllerThreadStateChanged.hpp"
-#include "ReportTargetControllerState.hpp"
+#include "TargetControllerStateChanged.hpp"
-#include "TargetControllerStateReported.hpp"
 #include "ShutdownTargetController.hpp"
 #include "TargetControllerErrorOccurred.hpp"
 #include "ShutdownApplication.hpp"

src/EventManager/Events/ReportTargetControllerState.hpp

@@ -1,28 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "Event.hpp"
-#include "TargetControllerStateReported.hpp"
-
-namespace Bloom::Events
-{
-    class ReportTargetControllerState: public Event
-    {
-    public:
-        using TargetControllerResponseType = TargetControllerStateReported;
-
-        static constexpr EventType type = EventType::REPORT_TARGET_CONTROLLER_STATE;
-        static inline const std::string name = "ReportTargetControllerState";
-
-        ReportTargetControllerState() {};
-
-        [[nodiscard]] EventType getType() const override {
-            return ReportTargetControllerState::type;
-        }
-
-        [[nodiscard]] std::string getName() const override {
-            return ReportTargetControllerState::name;
-        }
-    };
-}

src/EventManager/Events/TargetControllerStateChanged.hpp

@@ -7,21 +7,23 @@
 
 namespace Bloom::Events
 {
-    class TargetControllerStateReported: public Event
+    class TargetControllerStateChanged: public Event
     {
     public:
-        static constexpr EventType type = EventType::TARGET_CONTROLLER_STATE_REPORTED;
+        static constexpr EventType type = EventType::TARGET_CONTROLLER_STATE_CHANGED;
-        static inline const std::string name = "TargetControllerStateReported";
+        static inline const std::string name = "TargetControllerStateChanged";
 
         TargetController::TargetControllerState state;
-        explicit TargetControllerStateReported(TargetController::TargetControllerState state): state(state) {};
+        explicit TargetControllerStateChanged(TargetController::TargetControllerState state)
+            : state(state)
+        {};
 
         [[nodiscard]] EventType getType() const override {
-            return TargetControllerStateReported::type;
+            return TargetControllerStateChanged::type;
         }
 
         [[nodiscard]] std::string getName() const override {
-            return TargetControllerStateReported::name;
+            return TargetControllerStateChanged::name;
         }
     };
 }

src/Insight/InsightWorker/InsightWorker.cpp

@@ -3,7 +3,8 @@
 #include <QObject>
 #include <QTimer>
 
-#include "src/Helpers/Thread.hpp"
+#include "src/TargetController/TargetControllerState.hpp"
+
 #include "src/Logger/Logger.hpp"
 
 namespace Bloom
@@ -24,8 +25,8 @@ namespace Bloom
         Logger::debug("Starting InsightWorker thread");
         EventManager::registerListener(this->eventListener);
 
-        this->eventListener->registerCallbackForEventType<Events::TargetControllerStateReported>(
+        this->eventListener->registerCallbackForEventType<Events::TargetControllerStateChanged>(
-            std::bind(&InsightWorker::onTargetControllerStateReportedEvent, this, std::placeholders::_1)
+            std::bind(&InsightWorker::onTargetControllerStateChangedEvent, this, std::placeholders::_1)
         );
 
         this->eventListener->registerCallbackForEventType<Events::TargetExecutionStopped>(
@@ -125,19 +126,13 @@ namespace Bloom
         emit this->targetRegistersWritten(event.registers, event.createdTimestamp);
     }
 
-    void InsightWorker::onTargetControllerStateReportedEvent(const Events::TargetControllerStateReported& event) {
+    void InsightWorker::onTargetControllerStateChangedEvent(const Events::TargetControllerStateChanged& event) {
         using TargetController::TargetControllerState;
 
-        if (
+        if (event.state == TargetControllerState::SUSPENDED) {
-            this->lastTargetControllerState == TargetControllerState::ACTIVE
-            && event.state == TargetControllerState::SUSPENDED
-        ) {
             emit this->targetControllerSuspended();
 
-        } else if (
+        } else if (event.state == TargetControllerState::ACTIVE) {
-            this->lastTargetControllerState == TargetControllerState::SUSPENDED
-            && event.state == TargetControllerState::ACTIVE
-        ) {
             try {
                 emit this->targetControllerResumed(this->targetControllerConsole.getTargetDescriptor());
 
@@ -145,7 +140,6 @@ namespace Bloom
                 Logger::error("Insight resume failed - " + exception.getMessage());
             }
         }
-        this->lastTargetControllerState = event.state;
     }
 
     void InsightWorker::executeTasks() {

src/Insight/InsightWorker/InsightWorker.hpp

@@ -12,7 +12,6 @@
 #include "src/EventManager/Events/Events.hpp"
 
 #include "src/TargetController/TargetControllerConsole.hpp"
-#include "src/TargetController/TargetControllerState.hpp"
 
 #include "Tasks/InsightWorkerTask.hpp"
 
@@ -52,8 +51,6 @@ namespace Bloom
         TargetController::TargetControllerConsole targetControllerConsole = TargetController::TargetControllerConsole(
             *(this->eventListener)
         );
-        TargetController::TargetControllerState lastTargetControllerState =
-            TargetController::TargetControllerState::ACTIVE;
 
         Targets::TargetState lastTargetState = Targets::TargetState::UNKNOWN;
 
@@ -67,7 +64,7 @@ namespace Bloom
         void onTargetResumedEvent(const Events::TargetExecutionResumed& event);
         void onTargetResetEvent(const Events::TargetReset& event);
         void onTargetRegistersWrittenEvent(const Events::RegistersWrittenToTarget& event);
-        void onTargetControllerStateReportedEvent(const Events::TargetControllerStateReported& event);
+        void onTargetControllerStateChangedEvent(const Events::TargetControllerStateChanged& event);
 
         void executeTasks();
     };

src/TargetController/Commands/CommandTypes.hpp

@@ -7,6 +7,7 @@ namespace Bloom::TargetController::Commands
     enum class CommandType: std::uint8_t
     {
         GENERIC,
+        GET_TARGET_CONTROLLER_STATE,
         STOP_TARGET_EXECUTION,
         RESUME_TARGET_EXECUTION,
         RESET_TARGET,

src/TargetController/TargetControllerComponent.cpp

@@ -92,6 +92,10 @@ namespace Bloom::TargetController
         this->shutdown();
     }
 
+    TargetControllerState TargetControllerComponent::getState() {
+        return TargetControllerComponent::state;
+    }
+
     void TargetControllerComponent::registerCommand(std::unique_ptr<Command> command) {
         auto commandQueueLock = TargetControllerComponent::commandQueue.acquireLock();
         TargetControllerComponent::commandQueue.getValue().push(std::move(command));
@@ -149,10 +153,6 @@ namespace Bloom::TargetController
         TargetControllerComponent::checkUdevRules();
 
         // Register event handlers
-        this->eventListener->registerCallbackForEventType<Events::ReportTargetControllerState>(
-            std::bind(&TargetControllerComponent::onStateReportRequest, this, std::placeholders::_1)
-        );
-
         this->eventListener->registerCallbackForEventType<Events::ShutdownTargetController>(
             std::bind(&TargetControllerComponent::onShutdownTargetControllerEvent, this, std::placeholders::_1)
         );
@@ -400,8 +400,8 @@ namespace Bloom::TargetController
         this->registerDescriptorsByMemoryType.clear();
         this->registerAddressRangeByMemoryType.clear();
 
-        this->state = TargetControllerState::SUSPENDED;
+        TargetControllerComponent::state = TargetControllerState::SUSPENDED;
-        EventManager::triggerEvent(std::make_shared<TargetControllerStateReported>(this->state));
+        EventManager::triggerEvent(std::make_shared<TargetControllerStateChanged>(TargetControllerComponent::state));
 
         Logger::debug("TargetController suspended");
     }
@@ -478,9 +478,9 @@ namespace Bloom::TargetController
             std::bind(&TargetControllerComponent::onRetrieveStackPointerEvent, this, std::placeholders::_1)
         );
 
-        this->state = TargetControllerState::ACTIVE;
+        TargetControllerComponent::state = TargetControllerState::ACTIVE;
         EventManager::triggerEvent(
-            std::make_shared<TargetControllerStateReported>(this->state)
+            std::make_shared<TargetControllerStateChanged>(TargetControllerComponent::state)
         );
 
         if (this->target->getState() != TargetState::RUNNING) {
@@ -692,12 +692,6 @@ namespace Bloom::TargetController
         this->shutdown();
     }
 
-    void TargetControllerComponent::onStateReportRequest(const Events::ReportTargetControllerState& event) {
-        auto stateEvent = std::make_shared<Events::TargetControllerStateReported>(this->state);
-        stateEvent->correlationId = event.id;
-        EventManager::triggerEvent(stateEvent);
-    }
-
     void TargetControllerComponent::onExtractTargetDescriptor(const Events::ExtractTargetDescriptor& event) {
         auto targetDescriptorExtracted = std::make_shared<TargetDescriptorExtracted>();
         targetDescriptorExtracted->targetDescriptor = this->getTargetDescriptor();
@@ -707,7 +701,7 @@ namespace Bloom::TargetController
     }
 
     void TargetControllerComponent::onDebugSessionStartedEvent(const Events::DebugSessionStarted&) {
-        if (this->state == TargetControllerState::SUSPENDED) {
+        if (TargetControllerComponent::state == TargetControllerState::SUSPENDED) {
             Logger::debug("Waking TargetController");
 
             this->resume();

src/TargetController/TargetControllerComponent.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <atomic>
 #include <memory>
 #include <queue>
 #include <condition_variable>
@@ -43,6 +44,8 @@
 
 namespace Bloom::TargetController
 {
+    static_assert(std::atomic<TargetControllerState>::is_always_lock_free);
+
     /**
      * The TargetController possesses full control of the debugging target and the debug tool.
      *
@@ -65,6 +68,8 @@ namespace Bloom::TargetController
          */
         void run();
 
+        static TargetControllerState getState();
+
         static void registerCommand(std::unique_ptr<Commands::Command> command);
 
         static std::optional<std::unique_ptr<Responses::Response>> waitForResponse(
@@ -88,7 +93,7 @@ namespace Bloom::TargetController
          * The TC starts off in a suspended state. TargetControllerComponent::resume() is invoked from the startup
          * routine.
          */
-        TargetControllerState state = TargetControllerState::SUSPENDED;
+        static inline std::atomic<TargetControllerState> state = TargetControllerState::SUSPENDED;
 
         ProjectConfig projectConfig;
         EnvironmentConfig environmentConfig;
@@ -265,13 +270,6 @@ namespace Bloom::TargetController
          */
         void onShutdownTargetControllerEvent(const Events::ShutdownTargetController& event);
 
-        /**
-         * Reports the current state of the TargetController.
-         *
-         * @param event
-         */
-        void onStateReportRequest(const Events::ReportTargetControllerState& event);
-
         /**
          * Obtains a TargetDescriptor from the target and includes it in a TargetDescriptorExtracted event.
          *

src/TargetController/TargetControllerConsole.cpp

@@ -2,6 +2,8 @@
 
 #include "src/EventManager/Events/Events.hpp"
 
+#include "TargetControllerComponent.hpp"
+
 // Commands
 #include "Commands/StopTargetExecution.hpp"
 #include "Commands/ResumeTargetExecution.hpp"
@@ -30,9 +32,7 @@ namespace Bloom::TargetController
     {}
 
     TargetControllerState TargetControllerConsole::getTargetControllerState() {
-        return this->triggerTargetControllerEventAndWaitForResponse(
+        return TargetControllerComponent::getState();
-            std::make_shared<ReportTargetControllerState>()
-        )->state;
     }
 
     bool TargetControllerConsole::isTargetControllerInService() noexcept {