upload mutimodal

components/CommandManager/CommandManager/commands/device_commands.cpp

@@ -2,6 +2,8 @@
 
 #include <cJSON.h>
 #include <ProjectConfig.hpp>
+#include "esp_timer.h"
+#include <main_globals.hpp>
 
 // Implementation inspired by SummerSigh work, initial PR opened in openiris repo, adapted to this rewrite
 CommandResult setDeviceModeCommand(std::shared_ptr<DependencyRegistry> registry, std::string_view jsonPayload) {
@@ -64,3 +66,66 @@ CommandResult restartDeviceCommand() {
     OpenIrisTasks::ScheduleRestart(2000);
     return CommandResult::getSuccessResult("Device restarted");
 }
+
+CommandResult startStreamingCommand() {
+    activateStreaming(false); // Don't disable setup interfaces by default
+    return CommandResult::getSuccessResult("Streaming started");
+}
+
+CommandResult switchModeCommand(std::shared_ptr<DependencyRegistry> registry, std::string_view jsonPayload) {
+    const auto parsedJson = cJSON_Parse(jsonPayload.data());
+    if (parsedJson == nullptr) {
+        return CommandResult::getErrorResult("Invalid payload");
+    }
+
+    const auto modeObject = cJSON_GetObjectItem(parsedJson, "mode");
+    if (modeObject == nullptr) {
+        return CommandResult::getErrorResult("Invalid payload - missing mode");
+    }
+
+    const char* modeStr = modeObject->valuestring;
+    StreamingMode newMode;
+    
+    ESP_LOGI("[DEVICE_COMMANDS]", "Switch mode command received with mode: %s", modeStr);
+    
+    if (strcmp(modeStr, "uvc") == 0 || strcmp(modeStr, "UVC") == 0) {
+        newMode = StreamingMode::UVC;
+    } else if (strcmp(modeStr, "wifi") == 0 || strcmp(modeStr, "WiFi") == 0 || strcmp(modeStr, "WIFI") == 0) {
+        newMode = StreamingMode::WIFI;
+    } else if (strcmp(modeStr, "auto") == 0 || strcmp(modeStr, "AUTO") == 0) {
+        newMode = StreamingMode::AUTO;
+    } else {
+        return CommandResult::getErrorResult("Invalid mode - use 'uvc', 'wifi', or 'auto'");
+    }
+
+    const auto projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
+    ESP_LOGI("[DEVICE_COMMANDS]", "Setting device mode to: %d", (int)newMode);
+    projectConfig->setDeviceMode(newMode);
+    
+    cJSON_Delete(parsedJson);
+
+    return CommandResult::getSuccessResult("Device mode switched, restart to apply");
+}
+
+CommandResult getDeviceModeCommand(std::shared_ptr<DependencyRegistry> registry) {
+    const auto projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
+    StreamingMode currentMode = projectConfig->getDeviceMode();
+    
+    const char* modeStr = "unknown";
+    switch (currentMode) {
+        case StreamingMode::UVC:
+            modeStr = "UVC";
+            break;
+        case StreamingMode::WIFI:
+            modeStr = "WiFi";
+            break;
+        case StreamingMode::AUTO:
+            modeStr = "Auto";
+            break;
+    }
+    
+    char result[100];
+    sprintf(result, "{\"mode\":\"%s\",\"value\":%d}", modeStr, (int)currentMode);
+    
+    return CommandResult::getSuccessResult(result);
+}

components/CommandManager/CommandManager/commands/device_commands.hpp

@@ -6,4 +6,10 @@ CommandResult setDeviceModeCommand(std::shared_ptr<DependencyRegistry> registry,
 
 CommandResult updateOTACredentialsCommand(std::shared_ptr<DependencyRegistry> registry, std::string_view jsonPayload);
 
-CommandResult restartDeviceCommand();
+CommandResult restartDeviceCommand();
+
+CommandResult startStreamingCommand();
+
+CommandResult switchModeCommand(std::shared_ptr<DependencyRegistry> registry, std::string_view jsonPayload);
+
+CommandResult getDeviceModeCommand(std::shared_ptr<DependencyRegistry> registry);

components/CommandManager/CommandManager/commands/scan_commands.cpp

@@ -0,0 +1,38 @@
+#include "scan_commands.hpp"
+#include "cJSON.h"
+#include "esp_log.h"
+#include <string>
+
+CommandResult scanNetworksCommand(std::shared_ptr<DependencyRegistry> registry) {
+    auto wifiManager = registry->resolve<WiFiManager>(DependencyType::wifi_manager);
+    if (!wifiManager) {
+        return CommandResult::getErrorResult("WiFiManager not available");
+    }
+
+    auto networks = wifiManager->ScanNetworks();
+
+    cJSON *root = cJSON_CreateObject();
+    cJSON *networksArray = cJSON_CreateArray();
+    cJSON_AddItemToObject(root, "networks", networksArray);
+
+    for (const auto& network : networks) {
+        cJSON *networkObject = cJSON_CreateObject();
+        cJSON_AddStringToObject(networkObject, "ssid", network.ssid.c_str());
+        cJSON_AddNumberToObject(networkObject, "channel", network.channel);
+        cJSON_AddNumberToObject(networkObject, "rssi", network.rssi);
+        char mac_str[18];
+        sprintf(mac_str, "%02x:%02x:%02x:%02x:%02x:%02x",
+                network.mac[0], network.mac[1], network.mac[2],
+                network.mac[3], network.mac[4], network.mac[5]);
+        cJSON_AddStringToObject(networkObject, "mac_address", mac_str);
+        cJSON_AddNumberToObject(networkObject, "auth_mode", network.auth_mode);
+        cJSON_AddItemToArray(networksArray, networkObject);
+    }
+
+    char *json_string = cJSON_PrintUnformatted(root);
+    printf("%s\n", json_string);
+    cJSON_Delete(root);
+    free(json_string);
+
+    return CommandResult::getSuccessResult("Networks scanned");
+}

components/CommandManager/CommandManager/commands/scan_commands.hpp

@@ -0,0 +1,10 @@
+#ifndef SCAN_COMMANDS_HPP
+#define SCAN_COMMANDS_HPP
+
+#include "../CommandResult.hpp"
+#include "../DependencyRegistry.hpp"
+#include <wifiManager.hpp>
+
+CommandResult scanNetworksCommand(std::shared_ptr<DependencyRegistry> registry);
+
+#endif

components/CommandManager/CommandManager/commands/simple_commands.cpp

@@ -1,6 +1,25 @@
 #include "simple_commands.hpp"
+#include "main_globals.hpp"
+#include "esp_log.h"
+
+static const char* TAG = "SimpleCommands";
 
 CommandResult PingCommand()
 {
   return CommandResult::getSuccessResult("pong");
 };
+
+CommandResult PauseCommand(const PausePayload& payload)
+{
+  ESP_LOGI(TAG, "Pause command received: %s", payload.pause ? "true" : "false");
+  
+  startupPaused = payload.pause;
+  
+  if (payload.pause) {
+    ESP_LOGI(TAG, "Startup paused - device will remain in configuration mode");
+    return CommandResult::getSuccessResult("Startup paused");
+  } else {
+    ESP_LOGI(TAG, "Startup resumed");
+    return CommandResult::getSuccessResult("Startup resumed");
+  }
+};

components/CommandManager/CommandManager/commands/simple_commands.hpp

@@ -3,7 +3,9 @@
 
 #include <string>
 #include "CommandResult.hpp"
+#include "CommandSchema.hpp"
 
 CommandResult PingCommand();
+CommandResult PauseCommand(const PausePayload& payload);
 
 #endif

components/CommandManager/CommandManager/commands/wifi_commands.cpp

@@ -1,4 +1,5 @@
 #include "wifi_commands.hpp"
+#include "esp_netif.h"
 
 std::optional<WifiPayload> parseSetWiFiCommandPayload(std::string_view jsonPayload)
 {
@@ -223,3 +224,79 @@ CommandResult updateAPWiFiCommand(std::shared_ptr<DependencyRegistry> registry,
 
   return CommandResult::getSuccessResult("Config updated");
 }
+
+CommandResult getWiFiStatusCommand(std::shared_ptr<DependencyRegistry> registry) {
+    auto wifiManager = registry->resolve<WiFiManager>(DependencyType::wifi_manager);
+    auto projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
+    
+    // Get current WiFi state
+    auto wifiState = wifiManager->GetCurrentWiFiState();
+    auto networks = projectConfig->getWifiConfigs();
+    
+    cJSON* statusJson = cJSON_CreateObject();
+    
+    // Add WiFi state
+    const char* stateStr = "unknown";
+    switch(wifiState) {
+        case WiFiState_e::WiFiState_NotInitialized:
+            stateStr = "not_initialized";
+            break;
+        case WiFiState_e::WiFiState_Initialized:
+            stateStr = "initialized";
+            break;
+        case WiFiState_e::WiFiState_ReadyToConnect:
+            stateStr = "ready";
+            break;
+        case WiFiState_e::WiFiState_Connecting:
+            stateStr = "connecting";
+            break;
+        case WiFiState_e::WiFiState_WaitingForIp:
+            stateStr = "waiting_for_ip";
+            break;
+        case WiFiState_e::WiFiState_Connected:
+            stateStr = "connected";
+            break;
+        case WiFiState_e::WiFiState_Disconnected:
+            stateStr = "disconnected";
+            break;
+        case WiFiState_e::WiFiState_Error:
+            stateStr = "error";
+            break;
+    }
+    cJSON_AddStringToObject(statusJson, "status", stateStr);
+    cJSON_AddNumberToObject(statusJson, "networks_configured", networks.size());
+    
+    // Add IP info if connected
+    if (wifiState == WiFiState_e::WiFiState_Connected) {
+        // Get IP address from ESP32
+        esp_netif_ip_info_t ip_info;
+        esp_netif_t* netif = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
+        if (netif && esp_netif_get_ip_info(netif, &ip_info) == ESP_OK) {
+            char ip_str[16];
+            sprintf(ip_str, IPSTR, IP2STR(&ip_info.ip));
+            cJSON_AddStringToObject(statusJson, "ip_address", ip_str);
+        }
+    }
+    
+    char* statusString = cJSON_PrintUnformatted(statusJson);
+    std::string result(statusString);
+    free(statusString);
+    cJSON_Delete(statusJson);
+    
+    return CommandResult::getSuccessResult(result);
+}
+
+CommandResult connectWiFiCommand(std::shared_ptr<DependencyRegistry> registry) {
+    auto wifiManager = registry->resolve<WiFiManager>(DependencyType::wifi_manager);
+    auto projectConfig = registry->resolve<ProjectConfig>(DependencyType::project_config);
+    
+    auto networks = projectConfig->getWifiConfigs();
+    if (networks.empty()) {
+        return CommandResult::getErrorResult("No WiFi networks configured");
+    }
+    
+    // Trigger WiFi connection attempt
+    wifiManager->TryConnectToStoredNetworks();
+    
+    return CommandResult::getSuccessResult("WiFi connection attempt started");
+}

components/CommandManager/CommandManager/commands/wifi_commands.hpp

@@ -1,4 +1,6 @@
 #include <ProjectConfig.hpp>
+#include <wifiManager.hpp>
+#include <StateManager.hpp>
 #include <memory>
 #include <string>
 #include <optional>
@@ -18,3 +20,6 @@ CommandResult updateWiFiCommand(std::shared_ptr<DependencyRegistry> registry, st
 
 std::optional<UpdateAPWiFiPayload> parseUpdateAPWiFiCommandPayload(std::string_view jsonPayload);
 CommandResult updateAPWiFiCommand(std::shared_ptr<DependencyRegistry> registry, std::string_view jsonPayload);
+
+CommandResult getWiFiStatusCommand(std::shared_ptr<DependencyRegistry> registry);
+CommandResult connectWiFiCommand(std::shared_ptr<DependencyRegistry> registry);