chore(sec_touch): use c++ code to support ESPHOME 2025.11.0

Author: distante

components/sec_touch/fan/_fan_mode.cpp

@@ -2,8 +2,8 @@
 #include "_fan_mode.h"
 #include "vector"
 
-// Define the global static FanModeMap that is shared across all fans
-static const std::unordered_map<FanModeEnum::FanMode, FanModeEnum::FanModeData> FanModeMap = {
+// Define the global static FanModeList that preserves the intended order
+static const std::vector<std::pair<FanModeEnum::FanMode, FanModeEnum::FanModeData>> FanModeList = {
     {FanModeEnum::FanMode::NORMAL, {"Normal", 0, 6}},
     {FanModeEnum::FanMode::BURST, {"Burst", 7, esphome::nullopt}},
     {FanModeEnum::FanMode::AUTOMATIC_HUMIDITY, {"Automatic Humidity", 8, esphome::nullopt}},
@@ -12,39 +12,42 @@ static const std::unordered_map<FanModeEnum::FanMode, FanModeEnum::FanModeData>
     {FanModeEnum::FanMode::SLEEP, {"Sleep", 11, esphome::nullopt}},
 };
 
-// Static function to get a reference to the FanModeMap
-const std::unordered_map<FanModeEnum::FanMode, FanModeEnum::FanModeData> &FanModeEnum::getFanModeMap() {
-  return FanModeMap;
+// Static function to get a reference to the FanModeList
+const std::vector<std::pair<FanModeEnum::FanMode, FanModeEnum::FanModeData>> &FanModeEnum::getFanModeList() {
+  return FanModeList;
 }
 
 // Convert FanMode to string
 std::string_view FanModeEnum::to_string(FanMode mode) {
-  auto it = getFanModeMap().find(mode);
-  return (it != getFanModeMap().end()) ? it->second.str : "Unknown-Error-Mode";
+  for (const auto &pair : getFanModeList()) {
+    if (pair.first == mode)
+      return pair.second.str;
+  }
+  return "Unknown-Error-Mode";
 }
 
 // Convert string to FanMode
 esphome::optional<FanModeEnum::FanMode> FanModeEnum::from_string(std::string_view str) {
-  for (const auto &pair : getFanModeMap()) {
+  for (const auto &pair : getFanModeList()) {
     if (pair.second.str == str) {
       return pair.first;  // Return the FanMode (key)
     }
   }
   return esphome::nullopt;
 }
 
-// Get a list of string values dynamically from the map
+// Get a list of string values dynamically from the list
 std::vector<std::string_view> FanModeEnum::getStringValues() {
   std::vector<std::string_view> values;
-  for (const auto &pair : getFanModeMap()) {
+  for (const auto &pair : getFanModeList()) {
     values.push_back(pair.second.str);
   }
   return values;
 }
 
 FanModeEnum::FanMode FanModeEnum::get_fan_mode_fromSpeed(int speed) {
-  // Iterate through FanModeMap to find the correct FanMode based on speed
-  for (const auto &pair : getFanModeMap()) {
+  // Iterate through FanModeList to find the correct FanMode based on speed
+  for (const auto &pair : getFanModeList()) {
     const FanModeData &data = pair.second;
 
     // Check if speed is within the range
@@ -53,8 +56,14 @@ FanModeEnum::FanMode FanModeEnum::get_fan_mode_fromSpeed(int speed) {
     }
   }
 
-  // Return an invalid mode if no matching FanMode is found
+  // Return default mode if no matching FanMode is found
   return FanMode::NORMAL;  // Default or error mode
 }
 
-int FanModeEnum::get_start_speed(FanMode mode) { return getFanModeMap().at(mode).start_speed; }
+int FanModeEnum::get_start_speed(FanMode mode) {
+  for (const auto &pair : getFanModeList()) {
+    if (pair.first == mode)
+      return pair.second.start_speed;
+  }
+  return 0;
+}

components/sec_touch/fan/_fan_mode.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include <unordered_map>
+#include <vector>
 #include <string_view>
+#include <utility>
 #include "esphome/core/optional.h"
-#include "vector"
 
 class FanModeEnum {
  public:
@@ -16,16 +16,16 @@ class FanModeEnum {
     esphome::optional<int> end_speed;
   };
 
-  // Static function to get the FanModeMap
-  static const std::unordered_map<FanMode, FanModeData> &getFanModeMap();
+  // Static function to get the FanMode list (preserves order)
+  static const std::vector<std::pair<FanMode, FanModeData>> &getFanModeList();
 
   // Convert FanMode to string
   static std::string_view to_string(FanMode mode);
 
   // Convert string to FanMode
   static esphome::optional<FanMode> from_string(std::string_view str);
 
-  // Get a list of string values dynamically from the map
+  // Get a list of string values dynamically from the list
   static std::vector<std::string_view> getStringValues();
 
   static FanMode get_fan_mode_fromSpeed(int speed);

components/sec_touch/fan/sec_touch_fan.cpp

@@ -18,17 +18,20 @@ SecTouchFan::SecTouchFan(SECTouchComponent *parent, int level_id, int label_id)
     std::string_view mode_from_hardware_str = FanModeEnum::to_string(mode_from_hardware);
 
     bool needs_preset_publish = false;
-    if (this->preset_mode != mode_from_hardware_str) {
+    const char *current_preset = this->get_preset_mode();
+    if (current_preset == nullptr || std::string_view(current_preset) != mode_from_hardware_str) {
       ESP_LOGD(TAG, "Preset mode changed to %s", mode_from_hardware_str.data());
-      this->preset_mode = std::string(mode_from_hardware_str);
+      // set_preset_mode_ will validate and store a pointer into traits
+      this->set_preset_mode_(std::string(mode_from_hardware_str));
       needs_preset_publish = true;
     }
 
     bool need_speed_publish = this->assign_new_speed_if_needed(real_speed_from_device);
 
     if (!need_speed_publish && !needs_preset_publish) {
+      const char *log_p = this->get_preset_mode() ? this->get_preset_mode() : "Unknown";
       ESP_LOGD(TAG, "No update needed for fan with property_id %d (state %d) (speed %d)(preset %s)", property_id,
-               this->state, this->speed, this->preset_mode.c_str());
+               this->state, this->speed, log_p);
       return;
     }
 
@@ -107,11 +110,15 @@ void SecTouchFan::control(const fan::FanCall &call) {
   ESP_LOGD(TAG, "Control called");
 
   bool new_preset_found = false;
-  if (!call.get_preset_mode().empty()) {
-    if (call.get_preset_mode() != this->preset_mode) {
-      this->preset_mode = call.get_preset_mode();
+  if (call.has_preset_mode()) {
+    const char *pm = call.get_preset_mode();
+    const char *current = this->get_preset_mode();
+    if (current == nullptr || strcmp(pm, current) != 0) {
+      // Store the preset mode (validates and points into traits)
+      this->set_preset_mode_(pm);
       new_preset_found = true;
-      ESP_LOGI("SecTouchFan", "NEW Fan preset mode: %s", this->preset_mode.c_str());
+      const char *logged = this->get_preset_mode() ? this->get_preset_mode() : pm;
+      ESP_LOGI("SecTouchFan", "NEW Fan preset mode: %s", logged);
     }
   }
 
@@ -157,16 +164,17 @@ void SecTouchFan::control(const fan::FanCall &call) {
 
   // ON
   if (new_preset_found) {
-    FanModeEnum::FanMode calculated_mode =
-        FanModeEnum::from_string(this->preset_mode).value_or(FanModeEnum::FanMode::NORMAL);
+    const char *current = this->get_preset_mode();
+    std::string_view cur_sv = current ? std::string_view(current) : std::string_view("");
+    FanModeEnum::FanMode calculated_mode = FanModeEnum::from_string(cur_sv).value_or(FanModeEnum::FanMode::NORMAL);
     if (calculated_mode == FanModeEnum::FanMode::NORMAL) {
       this->speed = 1;
     } else {
       this->speed = FanModeEnum::get_start_speed(calculated_mode);
     }
   }
-
-  ESP_LOGI(TAG, "[Update for %d] - [%s] speed: %d", this->level_id, this->preset_mode.c_str(), this->speed);
+  const char *log_preset = this->get_preset_mode() ? this->get_preset_mode() : "Unknown";
+  ESP_LOGI(TAG, "[Update for %d] - [%s] speed: %d", this->level_id, log_preset, this->speed);
   this->parent->add_set_task(
       SetDataTask::create(TaskTargetType::LEVEL, this->level_id, std::to_string(this->speed).c_str()));
 
@@ -225,12 +233,12 @@ void SecTouchFan::update_label_mode() {
     return;
   }
 
-  if (this->preset_mode.empty()) {
+  if (!this->has_preset_mode()) {
     level_text_sensor->publish_state("Unknown");
     return;
   }
 
-  level_text_sensor->publish_state(this->preset_mode.c_str());
+  level_text_sensor->publish_state(this->get_preset_mode());
 }
 
 // Print method for debugging

components/sec_touch/fan/sec_touch_fan.h

@@ -5,6 +5,7 @@
 #include "esphome/components/text_sensor/text_sensor.h"
 #include "../sec_touch.h"
 #include "_fan_mode.h"
+#include <vector>
 
 namespace esphome {
 namespace sec_touch {
@@ -31,9 +32,9 @@ class SecTouchFan : public Component, public fan::Fan {
 
   void setup() override {
     this->traits_ = fan::FanTraits(false, true, false, 11);
-    std::set<std::string> preset_modes;
+    std::vector<const char *> preset_modes;
     for (auto str_view : FanModeEnum::getStringValues()) {
-      preset_modes.insert(std::string(str_view));
+      preset_modes.push_back(str_view.data());
     }
 
     this->traits_.set_supported_preset_modes(preset_modes);