esphome 2025.7.4__py3-none-any.whl → 2025.8.0b1__py3-none-any.whl

esphome/core/application.h

@@ -101,12 +101,9 @@ class Application {
     arch_init();
     this->name_add_mac_suffix_ = name_add_mac_suffix;
     if (name_add_mac_suffix) {
-      this->name_ = name + "-" + get_mac_address().substr(6);
-      if (friendly_name.empty()) {
-        this->friendly_name_ = "";
-      } else {
-        this->friendly_name_ = friendly_name + " " + get_mac_address().substr(6);
-      }
+      const std::string mac_suffix = get_mac_address().substr(6);
+      this->name_ = name + "-" + mac_suffix;
+      this->friendly_name_ = friendly_name.empty() ? "" : friendly_name + " " + mac_suffix;
     } else {
       this->name_ = name;
       this->friendly_name_ = friendly_name;
@@ -214,77 +211,6 @@ class Application {
 #endif
 
   /// Reserve space for components to avoid memory fragmentation
-  void reserve_components(size_t count) { this->components_.reserve(count); }
-
-#ifdef USE_BINARY_SENSOR
-  void reserve_binary_sensor(size_t count) { this->binary_sensors_.reserve(count); }
-#endif
-#ifdef USE_SWITCH
-  void reserve_switch(size_t count) { this->switches_.reserve(count); }
-#endif
-#ifdef USE_BUTTON
-  void reserve_button(size_t count) { this->buttons_.reserve(count); }
-#endif
-#ifdef USE_SENSOR
-  void reserve_sensor(size_t count) { this->sensors_.reserve(count); }
-#endif
-#ifdef USE_TEXT_SENSOR
-  void reserve_text_sensor(size_t count) { this->text_sensors_.reserve(count); }
-#endif
-#ifdef USE_FAN
-  void reserve_fan(size_t count) { this->fans_.reserve(count); }
-#endif
-#ifdef USE_COVER
-  void reserve_cover(size_t count) { this->covers_.reserve(count); }
-#endif
-#ifdef USE_CLIMATE
-  void reserve_climate(size_t count) { this->climates_.reserve(count); }
-#endif
-#ifdef USE_LIGHT
-  void reserve_light(size_t count) { this->lights_.reserve(count); }
-#endif
-#ifdef USE_NUMBER
-  void reserve_number(size_t count) { this->numbers_.reserve(count); }
-#endif
-#ifdef USE_DATETIME_DATE
-  void reserve_date(size_t count) { this->dates_.reserve(count); }
-#endif
-#ifdef USE_DATETIME_TIME
-  void reserve_time(size_t count) { this->times_.reserve(count); }
-#endif
-#ifdef USE_DATETIME_DATETIME
-  void reserve_datetime(size_t count) { this->datetimes_.reserve(count); }
-#endif
-#ifdef USE_SELECT
-  void reserve_select(size_t count) { this->selects_.reserve(count); }
-#endif
-#ifdef USE_TEXT
-  void reserve_text(size_t count) { this->texts_.reserve(count); }
-#endif
-#ifdef USE_LOCK
-  void reserve_lock(size_t count) { this->locks_.reserve(count); }
-#endif
-#ifdef USE_VALVE
-  void reserve_valve(size_t count) { this->valves_.reserve(count); }
-#endif
-#ifdef USE_MEDIA_PLAYER
-  void reserve_media_player(size_t count) { this->media_players_.reserve(count); }
-#endif
-#ifdef USE_ALARM_CONTROL_PANEL
-  void reserve_alarm_control_panel(size_t count) { this->alarm_control_panels_.reserve(count); }
-#endif
-#ifdef USE_EVENT
-  void reserve_event(size_t count) { this->events_.reserve(count); }
-#endif
-#ifdef USE_UPDATE
-  void reserve_update(size_t count) { this->updates_.reserve(count); }
-#endif
-#ifdef USE_AREAS
-  void reserve_area(size_t count) { this->areas_.reserve(count); }
-#endif
-#ifdef USE_DEVICES
-  void reserve_device(size_t count) { this->devices_.reserve(count); }
-#endif
 
   /// Register the component in this Application instance.
   template<class C> C *register_component(C *c) {
@@ -368,8 +294,19 @@ class Application {
 
   uint8_t get_app_state() const { return this->app_state_; }
 
-// Helper macro for entity getter method declarations - reduces code duplication
-// When USE_DEVICE_ID is enabled in the future, this can be conditionally compiled to add device_id parameter
+// Helper macro for entity getter method declarations
+#ifdef USE_DEVICES
+#define GET_ENTITY_METHOD(entity_type, entity_name, entities_member) \
+  entity_type *get_##entity_name##_by_key(uint32_t key, uint32_t device_id, bool include_internal = false) { \
+    for (auto *obj : this->entities_member##_) { \
+      if (obj->get_object_id_hash() == key && obj->get_device_id() == device_id && \
+          (include_internal || !obj->is_internal())) \
+        return obj; \
+    } \
+    return nullptr; \
+  }
+  const auto &get_devices() { return this->devices_; }
+#else
 #define GET_ENTITY_METHOD(entity_type, entity_name, entities_member) \
   entity_type *get_##entity_name##_by_key(uint32_t key, bool include_internal = false) { \
     for (auto *obj : this->entities_member##_) { \
@@ -378,100 +315,95 @@ class Application {
     } \
     return nullptr; \
   }
-
-#ifdef USE_DEVICES
-  const std::vector<Device *> &get_devices() { return this->devices_; }
-#endif
+#endif  // USE_DEVICES
 #ifdef USE_AREAS
-  const std::vector<Area *> &get_areas() { return this->areas_; }
+  const auto &get_areas() { return this->areas_; }
 #endif
 #ifdef USE_BINARY_SENSOR
-  const std::vector<binary_sensor::BinarySensor *> &get_binary_sensors() { return this->binary_sensors_; }
+  auto &get_binary_sensors() const { return this->binary_sensors_; }
   GET_ENTITY_METHOD(binary_sensor::BinarySensor, binary_sensor, binary_sensors)
 #endif
 #ifdef USE_SWITCH
-  const std::vector<switch_::Switch *> &get_switches() { return this->switches_; }
+  auto &get_switches() const { return this->switches_; }
   GET_ENTITY_METHOD(switch_::Switch, switch, switches)
 #endif
 #ifdef USE_BUTTON
-  const std::vector<button::Button *> &get_buttons() { return this->buttons_; }
+  auto &get_buttons() const { return this->buttons_; }
   GET_ENTITY_METHOD(button::Button, button, buttons)
 #endif
 #ifdef USE_SENSOR
-  const std::vector<sensor::Sensor *> &get_sensors() { return this->sensors_; }
+  auto &get_sensors() const { return this->sensors_; }
   GET_ENTITY_METHOD(sensor::Sensor, sensor, sensors)
 #endif
 #ifdef USE_TEXT_SENSOR
-  const std::vector<text_sensor::TextSensor *> &get_text_sensors() { return this->text_sensors_; }
+  auto &get_text_sensors() const { return this->text_sensors_; }
   GET_ENTITY_METHOD(text_sensor::TextSensor, text_sensor, text_sensors)
 #endif
 #ifdef USE_FAN
-  const std::vector<fan::Fan *> &get_fans() { return this->fans_; }
+  auto &get_fans() const { return this->fans_; }
   GET_ENTITY_METHOD(fan::Fan, fan, fans)
 #endif
 #ifdef USE_COVER
-  const std::vector<cover::Cover *> &get_covers() { return this->covers_; }
+  auto &get_covers() const { return this->covers_; }
   GET_ENTITY_METHOD(cover::Cover, cover, covers)
 #endif
 #ifdef USE_LIGHT
-  const std::vector<light::LightState *> &get_lights() { return this->lights_; }
+  auto &get_lights() const { return this->lights_; }
   GET_ENTITY_METHOD(light::LightState, light, lights)
 #endif
 #ifdef USE_CLIMATE
-  const std::vector<climate::Climate *> &get_climates() { return this->climates_; }
+  auto &get_climates() const { return this->climates_; }
   GET_ENTITY_METHOD(climate::Climate, climate, climates)
 #endif
 #ifdef USE_NUMBER
-  const std::vector<number::Number *> &get_numbers() { return this->numbers_; }
+  auto &get_numbers() const { return this->numbers_; }
   GET_ENTITY_METHOD(number::Number, number, numbers)
 #endif
 #ifdef USE_DATETIME_DATE
-  const std::vector<datetime::DateEntity *> &get_dates() { return this->dates_; }
+  auto &get_dates() const { return this->dates_; }
   GET_ENTITY_METHOD(datetime::DateEntity, date, dates)
 #endif
 #ifdef USE_DATETIME_TIME
-  const std::vector<datetime::TimeEntity *> &get_times() { return this->times_; }
+  auto &get_times() const { return this->times_; }
   GET_ENTITY_METHOD(datetime::TimeEntity, time, times)
 #endif
 #ifdef USE_DATETIME_DATETIME
-  const std::vector<datetime::DateTimeEntity *> &get_datetimes() { return this->datetimes_; }
+  auto &get_datetimes() const { return this->datetimes_; }
   GET_ENTITY_METHOD(datetime::DateTimeEntity, datetime, datetimes)
 #endif
 #ifdef USE_TEXT
-  const std::vector<text::Text *> &get_texts() { return this->texts_; }
+  auto &get_texts() const { return this->texts_; }
   GET_ENTITY_METHOD(text::Text, text, texts)
 #endif
 #ifdef USE_SELECT
-  const std::vector<select::Select *> &get_selects() { return this->selects_; }
+  auto &get_selects() const { return this->selects_; }
   GET_ENTITY_METHOD(select::Select, select, selects)
 #endif
 #ifdef USE_LOCK
-  const std::vector<lock::Lock *> &get_locks() { return this->locks_; }
+  auto &get_locks() const { return this->locks_; }
   GET_ENTITY_METHOD(lock::Lock, lock, locks)
 #endif
 #ifdef USE_VALVE
-  const std::vector<valve::Valve *> &get_valves() { return this->valves_; }
+  auto &get_valves() const { return this->valves_; }
   GET_ENTITY_METHOD(valve::Valve, valve, valves)
 #endif
 #ifdef USE_MEDIA_PLAYER
-  const std::vector<media_player::MediaPlayer *> &get_media_players() { return this->media_players_; }
+  auto &get_media_players() const { return this->media_players_; }
   GET_ENTITY_METHOD(media_player::MediaPlayer, media_player, media_players)
 #endif
 
 #ifdef USE_ALARM_CONTROL_PANEL
-  const std::vector<alarm_control_panel::AlarmControlPanel *> &get_alarm_control_panels() {
-    return this->alarm_control_panels_;
-  }
+  auto &get_alarm_control_panels() const { return this->alarm_control_panels_; }
   GET_ENTITY_METHOD(alarm_control_panel::AlarmControlPanel, alarm_control_panel, alarm_control_panels)
 #endif
 
 #ifdef USE_EVENT
-  const std::vector<event::Event *> &get_events() { return this->events_; }
+  auto &get_events() const { return this->events_; }
   GET_ENTITY_METHOD(event::Event, event, events)
 #endif
 
 #ifdef USE_UPDATE
-  const std::vector<update::UpdateEntity *> &get_updates() { return this->updates_; }
+  auto &get_updates() const { return this->updates_; }
   GET_ENTITY_METHOD(update::UpdateEntity, update, updates)
 #endif
 
@@ -519,12 +451,7 @@ class Application {
   const char *comment_{nullptr};
   const char *compilation_time_{nullptr};
 
-  // size_t members
-  size_t dump_config_at_{SIZE_MAX};
-
-  // Vectors (largest members)
-  std::vector<Component *> components_{};
-
+  // std::vector (3 pointers each: begin, end, capacity)
   // Partitioned vector design for looping components
   // =================================================
   // Components are partitioned into [active | inactive] sections:
@@ -542,110 +469,118 @@ class Application {
   //   and active_end_ is incremented
   // - This eliminates branch mispredictions from flag checking in the hot loop
   std::vector<Component *> looping_components_{};
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  std::vector<int> socket_fds_;  // Vector of all monitored socket file descriptors
+#endif
+
+  // std::string members (typically 24-32 bytes each)
+  std::string name_;
+  std::string friendly_name_;
+
+  // size_t members
+  size_t dump_config_at_{SIZE_MAX};
+
+  // 4-byte members
+  uint32_t last_loop_{0};
+  uint32_t loop_component_start_time_{0};
+
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  int max_fd_{-1};  // Highest file descriptor number for select()
+#endif
+
+  // 2-byte members (grouped together for alignment)
+  uint16_t loop_interval_{16};                 // Loop interval in ms (max 65535ms = 65.5 seconds)
+  uint16_t looping_components_active_end_{0};  // Index marking end of active components in looping_components_
+  uint16_t current_loop_index_{0};             // For safe reentrant modifications during iteration
+
+  // 1-byte members (grouped together to minimize padding)
+  uint8_t app_state_{0};
+  bool name_add_mac_suffix_;
+  bool in_loop_{false};
+  volatile bool has_pending_enable_loop_requests_{false};
+
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  bool socket_fds_changed_{false};  // Flag to rebuild base_read_fds_ when socket_fds_ changes
+#endif
+
+#ifdef USE_SOCKET_SELECT_SUPPORT
+  // Variable-sized members
+  fd_set base_read_fds_{};  // Cached fd_set rebuilt only when socket_fds_ changes
+  fd_set read_fds_{};       // Working fd_set for select(), copied from base_read_fds_
+#endif
+
+  // StaticVectors (largest members - contain actual array data inline)
+  StaticVector<Component *, ESPHOME_COMPONENT_COUNT> components_{};
 
 #ifdef USE_DEVICES
-  std::vector<Device *> devices_{};
+  StaticVector<Device *, ESPHOME_DEVICE_COUNT> devices_{};
 #endif
 #ifdef USE_AREAS
-  std::vector<Area *> areas_{};
+  StaticVector<Area *, ESPHOME_AREA_COUNT> areas_{};
 #endif
 #ifdef USE_BINARY_SENSOR
-  std::vector<binary_sensor::BinarySensor *> binary_sensors_{};
+  StaticVector<binary_sensor::BinarySensor *, ESPHOME_ENTITY_BINARY_SENSOR_COUNT> binary_sensors_{};
 #endif
 #ifdef USE_SWITCH
-  std::vector<switch_::Switch *> switches_{};
+  StaticVector<switch_::Switch *, ESPHOME_ENTITY_SWITCH_COUNT> switches_{};
 #endif
 #ifdef USE_BUTTON
-  std::vector<button::Button *> buttons_{};
+  StaticVector<button::Button *, ESPHOME_ENTITY_BUTTON_COUNT> buttons_{};
 #endif
 #ifdef USE_EVENT
-  std::vector<event::Event *> events_{};
+  StaticVector<event::Event *, ESPHOME_ENTITY_EVENT_COUNT> events_{};
 #endif
 #ifdef USE_SENSOR
-  std::vector<sensor::Sensor *> sensors_{};
+  StaticVector<sensor::Sensor *, ESPHOME_ENTITY_SENSOR_COUNT> sensors_{};
 #endif
 #ifdef USE_TEXT_SENSOR
-  std::vector<text_sensor::TextSensor *> text_sensors_{};
+  StaticVector<text_sensor::TextSensor *, ESPHOME_ENTITY_TEXT_SENSOR_COUNT> text_sensors_{};
 #endif
 #ifdef USE_FAN
-  std::vector<fan::Fan *> fans_{};
+  StaticVector<fan::Fan *, ESPHOME_ENTITY_FAN_COUNT> fans_{};
 #endif
 #ifdef USE_COVER
-  std::vector<cover::Cover *> covers_{};
+  StaticVector<cover::Cover *, ESPHOME_ENTITY_COVER_COUNT> covers_{};
 #endif
 #ifdef USE_CLIMATE
-  std::vector<climate::Climate *> climates_{};
+  StaticVector<climate::Climate *, ESPHOME_ENTITY_CLIMATE_COUNT> climates_{};
 #endif
 #ifdef USE_LIGHT
-  std::vector<light::LightState *> lights_{};
+  StaticVector<light::LightState *, ESPHOME_ENTITY_LIGHT_COUNT> lights_{};
 #endif
 #ifdef USE_NUMBER
-  std::vector<number::Number *> numbers_{};
+  StaticVector<number::Number *, ESPHOME_ENTITY_NUMBER_COUNT> numbers_{};
 #endif
 #ifdef USE_DATETIME_DATE
-  std::vector<datetime::DateEntity *> dates_{};
+  StaticVector<datetime::DateEntity *, ESPHOME_ENTITY_DATE_COUNT> dates_{};
 #endif
 #ifdef USE_DATETIME_TIME
-  std::vector<datetime::TimeEntity *> times_{};
+  StaticVector<datetime::TimeEntity *, ESPHOME_ENTITY_TIME_COUNT> times_{};
 #endif
 #ifdef USE_DATETIME_DATETIME
-  std::vector<datetime::DateTimeEntity *> datetimes_{};
+  StaticVector<datetime::DateTimeEntity *, ESPHOME_ENTITY_DATETIME_COUNT> datetimes_{};
 #endif
 #ifdef USE_SELECT
-  std::vector<select::Select *> selects_{};
+  StaticVector<select::Select *, ESPHOME_ENTITY_SELECT_COUNT> selects_{};
 #endif
 #ifdef USE_TEXT
-  std::vector<text::Text *> texts_{};
+  StaticVector<text::Text *, ESPHOME_ENTITY_TEXT_COUNT> texts_{};
 #endif
 #ifdef USE_LOCK
-  std::vector<lock::Lock *> locks_{};
+  StaticVector<lock::Lock *, ESPHOME_ENTITY_LOCK_COUNT> locks_{};
 #endif
 #ifdef USE_VALVE
-  std::vector<valve::Valve *> valves_{};
+  StaticVector<valve::Valve *, ESPHOME_ENTITY_VALVE_COUNT> valves_{};
 #endif
 #ifdef USE_MEDIA_PLAYER
-  std::vector<media_player::MediaPlayer *> media_players_{};
+  StaticVector<media_player::MediaPlayer *, ESPHOME_ENTITY_MEDIA_PLAYER_COUNT> media_players_{};
 #endif
 #ifdef USE_ALARM_CONTROL_PANEL
-  std::vector<alarm_control_panel::AlarmControlPanel *> alarm_control_panels_{};
+  StaticVector<alarm_control_panel::AlarmControlPanel *, ESPHOME_ENTITY_ALARM_CONTROL_PANEL_COUNT>
+      alarm_control_panels_{};
 #endif
 #ifdef USE_UPDATE
-  std::vector<update::UpdateEntity *> updates_{};
-#endif
-
-#ifdef USE_SOCKET_SELECT_SUPPORT
-  std::vector<int> socket_fds_;  // Vector of all monitored socket file descriptors
-#endif
-
-  // String members
-  std::string name_;
-  std::string friendly_name_;
-
-  // 4-byte members
-  uint32_t last_loop_{0};
-  uint32_t loop_component_start_time_{0};
-
-#ifdef USE_SOCKET_SELECT_SUPPORT
-  int max_fd_{-1};  // Highest file descriptor number for select()
-#endif
-
-  // 2-byte members (grouped together for alignment)
-  uint16_t loop_interval_{16};  // Loop interval in ms (max 65535ms = 65.5 seconds)
-  uint16_t looping_components_active_end_{0};
-  uint16_t current_loop_index_{0};  // For safe reentrant modifications during iteration
-
-  // 1-byte members (grouped together to minimize padding)
-  uint8_t app_state_{0};
-  bool name_add_mac_suffix_;
-  bool in_loop_{false};
-  volatile bool has_pending_enable_loop_requests_{false};
-
-#ifdef USE_SOCKET_SELECT_SUPPORT
-  bool socket_fds_changed_{false};  // Flag to rebuild base_read_fds_ when socket_fds_ changes
-
-  // Variable-sized members at end
-  fd_set base_read_fds_{};  // Cached fd_set rebuilt only when socket_fds_ changes
-  fd_set read_fds_{};       // Working fd_set for select(), copied from base_read_fds_
+  StaticVector<update::UpdateEntity *, ESPHOME_ENTITY_UPDATE_COUNT> updates_{};
 #endif
 };
 

esphome/core/color.h

@@ -1,8 +1,13 @@
 #pragma once
 
+#include "defines.h"
 #include "component.h"
 #include "helpers.h"
 
+#ifdef USE_LVGL
+#include "esphome/components/lvgl/lvgl_proxy.h"
+#endif  // USE_LVGL
+
 namespace esphome {
 
 inline static constexpr uint8_t esp_scale8(uint8_t i, uint8_t scale) {
@@ -33,6 +38,11 @@ struct Color {
     uint32_t raw_32;
   };
 
+#ifdef USE_LVGL
+  // convenience function for Color to get a lv_color_t representation
+  operator lv_color_t() const { return lv_color_make(this->r, this->g, this->b); }
+#endif
+
   inline constexpr Color() ESPHOME_ALWAYS_INLINE : raw_32(0) {}  // NOLINT
   inline constexpr Color(uint8_t red, uint8_t green, uint8_t blue) ESPHOME_ALWAYS_INLINE : r(red),
                                                                                            g(green),

esphome/core/component.cpp

@@ -9,10 +9,14 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#ifdef USE_RUNTIME_STATS
+#include "esphome/components/runtime_stats/runtime_stats.h"
+#endif
 
 namespace esphome {
 
 static const char *const TAG = "component";
+static const char *const UNSPECIFIED_MESSAGE = "unspecified";
 
 // Global vectors for component data that doesn't belong in every instance.
 // Using vector instead of unordered_map for both because:
@@ -129,7 +133,7 @@ void Component::call_dump_config() {
   this->dump_config();
   if (this->is_failed()) {
     // Look up error message from global vector
-    const char *error_msg = "unspecified";
+    const char *error_msg = nullptr;
     if (component_error_messages) {
       for (const auto &pair : *component_error_messages) {
         if (pair.first == this) {
@@ -138,7 +142,8 @@ void Component::call_dump_config() {
         }
       }
     }
-    ESP_LOGE(TAG, "  %s is marked FAILED: %s", this->get_component_source(), error_msg);
+    ESP_LOGE(TAG, "  %s is marked FAILED: %s", this->get_component_source(),
+             error_msg ? error_msg : UNSPECIFIED_MESSAGE);
   }
 }
 
@@ -146,28 +151,33 @@ uint8_t Component::get_component_state() const { return this->component_state_;
 void Component::call() {
   uint8_t state = this->component_state_ & COMPONENT_STATE_MASK;
   switch (state) {
-    case COMPONENT_STATE_CONSTRUCTION:
+    case COMPONENT_STATE_CONSTRUCTION: {
       // State Construction: Call setup and set state to setup
-      this->component_state_ &= ~COMPONENT_STATE_MASK;
-      this->component_state_ |= COMPONENT_STATE_SETUP;
+      this->set_component_state_(COMPONENT_STATE_SETUP);
+      ESP_LOGV(TAG, "Setup %s", this->get_component_source());
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG
+      uint32_t start_time = millis();
+#endif
       this->call_setup();
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG
+      uint32_t setup_time = millis() - start_time;
+      ESP_LOGCONFIG(TAG, "Setup %s took %ums", this->get_component_source(), (unsigned) setup_time);
+#endif
       break;
+    }
     case COMPONENT_STATE_SETUP:
       // State setup: Call first loop and set state to loop
-      this->component_state_ &= ~COMPONENT_STATE_MASK;
-      this->component_state_ |= COMPONENT_STATE_LOOP;
+      this->set_component_state_(COMPONENT_STATE_LOOP);
       this->call_loop();
       break;
     case COMPONENT_STATE_LOOP:
       // State loop: Call loop
       this->call_loop();
       break;
-    case COMPONENT_STATE_FAILED:  // NOLINT(bugprone-branch-clone)
+    case COMPONENT_STATE_FAILED:
       // State failed: Do nothing
-      break;
-    case COMPONENT_STATE_LOOP_DONE:  // NOLINT(bugprone-branch-clone)
+    case COMPONENT_STATE_LOOP_DONE:
       // State loop done: Do nothing, component has finished its work
-      break;
     default:
       break;
   }
@@ -192,25 +202,26 @@ bool Component::should_warn_of_blocking(uint32_t blocking_time) {
 }
 void Component::mark_failed() {
   ESP_LOGE(TAG, "%s was marked as failed", this->get_component_source());
-  this->component_state_ &= ~COMPONENT_STATE_MASK;
-  this->component_state_ |= COMPONENT_STATE_FAILED;
+  this->set_component_state_(COMPONENT_STATE_FAILED);
   this->status_set_error();
   // Also remove from loop since failed components shouldn't loop
   App.disable_component_loop_(this);
 }
+void Component::set_component_state_(uint8_t state) {
+  this->component_state_ &= ~COMPONENT_STATE_MASK;
+  this->component_state_ |= state;
+}
 void Component::disable_loop() {
   if ((this->component_state_ & COMPONENT_STATE_MASK) != COMPONENT_STATE_LOOP_DONE) {
     ESP_LOGVV(TAG, "%s loop disabled", this->get_component_source());
-    this->component_state_ &= ~COMPONENT_STATE_MASK;
-    this->component_state_ |= COMPONENT_STATE_LOOP_DONE;
+    this->set_component_state_(COMPONENT_STATE_LOOP_DONE);
     App.disable_component_loop_(this);
   }
 }
 void Component::enable_loop() {
   if ((this->component_state_ & COMPONENT_STATE_MASK) == COMPONENT_STATE_LOOP_DONE) {
     ESP_LOGVV(TAG, "%s loop enabled", this->get_component_source());
-    this->component_state_ &= ~COMPONENT_STATE_MASK;
-    this->component_state_ |= COMPONENT_STATE_LOOP;
+    this->set_component_state_(COMPONENT_STATE_LOOP);
     App.enable_component_loop_(this);
   }
 }
@@ -230,8 +241,7 @@ void IRAM_ATTR HOT Component::enable_loop_soon_any_context() {
 void Component::reset_to_construction_state() {
   if ((this->component_state_ & COMPONENT_STATE_MASK) == COMPONENT_STATE_FAILED) {
     ESP_LOGI(TAG, "%s is being reset to construction state", this->get_component_source());
-    this->component_state_ &= ~COMPONENT_STATE_MASK;
-    this->component_state_ |= COMPONENT_STATE_CONSTRUCTION;
+    this->set_component_state_(COMPONENT_STATE_CONSTRUCTION);
     // Clear error status when resetting
     this->status_clear_error();
   }
@@ -276,15 +286,15 @@ void Component::status_set_warning(const char *message) {
     return;
   this->component_state_ |= STATUS_LED_WARNING;
   App.app_state_ |= STATUS_LED_WARNING;
-  ESP_LOGW(TAG, "%s set Warning flag: %s", this->get_component_source(), message);
+  ESP_LOGW(TAG, "%s set Warning flag: %s", this->get_component_source(), message ? message : UNSPECIFIED_MESSAGE);
 }
 void Component::status_set_error(const char *message) {
   if ((this->component_state_ & STATUS_LED_ERROR) != 0)
     return;
   this->component_state_ |= STATUS_LED_ERROR;
   App.app_state_ |= STATUS_LED_ERROR;
-  ESP_LOGE(TAG, "%s set Error flag: %s", this->get_component_source(), message);
-  if (strcmp(message, "unspecified") != 0) {
+  ESP_LOGE(TAG, "%s set Error flag: %s", this->get_component_source(), message ? message : UNSPECIFIED_MESSAGE);
+  if (message != nullptr) {
     // Lazy allocate the error messages vector if needed
     if (!component_error_messages) {
       component_error_messages = std::make_unique<std::vector<std::pair<const Component *, const char *>>>();
@@ -370,11 +380,10 @@ bool Component::has_overridden_loop() const {
 PollingComponent::PollingComponent(uint32_t update_interval) : update_interval_(update_interval) {}
 
 void PollingComponent::call_setup() {
+  // init the poller before calling setup, allowing setup to cancel it if desired
+  this->start_poller();
   // Let the polling component subclass setup their HW.
   this->setup();
-
-  // init the poller
-  this->start_poller();
 }
 
 void PollingComponent::start_poller() {
@@ -396,6 +405,13 @@ uint32_t WarnIfComponentBlockingGuard::finish() {
   uint32_t curr_time = millis();
 
   uint32_t blocking_time = curr_time - this->started_;
+
+#ifdef USE_RUNTIME_STATS
+  // Record component runtime stats
+  if (global_runtime_stats != nullptr) {
+    global_runtime_stats->record_component_time(this->component_, blocking_time, curr_time);
+  }
+#endif
   bool should_warn;
   if (this->component_ != nullptr) {
     should_warn = this->component_->should_warn_of_blocking(blocking_time);

esphome/core/component.h

@@ -202,9 +202,9 @@ class Component {
 
   bool status_has_error() const;
 
-  void status_set_warning(const char *message = "unspecified");
+  void status_set_warning(const char *message = nullptr);
 
-  void status_set_error(const char *message = "unspecified");
+  void status_set_error(const char *message = nullptr);
 
   void status_clear_warning();
 
@@ -236,6 +236,9 @@ class Component {
   virtual void call_setup();
   virtual void call_dump_config();
 
+  /// Helper to set component state (clears state bits and sets new state)
+  void set_component_state_(uint8_t state);
+
   /** Set an interval function with a unique name. Empty name means no cancelling possible.
    *
    * This will call f every interval ms. Can be cancelled via CancelInterval().
@@ -405,10 +408,10 @@ class Component {
   const char *component_source_{nullptr};
   uint16_t warn_if_blocking_over_{WARN_IF_BLOCKING_OVER_MS};  ///< Warn if blocked for this many ms (max 65.5s)
   /// State of this component - each bit has a purpose:
-  /// Bits 0-1: Component state (0x00=CONSTRUCTION, 0x01=SETUP, 0x02=LOOP, 0x03=FAILED)
-  /// Bit 2: STATUS_LED_WARNING
-  /// Bit 3: STATUS_LED_ERROR
-  /// Bits 4-7: Unused - reserved for future expansion (50% of the bits are free)
+  /// Bits 0-2: Component state (0x00=CONSTRUCTION, 0x01=SETUP, 0x02=LOOP, 0x03=FAILED, 0x04=LOOP_DONE)
+  /// Bit 3: STATUS_LED_WARNING
+  /// Bit 4: STATUS_LED_ERROR
+  /// Bits 5-7: Unused - reserved for future expansion
   uint8_t component_state_{0x00};
   volatile bool pending_enable_loop_{false};  ///< ISR-safe flag for enable_loop_soon_any_context
 };