[api] Guarantee SSO for action call timeout keys

.github/PULL_REQUEST_TEMPLATE.md

@@ -27,7 +27,6 @@
 - [ ] RP2040
 - [ ] BK72xx
 - [ ] RTL87xx
-- [ ] LN882x
 - [ ] nRF52840
 
 ## Example entry for `config.yaml`:

.github/workflows/codeql.yml

@@ -58,7 +58,7 @@ jobs:
 
       # Initializes the CodeQL tools for scanning.
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
+        uses: github/codeql-action/init@5d4e8d1aca955e8d8589aabd499c5cae939e33c7 # v4.31.9
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
@@ -86,6 +86,6 @@ jobs:
           exit 1
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
+        uses: github/codeql-action/analyze@5d4e8d1aca955e8d8589aabd499c5cae939e33c7 # v4.31.9
         with:
           category: "/language:${{matrix.language}}"

CODEOWNERS

@@ -255,7 +255,6 @@ esphome/components/inkplate/* @jesserockz @JosipKuci
 esphome/components/integration/* @OttoWinter
 esphome/components/internal_temperature/* @Mat931
 esphome/components/interval/* @esphome/core
-esphome/components/ir_rf_proxy/* @kbx81
 esphome/components/jsn_sr04t/* @Mafus1
 esphome/components/json/* @esphome/core
 esphome/components/kamstrup_kmp/* @cfeenstra1024

esphome/components/api/__init__.py

@@ -4,7 +4,6 @@ import logging
 from esphome import automation
 from esphome.automation import Condition
 import esphome.codegen as cg
-from esphome.components.logger import request_log_listener
 from esphome.config_helpers import get_logger_level
 import esphome.config_validation as cv
 from esphome.const import (
@@ -327,9 +326,6 @@ async def to_code(config: ConfigType) -> None:
     # Track controller registration for StaticVector sizing
     CORE.register_controller()
 
-    # Request a log listener slot for API log streaming
-    request_log_listener()
-
     cg.add(var.set_port(config[CONF_PORT]))
     cg.add(var.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
     cg.add(var.set_batch_delay(config[CONF_BATCH_DELAY]))

esphome/components/api/api_connection.cpp

@@ -265,7 +265,8 @@ void APIConnection::loop() {
       // If we can't send the ping request directly (tx_buffer full),
       // schedule it at the front of the batch so it will be sent with priority
       ESP_LOGW(TAG, "Buffer full, ping queued");
-      this->schedule_message_front_(nullptr, PingRequest::MESSAGE_TYPE, PingRequest::ESTIMATED_SIZE);
+      this->schedule_message_front_(nullptr, &APIConnection::try_send_ping_request, PingRequest::MESSAGE_TYPE,
+                                    PingRequest::ESTIMATED_SIZE);
       this->flags_.sent_ping = true;  // Mark as sent to avoid scheduling multiple pings
     }
   }
@@ -304,8 +305,7 @@ uint16_t APIConnection::encode_message_to_buffer(ProtoMessage &msg, uint8_t mess
 #ifdef HAS_PROTO_MESSAGE_DUMP
   // If in log-only mode, just log and return
   if (conn->flags_.log_only_mode) {
-    DumpBuffer dump_buf;
-    conn->log_send_message_(msg.message_name(), msg.dump_to(dump_buf));
+    conn->log_send_message_(msg.message_name(), msg.dump());
     return 1;  // Return non-zero to indicate "success" for logging
   }
 #endif
@@ -361,8 +361,8 @@ uint16_t APIConnection::encode_message_to_buffer(ProtoMessage &msg, uint8_t mess
 
 #ifdef USE_BINARY_SENSOR
 bool APIConnection::send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor) {
-  return this->send_message_smart_(binary_sensor, BinarySensorStateResponse::MESSAGE_TYPE,
-                                   BinarySensorStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(binary_sensor, &APIConnection::try_send_binary_sensor_state,
+                                   BinarySensorStateResponse::MESSAGE_TYPE, BinarySensorStateResponse::ESTIMATED_SIZE);
 }
 
 uint16_t APIConnection::try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -388,7 +388,8 @@ uint16_t APIConnection::try_send_binary_sensor_info(EntityBase *entity, APIConne
 
 #ifdef USE_COVER
 bool APIConnection::send_cover_state(cover::Cover *cover) {
-  return this->send_message_smart_(cover, CoverStateResponse::MESSAGE_TYPE, CoverStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(cover, &APIConnection::try_send_cover_state, CoverStateResponse::MESSAGE_TYPE,
+                                   CoverStateResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_cover_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                              bool is_single) {
@@ -428,7 +429,8 @@ void APIConnection::cover_command(const CoverCommandRequest &msg) {
 
 #ifdef USE_FAN
 bool APIConnection::send_fan_state(fan::Fan *fan) {
-  return this->send_message_smart_(fan, FanStateResponse::MESSAGE_TYPE, FanStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(fan, &APIConnection::try_send_fan_state, FanStateResponse::MESSAGE_TYPE,
+                                   FanStateResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_fan_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                            bool is_single) {
@@ -479,7 +481,8 @@ void APIConnection::fan_command(const FanCommandRequest &msg) {
 
 #ifdef USE_LIGHT
 bool APIConnection::send_light_state(light::LightState *light) {
-  return this->send_message_smart_(light, LightStateResponse::MESSAGE_TYPE, LightStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(light, &APIConnection::try_send_light_state, LightStateResponse::MESSAGE_TYPE,
+                                   LightStateResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_light_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                              bool is_single) {
@@ -565,7 +568,8 @@ void APIConnection::light_command(const LightCommandRequest &msg) {
 
 #ifdef USE_SENSOR
 bool APIConnection::send_sensor_state(sensor::Sensor *sensor) {
-  return this->send_message_smart_(sensor, SensorStateResponse::MESSAGE_TYPE, SensorStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(sensor, &APIConnection::try_send_sensor_state, SensorStateResponse::MESSAGE_TYPE,
+                                   SensorStateResponse::ESTIMATED_SIZE);
 }
 
 uint16_t APIConnection::try_send_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -593,7 +597,8 @@ uint16_t APIConnection::try_send_sensor_info(EntityBase *entity, APIConnection *
 
 #ifdef USE_SWITCH
 bool APIConnection::send_switch_state(switch_::Switch *a_switch) {
-  return this->send_message_smart_(a_switch, SwitchStateResponse::MESSAGE_TYPE, SwitchStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(a_switch, &APIConnection::try_send_switch_state, SwitchStateResponse::MESSAGE_TYPE,
+                                   SwitchStateResponse::ESTIMATED_SIZE);
 }
 
 uint16_t APIConnection::try_send_switch_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -627,8 +632,8 @@ void APIConnection::switch_command(const SwitchCommandRequest &msg) {
 
 #ifdef USE_TEXT_SENSOR
 bool APIConnection::send_text_sensor_state(text_sensor::TextSensor *text_sensor) {
-  return this->send_message_smart_(text_sensor, TextSensorStateResponse::MESSAGE_TYPE,
-                                   TextSensorStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(text_sensor, &APIConnection::try_send_text_sensor_state,
+                                   TextSensorStateResponse::MESSAGE_TYPE, TextSensorStateResponse::ESTIMATED_SIZE);
 }
 
 uint16_t APIConnection::try_send_text_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -652,7 +657,8 @@ uint16_t APIConnection::try_send_text_sensor_info(EntityBase *entity, APIConnect
 
 #ifdef USE_CLIMATE
 bool APIConnection::send_climate_state(climate::Climate *climate) {
-  return this->send_message_smart_(climate, ClimateStateResponse::MESSAGE_TYPE, ClimateStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(climate, &APIConnection::try_send_climate_state, ClimateStateResponse::MESSAGE_TYPE,
+                                   ClimateStateResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_climate_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                bool is_single) {
@@ -747,7 +753,8 @@ void APIConnection::climate_command(const ClimateCommandRequest &msg) {
 
 #ifdef USE_NUMBER
 bool APIConnection::send_number_state(number::Number *number) {
-  return this->send_message_smart_(number, NumberStateResponse::MESSAGE_TYPE, NumberStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(number, &APIConnection::try_send_number_state, NumberStateResponse::MESSAGE_TYPE,
+                                   NumberStateResponse::ESTIMATED_SIZE);
 }
 
 uint16_t APIConnection::try_send_number_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -781,7 +788,8 @@ void APIConnection::number_command(const NumberCommandRequest &msg) {
 
 #ifdef USE_DATETIME_DATE
 bool APIConnection::send_date_state(datetime::DateEntity *date) {
-  return this->send_message_smart_(date, DateStateResponse::MESSAGE_TYPE, DateStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(date, &APIConnection::try_send_date_state, DateStateResponse::MESSAGE_TYPE,
+                                   DateStateResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_date_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                             bool is_single) {
@@ -809,7 +817,8 @@ void APIConnection::date_command(const DateCommandRequest &msg) {
 
 #ifdef USE_DATETIME_TIME
 bool APIConnection::send_time_state(datetime::TimeEntity *time) {
-  return this->send_message_smart_(time, TimeStateResponse::MESSAGE_TYPE, TimeStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(time, &APIConnection::try_send_time_state, TimeStateResponse::MESSAGE_TYPE,
+                                   TimeStateResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_time_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                             bool is_single) {
@@ -837,8 +846,8 @@ void APIConnection::time_command(const TimeCommandRequest &msg) {
 
 #ifdef USE_DATETIME_DATETIME
 bool APIConnection::send_datetime_state(datetime::DateTimeEntity *datetime) {
-  return this->send_message_smart_(datetime, DateTimeStateResponse::MESSAGE_TYPE,
-                                   DateTimeStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(datetime, &APIConnection::try_send_datetime_state,
+                                   DateTimeStateResponse::MESSAGE_TYPE, DateTimeStateResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_datetime_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                 bool is_single) {
@@ -868,7 +877,8 @@ void APIConnection::datetime_command(const DateTimeCommandRequest &msg) {
 
 #ifdef USE_TEXT
 bool APIConnection::send_text_state(text::Text *text) {
-  return this->send_message_smart_(text, TextStateResponse::MESSAGE_TYPE, TextStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(text, &APIConnection::try_send_text_state, TextStateResponse::MESSAGE_TYPE,
+                                   TextStateResponse::ESTIMATED_SIZE);
 }
 
 uint16_t APIConnection::try_send_text_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -900,7 +910,8 @@ void APIConnection::text_command(const TextCommandRequest &msg) {
 
 #ifdef USE_SELECT
 bool APIConnection::send_select_state(select::Select *select) {
-  return this->send_message_smart_(select, SelectStateResponse::MESSAGE_TYPE, SelectStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(select, &APIConnection::try_send_select_state, SelectStateResponse::MESSAGE_TYPE,
+                                   SelectStateResponse::ESTIMATED_SIZE);
 }
 
 uint16_t APIConnection::try_send_select_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -944,7 +955,8 @@ void esphome::api::APIConnection::button_command(const ButtonCommandRequest &msg
 
 #ifdef USE_LOCK
 bool APIConnection::send_lock_state(lock::Lock *a_lock) {
-  return this->send_message_smart_(a_lock, LockStateResponse::MESSAGE_TYPE, LockStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(a_lock, &APIConnection::try_send_lock_state, LockStateResponse::MESSAGE_TYPE,
+                                   LockStateResponse::ESTIMATED_SIZE);
 }
 
 uint16_t APIConnection::try_send_lock_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -984,7 +996,8 @@ void APIConnection::lock_command(const LockCommandRequest &msg) {
 
 #ifdef USE_VALVE
 bool APIConnection::send_valve_state(valve::Valve *valve) {
-  return this->send_message_smart_(valve, ValveStateResponse::MESSAGE_TYPE, ValveStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(valve, &APIConnection::try_send_valve_state, ValveStateResponse::MESSAGE_TYPE,
+                                   ValveStateResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_valve_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                              bool is_single) {
@@ -1018,8 +1031,8 @@ void APIConnection::valve_command(const ValveCommandRequest &msg) {
 
 #ifdef USE_MEDIA_PLAYER
 bool APIConnection::send_media_player_state(media_player::MediaPlayer *media_player) {
-  return this->send_message_smart_(media_player, MediaPlayerStateResponse::MESSAGE_TYPE,
-                                   MediaPlayerStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(media_player, &APIConnection::try_send_media_player_state,
+                                   MediaPlayerStateResponse::MESSAGE_TYPE, MediaPlayerStateResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_media_player_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                     bool is_single) {
@@ -1301,7 +1314,8 @@ void APIConnection::zwave_proxy_request(const ZWaveProxyRequest &msg) {
 
 #ifdef USE_ALARM_CONTROL_PANEL
 bool APIConnection::send_alarm_control_panel_state(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel) {
-  return this->send_message_smart_(a_alarm_control_panel, AlarmControlPanelStateResponse::MESSAGE_TYPE,
+  return this->send_message_smart_(a_alarm_control_panel, &APIConnection::try_send_alarm_control_panel_state,
+                                   AlarmControlPanelStateResponse::MESSAGE_TYPE,
                                    AlarmControlPanelStateResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_alarm_control_panel_state(EntityBase *entity, APIConnection *conn,
@@ -1354,8 +1368,8 @@ void APIConnection::alarm_control_panel_command(const AlarmControlPanelCommandRe
 
 #ifdef USE_WATER_HEATER
 bool APIConnection::send_water_heater_state(water_heater::WaterHeater *water_heater) {
-  return this->send_message_smart_(water_heater, WaterHeaterStateResponse::MESSAGE_TYPE,
-                                   WaterHeaterStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(water_heater, &APIConnection::try_send_water_heater_state,
+                                   WaterHeaterStateResponse::MESSAGE_TYPE, WaterHeaterStateResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_water_heater_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                     bool is_single) {
@@ -1404,11 +1418,10 @@ void APIConnection::on_water_heater_command_request(const WaterHeaterCommandRequ
 #endif
 
 #ifdef USE_EVENT
-// Event is a special case - unlike other entities with simple state fields,
-// events store their state in a member accessed via obj->get_last_event_type()
-void APIConnection::send_event(event::Event *event) {
-  this->send_message_smart_(event, EventResponse::MESSAGE_TYPE, EventResponse::ESTIMATED_SIZE,
-                            event->get_last_event_type_index());
+void APIConnection::send_event(event::Event *event, StringRef event_type) {
+  // get_last_event_type() returns StringRef pointing to null-terminated string literals from codegen
+  this->send_message_smart_(event, MessageCreator(event_type.c_str()), EventResponse::MESSAGE_TYPE,
+                            EventResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_event_response(event::Event *event, StringRef event_type, APIConnection *conn,
                                                 uint32_t remaining_size, bool is_single) {
@@ -1459,7 +1472,8 @@ uint16_t APIConnection::try_send_infrared_info(EntityBase *entity, APIConnection
 
 #ifdef USE_UPDATE
 bool APIConnection::send_update_state(update::UpdateEntity *update) {
-  return this->send_message_smart_(update, UpdateStateResponse::MESSAGE_TYPE, UpdateStateResponse::ESTIMATED_SIZE);
+  return this->send_message_smart_(update, &APIConnection::try_send_update_state, UpdateStateResponse::MESSAGE_TYPE,
+                                   UpdateStateResponse::ESTIMATED_SIZE);
 }
 uint16_t APIConnection::try_send_update_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single) {
@@ -1882,31 +1896,30 @@ void APIConnection::on_fatal_error() {
   this->flags_.remove = true;
 }
 
-void APIConnection::DeferredBatch::add_item(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
-                                            uint8_t aux_data_index) {
+void APIConnection::DeferredBatch::add_item(EntityBase *entity, MessageCreator creator, uint8_t message_type,
+                                            uint8_t estimated_size) {
   // Check if we already have a message of this type for this entity
   // This provides deduplication per entity/message_type combination
   // O(n) but optimized for RAM and not performance.
-  // Skip deduplication for events - they are edge-triggered, every occurrence matters
-#ifdef USE_EVENT
-  if (message_type != EventResponse::MESSAGE_TYPE)
-#endif
-  {
-    for (const auto &item : items) {
-      if (item.entity == entity && item.message_type == message_type)
-        return;  // Already queued
+  for (auto &item : items) {
+    if (item.entity == entity && item.message_type == message_type) {
+      // Replace with new creator
+      item.creator = creator;
+      return;
     }
   }
-  // No existing item found (or event), add new one
-  items.push_back({entity, message_type, estimated_size, aux_data_index});
+
+  // No existing item found, add new one
+  items.emplace_back(entity, creator, message_type, estimated_size);
 }
 
-void APIConnection::DeferredBatch::add_item_front(EntityBase *entity, uint8_t message_type, uint8_t estimated_size) {
+void APIConnection::DeferredBatch::add_item_front(EntityBase *entity, MessageCreator creator, uint8_t message_type,
+                                                  uint8_t estimated_size) {
   // Add high priority message and swap to front
   // This avoids expensive vector::insert which shifts all elements
   // Note: We only ever have one high-priority message at a time (ping OR disconnect)
   // If we're disconnecting, pings are blocked, so this simple swap is sufficient
-  items.push_back({entity, message_type, estimated_size, AUX_DATA_UNUSED});
+  items.emplace_back(entity, creator, message_type, estimated_size);
   if (items.size() > 1) {
     // Swap the new high-priority item to the front
     std::swap(items.front(), items.back());
@@ -1945,17 +1958,19 @@ void APIConnection::process_batch_() {
   if (num_items == 1) {
     const auto &item = this->deferred_batch_[0];
 
-    // Let dispatch_message_ calculate size and encode if it fits
-    uint16_t payload_size = this->dispatch_message_(item, std::numeric_limits<uint16_t>::max(), true);
+    // Let the creator calculate size and encode if it fits
+    uint16_t payload_size =
+        item.creator(item.entity, this, std::numeric_limits<uint16_t>::max(), true, item.message_type);
 
     if (payload_size > 0 && this->send_buffer(ProtoWriteBuffer{&shared_buf}, item.message_type)) {
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      // Log message after send attempt for VV debugging
+      // Log messages after send attempt for VV debugging
+      // It's safe to use the buffer for logging at this point regardless of send result
       this->log_batch_item_(item);
 #endif
       this->clear_batch_();
     } else if (payload_size == 0) {
-      // Message too large to fit in available space
+      // Message too large
       ESP_LOGW(TAG, "Message too large to send: type=%u", item.message_type);
       this->clear_batch_();
     }
@@ -2000,9 +2015,9 @@ void APIConnection::process_batch_() {
   // Process items and encode directly to buffer (up to our limit)
   for (size_t i = 0; i < messages_to_process; i++) {
     const auto &item = this->deferred_batch_[i];
-    // Try to encode message via dispatch
-    // The dispatch function calculates overhead to determine if the message fits
-    uint16_t payload_size = this->dispatch_message_(item, remaining_size, false);
+    // Try to encode message
+    // The creator will calculate overhead to determine if the message fits
+    uint16_t payload_size = item.creator(item.entity, this, remaining_size, false, item.message_type);
 
     if (payload_size == 0) {
       // Message won't fit, stop processing
@@ -2068,129 +2083,18 @@ void APIConnection::process_batch_() {
   }
 }
 
-// Dispatch message encoding based on message_type
-// Switch assigns function pointer, single call site for smaller code size
-uint16_t APIConnection::dispatch_message_(const DeferredBatch::BatchItem &item, uint32_t remaining_size,
-                                          bool is_single) {
+uint16_t APIConnection::MessageCreator::operator()(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                                   bool is_single, uint8_t message_type) const {
 #ifdef USE_EVENT
-  // Events need aux_data_index to look up event type from entity
-  if (item.message_type == EventResponse::MESSAGE_TYPE) {
-    // Skip if aux_data_index is invalid (should never happen in normal operation)
-    if (item.aux_data_index == DeferredBatch::AUX_DATA_UNUSED)
-      return 0;
-    auto *event = static_cast<event::Event *>(item.entity);
-    return try_send_event_response(event, StringRef::from_maybe_nullptr(event->get_event_type(item.aux_data_index)),
-                                   this, remaining_size, is_single);
+  // Special case: EventResponse uses const char * pointer
+  if (message_type == EventResponse::MESSAGE_TYPE) {
+    auto *e = static_cast<event::Event *>(entity);
+    return APIConnection::try_send_event_response(e, StringRef(data_.const_char_ptr), conn, remaining_size, is_single);
   }
 #endif
 
-  // All other message types use function pointer lookup via switch
-  MessageCreatorPtr func = nullptr;
-
-// Macros to reduce repetitive switch cases
-#define CASE_STATE_INFO(entity_name, StateResp, InfoResp) \
-  case StateResp::MESSAGE_TYPE: \
-    func = &try_send_##entity_name##_state; \
-    break; \
-  case InfoResp::MESSAGE_TYPE: \
-    func = &try_send_##entity_name##_info; \
-    break;
-#define CASE_INFO_ONLY(entity_name, InfoResp) \
-  case InfoResp::MESSAGE_TYPE: \
-    func = &try_send_##entity_name##_info; \
-    break;
-
-  switch (item.message_type) {
-#ifdef USE_BINARY_SENSOR
-    CASE_STATE_INFO(binary_sensor, BinarySensorStateResponse, ListEntitiesBinarySensorResponse)
-#endif
-#ifdef USE_COVER
-    CASE_STATE_INFO(cover, CoverStateResponse, ListEntitiesCoverResponse)
-#endif
-#ifdef USE_FAN
-    CASE_STATE_INFO(fan, FanStateResponse, ListEntitiesFanResponse)
-#endif
-#ifdef USE_LIGHT
-    CASE_STATE_INFO(light, LightStateResponse, ListEntitiesLightResponse)
-#endif
-#ifdef USE_SENSOR
-    CASE_STATE_INFO(sensor, SensorStateResponse, ListEntitiesSensorResponse)
-#endif
-#ifdef USE_SWITCH
-    CASE_STATE_INFO(switch, SwitchStateResponse, ListEntitiesSwitchResponse)
-#endif
-#ifdef USE_BUTTON
-    CASE_INFO_ONLY(button, ListEntitiesButtonResponse)
-#endif
-#ifdef USE_TEXT_SENSOR
-    CASE_STATE_INFO(text_sensor, TextSensorStateResponse, ListEntitiesTextSensorResponse)
-#endif
-#ifdef USE_CLIMATE
-    CASE_STATE_INFO(climate, ClimateStateResponse, ListEntitiesClimateResponse)
-#endif
-#ifdef USE_NUMBER
-    CASE_STATE_INFO(number, NumberStateResponse, ListEntitiesNumberResponse)
-#endif
-#ifdef USE_DATETIME_DATE
-    CASE_STATE_INFO(date, DateStateResponse, ListEntitiesDateResponse)
-#endif
-#ifdef USE_DATETIME_TIME
-    CASE_STATE_INFO(time, TimeStateResponse, ListEntitiesTimeResponse)
-#endif
-#ifdef USE_DATETIME_DATETIME
-    CASE_STATE_INFO(datetime, DateTimeStateResponse, ListEntitiesDateTimeResponse)
-#endif
-#ifdef USE_TEXT
-    CASE_STATE_INFO(text, TextStateResponse, ListEntitiesTextResponse)
-#endif
-#ifdef USE_SELECT
-    CASE_STATE_INFO(select, SelectStateResponse, ListEntitiesSelectResponse)
-#endif
-#ifdef USE_LOCK
-    CASE_STATE_INFO(lock, LockStateResponse, ListEntitiesLockResponse)
-#endif
-#ifdef USE_VALVE
-    CASE_STATE_INFO(valve, ValveStateResponse, ListEntitiesValveResponse)
-#endif
-#ifdef USE_MEDIA_PLAYER
-    CASE_STATE_INFO(media_player, MediaPlayerStateResponse, ListEntitiesMediaPlayerResponse)
-#endif
-#ifdef USE_ALARM_CONTROL_PANEL
-    CASE_STATE_INFO(alarm_control_panel, AlarmControlPanelStateResponse, ListEntitiesAlarmControlPanelResponse)
-#endif
-#ifdef USE_WATER_HEATER
-    CASE_STATE_INFO(water_heater, WaterHeaterStateResponse, ListEntitiesWaterHeaterResponse)
-#endif
-#ifdef USE_CAMERA
-    CASE_INFO_ONLY(camera, ListEntitiesCameraResponse)
-#endif
-#ifdef USE_INFRARED
-    CASE_INFO_ONLY(infrared, ListEntitiesInfraredResponse)
-#endif
-#ifdef USE_EVENT
-    CASE_INFO_ONLY(event, ListEntitiesEventResponse)
-#endif
-#ifdef USE_UPDATE
-    CASE_STATE_INFO(update, UpdateStateResponse, ListEntitiesUpdateResponse)
-#endif
-    // Special messages (not entity state/info)
-    case ListEntitiesDoneResponse::MESSAGE_TYPE:
-      func = &try_send_list_info_done;
-      break;
-    case DisconnectRequest::MESSAGE_TYPE:
-      func = &try_send_disconnect_request;
-      break;
-    case PingRequest::MESSAGE_TYPE:
-      func = &try_send_ping_request;
-      break;
-    default:
-      return 0;
-  }
-
-#undef CASE_STATE_INFO
-#undef CASE_INFO_ONLY
-
-  return func(item.entity, this, remaining_size, is_single);
+  // All other message types use function pointers
+  return data_.function_ptr(entity, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_list_info_done(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,

esphome/components/api/api_connection.h

@@ -12,7 +12,6 @@
 #include "esphome/core/string_ref.h"
 
 #include <functional>
-#include <limits>
 #include <vector>
 
 namespace esphome::api {
@@ -39,8 +38,8 @@ class APIConnection final : public APIServerConnection {
   void loop();
 
   bool send_list_info_done() {
-    return this->schedule_message_(nullptr, ListEntitiesDoneResponse::MESSAGE_TYPE,
-                                   ListEntitiesDoneResponse::ESTIMATED_SIZE);
+    return this->schedule_message_(nullptr, &APIConnection::try_send_list_info_done,
+                                   ListEntitiesDoneResponse::MESSAGE_TYPE, ListEntitiesDoneResponse::ESTIMATED_SIZE);
   }
 #ifdef USE_BINARY_SENSOR
   bool send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor);
@@ -179,7 +178,7 @@ class APIConnection final : public APIServerConnection {
 #endif
 
 #ifdef USE_EVENT
-  void send_event(event::Event *event);
+  void send_event(event::Event *event, StringRef event_type);
 #endif
 
 #ifdef USE_UPDATE
@@ -541,17 +540,33 @@ class APIConnection final : public APIServerConnection {
   // Function pointer type for message encoding
   using MessageCreatorPtr = uint16_t (*)(EntityBase *, APIConnection *, uint32_t remaining_size, bool is_single);
 
+  class MessageCreator {
+   public:
+    MessageCreator(MessageCreatorPtr ptr) { data_.function_ptr = ptr; }
+    explicit MessageCreator(const char *str_value) { data_.const_char_ptr = str_value; }
+
+    // Call operator - uses message_type to determine union type
+    uint16_t operator()(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single,
+                        uint8_t message_type) const;
+
+   private:
+    union Data {
+      MessageCreatorPtr function_ptr;
+      const char *const_char_ptr;
+    } data_;  // 4 bytes on 32-bit, 8 bytes on 64-bit
+  };
+
   // Generic batching mechanism for both state updates and entity info
   struct DeferredBatch {
-    // Sentinel value for unused aux_data_index
-    static constexpr uint8_t AUX_DATA_UNUSED = std::numeric_limits<uint8_t>::max();
-
     struct BatchItem {
-      EntityBase *entity;                       // 4 bytes - Entity pointer
-      uint8_t message_type;                     // 1 byte - Message type for protocol and dispatch
-      uint8_t estimated_size;                   // 1 byte - Estimated message size (max 255 bytes)
-      uint8_t aux_data_index{AUX_DATA_UNUSED};  // 1 byte - For events: index into entity's event_types
-      // 1 byte padding
+      EntityBase *entity;      // Entity pointer
+      MessageCreator creator;  // Function that creates the message when needed
+      uint8_t message_type;    // Message type for overhead calculation (max 255)
+      uint8_t estimated_size;  // Estimated message size (max 255 bytes)
+
+      // Constructor for creating BatchItem
+      BatchItem(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size)
+          : entity(entity), creator(creator), message_type(message_type), estimated_size(estimated_size) {}
     };
 
     std::vector<BatchItem> items;
@@ -560,11 +575,10 @@ class APIConnection final : public APIServerConnection {
     // No pre-allocation - log connections never use batching, and for
     // connections that do, buffers are released after initial sync anyway
 
-    // Add item to the batch (with deduplication)
-    void add_item(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
-                  uint8_t aux_data_index = AUX_DATA_UNUSED);
+    // Add item to the batch
+    void add_item(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size);
     // Add item to the front of the batch (for high priority messages like ping)
-    void add_item_front(EntityBase *entity, uint8_t message_type, uint8_t estimated_size);
+    void add_item_front(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size);
 
     // Clear all items
     void clear() {
@@ -578,7 +592,6 @@ class APIConnection final : public APIServerConnection {
     bool empty() const { return items.empty(); }
     size_t size() const { return items.size(); }
     const BatchItem &operator[](size_t index) const { return items[index]; }
-
     // Release excess capacity - only releases if items already empty
     void release_buffer() {
       // Safe to call: batch is processed before release_buffer is called,
@@ -650,16 +663,18 @@ class APIConnection final : public APIServerConnection {
     this->flags_.batch_scheduled = false;
   }
 
-  // Dispatch message encoding based on message_type - replaces function pointer storage
-  // Switch assigns pointer, single call site for smaller code size
-  uint16_t dispatch_message_(const DeferredBatch::BatchItem &item, uint32_t remaining_size, bool is_single);
-
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  void log_batch_item_(const DeferredBatch::BatchItem &item) {
+  // Helper to log a proto message from a MessageCreator object
+  void log_proto_message_(EntityBase *entity, const MessageCreator &creator, uint8_t message_type) {
     this->flags_.log_only_mode = true;
-    this->dispatch_message_(item, MAX_BATCH_PACKET_SIZE, true);
+    creator(entity, this, MAX_BATCH_PACKET_SIZE, true, message_type);
     this->flags_.log_only_mode = false;
   }
+
+  void log_batch_item_(const DeferredBatch::BatchItem &item) {
+    // Use the helper to log the message
+    this->log_proto_message_(item.entity, item.creator, item.message_type);
+  }
 #endif
 
   // Helper to check if a message type should bypass batching
@@ -683,31 +698,63 @@ class APIConnection final : public APIServerConnection {
   // Helper method to send a message either immediately or via batching
   // Tries immediate send if should_send_immediately_() returns true and buffer has space
   // Falls back to batching if immediate send fails or isn't applicable
-  bool send_message_smart_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
-                           uint8_t aux_data_index = DeferredBatch::AUX_DATA_UNUSED) {
+  bool send_message_smart_(EntityBase *entity, MessageCreatorPtr creator, uint8_t message_type,
+                           uint8_t estimated_size) {
     if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
-      DeferredBatch::BatchItem item{entity, message_type, estimated_size, aux_data_index};
-      if (this->dispatch_message_(item, MAX_BATCH_PACKET_SIZE, true) &&
+      // Now actually encode and send
+      if (creator(entity, this, MAX_BATCH_PACKET_SIZE, true) &&
           this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
 #ifdef HAS_PROTO_MESSAGE_DUMP
-        this->log_batch_item_(item);
+        // Log the message in verbose mode
+        this->log_proto_message_(entity, MessageCreator(creator), message_type);
 #endif
         return true;
       }
+
+      // If immediate send failed, fall through to batching
     }
-    return this->schedule_message_(entity, message_type, estimated_size, aux_data_index);
+
+    // Fall back to scheduled batching
+    return this->schedule_message_(entity, creator, message_type, estimated_size);
+  }
+
+  // Overload for MessageCreator (used by events which need to capture event_type)
+  bool send_message_smart_(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size) {
+    // Try to send immediately if message type should bypass batching and buffer has space
+    if (this->should_send_immediately_(message_type) && this->helper_->can_write_without_blocking()) {
+      // Now actually encode and send
+      if (creator(entity, this, MAX_BATCH_PACKET_SIZE, true, message_type) &&
+          this->send_buffer(ProtoWriteBuffer{&this->parent_->get_shared_buffer_ref()}, message_type)) {
+#ifdef HAS_PROTO_MESSAGE_DUMP
+        // Log the message in verbose mode
+        this->log_proto_message_(entity, creator, message_type);
+#endif
+        return true;
+      }
+
+      // If immediate send failed, fall through to batching
+    }
+
+    // Fall back to scheduled batching
+    return this->schedule_message_(entity, creator, message_type, estimated_size);
   }
 
   // Helper function to schedule a deferred message with known message type
-  bool schedule_message_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size,
-                         uint8_t aux_data_index = DeferredBatch::AUX_DATA_UNUSED) {
-    this->deferred_batch_.add_item(entity, message_type, estimated_size, aux_data_index);
+  bool schedule_message_(EntityBase *entity, MessageCreator creator, uint8_t message_type, uint8_t estimated_size) {
+    this->deferred_batch_.add_item(entity, creator, message_type, estimated_size);
     return this->schedule_batch_();
   }
 
+  // Overload for function pointers (for info messages and current state reads)
+  bool schedule_message_(EntityBase *entity, MessageCreatorPtr function_ptr, uint8_t message_type,
+                         uint8_t estimated_size) {
+    return schedule_message_(entity, MessageCreator(function_ptr), message_type, estimated_size);
+  }
+
   // Helper function to schedule a high priority message at the front of the batch
-  bool schedule_message_front_(EntityBase *entity, uint8_t message_type, uint8_t estimated_size) {
-    this->deferred_batch_.add_item_front(entity, message_type, estimated_size);
+  bool schedule_message_front_(EntityBase *entity, MessageCreatorPtr function_ptr, uint8_t message_type,
+                               uint8_t estimated_size) {
+    this->deferred_batch_.add_item_front(entity, MessageCreator(function_ptr), message_type, estimated_size);
     return this->schedule_batch_();
   }
 

esphome/components/api/api_pb2_service.cpp

@@ -8,12 +8,8 @@ namespace esphome::api {
 static const char *const TAG = "api.service";
 
 #ifdef HAS_PROTO_MESSAGE_DUMP
-void APIServerConnectionBase::log_send_message_(const char *name, const char *dump) {
-  ESP_LOGVV(TAG, "send_message %s: %s", name, dump);
-}
-void APIServerConnectionBase::log_receive_message_(const LogString *name, const ProtoMessage &msg) {
-  DumpBuffer dump_buf;
-  ESP_LOGVV(TAG, "%s: %s", LOG_STR_ARG(name), msg.dump_to(dump_buf));
+void APIServerConnectionBase::log_send_message_(const char *name, const std::string &dump) {
+  ESP_LOGVV(TAG, "send_message %s: %s", name, dump.c_str());
 }
 #endif
 
@@ -23,7 +19,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       HelloRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_hello_request"), msg);
+      ESP_LOGVV(TAG, "on_hello_request: %s", msg.dump().c_str());
 #endif
       this->on_hello_request(msg);
       break;
@@ -32,7 +28,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       DisconnectRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_disconnect_request"), msg);
+      ESP_LOGVV(TAG, "on_disconnect_request: %s", msg.dump().c_str());
 #endif
       this->on_disconnect_request(msg);
       break;
@@ -41,7 +37,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       DisconnectResponse msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_disconnect_response"), msg);
+      ESP_LOGVV(TAG, "on_disconnect_response: %s", msg.dump().c_str());
 #endif
       this->on_disconnect_response(msg);
       break;
@@ -50,7 +46,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       PingRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_ping_request"), msg);
+      ESP_LOGVV(TAG, "on_ping_request: %s", msg.dump().c_str());
 #endif
       this->on_ping_request(msg);
       break;
@@ -59,7 +55,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       PingResponse msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_ping_response"), msg);
+      ESP_LOGVV(TAG, "on_ping_response: %s", msg.dump().c_str());
 #endif
       this->on_ping_response(msg);
       break;
@@ -68,7 +64,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       DeviceInfoRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_device_info_request"), msg);
+      ESP_LOGVV(TAG, "on_device_info_request: %s", msg.dump().c_str());
 #endif
       this->on_device_info_request(msg);
       break;
@@ -77,7 +73,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ListEntitiesRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_list_entities_request"), msg);
+      ESP_LOGVV(TAG, "on_list_entities_request: %s", msg.dump().c_str());
 #endif
       this->on_list_entities_request(msg);
       break;
@@ -86,7 +82,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SubscribeStatesRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_states_request"), msg);
+      ESP_LOGVV(TAG, "on_subscribe_states_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_states_request(msg);
       break;
@@ -95,7 +91,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SubscribeLogsRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_logs_request"), msg);
+      ESP_LOGVV(TAG, "on_subscribe_logs_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_logs_request(msg);
       break;
@@ -105,7 +101,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       CoverCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_cover_command_request"), msg);
+      ESP_LOGVV(TAG, "on_cover_command_request: %s", msg.dump().c_str());
 #endif
       this->on_cover_command_request(msg);
       break;
@@ -116,7 +112,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       FanCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_fan_command_request"), msg);
+      ESP_LOGVV(TAG, "on_fan_command_request: %s", msg.dump().c_str());
 #endif
       this->on_fan_command_request(msg);
       break;
@@ -127,7 +123,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       LightCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_light_command_request"), msg);
+      ESP_LOGVV(TAG, "on_light_command_request: %s", msg.dump().c_str());
 #endif
       this->on_light_command_request(msg);
       break;
@@ -138,7 +134,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SwitchCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_switch_command_request"), msg);
+      ESP_LOGVV(TAG, "on_switch_command_request: %s", msg.dump().c_str());
 #endif
       this->on_switch_command_request(msg);
       break;
@@ -149,7 +145,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SubscribeHomeassistantServicesRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_homeassistant_services_request"), msg);
+      ESP_LOGVV(TAG, "on_subscribe_homeassistant_services_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_homeassistant_services_request(msg);
       break;
@@ -159,7 +155,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       GetTimeResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_get_time_response"), msg);
+      ESP_LOGVV(TAG, "on_get_time_response: %s", msg.dump().c_str());
 #endif
       this->on_get_time_response(msg);
       break;
@@ -169,7 +165,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SubscribeHomeAssistantStatesRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_home_assistant_states_request"), msg);
+      ESP_LOGVV(TAG, "on_subscribe_home_assistant_states_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_home_assistant_states_request(msg);
       break;
@@ -180,7 +176,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       HomeAssistantStateResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_home_assistant_state_response"), msg);
+      ESP_LOGVV(TAG, "on_home_assistant_state_response: %s", msg.dump().c_str());
 #endif
       this->on_home_assistant_state_response(msg);
       break;
@@ -191,7 +187,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ExecuteServiceRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_execute_service_request"), msg);
+      ESP_LOGVV(TAG, "on_execute_service_request: %s", msg.dump().c_str());
 #endif
       this->on_execute_service_request(msg);
       break;
@@ -202,7 +198,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       CameraImageRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_camera_image_request"), msg);
+      ESP_LOGVV(TAG, "on_camera_image_request: %s", msg.dump().c_str());
 #endif
       this->on_camera_image_request(msg);
       break;
@@ -213,7 +209,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ClimateCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_climate_command_request"), msg);
+      ESP_LOGVV(TAG, "on_climate_command_request: %s", msg.dump().c_str());
 #endif
       this->on_climate_command_request(msg);
       break;
@@ -224,7 +220,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       NumberCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_number_command_request"), msg);
+      ESP_LOGVV(TAG, "on_number_command_request: %s", msg.dump().c_str());
 #endif
       this->on_number_command_request(msg);
       break;
@@ -235,7 +231,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SelectCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_select_command_request"), msg);
+      ESP_LOGVV(TAG, "on_select_command_request: %s", msg.dump().c_str());
 #endif
       this->on_select_command_request(msg);
       break;
@@ -246,7 +242,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SirenCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_siren_command_request"), msg);
+      ESP_LOGVV(TAG, "on_siren_command_request: %s", msg.dump().c_str());
 #endif
       this->on_siren_command_request(msg);
       break;
@@ -257,7 +253,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       LockCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_lock_command_request"), msg);
+      ESP_LOGVV(TAG, "on_lock_command_request: %s", msg.dump().c_str());
 #endif
       this->on_lock_command_request(msg);
       break;
@@ -268,7 +264,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ButtonCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_button_command_request"), msg);
+      ESP_LOGVV(TAG, "on_button_command_request: %s", msg.dump().c_str());
 #endif
       this->on_button_command_request(msg);
       break;
@@ -279,7 +275,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       MediaPlayerCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_media_player_command_request"), msg);
+      ESP_LOGVV(TAG, "on_media_player_command_request: %s", msg.dump().c_str());
 #endif
       this->on_media_player_command_request(msg);
       break;
@@ -290,7 +286,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SubscribeBluetoothLEAdvertisementsRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_bluetooth_le_advertisements_request"), msg);
+      ESP_LOGVV(TAG, "on_subscribe_bluetooth_le_advertisements_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_bluetooth_le_advertisements_request(msg);
       break;
@@ -301,7 +297,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothDeviceRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_device_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_device_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_device_request(msg);
       break;
@@ -312,7 +308,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothGATTGetServicesRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_gatt_get_services_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_get_services_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_get_services_request(msg);
       break;
@@ -323,7 +319,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothGATTReadRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_gatt_read_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_read_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_read_request(msg);
       break;
@@ -334,7 +330,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothGATTWriteRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_gatt_write_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_write_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_write_request(msg);
       break;
@@ -345,7 +341,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothGATTReadDescriptorRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_gatt_read_descriptor_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_read_descriptor_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_read_descriptor_request(msg);
       break;
@@ -356,7 +352,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothGATTWriteDescriptorRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_gatt_write_descriptor_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_write_descriptor_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_write_descriptor_request(msg);
       break;
@@ -367,7 +363,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothGATTNotifyRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_gatt_notify_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_gatt_notify_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_notify_request(msg);
       break;
@@ -378,7 +374,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SubscribeBluetoothConnectionsFreeRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_bluetooth_connections_free_request"), msg);
+      ESP_LOGVV(TAG, "on_subscribe_bluetooth_connections_free_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_bluetooth_connections_free_request(msg);
       break;
@@ -389,7 +385,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       UnsubscribeBluetoothLEAdvertisementsRequest msg;
       // Empty message: no decode needed
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_unsubscribe_bluetooth_le_advertisements_request"), msg);
+      ESP_LOGVV(TAG, "on_unsubscribe_bluetooth_le_advertisements_request: %s", msg.dump().c_str());
 #endif
       this->on_unsubscribe_bluetooth_le_advertisements_request(msg);
       break;
@@ -400,7 +396,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       SubscribeVoiceAssistantRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_subscribe_voice_assistant_request"), msg);
+      ESP_LOGVV(TAG, "on_subscribe_voice_assistant_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_voice_assistant_request(msg);
       break;
@@ -411,7 +407,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       VoiceAssistantResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_voice_assistant_response"), msg);
+      ESP_LOGVV(TAG, "on_voice_assistant_response: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_response(msg);
       break;
@@ -422,7 +418,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       VoiceAssistantEventResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_voice_assistant_event_response"), msg);
+      ESP_LOGVV(TAG, "on_voice_assistant_event_response: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_event_response(msg);
       break;
@@ -433,7 +429,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       AlarmControlPanelCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_alarm_control_panel_command_request"), msg);
+      ESP_LOGVV(TAG, "on_alarm_control_panel_command_request: %s", msg.dump().c_str());
 #endif
       this->on_alarm_control_panel_command_request(msg);
       break;
@@ -444,7 +440,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       TextCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_text_command_request"), msg);
+      ESP_LOGVV(TAG, "on_text_command_request: %s", msg.dump().c_str());
 #endif
       this->on_text_command_request(msg);
       break;
@@ -455,7 +451,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       DateCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_date_command_request"), msg);
+      ESP_LOGVV(TAG, "on_date_command_request: %s", msg.dump().c_str());
 #endif
       this->on_date_command_request(msg);
       break;
@@ -466,7 +462,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       TimeCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_time_command_request"), msg);
+      ESP_LOGVV(TAG, "on_time_command_request: %s", msg.dump().c_str());
 #endif
       this->on_time_command_request(msg);
       break;
@@ -477,7 +473,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       VoiceAssistantAudio msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_voice_assistant_audio"), msg);
+      ESP_LOGVV(TAG, "on_voice_assistant_audio: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_audio(msg);
       break;
@@ -488,7 +484,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ValveCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_valve_command_request"), msg);
+      ESP_LOGVV(TAG, "on_valve_command_request: %s", msg.dump().c_str());
 #endif
       this->on_valve_command_request(msg);
       break;
@@ -499,7 +495,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       DateTimeCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_date_time_command_request"), msg);
+      ESP_LOGVV(TAG, "on_date_time_command_request: %s", msg.dump().c_str());
 #endif
       this->on_date_time_command_request(msg);
       break;
@@ -510,7 +506,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       VoiceAssistantTimerEventResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_voice_assistant_timer_event_response"), msg);
+      ESP_LOGVV(TAG, "on_voice_assistant_timer_event_response: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_timer_event_response(msg);
       break;
@@ -521,7 +517,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       UpdateCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_update_command_request"), msg);
+      ESP_LOGVV(TAG, "on_update_command_request: %s", msg.dump().c_str());
 #endif
       this->on_update_command_request(msg);
       break;
@@ -532,7 +528,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       VoiceAssistantAnnounceRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_voice_assistant_announce_request"), msg);
+      ESP_LOGVV(TAG, "on_voice_assistant_announce_request: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_announce_request(msg);
       break;
@@ -543,7 +539,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       VoiceAssistantConfigurationRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_voice_assistant_configuration_request"), msg);
+      ESP_LOGVV(TAG, "on_voice_assistant_configuration_request: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_configuration_request(msg);
       break;
@@ -554,7 +550,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       VoiceAssistantSetConfiguration msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_voice_assistant_set_configuration"), msg);
+      ESP_LOGVV(TAG, "on_voice_assistant_set_configuration: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_set_configuration(msg);
       break;
@@ -565,7 +561,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       NoiseEncryptionSetKeyRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_noise_encryption_set_key_request"), msg);
+      ESP_LOGVV(TAG, "on_noise_encryption_set_key_request: %s", msg.dump().c_str());
 #endif
       this->on_noise_encryption_set_key_request(msg);
       break;
@@ -576,7 +572,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       BluetoothScannerSetModeRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_bluetooth_scanner_set_mode_request"), msg);
+      ESP_LOGVV(TAG, "on_bluetooth_scanner_set_mode_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_scanner_set_mode_request(msg);
       break;
@@ -587,7 +583,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ZWaveProxyFrame msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_z_wave_proxy_frame"), msg);
+      ESP_LOGVV(TAG, "on_z_wave_proxy_frame: %s", msg.dump().c_str());
 #endif
       this->on_z_wave_proxy_frame(msg);
       break;
@@ -598,7 +594,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       ZWaveProxyRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_z_wave_proxy_request"), msg);
+      ESP_LOGVV(TAG, "on_z_wave_proxy_request: %s", msg.dump().c_str());
 #endif
       this->on_z_wave_proxy_request(msg);
       break;
@@ -609,7 +605,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       HomeassistantActionResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_homeassistant_action_response"), msg);
+      ESP_LOGVV(TAG, "on_homeassistant_action_response: %s", msg.dump().c_str());
 #endif
       this->on_homeassistant_action_response(msg);
       break;
@@ -620,7 +616,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       WaterHeaterCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_water_heater_command_request"), msg);
+      ESP_LOGVV(TAG, "on_water_heater_command_request: %s", msg.dump().c_str());
 #endif
       this->on_water_heater_command_request(msg);
       break;
@@ -631,7 +627,7 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       InfraredRFTransmitRawTimingsRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
-      this->log_receive_message_(LOG_STR("on_infrared_rf_transmit_raw_timings_request"), msg);
+      ESP_LOGVV(TAG, "on_infrared_rf_transmit_raw_timings_request: %s", msg.dump().c_str());
 #endif
       this->on_infrared_rf_transmit_raw_timings_request(msg);
       break;

esphome/components/api/api_pb2_service.h

@@ -12,16 +12,14 @@ class APIServerConnectionBase : public ProtoService {
  public:
 #ifdef HAS_PROTO_MESSAGE_DUMP
  protected:
-  void log_send_message_(const char *name, const char *dump);
-  void log_receive_message_(const LogString *name, const ProtoMessage &msg);
+  void log_send_message_(const char *name, const std::string &dump);
 
  public:
 #endif
 
   bool send_message(const ProtoMessage &msg, uint8_t message_type) {
 #ifdef HAS_PROTO_MESSAGE_DUMP
-    DumpBuffer dump_buf;
-    this->log_send_message_(msg.message_name(), msg.dump_to(dump_buf));
+    this->log_send_message_(msg.message_name(), msg.dump());
 #endif
     return this->send_message_(msg, message_type);
   }

esphome/components/api/api_server.cpp

@@ -318,11 +318,13 @@ API_DISPATCH_UPDATE(water_heater::WaterHeater, water_heater)
 #endif
 
 #ifdef USE_EVENT
+// Event is a special case - unlike other entities with simple state fields,
+// events store their state in a member accessed via obj->get_last_event_type()
 void APIServer::on_event(event::Event *obj) {
   if (obj->is_internal())
     return;
   for (auto &c : this->clients_)
-    c->send_event(obj);
+    c->send_event(obj, obj->get_last_event_type());
 }
 #endif
 
@@ -613,7 +615,8 @@ void APIServer::on_shutdown() {
     if (!c->send_message(req, DisconnectRequest::MESSAGE_TYPE)) {
       // If we can't send the disconnect request directly (tx_buffer full),
       // schedule it at the front of the batch so it will be sent with priority
-      c->schedule_message_front_(nullptr, DisconnectRequest::MESSAGE_TYPE, DisconnectRequest::ESTIMATED_SIZE);
+      c->schedule_message_front_(nullptr, &APIConnection::try_send_disconnect_request, DisconnectRequest::MESSAGE_TYPE,
+                                 DisconnectRequest::ESTIMATED_SIZE);
     }
   }
 }
@@ -636,6 +639,14 @@ bool APIServer::teardown() {
 #define USE_API_ACTION_CALL_TIMEOUT_MS 30000  // NOLINT
 #endif
 
+// SSO-friendly action call key - hex format guarantees max 11 chars ("ac_ffffffff")
+// which fits in any std::string SSO buffer (typically 12-15 bytes)
+static inline std::string make_action_call_key(uint32_t id) {
+  char buf[12];
+  size_t len = snprintf(buf, sizeof(buf), "ac_%x", id);
+  return std::string(buf, len);
+}
+
 uint32_t APIServer::register_active_action_call(uint32_t client_call_id, APIConnection *conn) {
   uint32_t action_call_id = this->next_action_call_id_++;
   // Handle wraparound (skip 0 as it means "no call")
@@ -645,18 +656,17 @@ uint32_t APIServer::register_active_action_call(uint32_t client_call_id, APIConn
   this->active_action_calls_.push_back({action_call_id, client_call_id, conn});
 
   // Schedule automatic cleanup after timeout (client will have given up by then)
-  this->set_timeout(str_sprintf("action_call_%u", action_call_id), USE_API_ACTION_CALL_TIMEOUT_MS,
-                    [this, action_call_id]() {
-                      ESP_LOGD(TAG, "Action call %u timed out", action_call_id);
-                      this->unregister_active_action_call(action_call_id);
-                    });
+  this->set_timeout(make_action_call_key(action_call_id), USE_API_ACTION_CALL_TIMEOUT_MS, [this, action_call_id]() {
+    ESP_LOGD(TAG, "Action call %u timed out", action_call_id);
+    this->unregister_active_action_call(action_call_id);
+  });
 
   return action_call_id;
 }
 
 void APIServer::unregister_active_action_call(uint32_t action_call_id) {
   // Cancel the timeout for this action call
-  this->cancel_timeout(str_sprintf("action_call_%u", action_call_id));
+  this->cancel_timeout(make_action_call_key(action_call_id));
 
   // Swap-and-pop is more efficient than remove_if for unordered vectors
   for (size_t i = 0; i < this->active_action_calls_.size(); i++) {
@@ -673,7 +683,7 @@ void APIServer::unregister_active_action_calls_for_connection(APIConnection *con
   for (size_t i = 0; i < this->active_action_calls_.size();) {
     if (this->active_action_calls_[i].connection == conn) {
       // Cancel the timeout for this action call
-      this->cancel_timeout(str_sprintf("action_call_%u", this->active_action_calls_[i].action_call_id));
+      this->cancel_timeout(make_action_call_key(this->active_action_calls_[i].action_call_id));
 
       std::swap(this->active_action_calls_[i], this->active_action_calls_.back());
       this->active_action_calls_.pop_back();

esphome/components/api/list_entities.h

@@ -9,10 +9,11 @@ namespace esphome::api {
 class APIConnection;
 
 // Macro for generating ListEntitiesIterator handlers
-// Calls schedule_message_ which dispatches to try_send_*_info
+// Calls schedule_message_ with try_send_*_info
 #define LIST_ENTITIES_HANDLER(entity_type, EntityClass, ResponseType) \
   bool ListEntitiesIterator::on_##entity_type(EntityClass *entity) { /* NOLINT(bugprone-macro-parentheses) */ \
