Reformat project using clang-format

components/StateManager/StateManager/StateManager.cpp

@@ -4,100 +4,99 @@ StateManager::StateManager(QueueHandle_t eventQueue, QueueHandle_t ledStateQueue
 
 void StateManager::HandleUpdateState()
 {
-  SystemEvent eventBuffer;
-  auto ledStreamState = LEDStates_e::LedStateNone;
+    SystemEvent eventBuffer;
+    auto ledStreamState = LEDStates_e::LedStateNone;
 
-  if (xQueueReceive(this->eventQueue, &eventBuffer, portMAX_DELAY))
-  {
-    switch (eventBuffer.source)
+    if (xQueueReceive(this->eventQueue, &eventBuffer, portMAX_DELAY))
     {
+        switch (eventBuffer.source)
+        {
+        case EventSource::WIFI:
+        {
+            this->wifi_state = std::get<WiFiState_e>(eventBuffer.value);
 
-    case EventSource::WIFI:
-    {
-      this->wifi_state = std::get<WiFiState_e>(eventBuffer.value);
+            if (this->wifi_state == WiFiState_e::WiFiState_Connecting)
+            {
+                ledStreamState = LEDStates_e::WiFiStateConnecting;
+                xQueueSend(this->ledStateQueue, &ledStreamState, 10);
+            }
+            if (this->wifi_state == WiFiState_e::WiFiState_Connected)
+            {
+                ledStreamState = LEDStates_e::WiFiStateConnected;
+                xQueueSend(this->ledStateQueue, &ledStreamState, 10);
+            }
+            if (this->wifi_state == WiFiState_e::WiFiState_Error)
+            {
+                ledStreamState = LEDStates_e::WiFiStateError;
+                xQueueSend(this->ledStateQueue, &ledStreamState, 10);
+            }
 
-      if (this->wifi_state == WiFiState_e::WiFiState_Connecting)
-      {
-        ledStreamState = LEDStates_e::WiFiStateConnecting;
-        xQueueSend(this->ledStateQueue, &ledStreamState, 10);
-      }
-      if (this->wifi_state == WiFiState_e::WiFiState_Connected)
-      {
-        ledStreamState = LEDStates_e::WiFiStateConnected;
-        xQueueSend(this->ledStateQueue, &ledStreamState, 10);
-      }
-      if (this->wifi_state == WiFiState_e::WiFiState_Error)
-      {
-        ledStreamState = LEDStates_e::WiFiStateError;
-        xQueueSend(this->ledStateQueue, &ledStreamState, 10);
-      }
+            break;
+        }
 
-      break;
+        case EventSource::MDNS:
+        {
+            this->mdns_state = std::get<MDNSState_e>(eventBuffer.value);
+            break;
+        }
+
+        case EventSource::CAMERA:
+        {
+            this->camera_state = std::get<CameraState_e>(eventBuffer.value);
+
+            if (this->camera_state == CameraState_e::Camera_Error)
+            {
+                ledStreamState = LEDStates_e::CameraError;
+                xQueueSend(this->ledStateQueue, &ledStreamState, 10);
+            }
+
+            break;
+        }
+
+        case EventSource::STREAM:
+        {
+            this->stream_state = std::get<StreamState_e>(eventBuffer.value);
+
+            if (this->stream_state == StreamState_e::Stream_ON)
+            {
+                ledStreamState = LEDStates_e::LedStateStreaming;
+                xQueueSend(this->ledStateQueue, &ledStreamState, 10);
+            }
+            else if (this->stream_state == StreamState_e::Stream_OFF)
+            {
+                ledStreamState = LEDStates_e::LedStateStoppedStreaming;
+                xQueueSend(this->ledStateQueue, &ledStreamState, 10);
+            }
+            break;
+        }
+
+        default:
+            break;
+        }
     }
-
-    case EventSource::MDNS:
-    {
-      this->mdns_state = std::get<MDNSState_e>(eventBuffer.value);
-      break;
-    }
-
-    case EventSource::CAMERA:
-    {
-      this->camera_state = std::get<CameraState_e>(eventBuffer.value);
-
-      if (this->camera_state == CameraState_e::Camera_Error)
-      {
-        ledStreamState = LEDStates_e::CameraError;
-        xQueueSend(this->ledStateQueue, &ledStreamState, 10);
-      }
-
-      break;
-    }
-
-    case EventSource::STREAM:
-    {
-      this->stream_state = std::get<StreamState_e>(eventBuffer.value);
-
-      if (this->stream_state == StreamState_e::Stream_ON)
-      {
-        ledStreamState = LEDStates_e::LedStateStreaming;
-        xQueueSend(this->ledStateQueue, &ledStreamState, 10);
-      }
-      else if (this->stream_state == StreamState_e::Stream_OFF)
-      {
-        ledStreamState = LEDStates_e::LedStateStoppedStreaming;
-        xQueueSend(this->ledStateQueue, &ledStreamState, 10);
-      }
-      break;
-    }
-
-    default:
-      break;
-    }
-  }
 }
 
 WiFiState_e StateManager::GetWifiState()
 {
-  return this->wifi_state;
+    return this->wifi_state;
 }
 
 CameraState_e StateManager::GetCameraState()
 {
-  return this->camera_state;
+    return this->camera_state;
 }
 
 QueueHandle_t StateManager::GetEventQueue() const
 {
-  return this->eventQueue;
+    return this->eventQueue;
 }
 
-void HandleStateManagerTask(void *pvParameters)
+void HandleStateManagerTask(void* pvParameters)
 {
-  auto *stateManager = static_cast<StateManager *>(pvParameters);
+    auto* stateManager = static_cast<StateManager*>(pvParameters);
 
-  while (true)
-  {
-    stateManager->HandleUpdateState();
-  }
+    while (true)
+    {
+        stateManager->HandleUpdateState();
+    }
 }

components/StateManager/StateManager/StateManager.hpp

@@ -10,93 +10,93 @@
 // Naming kept stable for existing queues; documented meanings added.
 enum class LEDStates_e
 {
-  LedStateNone,           // Idle / no indication (LED off)
-  LedStateStreaming,      // Active streaming (UVC or WiFi) – steady ON
-  LedStateStoppedStreaming, // Streaming stopped intentionally – steady OFF (could differentiate later)
-  CameraError,            // Camera init / runtime failure – double blink pattern
-  WiFiStateError,         // WiFi connection error – distinctive blink sequence
-  WiFiStateConnecting,    // WiFi association / DHCP pending – slow blink
-  WiFiStateConnected      // WiFi connected (momentary confirmation burst)
+    LedStateNone,              // Idle / no indication (LED off)
+    LedStateStreaming,         // Active streaming (UVC or WiFi) - steady ON
+    LedStateStoppedStreaming,  // Streaming stopped intentionally - steady OFF (could differentiate later)
+    CameraError,               // Camera init / runtime failure - double blink pattern
+    WiFiStateError,            // WiFi connection error - distinctive blink sequence
+    WiFiStateConnecting,       // WiFi association / DHCP pending - slow blink
+    WiFiStateConnected         // WiFi connected (momentary confirmation burst)
 };
 
 enum class WiFiState_e
 {
-  WiFiState_NotInitialized,
-  WiFiState_Initialized,
-  WiFiState_ReadyToConnect,
-  WiFiState_Connecting,
-  WiFiState_WaitingForIp,
-  WiFiState_Connected,
-  WiFiState_Disconnected,
-  WiFiState_Error
+    WiFiState_NotInitialized,
+    WiFiState_Initialized,
+    WiFiState_ReadyToConnect,
+    WiFiState_Connecting,
+    WiFiState_WaitingForIp,
+    WiFiState_Connected,
+    WiFiState_Disconnected,
+    WiFiState_Error
 };
 
 enum class MDNSState_e
 {
-  MDNSState_Stopped,
-  MDNSState_Starting,
-  MDNSState_Started,
-  MDNSState_Stopping,
-  MDNSState_Error,
-  MDNSState_QueryStarted,
-  MDNSState_QueryComplete
+    MDNSState_Stopped,
+    MDNSState_Starting,
+    MDNSState_Started,
+    MDNSState_Stopping,
+    MDNSState_Error,
+    MDNSState_QueryStarted,
+    MDNSState_QueryComplete
 };
 
 enum class CameraState_e
 {
-  Camera_Disconnected,
-  Camera_Success,
-  Camera_Error
+    Camera_Disconnected,
+    Camera_Success,
+    Camera_Error
 };
 
 enum class StreamState_e
 {
-  Stream_OFF,
-  Stream_ON,
+    Stream_OFF,
+    Stream_ON,
 };
 
 enum class EventSource
 {
-  WIFI,
-  MDNS,
-  CAMERA,
-  STREAM
+    WIFI,
+    MDNS,
+    CAMERA,
+    STREAM
 };
 
 struct SystemEvent
 {
-  EventSource source;
-  std::variant<WiFiState_e, MDNSState_e, CameraState_e, StreamState_e> value;
+    EventSource source;
+    std::variant<WiFiState_e, MDNSState_e, CameraState_e, StreamState_e> value;
 };
 
 class StateManager
 {
-public:
-  StateManager(QueueHandle_t eventQueue, QueueHandle_t ledStateQueue);
-  void HandleUpdateState();
-  WiFiState_e GetWifiState();
-  CameraState_e GetCameraState();
-  QueueHandle_t GetEventQueue() const;
+   public:
+    StateManager(QueueHandle_t eventQueue, QueueHandle_t ledStateQueue);
+    void HandleUpdateState();
+    WiFiState_e GetWifiState();
+    CameraState_e GetCameraState();
+    QueueHandle_t GetEventQueue() const;
 
-private:
-  QueueHandle_t eventQueue;
-  QueueHandle_t ledStateQueue;
+   private:
+    QueueHandle_t eventQueue;
+    QueueHandle_t ledStateQueue;
 
-  WiFiState_e wifi_state;
-  MDNSState_e mdns_state;
-  CameraState_e camera_state;
-  StreamState_e stream_state;
+    WiFiState_e wifi_state;
+    MDNSState_e mdns_state;
+    CameraState_e camera_state;
+    StreamState_e stream_state;
 };
 
 // Lightweight helper to publish stream state changes to the shared event queue.
 static inline bool SendStreamEvent(QueueHandle_t queue, StreamState_e state)
 {
-  if (!queue)
-    return false;
-  SystemEvent evt{EventSource::STREAM, state};
-  return xQueueSend(queue, &evt, 0) == pdTRUE;
+    if (!queue)
+        return false;
+    SystemEvent evt{EventSource::STREAM, state};
+    return xQueueSend(queue, &evt, 0) == pdTRUE;
 }
 
-void HandleStateManagerTask(void *pvParameters);
+void HandleStateManagerTask(void* pvParameters);
 
-#endif // STATEMANAGER_HPP
+#endif  // STATEMANAGER_HPP