-    return this->client_->schedule_message_(entity, ResponseType::MESSAGE_TYPE, ResponseType::ESTIMATED_SIZE); \
+    return this->client_->schedule_message_(entity, &APIConnection::try_send_##entity_type##_info, \
+                                            ResponseType::MESSAGE_TYPE, ResponseType::ESTIMATED_SIZE); \
   }
 
 class ListEntitiesIterator : public ComponentIterator {

esphome/components/api/proto.cpp

@@ -139,4 +139,12 @@ void ProtoDecodableMessage::decode(const uint8_t *buffer, size_t length) {
   }
 }
 
+#ifdef HAS_PROTO_MESSAGE_DUMP
+std::string ProtoMessage::dump() const {
+  std::string out;
+  this->dump_to(out);
+  return out;
+}
+#endif
+
 }  // namespace esphome::api

esphome/components/api/proto.h

@@ -362,63 +362,6 @@ class ProtoWriteBuffer {
   std::vector<uint8_t> *buffer_;
 };
 
-#ifdef HAS_PROTO_MESSAGE_DUMP
-/**
- * Fixed-size buffer for message dumps - avoids heap allocation.
- * Sized to match the logger's default tx_buffer_size (512 bytes)
- * since anything larger gets truncated anyway.
- */
-class DumpBuffer {
- public:
-  // Matches default tx_buffer_size in logger component
-  static constexpr size_t CAPACITY = 512;
-
-  DumpBuffer() : pos_(0) { buf_[0] = '\0'; }
-
-  DumpBuffer &append(const char *str) {
-    if (str) {
-      append_impl_(str, strlen(str));
-    }
-    return *this;
-  }
-
-  DumpBuffer &append(const char *str, size_t len) {
-    append_impl_(str, len);
-    return *this;
-  }
-
-  DumpBuffer &append(size_t n, char c) {
-    size_t space = CAPACITY - 1 - pos_;
-    if (n > space)
-      n = space;
-    if (n > 0) {
-      memset(buf_ + pos_, c, n);
-      pos_ += n;
-      buf_[pos_] = '\0';
-    }
-    return *this;
-  }
-
-  const char *c_str() const { return buf_; }
-  size_t size() const { return pos_; }
-
- private:
-  void append_impl_(const char *str, size_t len) {
-    size_t space = CAPACITY - 1 - pos_;
-    if (len > space)
-      len = space;
-    if (len > 0) {
-      memcpy(buf_ + pos_, str, len);
-      pos_ += len;
-      buf_[pos_] = '\0';
-    }
-  }
-
-  char buf_[CAPACITY];
-  size_t pos_;
-};
-#endif
-
 class ProtoMessage {
  public:
   virtual ~ProtoMessage() = default;
@@ -427,7 +370,8 @@ class ProtoMessage {
   // Default implementation for messages with no fields
   virtual void calculate_size(ProtoSize &size) const {}
 #ifdef HAS_PROTO_MESSAGE_DUMP
-  virtual const char *dump_to(DumpBuffer &out) const = 0;
+  std::string dump() const;
+  virtual void dump_to(std::string &out) const = 0;
   virtual const char *message_name() const { return "unknown"; }
 #endif
 };

esphome/components/bh1750/bh1750.cpp

@@ -1,8 +1,8 @@
 #include "bh1750.h"
 #include "esphome/core/log.h"
-#include "esphome/core/application.h"
 
-namespace esphome::bh1750 {
+namespace esphome {
+namespace bh1750 {
 
 static const char *const TAG = "bh1750.sensor";
 
@@ -13,31 +13,6 @@ static const uint8_t BH1750_COMMAND_ONE_TIME_L = 0b00100011;
 static const uint8_t BH1750_COMMAND_ONE_TIME_H = 0b00100000;
 static const uint8_t BH1750_COMMAND_ONE_TIME_H2 = 0b00100001;
 
-static constexpr uint32_t MEASUREMENT_TIMEOUT_MS = 2000;
-static constexpr float HIGH_LIGHT_THRESHOLD_LX = 7000.0f;
-
-// Measurement time constants (datasheet values)
-static constexpr uint16_t MTREG_DEFAULT = 69;
-static constexpr uint16_t MTREG_MIN = 31;
-static constexpr uint16_t MTREG_MAX = 254;
-static constexpr uint16_t MEAS_TIME_L_MS = 24;   // L-resolution max measurement time @ mtreg=69
-static constexpr uint16_t MEAS_TIME_H_MS = 180;  // H/H2-resolution max measurement time @ mtreg=69
-
-// Conversion constants (datasheet formulas)
-static constexpr float RESOLUTION_DIVISOR = 1.2f;  // counts to lux conversion divisor
-static constexpr float MODE_H2_DIVISOR = 2.0f;     // H2 mode has 2x higher resolution
-
-// MTreg calculation constants
-static constexpr int COUNTS_TARGET = 50000;  // Target counts for optimal range (avoid saturation)
-static constexpr int COUNTS_NUMERATOR = 10;
-static constexpr int COUNTS_DENOMINATOR = 12;
-
-// MTreg register bit manipulation constants
-static constexpr uint8_t MTREG_HI_SHIFT = 5;       // High 3 bits start at bit 5
-static constexpr uint8_t MTREG_HI_MASK = 0b111;    // 3-bit mask for high bits
-static constexpr uint8_t MTREG_LO_SHIFT = 0;       // Low 5 bits start at bit 0
-static constexpr uint8_t MTREG_LO_MASK = 0b11111;  // 5-bit mask for low bits
-
 /*
 bh1750 properties:
 
@@ -68,7 +43,74 @@ void BH1750Sensor::setup() {
     this->mark_failed();
     return;
   }
-  this->state_ = IDLE;
+}
+
+void BH1750Sensor::read_lx_(BH1750Mode mode, uint8_t mtreg, const std::function<void(float)> &f) {
+  // turn on (after one-shot sensor automatically powers down)
+  uint8_t turn_on = BH1750_COMMAND_POWER_ON;
+  if (this->write(&turn_on, 1) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Power on failed");
+    f(NAN);
+    return;
+  }
+
+  if (active_mtreg_ != mtreg) {
+    // set mtreg
+    uint8_t mtreg_hi = BH1750_COMMAND_MT_REG_HI | ((mtreg >> 5) & 0b111);
+    uint8_t mtreg_lo = BH1750_COMMAND_MT_REG_LO | ((mtreg >> 0) & 0b11111);
+    if (this->write(&mtreg_hi, 1) != i2c::ERROR_OK || this->write(&mtreg_lo, 1) != i2c::ERROR_OK) {
+      ESP_LOGW(TAG, "Set measurement time failed");
+      active_mtreg_ = 0;
+      f(NAN);
+      return;
+    }
+    active_mtreg_ = mtreg;
+  }
+
+  uint8_t cmd;
+  uint16_t meas_time;
+  switch (mode) {
+    case BH1750_MODE_L:
+      cmd = BH1750_COMMAND_ONE_TIME_L;
+      meas_time = 24 * mtreg / 69;
+      break;
+    case BH1750_MODE_H:
+      cmd = BH1750_COMMAND_ONE_TIME_H;
+      meas_time = 180 * mtreg / 69;
+      break;
+    case BH1750_MODE_H2:
+      cmd = BH1750_COMMAND_ONE_TIME_H2;
+      meas_time = 180 * mtreg / 69;
+      break;
+    default:
+      f(NAN);
+      return;
+  }
+  if (this->write(&cmd, 1) != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "Start measurement failed");
+    f(NAN);
+    return;
+  }
+
+  // probably not needed, but adjust for rounding
+  meas_time++;
+
+  this->set_timeout("read", meas_time, [this, mode, mtreg, f]() {
+    uint16_t raw_value;
+    if (this->read(reinterpret_cast<uint8_t *>(&raw_value), 2) != i2c::ERROR_OK) {
+      ESP_LOGW(TAG, "Read data failed");
+      f(NAN);
+      return;
+    }
+    raw_value = i2c::i2ctohs(raw_value);
+
+    float lx = float(raw_value) / 1.2f;
+    lx *= 69.0f / mtreg;
+    if (mode == BH1750_MODE_H2)
+      lx /= 2.0f;
+
+    f(lx);
+  });
 }
 
 void BH1750Sensor::dump_config() {
@@ -82,189 +124,45 @@ void BH1750Sensor::dump_config() {
 }
 
 void BH1750Sensor::update() {
-  const uint32_t now = millis();
-
-  // Start coarse measurement to determine optimal mode/mtreg
-  if (this->state_ != IDLE) {
-    // Safety timeout: reset if stuck
-    if (now - this->measurement_start_time_ > MEASUREMENT_TIMEOUT_MS) {
-      ESP_LOGW(TAG, "Measurement timeout, resetting state");
-      this->state_ = IDLE;
-    } else {
-      ESP_LOGW(TAG, "Previous measurement not complete, skipping update");
+  // first do a quick measurement in L-mode with full range
+  // to find right range
+  this->read_lx_(BH1750_MODE_L, 31, [this](float val) {
+    if (std::isnan(val)) {
+      this->status_set_warning();
+      this->publish_state(NAN);
       return;
     }
-  }
 
-  if (!this->start_measurement_(BH1750_MODE_L, MTREG_MIN, now)) {
-    this->status_set_warning();
-    this->publish_state(NAN);
-    return;
-  }
-
-  this->state_ = WAITING_COARSE_MEASUREMENT;
-  this->enable_loop();  // Enable loop while measurement in progress
-}
-
-void BH1750Sensor::loop() {
-  const uint32_t now = App.get_loop_component_start_time();
-
-  switch (this->state_) {
-    case IDLE:
-      // Disable loop when idle to save cycles
-      this->disable_loop();
-      break;
-
-    case WAITING_COARSE_MEASUREMENT:
-      if (now - this->measurement_start_time_ >= this->measurement_duration_) {
-        this->state_ = READING_COARSE_RESULT;
-      }
-      break;
-
-    case READING_COARSE_RESULT: {
-      float lx;
-      if (!this->read_measurement_(lx)) {
-        this->fail_and_reset_();
-        break;
-      }
-
-      this->process_coarse_result_(lx);
-
-      // Start fine measurement with optimal settings
-      // fetch millis() again since the read can take a bit
-      if (!this->start_measurement_(this->fine_mode_, this->fine_mtreg_, millis())) {
-        this->fail_and_reset_();
-        break;
-      }
-
-      this->state_ = WAITING_FINE_MEASUREMENT;
-      break;
+    BH1750Mode use_mode;
+    uint8_t use_mtreg;
+    if (val <= 7000) {
+      use_mode = BH1750_MODE_H2;
+      use_mtreg = 254;
+    } else {
+      use_mode = BH1750_MODE_H;
+      // lx = counts / 1.2 * (69 / mtreg)
+      // -> mtreg = counts / 1.2 * (69 / lx)
+      // calculate for counts=50000 (allow some range to not saturate, but maximize mtreg)
+      // -> mtreg = 50000*(10/12)*(69/lx)
+      int ideal_mtreg = 50000 * 10 * 69 / (12 * (int) val);
+      use_mtreg = std::min(254, std::max(31, ideal_mtreg));
     }
+    ESP_LOGV(TAG, "L result: %f -> Calculated mode=%d, mtreg=%d", val, (int) use_mode, use_mtreg);
 
-    case WAITING_FINE_MEASUREMENT:
-      if (now - this->measurement_start_time_ >= this->measurement_duration_) {
-        this->state_ = READING_FINE_RESULT;
+    this->read_lx_(use_mode, use_mtreg, [this](float val) {
+      if (std::isnan(val)) {
+        this->status_set_warning();
+        this->publish_state(NAN);
+        return;
       }
-      break;
-
-    case READING_FINE_RESULT: {
-      float lx;
-      if (!this->read_measurement_(lx)) {
-        this->fail_and_reset_();
-        break;
-      }
-
-      ESP_LOGD(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), lx);
+      ESP_LOGD(TAG, "'%s': Illuminance=%.1flx", this->get_name().c_str(), val);
       this->status_clear_warning();
-      this->publish_state(lx);
-      this->state_ = IDLE;
-      break;
-    }
-  }
-}
-
-bool BH1750Sensor::start_measurement_(BH1750Mode mode, uint8_t mtreg, uint32_t now) {
-  // Power on
-  uint8_t turn_on = BH1750_COMMAND_POWER_ON;
-  if (this->write(&turn_on, 1) != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "Power on failed");
-    return false;
-  }
-
-  // Set MTreg if changed
-  if (this->active_mtreg_ != mtreg) {
-    uint8_t mtreg_hi = BH1750_COMMAND_MT_REG_HI | ((mtreg >> MTREG_HI_SHIFT) & MTREG_HI_MASK);
-    uint8_t mtreg_lo = BH1750_COMMAND_MT_REG_LO | ((mtreg >> MTREG_LO_SHIFT) & MTREG_LO_MASK);
-    if (this->write(&mtreg_hi, 1) != i2c::ERROR_OK || this->write(&mtreg_lo, 1) != i2c::ERROR_OK) {
-      ESP_LOGW(TAG, "Set measurement time failed");
-      this->active_mtreg_ = 0;
-      return false;
-    }
-    this->active_mtreg_ = mtreg;
-  }
-
-  // Start measurement
-  uint8_t cmd;
-  uint16_t meas_time;
-  switch (mode) {
-    case BH1750_MODE_L:
-      cmd = BH1750_COMMAND_ONE_TIME_L;
-      meas_time = MEAS_TIME_L_MS * mtreg / MTREG_DEFAULT;
-      break;
-    case BH1750_MODE_H:
-      cmd = BH1750_COMMAND_ONE_TIME_H;
-      meas_time = MEAS_TIME_H_MS * mtreg / MTREG_DEFAULT;
-      break;
-    case BH1750_MODE_H2:
-      cmd = BH1750_COMMAND_ONE_TIME_H2;
-      meas_time = MEAS_TIME_H_MS * mtreg / MTREG_DEFAULT;
-      break;
-    default:
-      return false;
-  }
-
-  if (this->write(&cmd, 1) != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "Start measurement failed");
-    return false;
-  }
-
-  // Store current measurement parameters
-  this->current_mode_ = mode;
-  this->current_mtreg_ = mtreg;
-  this->measurement_start_time_ = now;
-  this->measurement_duration_ = meas_time + 1;  // Add 1ms for safety
-
-  return true;
-}
-
-bool BH1750Sensor::read_measurement_(float &lx_out) {
-  uint16_t raw_value;
-  if (this->read(reinterpret_cast<uint8_t *>(&raw_value), 2) != i2c::ERROR_OK) {
-    ESP_LOGW(TAG, "Read data failed");
-    return false;
-  }
-  raw_value = i2c::i2ctohs(raw_value);
-
-  float lx = float(raw_value) / RESOLUTION_DIVISOR;
-  lx *= float(MTREG_DEFAULT) / this->current_mtreg_;
-  if (this->current_mode_ == BH1750_MODE_H2) {
-    lx /= MODE_H2_DIVISOR;
-  }
-
-  lx_out = lx;
-  return true;
-}
-
-void BH1750Sensor::process_coarse_result_(float lx) {
-  if (std::isnan(lx)) {
-    // Use defaults if coarse measurement failed
-    this->fine_mode_ = BH1750_MODE_H2;
-    this->fine_mtreg_ = MTREG_MAX;
-    return;
-  }
-
-  if (lx <= HIGH_LIGHT_THRESHOLD_LX) {
-    this->fine_mode_ = BH1750_MODE_H2;
-    this->fine_mtreg_ = MTREG_MAX;
-  } else {
-    this->fine_mode_ = BH1750_MODE_H;
-    // lx = counts / 1.2 * (69 / mtreg)
-    // -> mtreg = counts / 1.2 * (69 / lx)
-    // calculate for counts=50000 (allow some range to not saturate, but maximize mtreg)
-    // -> mtreg = 50000*(10/12)*(69/lx)
-    int ideal_mtreg = COUNTS_TARGET * COUNTS_NUMERATOR * MTREG_DEFAULT / (COUNTS_DENOMINATOR * (int) lx);
-    this->fine_mtreg_ = std::min((int) MTREG_MAX, std::max((int) MTREG_MIN, ideal_mtreg));
-  }
-
-  ESP_LOGV(TAG, "L result: %.1f -> Calculated mode=%d, mtreg=%d", lx, (int) this->fine_mode_, this->fine_mtreg_);
-}
-
-void BH1750Sensor::fail_and_reset_() {
-  this->status_set_warning();
-  this->publish_state(NAN);
-  this->state_ = IDLE;
+      this->publish_state(val);
+    });
+  });
 }
 
 float BH1750Sensor::get_setup_priority() const { return setup_priority::DATA; }
 
-}  // namespace esphome::bh1750
+}  // namespace bh1750
+}  // namespace esphome

esphome/components/bh1750/bh1750.h

@@ -4,9 +4,10 @@
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
 
-namespace esphome::bh1750 {
+namespace esphome {
+namespace bh1750 {
 
-enum BH1750Mode : uint8_t {
+enum BH1750Mode {
   BH1750_MODE_L,
   BH1750_MODE_H,
   BH1750_MODE_H2,
@@ -20,36 +21,13 @@ class BH1750Sensor : public sensor::Sensor, public PollingComponent, public i2c:
   void setup() override;
   void dump_config() override;
   void update() override;
-  void loop() override;
   float get_setup_priority() const override;
 
  protected:
-  // State machine states
-  enum State : uint8_t {
-    IDLE,
-    WAITING_COARSE_MEASUREMENT,
-    READING_COARSE_RESULT,
-    WAITING_FINE_MEASUREMENT,
-    READING_FINE_RESULT,
-  };
+  void read_lx_(BH1750Mode mode, uint8_t mtreg, const std::function<void(float)> &f);
 
-  // 4-byte aligned members
-  uint32_t measurement_start_time_{0};
-  uint32_t measurement_duration_{0};
-
-  // 1-byte members grouped together to minimize padding
-  State state_{IDLE};
-  BH1750Mode current_mode_{BH1750_MODE_L};
-  uint8_t current_mtreg_{31};
-  BH1750Mode fine_mode_{BH1750_MODE_H2};
-  uint8_t fine_mtreg_{254};
   uint8_t active_mtreg_{0};
-
-  // Helper methods
-  bool start_measurement_(BH1750Mode mode, uint8_t mtreg, uint32_t now);
-  bool read_measurement_(float &lx_out);
-  void process_coarse_result_(float lx);
-  void fail_and_reset_();
 };
 
-}  // namespace esphome::bh1750
+}  // namespace bh1750
+}  // namespace esphome

esphome/components/bk72xx/__init__.py

@@ -1,23 +1,9 @@
-"""
-██╗    ██╗ █████╗ ██████╗ ███╗   ██╗██╗███╗   ██╗ ██████╗
-██║    ██║██╔══██╗██╔══██╗████╗  ██║██║████╗  ██║██╔════╝
-██║ █╗ ██║███████║██████╔╝██╔██╗ ██║██║██╔██╗ ██║██║  ███╗
-██║███╗██║██╔══██║██╔══██╗██║╚██╗██║██║██║╚██╗██║██║   ██║
-╚███╔███╔╝██║  ██║██║  ██║██║ ╚████║██║██║ ╚████║╚██████╔╝
- ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═══╝ ╚═════╝
-
-         AUTO-GENERATED FILE - DO NOT EDIT!
-
-This file was auto-generated by libretiny/generate_components.py.
-Any manual changes WILL BE LOST on regeneration.
-
-To customize this component:
-  - Pin validators: Create gpio.py with validate_pin() or validate_usage()
-  - Schema extensions: Create schema.py with COMPONENT_SCHEMA or COMPONENT_PIN_SCHEMA
-
-Platform-specific code should be added to the main libretiny component
-(__init__.py in esphome/components/libretiny/) rather than here.
-"""
+# This file was auto-generated by libretiny/generate_components.py
+# Do not modify its contents.
+# For custom pin validators, put validate_pin() or validate_usage()
+# in gpio.py file in this directory.
+# For changing schema/pin schema, put COMPONENT_SCHEMA or COMPONENT_PIN_SCHEMA
+# in schema.py file in this directory.
 
 from esphome import pins
 from esphome.components import libretiny
@@ -41,7 +27,6 @@ COMPONENT_DATA = LibreTinyComponent(
     board_pins=BK72XX_BOARD_PINS,
     pin_validation=None,
     usage_validation=None,
-    supports_atomics=False,
 )
 
 

esphome/components/ble_nus/__init__.py

@@ -1,5 +1,4 @@
 import esphome.codegen as cg
-from esphome.components.logger import request_log_listener
 from esphome.components.zephyr import zephyr_add_prj_conf
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_LOGS, CONF_TYPE
@@ -26,8 +25,5 @@ CONFIG_SCHEMA = cv.All(
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     zephyr_add_prj_conf("BT_NUS", True)
-    expose_log = config[CONF_TYPE] == CONF_LOGS
-    cg.add(var.set_expose_log(expose_log))
-    if expose_log:
-        request_log_listener()  # Request a log listener slot for BLE NUS log streaming
+    cg.add(var.set_expose_log(config[CONF_TYPE] == CONF_LOGS))
     await cg.register_component(var, config)

esphome/components/bme68x_bsec2/sensor.py

@@ -50,7 +50,7 @@ TYPES = [
 
 CONFIG_SCHEMA = cv.Schema(
     {
-        cv.GenerateID(): cv.declare_id(cg.EntityBase),
+        cv.GenerateID(): cv.declare_id(cg.Component),
         cv.GenerateID(CONF_BME68X_BSEC2_ID): cv.use_id(BME68xBSEC2Component),
         cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
             unit_of_measurement=UNIT_CELSIUS,

esphome/components/epaper_spi/display.py

@@ -184,7 +184,6 @@ async def to_code(config):
         height,
         init_sequence_id,
         init_sequence_length,
-        *model.get_constructor_args(config),
     )
 
     # Rotation is handled by setting the transform

esphome/components/epaper_spi/epaper_spi.cpp

@@ -54,14 +54,20 @@ void EPaperBase::setup_pins_() const {
 float EPaperBase::get_setup_priority() const { return setup_priority::PROCESSOR; }
 
 void EPaperBase::command(uint8_t value) {
-  ESP_LOGV(TAG, "Command: 0x%02X", value);
-  this->dc_pin_->digital_write(false);
-  this->enable();
+  this->start_command_();
   this->write_byte(value);
-  this->disable();
+  this->end_command_();
+}
+
+void EPaperBase::data(uint8_t value) {
+  this->start_data_();
+  this->write_byte(value);
+  this->end_data_();
 }
 
 // write a command followed by zero or more bytes of data.
+// The command is the first byte, length is the length of data only in the second byte, followed by the data.
+// [COMMAND, LENGTH, DATA...]
 void EPaperBase::cmd_data(uint8_t command, const uint8_t *ptr, size_t length) {
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
   char hex_buf[format_hex_pretty_size(EPAPER_MAX_CMD_LOG_BYTES)];
@@ -124,10 +130,14 @@ void EPaperBase::wait_for_idle_(bool should_wait) {
 
 void EPaperBase::loop() {
   auto now = millis();
-  // using modulus arithmetic to handle wrap-around
-  int diff = now - this->delay_until_;
-  if (diff < 0)
-    return;
+  if (this->delay_until_ != 0) {
+    // using modulus arithmetic to handle wrap-around
+    int diff = now - this->delay_until_;
+    if (diff < 0) {
+      return;
+    }
+    this->delay_until_ = 0;
+  }
   if (this->waiting_for_idle_) {
     if (this->is_idle_()) {
       this->waiting_for_idle_ = false;
@@ -182,7 +192,7 @@ void EPaperBase::process_state_() {
       this->set_state_(EPaperState::RESET);
       break;
     case EPaperState::INITIALISE:
-      this->initialise(this->update_count_ != 0);
+      this->initialise_();
       this->set_state_(EPaperState::TRANSFER_DATA);
       break;
     case EPaperState::TRANSFER_DATA:
@@ -220,11 +230,11 @@ void EPaperBase::set_state_(EPaperState state, uint16_t delay) {
   ESP_LOGV(TAG, "Exit state %s", this->epaper_state_to_string_());
   this->state_ = state;
   this->wait_for_idle_(state > EPaperState::SHOULD_WAIT);
-  // allow subclasses to nominate delays
-  if (delay == 0)
-    delay = this->next_delay_;
-  this->next_delay_ = 0;
-  this->delay_until_ = millis() + delay;
+  if (delay != 0) {
+    this->delay_until_ = millis() + delay;
+  } else {
+    this->delay_until_ = 0;
+  }
   ESP_LOGV(TAG, "Enter state %s, delay %u, wait_for_idle=%s", this->epaper_state_to_string_(), delay,
            TRUEFALSE(this->waiting_for_idle_));
   if (state == EPaperState::IDLE) {
@@ -232,14 +242,22 @@ void EPaperBase::set_state_(EPaperState state, uint16_t delay) {
   }
 }
 
+void EPaperBase::start_command_() {
+  this->dc_pin_->digital_write(false);
+  this->enable();
+}
+
+void EPaperBase::end_command_() { this->disable(); }
+
 void EPaperBase::start_data_() {
   this->dc_pin_->digital_write(true);
   this->enable();
 }
+void EPaperBase::end_data_() { this->disable(); }
 
 void EPaperBase::on_safe_shutdown() { this->deep_sleep(); }
 
-void EPaperBase::initialise(bool partial) {
+void EPaperBase::initialise_() {
   size_t index = 0;
 
   auto *sequence = this->init_sequence_;
@@ -299,8 +317,9 @@ bool EPaperBase::rotate_coordinates_(int &x, int &y) {
 void HOT EPaperBase::draw_pixel_at(int x, int y, Color color) {
   if (!rotate_coordinates_(x, y))
     return;
-  const size_t byte_position = y * this->row_width_ + x / 8;
-  const uint8_t bit_position = x % 8;
+  const size_t pixel_position = y * this->width_ + x;
+  const size_t byte_position = pixel_position / 8;
+  const uint8_t bit_position = pixel_position % 8;
   const uint8_t pixel_bit = 0x80 >> bit_position;
   const auto original = this->buffer_[byte_position];
   if ((color_to_bit(color) == 0)) {

esphome/components/epaper_spi/epaper_spi.h

@@ -36,16 +36,14 @@ class EPaperBase : public Display,
                    public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW, spi::CLOCK_PHASE_LEADING,
                                          spi::DATA_RATE_2MHZ> {
  public:
-  EPaperBase(const char *name, uint16_t width, uint16_t height, const uint8_t *init_sequence = nullptr,
-             size_t init_sequence_length = 0, DisplayType display_type = DISPLAY_TYPE_BINARY)
+  EPaperBase(const char *name, uint16_t width, uint16_t height, const uint8_t *init_sequence,
+             size_t init_sequence_length, DisplayType display_type = DISPLAY_TYPE_BINARY)
       : name_(name),
         width_(width),
         height_(height),
         init_sequence_(init_sequence),
         init_sequence_length_(init_sequence_length),
-        display_type_(display_type) {
-    this->row_width_ = (this->width_ + 7) / 8;  // width of a row in bytes
-  }
+        display_type_(display_type) {}
   void set_dc_pin(GPIOPin *dc_pin) { dc_pin_ = dc_pin; }
   float get_setup_priority() const override;
   void set_reset_pin(GPIOPin *reset) { this->reset_pin_ = reset; }
@@ -56,13 +54,9 @@ class EPaperBase : public Display,
   void dump_config() override;
 
   void command(uint8_t value);
+  void data(uint8_t value);
   void cmd_data(uint8_t command, const uint8_t *ptr, size_t length);
 
-  // variant with in-place initializer list
-  void cmd_data(uint8_t command, std::initializer_list<uint8_t> data) {
-    this->cmd_data(command, data.begin(), data.size());
-  }
-
   void update() override;
   void loop() override;
 
@@ -115,7 +109,7 @@ class EPaperBase : public Display,
   bool is_idle_() const;
   void setup_pins_() const;
   virtual bool reset();
-  virtual void initialise(bool partial);
+  void initialise_();
   void wait_for_idle_(bool should_wait);
   bool init_buffer_(size_t buffer_length);
   bool rotate_coordinates_(int &x, int &y);
@@ -149,12 +143,14 @@ class EPaperBase : public Display,
 
   void set_state_(EPaperState state, uint16_t delay = 0);
 
+  void start_command_();
+  void end_command_();
   void start_data_();
+  void end_data_();
 
   // properties initialised in the constructor
   const char *name_;
   uint16_t width_;
-  uint16_t row_width_;  // width of a row in bytes
   uint16_t height_;
   const uint8_t *init_sequence_;
   size_t init_sequence_length_;
@@ -167,8 +163,7 @@ class EPaperBase : public Display,
   GPIOPin *busy_pin_{};
   GPIOPin *reset_pin_{};
   bool waiting_for_idle_{};
-  uint32_t delay_until_{};  // timestamp until which to delay processing
-  uint16_t next_delay_{};   // milliseconds to delay before next state
+  uint32_t delay_until_{};
   uint8_t transform_{};
   uint8_t update_count_{};
   // these values represent the bounds of the updated buffer. Note that x_high and y_high

esphome/components/epaper_spi/epaper_spi_spectra_e6.cpp

@@ -80,17 +80,20 @@ void EPaperSpectraE6::power_on() {
 
 void EPaperSpectraE6::power_off() {
   ESP_LOGV(TAG, "Power off");
-  this->cmd_data(0x02, {0x00});
+  this->command(0x02);
+  this->data(0x00);
 }
 
 void EPaperSpectraE6::refresh_screen(bool partial) {
   ESP_LOGV(TAG, "Refresh");
-  this->cmd_data(0x12, {0x00});
+  this->command(0x12);
+  this->data(0x00);
 }
 
 void EPaperSpectraE6::deep_sleep() {
   ESP_LOGV(TAG, "Deep sleep");
-  this->cmd_data(0x07, {0xA5});
+  this->command(0x07);
+  this->data(0xA5);
 }
 
 void EPaperSpectraE6::fill(Color color) {
@@ -140,7 +143,7 @@ bool HOT EPaperSpectraE6::transfer_data() {
     if (buf_idx == sizeof bytes_to_send) {
       this->start_data_();
       this->write_array(bytes_to_send, buf_idx);
-      this->disable();
+      this->end_data_();
       ESP_LOGV(TAG, "Wrote %d bytes at %ums", buf_idx, (unsigned) millis());
       buf_idx = 0;
 
@@ -154,7 +157,7 @@ bool HOT EPaperSpectraE6::transfer_data() {
   if (buf_idx != 0) {
     this->start_data_();
     this->write_array(bytes_to_send, buf_idx);
-    this->disable();
+    this->end_data_();
   }
   this->current_data_index_ = 0;
   return true;

esphome/components/epaper_spi/epaper_spi_ssd1677.cpp

@@ -1,24 +1,25 @@
-#include "epaper_spi_mono.h"
+#include "epaper_spi_ssd1677.h"
 
 #include <algorithm>
 
 #include "esphome/core/log.h"
 
 namespace esphome::epaper_spi {
-static constexpr const char *const TAG = "epaper_spi.mono";
+static constexpr const char *const TAG = "epaper_spi.ssd1677";
 
-void EPaperMono::refresh_screen(bool partial) {
+void EPaperSSD1677::refresh_screen(bool partial) {
   ESP_LOGV(TAG, "Refresh screen");
-  this->cmd_data(0x22, {partial ? (uint8_t) 0xFF : (uint8_t) 0xF7});
+  this->command(0x22);
+  this->data(partial ? 0xFF : 0xF7);
   this->command(0x20);
 }
 
-void EPaperMono::deep_sleep() {
+void EPaperSSD1677::deep_sleep() {
   ESP_LOGV(TAG, "Deep sleep");
   this->command(0x10);
 }
 
-bool EPaperMono::reset() {
+bool EPaperSSD1677::reset() {
   if (EPaperBase::reset()) {
     this->command(0x12);
     return true;
@@ -26,24 +27,29 @@ bool EPaperMono::reset() {
   return false;
 }
 
-void EPaperMono::set_window() {
-  // round x-coordinates to byte boundaries
-  this->x_low_ &= ~7;
-  this->x_high_ += 7;
-  this->x_high_ &= ~7;
-  this->cmd_data(0x44, {(uint8_t) this->x_low_, (uint8_t) (this->x_low_ / 256), (uint8_t) (this->x_high_ - 1),
-                        (uint8_t) ((this->x_high_ - 1) / 256)});
-  this->cmd_data(0x4E, {(uint8_t) this->x_low_, (uint8_t) (this->x_low_ / 256)});
-  this->cmd_data(0x45, {(uint8_t) this->y_low_, (uint8_t) (this->y_low_ / 256), (uint8_t) (this->y_high_ - 1),
-                        (uint8_t) ((this->y_high_ - 1) / 256)});
-  this->cmd_data(0x4F, {(uint8_t) this->y_low_, (uint8_t) (this->y_low_ / 256)});
-}
-
-bool HOT EPaperMono::transfer_data() {
+bool HOT EPaperSSD1677::transfer_data() {
   auto start_time = millis();
   if (this->current_data_index_ == 0) {
+    uint8_t data[4]{};
     // round to byte boundaries
-    this->set_window();
+    this->x_low_ &= ~7;
+    this->y_low_ &= ~7;
+    this->x_high_ += 7;
+    this->x_high_ &= ~7;
+    this->y_high_ += 7;
+    this->y_high_ &= ~7;
+    data[0] = this->x_low_;
+    data[1] = this->x_low_ / 256;
+    data[2] = this->x_high_ - 1;
+    data[3] = (this->x_high_ - 1) / 256;
+    cmd_data(0x4E, data, 2);
+    cmd_data(0x44, data, sizeof(data));
+    data[0] = this->y_low_;
+    data[1] = this->y_low_ / 256;
+    data[2] = this->y_high_ - 1;
+    data[3] = (this->y_high_ - 1) / 256;
+    cmd_data(0x4F, data, 2);
+    this->cmd_data(0x45, data, sizeof(data));
     // for monochrome, we still need to clear the red data buffer at least once to prevent it
     // causing dirty pixels after partial refresh.
     this->command(this->send_red_ ? 0x26 : 0x24);
@@ -52,10 +58,10 @@ bool HOT EPaperMono::transfer_data() {
   size_t row_length = (this->x_high_ - this->x_low_) / 8;
   FixedVector<uint8_t> bytes_to_send{};
   bytes_to_send.init(row_length);
-  ESP_LOGV(TAG, "Writing %u bytes at line %zu at %ums", row_length, this->current_data_index_, (unsigned) millis());
+  ESP_LOGV(TAG, "Writing bytes at line %zu at %ums", this->current_data_index_, (unsigned) millis());
   this->start_data_();
   while (this->current_data_index_ != this->y_high_) {
-    size_t data_idx = this->current_data_index_ * this->row_width_ + this->x_low_ / 8;
+    size_t data_idx = (this->current_data_index_ * this->width_ + this->x_low_) / 8;
     for (size_t i = 0; i != row_length; i++) {
       bytes_to_send[i] = this->send_red_ ? 0 : this->buffer_[data_idx++];
     }
@@ -63,12 +69,12 @@ bool HOT EPaperMono::transfer_data() {
     this->write_array(&bytes_to_send.front(), row_length);  // NOLINT
     if (millis() - start_time > MAX_TRANSFER_TIME) {
       // Let the main loop run and come back next loop
-      this->disable();
+      this->end_data_();
       return false;
     }
   }
 
-  this->disable();
+  this->end_data_();
   this->current_data_index_ = 0;
   if (this->send_red_) {
     this->send_red_ = false;

esphome/components/epaper_spi/epaper_spi_ssd1677.h

@@ -3,15 +3,13 @@
 #include "epaper_spi.h"
 
 namespace esphome::epaper_spi {
-/**
- * A class for monochrome epaper displays.
- */
-class EPaperMono : public EPaperBase {
+
+class EPaperSSD1677 : public EPaperBase {
  public:
-  EPaperMono(const char *name, uint16_t width, uint16_t height, const uint8_t *init_sequence,
-             size_t init_sequence_length)
+  EPaperSSD1677(const char *name, uint16_t width, uint16_t height, const uint8_t *init_sequence,
+                size_t init_sequence_length)
       : EPaperBase(name, width, height, init_sequence, init_sequence_length, DISPLAY_TYPE_BINARY) {
-    this->buffer_length_ = (width + 7) / 8 * height;  // 8 pixels per byte, rounded up
+    this->buffer_length_ = width * height / 8;  // 8 pixels per byte
   }
 
  protected:
@@ -20,7 +18,6 @@ class EPaperMono : public EPaperBase {
   void power_off() override{};
   void deep_sleep() override;
   bool reset() override;
-  virtual void set_window();
   bool transfer_data() override;
   bool send_red_{true};
 };

esphome/components/epaper_spi/epaper_waveshare.cpp

@@ -1,47 +0,0 @@
-#include "epaper_waveshare.h"
-
-namespace esphome::epaper_spi {
-
-static const char *const TAG = "epaper_spi.waveshare";
-
-void EpaperWaveshare::initialise(bool partial) {
-  EPaperBase::initialise(partial);
-  if (partial) {
-    this->cmd_data(0x32, this->partial_lut_, this->partial_lut_length_);
-    this->cmd_data(0x3C, {0x80});
-    this->cmd_data(0x22, {0xC0});
-    this->command(0x20);
-    this->next_delay_ = 100;
-  } else {
-    this->cmd_data(0x32, this->lut_, this->lut_length_);
-    this->cmd_data(0x3C, {0x05});
-  }
-  this->send_red_ = true;
-}
-
-void EpaperWaveshare::set_window() {
-  this->x_low_ &= ~7;
-  this->x_high_ += 7;
-  this->x_high_ &= ~7;
-  uint16_t x_start = this->x_low_ / 8;
-  uint16_t x_end = (this->x_high_ - 1) / 8;
-  this->cmd_data(0x44, {(uint8_t) x_start, (uint8_t) (x_end)});
-  this->cmd_data(0x4E, {(uint8_t) x_start});
-  this->cmd_data(0x45, {(uint8_t) this->y_low_, (uint8_t) (this->y_low_ / 256), (uint8_t) (this->y_high_ - 1),
-                        (uint8_t) ((this->y_high_ - 1) / 256)});
-  this->cmd_data(0x4F, {(uint8_t) this->y_low_, (uint8_t) (this->y_low_ / 256)});
-  ESP_LOGV(TAG, "Set window X: %u-%u, Y: %u-%u", this->x_low_, this->x_high_, this->y_low_, this->y_high_);
-}
-
-void EpaperWaveshare::refresh_screen(bool partial) {
-  if (partial) {
-    this->cmd_data(0x22, {0x0F});
-  } else {
-    this->cmd_data(0x22, {0xC7});
-  }
-  this->command(0x20);
-  this->next_delay_ = partial ? 100 : 3000;
-}
-
-void EpaperWaveshare::deep_sleep() { this->cmd_data(0x10, {0x01}); }
-}  // namespace esphome::epaper_spi

esphome/components/epaper_spi/epaper_waveshare.h

@@ -1,30 +0,0 @@
-#pragma once
-#include "epaper_spi.h"
-#include "epaper_spi_mono.h"
-
-namespace esphome::epaper_spi {
-/**
- * An epaper display that needs LUTs to be sent to it.
- */
-class EpaperWaveshare : public EPaperMono {
- public:
-  EpaperWaveshare(const char *name, uint16_t width, uint16_t height, const uint8_t *init_sequence,
-                  size_t init_sequence_length, const uint8_t *lut, size_t lut_length, const uint8_t *partial_lut,
-                  uint16_t partial_lut_length)
-      : EPaperMono(name, width, height, init_sequence, init_sequence_length),
-        lut_(lut),
-        lut_length_(lut_length),
-        partial_lut_(partial_lut),
-        partial_lut_length_(partial_lut_length) {}
-
- protected:
-  void initialise(bool partial) override;
-  void set_window() override;
-  void refresh_screen(bool partial) override;
-  void deep_sleep() override;
-  const uint8_t *lut_;
-  size_t lut_length_;
-  const uint8_t *partial_lut_;
-  uint16_t partial_lut_length_;
-};
-}  // namespace esphome::epaper_spi

esphome/components/epaper_spi/models/__init__.py

@@ -32,9 +32,6 @@ class EpaperModel:
             return cv.Required(name)
         return cv.Optional(name, default=self.get_default(name, fallback))
 
-    def get_constructor_args(self, config) -> tuple:
-        return ()
-
     def get_dimensions(self, config) -> tuple[int, int]:
         if CONF_DIMENSIONS in config:
             # Explicit dimensions, just use as is

esphome/components/epaper_spi/models/ssd1677.py

@@ -4,9 +4,10 @@ from . import EpaperModel
 
 
 class SSD1677(EpaperModel):
-    def __init__(self, name, class_name="EPaperMono", data_rate="20MHz", **defaults):
-        defaults[CONF_DATA_RATE] = data_rate
-        super().__init__(name, class_name, **defaults)
+    def __init__(self, name, class_name="EPaperSSD1677", **kwargs):
+        if CONF_DATA_RATE not in kwargs:
+            kwargs[CONF_DATA_RATE] = "20MHz"
+        super().__init__(name, class_name, **kwargs)
 
     # fmt: off
     def get_init_sequence(self, config: dict):
@@ -22,15 +23,11 @@ class SSD1677(EpaperModel):
 
 ssd1677 = SSD1677("ssd1677")
 
-wave_4_26 = ssd1677.extend(
-    "waveshare-4.26in",
+ssd1677.extend(
+    "seeed-ee04-mono-4.26",
     width=800,
     height=480,
     mirror_x=True,
-)
-
-wave_4_26.extend(
-    "seeed-ee04-mono-4.26",
     cs_pin=44,
     dc_pin=10,
     reset_pin=38,

esphome/components/epaper_spi/models/waveshare.py

@@ -1,88 +0,0 @@
-import esphome.codegen as cg
-from esphome.core import ID
-
-from ..display import CONF_INIT_SEQUENCE_ID
-from . import EpaperModel
-
-
-class WaveshareModel(EpaperModel):
-    def __init__(self, name, lut, lut_partial=None, **defaults):
-        super().__init__(name, "EpaperWaveshare", **defaults)
-        self.lut = lut
-        self.lut_partial = lut_partial
-
-    def get_constructor_args(self, config) -> tuple:
-        lut = (
-            cg.static_const_array(
-                ID(config[CONF_INIT_SEQUENCE_ID].id + "_lut", type=cg.uint8), self.lut
-            ),
-            len(self.lut),
-        )
-        if self.lut_partial is None:
-            lut_partial = cg.nullptr, 0
-        else:
-            lut_partial = (
-                cg.static_const_array(
-                    ID(
-                        config[CONF_INIT_SEQUENCE_ID].id + "_lut_partial", type=cg.uint8
-                    ),
-                    self.lut_partial,
-                ),
-                len(self.lut_partial),
-            )
-        return *lut, *lut_partial
-
-
-# fmt: off
-WaveshareModel(
-    "waveshare-2.13in-v3",
-    width=122,
-    height=250,
-    initsequence=(
-        (0x01, 0x27, 0x01, 0x00),  # driver output control
-        (0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00),
-        (0x11, 0x03),  # Data entry mode
-        (0x3F, 0x22),  # Undocumented command
-        (0x2C, 0x36),  # write VCOM register
-        (0x04, 0x41, 0x0C, 0x32),  # SRC voltage
-        (0x03, 0x17),  # Gate voltage
-        (0x21, 0x00, 0x80),  # Display update control
-        (0x18, 0x80),  # Select internal temperature sensor
-    ),
-    lut=(
-        0x80, 0x4A, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x40, 0x4A, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x80, 0x4A, 0x40, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x4A, 0x80, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0xF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xF, 0x0, 0x0,
-        0xF, 0x0, 0x0, 0x2, 0xF, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-        0x0, 0x0, 0x0,
-    ),
-    lut_partial=(
-        0x0, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x80, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x40, 0x40, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0xF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x4, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1,
-        0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
-        0x0, 0x0, 0x0, 0x0, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
-        0x0, 0x0, 0x0,
-    ),
-)

esphome/components/esp32_hosted/update/esp32_hosted_update.cpp

@@ -8,7 +8,6 @@
 #include <esp_app_desc.h>
 #include <esp_hosted.h>
 #include <esp_hosted_host_fw_ver.h>
-#include <esp_ota_ops.h>
 
 #ifdef USE_ESP32_HOSTED_HTTP_UPDATE
 #include "esphome/components/json/json_util.h"
@@ -443,12 +442,6 @@ void Esp32HostedUpdate::perform(bool force) {
   this->status_clear_error();
   this->publish_state();
 
-#ifdef USE_OTA_ROLLBACK
-  // Mark the host partition as valid before rebooting, in case the safe mode
-  // timer hasn't expired yet.
-  esp_ota_mark_app_valid_cancel_rollback();
-#endif
-
   // Schedule a restart to ensure everything is in sync
   ESP_LOGI(TAG, "Restarting in 1 second");
   this->set_timeout(1000, []() { App.safe_reboot(); });

esphome/components/esphome/ota/ota_esphome.cpp

@@ -370,14 +370,12 @@ void ESPHomeOTAComponent::handle_data_() {
 
 error:
   this->write_byte_(static_cast<uint8_t>(error_code));
+  this->cleanup_connection_();
 
-  // Abort backend before cleanup - cleanup_connection_() destroys the backend
   if (this->backend_ != nullptr && update_started) {
     this->backend_->abort();
   }
 
-  this->cleanup_connection_();
-
   this->status_momentary_error("err", 5000);
 #ifdef USE_OTA_STATE_LISTENER
   this->notify_state_(ota::OTA_ERROR, 0.0f, static_cast<uint8_t>(error_code));

esphome/components/event/event.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <cstring>
-#include <limits>
 #include <string>
 #include <vector>
 
@@ -49,24 +48,6 @@ class Event : public EntityBase, public EntityBase_DeviceClass {
   /// Return the last triggered event type, or empty StringRef if no event triggered yet.
   StringRef get_last_event_type() const { return StringRef::from_maybe_nullptr(this->last_event_type_); }
 
-  /// Return event type by index, or nullptr if index is out of bounds.
-  const char *get_event_type(uint8_t index) const {
-    return index < this->types_.size() ? this->types_[index] : nullptr;
-  }
-
-  /// Return index of last triggered event type, or max uint8_t if no event triggered yet.
-  uint8_t get_last_event_type_index() const {
-    if (this->last_event_type_ == nullptr)
-      return std::numeric_limits<uint8_t>::max();
-    // Most events have <3 types, uint8_t is sufficient for all reasonable scenarios
-    const uint8_t size = static_cast<uint8_t>(this->types_.size());
-    for (uint8_t i = 0; i < size; i++) {
-      if (this->types_[i] == this->last_event_type_)
-        return i;
-    }
-    return std::numeric_limits<uint8_t>::max();
-  }
-
   /// Check if an event has been triggered.
   bool has_event() const { return this->last_event_type_ != nullptr; }
 

esphome/components/i2s_audio/speaker/i2s_audio_speaker.cpp

@@ -340,8 +340,8 @@ void I2SAudioSpeaker::speaker_task(void *params) {
       const uint32_t read_delay =
           (this_speaker->current_stream_info_.frames_to_microseconds(frames_written) / 1000) / 2;
 
+      uint8_t *new_data = transfer_buffer->get_buffer_end();  // track start of any newly copied bytes
       size_t bytes_read = transfer_buffer->transfer_data_from_source(pdMS_TO_TICKS(read_delay));
-      uint8_t *new_data = transfer_buffer->get_buffer_end() - bytes_read;
 
       if (bytes_read > 0) {
         if (this_speaker->q15_volume_factor_ < INT16_MAX) {

esphome/components/improv_serial/improv_serial_component.cpp

@@ -193,12 +193,8 @@ std::vector<uint8_t> ImprovSerialComponent::build_rpc_settings_response_(improv:
 #ifdef USE_WEBSERVER
   for (auto &ip : wifi::global_wifi_component->wifi_sta_ip_addresses()) {
     if (ip.is_ip4()) {
-      char ip_buf[network::IP_ADDRESS_BUFFER_SIZE];
-      ip.str_to(ip_buf);
-      // "http://" (7) + IP (40) + ":" (1) + port (5) + null (1) = 54
-      char webserver_url[7 + network::IP_ADDRESS_BUFFER_SIZE + 1 + 5 + 1];
-      snprintf(webserver_url, sizeof(webserver_url), "http://%s:%u", ip_buf, USE_WEBSERVER_PORT);
-      urls.emplace_back(webserver_url);
+      std::string webserver_url = "http://" + ip.str() + ":" + to_string(USE_WEBSERVER_PORT);
+      urls.push_back(webserver_url);
       break;
     }
   }

esphome/components/ir_rf_proxy/__init__.py

@@ -1,11 +0,0 @@
-"""IR/RF Proxy component - provides remote_base backend for infrared platform."""
-
-import esphome.codegen as cg
-
-CODEOWNERS = ["@kbx81"]
-
-# Namespace and constants exported for infrared.py platform
-ir_rf_proxy_ns = cg.esphome_ns.namespace("ir_rf_proxy")
-
-CONF_REMOTE_RECEIVER_ID = "remote_receiver_id"
-CONF_REMOTE_TRANSMITTER_ID = "remote_transmitter_id"

esphome/components/ir_rf_proxy/infrared.py

@@ -1,77 +0,0 @@
-"""Infrared platform implementation using remote_base (remote_transmitter/receiver)."""
-
-from typing import Any
-
-import esphome.codegen as cg
-from esphome.components import infrared, remote_receiver, remote_transmitter
-import esphome.config_validation as cv
-from esphome.const import CONF_CARRIER_DUTY_PERCENT, CONF_FREQUENCY
-import esphome.final_validate as fv
-
-from . import CONF_REMOTE_RECEIVER_ID, CONF_REMOTE_TRANSMITTER_ID, ir_rf_proxy_ns
-
-CODEOWNERS = ["@kbx81"]
-DEPENDENCIES = ["infrared"]
-
-IrRfProxy = ir_rf_proxy_ns.class_("IrRfProxy", infrared.Infrared)
-
-CONFIG_SCHEMA = cv.All(
-    infrared.infrared_schema(IrRfProxy).extend(
-        {
-            cv.Optional(CONF_FREQUENCY, default=0): cv.frequency,
-            cv.Optional(CONF_REMOTE_RECEIVER_ID): cv.use_id(
-                remote_receiver.RemoteReceiverComponent
-            ),
-            cv.Optional(CONF_REMOTE_TRANSMITTER_ID): cv.use_id(
-                remote_transmitter.RemoteTransmitterComponent
-            ),
-        }
-    ),
-    cv.has_exactly_one_key(CONF_REMOTE_RECEIVER_ID, CONF_REMOTE_TRANSMITTER_ID),
-)
-
-
-def _final_validate(config: dict[str, Any]) -> None:
-    """Validate that transmitters have a proper carrier duty cycle."""
-    # Only validate if this is an infrared (not RF) configuration with a transmitter
-    if config.get(CONF_FREQUENCY, 0) != 0 or CONF_REMOTE_TRANSMITTER_ID not in config:
-        return
-
-    # Get the transmitter configuration
-    transmitter_id = config[CONF_REMOTE_TRANSMITTER_ID]
-    full_config = fv.full_config.get()
-    transmitter_path = full_config.get_path_for_id(transmitter_id)[:-1]
-    transmitter_config = full_config.get_config_for_path(transmitter_path)
-
-    # Check if carrier_duty_percent set to 0 or 100
-    # Note: remote_transmitter schema requires this field and validates 1-100%,
-    # but we double-check here for infrared to provide a helpful error message
-    duty_percent = transmitter_config.get(CONF_CARRIER_DUTY_PERCENT)
-    if duty_percent in {0, 100}:
-        raise cv.Invalid(
-            f"Transmitter '{transmitter_id}' must have '{CONF_CARRIER_DUTY_PERCENT}' configured with "
-            "an intermediate value (typically 30-50%) for infrared transmission. If this is an RF "
-            f"transmitter, configure this infrared with a '{CONF_FREQUENCY}' value greater than 0"
-        )
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
-async def to_code(config: dict[str, Any]) -> None:
-    """Code generation for remote_base infrared platform."""
-    # Create and register the infrared entity
-    var = await infrared.new_infrared(config)
-
-    # Set frequency / 1000; zero indicates infrared hardware
-    cg.add(var.set_frequency(config[CONF_FREQUENCY] / 1000))
-
-    # Link transmitter if specified
-    if CONF_REMOTE_TRANSMITTER_ID in config:
-        transmitter = await cg.get_variable(config[CONF_REMOTE_TRANSMITTER_ID])
-        cg.add(var.set_transmitter(transmitter))
-
-    # Link receiver if specified
-    if CONF_REMOTE_RECEIVER_ID in config:
-        receiver = await cg.get_variable(config[CONF_REMOTE_RECEIVER_ID])
-        cg.add(var.set_receiver(receiver))

esphome/components/ir_rf_proxy/ir_rf_proxy.cpp

@@ -1,23 +0,0 @@
-#include "ir_rf_proxy.h"
-#include "esphome/core/log.h"
-
-namespace esphome::ir_rf_proxy {
-
-static const char *const TAG = "ir_rf_proxy";
-
-void IrRfProxy::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "IR/RF Proxy '%s'\n"
-                "  Supports Transmitter: %s\n"
-                "  Supports Receiver: %s",
-                this->get_name().c_str(), YESNO(this->traits_.get_supports_transmitter()),
-                YESNO(this->traits_.get_supports_receiver()));
-
-  if (this->is_rf()) {
-    ESP_LOGCONFIG(TAG, "  Hardware Type: RF (%.3f MHz)", this->frequency_khz_ / 1e3f);
-  } else {
-    ESP_LOGCONFIG(TAG, "  Hardware Type: Infrared");
-  }
-}
-
-}  // namespace esphome::ir_rf_proxy

esphome/components/ir_rf_proxy/ir_rf_proxy.h

@@ -1,32 +0,0 @@
-#pragma once
-
-// WARNING: This component is EXPERIMENTAL. The API may change at any time
-// without following the normal breaking changes policy. Use at your own risk.
-// Once the API is considered stable, this warning will be removed.
-
-#include "esphome/components/infrared/infrared.h"
-#include "esphome/components/remote_transmitter/remote_transmitter.h"
-#include "esphome/components/remote_receiver/remote_receiver.h"
-
-namespace esphome::ir_rf_proxy {
-
-/// IrRfProxy - Infrared platform implementation using remote_transmitter/receiver as backend
-class IrRfProxy : public infrared::Infrared {
- public:
-  IrRfProxy() = default;
-
-  void dump_config() override;
-
-  /// Set RF frequency in kHz (0 = infrared, non-zero = RF)
-  void set_frequency(uint32_t frequency_khz) { this->frequency_khz_ = frequency_khz; }
-  /// Get RF frequency in kHz
-  uint32_t get_frequency() const { return this->frequency_khz_; }
-  /// Check if this is RF mode (non-zero frequency)
-  bool is_rf() const { return this->frequency_khz_ > 0; }
-
- protected:
-  // RF frequency in kHz (Hz / 1000); 0 = infrared, non-zero = RF
-  uint32_t frequency_khz_{0};
-};
-
-}  // namespace esphome::ir_rf_proxy

esphome/components/ld2410/binary_sensor.py

@@ -5,7 +5,6 @@ from esphome.const import (
     CONF_HAS_MOVING_TARGET,
     CONF_HAS_STILL_TARGET,
     CONF_HAS_TARGET,
-    CONF_ID,
     DEVICE_CLASS_MOTION,
     DEVICE_CLASS_OCCUPANCY,
     DEVICE_CLASS_PRESENCE,
@@ -20,7 +19,6 @@ DEPENDENCIES = ["ld2410"]
 CONF_OUT_PIN_PRESENCE_STATUS = "out_pin_presence_status"
 
 CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
     cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
     cv.Optional(CONF_HAS_TARGET): binary_sensor.binary_sensor_schema(
         device_class=DEVICE_CLASS_OCCUPANCY,

esphome/components/ld2410/button/__init__.py

@@ -3,7 +3,6 @@ from esphome.components import button
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_FACTORY_RESET,
-    CONF_ID,
     CONF_RESTART,
     DEVICE_CLASS_RESTART,
     ENTITY_CATEGORY_CONFIG,
@@ -22,7 +21,6 @@ RestartButton = ld2410_ns.class_("RestartButton", button.Button)
 CONF_QUERY_PARAMS = "query_params"
 
 CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
     cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
     cv.Optional(CONF_FACTORY_RESET): button.button_schema(
         FactoryResetButton,

esphome/components/ld2410/number/__init__.py

@@ -31,7 +31,6 @@ TIMEOUT_GROUP = "timeout"
 
 CONFIG_SCHEMA = cv.Schema(
     {
-        cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
         cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
         cv.Inclusive(CONF_TIMEOUT, TIMEOUT_GROUP): number.number_schema(
             MaxDistanceTimeoutNumber,

esphome/components/ld2410/select/__init__.py

@@ -3,7 +3,6 @@ from esphome.components import select
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BAUD_RATE,
-    CONF_ID,
     ENTITY_CATEGORY_CONFIG,
     ICON_LIGHTBULB,
     ICON_RULER,
@@ -23,7 +22,6 @@ CONF_OUT_PIN_LEVEL = "out_pin_level"
 
 
 CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
     cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
     cv.Optional(CONF_DISTANCE_RESOLUTION): select.select_schema(
         DistanceResolutionSelect,

esphome/components/ld2410/sensor.py

@@ -2,7 +2,6 @@ import esphome.codegen as cg
 from esphome.components import sensor
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_ID,
     CONF_LIGHT,
     CONF_MOVING_DISTANCE,
     DEVICE_CLASS_DISTANCE,
@@ -29,7 +28,6 @@ CONF_STILL_ENERGY = "still_energy"
 
 CONFIG_SCHEMA = cv.Schema(
     {
-        cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
         cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
         cv.Optional(CONF_MOVING_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,

esphome/components/ld2410/switch/__init__.py

@@ -3,7 +3,6 @@ from esphome.components import switch
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BLUETOOTH,
-    CONF_ID,
     DEVICE_CLASS_SWITCH,
     ENTITY_CATEGORY_CONFIG,
     ICON_BLUETOOTH,
@@ -18,7 +17,6 @@ EngineeringModeSwitch = ld2410_ns.class_("EngineeringModeSwitch", switch.Switch)
 CONF_ENGINEERING_MODE = "engineering_mode"
 
 CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
     cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
     cv.Optional(CONF_ENGINEERING_MODE): switch.switch_schema(
         EngineeringModeSwitch,

esphome/components/ld2410/text_sensor.py

@@ -2,7 +2,6 @@ import esphome.codegen as cg
 from esphome.components import text_sensor
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_ID,
     CONF_MAC_ADDRESS,
     CONF_VERSION,
     ENTITY_CATEGORY_DIAGNOSTIC,
@@ -15,7 +14,6 @@ from . import CONF_LD2410_ID, LD2410Component
 DEPENDENCIES = ["ld2410"]
 
 CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
     cv.GenerateID(CONF_LD2410_ID): cv.use_id(LD2410Component),
     cv.Optional(CONF_VERSION): text_sensor.text_sensor_schema(
         entity_category=ENTITY_CATEGORY_DIAGNOSTIC, icon=ICON_CHIP

esphome/components/ld2412/binary_sensor.py

@@ -5,7 +5,6 @@ from esphome.const import (
     CONF_HAS_MOVING_TARGET,
     CONF_HAS_STILL_TARGET,
     CONF_HAS_TARGET,
-    CONF_ID,
     DEVICE_CLASS_MOTION,
     DEVICE_CLASS_OCCUPANCY,
     DEVICE_CLASS_RUNNING,
@@ -21,7 +20,6 @@ DEPENDENCIES = ["ld2412"]
 CONF_DYNAMIC_BACKGROUND_CORRECTION_STATUS = "dynamic_background_correction_status"
 
 CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
     cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
     cv.Optional(
         CONF_DYNAMIC_BACKGROUND_CORRECTION_STATUS

esphome/components/ld2412/button/__init__.py

@@ -3,7 +3,6 @@ from esphome.components import button
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_FACTORY_RESET,
-    CONF_ID,
     CONF_RESTART,
     DEVICE_CLASS_RESTART,
     ENTITY_CATEGORY_CONFIG,
@@ -27,7 +26,6 @@ CONF_QUERY_PARAMS = "query_params"
 CONF_START_DYNAMIC_BACKGROUND_CORRECTION = "start_dynamic_background_correction"
 
 CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
     cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
     cv.Optional(CONF_FACTORY_RESET): button.button_schema(
         FactoryResetButton,

esphome/components/ld2412/number/__init__.py

@@ -31,7 +31,6 @@ TIMEOUT_GROUP = "timeout"
 
 CONFIG_SCHEMA = cv.Schema(
     {
-        cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
         cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
         cv.Optional(CONF_LIGHT_THRESHOLD): number.number_schema(
             LightThresholdNumber,

esphome/components/ld2412/select/__init__.py

@@ -3,7 +3,6 @@ from esphome.components import select
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BAUD_RATE,
-    CONF_ID,
     ENTITY_CATEGORY_CONFIG,
     ICON_LIGHTBULB,
     ICON_RULER,
@@ -23,7 +22,6 @@ CONF_OUT_PIN_LEVEL = "out_pin_level"
 
 
 CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
     cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
     cv.Optional(CONF_BAUD_RATE): select.select_schema(
         BaudRateSelect,

esphome/components/ld2412/sensor.py

@@ -2,7 +2,6 @@ import esphome.codegen as cg
 from esphome.components import sensor
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_ID,
     CONF_LIGHT,
     CONF_MOVING_DISTANCE,
     DEVICE_CLASS_DISTANCE,
@@ -29,7 +28,6 @@ CONF_STILL_ENERGY = "still_energy"
 
 CONFIG_SCHEMA = cv.Schema(
     {
-        cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
         cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
         cv.Optional(CONF_DETECTION_DISTANCE): sensor.sensor_schema(
             device_class=DEVICE_CLASS_DISTANCE,

esphome/components/ld2412/switch/__init__.py

@@ -3,7 +3,6 @@ from esphome.components import switch
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BLUETOOTH,
-    CONF_ID,
     DEVICE_CLASS_SWITCH,
     ENTITY_CATEGORY_CONFIG,
     ICON_BLUETOOTH,
@@ -18,7 +17,6 @@ EngineeringModeSwitch = LD2412_ns.class_("EngineeringModeSwitch", switch.Switch)
 CONF_ENGINEERING_MODE = "engineering_mode"
 
 CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
     cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
     cv.Optional(CONF_BLUETOOTH): switch.switch_schema(
         BluetoothSwitch,

esphome/components/ld2412/text_sensor.py

@@ -2,7 +2,6 @@ import esphome.codegen as cg
 from esphome.components import text_sensor
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_ID,
     CONF_MAC_ADDRESS,
     CONF_VERSION,
     ENTITY_CATEGORY_DIAGNOSTIC,
@@ -15,7 +14,6 @@ from . import CONF_LD2412_ID, LD2412Component
 DEPENDENCIES = ["ld2412"]
 
 CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
     cv.GenerateID(CONF_LD2412_ID): cv.use_id(LD2412Component),
     cv.Optional(CONF_VERSION): text_sensor.text_sensor_schema(
         entity_category=ENTITY_CATEGORY_DIAGNOSTIC, icon=ICON_CHIP

esphome/components/ld2450/binary_sensor.py

@@ -5,7 +5,6 @@ from esphome.const import (
     CONF_HAS_MOVING_TARGET,
     CONF_HAS_STILL_TARGET,
     CONF_HAS_TARGET,
-    CONF_ID,
     DEVICE_CLASS_MOTION,
     DEVICE_CLASS_OCCUPANCY,
 )
@@ -19,7 +18,6 @@ ICON_SHIELD_ACCOUNT = "mdi:shield-account"
 ICON_TARGET_ACCOUNT = "mdi:target-account"
 
 CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
     cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
     cv.Optional(CONF_HAS_TARGET): binary_sensor.binary_sensor_schema(
         device_class=DEVICE_CLASS_OCCUPANCY,

esphome/components/ld2450/button/__init__.py

@@ -3,7 +3,6 @@ from esphome.components import button
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_FACTORY_RESET,
-    CONF_ID,
     CONF_RESTART,
     DEVICE_CLASS_RESTART,
     ENTITY_CATEGORY_CONFIG,
@@ -18,7 +17,6 @@ FactoryResetButton = ld2450_ns.class_("FactoryResetButton", button.Button)
 RestartButton = ld2450_ns.class_("RestartButton", button.Button)
 
 CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
     cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
     cv.Optional(CONF_FACTORY_RESET): button.button_schema(
         FactoryResetButton,

esphome/components/ld2450/number/__init__.py

@@ -28,7 +28,6 @@ ZoneCoordinateNumber = ld2450_ns.class_("ZoneCoordinateNumber", number.Number)
 
 CONFIG_SCHEMA = cv.Schema(
     {
-        cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
         cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
         cv.Required(CONF_PRESENCE_TIMEOUT): number.number_schema(
             PresenceTimeoutNumber,

esphome/components/ld2450/select/__init__.py

@@ -1,12 +1,7 @@
 import esphome.codegen as cg
 from esphome.components import select
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_BAUD_RATE,
-    CONF_ID,
-    ENTITY_CATEGORY_CONFIG,
-    ICON_THERMOMETER,
-)
+from esphome.const import CONF_BAUD_RATE, ENTITY_CATEGORY_CONFIG, ICON_THERMOMETER
 
 from .. import CONF_LD2450_ID, LD2450Component, ld2450_ns
 
@@ -16,7 +11,6 @@ BaudRateSelect = ld2450_ns.class_("BaudRateSelect", select.Select)
 ZoneTypeSelect = ld2450_ns.class_("ZoneTypeSelect", select.Select)
 
 CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
     cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
     cv.Optional(CONF_BAUD_RATE): select.select_schema(
         BaudRateSelect,

esphome/components/ld2450/sensor.py

@@ -4,7 +4,6 @@ import esphome.config_validation as cv
 from esphome.const import (
     CONF_ANGLE,
     CONF_DISTANCE,
-    CONF_ID,
     CONF_RESOLUTION,
     CONF_SPEED,
     CONF_X,
@@ -41,7 +40,6 @@ UNIT_MILLIMETER_PER_SECOND = "mm/s"
 
 CONFIG_SCHEMA = cv.Schema(
     {
-        cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
         cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
         cv.Optional(CONF_TARGET_COUNT): sensor.sensor_schema(
             accuracy_decimals=0,

esphome/components/ld2450/switch/__init__.py

@@ -3,7 +3,6 @@ from esphome.components import switch
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_BLUETOOTH,
-    CONF_ID,
     DEVICE_CLASS_SWITCH,
     ENTITY_CATEGORY_CONFIG,
     ICON_BLUETOOTH,
@@ -18,7 +17,6 @@ MultiTargetSwitch = ld2450_ns.class_("MultiTargetSwitch", switch.Switch)
 CONF_MULTI_TARGET = "multi_target"
 
 CONFIG_SCHEMA = {
-    cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
     cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
     cv.Optional(CONF_BLUETOOTH): switch.switch_schema(
         BluetoothSwitch,

esphome/components/ld2450/text_sensor.py

@@ -3,7 +3,6 @@ from esphome.components import text_sensor
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_DIRECTION,
-    CONF_ID,
     CONF_MAC_ADDRESS,
     CONF_VERSION,
     ENTITY_CATEGORY_DIAGNOSTIC,
@@ -21,7 +20,6 @@ MAX_TARGETS = 3
 
 CONFIG_SCHEMA = cv.Schema(
     {
-        cv.GenerateID(CONF_ID): cv.declare_id(cg.EntityBase),
         cv.GenerateID(CONF_LD2450_ID): cv.use_id(LD2450Component),
         cv.Optional(CONF_VERSION): text_sensor.text_sensor_schema(
             entity_category=ENTITY_CATEGORY_DIAGNOSTIC,

esphome/components/libretiny/__init__.py

@@ -35,7 +35,6 @@ from .const import (
     FAMILY_BK7231N,
     FAMILY_COMPONENT,
     FAMILY_FRIENDLY,
-    FAMILY_RTL8710B,
     KEY_BOARD,
     KEY_COMPONENT,
     KEY_COMPONENT_DATA,
@@ -279,23 +278,11 @@ async def component_to_code(config):
     cg.add_build_flag(f"-DUSE_LIBRETINY_VARIANT_{config[CONF_FAMILY]}")
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
     cg.add_define("ESPHOME_VARIANT", FAMILY_FRIENDLY[config[CONF_FAMILY]])
-    # Set threading model based on chip architecture
-    component: LibreTinyComponent = CORE.data[KEY_LIBRETINY][KEY_COMPONENT_DATA]
-    if component.supports_atomics:
-        # RTL87xx (Cortex-M4) and LN882x (Cortex-M4F) have LDREX/STREX
-        cg.add_define(ThreadModel.MULTI_ATOMICS)
-    else:
-        # BK72xx uses ARM968E-S (ARMv5TE) which lacks LDREX/STREX.
-        # std::atomic RMW operations would require libatomic (not linked to save
-        # 4-8KB flash). Even if linked, it would use locks, so explicit FreeRTOS
-        # mutexes are simpler and equivalent.
-        cg.add_define(ThreadModel.MULTI_NO_ATOMICS)
-
-    # RTL8710B needs FreeRTOS 8.2.3+ for xTaskNotifyGive/ulTaskNotifyTake
-    # required by AsyncTCP 3.4.3+ (https://github.com/esphome/esphome/issues/10220)
-    # RTL8720C (ambz2) requires FreeRTOS 10.x so this only applies to RTL8710B
-    if config[CONF_FAMILY] == FAMILY_RTL8710B:
-        cg.add_platformio_option("custom_versions.freertos", "8.2.3")
+    # LibreTiny uses MULTI_NO_ATOMICS because platforms like BK7231N (ARM968E-S) lack
+    # exclusive load/store (no LDREX/STREX). std::atomic RMW operations require libatomic,
+    # which is not linked to save flash (4-8KB). Even if linked, libatomic would use locks
+    # (ATOMIC_INT_LOCK_FREE=1), so explicit FreeRTOS mutexes are simpler and equivalent.
+    cg.add_define(ThreadModel.MULTI_NO_ATOMICS)
 
     # force using arduino framework
     cg.add_platformio_option("framework", "arduino")

esphome/components/libretiny/const.py

@@ -11,7 +11,6 @@ class LibreTinyComponent:
     board_pins: dict[str, dict[str, int]]
     pin_validation: Callable[[int], int]
     usage_validation: Callable[[dict], dict]
-    supports_atomics: bool = False  # True for Cortex-M4(F) with LDREX/STREX
 
 
 CONF_LIBRETINY = "libretiny"

esphome/components/libretiny/generate_components.py

@@ -11,27 +11,13 @@ from black import FileMode, format_str
 from ltchiptool import Board, Family
 from ltchiptool.util.lvm import LVM
 
-BASE_CODE_INIT = '''
-"""
-██╗    ██╗ █████╗ ██████╗ ███╗   ██╗██╗███╗   ██╗ ██████╗
-██║    ██║██╔══██╗██╔══██╗████╗  ██║██║████╗  ██║██╔════╝
-██║ █╗ ██║███████║██████╔╝██╔██╗ ██║██║██╔██╗ ██║██║  ███╗
-██║███╗██║██╔══██║██╔══██╗██║╚██╗██║██║██║╚██╗██║██║   ██║
-╚███╔███╔╝██║  ██║██║  ██║██║ ╚████║██║██║ ╚████║╚██████╔╝
- ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═══╝ ╚═════╝
-
-         AUTO-GENERATED FILE - DO NOT EDIT!
-
-This file was auto-generated by libretiny/generate_components.py.
-Any manual changes WILL BE LOST on regeneration.
-
-To customize this component:
-  - Pin validators: Create gpio.py with validate_pin() or validate_usage()
-  - Schema extensions: Create schema.py with COMPONENT_SCHEMA or COMPONENT_PIN_SCHEMA
-
-Platform-specific code should be added to the main libretiny component
-(__init__.py in esphome/components/libretiny/) rather than here.
-"""
+BASE_CODE_INIT = """
+# This file was auto-generated by libretiny/generate_components.py
+# Do not modify its contents.
+# For custom pin validators, put validate_pin() or validate_usage()
+# in gpio.py file in this directory.
+# For changing schema/pin schema, put COMPONENT_SCHEMA or COMPONENT_PIN_SCHEMA
+# in schema.py file in this directory.
 
 from esphome import pins
 from esphome.components import libretiny
@@ -45,9 +31,8 @@ from esphome.core import CORE
 
 {IMPORTS}
 
-CODEOWNERS = {CODEOWNERS}
+CODEOWNERS = ["@kuba2k2"]
 AUTO_LOAD = ["libretiny"]
-IS_TARGET_PLATFORM = True
 
 COMPONENT_DATA = LibreTinyComponent(
     name=COMPONENT_{COMPONENT},
@@ -55,7 +40,6 @@ COMPONENT_DATA = LibreTinyComponent(
     board_pins={COMPONENT}_BOARD_PINS,
     pin_validation={PIN_VALIDATION},
     usage_validation={USAGE_VALIDATION},
-    supports_atomics={SUPPORTS_ATOMICS},
 )
 
 
@@ -79,22 +63,11 @@ async def to_code(config):
 @pins.PIN_SCHEMA_REGISTRY.register("{COMPONENT_LOWER}", PIN_SCHEMA)
 async def pin_to_code(config):
     return await libretiny.gpio.component_pin_to_code(config)
-'''
-
-BASE_CODE_BOARDS = '''
 """
-██╗    ██╗ █████╗ ██████╗ ███╗   ██╗██╗███╗   ██╗ ██████╗
-██║    ██║██╔══██╗██╔══██╗████╗  ██║██║████╗  ██║██╔════╝
-██║ █╗ ██║███████║██████╔╝██╔██╗ ██║██║██╔██╗ ██║██║  ███╗
-██║███╗██║██╔══██║██╔══██╗██║╚██╗██║██║██║╚██╗██║██║   ██║
-╚███╔███╔╝██║  ██║██║  ██║██║ ╚████║██║██║ ╚████║╚██████╔╝
- ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═══╝ ╚═════╝
 
-         AUTO-GENERATED FILE - DO NOT EDIT!
-
-This file was auto-generated by libretiny/generate_components.py.
-Any manual changes WILL BE LOST on regeneration.
-"""
+BASE_CODE_BOARDS = """
+# This file was auto-generated by libretiny/generate_components.py
+# Do not modify its contents.
 
 from esphome.components.libretiny.const import {FAMILIES}
 
@@ -103,7 +76,7 @@ from esphome.components.libretiny.const import {FAMILIES}
 {COMPONENT}_BOARD_PINS = {PINS_JSON}
 
 BOARDS = {COMPONENT}_BOARDS
-'''
+"""
 
 # variable names in component extension code
 VAR_SCHEMA = "COMPONENT_SCHEMA"
@@ -124,19 +97,6 @@ COMPONENT_MAP = {
     "ln882x": "lightning-ln882x",
 }
 
-# Components with Cortex-M4(F) have LDREX/STREX for native atomic support.
-# BK72xx uses ARM968E-S (ARMv5TE) which lacks these instructions.
-COMPONENT_SUPPORTS_ATOMICS = {
-    "rtl87xx": True,  # Cortex-M4
-    "ln882x": True,  # Cortex-M4F
-    "bk72xx": False,  # ARM968E-S
-}
-
-# CODEOWNERS for each component. If not specified, defaults to @kuba2k2.
-COMPONENT_CODEOWNERS = {
-    "ln882x": ["@lamauny"],
-}
-
 
 def subst(code: str, key: str, value: str) -> str:
     return code.replace(f"{{{key}}}", value)
@@ -180,7 +140,6 @@ def write_component_code(
         "boards": {"{COMPONENT}_BOARDS", "{COMPONENT}_BOARD_PINS"},
     }
     # substitution values
-    codeowners = COMPONENT_CODEOWNERS.get(component, ["@kuba2k2"])
     values = dict(
         COMPONENT=component.upper(),
         COMPONENT_LOWER=component.lower(),
@@ -188,8 +147,6 @@ def write_component_code(
         PIN_SCHEMA=PIN_SCHEMA_BASE,
         PIN_VALIDATION="None",
         USAGE_VALIDATION="None",
-        SUPPORTS_ATOMICS=str(COMPONENT_SUPPORTS_ATOMICS.get(component, False)),
-        CODEOWNERS=repr(codeowners),
     )
 
     # parse gpio.py file to find custom validators

esphome/components/ln882x/__init__.py

@@ -1,23 +1,9 @@
-"""
-██╗    ██╗ █████╗ ██████╗ ███╗   ██╗██╗███╗   ██╗ ██████╗
-██║    ██║██╔══██╗██╔══██╗████╗  ██║██║████╗  ██║██╔════╝
-██║ █╗ ██║███████║██████╔╝██╔██╗ ██║██║██╔██╗ ██║██║  ███╗
-██║███╗██║██╔══██║██╔══██╗██║╚██╗██║██║██║╚██╗██║██║   ██║
-╚███╔███╔╝██║  ██║██║  ██║██║ ╚████║██║██║ ╚████║╚██████╔╝
- ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═══╝ ╚═════╝
-
-         AUTO-GENERATED FILE - DO NOT EDIT!
-
-This file was auto-generated by libretiny/generate_components.py.
-Any manual changes WILL BE LOST on regeneration.
-
-To customize this component:
-  - Pin validators: Create gpio.py with validate_pin() or validate_usage()
-  - Schema extensions: Create schema.py with COMPONENT_SCHEMA or COMPONENT_PIN_SCHEMA
-
-Platform-specific code should be added to the main libretiny component
-(__init__.py in esphome/components/libretiny/) rather than here.
-"""
+# This file was auto-generated by libretiny/generate_components.py
+# Do not modify its contents.
+# For custom pin validators, put validate_pin() or validate_usage()
+# in gpio.py file in this directory.
+# For changing schema/pin schema, put COMPONENT_SCHEMA or COMPONENT_PIN_SCHEMA
+# in schema.py file in this directory.
 
 from esphome import pins
 from esphome.components import libretiny
@@ -41,7 +27,6 @@ COMPONENT_DATA = LibreTinyComponent(
     board_pins=LN882X_BOARD_PINS,
     pin_validation=None,
     usage_validation=None,
-    supports_atomics=True,
 )
 
 

esphome/components/ln882x/boards.py

@@ -1,28 +1,9 @@
-"""
-██╗    ██╗ █████╗ ██████╗ ███╗   ██╗██╗███╗   ██╗ ██████╗
-██║    ██║██╔══██╗██╔══██╗████╗  ██║██║████╗  ██║██╔════╝
-██║ █╗ ██║███████║██████╔╝██╔██╗ ██║██║██╔██╗ ██║██║  ███╗
-██║███╗██║██╔══██║██╔══██╗██║╚██╗██║██║██║╚██╗██║██║   ██║
-╚███╔███╔╝██║  ██║██║  ██║██║ ╚████║██║██║ ╚████║╚██████╔╝
- ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═══╝ ╚═════╝
-
-         AUTO-GENERATED FILE - DO NOT EDIT!
-
-This file was auto-generated by libretiny/generate_components.py.
-Any manual changes WILL BE LOST on regeneration.
-"""
+# This file was auto-generated by libretiny/generate_components.py
+# Do not modify its contents.
 
 from esphome.components.libretiny.const import FAMILY_LN882H
 
 LN882X_BOARDS = {
-    "generic-ln882hki": {
-        "name": "Generic - LN882HKI",
-        "family": FAMILY_LN882H,
-    },
-    "wb02a": {
-        "name": "WB02A Wi-Fi/BLE Module",
-        "family": FAMILY_LN882H,
-    },
     "wl2s": {
         "name": "WL2S Wi-Fi/BLE Module",
         "family": FAMILY_LN882H,
@@ -31,195 +12,13 @@ LN882X_BOARDS = {
         "name": "LN-02 Wi-Fi/BLE Module",
         "family": FAMILY_LN882H,
     },
+    "generic-ln882hki": {
+        "name": "Generic - LN882HKI",
+        "family": FAMILY_LN882H,
+    },
 }
 
 LN882X_BOARD_PINS = {
-    "generic-ln882hki": {
-        "WIRE0_SCL_0": 0,
-        "WIRE0_SCL_1": 1,
-        "WIRE0_SCL_2": 2,
-        "WIRE0_SCL_3": 3,
-        "WIRE0_SCL_4": 4,
-        "WIRE0_SCL_5": 5,
-        "WIRE0_SCL_6": 6,
-        "WIRE0_SCL_7": 7,
-        "WIRE0_SCL_8": 8,
-        "WIRE0_SCL_9": 9,
-        "WIRE0_SCL_10": 10,
-        "WIRE0_SCL_11": 11,
-        "WIRE0_SCL_12": 12,
-        "WIRE0_SCL_13": 19,
-        "WIRE0_SCL_14": 20,
-        "WIRE0_SCL_15": 21,
-        "WIRE0_SCL_16": 22,
-        "WIRE0_SCL_17": 23,
-        "WIRE0_SCL_18": 24,
-        "WIRE0_SCL_19": 25,
-        "WIRE0_SDA_0": 0,
-        "WIRE0_SDA_1": 1,
-        "WIRE0_SDA_2": 2,
-        "WIRE0_SDA_3": 3,
-        "WIRE0_SDA_4": 4,
-        "WIRE0_SDA_5": 5,
-        "WIRE0_SDA_6": 6,
-        "WIRE0_SDA_7": 7,
-        "WIRE0_SDA_8": 8,
-        "WIRE0_SDA_9": 9,
-        "WIRE0_SDA_10": 10,
-        "WIRE0_SDA_11": 11,
-        "WIRE0_SDA_12": 12,
-        "WIRE0_SDA_13": 19,
-        "WIRE0_SDA_14": 20,
-        "WIRE0_SDA_15": 21,
-        "WIRE0_SDA_16": 22,
-        "WIRE0_SDA_17": 23,
-        "WIRE0_SDA_18": 24,
-        "WIRE0_SDA_19": 25,
-        "SERIAL0_RX": 3,
-        "SERIAL0_TX": 2,
-        "SERIAL1_RX": 24,
-        "SERIAL1_TX": 25,
-        "ADC2": 0,
-        "ADC3": 1,
-        "ADC4": 4,
-        "ADC5": 19,
-        "ADC6": 20,
-        "ADC7": 21,
-        "PA00": 0,
-        "PA0": 0,
-        "PA01": 1,
-        "PA1": 1,
-        "PA02": 2,
-        "PA2": 2,
-        "PA03": 3,
-        "PA3": 3,
-        "PA04": 4,
-        "PA4": 4,
-        "PA05": 5,
-        "PA5": 5,
-        "PA06": 6,
-        "PA6": 6,
-        "PA07": 7,
-        "PA7": 7,
-        "PA08": 8,
-        "PA8": 8,
-        "PA09": 9,
-        "PA9": 9,
-        "PA10": 10,
-        "PA11": 11,
-        "PA12": 12,
-        "PB03": 19,
-        "PB3": 19,
-        "PB04": 20,
-        "PB4": 20,
-        "PB05": 21,
-        "PB5": 21,
-        "PB06": 22,
-        "PB6": 22,
-        "PB07": 23,
-        "PB7": 23,
-        "PB08": 24,
-        "PB8": 24,
-        "PB09": 25,
-        "PB9": 25,
-        "RX0": 3,
-        "RX1": 24,
-        "TX0": 2,
-        "TX1": 25,
-        "D0": 0,
-        "D1": 1,
-        "D2": 2,
-        "D3": 3,
-        "D4": 4,
-        "D5": 5,
-        "D6": 6,
-        "D7": 7,
-        "D8": 8,
-        "D9": 9,
-        "D10": 10,
-        "D11": 11,
-        "D12": 12,
-        "D13": 19,
-        "D14": 20,
-        "D15": 21,
-        "D16": 22,
-        "D17": 23,
-        "D18": 24,
-        "D19": 25,
-        "A2": 0,
-        "A3": 1,
-        "A4": 4,
-        "A5": 19,
-        "A6": 20,
-        "A7": 21,
-    },
-    "wb02a": {
-        "WIRE0_SCL_0": 7,
-        "WIRE0_SCL_1": 5,
-        "WIRE0_SCL_2": 3,
-        "WIRE0_SCL_3": 10,
-        "WIRE0_SCL_4": 2,
-        "WIRE0_SCL_5": 1,
-        "WIRE0_SCL_6": 4,
-        "WIRE0_SCL_7": 5,
-        "WIRE0_SCL_8": 9,
-        "WIRE0_SCL_9": 24,
-        "WIRE0_SCL_10": 25,
-        "WIRE0_SDA_0": 7,
-        "WIRE0_SDA_1": 5,
-        "WIRE0_SDA_2": 3,
-        "WIRE0_SDA_3": 10,
-        "WIRE0_SDA_4": 2,
-        "WIRE0_SDA_5": 1,
-        "WIRE0_SDA_6": 4,
-        "WIRE0_SDA_7": 5,
-        "WIRE0_SDA_8": 9,
-        "WIRE0_SDA_9": 24,
-        "WIRE0_SDA_10": 25,
-        "SERIAL0_RX": 3,
-        "SERIAL0_TX": 2,
-        "SERIAL1_RX": 24,
-        "SERIAL1_TX": 25,
-        "ADC3": 1,
-        "ADC4": 4,
-        "PA01": 1,
-        "PA1": 1,
-        "PA02": 2,
-        "PA2": 2,
-        "PA03": 3,
-        "PA3": 3,
-        "PA04": 4,
-        "PA4": 4,
-        "PA05": 5,
-        "PA5": 5,
-        "PA07": 7,
-        "PA7": 7,
-        "PA09": 9,
-        "PA9": 9,
-        "PA10": 10,
-        "PB08": 24,
-        "PB8": 24,
-        "PB09": 25,
-        "PB9": 25,
-        "RX0": 3,
-        "RX1": 24,
-        "SCL0": 25,
-        "SDA0": 25,
-        "TX0": 2,
-        "TX1": 25,
-        "D0": 7,
-        "D1": 5,
-        "D2": 3,
-        "D3": 10,
-        "D4": 2,
-        "D5": 1,
-        "D6": 4,
-        "D7": 9,
-        "D8": 24,
-        "D9": 25,
-        "A0": 1,
-        "A1": 4,
-    },
     "wl2s": {
         "WIRE0_SCL_0": 7,
         "WIRE0_SCL_1": 12,
@@ -362,6 +161,125 @@ LN882X_BOARD_PINS = {
         "A1": 1,
         "A2": 0,
     },
+    "generic-ln882hki": {
+        "WIRE0_SCL_0": 0,
+        "WIRE0_SCL_1": 1,
+        "WIRE0_SCL_2": 2,
+        "WIRE0_SCL_3": 3,
+        "WIRE0_SCL_4": 4,
+        "WIRE0_SCL_5": 5,
+        "WIRE0_SCL_6": 6,
+        "WIRE0_SCL_7": 7,
+        "WIRE0_SCL_8": 8,
+        "WIRE0_SCL_9": 9,
+        "WIRE0_SCL_10": 10,
+        "WIRE0_SCL_11": 11,
+        "WIRE0_SCL_12": 12,
+        "WIRE0_SCL_13": 19,
+        "WIRE0_SCL_14": 20,
+        "WIRE0_SCL_15": 21,
+        "WIRE0_SCL_16": 22,
+        "WIRE0_SCL_17": 23,
+        "WIRE0_SCL_18": 24,
+        "WIRE0_SCL_19": 25,
+        "WIRE0_SDA_0": 0,
+        "WIRE0_SDA_1": 1,
+        "WIRE0_SDA_2": 2,
+        "WIRE0_SDA_3": 3,
+        "WIRE0_SDA_4": 4,
+        "WIRE0_SDA_5": 5,
+        "WIRE0_SDA_6": 6,
+        "WIRE0_SDA_7": 7,
+        "WIRE0_SDA_8": 8,
+        "WIRE0_SDA_9": 9,
+        "WIRE0_SDA_10": 10,
+        "WIRE0_SDA_11": 11,
+        "WIRE0_SDA_12": 12,
+        "WIRE0_SDA_13": 19,
+        "WIRE0_SDA_14": 20,
+        "WIRE0_SDA_15": 21,
+        "WIRE0_SDA_16": 22,
+        "WIRE0_SDA_17": 23,
+        "WIRE0_SDA_18": 24,
+        "WIRE0_SDA_19": 25,
+        "SERIAL0_RX": 3,
+        "SERIAL0_TX": 2,
+        "SERIAL1_RX": 24,
+        "SERIAL1_TX": 25,
+        "ADC2": 0,
+        "ADC3": 1,
+        "ADC4": 4,
+        "ADC5": 19,
+        "ADC6": 20,
+        "ADC7": 21,
+        "PA00": 0,
+        "PA0": 0,
+        "PA01": 1,
+        "PA1": 1,
+        "PA02": 2,
+        "PA2": 2,
+        "PA03": 3,
+        "PA3": 3,
+        "PA04": 4,
+        "PA4": 4,
+        "PA05": 5,
+        "PA5": 5,
+        "PA06": 6,
+        "PA6": 6,
+        "PA07": 7,
+        "PA7": 7,
+        "PA08": 8,
+        "PA8": 8,
+        "PA09": 9,
+        "PA9": 9,
+        "PA10": 10,
+        "PA11": 11,
+        "PA12": 12,
+        "PB03": 19,
+        "PB3": 19,
+        "PB04": 20,
+        "PB4": 20,
+        "PB05": 21,
+        "PB5": 21,
+        "PB06": 22,
+        "PB6": 22,
+        "PB07": 23,
+        "PB7": 23,
+        "PB08": 24,
+        "PB8": 24,
+        "PB09": 25,
+        "PB9": 25,
+        "RX0": 3,
+        "RX1": 24,
+        "TX0": 2,
+        "TX1": 25,
+        "D0": 0,
+        "D1": 1,
+        "D2": 2,
+        "D3": 3,
+        "D4": 4,
+        "D5": 5,
+        "D6": 6,
+        "D7": 7,
+        "D8": 8,
+        "D9": 9,
+        "D10": 10,
+        "D11": 11,
+        "D12": 12,
+        "D13": 19,
+        "D14": 20,
+        "D15": 21,
+        "D16": 22,
+        "D17": 23,
+        "D18": 24,
+        "D19": 25,
+        "A2": 0,
+        "A3": 1,
+        "A4": 4,
+        "A5": 19,
+        "A6": 20,
+        "A7": 21,
+    },
 }
 
 BOARDS = LN882X_BOARDS

esphome/components/logger/__init__.py

@@ -421,7 +421,6 @@ async def to_code(config):
     await cg.register_component(log, config)
 
     for conf in config.get(CONF_ON_MESSAGE, []):
-        request_log_listener()  # Each on_message trigger needs a listener slot
         trigger = cg.new_Pvariable(
             conf[CONF_TRIGGER_ID], log, LOG_LEVEL_SEVERITY.index(conf[CONF_LEVEL])
         )
@@ -547,7 +546,6 @@ FILTER_SOURCE_FILES = filter_source_files_from_platform(
 # Keys for CORE.data storage
 DOMAIN = "logger"
 KEY_LEVEL_LISTENERS = "level_listeners"
-KEY_LOG_LISTENERS = "log_listeners"
 
 
 def request_logger_level_listeners() -> None:
@@ -560,26 +558,8 @@ def request_logger_level_listeners() -> None:
     CORE.data.setdefault(DOMAIN, {})[KEY_LEVEL_LISTENERS] = True
 
 
-def request_log_listener() -> None:
-    """Request a log listener slot.
-
-    Components that need to receive log messages should call this function
-    during their code generation. This increments the listener count used
-    to size the StaticVector.
-    """
-    data = CORE.data.setdefault(DOMAIN, {})
-    data[KEY_LOG_LISTENERS] = data.get(KEY_LOG_LISTENERS, 0) + 1
-
-
 @coroutine_with_priority(CoroPriority.FINAL)
 async def final_step():
     """Final code generation step to configure optional logger features."""
-    domain_data = CORE.data.get(DOMAIN, {})
-    if domain_data.get(KEY_LEVEL_LISTENERS, False):
+    if CORE.data.get(DOMAIN, {}).get(KEY_LEVEL_LISTENERS, False):
         cg.add_define("USE_LOGGER_LEVEL_LISTENERS")
-
-    # Only generate log listener code if any component needs it
-    log_listener_count = domain_data.get(KEY_LOG_LISTENERS, 0)
-    if log_listener_count > 0:
-        cg.add_define("USE_LOG_LISTENERS")
-        cg.add_define("ESPHOME_LOG_MAX_LISTENERS", log_listener_count)

esphome/components/logger/logger.cpp

@@ -23,57 +23,30 @@ static const char *const TAG = "logger";
 //    - Messages are serialized through main loop for proper console output
 //    - Fallback to emergency console logging only if ring buffer is full
 //  - WITHOUT task log buffer: Only emergency console output, no callbacks
-//
-// Optimized for the common case: 99.9% of logs come from the main thread
 void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const char *format, va_list args) {  // NOLINT
   if (level > this->level_for(tag))
     return;
 
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
-  // Get task handle once - used for both main task check and passing to non-main thread handler
   TaskHandle_t current_task = xTaskGetCurrentTaskHandle();
-  const bool is_main_task = (current_task == this->main_task_);
+  bool is_main_task = (current_task == main_task_);
 #else  // USE_HOST
-  const bool is_main_task = pthread_equal(pthread_self(), this->main_thread_);
+  pthread_t current_thread = pthread_self();
+  bool is_main_task = pthread_equal(current_thread, main_thread_);
 #endif
 
-  // Fast path: main thread, no recursion (99.9% of all logs)
-  if (is_main_task && !this->main_task_recursion_guard_) [[likely]] {
-    RecursionGuard guard(this->main_task_recursion_guard_);
-    // Format and send to both console and callbacks
-    this->log_message_to_buffer_and_send_(level, tag, line, format, args);
-    return;
+  // Check and set recursion guard - uses pthread TLS for per-thread/task state
+  if (this->check_and_set_task_log_recursion_(is_main_task)) {
+    return;  // Recursion detected
   }
 
-  // Main task with recursion - silently drop to prevent infinite loop
+  // Main thread/task uses the shared buffer for efficiency
   if (is_main_task) {
+    this->log_message_to_buffer_and_send_(level, tag, line, format, args);
+    this->reset_task_log_recursion_(is_main_task);
     return;
   }
 
-  // Non-main thread handling (~0.1% of logs)
-#if defined(USE_ESP32) || defined(USE_LIBRETINY)
-  this->log_vprintf_non_main_thread_(level, tag, line, format, args, current_task);
-#else  // USE_HOST
-  this->log_vprintf_non_main_thread_(level, tag, line, format, args);
-#endif
-}
-
-// Handles non-main thread logging only
-// Kept separate from hot path to improve instruction cache performance
-#if defined(USE_ESP32) || defined(USE_LIBRETINY)
-void Logger::log_vprintf_non_main_thread_(uint8_t level, const char *tag, int line, const char *format, va_list args,
-                                          TaskHandle_t current_task) {
-#else  // USE_HOST
-void Logger::log_vprintf_non_main_thread_(uint8_t level, const char *tag, int line, const char *format, va_list args) {
-#endif
-  // Check if already in recursion for this non-main thread/task
-  if (this->is_non_main_task_recursive_()) {
-    return;
-  }
-
-  // RAII guard - automatically resets on any return path
-  auto guard = this->make_non_main_task_guard_();
-
   bool message_sent = false;
 #ifdef USE_ESPHOME_TASK_LOG_BUFFER
   // For non-main threads/tasks, queue the message for callbacks
@@ -112,17 +85,21 @@ void Logger::log_vprintf_non_main_thread_(uint8_t level, const char *tag, int li
     this->write_msg_(console_buffer, buffer_at);
   }
 
-  // RAII guard automatically resets on return
+  // Reset the recursion guard for this thread/task
+  this->reset_task_log_recursion_(is_main_task);
 }
 #else
-// Implementation for all other platforms (single-task, no threading)
+// Implementation for all other platforms
 void HOT Logger::log_vprintf_(uint8_t level, const char *tag, int line, const char *format, va_list args) {  // NOLINT
   if (level > this->level_for(tag) || global_recursion_guard_)
     return;
 
-  RecursionGuard guard(global_recursion_guard_);
+  global_recursion_guard_ = true;
+
   // Format and send to both console and callbacks
   this->log_message_to_buffer_and_send_(level, tag, line, format, args);
+
+  global_recursion_guard_ = false;
 }
 #endif  // USE_ESP32 / USE_HOST / USE_LIBRETINY
 
@@ -153,7 +130,7 @@ void Logger::log_vprintf_(uint8_t level, const char *tag, int line, const __Flas
   if (level > this->level_for(tag) || global_recursion_guard_)
     return;
 
-  RecursionGuard guard(global_recursion_guard_);
+  global_recursion_guard_ = true;
   this->tx_buffer_at_ = 0;
 
   // Copy format string from progmem
@@ -163,8 +140,9 @@ void Logger::log_vprintf_(uint8_t level, const char *tag, int line, const __Flas
     this->tx_buffer_[this->tx_buffer_at_++] = ch = (char) progmem_read_byte(format_pgm_p++);
   }
 
-  // Buffer full from copying format - RAII guard handles cleanup on return
+  // Buffer full from copying format
   if (this->tx_buffer_at_ >= this->tx_buffer_size_) {
+    global_recursion_guard_ = false;  // Make sure to reset the recursion guard before returning
     return;
   }
 
@@ -178,13 +156,13 @@ void Logger::log_vprintf_(uint8_t level, const char *tag, int line, const __Flas
       this->tx_buffer_at_ - msg_start;  // Don't subtract 1 - tx_buffer_at_ is already at the null terminator position
 
   // Listeners get message first (before console write)
-#ifdef USE_LOG_LISTENERS
   for (auto *listener : this->log_listeners_)
     listener->on_log(level, tag, this->tx_buffer_ + msg_start, msg_length);
-#endif
 
   // Write to console starting at the msg_start
   this->write_tx_buffer_to_console_(msg_start, &msg_length);
+
+  global_recursion_guard_ = false;
 }
 #endif  // USE_STORE_LOG_STR_IN_FLASH
 

esphome/components/logger/logger.h

@@ -212,13 +212,8 @@ class Logger : public Component {
 
   inline uint8_t level_for(const char *tag);
 
-#ifdef USE_LOG_LISTENERS
   /// Register a log listener to receive log messages
   void add_log_listener(LogListener *listener) { this->log_listeners_.push_back(listener); }
-#else
-  /// No-op when log listeners are disabled
-  void add_log_listener(LogListener *listener) {}
-#endif
 
 #ifdef USE_LOGGER_LEVEL_LISTENERS
   /// Register a listener for log level changes
@@ -234,31 +229,6 @@ class Logger : public Component {
 #endif
 
  protected:
-  // RAII guard for recursion flags - sets flag on construction, clears on destruction
-  class RecursionGuard {
-   public:
-    explicit RecursionGuard(bool &flag) : flag_(flag) { flag_ = true; }
-    ~RecursionGuard() { flag_ = false; }
-    RecursionGuard(const RecursionGuard &) = delete;
-    RecursionGuard &operator=(const RecursionGuard &) = delete;
-    RecursionGuard(RecursionGuard &&) = delete;
-    RecursionGuard &operator=(RecursionGuard &&) = delete;
-
-   private:
-    bool &flag_;
-  };
-
-#if defined(USE_ESP32) || defined(USE_HOST) || defined(USE_LIBRETINY)
-  // Handles non-main thread logging only (~0.1% of calls)
-#if defined(USE_ESP32) || defined(USE_LIBRETINY)
-  // ESP32/LibreTiny: Pass task handle to avoid calling xTaskGetCurrentTaskHandle() twice
-  void log_vprintf_non_main_thread_(uint8_t level, const char *tag, int line, const char *format, va_list args,
-                                    TaskHandle_t current_task);
-#else  // USE_HOST
-  // Host: No task handle parameter needed (not used in send_message_thread_safe)
-  void log_vprintf_non_main_thread_(uint8_t level, const char *tag, int line, const char *format, va_list args);
-#endif
-#endif
   void process_messages_();
   void write_msg_(const char *msg, size_t len);
 
@@ -323,10 +293,8 @@ class Logger : public Component {
                                                 this->tx_buffer_size_);
 
     // Listeners get message WITHOUT newline (for API/MQTT/syslog)
-#ifdef USE_LOG_LISTENERS
     for (auto *listener : this->log_listeners_)
       listener->on_log(level, tag, this->tx_buffer_, this->tx_buffer_at_);
-#endif
 
     // Console gets message WITH newline (if platform needs it)
     this->write_tx_buffer_to_console_();
@@ -343,10 +311,8 @@ class Logger : public Component {
     this->write_body_to_buffer_(text, text_length, this->tx_buffer_, &this->tx_buffer_at_, this->tx_buffer_size_);
     this->write_footer_to_buffer_(this->tx_buffer_, &this->tx_buffer_at_, this->tx_buffer_size_);
     this->tx_buffer_[this->tx_buffer_at_] = '\0';
-#ifdef USE_LOG_LISTENERS
     for (auto *listener : this->log_listeners_)
       listener->on_log(level, tag, this->tx_buffer_, this->tx_buffer_at_);
-#endif
   }
 #endif
 
@@ -382,10 +348,10 @@ class Logger : public Component {
   const device *uart_dev_{nullptr};
 #endif
 #if defined(USE_ESP32) || defined(USE_LIBRETINY) || defined(USE_ZEPHYR)
-  void *main_task_{nullptr};  // Main thread/task for fast path comparison
+  void *main_task_ = nullptr;  // Only used for thread name identification
 #endif
 #ifdef USE_HOST
-  pthread_t main_thread_{};  // Main thread for pthread_equal() comparison
+  pthread_t main_thread_{};  // Main thread for identification
 #endif
 #ifdef USE_ESP32
   // Task-specific recursion guards:
@@ -403,10 +369,7 @@ class Logger : public Component {
 #ifdef USE_LOGGER_RUNTIME_TAG_LEVELS
   std::map<const char *, uint8_t, CStrCompare> log_levels_{};
 #endif
-#ifdef USE_LOG_LISTENERS
-  StaticVector<LogListener *, ESPHOME_LOG_MAX_LISTENERS>
-      log_listeners_;  // Log message listeners (API, MQTT, syslog, etc.)
-#endif
+  std::vector<LogListener *> log_listeners_;  // Log message listeners (API, MQTT, syslog, etc.)
 #ifdef USE_LOGGER_LEVEL_LISTENERS
   std::vector<LoggerLevelListener *> level_listeners_;  // Log level change listeners
 #endif
@@ -471,28 +434,29 @@ class Logger : public Component {
 #endif
 
 #if defined(USE_ESP32) || defined(USE_HOST)
-  // RAII guard for non-main task recursion using pthread TLS
-  class NonMainTaskRecursionGuard {
-   public:
-    explicit NonMainTaskRecursionGuard(pthread_key_t key) : key_(key) {
-      pthread_setspecific(key_, reinterpret_cast<void *>(1));
+  inline bool HOT check_and_set_task_log_recursion_(bool is_main_task) {
+    if (is_main_task) {
+      const bool was_recursive = main_task_recursion_guard_;
+      main_task_recursion_guard_ = true;
+      return was_recursive;
     }
-    ~NonMainTaskRecursionGuard() { pthread_setspecific(key_, nullptr); }
-    NonMainTaskRecursionGuard(const NonMainTaskRecursionGuard &) = delete;
-    NonMainTaskRecursionGuard &operator=(const NonMainTaskRecursionGuard &) = delete;
-    NonMainTaskRecursionGuard(NonMainTaskRecursionGuard &&) = delete;
-    NonMainTaskRecursionGuard &operator=(NonMainTaskRecursionGuard &&) = delete;
 
-   private:
-    pthread_key_t key_;
-  };
+    intptr_t current = (intptr_t) pthread_getspecific(log_recursion_key_);
+    if (current != 0)
+      return true;
 
-  // Check if non-main task is already in recursion (via TLS)
-  inline bool HOT is_non_main_task_recursive_() const { return pthread_getspecific(log_recursion_key_) != nullptr; }
+    pthread_setspecific(log_recursion_key_, (void *) 1);
+    return false;
+  }
 
-  // Create RAII guard for non-main task recursion
-  inline NonMainTaskRecursionGuard make_non_main_task_guard_() { return NonMainTaskRecursionGuard(log_recursion_key_); }
+  inline void HOT reset_task_log_recursion_(bool is_main_task) {
+    if (is_main_task) {
+      main_task_recursion_guard_ = false;
+      return;
+    }
 
+    pthread_setspecific(log_recursion_key_, (void *) 0);
+  }
 #elif defined(USE_LIBRETINY)
   // LibreTiny doesn't have FreeRTOS TLS, so use a simple approach:
   // - Main task uses dedicated boolean (same as ESP32)
@@ -502,11 +466,29 @@ class Logger : public Component {
   // - Cross-task "recursion" is prevented by the buffer mutex anyway
   // - Missing a recursive call from another task is acceptable (falls back to direct output)
 
-  // Check if non-main task is already in recursion
-  inline bool HOT is_non_main_task_recursive_() const { return non_main_task_recursion_guard_; }
+  inline bool HOT check_and_set_task_log_recursion_(bool is_main_task) {
+    if (is_main_task) {
+      const bool was_recursive = main_task_recursion_guard_;
+      main_task_recursion_guard_ = true;
+      return was_recursive;
+    }
 
-  // Create RAII guard for non-main task recursion (uses shared boolean for all non-main tasks)
-  inline RecursionGuard make_non_main_task_guard_() { return RecursionGuard(non_main_task_recursion_guard_); }
+    // For non-main tasks, use a simple shared guard
+    // This may block legitimate concurrent logs from different tasks,
+    // but that's acceptable - they'll fall back to direct console output
+    const bool was_recursive = non_main_task_recursion_guard_;
+    non_main_task_recursion_guard_ = true;
+    return was_recursive;
+  }
+
+  inline void HOT reset_task_log_recursion_(bool is_main_task) {
+    if (is_main_task) {
+      main_task_recursion_guard_ = false;
+      return;
+    }
+
+    non_main_task_recursion_guard_ = false;
+  }
 #endif
 
 #ifdef USE_HOST

esphome/components/mqtt/__init__.py

@@ -350,7 +350,6 @@ def exp_mqtt_message(config):
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
-
     # Add required libraries for ESP8266 and LibreTiny
     if CORE.is_esp8266 or CORE.is_libretiny:
         # https://github.com/heman/async-mqtt-client/blob/master/library.json
@@ -433,8 +432,6 @@ async def to_code(config):
         cg.add(var.disable_log_message())
     else:
         cg.add(var.set_log_message_template(exp_mqtt_message(log_topic)))
-        # Request a log listener slot only when log topic is enabled
-        logger.request_log_listener()
 
         if CONF_LEVEL in log_topic:
             cg.add(var.set_log_level(logger.LOG_LEVELS[log_topic[CONF_LEVEL]]))
@@ -575,13 +572,9 @@ async def register_mqtt_component(var, config):
     if not config.get(CONF_DISCOVERY, True):
         cg.add(var.disable_discovery())
     if CONF_STATE_TOPIC in config:
-        state_topic = await cg.templatable(config[CONF_STATE_TOPIC], [], cg.std_string)
-        cg.add(var.set_custom_state_topic(state_topic))
+        cg.add(var.set_custom_state_topic(config[CONF_STATE_TOPIC]))
     if CONF_COMMAND_TOPIC in config:
-        command_topic = await cg.templatable(
-            config[CONF_COMMAND_TOPIC], [], cg.std_string
-        )
-        cg.add(var.set_custom_command_topic(command_topic))
+        cg.add(var.set_custom_command_topic(config[CONF_COMMAND_TOPIC]))
     if CONF_COMMAND_RETAIN in config:
         cg.add(var.set_command_retain(config[CONF_COMMAND_RETAIN]))
     if CONF_AVAILABILITY in config:

esphome/components/mqtt/custom_mqtt_device.cpp

@@ -13,13 +13,13 @@ bool CustomMQTTDevice::publish(const std::string &topic, const std::string &payl
 }
 bool CustomMQTTDevice::publish(const std::string &topic, float value, int8_t number_decimals) {
   char buf[VALUE_ACCURACY_MAX_LEN];
-  size_t len = value_accuracy_to_buf(buf, value, number_decimals);
-  return global_mqtt_client->publish(topic, buf, len);
+  value_accuracy_to_buf(buf, value, number_decimals);
+  return this->publish(topic, buf);
 }
 bool CustomMQTTDevice::publish(const std::string &topic, int value) {
   char buffer[24];
-  int len = snprintf(buffer, sizeof(buffer), "%d", value);
-  return global_mqtt_client->publish(topic, buffer, len);
+  sprintf(buffer, "%d", value);
+  return this->publish(topic, buffer);
 }
 bool CustomMQTTDevice::publish_json(const std::string &topic, const json::json_build_t &f, uint8_t qos, bool retain) {
   return global_mqtt_client->publish_json(topic, f, qos, retain);

esphome/components/mqtt/mqtt_climate.cpp

@@ -292,37 +292,36 @@ bool MQTTClimateComponent::publish_state_() {
   int8_t target_accuracy = traits.get_target_temperature_accuracy_decimals();
   int8_t current_accuracy = traits.get_current_temperature_accuracy_decimals();
   char payload[VALUE_ACCURACY_MAX_LEN];
-  size_t len;
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE) &&
       !std::isnan(this->device_->current_temperature)) {
-    len = value_accuracy_to_buf(payload, this->device_->current_temperature, current_accuracy);
-    if (!this->publish(this->get_current_temperature_state_topic(), payload, len))
+    value_accuracy_to_buf(payload, this->device_->current_temperature, current_accuracy);
+    if (!this->publish(this->get_current_temperature_state_topic(), payload))
       success = false;
   }
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE |
                                climate::CLIMATE_REQUIRES_TWO_POINT_TARGET_TEMPERATURE)) {
-    len = value_accuracy_to_buf(payload, this->device_->target_temperature_low, target_accuracy);
-    if (!this->publish(this->get_target_temperature_low_state_topic(), payload, len))
+    value_accuracy_to_buf(payload, this->device_->target_temperature_low, target_accuracy);
+    if (!this->publish(this->get_target_temperature_low_state_topic(), payload))
       success = false;
-    len = value_accuracy_to_buf(payload, this->device_->target_temperature_high, target_accuracy);
-    if (!this->publish(this->get_target_temperature_high_state_topic(), payload, len))
+    value_accuracy_to_buf(payload, this->device_->target_temperature_high, target_accuracy);
+    if (!this->publish(this->get_target_temperature_high_state_topic(), payload))
       success = false;
   } else {
-    len = value_accuracy_to_buf(payload, this->device_->target_temperature, target_accuracy);
-    if (!this->publish(this->get_target_temperature_state_topic(), payload, len))
+    value_accuracy_to_buf(payload, this->device_->target_temperature, target_accuracy);
+    if (!this->publish(this->get_target_temperature_state_topic(), payload))
       success = false;
   }
 
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_HUMIDITY) &&
       !std::isnan(this->device_->current_humidity)) {
-    len = value_accuracy_to_buf(payload, this->device_->current_humidity, 0);
-    if (!this->publish(this->get_current_humidity_state_topic(), payload, len))
+    value_accuracy_to_buf(payload, this->device_->current_humidity, 0);
+    if (!this->publish(this->get_current_humidity_state_topic(), payload))
       success = false;
   }
   if (traits.has_feature_flags(climate::CLIMATE_SUPPORTS_TARGET_HUMIDITY) &&
       !std::isnan(this->device_->target_humidity)) {
-    len = value_accuracy_to_buf(payload, this->device_->target_humidity, 0);
-    if (!this->publish(this->get_target_humidity_state_topic(), payload, len))
+    value_accuracy_to_buf(payload, this->device_->target_humidity, 0);
+    if (!this->publish(this->get_target_humidity_state_topic(), payload))
       success = false;
   }
 

esphome/components/mqtt/mqtt_component.cpp

@@ -94,25 +94,21 @@ std::string MQTTComponent::get_default_topic_for_(const std::string &suffix) con
 }
 
 std::string MQTTComponent::get_state_topic_() const {
-  if (this->custom_state_topic_.has_value())
-    return this->custom_state_topic_.value();
+  if (this->has_custom_state_topic_)
+    return this->custom_state_topic_.str();
   return this->get_default_topic_for_("state");
 }
 
 std::string MQTTComponent::get_command_topic_() const {
-  if (this->custom_command_topic_.has_value())
-    return this->custom_command_topic_.value();
+  if (this->has_custom_command_topic_)
+    return this->custom_command_topic_.str();
   return this->get_default_topic_for_("command");
 }
 
 bool MQTTComponent::publish(const std::string &topic, const std::string &payload) {
-  return this->publish(topic, payload.data(), payload.size());
-}
-
-bool MQTTComponent::publish(const std::string &topic, const char *payload, size_t payload_length) {
   if (topic.empty())
     return false;
-  return global_mqtt_client->publish(topic, payload, payload_length, this->qos_, this->retain_);
+  return global_mqtt_client->publish(topic, payload, this->qos_, this->retain_);
 }
 
 bool MQTTComponent::publish_json(const std::string &topic, const json::json_build_t &f) {
@@ -277,6 +273,14 @@ MQTTComponent::MQTTComponent() = default;
 
 float MQTTComponent::get_setup_priority() const { return setup_priority::AFTER_CONNECTION; }
 void MQTTComponent::disable_discovery() { this->discovery_enabled_ = false; }
+void MQTTComponent::set_custom_state_topic(const char *custom_state_topic) {
+  this->custom_state_topic_ = StringRef(custom_state_topic);
+  this->has_custom_state_topic_ = true;
+}
+void MQTTComponent::set_custom_command_topic(const char *custom_command_topic) {
+  this->custom_command_topic_ = StringRef(custom_command_topic);
+  this->has_custom_command_topic_ = true;
+}
 void MQTTComponent::set_command_retain(bool command_retain) { this->command_retain_ = command_retain; }
 
 void MQTTComponent::set_availability(std::string topic, std::string payload_available,
@@ -345,13 +349,13 @@ StringRef MQTTComponent::get_default_object_id_to_(std::span<char, OBJECT_ID_MAX
 StringRef MQTTComponent::get_icon_ref_() const { return this->get_entity()->get_icon_ref(); }
 bool MQTTComponent::is_disabled_by_default_() const { return this->get_entity()->is_disabled_by_default(); }
 bool MQTTComponent::is_internal() {
-  if (this->custom_state_topic_.has_value()) {
+  if (this->has_custom_state_topic_) {
     // If the custom state_topic is null, return true as it is internal and should not publish
     // else, return false, as it is explicitly set to a topic, so it is not internal and should publish
     return this->get_state_topic_().empty();
   }
 
-  if (this->custom_command_topic_.has_value()) {
+  if (this->has_custom_command_topic_) {
     // If the custom command_topic is null, return true as it is internal and should not publish
     // else, return false, as it is explicitly set to a topic, so it is not internal and should publish
     return this->get_command_topic_().empty();

esphome/components/mqtt/mqtt_component.h

@@ -6,7 +6,6 @@
 
 #include <memory>
 
-#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
 #include "esphome/core/string_ref.h"
@@ -110,13 +109,10 @@ class MQTTComponent : public Component {
   /// Override this method to return the component type (e.g. "light", "sensor", ...)
   virtual const char *component_type() const = 0;
 
-  /// Set a custom state topic. Do not set for default behavior.
-  template<typename T> void set_custom_state_topic(T &&custom_state_topic) {
-    this->custom_state_topic_ = std::forward<T>(custom_state_topic);
-  }
-  template<typename T> void set_custom_command_topic(T &&custom_command_topic) {
-    this->custom_command_topic_ = std::forward<T>(custom_command_topic);
-  }
+  /// Set a custom state topic. Set to "" for default behavior.
+  void set_custom_state_topic(const char *custom_state_topic);
+  /// Set a custom command topic. Set to "" for default behavior.
+  void set_custom_command_topic(const char *custom_command_topic);
   /// Set whether command message should be retained.
   void set_command_retain(bool command_retain);
 
@@ -140,14 +136,6 @@ class MQTTComponent : public Component {
    */
   bool publish(const std::string &topic, const std::string &payload);
 
-  /** Send a MQTT message.
-   *
-   * @param topic The topic.
-   * @param payload The payload buffer.
-   * @param payload_length The length of the payload.
-   */
-  bool publish(const std::string &topic, const char *payload, size_t payload_length);
-
   /** Construct and send a JSON MQTT message.
    *
    * @param topic The topic.
@@ -215,11 +203,14 @@ class MQTTComponent : public Component {
   /// Get the object ID for this MQTT component, writing to the provided buffer.
   StringRef get_default_object_id_to_(std::span<char, OBJECT_ID_MAX_LEN> buf) const;
 
-  TemplatableValue<std::string> custom_state_topic_{};
-  TemplatableValue<std::string> custom_command_topic_{};
+  StringRef custom_state_topic_{};
+  StringRef custom_command_topic_{};
 
   std::unique_ptr<Availability> availability_;
 
+  bool has_custom_state_topic_{false};
+  bool has_custom_command_topic_{false};
+
   bool command_retain_{false};
   bool retain_{true};
   uint8_t qos_{0};

esphome/components/mqtt/mqtt_cover.cpp

@@ -99,14 +99,14 @@ bool MQTTCoverComponent::publish_state() {
   bool success = true;
   if (traits.get_supports_position()) {
     char pos[VALUE_ACCURACY_MAX_LEN];
-    size_t len = value_accuracy_to_buf(pos, roundf(this->cover_->position * 100), 0);
-    if (!this->publish(this->get_position_state_topic(), pos, len))
+    value_accuracy_to_buf(pos, roundf(this->cover_->position * 100), 0);
+    if (!this->publish(this->get_position_state_topic(), pos))
       success = false;
   }
   if (traits.get_supports_tilt()) {
     char pos[VALUE_ACCURACY_MAX_LEN];
-    size_t len = value_accuracy_to_buf(pos, roundf(this->cover_->tilt * 100), 0);
-    if (!this->publish(this->get_tilt_state_topic(), pos, len))
+    value_accuracy_to_buf(pos, roundf(this->cover_->tilt * 100), 0);
+    if (!this->publish(this->get_tilt_state_topic(), pos))
       success = false;
   }
   const char *state_s = this->cover_->current_operation == COVER_OPERATION_OPENING   ? "opening"

esphome/components/mqtt/mqtt_fan.cpp

@@ -174,9 +174,8 @@ bool MQTTFanComponent::publish_state() {
   }
   auto traits = this->state_->get_traits();
   if (traits.supports_speed()) {
-    char buf[12];
-    int len = snprintf(buf, sizeof(buf), "%d", this->state_->speed);
-    bool success = this->publish(this->get_speed_level_state_topic(), buf, len);
+    std::string payload = to_string(this->state_->speed);
+    bool success = this->publish(this->get_speed_level_state_topic(), payload);
     failed = failed || !success;
   }
   return !failed;

esphome/components/mqtt/mqtt_sensor.cpp

@@ -80,11 +80,11 @@ bool MQTTSensorComponent::send_initial_state() {
 }
 bool MQTTSensorComponent::publish_state(float value) {
   if (mqtt::global_mqtt_client->is_publish_nan_as_none() && std::isnan(value))
-    return this->publish(this->get_state_topic_(), "None", 4);
+    return this->publish(this->get_state_topic_(), "None");
   int8_t accuracy = this->sensor_->get_accuracy_decimals();
   char buf[VALUE_ACCURACY_MAX_LEN];
-  size_t len = value_accuracy_to_buf(buf, value, accuracy);
-  return this->publish(this->get_state_topic_(), buf, len);
+  value_accuracy_to_buf(buf, value, accuracy);
+  return this->publish(this->get_state_topic_(), buf);
 }
 
 }  // namespace esphome::mqtt

esphome/components/mqtt/mqtt_valve.cpp

@@ -74,8 +74,8 @@ bool MQTTValveComponent::publish_state() {
   bool success = true;
   if (traits.get_supports_position()) {
     char pos[VALUE_ACCURACY_MAX_LEN];
-    size_t len = value_accuracy_to_buf(pos, roundf(this->valve_->position * 100), 0);
-    if (!this->publish(this->get_position_state_topic(), pos, len))
+    value_accuracy_to_buf(pos, roundf(this->valve_->position * 100), 0);
+    if (!this->publish(this->get_position_state_topic(), pos))
       success = false;
   }
   const char *state_s = this->valve_->current_operation == VALVE_OPERATION_OPENING   ? "opening"

esphome/components/nfc/nfc.cpp

@@ -18,9 +18,9 @@ char *format_bytes_to(char *buffer, const std::vector<uint8_t> &bytes) {
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-// Deprecated wrappers intentionally use heap-allocating version for backward compatibility
-std::string format_uid(const std::vector<uint8_t> &uid) { return format_hex_pretty(uid, '-', false); }        // NOLINT
-std::string format_bytes(const std::vector<uint8_t> &bytes) { return format_hex_pretty(bytes, ' ', false); }  // NOLINT
+std::string format_uid(const std::vector<uint8_t> &uid) { return format_hex_pretty(uid, '-', false); }
+
+std::string format_bytes(const std::vector<uint8_t> &bytes) { return format_hex_pretty(bytes, ' ', false); }
 #pragma GCC diagnostic pop
 
 uint8_t guess_tag_type(uint8_t uid_length) {

esphome/components/ota/ota_backend_esp_idf.cpp

@@ -14,13 +14,6 @@ namespace ota {
 std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::IDFOTABackend>(); }
 
 OTAResponseTypes IDFOTABackend::begin(size_t image_size) {
-#ifdef USE_OTA_ROLLBACK
-  // If we're starting an OTA, the current boot is good enough - mark it valid
-  // to prevent rollback and allow the OTA to proceed even if the safe mode
-  // timer hasn't expired yet.
-  esp_ota_mark_app_valid_cancel_rollback();
-#endif
-
   this->partition_ = esp_ota_get_next_update_partition(nullptr);
   if (this->partition_ == nullptr) {
     return OTA_RESPONSE_ERROR_NO_UPDATE_PARTITION;

esphome/components/rc522/rc522.cpp

@@ -220,7 +220,7 @@ void RC522::loop() {
 
       std::vector<uint8_t> rfid_uid(std::begin(uid_buffer_), std::begin(uid_buffer_) + uid_idx_);
       uid_idx_ = 0;
-      // ESP_LOGD(TAG, "Processing '%s'", format_hex_pretty(rfid_uid, '-', false).c_str());  // NOLINT
+      // ESP_LOGD(TAG, "Processing '%s'", format_hex_pretty(rfid_uid, '-', false).c_str());
       pcd_antenna_off_();
       state_ = STATE_INIT;  // scan again on next update
       bool report = true;

esphome/components/remote_base/midea_protocol.h

@@ -31,7 +31,7 @@ class MideaData {
   bool is_compliment(const MideaData &rhs) const;
   /// @deprecated Allocates heap memory. Use to_str() instead. Removed in 2026.7.0.
   ESPDEPRECATED("Allocates heap memory. Use to_str() instead. Removed in 2026.7.0.", "2026.1.0")
-  std::string to_string() const { return format_hex_pretty(this->data_.data(), this->data_.size()); }  // NOLINT
+  std::string to_string() const { return format_hex_pretty(this->data_.data(), this->data_.size()); }
   /// Buffer size for to_str(): 6 bytes = "AA.BB.CC.DD.EE.FF\0"
   static constexpr size_t TO_STR_BUFFER_SIZE = format_hex_pretty_size(6);
   /// Format to buffer, returns pointer to buffer

esphome/components/rtl87xx/__init__.py

@@ -1,29 +1,18 @@
-"""
-██╗    ██╗ █████╗ ██████╗ ███╗   ██╗██╗███╗   ██╗ ██████╗
-██║    ██║██╔══██╗██╔══██╗████╗  ██║██║████╗  ██║██╔════╝
-██║ █╗ ██║███████║██████╔╝██╔██╗ ██║██║██╔██╗ ██║██║  ███╗
-██║███╗██║██╔══██║██╔══██╗██║╚██╗██║██║██║╚██╗██║██║   ██║
-╚███╔███╔╝██║  ██║██║  ██║██║ ╚████║██║██║ ╚████║╚██████╔╝
- ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═══╝ ╚═════╝
-
-         AUTO-GENERATED FILE - DO NOT EDIT!
-
-This file was auto-generated by libretiny/generate_components.py.
-Any manual changes WILL BE LOST on regeneration.
-
-To customize this component:
-  - Pin validators: Create gpio.py with validate_pin() or validate_usage()
-  - Schema extensions: Create schema.py with COMPONENT_SCHEMA or COMPONENT_PIN_SCHEMA
-
-Platform-specific code should be added to the main libretiny component
-(__init__.py in esphome/components/libretiny/) rather than here.
-"""
+# This file was auto-generated by libretiny/generate_components.py
+# Do not modify its contents.
+# For custom pin validators, put validate_pin() or validate_usage()
+# in gpio.py file in this directory.
+# For changing schema/pin schema, put COMPONENT_SCHEMA or COMPONENT_PIN_SCHEMA
+# in schema.py file in this directory.
 
 from esphome import pins
+import esphome.codegen as cg
 from esphome.components import libretiny
 from esphome.components.libretiny.const import (
     COMPONENT_RTL87XX,
+    FAMILY_RTL8710B,
     KEY_COMPONENT_DATA,
+    KEY_FAMILY,
     KEY_LIBRETINY,
     LibreTinyComponent,
 )
@@ -35,13 +24,13 @@ CODEOWNERS = ["@kuba2k2"]
 AUTO_LOAD = ["libretiny"]
 IS_TARGET_PLATFORM = True
 
+
 COMPONENT_DATA = LibreTinyComponent(
     name=COMPONENT_RTL87XX,
     boards=RTL87XX_BOARDS,
     board_pins=RTL87XX_BOARD_PINS,
     pin_validation=None,
     usage_validation=None,
-    supports_atomics=True,
 )
 
 
@@ -59,6 +48,11 @@ CONFIG_SCHEMA.prepend_extra(_set_core_data)
 
 
 async def to_code(config):
+    # Use FreeRTOS 8.2.3+ for xTaskNotifyGive/ulTaskNotifyTake required by AsyncTCP 3.4.3+
+    # https://github.com/esphome/esphome/issues/10220
+    # Only for RTL8710B (ambz) - RTL8720C (ambz2) requires FreeRTOS 10.x
+    if CORE.data[KEY_LIBRETINY][KEY_FAMILY] == FAMILY_RTL8710B:
+        cg.add_platformio_option("custom_versions.freertos", "8.2.3")
     return await libretiny.component_to_code(config)
 
 

esphome/components/socket/bsd_sockets_impl.cpp

@@ -79,13 +79,7 @@ class BSDSocketImpl final : public Socket {
     return ::setsockopt(this->fd_, level, optname, optval, optlen);
   }
   int listen(int backlog) override { return ::listen(this->fd_, backlog); }
-  ssize_t read(void *buf, size_t len) override {
-#ifdef USE_ESP32
-    return ::lwip_read(this->fd_, buf, len);
-#else
-    return ::read(this->fd_, buf, len);
-#endif
-  }
+  ssize_t read(void *buf, size_t len) override { return ::read(this->fd_, buf, len); }
   ssize_t recvfrom(void *buf, size_t len, sockaddr *addr, socklen_t *addr_len) override {
 #if defined(USE_ESP32) || defined(USE_HOST)
     return ::recvfrom(this->fd_, buf, len, 0, addr, addr_len);
@@ -100,13 +94,7 @@ class BSDSocketImpl final : public Socket {
     return ::readv(this->fd_, iov, iovcnt);
 #endif
   }
-  ssize_t write(const void *buf, size_t len) override {
-#ifdef USE_ESP32
-    return ::lwip_write(this->fd_, buf, len);
-#else
-    return ::write(this->fd_, buf, len);
-#endif
-  }
+  ssize_t write(const void *buf, size_t len) override { return ::write(this->fd_, buf, len); }
   ssize_t send(void *buf, size_t len, int flags) { return ::send(this->fd_, buf, len, flags); }
   ssize_t writev(const struct iovec *iov, int iovcnt) override {
 #if defined(USE_ESP32)

esphome/components/ssd1306_base/ssd1306_base.cpp

@@ -32,8 +32,6 @@ static const uint8_t SSD1306_COMMAND_PAGE_ADDRESS = 0x22;
 static const uint8_t SSD1306_COMMAND_NORMAL_DISPLAY = 0xA6;
 static const uint8_t SSD1306_COMMAND_INVERSE_DISPLAY = 0xA7;
 
-static const uint8_t SSD1306B_COMMAND_SELECT_IREF = 0xAD;
-
 static const uint8_t SSD1305_COMMAND_SET_BRIGHTNESS = 0x82;
 static const uint8_t SSD1305_COMMAND_SET_AREA_COLOR = 0xD8;
 
@@ -97,12 +95,6 @@ void SSD1306::setup() {
       this->command(0x8B);
     }
   } else {
-    if (this->is_ssd1306b_()) {
-      // Select external or internal Iref (0xAD)
-      this->command(SSD1306B_COMMAND_SELECT_IREF);
-      // Enable internal Iref and change from 19ua (POR) to 30uA
-      this->command(0x20 | 0x10);
-    }
     // Enable charge pump (0x8D)
     this->command(SSD1306_COMMAND_CHARGE_PUMP);
     if (this->external_vcc_) {
@@ -234,8 +226,6 @@ bool SSD1306::is_sh1107_() const { return this->model_ == SH1107_MODEL_128_64 ||
 bool SSD1306::is_ssd1305_() const {
   return this->model_ == SSD1305_MODEL_128_64 || this->model_ == SSD1305_MODEL_128_32;
 }
-bool SSD1306::is_ssd1306b_() const { return this->model_ == SSD1306_MODEL_72_40; }
-
 void SSD1306::update() {
   this->do_update_();
   this->display();

esphome/components/ssd1306_base/ssd1306_base.h

@@ -63,7 +63,6 @@ class SSD1306 : public display::DisplayBuffer {
   bool is_sh1106_() const;
   bool is_sh1107_() const;
   bool is_ssd1305_() const;
-  bool is_ssd1306b_() const;
 
   void draw_absolute_pixel_internal(int x, int y, Color color) override;
 

esphome/components/ssd1306_i2c/ssd1306_i2c.cpp

@@ -62,9 +62,9 @@ void HOT I2CSSD1306::write_display_data() {
     }
   } else {
     size_t block_size = 16;
-    if ((this->get_buffer_length_() % 24) == 0) {
-      // use 24 byte block size for e.g. 72x40 displays where buffer size is multiple of 24, not 16
-      block_size = 24;
+    if ((this->get_buffer_length_() & 8) == 8) {
+      // use smaller block size for e.g. 72x40 displays where buffer size is multiple of 8, not 16
+      block_size = 8;
     }
 
     for (uint32_t i = 0; i < this->get_buffer_length_();) {

esphome/components/switch/__init__.py

@@ -1,7 +1,7 @@
 from esphome import automation
 from esphome.automation import Condition, maybe_simple_id
 import esphome.codegen as cg
-from esphome.components import mqtt, web_server, zigbee
+from esphome.components import mqtt, web_server
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_DEVICE_CLASS,
@@ -74,7 +74,6 @@ validate_device_class = cv.one_of(*DEVICE_CLASSES, lower=True)
 _SWITCH_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
-    .extend(zigbee.SWITCH_SCHEMA)
     .extend(
         {
             cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTSwitchComponent),
@@ -104,7 +103,6 @@ _SWITCH_SCHEMA = (
 
 
 _SWITCH_SCHEMA.add_extra(entity_duplicate_validator("switch"))
-_SWITCH_SCHEMA.add_extra(zigbee.validate_switch)
 
 
 def switch_schema(
@@ -167,7 +165,6 @@ async def setup_switch_core_(var, config):
         cg.add(var.set_device_class(device_class))
 
     cg.add(var.set_restore_mode(config[CONF_RESTORE_MODE]))
-    await zigbee.setup_switch(var, config)
 
 
 async def register_switch(var, config):

esphome/components/syslog/__init__.py

@@ -1,6 +1,6 @@
 import esphome.codegen as cg
 from esphome.components import udp
-from esphome.components.logger import LOG_LEVELS, is_log_level, request_log_listener
+from esphome.components.logger import LOG_LEVELS, is_log_level
 from esphome.components.time import RealTimeClock
 from esphome.components.udp import CONF_UDP_ID
 import esphome.config_validation as cv
@@ -36,7 +36,6 @@ async def to_code(config):
     level = LOG_LEVELS[config[CONF_LEVEL]]
     var = cg.new_Pvariable(config[CONF_ID], level, time)
     await cg.register_component(var, config)
-    request_log_listener()  # Request a log listener slot for syslog
     await cg.register_parented(var, parent)
     cg.add(var.set_strip(config[CONF_STRIP]))
     cg.add(var.set_facility(config[CONF_FACILITY]))

esphome/components/web_server/__init__.py

@@ -4,7 +4,6 @@ import gzip
 
 import esphome.codegen as cg
 from esphome.components import web_server_base
-from esphome.components.logger import request_log_listener
 from esphome.components.web_server_base import CONF_WEB_SERVER_BASE_ID
 import esphome.config_validation as cv
 from esphome.const import (
@@ -314,8 +313,6 @@ async def to_code(config):
     if config.get(CONF_OTA) is False:
         cg.add_define("USE_WEBSERVER_OTA_DISABLED")
     cg.add(var.set_expose_log(config[CONF_LOG]))
-    if config[CONF_LOG]:
-        request_log_listener()  # Request a log listener slot for web server log streaming
     if config[CONF_ENABLE_PRIVATE_NETWORK_ACCESS]:
         cg.add_define("USE_WEBSERVER_PRIVATE_NETWORK_ACCESS")
     if CONF_AUTH in config:

esphome/components/wifi/__init__.py

@@ -624,11 +624,7 @@ async def wifi_disable_to_code(config, action_id, template_arg, args):
 
 KEEP_SCAN_RESULTS_KEY = "wifi_keep_scan_results"
 RUNTIME_POWER_SAVE_KEY = "wifi_runtime_power_save"
-# Keys for listener counts
-IP_STATE_LISTENERS_KEY = "wifi_ip_state_listeners"
-SCAN_RESULTS_LISTENERS_KEY = "wifi_scan_results_listeners"
-CONNECT_STATE_LISTENERS_KEY = "wifi_connect_state_listeners"
-POWER_SAVE_LISTENERS_KEY = "wifi_power_save_listeners"
+WIFI_LISTENERS_KEY = "wifi_listeners"
 
 
 def request_wifi_scan_results():
@@ -654,28 +650,15 @@ def enable_runtime_power_save_control():
     CORE.data[RUNTIME_POWER_SAVE_KEY] = True
 
 
-def request_wifi_ip_state_listener() -> None:
-    """Request an IP state listener slot."""
-    CORE.data[IP_STATE_LISTENERS_KEY] = CORE.data.get(IP_STATE_LISTENERS_KEY, 0) + 1
+def request_wifi_listeners() -> None:
+    """Request that WiFi state listeners be compiled in.
 
-
-def request_wifi_scan_results_listener() -> None:
-    """Request a scan results listener slot."""
-    CORE.data[SCAN_RESULTS_LISTENERS_KEY] = (
-        CORE.data.get(SCAN_RESULTS_LISTENERS_KEY, 0) + 1
-    )
-
-
-def request_wifi_connect_state_listener() -> None:
-    """Request a connect state listener slot."""
-    CORE.data[CONNECT_STATE_LISTENERS_KEY] = (
-        CORE.data.get(CONNECT_STATE_LISTENERS_KEY, 0) + 1
-    )
-
-
-def request_wifi_power_save_listener() -> None:
-    """Request a power save listener slot."""
-    CORE.data[POWER_SAVE_LISTENERS_KEY] = CORE.data.get(POWER_SAVE_LISTENERS_KEY, 0) + 1
+    Components that need to be notified about WiFi state changes (IP address changes,
+    scan results, connection state) should call this function during their code generation.
+    This enables the add_ip_state_listener(), add_scan_results_listener(),
+    and add_connect_state_listener() APIs.
+    """
+    CORE.data[WIFI_LISTENERS_KEY] = True
 
 
 @coroutine_with_priority(CoroPriority.FINAL)
@@ -687,25 +670,8 @@ async def final_step():
         )
     if CORE.data.get(RUNTIME_POWER_SAVE_KEY, False):
         cg.add_define("USE_WIFI_RUNTIME_POWER_SAVE")
-
-    # Generate listener defines - each listener type has its own #ifdef
-    ip_state_count = CORE.data.get(IP_STATE_LISTENERS_KEY, 0)
-    scan_results_count = CORE.data.get(SCAN_RESULTS_LISTENERS_KEY, 0)
-    connect_state_count = CORE.data.get(CONNECT_STATE_LISTENERS_KEY, 0)
-    power_save_count = CORE.data.get(POWER_SAVE_LISTENERS_KEY, 0)
-
-    if ip_state_count:
-        cg.add_define("USE_WIFI_IP_STATE_LISTENERS")
-        cg.add_define("ESPHOME_WIFI_IP_STATE_LISTENERS", ip_state_count)
-    if scan_results_count:
-        cg.add_define("USE_WIFI_SCAN_RESULTS_LISTENERS")
-        cg.add_define("ESPHOME_WIFI_SCAN_RESULTS_LISTENERS", scan_results_count)
-    if connect_state_count:
-        cg.add_define("USE_WIFI_CONNECT_STATE_LISTENERS")
-        cg.add_define("ESPHOME_WIFI_CONNECT_STATE_LISTENERS", connect_state_count)
-    if power_save_count:
-        cg.add_define("USE_WIFI_POWER_SAVE_LISTENERS")
-        cg.add_define("ESPHOME_WIFI_POWER_SAVE_LISTENERS", power_save_count)
+    if CORE.data.get(WIFI_LISTENERS_KEY, False):
+        cg.add_define("USE_WIFI_LISTENERS")
 
 
 @automation.register_action(

esphome/components/wifi/wifi_component.h

@@ -275,9 +275,6 @@ struct LTWiFiEvent;
  *
  * Components can implement this interface to receive IP address updates
  * without the overhead of std::function callbacks.
- *
- * @note Components must call wifi.request_wifi_ip_state_listener() in their
- *       Python to_code() to register for this listener type.
  */
 class WiFiIPStateListener {
  public:
@@ -289,9 +286,6 @@ class WiFiIPStateListener {
  *
  * Components can implement this interface to receive scan results
  * without the overhead of std::function callbacks.
- *
- * @note Components must call wifi.request_wifi_scan_results_listener() in their
- *       Python to_code() to register for this listener type.
  */
 class WiFiScanResultsListener {
  public:
@@ -302,9 +296,6 @@ class WiFiScanResultsListener {
  *
  * Components can implement this interface to receive connection updates
  * without the overhead of std::function callbacks.
- *
- * @note Components must call wifi.request_wifi_connect_state_listener() in their
- *       Python to_code() to register for this listener type.
  */
 class WiFiConnectStateListener {
  public:
@@ -315,9 +306,6 @@ class WiFiConnectStateListener {
  *
  * Components can implement this interface to receive power save mode updates
  * without the overhead of std::function callbacks.
- *
- * @note Components must call wifi.request_wifi_power_save_listener() in their
- *       Python to_code() to register for this listener type.
  */
 class WiFiPowerSaveListener {
  public:
@@ -456,32 +444,26 @@ class WiFiComponent : public Component {
 
   int32_t get_wifi_channel();
 
-#ifdef USE_WIFI_IP_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
   /** Add a listener for IP state changes.
    * Listener receives: IP addresses, DNS address 1, DNS address 2
    */
   void add_ip_state_listener(WiFiIPStateListener *listener) { this->ip_state_listeners_.push_back(listener); }
-#endif  // USE_WIFI_IP_STATE_LISTENERS
-#ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
   /// Add a listener for WiFi scan results
   void add_scan_results_listener(WiFiScanResultsListener *listener) {
     this->scan_results_listeners_.push_back(listener);
   }
-#endif  // USE_WIFI_SCAN_RESULTS_LISTENERS
-#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
   /** Add a listener for WiFi connection state changes.
    * Listener receives: SSID, BSSID
    */
   void add_connect_state_listener(WiFiConnectStateListener *listener) {
     this->connect_state_listeners_.push_back(listener);
   }
-#endif  // USE_WIFI_CONNECT_STATE_LISTENERS
-#ifdef USE_WIFI_POWER_SAVE_LISTENERS
   /** Add a listener for WiFi power save mode changes.
    * Listener receives: WiFiPowerSaveMode
    */
   void add_power_save_listener(WiFiPowerSaveListener *listener) { this->power_save_listeners_.push_back(listener); }
-#endif  // USE_WIFI_POWER_SAVE_LISTENERS
+#endif  // USE_WIFI_LISTENERS
 
 #ifdef USE_WIFI_RUNTIME_POWER_SAVE
   /** Request high-performance mode (no power saving) for improved WiFi latency.
@@ -646,18 +628,12 @@ class WiFiComponent : public Component {
   WiFiAP ap_;
 #endif
   float output_power_{NAN};
-#ifdef USE_WIFI_IP_STATE_LISTENERS
-  StaticVector<WiFiIPStateListener *, ESPHOME_WIFI_IP_STATE_LISTENERS> ip_state_listeners_;
-#endif
-#ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
-  StaticVector<WiFiScanResultsListener *, ESPHOME_WIFI_SCAN_RESULTS_LISTENERS> scan_results_listeners_;
-#endif
-#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
-  StaticVector<WiFiConnectStateListener *, ESPHOME_WIFI_CONNECT_STATE_LISTENERS> connect_state_listeners_;
-#endif
-#ifdef USE_WIFI_POWER_SAVE_LISTENERS
-  StaticVector<WiFiPowerSaveListener *, ESPHOME_WIFI_POWER_SAVE_LISTENERS> power_save_listeners_;
-#endif
+#ifdef USE_WIFI_LISTENERS
+  std::vector<WiFiIPStateListener *> ip_state_listeners_;
+  std::vector<WiFiScanResultsListener *> scan_results_listeners_;
+  std::vector<WiFiConnectStateListener *> connect_state_listeners_;
+  std::vector<WiFiPowerSaveListener *> power_save_listeners_;
+#endif  // USE_WIFI_LISTENERS
   ESPPreferenceObject pref_;
 #ifdef USE_WIFI_FAST_CONNECT
   ESPPreferenceObject fast_connect_pref_;

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -105,7 +105,7 @@ bool WiFiComponent::wifi_apply_power_save_() {
   }
   wifi_fpm_auto_sleep_set_in_null_mode(1);
   bool success = wifi_set_sleep_type(power_save);
-#ifdef USE_WIFI_POWER_SAVE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
   if (success) {
     for (auto *listener : this->power_save_listeners_) {
       listener->on_wifi_power_save(this->power_save_);
@@ -511,13 +511,12 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
                it.channel);
 #endif
       s_sta_connected = true;
-#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
       for (auto *listener : global_wifi_component->connect_state_listeners_) {
         listener->on_wifi_connect_state(StringRef(it.ssid, it.ssid_len), it.bssid);
       }
-#endif
       // For static IP configurations, GOT_IP event may not fire, so notify IP listeners here
-#if defined(USE_WIFI_IP_STATE_LISTENERS) && defined(USE_WIFI_MANUAL_IP)
+#ifdef USE_WIFI_MANUAL_IP
       if (const WiFiAP *config = global_wifi_component->get_selected_sta_();
           config && config->get_manual_ip().has_value()) {
         for (auto *listener : global_wifi_component->ip_state_listeners_) {
@@ -525,6 +524,7 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
                                 global_wifi_component->get_dns_address(0), global_wifi_component->get_dns_address(1));
         }
       }
+#endif
 #endif
       break;
     }
@@ -543,12 +543,7 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
       }
       s_sta_connected = false;
       s_sta_connecting = false;
-      // IMPORTANT: Set error flag BEFORE notifying listeners.
-      // This ensures is_connected() returns false during listener callbacks,
-      // which is critical for proper reconnection logic (e.g., roaming).
-      global_wifi_component->error_from_callback_ = true;
-#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
-      // Notify listeners AFTER setting error flag so they see correct state
+#ifdef USE_WIFI_LISTENERS
       static constexpr uint8_t EMPTY_BSSID[6] = {};
       for (auto *listener : global_wifi_component->connect_state_listeners_) {
         listener->on_wifi_connect_state(StringRef(), EMPTY_BSSID);
@@ -578,7 +573,7 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
       ESP_LOGV(TAG, "static_ip=%s gateway=%s netmask=%s", network::IPAddress(&it.ip).str_to(ip_buf),
                network::IPAddress(&it.gw).str_to(gw_buf), network::IPAddress(&it.mask).str_to(mask_buf));
       s_sta_got_ip = true;
-#ifdef USE_WIFI_IP_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
       for (auto *listener : global_wifi_component->ip_state_listeners_) {
         listener->on_ip_state(global_wifi_component->wifi_sta_ip_addresses(), global_wifi_component->get_dns_address(0),
                               global_wifi_component->get_dns_address(1));
@@ -640,6 +635,10 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
       break;
   }
 
+  if (event->event == EVENT_STAMODE_DISCONNECTED) {
+    global_wifi_component->error_from_callback_ = true;
+  }
+
   WiFiMockClass::_event_callback(event);
 }
 
@@ -771,7 +770,7 @@ void WiFiComponent::wifi_scan_done_callback_(void *arg, STATUS status) {
         it->is_hidden != 0);
   }
   this->scan_done_ = true;
-#ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
+#ifdef USE_WIFI_LISTENERS
   for (auto *listener : global_wifi_component->scan_results_listeners_) {
     listener->on_wifi_scan_results(global_wifi_component->scan_result_);
   }

esphome/components/wifi/wifi_component_esp_idf.cpp

@@ -281,7 +281,7 @@ bool WiFiComponent::wifi_apply_power_save_() {
       break;
   }
   bool success = esp_wifi_set_ps(power_save) == ESP_OK;
-#ifdef USE_WIFI_POWER_SAVE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
   if (success) {
     for (auto *listener : this->power_save_listeners_) {
       listener->on_wifi_power_save(this->power_save_);
@@ -741,18 +741,18 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
              (const char *) it.ssid, bssid_buf, it.channel, get_auth_mode_str(it.authmode));
 #endif
     s_sta_connected = true;
-#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
     for (auto *listener : this->connect_state_listeners_) {
       listener->on_wifi_connect_state(StringRef(it.ssid, it.ssid_len), it.bssid);
     }
-#endif
     // For static IP configurations, GOT_IP event may not fire, so notify IP listeners here
-#if defined(USE_WIFI_IP_STATE_LISTENERS) && defined(USE_WIFI_MANUAL_IP)
+#ifdef USE_WIFI_MANUAL_IP
     if (const WiFiAP *config = this->get_selected_sta_(); config && config->get_manual_ip().has_value()) {
       for (auto *listener : this->ip_state_listeners_) {
         listener->on_ip_state(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
       }
     }
+#endif
 #endif
 
   } else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_STA_DISCONNECTED) {
@@ -774,7 +774,7 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
     s_sta_connected = false;
     s_sta_connecting = false;
     error_from_callback_ = true;
-#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
     static constexpr uint8_t EMPTY_BSSID[6] = {};
     for (auto *listener : this->connect_state_listeners_) {
       listener->on_wifi_connect_state(StringRef(), EMPTY_BSSID);
@@ -788,7 +788,7 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
 #endif /* USE_NETWORK_IPV6 */
     ESP_LOGV(TAG, "static_ip=" IPSTR " gateway=" IPSTR, IP2STR(&it.ip_info.ip), IP2STR(&it.ip_info.gw));
     this->got_ipv4_address_ = true;
-#ifdef USE_WIFI_IP_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
     for (auto *listener : this->ip_state_listeners_) {
       listener->on_ip_state(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
     }
@@ -799,7 +799,7 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
     const auto &it = data->data.ip_got_ip6;
     ESP_LOGV(TAG, "IPv6 address=" IPV6STR, IPV62STR(it.ip6_info.ip));
     this->num_ipv6_addresses_++;
-#ifdef USE_WIFI_IP_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
     for (auto *listener : this->ip_state_listeners_) {
       listener->on_ip_state(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
     }
@@ -843,7 +843,7 @@ void WiFiComponent::wifi_process_event_(IDFWiFiEvent *data) {
       scan_result_.emplace_back(bssid, ssid, record.primary, record.rssi, record.authmode != WIFI_AUTH_OPEN,
                                 ssid.empty());
     }
-#ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
+#ifdef USE_WIFI_LISTENERS
     for (auto *listener : this->scan_results_listeners_) {
       listener->on_wifi_scan_results(this->scan_result_);
     }

esphome/components/wifi/wifi_component_libretiny.cpp

@@ -144,7 +144,7 @@ bool WiFiComponent::wifi_sta_pre_setup_() {
 }
 bool WiFiComponent::wifi_apply_power_save_() {
   bool success = WiFi.setSleep(this->power_save_ != WIFI_POWER_SAVE_NONE);
-#ifdef USE_WIFI_POWER_SAVE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
   if (success) {
     for (auto *listener : this->power_save_listeners_) {
       listener->on_wifi_power_save(this->power_save_);
@@ -455,19 +455,19 @@ void WiFiComponent::wifi_process_event_(LTWiFiEvent *event) {
       // Note: We don't set CONNECTED state here yet - wait for GOT_IP
       // This matches ESP32 IDF behavior where s_sta_connected is set but
       // wifi_sta_connect_status_() also checks got_ipv4_address_
-#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
       for (auto *listener : this->connect_state_listeners_) {
         listener->on_wifi_connect_state(StringRef(it.ssid, it.ssid_len), it.bssid);
       }
-#endif
       // For static IP configurations, GOT_IP event may not fire, so notify IP listeners here
-#if defined(USE_WIFI_IP_STATE_LISTENERS) && defined(USE_WIFI_MANUAL_IP)
+#ifdef USE_WIFI_MANUAL_IP
       if (const WiFiAP *config = this->get_selected_sta_(); config && config->get_manual_ip().has_value()) {
         s_sta_state = LTWiFiSTAState::CONNECTED;
         for (auto *listener : this->ip_state_listeners_) {
           listener->on_ip_state(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
         }
       }
+#endif
 #endif
       break;
     }
@@ -521,7 +521,7 @@ void WiFiComponent::wifi_process_event_(LTWiFiEvent *event) {
         this->error_from_callback_ = true;
       }
 
-#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
       static constexpr uint8_t EMPTY_BSSID[6] = {};
       for (auto *listener : this->connect_state_listeners_) {
         listener->on_wifi_connect_state(StringRef(), EMPTY_BSSID);
@@ -547,7 +547,7 @@ void WiFiComponent::wifi_process_event_(LTWiFiEvent *event) {
       ESP_LOGV(TAG, "static_ip=%s gateway=%s", network::IPAddress(WiFi.localIP()).str_to(ip_buf),
                network::IPAddress(WiFi.gatewayIP()).str_to(gw_buf));
       s_sta_state = LTWiFiSTAState::CONNECTED;
-#ifdef USE_WIFI_IP_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
       for (auto *listener : this->ip_state_listeners_) {
         listener->on_ip_state(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
       }
@@ -556,7 +556,7 @@ void WiFiComponent::wifi_process_event_(LTWiFiEvent *event) {
     }
     case ESPHOME_EVENT_ID_WIFI_STA_GOT_IP6: {
       ESP_LOGV(TAG, "Got IPv6");
-#ifdef USE_WIFI_IP_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
       for (auto *listener : this->ip_state_listeners_) {
         listener->on_ip_state(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
       }
@@ -677,7 +677,7 @@ void WiFiComponent::wifi_scan_done_callback_() {
                                     ssid.length() == 0);
   }
   WiFi.scanDelete();
-#ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
+#ifdef USE_WIFI_LISTENERS
   for (auto *listener : this->scan_results_listeners_) {
     listener->on_wifi_scan_results(this->scan_result_);
   }

esphome/components/wifi/wifi_component_pico_w.cpp

@@ -55,7 +55,7 @@ bool WiFiComponent::wifi_apply_power_save_() {
   }
   int ret = cyw43_wifi_pm(&cyw43_state, pm);
   bool success = ret == 0;
-#ifdef USE_WIFI_POWER_SAVE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
   if (success) {
     for (auto *listener : this->power_save_listeners_) {
       listener->on_wifi_power_save(this->power_save_);
@@ -245,7 +245,7 @@ void WiFiComponent::wifi_loop_() {
   if (this->state_ == WIFI_COMPONENT_STATE_STA_SCANNING && !cyw43_wifi_scan_active(&cyw43_state)) {
     this->scan_done_ = true;
     ESP_LOGV(TAG, "Scan done");
-#ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
+#ifdef USE_WIFI_LISTENERS
     for (auto *listener : this->scan_results_listeners_) {
       listener->on_wifi_scan_results(this->scan_result_);
     }
@@ -263,28 +263,28 @@ void WiFiComponent::wifi_loop_() {
     // Just connected
     s_sta_was_connected = true;
     ESP_LOGV(TAG, "Connected");
-#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
     String ssid = WiFi.SSID();
     bssid_t bssid = this->wifi_bssid();
     for (auto *listener : this->connect_state_listeners_) {
       listener->on_wifi_connect_state(StringRef(ssid.c_str(), ssid.length()), bssid);
     }
-#endif
     // For static IP configurations, notify IP listeners immediately as the IP is already configured
-#if defined(USE_WIFI_IP_STATE_LISTENERS) && defined(USE_WIFI_MANUAL_IP)
+#ifdef USE_WIFI_MANUAL_IP
     if (const WiFiAP *config = this->get_selected_sta_(); config && config->get_manual_ip().has_value()) {
       s_sta_had_ip = true;
       for (auto *listener : this->ip_state_listeners_) {
         listener->on_ip_state(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
       }
     }
+#endif
 #endif
   } else if (!is_connected && s_sta_was_connected) {
     // Just disconnected
     s_sta_was_connected = false;
     s_sta_had_ip = false;
     ESP_LOGV(TAG, "Disconnected");
-#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
     static constexpr uint8_t EMPTY_BSSID[6] = {};
     for (auto *listener : this->connect_state_listeners_) {
       listener->on_wifi_connect_state(StringRef(), EMPTY_BSSID);
@@ -305,7 +305,7 @@ void WiFiComponent::wifi_loop_() {
       // Just got IP address
       s_sta_had_ip = true;
       ESP_LOGV(TAG, "Got IP address");
-#ifdef USE_WIFI_IP_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
       for (auto *listener : this->ip_state_listeners_) {
         listener->on_ip_state(this->wifi_sta_ip_addresses(), this->get_dns_address(0), this->get_dns_address(1));
       }

esphome/components/wifi_info/text_sensor.py

@@ -69,6 +69,16 @@ CONFIG_SCHEMA = cv.Schema(
     }
 )
 
+# Keys that require WiFi listeners
+_NETWORK_INFO_KEYS = {
+    CONF_SSID,
+    CONF_BSSID,
+    CONF_IP_ADDRESS,
+    CONF_DNS_ADDRESS,
+    CONF_SCAN_RESULTS,
+    CONF_POWER_SAVE_MODE,
+}
+
 
 async def setup_conf(config, key):
     if key in config:
@@ -78,28 +88,16 @@ async def setup_conf(config, key):
 
 
 async def to_code(config):
-    # Request specific WiFi listeners based on which sensors are configured
-    # SSID and BSSID use WiFiConnectStateListener
-    if CONF_SSID in config or CONF_BSSID in config:
-        wifi.request_wifi_connect_state_listener()
-
-    # IP address and DNS use WiFiIPStateListener
-    if CONF_IP_ADDRESS in config or CONF_DNS_ADDRESS in config:
-        wifi.request_wifi_ip_state_listener()
-
-    # Scan results use WiFiScanResultsListener
-    if CONF_SCAN_RESULTS in config:
-        wifi.request_wifi_scan_results_listener()
-        wifi.request_wifi_scan_results()
-
-    # Power save mode uses WiFiPowerSaveListener
-    if CONF_POWER_SAVE_MODE in config:
-        wifi.request_wifi_power_save_listener()
+    # Request WiFi listeners for any sensor that needs them
+    if _NETWORK_INFO_KEYS.intersection(config):
+        wifi.request_wifi_listeners()
 
     await setup_conf(config, CONF_SSID)
     await setup_conf(config, CONF_BSSID)
     await setup_conf(config, CONF_MAC_ADDRESS)
-    await setup_conf(config, CONF_SCAN_RESULTS)
+    if CONF_SCAN_RESULTS in config:
+        await setup_conf(config, CONF_SCAN_RESULTS)
+        wifi.request_wifi_scan_results()
     await setup_conf(config, CONF_DNS_ADDRESS)
     await setup_conf(config, CONF_POWER_SAVE_MODE)
     if conf := config.get(CONF_IP_ADDRESS):

esphome/components/wifi_info/wifi_info_text_sensor.cpp

@@ -10,7 +10,9 @@ namespace esphome::wifi_info {
 
 static const char *const TAG = "wifi_info";
 
-#ifdef USE_WIFI_IP_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
+
+static constexpr size_t MAX_STATE_LENGTH = 255;
 
 /********************
  * IPAddressWiFiInfo
@@ -56,10 +58,6 @@ void DNSAddressWifiInfo::on_ip_state(const network::IPAddresses &ips, const netw
   this->publish_state(buf);
 }
 
-#endif  // USE_WIFI_IP_STATE_LISTENERS
-
-#ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
-
 /**********************
  * ScanResultsWiFiInfo
  *********************/
@@ -82,9 +80,9 @@ static char *format_scan_entry(char *buf, const char *ssid, size_t ssid_len, int
 }
 
 void ScanResultsWiFiInfo::on_wifi_scan_results(const wifi::wifi_scan_vector_t<wifi::WiFiScanResult> &results) {
-  char buf[MAX_STATE_LEN + 1];
+  char buf[MAX_STATE_LENGTH + 1];
   char *ptr = buf;
-  const char *end = buf + MAX_STATE_LEN;
+  const char *end = buf + MAX_STATE_LENGTH;
 
   for (const auto &scan : results) {
     if (scan.get_is_hidden())
@@ -100,10 +98,6 @@ void ScanResultsWiFiInfo::on_wifi_scan_results(const wifi::wifi_scan_vector_t<wi
   this->publish_state(buf);
 }
 
-#endif  // USE_WIFI_SCAN_RESULTS_LISTENERS
-
-#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
-
 /***************
  * SSIDWiFiInfo
  **************/
@@ -132,10 +126,6 @@ void BSSIDWiFiInfo::on_wifi_connect_state(StringRef ssid, std::span<const uint8_
   this->publish_state(buf);
 }
 
-#endif  // USE_WIFI_CONNECT_STATE_LISTENERS
-
-#ifdef USE_WIFI_POWER_SAVE_LISTENERS
-
 /************************
  * PowerSaveModeWiFiInfo
  ***********************/
@@ -192,7 +182,7 @@ void PowerSaveModeWiFiInfo::on_wifi_power_save(wifi::WiFiPowerSaveMode mode) {
   this->publish_state(mode_str);
 }
 
-#endif  // USE_WIFI_POWER_SAVE_LISTENERS
+#endif
 
 /*********************
  * MacAddressWifiInfo

esphome/components/wifi_info/wifi_info_text_sensor.h

@@ -11,7 +11,7 @@
 
 namespace esphome::wifi_info {
 
-#ifdef USE_WIFI_IP_STATE_LISTENERS
+#ifdef USE_WIFI_LISTENERS
 class IPAddressWiFiInfo final : public Component, public text_sensor::TextSensor, public wifi::WiFiIPStateListener {
  public:
   void setup() override;
@@ -35,9 +35,7 @@ class DNSAddressWifiInfo final : public Component, public text_sensor::TextSenso
   void on_ip_state(const network::IPAddresses &ips, const network::IPAddress &dns1,
                    const network::IPAddress &dns2) override;
 };
-#endif  // USE_WIFI_IP_STATE_LISTENERS
 
-#ifdef USE_WIFI_SCAN_RESULTS_LISTENERS
 class ScanResultsWiFiInfo final : public Component,
                                   public text_sensor::TextSensor,
                                   public wifi::WiFiScanResultsListener {
@@ -49,9 +47,7 @@ class ScanResultsWiFiInfo final : public Component,
   // WiFiScanResultsListener interface
   void on_wifi_scan_results(const wifi::wifi_scan_vector_t<wifi::WiFiScanResult> &results) override;
 };
-#endif  // USE_WIFI_SCAN_RESULTS_LISTENERS
 
-#ifdef USE_WIFI_CONNECT_STATE_LISTENERS
 class SSIDWiFiInfo final : public Component, public text_sensor::TextSensor, public wifi::WiFiConnectStateListener {
  public:
   void setup() override;
@@ -69,9 +65,7 @@ class BSSIDWiFiInfo final : public Component, public text_sensor::TextSensor, pu
   // WiFiConnectStateListener interface
   void on_wifi_connect_state(StringRef ssid, std::span<const uint8_t, 6> bssid) override;
 };
-#endif  // USE_WIFI_CONNECT_STATE_LISTENERS
 
-#ifdef USE_WIFI_POWER_SAVE_LISTENERS
 class PowerSaveModeWiFiInfo final : public Component,
                                     public text_sensor::TextSensor,
                                     public wifi::WiFiPowerSaveListener {
@@ -82,7 +76,7 @@ class PowerSaveModeWiFiInfo final : public Component,
   // WiFiPowerSaveListener interface
   void on_wifi_power_save(wifi::WiFiPowerSaveMode mode) override;
 };
-#endif  // USE_WIFI_POWER_SAVE_LISTENERS
+#endif
 
 class MacAddressWifiInfo final : public Component, public text_sensor::TextSensor {
  public: