Merge branch 'ble_events' into ble_events_loop_runtime_stats

Co-authored-by: J. Nick Koston <nick@koston.org>

CODEOWNERS

@@ -150,6 +150,7 @@ esphome/components/esp32_improv/* @jesserockz
 esphome/components/esp32_rmt/* @jesserockz
 esphome/components/esp32_rmt_led_strip/* @jesserockz
 esphome/components/esp8266/* @esphome/core
+esphome/components/esp_ldo/* @clydebarrow
 esphome/components/ethernet_info/* @gtjadsonsantos
 esphome/components/event/* @nohat
 esphome/components/event_emitter/* @Rapsssito
@@ -321,6 +322,7 @@ esphome/components/number/* @esphome/core
 esphome/components/one_wire/* @ssieb
 esphome/components/online_image/* @clydebarrow @guillempages
 esphome/components/opentherm/* @olegtarasov
+esphome/components/openthread/* @mrene
 esphome/components/ota/* @esphome/core
 esphome/components/output/* @esphome/core
 esphome/components/packet_transport/* @clydebarrow

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2025.6.0-dev
+PROJECT_NUMBER         = 2025.7.0-dev
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

esphome/__main__.py

@@ -134,6 +134,7 @@ def get_port_type(port):
 
 
 def run_miniterm(config, port, args):
+    from aioesphomeapi import LogParser
     import serial
 
     from esphome import platformio_api
@@ -158,6 +159,7 @@ def run_miniterm(config, port, args):
         ser.dtr = False
         ser.rts = False
 
+    parser = LogParser()
     tries = 0
     while tries < 5:
         try:
@@ -174,8 +176,7 @@ def run_miniterm(config, port, args):
                         .decode("utf8", "backslashreplace")
                     )
                     time_str = datetime.now().time().strftime("[%H:%M:%S]")
-                    message = time_str + line
-                    safe_print(message)
+                    safe_print(parser.parse_line(line, time_str))
 
                     backtrace_state = platformio_api.process_stacktrace(
                         config, line, backtrace_state=backtrace_state

esphome/components/absolute_humidity/absolute_humidity.cpp

@@ -40,9 +40,11 @@ void AbsoluteHumidityComponent::dump_config() {
       break;
   }
 
-  ESP_LOGCONFIG(TAG, "Sources");
-  ESP_LOGCONFIG(TAG, "  Temperature: '%s'", this->temperature_sensor_->get_name().c_str());
-  ESP_LOGCONFIG(TAG, "  Relative Humidity: '%s'", this->humidity_sensor_->get_name().c_str());
+  ESP_LOGCONFIG(TAG,
+                "Sources\n"
+                "  Temperature: '%s'\n"
+                "  Relative Humidity: '%s'",
+                this->temperature_sensor_->get_name().c_str(), this->humidity_sensor_->get_name().c_str());
 }
 
 float AbsoluteHumidityComponent::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/ac_dimmer/ac_dimmer.cpp

@@ -214,8 +214,10 @@ void AcDimmer::dump_config() {
   ESP_LOGCONFIG(TAG, "AcDimmer:");
   LOG_PIN("  Output Pin: ", this->gate_pin_);
   LOG_PIN("  Zero-Cross Pin: ", this->zero_cross_pin_);
-  ESP_LOGCONFIG(TAG, "   Min Power: %.1f%%", this->store_.min_power / 10.0f);
-  ESP_LOGCONFIG(TAG, "   Init with half cycle: %s", YESNO(this->init_with_half_cycle_));
+  ESP_LOGCONFIG(TAG,
+                "   Min Power: %.1f%%\n"
+                "   Init with half cycle: %s",
+                this->store_.min_power / 10.0f, YESNO(this->init_with_half_cycle_));
   if (method_ == DIM_METHOD_LEADING_PULSE) {
     ESP_LOGCONFIG(TAG, "   Method: leading pulse");
   } else if (method_ == DIM_METHOD_LEADING) {

esphome/components/adc/adc_sensor_esp32.cpp

@@ -77,8 +77,10 @@ void ADCSensor::dump_config() {
         break;
     }
   }
-  ESP_LOGCONFIG(TAG, "  Samples: %i", this->sample_count_);
-  ESP_LOGCONFIG(TAG, "  Sampling mode: %s", LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
+  ESP_LOGCONFIG(TAG,
+                "  Samples: %i\n"
+                "  Sampling mode: %s",
+                this->sample_count_, LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/adc/adc_sensor_esp8266.cpp

@@ -30,8 +30,10 @@ void ADCSensor::dump_config() {
 #else
   LOG_PIN("  Pin: ", this->pin_);
 #endif  // USE_ADC_SENSOR_VCC
-  ESP_LOGCONFIG(TAG, "  Samples: %i", this->sample_count_);
-  ESP_LOGCONFIG(TAG, "  Sampling mode: %s", LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
+  ESP_LOGCONFIG(TAG,
+                "  Samples: %i\n"
+                "  Sampling mode: %s",
+                this->sample_count_, LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/adc/adc_sensor_libretiny.cpp

@@ -22,8 +22,10 @@ void ADCSensor::dump_config() {
 #else   // USE_ADC_SENSOR_VCC
   LOG_PIN("  Pin: ", this->pin_);
 #endif  // USE_ADC_SENSOR_VCC
-  ESP_LOGCONFIG(TAG, "  Samples: %i", this->sample_count_);
-  ESP_LOGCONFIG(TAG, "  Sampling mode: %s", LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
+  ESP_LOGCONFIG(TAG,
+                "  Samples: %i\n"
+                "  Sampling mode: %s",
+                this->sample_count_, LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/adc/adc_sensor_rp2040.cpp

@@ -33,8 +33,10 @@ void ADCSensor::dump_config() {
     LOG_PIN("  Pin: ", this->pin_);
 #endif  // USE_ADC_SENSOR_VCC
   }
-  ESP_LOGCONFIG(TAG, "  Samples: %i", this->sample_count_);
-  ESP_LOGCONFIG(TAG, "  Sampling mode: %s", LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
+  ESP_LOGCONFIG(TAG,
+                "  Samples: %i\n"
+                "  Sampling mode: %s",
+                this->sample_count_, LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/ade7880/ade7880.cpp

@@ -177,11 +177,14 @@ void ADE7880::dump_config() {
     LOG_SENSOR("    ", "Power Factor", this->channel_a_->power_factor);
     LOG_SENSOR("    ", "Forward Active Energy", this->channel_a_->forward_active_energy);
     LOG_SENSOR("    ", "Reverse Active Energy", this->channel_a_->reverse_active_energy);
-    ESP_LOGCONFIG(TAG, "    Calibration:");
-    ESP_LOGCONFIG(TAG, "     Current: %" PRId32, this->channel_a_->current_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Voltage: %" PRId32, this->channel_a_->voltage_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Power: %" PRId32, this->channel_a_->power_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Phase Angle: %u", this->channel_a_->phase_angle_calibration);
+    ESP_LOGCONFIG(TAG,
+                  "    Calibration:\n"
+                  "     Current: %" PRId32 "\n"
+                  "     Voltage: %" PRId32 "\n"
+                  "     Power: %" PRId32 "\n"
+                  "     Phase Angle: %u",
+                  this->channel_a_->current_gain_calibration, this->channel_a_->voltage_gain_calibration,
+                  this->channel_a_->power_gain_calibration, this->channel_a_->phase_angle_calibration);
   }
 
   if (this->channel_b_ != nullptr) {
@@ -193,11 +196,14 @@ void ADE7880::dump_config() {
     LOG_SENSOR("    ", "Power Factor", this->channel_b_->power_factor);
     LOG_SENSOR("    ", "Forward Active Energy", this->channel_b_->forward_active_energy);
     LOG_SENSOR("    ", "Reverse Active Energy", this->channel_b_->reverse_active_energy);
-    ESP_LOGCONFIG(TAG, "    Calibration:");
-    ESP_LOGCONFIG(TAG, "     Current: %" PRId32, this->channel_b_->current_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Voltage: %" PRId32, this->channel_b_->voltage_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Power: %" PRId32, this->channel_b_->power_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Phase Angle: %u", this->channel_b_->phase_angle_calibration);
+    ESP_LOGCONFIG(TAG,
+                  "    Calibration:\n"
+                  "     Current: %" PRId32 "\n"
+                  "     Voltage: %" PRId32 "\n"
+                  "     Power: %" PRId32 "\n"
+                  "     Phase Angle: %u",
+                  this->channel_b_->current_gain_calibration, this->channel_b_->voltage_gain_calibration,
+                  this->channel_b_->power_gain_calibration, this->channel_b_->phase_angle_calibration);
   }
 
   if (this->channel_c_ != nullptr) {
@@ -209,18 +215,23 @@ void ADE7880::dump_config() {
     LOG_SENSOR("    ", "Power Factor", this->channel_c_->power_factor);
     LOG_SENSOR("    ", "Forward Active Energy", this->channel_c_->forward_active_energy);
     LOG_SENSOR("    ", "Reverse Active Energy", this->channel_c_->reverse_active_energy);
-    ESP_LOGCONFIG(TAG, "    Calibration:");
-    ESP_LOGCONFIG(TAG, "     Current: %" PRId32, this->channel_c_->current_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Voltage: %" PRId32, this->channel_c_->voltage_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Power: %" PRId32, this->channel_c_->power_gain_calibration);
-    ESP_LOGCONFIG(TAG, "     Phase Angle: %u", this->channel_c_->phase_angle_calibration);
+    ESP_LOGCONFIG(TAG,
+                  "    Calibration:\n"
+                  "     Current: %" PRId32 "\n"
+                  "     Voltage: %" PRId32 "\n"
+                  "     Power: %" PRId32 "\n"
+                  "     Phase Angle: %u",
+                  this->channel_c_->current_gain_calibration, this->channel_c_->voltage_gain_calibration,
+                  this->channel_c_->power_gain_calibration, this->channel_c_->phase_angle_calibration);
   }
 
   if (this->channel_n_ != nullptr) {
     ESP_LOGCONFIG(TAG, "  Neutral:");
     LOG_SENSOR("    ", "Current", this->channel_n_->current);
-    ESP_LOGCONFIG(TAG, "    Calibration:");
-    ESP_LOGCONFIG(TAG, "     Current: %" PRId32, this->channel_n_->current_gain_calibration);
+    ESP_LOGCONFIG(TAG,
+                  "    Calibration:\n"
+                  "     Current: %" PRId32,
+                  this->channel_n_->current_gain_calibration);
   }
 
   LOG_I2C_DEVICE(this);

esphome/components/ade7953_base/ade7953_base.cpp

@@ -58,15 +58,18 @@ void ADE7953::dump_config() {
   LOG_SENSOR("  ", "Active Power B Sensor", this->active_power_b_sensor_);
   LOG_SENSOR("  ", "Rective Power A Sensor", this->reactive_power_a_sensor_);
   LOG_SENSOR("  ", "Reactive Power B Sensor", this->reactive_power_b_sensor_);
-  ESP_LOGCONFIG(TAG, "  USE_ACC_ENERGY_REGS: %d", this->use_acc_energy_regs_);
-  ESP_LOGCONFIG(TAG, "  PGA_V_8: 0x%X", pga_v_);
-  ESP_LOGCONFIG(TAG, "  PGA_IA_8: 0x%X", pga_ia_);
-  ESP_LOGCONFIG(TAG, "  PGA_IB_8: 0x%X", pga_ib_);
-  ESP_LOGCONFIG(TAG, "  VGAIN_32: 0x%08jX", (uintmax_t) vgain_);
-  ESP_LOGCONFIG(TAG, "  AIGAIN_32: 0x%08jX", (uintmax_t) aigain_);
-  ESP_LOGCONFIG(TAG, "  BIGAIN_32: 0x%08jX", (uintmax_t) bigain_);
-  ESP_LOGCONFIG(TAG, "  AWGAIN_32: 0x%08jX", (uintmax_t) awgain_);
-  ESP_LOGCONFIG(TAG, "  BWGAIN_32: 0x%08jX", (uintmax_t) bwgain_);
+  ESP_LOGCONFIG(TAG,
+                "  USE_ACC_ENERGY_REGS: %d\n"
+                "  PGA_V_8: 0x%X\n"
+                "  PGA_IA_8: 0x%X\n"
+                "  PGA_IB_8: 0x%X\n"
+                "  VGAIN_32: 0x%08jX\n"
+                "  AIGAIN_32: 0x%08jX\n"
+                "  BIGAIN_32: 0x%08jX\n"
+                "  AWGAIN_32: 0x%08jX\n"
+                "  BWGAIN_32: 0x%08jX",
+                this->use_acc_energy_regs_, pga_v_, pga_ia_, pga_ib_, (uintmax_t) vgain_, (uintmax_t) aigain_,
+                (uintmax_t) bigain_, (uintmax_t) awgain_, (uintmax_t) bwgain_);
 }
 
 #define ADE_PUBLISH_(name, val, factor) \

esphome/components/ade7953_i2c/ade7953_i2c.cpp

@@ -1,6 +1,6 @@
 #include "ade7953_i2c.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace ade7953_i2c {

esphome/components/ade7953_spi/ade7953_spi.cpp

@@ -1,6 +1,6 @@
 #include "ade7953_spi.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace ade7953_spi {

esphome/components/ads1118/ads1118.cpp

@@ -1,4 +1,5 @@
 #include "ads1118.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {

esphome/components/ags10/ags10.cpp

@@ -1,4 +1,5 @@
 #include "ags10.h"
+#include "esphome/core/helpers.h"
 
 #include <cinttypes>
 

esphome/components/aht10/aht10.cpp

@@ -13,9 +13,9 @@
 // results making successive requests; the current implementation makes 3 attempts with a delay of 30ms each time.
 
 #include "aht10.h"
-#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace aht10 {

esphome/components/alarm_control_panel/__init__.py

@@ -235,6 +235,7 @@ async def register_alarm_control_panel(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_alarm_control_panel(var))
+    CORE.register_platform_component("alarm_control_panel", var)
     await setup_alarm_control_panel_core_(var, config)
 
 

esphome/components/am43/am43_base.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace am43 {

esphome/components/am43/cover/am43_cover.cpp

@@ -12,8 +12,10 @@ using namespace esphome::cover;
 
 void Am43Component::dump_config() {
   LOG_COVER("", "AM43 Cover", this);
-  ESP_LOGCONFIG(TAG, "  Device Pin: %d", this->pin_);
-  ESP_LOGCONFIG(TAG, "  Invert Position: %d", (int) this->invert_position_);
+  ESP_LOGCONFIG(TAG,
+                "  Device Pin: %d\n"
+                "  Invert Position: %d",
+                this->pin_, (int) this->invert_position_);
 }
 
 void Am43Component::setup() {

esphome/components/analog_threshold/analog_threshold_binary_sensor.cpp

@@ -34,8 +34,10 @@ void AnalogThresholdBinarySensor::set_sensor(sensor::Sensor *analog_sensor) {
 void AnalogThresholdBinarySensor::dump_config() {
   LOG_BINARY_SENSOR("", "Analog Threshold Binary Sensor", this);
   LOG_SENSOR("  ", "Sensor", this->sensor_);
-  ESP_LOGCONFIG(TAG, "  Upper threshold: %.11f", this->upper_threshold_.value());
-  ESP_LOGCONFIG(TAG, "  Lower threshold: %.11f", this->lower_threshold_.value());
+  ESP_LOGCONFIG(TAG,
+                "  Upper threshold: %.11f\n"
+                "  Lower threshold: %.11f",
+                this->upper_threshold_.value(), this->lower_threshold_.value());
 }
 
 }  // namespace analog_threshold

esphome/components/apds9306/apds9306.cpp

@@ -108,9 +108,12 @@ void APDS9306::dump_config() {
     }
   }
 
-  ESP_LOGCONFIG(TAG, "  Gain: %u", AMBIENT_LIGHT_GAIN_VALUES[this->gain_]);
-  ESP_LOGCONFIG(TAG, "  Measurement rate: %u", MEASUREMENT_RATE_VALUES[this->measurement_rate_]);
-  ESP_LOGCONFIG(TAG, "  Measurement Resolution/Bit width: %d", MEASUREMENT_BIT_WIDTH_VALUES[this->bit_width_]);
+  ESP_LOGCONFIG(TAG,
+                "  Gain: %u\n"
+                "  Measurement rate: %u\n"
+                "  Measurement Resolution/Bit width: %d",
+                AMBIENT_LIGHT_GAIN_VALUES[this->gain_], MEASUREMENT_RATE_VALUES[this->measurement_rate_],
+                MEASUREMENT_BIT_WIDTH_VALUES[this->bit_width_]);
 
   LOG_UPDATE_INTERVAL(this);
 }

esphome/components/api/api_connection.cpp

@@ -239,7 +239,8 @@ DisconnectResponse APIConnection::disconnect(const DisconnectRequest &msg) {
   return resp;
 }
 void APIConnection::on_disconnect_response(const DisconnectResponse &value) {
-  // pass
+  this->helper_->close();
+  this->remove_ = true;
 }
 
 // Encodes a message to the buffer and returns the total number of bytes used,
@@ -269,10 +270,6 @@ uint16_t APIConnection::encode_message_to_buffer(ProtoMessage &msg, uint16_t mes
 }
 
 #ifdef USE_BINARY_SENSOR
-bool APIConnection::send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor, bool state) {
-  return this->schedule_message_(binary_sensor, MessageCreator(state, BinarySensorStateResponse::MESSAGE_TYPE),
-                                 BinarySensorStateResponse::MESSAGE_TYPE);
-}
 bool APIConnection::send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor) {
   return this->schedule_message_(binary_sensor, &APIConnection::try_send_binary_sensor_state,
                                  BinarySensorStateResponse::MESSAGE_TYPE);
@@ -281,20 +278,15 @@ void APIConnection::send_binary_sensor_info(binary_sensor::BinarySensor *binary_
   this->schedule_message_(binary_sensor, &APIConnection::try_send_binary_sensor_info,
                           ListEntitiesBinarySensorResponse::MESSAGE_TYPE);
 }
-uint16_t APIConnection::try_send_binary_sensor_state_response(binary_sensor::BinarySensor *binary_sensor, bool state,
-                                                              APIConnection *conn, uint32_t remaining_size,
-                                                              bool is_single) {
-  BinarySensorStateResponse resp;
-  resp.state = state;
-  resp.missing_state = !binary_sensor->has_state();
-  resp.key = binary_sensor->get_object_id_hash();
-  return encode_message_to_buffer(resp, BinarySensorStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
-}
 
 uint16_t APIConnection::try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                      bool is_single) {
   auto *binary_sensor = static_cast<binary_sensor::BinarySensor *>(entity);
-  return try_send_binary_sensor_state_response(binary_sensor, binary_sensor->state, conn, remaining_size, is_single);
+  BinarySensorStateResponse resp;
+  resp.state = binary_sensor->state;
+  resp.missing_state = !binary_sensor->has_state();
+  resp.key = binary_sensor->get_object_id_hash();
+  return encode_message_to_buffer(resp, BinarySensorStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_binary_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -531,29 +523,21 @@ void APIConnection::light_command(const LightCommandRequest &msg) {
 #endif
 
 #ifdef USE_SENSOR
-bool APIConnection::send_sensor_state(sensor::Sensor *sensor, float state) {
-  return this->schedule_message_(sensor, MessageCreator(state, SensorStateResponse::MESSAGE_TYPE),
-                                 SensorStateResponse::MESSAGE_TYPE);
-}
 bool APIConnection::send_sensor_state(sensor::Sensor *sensor) {
   return this->schedule_message_(sensor, &APIConnection::try_send_sensor_state, SensorStateResponse::MESSAGE_TYPE);
 }
 void APIConnection::send_sensor_info(sensor::Sensor *sensor) {
   this->schedule_message_(sensor, &APIConnection::try_send_sensor_info, ListEntitiesSensorResponse::MESSAGE_TYPE);
 }
-uint16_t APIConnection::try_send_sensor_state_response(sensor::Sensor *sensor, float state, APIConnection *conn,
-                                                       uint32_t remaining_size, bool is_single) {
-  SensorStateResponse resp;
-  resp.state = state;
-  resp.missing_state = !sensor->has_state();
-  resp.key = sensor->get_object_id_hash();
-  return encode_message_to_buffer(resp, SensorStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
-}
 
 uint16_t APIConnection::try_send_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single) {
   auto *sensor = static_cast<sensor::Sensor *>(entity);
-  return try_send_sensor_state_response(sensor, sensor->state, conn, remaining_size, is_single);
+  SensorStateResponse resp;
+  resp.state = sensor->state;
+  resp.missing_state = !sensor->has_state();
+  resp.key = sensor->get_object_id_hash();
+  return encode_message_to_buffer(resp, SensorStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -574,28 +558,20 @@ uint16_t APIConnection::try_send_sensor_info(EntityBase *entity, APIConnection *
 #endif
 
 #ifdef USE_SWITCH
-bool APIConnection::send_switch_state(switch_::Switch *a_switch, bool state) {
-  return this->schedule_message_(a_switch, MessageCreator(state, SwitchStateResponse::MESSAGE_TYPE),
-                                 SwitchStateResponse::MESSAGE_TYPE);
-}
 bool APIConnection::send_switch_state(switch_::Switch *a_switch) {
   return this->schedule_message_(a_switch, &APIConnection::try_send_switch_state, SwitchStateResponse::MESSAGE_TYPE);
 }
 void APIConnection::send_switch_info(switch_::Switch *a_switch) {
   this->schedule_message_(a_switch, &APIConnection::try_send_switch_info, ListEntitiesSwitchResponse::MESSAGE_TYPE);
 }
-uint16_t APIConnection::try_send_switch_state_response(switch_::Switch *a_switch, bool state, APIConnection *conn,
-                                                       uint32_t remaining_size, bool is_single) {
-  SwitchStateResponse resp;
-  resp.state = state;
-  resp.key = a_switch->get_object_id_hash();
-  return encode_message_to_buffer(resp, SwitchStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
-}
 
 uint16_t APIConnection::try_send_switch_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single) {
   auto *a_switch = static_cast<switch_::Switch *>(entity);
-  return try_send_switch_state_response(a_switch, a_switch->state, conn, remaining_size, is_single);
+  SwitchStateResponse resp;
+  resp.state = a_switch->state;
+  resp.key = a_switch->get_object_id_hash();
+  return encode_message_to_buffer(resp, SwitchStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_switch_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -622,10 +598,6 @@ void APIConnection::switch_command(const SwitchCommandRequest &msg) {
 #endif
 
 #ifdef USE_TEXT_SENSOR
-bool APIConnection::send_text_sensor_state(text_sensor::TextSensor *text_sensor, const std::string &state) {
-  return this->schedule_message_(text_sensor, MessageCreator(state, TextSensorStateResponse::MESSAGE_TYPE),
-                                 TextSensorStateResponse::MESSAGE_TYPE);
-}
 bool APIConnection::send_text_sensor_state(text_sensor::TextSensor *text_sensor) {
   return this->schedule_message_(text_sensor, &APIConnection::try_send_text_sensor_state,
                                  TextSensorStateResponse::MESSAGE_TYPE);
@@ -634,20 +606,15 @@ void APIConnection::send_text_sensor_info(text_sensor::TextSensor *text_sensor)
   this->schedule_message_(text_sensor, &APIConnection::try_send_text_sensor_info,
                           ListEntitiesTextSensorResponse::MESSAGE_TYPE);
 }
-uint16_t APIConnection::try_send_text_sensor_state_response(text_sensor::TextSensor *text_sensor,
-                                                            const std::string &state, APIConnection *conn,
-                                                            uint32_t remaining_size, bool is_single) {
-  TextSensorStateResponse resp;
-  resp.state = state;
-  resp.missing_state = !text_sensor->has_state();
-  resp.key = text_sensor->get_object_id_hash();
-  return encode_message_to_buffer(resp, TextSensorStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
-}
 
 uint16_t APIConnection::try_send_text_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                    bool is_single) {
   auto *text_sensor = static_cast<text_sensor::TextSensor *>(entity);
-  return try_send_text_sensor_state_response(text_sensor, text_sensor->get_state(), conn, remaining_size, is_single);
+  TextSensorStateResponse resp;
+  resp.state = text_sensor->state;
+  resp.missing_state = !text_sensor->has_state();
+  resp.key = text_sensor->get_object_id_hash();
+  return encode_message_to_buffer(resp, TextSensorStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 uint16_t APIConnection::try_send_text_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                   bool is_single) {
@@ -766,29 +733,21 @@ void APIConnection::climate_command(const ClimateCommandRequest &msg) {
 #endif
 
 #ifdef USE_NUMBER
-bool APIConnection::send_number_state(number::Number *number, float state) {
-  return this->schedule_message_(number, MessageCreator(state, NumberStateResponse::MESSAGE_TYPE),
-                                 NumberStateResponse::MESSAGE_TYPE);
-}
 bool APIConnection::send_number_state(number::Number *number) {
   return this->schedule_message_(number, &APIConnection::try_send_number_state, NumberStateResponse::MESSAGE_TYPE);
 }
 void APIConnection::send_number_info(number::Number *number) {
   this->schedule_message_(number, &APIConnection::try_send_number_info, ListEntitiesNumberResponse::MESSAGE_TYPE);
 }
-uint16_t APIConnection::try_send_number_state_response(number::Number *number, float state, APIConnection *conn,
-                                                       uint32_t remaining_size, bool is_single) {
-  NumberStateResponse resp;
-  resp.state = state;
-  resp.missing_state = !number->has_state();
-  resp.key = number->get_object_id_hash();
-  return encode_message_to_buffer(resp, NumberStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
-}
 
 uint16_t APIConnection::try_send_number_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single) {
   auto *number = static_cast<number::Number *>(entity);
-  return try_send_number_state_response(number, number->state, conn, remaining_size, is_single);
+  NumberStateResponse resp;
+  resp.state = number->state;
+  resp.missing_state = !number->has_state();
+  resp.key = number->get_object_id_hash();
+  return encode_message_to_buffer(resp, NumberStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_number_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -930,29 +889,21 @@ void APIConnection::datetime_command(const DateTimeCommandRequest &msg) {
 #endif
 
 #ifdef USE_TEXT
-bool APIConnection::send_text_state(text::Text *text, const std::string &state) {
-  return this->schedule_message_(text, MessageCreator(state, TextStateResponse::MESSAGE_TYPE),
-                                 TextStateResponse::MESSAGE_TYPE);
-}
 bool APIConnection::send_text_state(text::Text *text) {
   return this->schedule_message_(text, &APIConnection::try_send_text_state, TextStateResponse::MESSAGE_TYPE);
 }
 void APIConnection::send_text_info(text::Text *text) {
   this->schedule_message_(text, &APIConnection::try_send_text_info, ListEntitiesTextResponse::MESSAGE_TYPE);
 }
-uint16_t APIConnection::try_send_text_state_response(text::Text *text, const std::string &state, APIConnection *conn,
-                                                     uint32_t remaining_size, bool is_single) {
-  TextStateResponse resp;
-  resp.state = state;
-  resp.missing_state = !text->has_state();
-  resp.key = text->get_object_id_hash();
-  return encode_message_to_buffer(resp, TextStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
-}
 
 uint16_t APIConnection::try_send_text_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                             bool is_single) {
   auto *text = static_cast<text::Text *>(entity);
-  return try_send_text_state_response(text, text->state, conn, remaining_size, is_single);
+  TextStateResponse resp;
+  resp.state = text->state;
+  resp.missing_state = !text->has_state();
+  resp.key = text->get_object_id_hash();
+  return encode_message_to_buffer(resp, TextStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_text_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -979,29 +930,21 @@ void APIConnection::text_command(const TextCommandRequest &msg) {
 #endif
 
 #ifdef USE_SELECT
-bool APIConnection::send_select_state(select::Select *select, const std::string &state) {
-  return this->schedule_message_(select, MessageCreator(state, SelectStateResponse::MESSAGE_TYPE),
-                                 SelectStateResponse::MESSAGE_TYPE);
-}
 bool APIConnection::send_select_state(select::Select *select) {
   return this->schedule_message_(select, &APIConnection::try_send_select_state, SelectStateResponse::MESSAGE_TYPE);
 }
 void APIConnection::send_select_info(select::Select *select) {
   this->schedule_message_(select, &APIConnection::try_send_select_info, ListEntitiesSelectResponse::MESSAGE_TYPE);
 }
-uint16_t APIConnection::try_send_select_state_response(select::Select *select, const std::string &state,
-                                                       APIConnection *conn, uint32_t remaining_size, bool is_single) {
-  SelectStateResponse resp;
-  resp.state = state;
-  resp.missing_state = !select->has_state();
-  resp.key = select->get_object_id_hash();
-  return encode_message_to_buffer(resp, SelectStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
-}
 
 uint16_t APIConnection::try_send_select_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single) {
   auto *select = static_cast<select::Select *>(entity);
-  return try_send_select_state_response(select, select->state, conn, remaining_size, is_single);
+  SelectStateResponse resp;
+  resp.state = select->state;
+  resp.missing_state = !select->has_state();
+  resp.key = select->get_object_id_hash();
+  return encode_message_to_buffer(resp, SelectStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_select_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -1048,28 +991,20 @@ void esphome::api::APIConnection::button_command(const ButtonCommandRequest &msg
 #endif
 
 #ifdef USE_LOCK
-bool APIConnection::send_lock_state(lock::Lock *a_lock, lock::LockState state) {
-  return this->schedule_message_(a_lock, MessageCreator(state, LockStateResponse::MESSAGE_TYPE),
-                                 LockStateResponse::MESSAGE_TYPE);
-}
 bool APIConnection::send_lock_state(lock::Lock *a_lock) {
   return this->schedule_message_(a_lock, &APIConnection::try_send_lock_state, LockStateResponse::MESSAGE_TYPE);
 }
 void APIConnection::send_lock_info(lock::Lock *a_lock) {
   this->schedule_message_(a_lock, &APIConnection::try_send_lock_info, ListEntitiesLockResponse::MESSAGE_TYPE);
 }
-uint16_t APIConnection::try_send_lock_state_response(lock::Lock *a_lock, lock::LockState state, APIConnection *conn,
-                                                     uint32_t remaining_size, bool is_single) {
-  LockStateResponse resp;
-  resp.state = static_cast<enums::LockState>(state);
-  resp.key = a_lock->get_object_id_hash();
-  return encode_message_to_buffer(resp, LockStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
-}
 
 uint16_t APIConnection::try_send_lock_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                             bool is_single) {
   auto *a_lock = static_cast<lock::Lock *>(entity);
-  return try_send_lock_state_response(a_lock, a_lock->state, conn, remaining_size, is_single);
+  LockStateResponse resp;
+  resp.state = static_cast<enums::LockState>(a_lock->state);
+  resp.key = a_lock->get_object_id_hash();
+  return encode_message_to_buffer(resp, LockStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_lock_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -1932,63 +1867,6 @@ uint16_t APIConnection::MessageCreator::operator()(EntityBase *entity, APIConnec
     case 0:  // Function pointer
       return data_.ptr(entity, conn, remaining_size, is_single);
 
-#ifdef USE_BINARY_SENSOR
-    case BinarySensorStateResponse::MESSAGE_TYPE: {
-      auto *bs = static_cast<binary_sensor::BinarySensor *>(entity);
-      return APIConnection::try_send_binary_sensor_state_response(bs, data_.bool_value, conn, remaining_size,
-                                                                  is_single);
-    }
-#endif
-
-#ifdef USE_SENSOR
-    case SensorStateResponse::MESSAGE_TYPE: {
-      auto *s = static_cast<sensor::Sensor *>(entity);
-      return APIConnection::try_send_sensor_state_response(s, data_.float_value, conn, remaining_size, is_single);
-    }
-#endif
-
-#ifdef USE_SWITCH
-    case SwitchStateResponse::MESSAGE_TYPE: {
-      auto *sw = static_cast<switch_::Switch *>(entity);
-      return APIConnection::try_send_switch_state_response(sw, data_.bool_value, conn, remaining_size, is_single);
-    }
-#endif
-
-#ifdef USE_TEXT_SENSOR
-    case TextSensorStateResponse::MESSAGE_TYPE: {
-      auto *ts = static_cast<text_sensor::TextSensor *>(entity);
-      return APIConnection::try_send_text_sensor_state_response(ts, *data_.string_ptr, conn, remaining_size, is_single);
-    }
-#endif
-
-#ifdef USE_SELECT
-    case SelectStateResponse::MESSAGE_TYPE: {
-      auto *s = static_cast<select::Select *>(entity);
-      return APIConnection::try_send_select_state_response(s, *data_.string_ptr, conn, remaining_size, is_single);
-    }
-#endif
-
-#ifdef USE_NUMBER
-    case NumberStateResponse::MESSAGE_TYPE: {
-      auto *n = static_cast<number::Number *>(entity);
-      return APIConnection::try_send_number_state_response(n, data_.float_value, conn, remaining_size, is_single);
-    }
-#endif
-
-#ifdef USE_TEXT
-    case TextStateResponse::MESSAGE_TYPE: {
-      auto *t = static_cast<text::Text *>(entity);
-      return APIConnection::try_send_text_state_response(t, *data_.string_ptr, conn, remaining_size, is_single);
-    }
-#endif
-
-#ifdef USE_LOCK
-    case LockStateResponse::MESSAGE_TYPE: {
-      auto *l = static_cast<lock::Lock *>(entity);
-      return APIConnection::try_send_lock_state_response(l, data_.lock_value, conn, remaining_size, is_single);
-    }
-#endif
-
 #ifdef USE_EVENT
     case EventResponse::MESSAGE_TYPE: {
       auto *e = static_cast<event::Event *>(entity);
@@ -2008,6 +1886,12 @@ uint16_t APIConnection::try_send_list_info_done(EntityBase *entity, APIConnectio
   return encode_message_to_buffer(resp, ListEntitiesDoneResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 
+uint16_t APIConnection::try_send_disconnect_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                                    bool is_single) {
+  DisconnectRequest req;
+  return encode_message_to_buffer(req, DisconnectRequest::MESSAGE_TYPE, conn, remaining_size, is_single);
+}
+
 uint16_t APIConnection::get_estimated_message_size(uint16_t message_type) {
   // Use generated ESTIMATED_SIZE constants from each message type
   switch (message_type) {
@@ -2143,6 +2027,8 @@ uint16_t APIConnection::get_estimated_message_size(uint16_t message_type) {
       return ListEntitiesServicesResponse::ESTIMATED_SIZE;
     case ListEntitiesDoneResponse::MESSAGE_TYPE:
       return ListEntitiesDoneResponse::ESTIMATED_SIZE;
+    case DisconnectRequest::MESSAGE_TYPE:
+      return DisconnectRequest::ESTIMATED_SIZE;
     default:
       // Fallback for unknown message types
       return 24;

esphome/components/api/api_connection.h

@@ -33,7 +33,6 @@ class APIConnection : public APIServerConnection {
                                    ListEntitiesDoneResponse::MESSAGE_TYPE);
   }
 #ifdef USE_BINARY_SENSOR
-  bool send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor, bool state);
   bool send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor);
   void send_binary_sensor_info(binary_sensor::BinarySensor *binary_sensor);
 #endif
@@ -53,18 +52,15 @@ class APIConnection : public APIServerConnection {
   void light_command(const LightCommandRequest &msg) override;
 #endif
 #ifdef USE_SENSOR
-  bool send_sensor_state(sensor::Sensor *sensor, float state);
   bool send_sensor_state(sensor::Sensor *sensor);
   void send_sensor_info(sensor::Sensor *sensor);
 #endif
 #ifdef USE_SWITCH
-  bool send_switch_state(switch_::Switch *a_switch, bool state);
   bool send_switch_state(switch_::Switch *a_switch);
   void send_switch_info(switch_::Switch *a_switch);
   void switch_command(const SwitchCommandRequest &msg) override;
 #endif
 #ifdef USE_TEXT_SENSOR
-  bool send_text_sensor_state(text_sensor::TextSensor *text_sensor, const std::string &state);
   bool send_text_sensor_state(text_sensor::TextSensor *text_sensor);
   void send_text_sensor_info(text_sensor::TextSensor *text_sensor);
 #endif
@@ -79,7 +75,6 @@ class APIConnection : public APIServerConnection {
   void climate_command(const ClimateCommandRequest &msg) override;
 #endif
 #ifdef USE_NUMBER
-  bool send_number_state(number::Number *number, float state);
   bool send_number_state(number::Number *number);
   void send_number_info(number::Number *number);
   void number_command(const NumberCommandRequest &msg) override;
@@ -100,13 +95,11 @@ class APIConnection : public APIServerConnection {
   void datetime_command(const DateTimeCommandRequest &msg) override;
 #endif
 #ifdef USE_TEXT
-  bool send_text_state(text::Text *text, const std::string &state);
   bool send_text_state(text::Text *text);
   void send_text_info(text::Text *text);
   void text_command(const TextCommandRequest &msg) override;
 #endif
 #ifdef USE_SELECT
-  bool send_select_state(select::Select *select, const std::string &state);
   bool send_select_state(select::Select *select);
   void send_select_info(select::Select *select);
   void select_command(const SelectCommandRequest &msg) override;
@@ -116,7 +109,6 @@ class APIConnection : public APIServerConnection {
   void button_command(const ButtonCommandRequest &msg) override;
 #endif
 #ifdef USE_LOCK
-  bool send_lock_state(lock::Lock *a_lock, lock::LockState state);
   bool send_lock_state(lock::Lock *a_lock);
   void send_lock_info(lock::Lock *a_lock);
   void lock_command(const LockCommandRequest &msg) override;
@@ -316,9 +308,7 @@ class APIConnection : public APIServerConnection {
                                            uint32_t remaining_size, bool is_single);
 
 #ifdef USE_BINARY_SENSOR
-  static uint16_t try_send_binary_sensor_state_response(binary_sensor::BinarySensor *binary_sensor, bool state,
-                                                        APIConnection *conn, uint32_t remaining_size, bool is_single);
-  static uint16_t try_send_binary_sensor_state(EntityBase *binary_sensor, APIConnection *conn, uint32_t remaining_size,
+  static uint16_t try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                bool is_single);
   static uint16_t try_send_binary_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single);
@@ -338,24 +328,18 @@ class APIConnection : public APIServerConnection {
   static uint16_t try_send_light_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
 #ifdef USE_SENSOR
-  static uint16_t try_send_sensor_state_response(sensor::Sensor *sensor, float state, APIConnection *conn,
-                                                 uint32_t remaining_size, bool is_single);
   static uint16_t try_send_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                         bool is_single);
   static uint16_t try_send_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                        bool is_single);
 #endif
 #ifdef USE_SWITCH
-  static uint16_t try_send_switch_state_response(switch_::Switch *a_switch, bool state, APIConnection *conn,
-                                                 uint32_t remaining_size, bool is_single);
   static uint16_t try_send_switch_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                         bool is_single);
   static uint16_t try_send_switch_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                        bool is_single);
 #endif
 #ifdef USE_TEXT_SENSOR
-  static uint16_t try_send_text_sensor_state_response(text_sensor::TextSensor *text_sensor, const std::string &state,
-                                                      APIConnection *conn, uint32_t remaining_size, bool is_single);
   static uint16_t try_send_text_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                              bool is_single);
   static uint16_t try_send_text_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -368,8 +352,6 @@ class APIConnection : public APIServerConnection {
                                         bool is_single);
 #endif
 #ifdef USE_NUMBER
-  static uint16_t try_send_number_state_response(number::Number *number, float state, APIConnection *conn,
-                                                 uint32_t remaining_size, bool is_single);
   static uint16_t try_send_number_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                         bool is_single);
   static uint16_t try_send_number_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -390,14 +372,10 @@ class APIConnection : public APIServerConnection {
                                          bool is_single);
 #endif
 #ifdef USE_TEXT
-  static uint16_t try_send_text_state_response(text::Text *text, const std::string &state, APIConnection *conn,
-                                               uint32_t remaining_size, bool is_single);
   static uint16_t try_send_text_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
   static uint16_t try_send_text_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
 #ifdef USE_SELECT
-  static uint16_t try_send_select_state_response(select::Select *select, const std::string &state, APIConnection *conn,
-                                                 uint32_t remaining_size, bool is_single);
   static uint16_t try_send_select_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                         bool is_single);
   static uint16_t try_send_select_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -408,8 +386,6 @@ class APIConnection : public APIServerConnection {
                                        bool is_single);
 #endif
 #ifdef USE_LOCK
-  static uint16_t try_send_lock_state_response(lock::Lock *a_lock, lock::LockState state, APIConnection *conn,
-                                               uint32_t remaining_size, bool is_single);
   static uint16_t try_send_lock_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
   static uint16_t try_send_lock_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
@@ -450,6 +426,10 @@ class APIConnection : public APIServerConnection {
   static uint16_t try_send_list_info_done(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                           bool is_single);
 
+  // Method for DisconnectRequest batching
+  static uint16_t try_send_disconnect_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                              bool is_single);
+
   // Helper function to get estimated message size for buffer pre-allocation
   static uint16_t get_estimated_message_size(uint16_t message_type);
 
@@ -494,22 +474,11 @@ class APIConnection : public APIServerConnection {
     // Constructor for function pointer (message_type = 0)
     MessageCreator(MessageCreatorPtr ptr) : message_type_(0) { data_.ptr = ptr; }
 
-    // Constructor for bool state capture
-    MessageCreator(bool value, uint16_t msg_type) : message_type_(msg_type) { data_.bool_value = value; }
-
-    // Constructor for float state capture
-    MessageCreator(float value, uint16_t msg_type) : message_type_(msg_type) { data_.float_value = value; }
-
     // Constructor for string state capture
     MessageCreator(const std::string &value, uint16_t msg_type) : message_type_(msg_type) {
       data_.string_ptr = new std::string(value);
     }
 
-#ifdef USE_LOCK
-    // Constructor for lock state capture
-    MessageCreator(lock::LockState value, uint16_t msg_type) : message_type_(msg_type) { data_.lock_value = value; }
-#endif
-
     // Destructor
     ~MessageCreator() {
       // Clean up string data for string-based message types
@@ -576,21 +545,12 @@ class APIConnection : public APIServerConnection {
 
    private:
     // Helper to check if this message type uses heap-allocated strings
-    bool uses_string_data_() const {
-      return message_type_ == TextSensorStateResponse::MESSAGE_TYPE ||
-             message_type_ == SelectStateResponse::MESSAGE_TYPE || message_type_ == TextStateResponse::MESSAGE_TYPE ||
-             message_type_ == EventResponse::MESSAGE_TYPE;
-    }
+    bool uses_string_data_() const { return message_type_ == EventResponse::MESSAGE_TYPE; }
     union CreatorData {
       MessageCreatorPtr ptr;    // 8 bytes
-      bool bool_value;          // 1 byte
-      float float_value;        // 4 bytes
       std::string *string_ptr;  // 8 bytes
-#ifdef USE_LOCK
-      lock::LockState lock_value;  // 4 bytes
-#endif
-    } data_;                 // 8 bytes
-    uint16_t message_type_;  // 2 bytes (0 = function ptr, >0 = state capture)
+    } data_;                    // 8 bytes
+    uint16_t message_type_;     // 2 bytes (0 = function ptr, >0 = state capture)
   };
 
   // Generic batching mechanism for both state updates and entity info

esphome/components/api/api_frame_helper.cpp

@@ -1,9 +1,9 @@
 #include "api_frame_helper.h"
 #ifdef USE_API
-#include "esphome/core/log.h"
+#include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/application.h"
+#include "esphome/core/log.h"
 #include "proto.h"
 #include "api_pb2_size.h"
 #include <cstring>

esphome/components/api/api_server.cpp

@@ -92,6 +92,12 @@ void APIServer::setup() {
 #ifdef USE_LOGGER
   if (logger::global_logger != nullptr) {
     logger::global_logger->add_on_log_callback([this](int level, const char *tag, const char *message) {
+      if (this->shutting_down_) {
+        // Don't try to send logs during shutdown
+        // as it could result in a recursion and
+        // we would be filling a buffer we are trying to clear
+        return;
+      }
       for (auto &c : this->clients_) {
         if (!c->remove_)
           c->try_send_log_message(level, tag, message);
@@ -116,8 +122,8 @@ void APIServer::setup() {
 }
 
 void APIServer::loop() {
-  // Accept new clients only if the socket has incoming connections
-  if (this->socket_->ready()) {
+  // Accept new clients only if the socket exists and has incoming connections
+  if (this->socket_ && this->socket_->ready()) {
     while (true) {
       struct sockaddr_storage source_addr;
       socklen_t addr_len = sizeof(source_addr);
@@ -173,8 +179,10 @@ void APIServer::loop() {
 }
 
 void APIServer::dump_config() {
-  ESP_LOGCONFIG(TAG, "API Server:");
-  ESP_LOGCONFIG(TAG, "  Address: %s:%u", network::get_use_address().c_str(), this->port_);
+  ESP_LOGCONFIG(TAG,
+                "API Server:\n"
+                "  Address: %s:%u",
+                network::get_use_address().c_str(), this->port_);
 #ifdef USE_API_NOISE
   ESP_LOGCONFIG(TAG, "  Using noise encryption: %s", YESNO(this->noise_ctx_->has_psk()));
   if (!this->noise_ctx_->has_psk()) {
@@ -219,12 +227,11 @@ bool APIServer::check_password(const std::string &password) const {
 void APIServer::handle_disconnect(APIConnection *conn) {}
 
 #ifdef USE_BINARY_SENSOR
-void APIServer::on_binary_sensor_update(binary_sensor::BinarySensor *obj, bool state) {
+void APIServer::on_binary_sensor_update(binary_sensor::BinarySensor *obj) {
   if (obj->is_internal())
     return;
-  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    use_current ? c->send_binary_sensor_state(obj) : c->send_binary_sensor_state(obj, state);
+    c->send_binary_sensor_state(obj);
 }
 #endif
 
@@ -259,9 +266,8 @@ void APIServer::on_light_update(light::LightState *obj) {
 void APIServer::on_sensor_update(sensor::Sensor *obj, float state) {
   if (obj->is_internal())
     return;
-  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    use_current ? c->send_sensor_state(obj) : c->send_sensor_state(obj, state);
+    c->send_sensor_state(obj);
 }
 #endif
 
@@ -269,9 +275,8 @@ void APIServer::on_sensor_update(sensor::Sensor *obj, float state) {
 void APIServer::on_switch_update(switch_::Switch *obj, bool state) {
   if (obj->is_internal())
     return;
-  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    use_current ? c->send_switch_state(obj) : c->send_switch_state(obj, state);
+    c->send_switch_state(obj);
 }
 #endif
 
@@ -279,9 +284,8 @@ void APIServer::on_switch_update(switch_::Switch *obj, bool state) {
 void APIServer::on_text_sensor_update(text_sensor::TextSensor *obj, const std::string &state) {
   if (obj->is_internal())
     return;
-  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    use_current ? c->send_text_sensor_state(obj) : c->send_text_sensor_state(obj, state);
+    c->send_text_sensor_state(obj);
 }
 #endif
 
@@ -298,9 +302,8 @@ void APIServer::on_climate_update(climate::Climate *obj) {
 void APIServer::on_number_update(number::Number *obj, float state) {
   if (obj->is_internal())
     return;
-  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    use_current ? c->send_number_state(obj) : c->send_number_state(obj, state);
+    c->send_number_state(obj);
 }
 #endif
 
@@ -335,9 +338,8 @@ void APIServer::on_datetime_update(datetime::DateTimeEntity *obj) {
 void APIServer::on_text_update(text::Text *obj, const std::string &state) {
   if (obj->is_internal())
     return;
-  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    use_current ? c->send_text_state(obj) : c->send_text_state(obj, state);
+    c->send_text_state(obj);
 }
 #endif
 
@@ -345,9 +347,8 @@ void APIServer::on_text_update(text::Text *obj, const std::string &state) {
 void APIServer::on_select_update(select::Select *obj, const std::string &state, size_t index) {
   if (obj->is_internal())
     return;
-  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    use_current ? c->send_select_state(obj) : c->send_select_state(obj, state);
+    c->send_select_state(obj);
 }
 #endif
 
@@ -487,10 +488,36 @@ void APIServer::request_time() {
 bool APIServer::is_connected() const { return !this->clients_.empty(); }
 
 void APIServer::on_shutdown() {
-  for (auto &c : this->clients_) {
-    c->send_message(DisconnectRequest());
+  this->shutting_down_ = true;
+
+  // Close the listening socket to prevent new connections
+  if (this->socket_) {
+    this->socket_->close();
+    this->socket_ = nullptr;
   }
-  delay(10);
+
+  // Change batch delay to 5ms for quick flushing during shutdown
+  this->batch_delay_ = 5;
+
+  // Send disconnect requests to all connected clients
+  for (auto &c : this->clients_) {
+    if (!c->send_message(DisconnectRequest())) {
+      // If we can't send the disconnect request directly (tx_buffer full),
+      // schedule it in the batch so it will be sent with the 5ms timer
+      c->schedule_message_(nullptr, &APIConnection::try_send_disconnect_request, DisconnectRequest::MESSAGE_TYPE);
+    }
+  }
+}
+
+bool APIServer::teardown() {
+  // If network is disconnected, no point trying to flush buffers
+  if (!network::is_connected()) {
+    return true;
+  }
+  this->loop();
+
+  // Return true only when all clients have been torn down
+  return this->clients_.empty();
 }
 
 }  // namespace api

esphome/components/api/api_server.h

@@ -34,6 +34,7 @@ class APIServer : public Component, public Controller {
   void loop() override;
   void dump_config() override;
   void on_shutdown() override;
+  bool teardown() override;
   bool check_password(const std::string &password) const;
   bool uses_password() const;
   void set_port(uint16_t port);
@@ -53,7 +54,7 @@ class APIServer : public Component, public Controller {
 
   void handle_disconnect(APIConnection *conn);
 #ifdef USE_BINARY_SENSOR
-  void on_binary_sensor_update(binary_sensor::BinarySensor *obj, bool state) override;
+  void on_binary_sensor_update(binary_sensor::BinarySensor *obj) override;
 #endif
 #ifdef USE_COVER
   void on_cover_update(cover::Cover *obj) override;
@@ -141,6 +142,7 @@ class APIServer : public Component, public Controller {
   }
 
  protected:
+  bool shutting_down_ = false;
   std::unique_ptr<socket::Socket> socket_ = nullptr;
   uint16_t port_{6053};
   uint32_t reboot_timeout_{300000};

esphome/components/api/client.py

@@ -5,7 +5,7 @@ from datetime import datetime
 import logging
 from typing import TYPE_CHECKING, Any
 
-from aioesphomeapi import APIClient
+from aioesphomeapi import APIClient, parse_log_message
 from aioesphomeapi.log_runner import async_run
 
 from esphome.const import CONF_KEY, CONF_PASSWORD, CONF_PORT, __version__
@@ -46,9 +46,10 @@ async def async_run_logs(config: dict[str, Any], address: str) -> None:
         time_ = datetime.now()
         message: bytes = msg.message
         text = message.decode("utf8", "backslashreplace")
-        if dashboard:
-            text = text.replace("\033", "\\033")
-        print(f"[{time_.hour:02}:{time_.minute:02}:{time_.second:02}]{text}")
+        for parsed_msg in parse_log_message(
+            text, f"[{time_.hour:02}:{time_.minute:02}:{time_.second:02}]"
+        ):
+            print(parsed_msg.replace("\033", "\\033") if dashboard else parsed_msg)
 
     stop = await async_run(cli, on_log, name=name)
     try:

esphome/components/api/homeassistant_service.h

@@ -3,8 +3,8 @@
 #include "api_server.h"
 #ifdef USE_API
 #include "api_pb2.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/automation.h"
+#include "esphome/core/helpers.h"
 #include <vector>
 
 namespace esphome {

esphome/components/api/proto.cpp

@@ -1,5 +1,6 @@
 #include "proto.h"
 #include <cinttypes>
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {

esphome/components/api/proto.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "esphome/core/component.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 #include <vector>
 

esphome/components/as5600/as5600.cpp

@@ -95,11 +95,13 @@ void AS5600Component::dump_config() {
     return;
   }
 
-  ESP_LOGCONFIG(TAG, "  Watchdog: %d", this->watchdog_);
-  ESP_LOGCONFIG(TAG, "  Fast Filter: %d", this->fast_filter_);
-  ESP_LOGCONFIG(TAG, "  Slow Filter: %d", this->slow_filter_);
-  ESP_LOGCONFIG(TAG, "  Hysteresis: %d", this->hysteresis_);
-  ESP_LOGCONFIG(TAG, "  Start Position: %d", this->start_position_);
+  ESP_LOGCONFIG(TAG,
+                "  Watchdog: %d\n"
+                "  Fast Filter: %d\n"
+                "  Slow Filter: %d\n"
+                "  Hysteresis: %d\n"
+                "  Start Position: %d",
+                this->watchdog_, this->fast_filter_, this->slow_filter_, this->hysteresis_, this->start_position_);
   if (this->end_mode_ == END_MODE_POSITION) {
     ESP_LOGCONFIG(TAG, "  End Position: %d", this->end_position_);
   } else {

esphome/components/as7341/as7341.cpp

@@ -41,9 +41,11 @@ void AS7341Component::dump_config() {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
-  ESP_LOGCONFIG(TAG, "  Gain: %u", get_gain());
-  ESP_LOGCONFIG(TAG, "  ATIME: %u", get_atime());
-  ESP_LOGCONFIG(TAG, "  ASTEP: %u", get_astep());
+  ESP_LOGCONFIG(TAG,
+                "  Gain: %u\n"
+                "  ATIME: %u\n"
+                "  ASTEP: %u",
+                get_gain(), get_atime(), get_astep());
 
   LOG_SENSOR("  ", "F1", this->f1_);
   LOG_SENSOR("  ", "F2", this->f2_);

esphome/components/at581x/at581x.cpp

@@ -75,15 +75,18 @@ void AT581XComponent::setup() { ESP_LOGCONFIG(TAG, "Running setup"); }
 void AT581XComponent::dump_config() { LOG_I2C_DEVICE(this); }
 #define ARRAY_SIZE(X) (sizeof(X) / sizeof((X)[0]))
 bool AT581XComponent::i2c_write_config() {
-  ESP_LOGCONFIG(TAG, "Writing new config for AT581X");
-  ESP_LOGCONFIG(TAG, "Frequency: %dMHz", this->freq_);
-  ESP_LOGCONFIG(TAG, "Sensing distance: %d", this->delta_);
-  ESP_LOGCONFIG(TAG, "Power: %dµA", this->power_);
-  ESP_LOGCONFIG(TAG, "Gain: %d", this->gain_);
-  ESP_LOGCONFIG(TAG, "Trigger base time: %dms", this->trigger_base_time_ms_);
-  ESP_LOGCONFIG(TAG, "Trigger keep time: %dms", this->trigger_keep_time_ms_);
-  ESP_LOGCONFIG(TAG, "Protect time: %dms", this->protect_time_ms_);
-  ESP_LOGCONFIG(TAG, "Self check time: %dms", this->self_check_time_ms_);
+  ESP_LOGCONFIG(TAG,
+                "Writing new config for AT581X\n"
+                "Frequency: %dMHz\n"
+                "Sensing distance: %d\n"
+                "Power: %dµA\n"
+                "Gain: %d\n"
+                "Trigger base time: %dms\n"
+                "Trigger keep time: %dms\n"
+                "Protect time: %dms\n"
+                "Self check time: %dms",
+                this->freq_, this->delta_, this->power_, this->gain_, this->trigger_base_time_ms_,
+                this->trigger_keep_time_ms_, this->protect_time_ms_, this->self_check_time_ms_);
 
   // Set frequency point
   if (!this->i2c_write_reg(FREQ_ADDR, GAIN61_VALUE)) {

esphome/components/axs15231/touchscreen/axs15231_touchscreen.cpp

@@ -60,8 +60,10 @@ void AXS15231Touchscreen::dump_config() {
   LOG_I2C_DEVICE(this);
   LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
   LOG_PIN("  Reset Pin: ", this->reset_pin_);
-  ESP_LOGCONFIG(TAG, "  Width: %d", this->x_raw_max_);
-  ESP_LOGCONFIG(TAG, "  Height: %d", this->y_raw_max_);
+  ESP_LOGCONFIG(TAG,
+                "  Width: %d\n"
+                "  Height: %d",
+                this->x_raw_max_, this->y_raw_max_);
 }
 
 }  // namespace axs15231

esphome/components/bang_bang/bang_bang_climate.cpp

@@ -194,11 +194,14 @@ Trigger<> *BangBangClimate::get_heat_trigger() const { return this->heat_trigger
 void BangBangClimate::set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }
 void BangBangClimate::dump_config() {
   LOG_CLIMATE("", "Bang Bang Climate", this);
-  ESP_LOGCONFIG(TAG, "  Supports HEAT: %s", YESNO(this->supports_heat_));
-  ESP_LOGCONFIG(TAG, "  Supports COOL: %s", YESNO(this->supports_cool_));
-  ESP_LOGCONFIG(TAG, "  Supports AWAY mode: %s", YESNO(this->supports_away_));
-  ESP_LOGCONFIG(TAG, "  Default Target Temperature Low: %.2f°C", this->normal_config_.default_temperature_low);
-  ESP_LOGCONFIG(TAG, "  Default Target Temperature High: %.2f°C", this->normal_config_.default_temperature_high);
+  ESP_LOGCONFIG(TAG,
+                "  Supports HEAT: %s\n"
+                "  Supports COOL: %s\n"
+                "  Supports AWAY mode: %s\n"
+                "  Default Target Temperature Low: %.2f°C\n"
+                "  Default Target Temperature High: %.2f°C",
+                YESNO(this->supports_heat_), YESNO(this->supports_cool_), YESNO(this->supports_away_),
+                this->normal_config_.default_temperature_low, this->normal_config_.default_temperature_high);
 }
 
 BangBangClimateTargetTempConfig::BangBangClimateTargetTempConfig() = default;

esphome/components/bedjet/bedjet_hub.cpp

@@ -484,9 +484,11 @@ void BedJetHub::loop() {}
 void BedJetHub::update() { this->dispatch_status_(); }
 
 void BedJetHub::dump_config() {
-  ESP_LOGCONFIG(TAG, "BedJet Hub '%s'", this->get_name().c_str());
-  ESP_LOGCONFIG(TAG, "  ble_client.app_id: %d", this->parent()->app_id);
-  ESP_LOGCONFIG(TAG, "  ble_client.conn_id: %d", this->parent()->get_conn_id());
+  ESP_LOGCONFIG(TAG,
+                "BedJet Hub '%s'\n"
+                "  ble_client.app_id: %d\n"
+                "  ble_client.conn_id: %d",
+                this->get_name().c_str(), this->parent()->app_id, this->parent()->get_conn_id());
   LOG_UPDATE_INTERVAL(this)
   ESP_LOGCONFIG(TAG, "  Child components (%d):", this->children_.size());
   for (auto *child : this->children_) {

esphome/components/beken_spi_led_strip/led_strip.cpp

@@ -345,8 +345,10 @@ light::ESPColorView BekenSPILEDStripLightOutput::get_view_internal(int32_t index
 }
 
 void BekenSPILEDStripLightOutput::dump_config() {
-  ESP_LOGCONFIG(TAG, "Beken SPI LED Strip:");
-  ESP_LOGCONFIG(TAG, "  Pin: %u", this->pin_);
+  ESP_LOGCONFIG(TAG,
+                "Beken SPI LED Strip:\n"
+                "  Pin: %u",
+                this->pin_);
   const char *rgb_order;
   switch (this->rgb_order_) {
     case ORDER_RGB:
@@ -371,9 +373,11 @@ void BekenSPILEDStripLightOutput::dump_config() {
       rgb_order = "UNKNOWN";
       break;
   }
-  ESP_LOGCONFIG(TAG, "  RGB Order: %s", rgb_order);
-  ESP_LOGCONFIG(TAG, "  Max refresh rate: %" PRIu32, *this->max_refresh_rate_);
-  ESP_LOGCONFIG(TAG, "  Number of LEDs: %u", this->num_leds_);
+  ESP_LOGCONFIG(TAG,
+                "  RGB Order: %s\n"
+                "  Max refresh rate: %" PRIu32 "\n"
+                "  Number of LEDs: %u",
+                rgb_order, *this->max_refresh_rate_, this->num_leds_);
 }
 
 float BekenSPILEDStripLightOutput::get_setup_priority() const { return setup_priority::HARDWARE; }

esphome/components/binary_sensor/__init__.py

@@ -1,7 +1,10 @@
+from logging import getLogger
+
 from esphome import automation, core
 from esphome.automation import Condition, maybe_simple_id
 import esphome.codegen as cg
 from esphome.components import mqtt, web_server
+from esphome.components.const import CONF_ON_STATE_CHANGE
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_DELAY,
@@ -98,6 +101,7 @@ IS_PLATFORM_COMPONENT = True
 
 CONF_TIME_OFF = "time_off"
 CONF_TIME_ON = "time_on"
+CONF_TRIGGER_ON_INITIAL_STATE = "trigger_on_initial_state"
 
 DEFAULT_DELAY = "1s"
 DEFAULT_TIME_OFF = "100ms"
@@ -127,9 +131,17 @@ MultiClickTriggerEvent = binary_sensor_ns.struct("MultiClickTriggerEvent")
 StateTrigger = binary_sensor_ns.class_(
     "StateTrigger", automation.Trigger.template(bool)
 )
+StateChangeTrigger = binary_sensor_ns.class_(
+    "StateChangeTrigger",
+    automation.Trigger.template(cg.optional.template(bool), cg.optional.template(bool)),
+)
+
 BinarySensorPublishAction = binary_sensor_ns.class_(
     "BinarySensorPublishAction", automation.Action
 )
+BinarySensorInvalidateAction = binary_sensor_ns.class_(
+    "BinarySensorInvalidateAction", automation.Action
+)
 
 # Condition
 BinarySensorCondition = binary_sensor_ns.class_("BinarySensorCondition", Condition)
@@ -144,6 +156,8 @@ AutorepeatFilter = binary_sensor_ns.class_("AutorepeatFilter", Filter, cg.Compon
 LambdaFilter = binary_sensor_ns.class_("LambdaFilter", Filter)
 SettleFilter = binary_sensor_ns.class_("SettleFilter", Filter, cg.Component)
 
+_LOGGER = getLogger(__name__)
+
 FILTER_REGISTRY = Registry()
 validate_filters = cv.validate_registry("filter", FILTER_REGISTRY)
 
@@ -386,6 +400,14 @@ def validate_click_timing(value):
     return value
 
 
+def validate_publish_initial_state(value):
+    value = cv.boolean(value)
+    _LOGGER.warning(
+        "The 'publish_initial_state' option has been replaced by 'trigger_on_initial_state' and will be removed in a future release"
+    )
+    return value
+
+
 _BINARY_SENSOR_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMPONENT_SCHEMA)
@@ -395,7 +417,12 @@ _BINARY_SENSOR_SCHEMA = (
             cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(
                 mqtt.MQTTBinarySensorComponent
             ),
-            cv.Optional(CONF_PUBLISH_INITIAL_STATE): cv.boolean,
+            cv.Exclusive(
+                CONF_PUBLISH_INITIAL_STATE, CONF_TRIGGER_ON_INITIAL_STATE
+            ): validate_publish_initial_state,
+            cv.Exclusive(
+                CONF_TRIGGER_ON_INITIAL_STATE, CONF_TRIGGER_ON_INITIAL_STATE
+            ): cv.boolean,
             cv.Optional(CONF_DEVICE_CLASS): validate_device_class,
             cv.Optional(CONF_FILTERS): validate_filters,
             cv.Optional(CONF_ON_PRESS): automation.validate_automation(
@@ -454,6 +481,11 @@ _BINARY_SENSOR_SCHEMA = (
                     cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StateTrigger),
                 }
             ),
+            cv.Optional(CONF_ON_STATE_CHANGE): automation.validate_automation(
+                {
+                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StateChangeTrigger),
+                }
+            ),
         }
     )
 )
@@ -493,8 +525,10 @@ async def setup_binary_sensor_core_(var, config):
 
     if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
         cg.add(var.set_device_class(device_class))
-    if publish_initial_state := config.get(CONF_PUBLISH_INITIAL_STATE):
-        cg.add(var.set_publish_initial_state(publish_initial_state))
+    trigger = config.get(CONF_TRIGGER_ON_INITIAL_STATE, False) or config.get(
+        CONF_PUBLISH_INITIAL_STATE, False
+    )
+    cg.add(var.set_trigger_on_initial_state(trigger))
     if inverted := config.get(CONF_INVERTED):
         cg.add(var.set_inverted(inverted))
     if filters_config := config.get(CONF_FILTERS):
@@ -542,6 +576,17 @@ async def setup_binary_sensor_core_(var, config):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [(bool, "x")], conf)
 
+    for conf in config.get(CONF_ON_STATE_CHANGE, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(
+            trigger,
+            [
+                (cg.optional.template(bool), "x_previous"),
+                (cg.optional.template(bool), "x"),
+            ],
+            conf,
+        )
+
     if mqtt_id := config.get(CONF_MQTT_ID):
         mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
@@ -554,6 +599,7 @@ async def register_binary_sensor(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_binary_sensor(var))
+    CORE.register_platform_component("binary_sensor", var)
     await setup_binary_sensor_core_(var, config)
 
 
@@ -590,3 +636,18 @@ async def binary_sensor_is_off_to_code(config, condition_id, template_arg, args)
 async def to_code(config):
     cg.add_define("USE_BINARY_SENSOR")
     cg.add_global(binary_sensor_ns.using)
+
+
+@automation.register_action(
+    "binary_sensor.invalidate_state",
+    BinarySensorInvalidateAction,
+    cv.maybe_simple_value(
+        {
+            cv.Required(CONF_ID): cv.use_id(BinarySensor),
+        },
+        key=CONF_ID,
+    ),
+)
+async def binary_sensor_invalidate_state_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    return cg.new_Pvariable(action_id, template_arg, paren)

esphome/components/binary_sensor/automation.h

@@ -96,7 +96,7 @@ class MultiClickTrigger : public Trigger<>, public Component {
       : parent_(parent), timing_(std::move(timing)) {}
 
   void setup() override {
-    this->last_state_ = this->parent_->state;
+    this->last_state_ = this->parent_->get_state_default(false);
     auto f = std::bind(&MultiClickTrigger::on_state_, this, std::placeholders::_1);
     this->parent_->add_on_state_callback(f);
   }
@@ -130,6 +130,14 @@ class StateTrigger : public Trigger<bool> {
   }
 };
 
+class StateChangeTrigger : public Trigger<optional<bool>, optional<bool> > {
+ public:
+  explicit StateChangeTrigger(BinarySensor *parent) {
+    parent->add_full_state_callback(
+        [this](optional<bool> old_state, optional<bool> state) { this->trigger(old_state, state); });
+  }
+};
+
 template<typename... Ts> class BinarySensorCondition : public Condition<Ts...> {
  public:
   BinarySensorCondition(BinarySensor *parent, bool state) : parent_(parent), state_(state) {}
@@ -154,5 +162,15 @@ template<typename... Ts> class BinarySensorPublishAction : public Action<Ts...>
   BinarySensor *sensor_;
 };
 
+template<typename... Ts> class BinarySensorInvalidateAction : public Action<Ts...> {
+ public:
+  explicit BinarySensorInvalidateAction(BinarySensor *sensor) : sensor_(sensor) {}
+
+  void play(Ts... x) override { this->sensor_->invalidate_state(); }
+
+ protected:
+  BinarySensor *sensor_;
+};
+
 }  // namespace binary_sensor
 }  // namespace esphome

esphome/components/binary_sensor/binary_sensor.cpp

@@ -7,42 +7,25 @@ namespace binary_sensor {
 
 static const char *const TAG = "binary_sensor";
 
-void BinarySensor::add_on_state_callback(std::function<void(bool)> &&callback) {
-  this->state_callback_.add(std::move(callback));
-}
-
-void BinarySensor::publish_state(bool state) {
-  if (!this->publish_dedup_.next(state))
-    return;
+void BinarySensor::publish_state(bool new_state) {
   if (this->filter_list_ == nullptr) {
-    this->send_state_internal(state, false);
+    this->send_state_internal(new_state);
   } else {
-    this->filter_list_->input(state, false);
+    this->filter_list_->input(new_state);
   }
 }
-void BinarySensor::publish_initial_state(bool state) {
-  if (!this->publish_dedup_.next(state))
-    return;
-  if (this->filter_list_ == nullptr) {
-    this->send_state_internal(state, true);
-  } else {
-    this->filter_list_->input(state, true);
+void BinarySensor::publish_initial_state(bool new_state) {
+  this->invalidate_state();
+  this->publish_state(new_state);
+}
+void BinarySensor::send_state_internal(bool new_state) {
+  // copy the new state to the visible property for backwards compatibility, before any callbacks
+  this->state = new_state;
+  // Note that set_state_ de-dups and will only trigger callbacks if the state has actually changed
+  if (this->set_state_(new_state)) {
+    ESP_LOGD(TAG, "'%s': New state is %s", this->get_name().c_str(), ONOFF(new_state));
   }
 }
-void BinarySensor::send_state_internal(bool state, bool is_initial) {
-  if (is_initial) {
-    ESP_LOGD(TAG, "'%s': Sending initial state %s", this->get_name().c_str(), ONOFF(state));
-  } else {
-    ESP_LOGD(TAG, "'%s': Sending state %s", this->get_name().c_str(), ONOFF(state));
-  }
-  this->has_state_ = true;
-  this->state = state;
-  if (!is_initial || this->publish_initial_state_) {
-    this->state_callback_.call(state);
-  }
-}
-
-BinarySensor::BinarySensor() : state(false) {}
 
 void BinarySensor::add_filter(Filter *filter) {
   filter->parent_ = this;
@@ -60,7 +43,6 @@ void BinarySensor::add_filters(const std::vector<Filter *> &filters) {
     this->add_filter(filter);
   }
 }
-bool BinarySensor::has_state() const { return this->has_state_; }
 bool BinarySensor::is_status_binary_sensor() const { return false; }
 
 }  // namespace binary_sensor

esphome/components/binary_sensor/binary_sensor.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
 #include "esphome/components/binary_sensor/filter.h"
@@ -34,52 +33,39 @@ namespace binary_sensor {
  * The sub classes should notify the front-end of new states via the publish_state() method which
  * handles inverted inputs for you.
  */
-class BinarySensor : public EntityBase, public EntityBase_DeviceClass {
+class BinarySensor : public StatefulEntityBase<bool>, public EntityBase_DeviceClass {
  public:
-  explicit BinarySensor();
-
-  /** Add a callback to be notified of state changes.
-   *
-   * @param callback The void(bool) callback.
-   */
-  void add_on_state_callback(std::function<void(bool)> &&callback);
+  explicit BinarySensor(){};
 
   /** Publish a new state to the front-end.
    *
-   * @param state The new state.
+   * @param new_state The new state.
    */
-  void publish_state(bool state);
+  void publish_state(bool new_state);
 
   /** Publish the initial state, this will not make the callback manager send callbacks
    * and is meant only for the initial state on boot.
    *
-   * @param state The new state.
+   * @param new_state The new state.
    */
-  void publish_initial_state(bool state);
-
-  /// The current reported state of the binary sensor.
-  bool state{false};
+  void publish_initial_state(bool new_state);
 
   void add_filter(Filter *filter);
   void add_filters(const std::vector<Filter *> &filters);
 
-  void set_publish_initial_state(bool publish_initial_state) { this->publish_initial_state_ = publish_initial_state; }
-
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)
-  void send_state_internal(bool state, bool is_initial);
+  void send_state_internal(bool new_state);
 
   /// Return whether this binary sensor has outputted a state.
-  virtual bool has_state() const;
-
   virtual bool is_status_binary_sensor() const;
 
+  // For backward compatibility, provide an accessible property
+
+  bool state{};
+
  protected:
-  CallbackManager<void(bool)> state_callback_{};
   Filter *filter_list_{nullptr};
-  bool has_state_{false};
-  bool publish_initial_state_{false};
-  Deduplicator<bool> publish_dedup_;
 };
 
 class BinarySensorInitiallyOff : public BinarySensor {

esphome/components/binary_sensor/filter.cpp

@@ -9,37 +9,36 @@ namespace binary_sensor {
 
 static const char *const TAG = "sensor.filter";
 
-void Filter::output(bool value, bool is_initial) {
+void Filter::output(bool value) {
+  if (this->next_ == nullptr) {
+    this->parent_->send_state_internal(value);
+  } else {
+    this->next_->input(value);
+  }
+}
+void Filter::input(bool value) {
   if (!this->dedup_.next(value))
     return;
-
-  if (this->next_ == nullptr) {
-    this->parent_->send_state_internal(value, is_initial);
-  } else {
-    this->next_->input(value, is_initial);
-  }
-}
-void Filter::input(bool value, bool is_initial) {
-  auto b = this->new_value(value, is_initial);
+  auto b = this->new_value(value);
   if (b.has_value()) {
-    this->output(*b, is_initial);
+    this->output(*b);
   }
 }
 
-optional<bool> DelayedOnOffFilter::new_value(bool value, bool is_initial) {
+optional<bool> DelayedOnOffFilter::new_value(bool value) {
   if (value) {
-    this->set_timeout("ON_OFF", this->on_delay_.value(), [this, is_initial]() { this->output(true, is_initial); });
+    this->set_timeout("ON_OFF", this->on_delay_.value(), [this]() { this->output(true); });
   } else {
-    this->set_timeout("ON_OFF", this->off_delay_.value(), [this, is_initial]() { this->output(false, is_initial); });
+    this->set_timeout("ON_OFF", this->off_delay_.value(), [this]() { this->output(false); });
   }
   return {};
 }
 
 float DelayedOnOffFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-optional<bool> DelayedOnFilter::new_value(bool value, bool is_initial) {
+optional<bool> DelayedOnFilter::new_value(bool value) {
   if (value) {
-    this->set_timeout("ON", this->delay_.value(), [this, is_initial]() { this->output(true, is_initial); });
+    this->set_timeout("ON", this->delay_.value(), [this]() { this->output(true); });
     return {};
   } else {
     this->cancel_timeout("ON");
@@ -49,9 +48,9 @@ optional<bool> DelayedOnFilter::new_value(bool value, bool is_initial) {
 
 float DelayedOnFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-optional<bool> DelayedOffFilter::new_value(bool value, bool is_initial) {
+optional<bool> DelayedOffFilter::new_value(bool value) {
   if (!value) {
-    this->set_timeout("OFF", this->delay_.value(), [this, is_initial]() { this->output(false, is_initial); });
+    this->set_timeout("OFF", this->delay_.value(), [this]() { this->output(false); });
     return {};
   } else {
     this->cancel_timeout("OFF");
@@ -61,11 +60,11 @@ optional<bool> DelayedOffFilter::new_value(bool value, bool is_initial) {
 
 float DelayedOffFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-optional<bool> InvertFilter::new_value(bool value, bool is_initial) { return !value; }
+optional<bool> InvertFilter::new_value(bool value) { return !value; }
 
 AutorepeatFilter::AutorepeatFilter(std::vector<AutorepeatFilterTiming> timings) : timings_(std::move(timings)) {}
 
-optional<bool> AutorepeatFilter::new_value(bool value, bool is_initial) {
+optional<bool> AutorepeatFilter::new_value(bool value) {
   if (value) {
     // Ignore if already running
     if (this->active_timing_ != 0)
@@ -101,7 +100,7 @@ void AutorepeatFilter::next_timing_() {
 
 void AutorepeatFilter::next_value_(bool val) {
   const AutorepeatFilterTiming &timing = this->timings_[this->active_timing_ - 2];
-  this->output(val, false);  // This is at least the second one so not initial
+  this->output(val);  // This is at least the second one so not initial
   this->set_timeout("ON_OFF", val ? timing.time_on : timing.time_off, [this, val]() { this->next_value_(!val); });
 }
 
@@ -109,18 +108,18 @@ float AutorepeatFilter::get_setup_priority() const { return setup_priority::HARD
 
 LambdaFilter::LambdaFilter(std::function<optional<bool>(bool)> f) : f_(std::move(f)) {}
 
-optional<bool> LambdaFilter::new_value(bool value, bool is_initial) { return this->f_(value); }
+optional<bool> LambdaFilter::new_value(bool value) { return this->f_(value); }
 
-optional<bool> SettleFilter::new_value(bool value, bool is_initial) {
+optional<bool> SettleFilter::new_value(bool value) {
   if (!this->steady_) {
-    this->set_timeout("SETTLE", this->delay_.value(), [this, value, is_initial]() {
+    this->set_timeout("SETTLE", this->delay_.value(), [this, value]() {
       this->steady_ = true;
-      this->output(value, is_initial);
+      this->output(value);
     });
     return {};
   } else {
     this->steady_ = false;
-    this->output(value, is_initial);
+    this->output(value);
     this->set_timeout("SETTLE", this->delay_.value(), [this]() { this->steady_ = true; });
     return value;
   }

esphome/components/binary_sensor/filter.h

@@ -14,11 +14,11 @@ class BinarySensor;
 
 class Filter {
  public:
-  virtual optional<bool> new_value(bool value, bool is_initial) = 0;
+  virtual optional<bool> new_value(bool value) = 0;
 
-  void input(bool value, bool is_initial);
+  void input(bool value);
 
-  void output(bool value, bool is_initial);
+  void output(bool value);
 
  protected:
   friend BinarySensor;
@@ -30,7 +30,7 @@ class Filter {
 
 class DelayedOnOffFilter : public Filter, public Component {
  public:
-  optional<bool> new_value(bool value, bool is_initial) override;
+  optional<bool> new_value(bool value) override;
 
   float get_setup_priority() const override;
 
@@ -44,7 +44,7 @@ class DelayedOnOffFilter : public Filter, public Component {
 
 class DelayedOnFilter : public Filter, public Component {
  public:
-  optional<bool> new_value(bool value, bool is_initial) override;
+  optional<bool> new_value(bool value) override;
 
   float get_setup_priority() const override;
 
@@ -56,7 +56,7 @@ class DelayedOnFilter : public Filter, public Component {
 
 class DelayedOffFilter : public Filter, public Component {
  public:
-  optional<bool> new_value(bool value, bool is_initial) override;
+  optional<bool> new_value(bool value) override;
 
   float get_setup_priority() const override;
 
@@ -68,7 +68,7 @@ class DelayedOffFilter : public Filter, public Component {
 
 class InvertFilter : public Filter {
  public:
-  optional<bool> new_value(bool value, bool is_initial) override;
+  optional<bool> new_value(bool value) override;
 };
 
 struct AutorepeatFilterTiming {
@@ -86,7 +86,7 @@ class AutorepeatFilter : public Filter, public Component {
  public:
   explicit AutorepeatFilter(std::vector<AutorepeatFilterTiming> timings);
 
-  optional<bool> new_value(bool value, bool is_initial) override;
+  optional<bool> new_value(bool value) override;
 
   float get_setup_priority() const override;
 
@@ -102,7 +102,7 @@ class LambdaFilter : public Filter {
  public:
   explicit LambdaFilter(std::function<optional<bool>(bool)> f);
 
-  optional<bool> new_value(bool value, bool is_initial) override;
+  optional<bool> new_value(bool value) override;
 
  protected:
   std::function<optional<bool>(bool)> f_;
@@ -110,7 +110,7 @@ class LambdaFilter : public Filter {
 
 class SettleFilter : public Filter, public Component {
  public:
-  optional<bool> new_value(bool value, bool is_initial) override;
+  optional<bool> new_value(bool value) override;
 
   float get_setup_priority() const override;
 

esphome/components/bl0942/bl0942.cpp

@@ -196,14 +196,17 @@ void BL0942::received_package_(DataPacket *data) {
 }
 
 void BL0942::dump_config() {  // NOLINT(readability-function-cognitive-complexity)
-  ESP_LOGCONFIG(TAG, "BL0942:");
-  ESP_LOGCONFIG(TAG, "  Reset: %s", TRUEFALSE(this->reset_));
-  ESP_LOGCONFIG(TAG, "  Address: %d", this->address_);
-  ESP_LOGCONFIG(TAG, "  Nominal line frequency: %d Hz", this->line_freq_);
-  ESP_LOGCONFIG(TAG, "  Current reference: %f", this->current_reference_);
-  ESP_LOGCONFIG(TAG, "  Energy reference: %f", this->energy_reference_);
-  ESP_LOGCONFIG(TAG, "  Power reference: %f", this->power_reference_);
-  ESP_LOGCONFIG(TAG, "  Voltage reference: %f", this->voltage_reference_);
+  ESP_LOGCONFIG(TAG,
+                "BL0942:\n"
+                "  Reset: %s\n"
+                "  Address: %d\n"
+                "  Nominal line frequency: %d Hz\n"
+                "  Current reference: %f\n"
+                "  Energy reference: %f\n"
+                "  Power reference: %f\n"
+                "  Voltage reference: %f",
+                TRUEFALSE(this->reset_), this->address_, this->line_freq_, this->current_reference_,
+                this->energy_reference_, this->power_reference_, this->voltage_reference_);
   LOG_SENSOR("", "Voltage", this->voltage_sensor_);
   LOG_SENSOR("", "Current", this->current_sensor_);
   LOG_SENSOR("", "Power", this->power_sensor_);

esphome/components/ble_client/__init__.py

@@ -1,7 +1,8 @@
 from esphome import automation
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
-from esphome.components import esp32_ble_client, esp32_ble_tracker
+from esphome.components import esp32_ble, esp32_ble_client, esp32_ble_tracker
+from esphome.components.esp32_ble import BTLoggers
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CHARACTERISTIC_UUID,
@@ -287,6 +288,9 @@ async def remove_bond_to_code(config, action_id, template_arg, args):
 
 
 async def to_code(config):
+    # Register the loggers this component needs
+    esp32_ble.register_bt_logger(BTLoggers.GATT, BTLoggers.SMP)
+
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await esp32_ble_tracker.register_client(var, config)

esphome/components/ble_client/output/ble_binary_output.cpp

@@ -10,9 +10,12 @@ static const char *const TAG = "ble_binary_output";
 
 void BLEBinaryOutput::dump_config() {
   ESP_LOGCONFIG(TAG, "BLE Binary Output:");
-  ESP_LOGCONFIG(TAG, "  MAC address        : %s", this->parent_->address_str().c_str());
-  ESP_LOGCONFIG(TAG, "  Service UUID       : %s", this->service_uuid_.to_string().c_str());
-  ESP_LOGCONFIG(TAG, "  Characteristic UUID: %s", this->char_uuid_.to_string().c_str());
+  ESP_LOGCONFIG(TAG,
+                "  MAC address        : %s\n"
+                "  Service UUID       : %s\n"
+                "  Characteristic UUID: %s",
+                this->parent_->address_str().c_str(), this->service_uuid_.to_string().c_str(),
+                this->char_uuid_.to_string().c_str());
   LOG_BINARY_OUTPUT(this);
 }
 

esphome/components/ble_client/sensor/ble_sensor.cpp

@@ -1,7 +1,7 @@
 #include "ble_sensor.h"
-#include "esphome/core/log.h"
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 
 #ifdef USE_ESP32
@@ -15,11 +15,14 @@ void BLESensor::loop() {}
 
 void BLESensor::dump_config() {
   LOG_SENSOR("", "BLE Sensor", this);
-  ESP_LOGCONFIG(TAG, "  MAC address        : %s", this->parent()->address_str().c_str());
-  ESP_LOGCONFIG(TAG, "  Service UUID       : %s", this->service_uuid_.to_string().c_str());
-  ESP_LOGCONFIG(TAG, "  Characteristic UUID: %s", this->char_uuid_.to_string().c_str());
-  ESP_LOGCONFIG(TAG, "  Descriptor UUID    : %s", this->descr_uuid_.to_string().c_str());
-  ESP_LOGCONFIG(TAG, "  Notifications      : %s", YESNO(this->notify_));
+  ESP_LOGCONFIG(TAG,
+                "  MAC address        : %s\n"
+                "  Service UUID       : %s\n"
+                "  Characteristic UUID: %s\n"
+                "  Descriptor UUID    : %s\n"
+                "  Notifications      : %s",
+                this->parent()->address_str().c_str(), this->service_uuid_.to_string().c_str(),
+                this->char_uuid_.to_string().c_str(), this->descr_uuid_.to_string().c_str(), YESNO(this->notify_));
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/ble_client/text_sensor/ble_text_sensor.cpp

@@ -18,11 +18,14 @@ void BLETextSensor::loop() {}
 
 void BLETextSensor::dump_config() {
   LOG_TEXT_SENSOR("", "BLE Text Sensor", this);
-  ESP_LOGCONFIG(TAG, "  MAC address        : %s", this->parent()->address_str().c_str());
-  ESP_LOGCONFIG(TAG, "  Service UUID       : %s", this->service_uuid_.to_string().c_str());
-  ESP_LOGCONFIG(TAG, "  Characteristic UUID: %s", this->char_uuid_.to_string().c_str());
-  ESP_LOGCONFIG(TAG, "  Descriptor UUID    : %s", this->descr_uuid_.to_string().c_str());
-  ESP_LOGCONFIG(TAG, "  Notifications      : %s", YESNO(this->notify_));
+  ESP_LOGCONFIG(TAG,
+                "  MAC address        : %s\n"
+                "  Service UUID       : %s\n"
+                "  Characteristic UUID: %s\n"
+                "  Descriptor UUID    : %s\n"
+                "  Notifications      : %s",
+                this->parent()->address_str().c_str(), this->service_uuid_.to_string().c_str(),
+                this->char_uuid_.to_string().c_str(), this->descr_uuid_.to_string().c_str(), YESNO(this->notify_));
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/bluetooth_proxy/__init__.py

@@ -1,6 +1,7 @@
 import esphome.codegen as cg
-from esphome.components import esp32_ble_client, esp32_ble_tracker
+from esphome.components import esp32_ble, esp32_ble_client, esp32_ble_tracker
 from esphome.components.esp32 import add_idf_sdkconfig_option
+from esphome.components.esp32_ble import BTLoggers
 import esphome.config_validation as cv
 from esphome.const import CONF_ACTIVE, CONF_ID
 
@@ -77,6 +78,9 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
+    # Register the loggers this component needs
+    esp32_ble.register_bt_logger(BTLoggers.GATT, BTLoggers.L2CAP, BTLoggers.SMP)
+
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 

esphome/components/bluetooth_proxy/bluetooth_proxy.cpp

@@ -58,7 +58,7 @@ static std::vector<api::BluetoothLERawAdvertisement> &get_batch_buffer() {
   return batch_buffer;
 }
 
-bool BluetoothProxy::parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_param *advertisements, size_t count) {
+bool BluetoothProxy::parse_devices(const esp32_ble::BLEScanResult *scan_results, size_t count) {
   if (!api::global_api_server->is_connected() || this->api_connection_ == nullptr || !this->raw_advertisements_)
     return false;
 
@@ -73,7 +73,7 @@ bool BluetoothProxy::parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_p
 
   // Add new advertisements to the batch buffer
   for (size_t i = 0; i < count; i++) {
-    auto &result = advertisements[i];
+    auto &result = scan_results[i];
     uint8_t length = result.adv_data_len + result.scan_rsp_len;
 
     batch_buffer.emplace_back();
@@ -146,9 +146,11 @@ void BluetoothProxy::send_api_packet_(const esp32_ble_tracker::ESPBTDevice &devi
 
 void BluetoothProxy::dump_config() {
   ESP_LOGCONFIG(TAG, "Bluetooth Proxy:");
-  ESP_LOGCONFIG(TAG, "  Active: %s", YESNO(this->active_));
-  ESP_LOGCONFIG(TAG, "  Connections: %d", this->connections_.size());
-  ESP_LOGCONFIG(TAG, "  Raw advertisements: %s", YESNO(this->raw_advertisements_));
+  ESP_LOGCONFIG(TAG,
+                "  Active: %s\n"
+                "  Connections: %d\n"
+                "  Raw advertisements: %s",
+                YESNO(this->active_), this->connections_.size(), YESNO(this->raw_advertisements_));
 }
 
 int BluetoothProxy::get_bluetooth_connections_free() {

esphome/components/bluetooth_proxy/bluetooth_proxy.h

@@ -52,7 +52,7 @@ class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Com
  public:
   BluetoothProxy();
   bool parse_device(const esp32_ble_tracker::ESPBTDevice &device) override;
-  bool parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_param *advertisements, size_t count) override;
+  bool parse_devices(const esp32_ble::BLEScanResult *scan_results, size_t count) override;
   void dump_config() override;
   void setup() override;
   void loop() override;

esphome/components/bme680_bsec/bme680_bsec.cpp

@@ -1,6 +1,6 @@
 #include "bme680_bsec.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include <string>
 
 namespace esphome {
@@ -159,11 +159,15 @@ void BME680BSECComponent::dump_config() {
              this->bme680_status_);
   }
 
-  ESP_LOGCONFIG(TAG, "  Temperature Offset: %.2f", this->temperature_offset_);
-  ESP_LOGCONFIG(TAG, "  IAQ Mode: %s", this->iaq_mode_ == IAQ_MODE_STATIC ? "Static" : "Mobile");
-  ESP_LOGCONFIG(TAG, "  Supply Voltage: %sV", this->supply_voltage_ == SUPPLY_VOLTAGE_3V3 ? "3.3" : "1.8");
-  ESP_LOGCONFIG(TAG, "  Sample Rate: %s", BME680_BSEC_SAMPLE_RATE_LOG(this->sample_rate_));
-  ESP_LOGCONFIG(TAG, "  State Save Interval: %ims", this->state_save_interval_ms_);
+  ESP_LOGCONFIG(TAG,
+                "  Temperature Offset: %.2f\n"
+                "  IAQ Mode: %s\n"
+                "  Supply Voltage: %sV\n"
+                "  Sample Rate: %s\n"
+                "  State Save Interval: %ims",
+                this->temperature_offset_, this->iaq_mode_ == IAQ_MODE_STATIC ? "Static" : "Mobile",
+                this->supply_voltage_ == SUPPLY_VOLTAGE_3V3 ? "3.3" : "1.8",
+                BME680_BSEC_SAMPLE_RATE_LOG(this->sample_rate_), this->state_save_interval_ms_);
 
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   ESP_LOGCONFIG(TAG, "    Sample Rate: %s", BME680_BSEC_SAMPLE_RATE_LOG(this->temperature_sample_rate_));

esphome/components/bme68x_bsec2/bme68x_bsec2.cpp

@@ -58,13 +58,13 @@ void BME68xBSEC2Component::setup() {
 }
 
 void BME68xBSEC2Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "BME68X via BSEC2:");
-
-  ESP_LOGCONFIG(TAG, "  BSEC2 version: %d.%d.%d.%d", this->version_.major, this->version_.minor,
-                this->version_.major_bugfix, this->version_.minor_bugfix);
-
-  ESP_LOGCONFIG(TAG, "  BSEC2 configuration blob:");
-  ESP_LOGCONFIG(TAG, "    Configured: %s", YESNO(this->bsec2_blob_configured_));
+  ESP_LOGCONFIG(TAG,
+                "BME68X via BSEC2:\n"
+                "  BSEC2 version: %d.%d.%d.%d\n"
+                "  BSEC2 configuration blob:\n"
+                "    Configured: %s",
+                this->version_.major, this->version_.minor, this->version_.major_bugfix, this->version_.minor_bugfix,
+                YESNO(this->bsec2_blob_configured_));
   if (this->bsec2_configuration_ != nullptr && this->bsec2_configuration_length_) {
     ESP_LOGCONFIG(TAG, "    Size: %" PRIu32, this->bsec2_configuration_length_);
   }
@@ -77,11 +77,14 @@ void BME68xBSEC2Component::dump_config() {
   if (this->algorithm_output_ != ALGORITHM_OUTPUT_IAQ) {
     ESP_LOGCONFIG(TAG, "  Algorithm output: %s", BME68X_BSEC2_ALGORITHM_OUTPUT_LOG(this->algorithm_output_));
   }
-  ESP_LOGCONFIG(TAG, "  Operating age: %s", BME68X_BSEC2_OPERATING_AGE_LOG(this->operating_age_));
-  ESP_LOGCONFIG(TAG, "  Sample rate: %s", BME68X_BSEC2_SAMPLE_RATE_LOG(this->sample_rate_));
-  ESP_LOGCONFIG(TAG, "  Voltage: %s", BME68X_BSEC2_VOLTAGE_LOG(this->voltage_));
-  ESP_LOGCONFIG(TAG, "  State save interval: %ims", this->state_save_interval_ms_);
-  ESP_LOGCONFIG(TAG, "  Temperature offset: %.2f", this->temperature_offset_);
+  ESP_LOGCONFIG(TAG,
+                "  Operating age: %s\n"
+                "  Sample rate: %s\n"
+                "  Voltage: %s\n"
+                "  State save interval: %ims\n"
+                "  Temperature offset: %.2f",
+                BME68X_BSEC2_OPERATING_AGE_LOG(this->operating_age_), BME68X_BSEC2_SAMPLE_RATE_LOG(this->sample_rate_),
+                BME68X_BSEC2_VOLTAGE_LOG(this->voltage_), this->state_save_interval_ms_, this->temperature_offset_);
 
 #ifdef USE_SENSOR
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);

esphome/components/bmp3xx_base/bmp3xx_base.cpp

@@ -148,8 +148,10 @@ void BMP3XXComponent::setup() {
 }
 
 void BMP3XXComponent::dump_config() {
-  ESP_LOGCONFIG(TAG, "BMP3XX:");
-  ESP_LOGCONFIG(TAG, "  Type: %s (0x%X)", LOG_STR_ARG(chip_type_to_str(this->chip_id_.reg)), this->chip_id_.reg);
+  ESP_LOGCONFIG(TAG,
+                "BMP3XX:\n"
+                "  Type: %s (0x%X)",
+                LOG_STR_ARG(chip_type_to_str(this->chip_id_.reg)), this->chip_id_.reg);
   switch (this->error_code_) {
     case NONE:
       break;

esphome/components/bmp581/bmp581.cpp

@@ -98,14 +98,20 @@ void BMP581Component::dump_config() {
 
   if (this->temperature_sensor_) {
     LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
-    ESP_LOGCONFIG(TAG, "    IIR Filter: %s", LOG_STR_ARG(iir_filter_to_str(this->iir_temperature_level_)));
-    ESP_LOGCONFIG(TAG, "    Oversampling: %s", LOG_STR_ARG(oversampling_to_str(this->temperature_oversampling_)));
+    ESP_LOGCONFIG(TAG,
+                  "    IIR Filter: %s\n"
+                  "    Oversampling: %s",
+                  LOG_STR_ARG(iir_filter_to_str(this->iir_temperature_level_)),
+                  LOG_STR_ARG(oversampling_to_str(this->temperature_oversampling_)));
   }
 
   if (this->pressure_sensor_) {
     LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
-    ESP_LOGCONFIG(TAG, "    IIR Filter: %s", LOG_STR_ARG(iir_filter_to_str(this->iir_pressure_level_)));
-    ESP_LOGCONFIG(TAG, "    Oversampling: %s", LOG_STR_ARG(oversampling_to_str(this->pressure_oversampling_)));
+    ESP_LOGCONFIG(TAG,
+                  "    IIR Filter: %s\n"
+                  "    Oversampling: %s",
+                  LOG_STR_ARG(iir_filter_to_str(this->iir_pressure_level_)),
+                  LOG_STR_ARG(oversampling_to_str(this->pressure_oversampling_)));
   }
 }
 

esphome/components/bp1658cj/bp1658cj.cpp

@@ -26,8 +26,10 @@ void BP1658CJ::dump_config() {
   ESP_LOGCONFIG(TAG, "BP1658CJ:");
   LOG_PIN("  Data Pin: ", this->data_pin_);
   LOG_PIN("  Clock Pin: ", this->clock_pin_);
-  ESP_LOGCONFIG(TAG, "  Color Channels Max Power: %u", this->max_power_color_channels_);
-  ESP_LOGCONFIG(TAG, "  White Channels Max Power: %u", this->max_power_white_channels_);
+  ESP_LOGCONFIG(TAG,
+                "  Color Channels Max Power: %u\n"
+                "  White Channels Max Power: %u",
+                this->max_power_color_channels_, this->max_power_white_channels_);
 }
 
 void BP1658CJ::loop() {

esphome/components/button/__init__.py

@@ -108,6 +108,7 @@ async def register_button(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_button(var))
+    CORE.register_platform_component("button", var)
     await setup_button_core_(var, config)
 
 

esphome/components/cap1188/cap1188.cpp

@@ -52,9 +52,11 @@ void CAP1188Component::dump_config() {
   ESP_LOGCONFIG(TAG, "CAP1188:");
   LOG_I2C_DEVICE(this);
   LOG_PIN("  Reset Pin: ", this->reset_pin_);
-  ESP_LOGCONFIG(TAG, "  Product ID: 0x%x", this->cap1188_product_id_);
-  ESP_LOGCONFIG(TAG, "  Manufacture ID: 0x%x", this->cap1188_manufacture_id_);
-  ESP_LOGCONFIG(TAG, "  Revision ID: 0x%x", this->cap1188_revision_);
+  ESP_LOGCONFIG(TAG,
+                "  Product ID: 0x%x\n"
+                "  Manufacture ID: 0x%x\n"
+                "  Revision ID: 0x%x",
+                this->cap1188_product_id_, this->cap1188_manufacture_id_, this->cap1188_revision_);
 
   switch (this->error_code_) {
     case COMMUNICATION_FAILED:

esphome/components/ccs811/ccs811.cpp

@@ -1,6 +1,7 @@
 #include "ccs811.h"
-#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace ccs811 {

esphome/components/chsc6x/chsc6x_touchscreen.cpp

@@ -38,9 +38,11 @@ void CHSC6XTouchscreen::dump_config() {
   ESP_LOGCONFIG(TAG, "CHSC6X Touchscreen:");
   LOG_I2C_DEVICE(this);
   LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
-  ESP_LOGCONFIG(TAG, "  Touch timeout: %d", this->touch_timeout_);
-  ESP_LOGCONFIG(TAG, "  x_raw_max_: %d", this->x_raw_max_);
-  ESP_LOGCONFIG(TAG, "  y_raw_max_: %d", this->y_raw_max_);
+  ESP_LOGCONFIG(TAG,
+                "  Touch timeout: %d\n"
+                "  x_raw_max_: %d\n"
+                "  y_raw_max_: %d",
+                this->touch_timeout_, this->x_raw_max_, this->y_raw_max_);
 }
 
 }  // namespace chsc6x

esphome/components/climate/__init__.py

@@ -443,6 +443,7 @@ async def register_climate(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_climate(var))
+    CORE.register_platform_component("climate", var)
     await setup_climate_core_(var, config)
 
 

esphome/components/climate/climate.cpp

@@ -569,17 +569,22 @@ bool Climate::set_custom_preset_(const std::string &preset) {
 void Climate::dump_traits_(const char *tag) {
   auto traits = this->get_traits();
   ESP_LOGCONFIG(tag, "ClimateTraits:");
-  ESP_LOGCONFIG(tag, "  [x] Visual settings:");
-  ESP_LOGCONFIG(tag, "      - Min temperature: %.1f", traits.get_visual_min_temperature());
-  ESP_LOGCONFIG(tag, "      - Max temperature: %.1f", traits.get_visual_max_temperature());
-  ESP_LOGCONFIG(tag, "      - Temperature step:");
-  ESP_LOGCONFIG(tag, "          Target: %.1f", traits.get_visual_target_temperature_step());
+  ESP_LOGCONFIG(tag,
+                "  [x] Visual settings:\n"
+                "      - Min temperature: %.1f\n"
+                "      - Max temperature: %.1f\n"
+                "      - Temperature step:\n"
+                "          Target: %.1f",
+                traits.get_visual_min_temperature(), traits.get_visual_max_temperature(),
+                traits.get_visual_target_temperature_step());
   if (traits.get_supports_current_temperature()) {
     ESP_LOGCONFIG(tag, "          Current: %.1f", traits.get_visual_current_temperature_step());
   }
   if (traits.get_supports_target_humidity() || traits.get_supports_current_humidity()) {
-    ESP_LOGCONFIG(tag, "      - Min humidity: %.0f", traits.get_visual_min_humidity());
-    ESP_LOGCONFIG(tag, "      - Max humidity: %.0f", traits.get_visual_max_humidity());
+    ESP_LOGCONFIG(tag,
+                  "      - Min humidity: %.0f\n"
+                  "      - Max humidity: %.0f",
+                  traits.get_visual_min_humidity(), traits.get_visual_max_humidity());
   }
   if (traits.get_supports_two_point_target_temperature()) {
     ESP_LOGCONFIG(tag, "  [x] Supports two-point target temperature");

esphome/components/climate/climate.h

@@ -3,8 +3,8 @@
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/preferences.h"
 #include "esphome/core/log.h"
+#include "esphome/core/preferences.h"
 #include "climate_mode.h"
 #include "climate_traits.h"
 

esphome/components/climate_ir/climate_ir.cpp

@@ -75,10 +75,13 @@ void ClimateIR::control(const climate::ClimateCall &call) {
 }
 void ClimateIR::dump_config() {
   LOG_CLIMATE("", "IR Climate", this);
-  ESP_LOGCONFIG(TAG, "  Min. Temperature: %.1f°C", this->minimum_temperature_);
-  ESP_LOGCONFIG(TAG, "  Max. Temperature: %.1f°C", this->maximum_temperature_);
-  ESP_LOGCONFIG(TAG, "  Supports HEAT: %s", YESNO(this->supports_heat_));
-  ESP_LOGCONFIG(TAG, "  Supports COOL: %s", YESNO(this->supports_cool_));
+  ESP_LOGCONFIG(TAG,
+                "  Min. Temperature: %.1f°C\n"
+                "  Max. Temperature: %.1f°C\n"
+                "  Supports HEAT: %s\n"
+                "  Supports COOL: %s",
+                this->minimum_temperature_, this->maximum_temperature_, YESNO(this->supports_heat_),
+                YESNO(this->supports_cool_));
 }
 
 }  // namespace climate_ir

esphome/components/const/__init__.py

@@ -3,4 +3,5 @@
 CODEOWNERS = ["@esphome/core"]
 
 CONF_DRAW_ROUNDING = "draw_rounding"
+CONF_ON_STATE_CHANGE = "on_state_change"
 CONF_REQUEST_HEADERS = "request_headers"

esphome/components/cover/__init__.py

@@ -189,6 +189,7 @@ async def register_cover(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_cover(var))
+    CORE.register_platform_component("cover", var)
     await setup_cover_core_(var, config)
 
 

esphome/components/cs5460a/cs5460a.cpp

@@ -319,18 +319,23 @@ bool CS5460AComponent::check_status_() {
 void CS5460AComponent::dump_config() {
   uint32_t state = this->get_component_state();
 
-  ESP_LOGCONFIG(TAG, "CS5460A:");
-  ESP_LOGCONFIG(TAG, "  Init status: %s",
+  ESP_LOGCONFIG(TAG,
+                "CS5460A:\n"
+                "  Init status: %s",
                 state == COMPONENT_STATE_LOOP ? "OK" : (state == COMPONENT_STATE_FAILED ? "failed" : "other"));
   LOG_PIN("  CS Pin: ", cs_);
-  ESP_LOGCONFIG(TAG, "  Samples / cycle: %" PRIu32, samples_);
-  ESP_LOGCONFIG(TAG, "  Phase offset: %i", phase_offset_);
-  ESP_LOGCONFIG(TAG, "  PGA Gain: %s", pga_gain_ == CS5460A_PGA_GAIN_50X ? "50x" : "10x");
-  ESP_LOGCONFIG(TAG, "  Current gain: %.5f", current_gain_);
-  ESP_LOGCONFIG(TAG, "  Voltage gain: %.5f", voltage_gain_);
-  ESP_LOGCONFIG(TAG, "  Current HPF: %s", current_hpf_ ? "enabled" : "disabled");
-  ESP_LOGCONFIG(TAG, "  Voltage HPF: %s", voltage_hpf_ ? "enabled" : "disabled");
-  ESP_LOGCONFIG(TAG, "  Pulse energy: %.2f Wh", pulse_energy_wh_);
+  ESP_LOGCONFIG(TAG,
+                "  Samples / cycle: %" PRIu32 "\n"
+                "  Phase offset: %i\n"
+                "  PGA Gain: %s\n"
+                "  Current gain: %.5f\n"
+                "  Voltage gain: %.5f\n"
+                "  Current HPF: %s\n"
+                "  Voltage HPF: %s\n"
+                "  Pulse energy: %.2f Wh",
+                samples_, phase_offset_, pga_gain_ == CS5460A_PGA_GAIN_50X ? "50x" : "10x", current_gain_,
+                voltage_gain_, current_hpf_ ? "enabled" : "disabled", voltage_hpf_ ? "enabled" : "disabled",
+                pulse_energy_wh_);
   LOG_SENSOR("  ", "Voltage", voltage_sensor_);
   LOG_SENSOR("  ", "Current", current_sensor_);
   LOG_SENSOR("  ", "Power", power_sensor_);

esphome/components/cse7766/cse7766.cpp

@@ -223,11 +223,6 @@ void CSE7766Component::parse_data_() {
 #endif
 }
 
-uint32_t CSE7766Component::get_24_bit_uint_(uint8_t start_index) {
-  return (uint32_t(this->raw_data_[start_index]) << 16) | (uint32_t(this->raw_data_[start_index + 1]) << 8) |
-         uint32_t(this->raw_data_[start_index + 2]);
-}
-
 void CSE7766Component::dump_config() {
   ESP_LOGCONFIG(TAG, "CSE7766:");
   LOG_SENSOR("  ", "Voltage", this->voltage_sensor_);

esphome/components/cse7766/cse7766.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/uart/uart.h"
 
@@ -28,7 +29,10 @@ class CSE7766Component : public Component, public uart::UARTDevice {
  protected:
   bool check_byte_();
   void parse_data_();
-  uint32_t get_24_bit_uint_(uint8_t start_index);
+  uint32_t get_24_bit_uint_(uint8_t start_index) const {
+    return encode_uint24(this->raw_data_[start_index], this->raw_data_[start_index + 1],
+                         this->raw_data_[start_index + 2]);
+  }
 
   uint8_t raw_data_[24];
   uint8_t raw_data_index_{0};

esphome/components/cst816/touchscreen/cst816_touchscreen.cpp

@@ -1,4 +1,5 @@
 #include "cst816_touchscreen.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace cst816 {
@@ -74,8 +75,10 @@ void CST816Touchscreen::dump_config() {
   LOG_I2C_DEVICE(this);
   LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
   LOG_PIN("  Reset Pin: ", this->reset_pin_);
-  ESP_LOGCONFIG(TAG, "  X Raw Min: %d, X Raw Max: %d", this->x_raw_min_, this->x_raw_max_);
-  ESP_LOGCONFIG(TAG, "  Y Raw Min: %d, Y Raw Max: %d", this->y_raw_min_, this->y_raw_max_);
+  ESP_LOGCONFIG(TAG,
+                "  X Raw Min: %d, X Raw Max: %d\n"
+                "  Y Raw Min: %d, Y Raw Max: %d",
+                this->x_raw_min_, this->x_raw_max_, this->y_raw_min_, this->y_raw_max_);
   const char *name;
   switch (this->chip_id_) {
     case CST820_CHIP_ID:

esphome/components/current_based/current_based_cover.cpp

@@ -151,8 +151,10 @@ void CurrentBasedCover::dump_config() {
   if (this->max_duration_ != UINT32_MAX) {
     ESP_LOGCONFIG(TAG, "Maximum duration: %.1fs", this->max_duration_ / 1e3f);
   }
-  ESP_LOGCONFIG(TAG, "Start sensing delay: %.1fs", this->start_sensing_delay_ / 1e3f);
-  ESP_LOGCONFIG(TAG, "Malfunction detection: %s", YESNO(this->malfunction_detection_));
+  ESP_LOGCONFIG(TAG,
+                "Start sensing delay: %.1fs\n"
+                "Malfunction detection: %s",
+                this->start_sensing_delay_ / 1e3f, YESNO(this->malfunction_detection_));
 }
 
 float CurrentBasedCover::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/dac7678/dac7678_output.cpp

@@ -1,7 +1,7 @@
 #include "dac7678_output.h"
-#include "esphome/core/log.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace dac7678 {

esphome/components/daly_bms/daly_bms.cpp

@@ -1,7 +1,8 @@
 #include "daly_bms.h"
 #include <vector>
-#include "esphome/core/log.h"
 #include "esphome/core/application.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace daly_bms {

esphome/components/datetime/__init__.py

@@ -158,7 +158,9 @@ async def setup_datetime_core_(var, config):
 async def register_datetime(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
-    cg.add(getattr(cg.App, f"register_{config[CONF_TYPE].lower()}")(var))
+    entity_type = config[CONF_TYPE].lower()
+    cg.add(getattr(cg.App, f"register_{entity_type}")(var))
+    CORE.register_platform_component(entity_type, var)
     await setup_datetime_core_(var, config)
     cg.add_define(f"USE_DATETIME_{config[CONF_TYPE]}")
 

esphome/components/debug/debug_component.cpp

@@ -2,9 +2,9 @@
 
 #include <algorithm>
 #include "esphome/core/application.h"
-#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 #include "esphome/core/version.h"
 #include <cinttypes>
 #include <climits>

esphome/components/debug/debug_component.h

@@ -2,8 +2,8 @@
 
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
-#include "esphome/core/macros.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/macros.h"
 
 #ifdef USE_SENSOR
 #include "esphome/components/sensor/sensor.h"

esphome/components/debug/debug_esp32.cpp

@@ -107,8 +107,10 @@ std::string DebugComponent::get_wakeup_cause_() {
 }
 
 void DebugComponent::log_partition_info_() {
-  ESP_LOGCONFIG(TAG, "Partition table:");
-  ESP_LOGCONFIG(TAG, "  %-12s %-4s %-8s %-10s %-10s", "Name", "Type", "Subtype", "Address", "Size");
+  ESP_LOGCONFIG(TAG,
+                "Partition table:\n"
+                "  %-12s %-4s %-8s %-10s %-10s",
+                "Name", "Type", "Subtype", "Address", "Size");
   esp_partition_iterator_t it = esp_partition_find(ESP_PARTITION_TYPE_ANY, ESP_PARTITION_SUBTYPE_ANY, NULL);
   while (it != NULL) {
     const esp_partition_t *partition = esp_partition_get(it);

esphome/components/deep_sleep/deep_sleep_component.cpp

@@ -6,6 +6,8 @@ namespace esphome {
 namespace deep_sleep {
 
 static const char *const TAG = "deep_sleep";
+// 5 seconds for deep sleep to ensure clean disconnect from Home Assistant
+static const uint32_t TEARDOWN_TIMEOUT_DEEP_SLEEP_MS = 5000;
 
 bool global_has_deep_sleep = false;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
@@ -62,6 +64,10 @@ void DeepSleepComponent::begin_sleep(bool manual) {
     ESP_LOGI(TAG, "Sleeping for %" PRId64 "us", *this->sleep_duration_);
   }
   App.run_safe_shutdown_hooks();
+  // It's critical to teardown components cleanly for deep sleep to ensure
+  // Home Assistant sees a clean disconnect instead of marking the device unavailable
+  App.teardown_components(TEARDOWN_TIMEOUT_DEEP_SLEEP_MS);
+  App.run_powerdown_hooks();
 
   this->deep_sleep_();
 }

esphome/components/deep_sleep/deep_sleep_esp32.cpp

@@ -46,10 +46,12 @@ void DeepSleepComponent::dump_config_platform_() {
     LOG_PIN("  Wakeup Pin: ", this->wakeup_pin_);
   }
   if (this->wakeup_cause_to_run_duration_.has_value()) {
-    ESP_LOGCONFIG(TAG, "  Default Wakeup Run Duration: %" PRIu32 " ms",
-                  this->wakeup_cause_to_run_duration_->default_cause);
-    ESP_LOGCONFIG(TAG, "  Touch Wakeup Run Duration: %" PRIu32 " ms", this->wakeup_cause_to_run_duration_->touch_cause);
-    ESP_LOGCONFIG(TAG, "  GPIO Wakeup Run Duration: %" PRIu32 " ms", this->wakeup_cause_to_run_duration_->gpio_cause);
+    ESP_LOGCONFIG(TAG,
+                  "  Default Wakeup Run Duration: %" PRIu32 " ms\n"
+                  "  Touch Wakeup Run Duration: %" PRIu32 " ms\n"
+                  "  GPIO Wakeup Run Duration: %" PRIu32 " ms",
+                  this->wakeup_cause_to_run_duration_->default_cause, this->wakeup_cause_to_run_duration_->touch_cause,
+                  this->wakeup_cause_to_run_duration_->gpio_cause);
   }
 }
 

esphome/components/dht/dht.cpp

@@ -1,6 +1,6 @@
 #include "dht.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace dht {

esphome/components/display/display.h

@@ -182,9 +182,11 @@ using display_writer_t = std::function<void(Display &)>;
 
 #define LOG_DISPLAY(prefix, type, obj) \
   if ((obj) != nullptr) { \
-    ESP_LOGCONFIG(TAG, prefix type); \
-    ESP_LOGCONFIG(TAG, "%s  Rotations: %d °", prefix, (obj)->rotation_); \
-    ESP_LOGCONFIG(TAG, "%s  Dimensions: %dpx x %dpx", prefix, (obj)->get_width(), (obj)->get_height()); \
+    ESP_LOGCONFIG(TAG, \
+                  prefix type "\n" \
+                              "%s  Rotations: %d °\n" \
+                              "%s  Dimensions: %dpx x %dpx", \
+                  prefix, (obj)->rotation_, prefix, (obj)->get_width(), (obj)->get_height()); \
   }
 
 /// Turn the pixel OFF.

esphome/components/dps310/dps310.cpp

@@ -86,9 +86,11 @@ void DPS310Component::setup() {
 }
 
 void DPS310Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "DPS310:");
-  ESP_LOGCONFIG(TAG, "  Product ID: %u", this->prod_rev_id_ & 0x0F);
-  ESP_LOGCONFIG(TAG, "  Revision ID: %u", (this->prod_rev_id_ >> 4) & 0x0F);
+  ESP_LOGCONFIG(TAG,
+                "DPS310:\n"
+                "  Product ID: %u\n"
+                "  Revision ID: %u",
+                this->prod_rev_id_ & 0x0F, (this->prod_rev_id_ >> 4) & 0x0F);
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);

esphome/components/dsmr/dsmr.cpp

@@ -278,9 +278,11 @@ bool Dsmr::parse_telegram() {
 }
 
 void Dsmr::dump_config() {
-  ESP_LOGCONFIG(TAG, "DSMR:");
-  ESP_LOGCONFIG(TAG, "  Max telegram length: %d", this->max_telegram_len_);
-  ESP_LOGCONFIG(TAG, "  Receive timeout: %.1fs", this->receive_timeout_ / 1e3f);
+  ESP_LOGCONFIG(TAG,
+                "DSMR:\n"
+                "  Max telegram length: %d\n"
+                "  Receive timeout: %.1fs",
+                this->max_telegram_len_, this->receive_timeout_ / 1e3f);
   if (this->request_pin_ != nullptr) {
     LOG_PIN("  Request Pin: ", this->request_pin_);
   }

esphome/components/duty_cycle/duty_cycle_sensor.cpp

@@ -1,6 +1,6 @@
 #include "duty_cycle_sensor.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace duty_cycle {

esphome/components/duty_time/duty_time_sensor.cpp

@@ -94,9 +94,11 @@ void DutyTimeSensor::publish_and_save_(const uint32_t sec, const uint32_t ms) {
 }
 
 void DutyTimeSensor::dump_config() {
-  ESP_LOGCONFIG(TAG, "Duty Time:");
-  ESP_LOGCONFIG(TAG, "  Update Interval: %" PRId32 "ms", this->get_update_interval());
-  ESP_LOGCONFIG(TAG, "  Restore: %s", ONOFF(this->restore_));
+  ESP_LOGCONFIG(TAG,
+                "Duty Time:\n"
+                "  Update Interval: %" PRId32 "ms\n"
+                "  Restore: %s",
+                this->get_update_interval(), ONOFF(this->restore_));
   LOG_SENSOR("  ", "Duty Time Sensor:", this);
   LOG_SENSOR("  ", "Last Duty Time Sensor:", this->last_duty_time_sensor_);
 }

esphome/components/ee895/ee895.cpp

@@ -1,6 +1,6 @@
 #include "ee895.h"
-#include "esphome/core/log.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome {
 namespace ee895 {

esphome/components/emc2101/emc2101.cpp

@@ -100,8 +100,10 @@ void Emc2101Component::dump_config() {
   if (this->dac_mode_) {
     ESP_LOGCONFIG(TAG, "  DAC Conversion Rate: %X", this->dac_conversion_rate_);
   } else {
-    ESP_LOGCONFIG(TAG, "  PWM Resolution: %02X", this->pwm_resolution_);
-    ESP_LOGCONFIG(TAG, "  PWM Divider: %02X", this->pwm_divider_);
+    ESP_LOGCONFIG(TAG,
+                  "  PWM Resolution: %02X\n"
+                  "  PWM Divider: %02X",
+                  this->pwm_resolution_, this->pwm_divider_);
   }
   ESP_LOGCONFIG(TAG, "  Inverted: %s", YESNO(this->inverted_));
 }

esphome/components/es7210/es7210.cpp

@@ -25,9 +25,11 @@ static const size_t MCLK_DIV_FRE = 256;
   }
 
 void ES7210::dump_config() {
-  ESP_LOGCONFIG(TAG, "ES7210 audio ADC:");
-  ESP_LOGCONFIG(TAG, "  Bits Per Sample: %" PRIu8, this->bits_per_sample_);
-  ESP_LOGCONFIG(TAG, "  Sample Rate: %" PRIu32, this->sample_rate_);
+  ESP_LOGCONFIG(TAG,
+                "ES7210 audio ADC:\n"
+                "  Bits Per Sample: %" PRIu8 "\n"
+                "  Sample Rate: %" PRIu32,
+                this->bits_per_sample_, this->sample_rate_);
 
   if (this->is_failed()) {
     ESP_LOGE(TAG, "  Failed to initialize");

esphome/components/es8311/es8311.cpp

@@ -52,11 +52,13 @@ void ES8311::setup() {
 }
 
 void ES8311::dump_config() {
-  ESP_LOGCONFIG(TAG, "ES8311 Audio Codec:");
-  ESP_LOGCONFIG(TAG, "  Use MCLK: %s", YESNO(this->use_mclk_));
-  ESP_LOGCONFIG(TAG, "  Use Microphone: %s", YESNO(this->use_mic_));
-  ESP_LOGCONFIG(TAG, "  DAC Bits per Sample: %" PRIu8, this->resolution_out_);
-  ESP_LOGCONFIG(TAG, "  Sample Rate: %" PRIu32, this->sample_frequency_);
+  ESP_LOGCONFIG(TAG,
+                "ES8311 Audio Codec:\n"
+                "  Use MCLK: %s\n"
+                "  Use Microphone: %s\n"
+                "  DAC Bits per Sample: %" PRIu8 "\n"
+                "  Sample Rate: %" PRIu32,
+                YESNO(this->use_mclk_), YESNO(this->use_mic_), this->resolution_out_, this->sample_frequency_);
 
   if (this->is_failed()) {
     ESP_LOGCONFIG(TAG, "  Failed to initialize!");

esphome/components/esp32/__init__.py

@@ -71,12 +71,28 @@ from .const import (  # noqa
 from .gpio import esp32_pin_to_code  # noqa
 
 _LOGGER = logging.getLogger(__name__)
-CODEOWNERS = ["@esphome/core"]
 AUTO_LOAD = ["preferences"]
+CODEOWNERS = ["@esphome/core"]
 IS_TARGET_PLATFORM = True
 
-CONF_RELEASE = "release"
+CONF_ASSERTION_LEVEL = "assertion_level"
+CONF_COMPILER_OPTIMIZATION = "compiler_optimization"
 CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES = "enable_idf_experimental_features"
+CONF_ENABLE_LWIP_ASSERT = "enable_lwip_assert"
+CONF_RELEASE = "release"
+
+ASSERTION_LEVELS = {
+    "DISABLE": "CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_DISABLE",
+    "ENABLE": "CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE",
+    "SILENT": "CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT",
+}
+
+COMPILER_OPTIMIZATIONS = {
+    "DEBUG": "CONFIG_COMPILER_OPTIMIZATION_DEBUG",
+    "NONE": "CONFIG_COMPILER_OPTIMIZATION_NONE",
+    "PERF": "CONFIG_COMPILER_OPTIMIZATION_PERF",
+    "SIZE": "CONFIG_COMPILER_OPTIMIZATION_SIZE",
+}
 
 
 def get_cpu_frequencies(*frequencies):
@@ -451,8 +467,8 @@ def _parse_platform_version(value):
         if ver.major >= 50:  # a pioarduino version
             if "-" in value:
                 # maybe a release candidate?...definitely not our default, just use it as-is...
-                return f"https://github.com/pioarduino/platform-espressif32.git#{value}"
-            return f"https://github.com/pioarduino/platform-espressif32.git#{ver.major}.{ver.minor:02d}.{ver.patch:02d}"
+                return f"https://github.com/pioarduino/platform-espressif32/releases/download/{value}/platform-espressif32.zip"
+            return f"https://github.com/pioarduino/platform-espressif32/releases/download/{ver.major}.{ver.minor:02d}.{ver.patch:02d}/platform-espressif32.zip"
         # if platform version is a valid version constraint, prefix the default package
         cv.platformio_version_constraint(value)
         return f"platformio/espressif32@{value}"
@@ -542,6 +558,10 @@ ARDUINO_FRAMEWORK_SCHEMA = cv.All(
 )
 
 CONF_SDKCONFIG_OPTIONS = "sdkconfig_options"
+CONF_ENABLE_LWIP_DHCP_SERVER = "enable_lwip_dhcp_server"
+CONF_ENABLE_LWIP_MDNS_QUERIES = "enable_lwip_mdns_queries"
+CONF_ENABLE_LWIP_BRIDGE_INTERFACE = "enable_lwip_bridge_interface"
+
 ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
     cv.Schema(
         {
@@ -554,11 +574,30 @@ ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
             },
             cv.Optional(CONF_ADVANCED, default={}): cv.Schema(
                 {
+                    cv.Optional(CONF_ASSERTION_LEVEL): cv.one_of(
+                        *ASSERTION_LEVELS, upper=True
+                    ),
+                    cv.Optional(CONF_COMPILER_OPTIMIZATION, default="SIZE"): cv.one_of(
+                        *COMPILER_OPTIMIZATIONS, upper=True
+                    ),
+                    cv.Optional(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES): cv.boolean,
+                    cv.Optional(CONF_ENABLE_LWIP_ASSERT, default=True): cv.boolean,
                     cv.Optional(
                         CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False
                     ): cv.boolean,
                     cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC): cv.boolean,
-                    cv.Optional(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES): cv.boolean,
+                    # DHCP server is needed for WiFi AP mode. When WiFi component is used,
+                    # it will handle disabling DHCP server when AP is not configured.
+                    # Default to false (disabled) when WiFi is not used.
+                    cv.OnlyWithout(
+                        CONF_ENABLE_LWIP_DHCP_SERVER, "wifi", default=False
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_ENABLE_LWIP_MDNS_QUERIES, default=False
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_ENABLE_LWIP_BRIDGE_INTERFACE, default=False
+                    ): cv.boolean,
                 }
             ),
             cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
@@ -641,7 +680,7 @@ async def to_code(config):
     conf = config[CONF_FRAMEWORK]
     cg.add_platformio_option("platform", conf[CONF_PLATFORM_VERSION])
 
-    if CONF_ADVANCED in conf and conf[CONF_ADVANCED][CONF_IGNORE_EFUSE_CUSTOM_MAC]:
+    if conf[CONF_ADVANCED][CONF_IGNORE_EFUSE_CUSTOM_MAC]:
         cg.add_define("USE_ESP32_IGNORE_EFUSE_CUSTOM_MAC")
 
     add_extra_script(
@@ -672,8 +711,6 @@ async def to_code(config):
         add_idf_sdkconfig_option(
             "CONFIG_PARTITION_TABLE_CUSTOM_FILENAME", "partitions.csv"
         )
-        add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_DEFAULT", False)
-        add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_SIZE", True)
 
         # Increase freertos tick speed from 100Hz to 1kHz so that delay() resolution is 1ms
         add_idf_sdkconfig_option("CONFIG_FREERTOS_HZ", 1000)
@@ -687,16 +724,41 @@ async def to_code(config):
         # Set default CPU frequency
         add_idf_sdkconfig_option(f"CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_{freq}", True)
 
+        # Apply LWIP optimization settings
+        advanced = conf[CONF_ADVANCED]
+        # DHCP server: only disable if explicitly set to false
+        # WiFi component handles its own optimization when AP mode is not used
+        if (
+            CONF_ENABLE_LWIP_DHCP_SERVER in advanced
+            and not advanced[CONF_ENABLE_LWIP_DHCP_SERVER]
+        ):
+            add_idf_sdkconfig_option("CONFIG_LWIP_DHCPS", False)
+        if not advanced.get(CONF_ENABLE_LWIP_MDNS_QUERIES, False):
+            add_idf_sdkconfig_option("CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES", False)
+        if not advanced.get(CONF_ENABLE_LWIP_BRIDGE_INTERFACE, False):
+            add_idf_sdkconfig_option("CONFIG_LWIP_BRIDGEIF_MAX_PORTS", 0)
+
         cg.add_platformio_option("board_build.partitions", "partitions.csv")
         if CONF_PARTITIONS in config:
             add_extra_build_file(
                 "partitions.csv", CORE.relative_config_path(config[CONF_PARTITIONS])
             )
 
-        for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():
-            add_idf_sdkconfig_option(name, RawSdkconfigValue(value))
+        if assertion_level := advanced.get(CONF_ASSERTION_LEVEL):
+            for key, flag in ASSERTION_LEVELS.items():
+                add_idf_sdkconfig_option(flag, assertion_level == key)
 
-        if conf[CONF_ADVANCED].get(CONF_IGNORE_EFUSE_MAC_CRC):
+        add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_DEFAULT", False)
+        compiler_optimization = advanced.get(CONF_COMPILER_OPTIMIZATION)
+        for key, flag in COMPILER_OPTIMIZATIONS.items():
+            add_idf_sdkconfig_option(flag, compiler_optimization == key)
+
+        add_idf_sdkconfig_option(
+            "CONFIG_LWIP_ESP_LWIP_ASSERT",
+            conf[CONF_ADVANCED][CONF_ENABLE_LWIP_ASSERT],
+        )
+
+        if advanced.get(CONF_IGNORE_EFUSE_MAC_CRC):
             add_idf_sdkconfig_option("CONFIG_ESP_MAC_IGNORE_MAC_CRC_ERROR", True)
             if (framework_ver.major, framework_ver.minor) >= (4, 4):
                 add_idf_sdkconfig_option(
@@ -706,7 +768,7 @@ async def to_code(config):
                 add_idf_sdkconfig_option(
                     "CONFIG_ESP32_PHY_CALIBRATION_AND_DATA_STORAGE", False
                 )
-        if conf[CONF_ADVANCED].get(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES):
+        if advanced.get(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES):
             _LOGGER.warning(
                 "Using experimental features in ESP-IDF may result in unexpected failures."
             )
@@ -719,6 +781,9 @@ async def to_code(config):
             ),
         )
 
+        for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():
+            add_idf_sdkconfig_option(name, RawSdkconfigValue(value))
+
         for component in conf[CONF_COMPONENTS]:
             source = component[CONF_SOURCE]
             if source[CONF_TYPE] == TYPE_GIT:

esphome/components/esp32/preferences.cpp

@@ -1,8 +1,8 @@
 #ifdef USE_ESP32
 
-#include "esphome/core/preferences.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/preferences.h"
 #include <nvs_flash.h>
 #include <cstring>
 #include <cinttypes>

esphome/components/esp32_ble/__init__.py

@@ -1,3 +1,4 @@
+from enum import Enum
 import re
 
 from esphome import automation
@@ -12,9 +13,110 @@ import esphome.final_validate as fv
 DEPENDENCIES = ["esp32"]
 CODEOWNERS = ["@jesserockz", "@Rapsssito"]
 
+
+class BTLoggers(Enum):
+    """Bluetooth logger categories available in ESP-IDF.
+
+    Each logger controls debug output for a specific Bluetooth subsystem.
+    The value is the ESP-IDF sdkconfig option name for controlling the log level.
+    """
+
+    # Core Stack Layers
+    HCI = "CONFIG_BT_LOG_HCI_TRACE_LEVEL"
+    """Host Controller Interface - Low-level interface between host and controller"""
+
+    BTM = "CONFIG_BT_LOG_BTM_TRACE_LEVEL"
+    """Bluetooth Manager - Core device control, connections, and security"""
+
+    L2CAP = "CONFIG_BT_LOG_L2CAP_TRACE_LEVEL"
+    """Logical Link Control and Adaptation Protocol - Connection multiplexing"""
+
+    RFCOMM = "CONFIG_BT_LOG_RFCOMM_TRACE_LEVEL"
+    """Serial port emulation over Bluetooth (Classic only)"""
+
+    SDP = "CONFIG_BT_LOG_SDP_TRACE_LEVEL"
+    """Service Discovery Protocol - Service discovery (Classic only)"""
+
+    GAP = "CONFIG_BT_LOG_GAP_TRACE_LEVEL"
+    """Generic Access Profile - Device discovery and connections"""
+
+    # Network Protocols
+    BNEP = "CONFIG_BT_LOG_BNEP_TRACE_LEVEL"
+    """Bluetooth Network Encapsulation Protocol - IP over Bluetooth"""
+
+    PAN = "CONFIG_BT_LOG_PAN_TRACE_LEVEL"
+    """Personal Area Networking - Ethernet over Bluetooth"""
+
+    # Audio/Video Profiles (Classic Bluetooth)
+    A2D = "CONFIG_BT_LOG_A2D_TRACE_LEVEL"
+    """Advanced Audio Distribution - A2DP audio streaming"""
+
+    AVDT = "CONFIG_BT_LOG_AVDT_TRACE_LEVEL"
+    """Audio/Video Distribution Transport - A2DP transport protocol"""
+
+    AVCT = "CONFIG_BT_LOG_AVCT_TRACE_LEVEL"
+    """Audio/Video Control Transport - AVRCP transport protocol"""
+
+    AVRC = "CONFIG_BT_LOG_AVRC_TRACE_LEVEL"
+    """Audio/Video Remote Control - Media playback control"""
+
+    # Security
+    SMP = "CONFIG_BT_LOG_SMP_TRACE_LEVEL"
+    """Security Manager Protocol - BLE pairing and encryption"""
+
+    # Application Layer
+    BTIF = "CONFIG_BT_LOG_BTIF_TRACE_LEVEL"
+    """Bluetooth Interface - Application interface layer"""
+
+    BTC = "CONFIG_BT_LOG_BTC_TRACE_LEVEL"
+    """Bluetooth Common - Task handling and coordination"""
+
+    # BLE Specific
+    BLE_SCAN = "CONFIG_BT_LOG_BLE_SCAN_TRACE_LEVEL"
+    """BLE scanning operations"""
+
+    GATT = "CONFIG_BT_LOG_GATT_TRACE_LEVEL"
+    """Generic Attribute Profile - BLE data exchange protocol"""
+
+    # Other Profiles
+    MCA = "CONFIG_BT_LOG_MCA_TRACE_LEVEL"
+    """Multi-Channel Adaptation - Health device profile"""
+
+    HID = "CONFIG_BT_LOG_HID_TRACE_LEVEL"
+    """Human Interface Device - Keyboards, mice, controllers"""
+
+    APPL = "CONFIG_BT_LOG_APPL_TRACE_LEVEL"
+    """Application layer logging"""
+
+    OSI = "CONFIG_BT_LOG_OSI_TRACE_LEVEL"
+    """OS abstraction layer - Threading, memory, timers"""
+
+    BLUFI = "CONFIG_BT_LOG_BLUFI_TRACE_LEVEL"
+    """ESP32 WiFi provisioning over Bluetooth"""
+
+
+# Set to track which loggers are needed by components
+_required_loggers: set[BTLoggers] = set()
+
+
+def register_bt_logger(*loggers: BTLoggers) -> None:
+    """Register Bluetooth logger categories that a component needs.
+
+    Args:
+        *loggers: One or more BTLoggers enum members
+    """
+    for logger in loggers:
+        if not isinstance(logger, BTLoggers):
+            raise TypeError(
+                f"Logger must be a BTLoggers enum member, got {type(logger)}"
+            )
+        _required_loggers.add(logger)
+
+
 CONF_BLE_ID = "ble_id"
 CONF_IO_CAPABILITY = "io_capability"
 CONF_ADVERTISING_CYCLE_TIME = "advertising_cycle_time"
+CONF_DISABLE_BT_LOGS = "disable_bt_logs"
 
 NO_BLUETOOTH_VARIANTS = [const.VARIANT_ESP32S2]
 
@@ -62,6 +164,9 @@ CONFIG_SCHEMA = cv.Schema(
         cv.Optional(
             CONF_ADVERTISING_CYCLE_TIME, default="10s"
         ): cv.positive_time_period_milliseconds,
+        cv.SplitDefault(CONF_DISABLE_BT_LOGS, esp32_idf=True): cv.All(
+            cv.only_with_esp_idf, cv.boolean
+        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
@@ -140,6 +245,16 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_BT_ENABLED", True)
         add_idf_sdkconfig_option("CONFIG_BT_BLE_42_FEATURES_SUPPORTED", True)
 
+        # Register the core BLE loggers that are always needed
+        register_bt_logger(BTLoggers.GAP, BTLoggers.BTM, BTLoggers.HCI)
+
+        # Apply logger settings if log disabling is enabled
+        if config.get(CONF_DISABLE_BT_LOGS, False):
+            # Disable all Bluetooth loggers that are not required
+            for logger in BTLoggers:
+                if logger not in _required_loggers:
+                    add_idf_sdkconfig_option(f"{logger.value}_NONE", True)
+
     cg.add_define("USE_ESP32_BLE")
 
 

esphome/components/esp32_ble/ble.cpp

@@ -23,6 +23,9 @@ namespace esp32_ble {
 
 static const char *const TAG = "esp32_ble";
 
+// Maximum size of the BLE event queue
+static constexpr size_t MAX_BLE_QUEUE_SIZE = SCAN_RESULT_BUFFER_SIZE * 2;
+
 static RAMAllocator<BLEEvent> EVENT_ALLOCATOR(  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
     RAMAllocator<BLEEvent>::ALLOW_FAILURE | RAMAllocator<BLEEvent>::ALLOC_INTERNAL);
 
@@ -304,20 +307,52 @@ void ESP32BLE::loop() {
   BLEEvent *ble_event = this->ble_events_.pop();
   while (ble_event != nullptr) {
     switch (ble_event->type_) {
-      case BLEEvent::GATTS:
-        this->real_gatts_event_handler_(ble_event->event_.gatts.gatts_event, ble_event->event_.gatts.gatts_if,
-                                        &ble_event->event_.gatts.gatts_param);
+      case BLEEvent::GATTS: {
+        esp_gatts_cb_event_t event = ble_event->event_.gatts.gatts_event;
+        esp_gatt_if_t gatts_if = ble_event->event_.gatts.gatts_if;
+        esp_ble_gatts_cb_param_t *param = ble_event->event_.gatts.gatts_param;
+        ESP_LOGV(TAG, "gatts_event [esp_gatt_if: %d] - %d", gatts_if, event);
+        for (auto *gatts_handler : this->gatts_event_handlers_) {
+          gatts_handler->gatts_event_handler(event, gatts_if, param);
+        }
         break;
-      case BLEEvent::GATTC:
-        this->real_gattc_event_handler_(ble_event->event_.gattc.gattc_event, ble_event->event_.gattc.gattc_if,
-                                        &ble_event->event_.gattc.gattc_param);
+      }
+      case BLEEvent::GATTC: {
+        esp_gattc_cb_event_t event = ble_event->event_.gattc.gattc_event;
+        esp_gatt_if_t gattc_if = ble_event->event_.gattc.gattc_if;
+        esp_ble_gattc_cb_param_t *param = ble_event->event_.gattc.gattc_param;
+        ESP_LOGV(TAG, "gattc_event [esp_gatt_if: %d] - %d", gattc_if, event);
+        for (auto *gattc_handler : this->gattc_event_handlers_) {
+          gattc_handler->gattc_event_handler(event, gattc_if, param);
+        }
         break;
-      case BLEEvent::GAP:
-        this->real_gap_event_handler_(ble_event->event_.gap.gap_event, &ble_event->event_.gap.gap_param);
+      }
+      case BLEEvent::GAP: {
+        esp_gap_ble_cb_event_t gap_event = ble_event->event_.gap.gap_event;
+        if (gap_event == ESP_GAP_BLE_SCAN_RESULT_EVT) {
+          // Use the new scan event handler - no memcpy!
+          for (auto *scan_handler : this->gap_scan_event_handlers_) {
+            scan_handler->gap_scan_event_handler(ble_event->scan_result());
+          }
+        } else if (gap_event == ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT ||
+                   gap_event == ESP_GAP_BLE_SCAN_START_COMPLETE_EVT ||
+                   gap_event == ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT) {
+          // All three scan complete events have the same structure with just status
+          // The scan_complete struct matches ESP-IDF's layout exactly, so this reinterpret_cast is safe
+          // This is verified at compile-time by static_assert checks in ble_event.h
+          // The struct already contains our copy of the status (copied in BLEEvent constructor)
+          ESP_LOGV(TAG, "gap_event_handler - %d", gap_event);
+          for (auto *gap_handler : this->gap_event_handlers_) {
+            gap_handler->gap_event_handler(
+                gap_event, reinterpret_cast<esp_ble_gap_cb_param_t *>(&ble_event->event_.gap.scan_complete));
+          }
+        }
         break;
+      }
       default:
         break;
     }
+    // Destructor will clean up external allocations for GATTC/GATTS
     ble_event->~BLEEvent();
     EVENT_ALLOCATOR.deallocate(ble_event, 1);
     ble_event = this->ble_events_.pop();
@@ -327,59 +362,55 @@ void ESP32BLE::loop() {
   }
 }
 
-void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
+template<typename... Args> void enqueue_ble_event(Args... args) {
+  if (global_ble->ble_events_.size() >= MAX_BLE_QUEUE_SIZE) {
+    ESP_LOGD(TAG, "BLE event queue full (%zu), dropping event", MAX_BLE_QUEUE_SIZE);
+    return;
+  }
+
   BLEEvent *new_event = EVENT_ALLOCATOR.allocate(1);
   if (new_event == nullptr) {
     // Memory too fragmented to allocate new event. Can only drop it until memory comes back
     return;
   }
-  new (new_event) BLEEvent(event, param);
+  new (new_event) BLEEvent(args...);
   global_ble->ble_events_.push(new_event);
 }  // NOLINT(clang-analyzer-unix.Malloc)
 
-void ESP32BLE::real_gap_event_handler_(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
-  ESP_LOGV(TAG, "(BLE) gap_event_handler - %d", event);
-  for (auto *gap_handler : this->gap_event_handlers_) {
-    gap_handler->gap_event_handler(event, param);
+// Explicit template instantiations for the friend function
+template void enqueue_ble_event(esp_gap_ble_cb_event_t, esp_ble_gap_cb_param_t *);
+template void enqueue_ble_event(esp_gatts_cb_event_t, esp_gatt_if_t, esp_ble_gatts_cb_param_t *);
+template void enqueue_ble_event(esp_gattc_cb_event_t, esp_gatt_if_t, esp_ble_gattc_cb_param_t *);
+
+void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
+  switch (event) {
+    // Only queue the 4 GAP events we actually handle
+    case ESP_GAP_BLE_SCAN_RESULT_EVT:
+    case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
+    case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
+    case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
+      enqueue_ble_event(event, param);
+      return;
+
+    // Ignore these GAP events as they are not relevant for our use case
+    case ESP_GAP_BLE_UPDATE_CONN_PARAMS_EVT:
+    case ESP_GAP_BLE_SET_PKT_LENGTH_COMPLETE_EVT:
+      return;
+
+    default:
+      break;
   }
+  ESP_LOGW(TAG, "Ignoring unexpected GAP event type: %d", event);
 }
 
 void ESP32BLE::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,
                                    esp_ble_gatts_cb_param_t *param) {
-  BLEEvent *new_event = EVENT_ALLOCATOR.allocate(1);
-  if (new_event == nullptr) {
-    // Memory too fragmented to allocate new event. Can only drop it until memory comes back
-    return;
-  }
-  new (new_event) BLEEvent(event, gatts_if, param);
-  global_ble->ble_events_.push(new_event);
-}  // NOLINT(clang-analyzer-unix.Malloc)
-
-void ESP32BLE::real_gatts_event_handler_(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,
-                                         esp_ble_gatts_cb_param_t *param) {
-  ESP_LOGV(TAG, "(BLE) gatts_event [esp_gatt_if: %d] - %d", gatts_if, event);
-  for (auto *gatts_handler : this->gatts_event_handlers_) {
-    gatts_handler->gatts_event_handler(event, gatts_if, param);
-  }
+  enqueue_ble_event(event, gatts_if, param);
 }
 
 void ESP32BLE::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                                    esp_ble_gattc_cb_param_t *param) {
-  BLEEvent *new_event = EVENT_ALLOCATOR.allocate(1);
-  if (new_event == nullptr) {
-    // Memory too fragmented to allocate new event. Can only drop it until memory comes back
-    return;
-  }
-  new (new_event) BLEEvent(event, gattc_if, param);
-  global_ble->ble_events_.push(new_event);
-}  // NOLINT(clang-analyzer-unix.Malloc)
-
-void ESP32BLE::real_gattc_event_handler_(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
-                                         esp_ble_gattc_cb_param_t *param) {
-  ESP_LOGV(TAG, "(BLE) gattc_event [esp_gatt_if: %d] - %d", gattc_if, event);
-  for (auto *gattc_handler : this->gattc_event_handlers_) {
-    gattc_handler->gattc_event_handler(event, gattc_if, param);
-  }
+  enqueue_ble_event(event, gattc_if, param);
 }
 
 float ESP32BLE::get_setup_priority() const { return setup_priority::BLUETOOTH; }
@@ -408,10 +439,12 @@ void ESP32BLE::dump_config() {
         io_capability_s = "invalid";
         break;
     }
-    ESP_LOGCONFIG(TAG, "ESP32 BLE:");
-    ESP_LOGCONFIG(TAG, "  MAC address: %02X:%02X:%02X:%02X:%02X:%02X", mac_address[0], mac_address[1], mac_address[2],
-                  mac_address[3], mac_address[4], mac_address[5]);
-    ESP_LOGCONFIG(TAG, "  IO Capability: %s", io_capability_s);
+    ESP_LOGCONFIG(TAG,
+                  "ESP32 BLE:\n"
+                  "  MAC address: %02X:%02X:%02X:%02X:%02X:%02X\n"
+                  "  IO Capability: %s",
+                  mac_address[0], mac_address[1], mac_address[2], mac_address[3], mac_address[4], mac_address[5],
+                  io_capability_s);
   } else {
     ESP_LOGCONFIG(TAG, "ESP32 BLE: bluetooth stack is not enabled");
   }

esphome/components/esp32_ble/ble.h

@@ -2,6 +2,7 @@
 
 #include "ble_advertising.h"
 #include "ble_uuid.h"
+#include "ble_scan_result.h"
 
 #include <functional>
 
@@ -22,6 +23,13 @@
 namespace esphome {
 namespace esp32_ble {
 
+// Maximum number of BLE scan results to buffer
+#ifdef USE_PSRAM
+static constexpr uint8_t SCAN_RESULT_BUFFER_SIZE = 32;
+#else
+static constexpr uint8_t SCAN_RESULT_BUFFER_SIZE = 20;
+#endif
+
 uint64_t ble_addr_to_uint64(const esp_bd_addr_t address);
 
 // NOLINTNEXTLINE(modernize-use-using)
@@ -57,6 +65,11 @@ class GAPEventHandler {
   virtual void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) = 0;
 };
 
+class GAPScanEventHandler {
+ public:
+  virtual void gap_scan_event_handler(const BLEScanResult &scan_result) = 0;
+};
+
 class GATTcEventHandler {
  public:
   virtual void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
@@ -101,6 +114,9 @@ class ESP32BLE : public Component {
   void advertising_register_raw_advertisement_callback(std::function<void(bool)> &&callback);
 
   void register_gap_event_handler(GAPEventHandler *handler) { this->gap_event_handlers_.push_back(handler); }
+  void register_gap_scan_event_handler(GAPScanEventHandler *handler) {
+    this->gap_scan_event_handlers_.push_back(handler);
+  }
   void register_gattc_event_handler(GATTcEventHandler *handler) { this->gattc_event_handlers_.push_back(handler); }
   void register_gatts_event_handler(GATTsEventHandler *handler) { this->gatts_event_handlers_.push_back(handler); }
   void register_ble_status_event_handler(BLEStatusEventHandler *handler) {
@@ -113,16 +129,16 @@ class ESP32BLE : public Component {
   static void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param);
   static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param);
 
-  void real_gatts_event_handler_(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param);
-  void real_gattc_event_handler_(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param);
-  void real_gap_event_handler_(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param);
-
   bool ble_setup_();
   bool ble_dismantle_();
   bool ble_pre_setup_();
   void advertising_init_();
 
+ private:
+  template<typename... Args> friend void enqueue_ble_event(Args... args);
+
   std::vector<GAPEventHandler *> gap_event_handlers_;
+  std::vector<GAPScanEventHandler *> gap_scan_event_handlers_;
   std::vector<GATTcEventHandler *> gattc_event_handlers_;
   std::vector<GATTsEventHandler *> gatts_event_handlers_;
   std::vector<BLEStatusEventHandler *> ble_status_event_handlers_;

esphome/components/esp32_ble/ble_event.h

@@ -2,92 +2,232 @@
 
 #ifdef USE_ESP32
 
+#include <cstddef>  // for offsetof
 #include <vector>
 
 #include <esp_gap_ble_api.h>
 #include <esp_gattc_api.h>
 #include <esp_gatts_api.h>
 
+#include "ble_scan_result.h"
+
 namespace esphome {
 namespace esp32_ble {
+
+// Compile-time verification that ESP-IDF scan complete events only contain a status field
+// This ensures our reinterpret_cast in ble.cpp is safe
+static_assert(sizeof(esp_ble_gap_cb_param_t::ble_scan_param_cmpl_evt_param) == sizeof(esp_bt_status_t),
+              "ESP-IDF scan_param_cmpl structure has unexpected size");
+static_assert(sizeof(esp_ble_gap_cb_param_t::ble_scan_start_cmpl_evt_param) == sizeof(esp_bt_status_t),
+              "ESP-IDF scan_start_cmpl structure has unexpected size");
+static_assert(sizeof(esp_ble_gap_cb_param_t::ble_scan_stop_cmpl_evt_param) == sizeof(esp_bt_status_t),
+              "ESP-IDF scan_stop_cmpl structure has unexpected size");
+
+// Verify the status field is at offset 0 (first member)
+static_assert(offsetof(esp_ble_gap_cb_param_t, scan_param_cmpl.status) ==
+                  offsetof(esp_ble_gap_cb_param_t, scan_param_cmpl),
+              "status must be first member of scan_param_cmpl");
+static_assert(offsetof(esp_ble_gap_cb_param_t, scan_start_cmpl.status) ==
+                  offsetof(esp_ble_gap_cb_param_t, scan_start_cmpl),
+              "status must be first member of scan_start_cmpl");
+static_assert(offsetof(esp_ble_gap_cb_param_t, scan_stop_cmpl.status) ==
+                  offsetof(esp_ble_gap_cb_param_t, scan_stop_cmpl),
+              "status must be first member of scan_stop_cmpl");
+
 // Received GAP, GATTC and GATTS events are only queued, and get processed in the main loop().
-// This class stores each event in a single type.
+// This class stores each event with minimal memory usage.
+// GAP events (99% of traffic) don't have the vector overhead.
+// GATTC/GATTS events use heap allocation for their param and data.
+//
+// Event flow:
+// 1. ESP-IDF BLE stack calls our static handlers in the BLE task context
+// 2. The handlers create a BLEEvent instance, copying only the data we need
+// 3. The event is pushed to a thread-safe queue
+// 4. In the main loop(), events are popped from the queue and processed
+// 5. The event destructor cleans up any external allocations
+//
+// Thread safety:
+// - GAP events: We copy only the fields we need directly into the union
+// - GATTC/GATTS events: We heap-allocate and copy the entire param struct, ensuring
+//   the data remains valid even after the BLE callback returns. The original
+//   param pointer from ESP-IDF is only valid during the callback.
 class BLEEvent {
  public:
-  BLEEvent(esp_gap_ble_cb_event_t e, esp_ble_gap_cb_param_t *p) {
-    this->event_.gap.gap_event = e;
-    memcpy(&this->event_.gap.gap_param, p, sizeof(esp_ble_gap_cb_param_t));
-    this->type_ = GAP;
-  };
-
-  BLEEvent(esp_gattc_cb_event_t e, esp_gatt_if_t i, esp_ble_gattc_cb_param_t *p) {
-    this->event_.gattc.gattc_event = e;
-    this->event_.gattc.gattc_if = i;
-    memcpy(&this->event_.gattc.gattc_param, p, sizeof(esp_ble_gattc_cb_param_t));
-    // Need to also make a copy of relevant event data.
-    switch (e) {
-      case ESP_GATTC_NOTIFY_EVT:
-        this->data.assign(p->notify.value, p->notify.value + p->notify.value_len);
-        this->event_.gattc.gattc_param.notify.value = this->data.data();
-        break;
-      case ESP_GATTC_READ_CHAR_EVT:
-      case ESP_GATTC_READ_DESCR_EVT:
-        this->data.assign(p->read.value, p->read.value + p->read.value_len);
-        this->event_.gattc.gattc_param.read.value = this->data.data();
-        break;
-      default:
-        break;
-    }
-    this->type_ = GATTC;
-  };
-
-  BLEEvent(esp_gatts_cb_event_t e, esp_gatt_if_t i, esp_ble_gatts_cb_param_t *p) {
-    this->event_.gatts.gatts_event = e;
-    this->event_.gatts.gatts_if = i;
-    memcpy(&this->event_.gatts.gatts_param, p, sizeof(esp_ble_gatts_cb_param_t));
-    // Need to also make a copy of relevant event data.
-    switch (e) {
-      case ESP_GATTS_WRITE_EVT:
-        this->data.assign(p->write.value, p->write.value + p->write.len);
-        this->event_.gatts.gatts_param.write.value = this->data.data();
-        break;
-      default:
-        break;
-    }
-    this->type_ = GATTS;
-  };
-
-  union {
-    // NOLINTNEXTLINE(readability-identifier-naming)
-    struct gap_event {
-      esp_gap_ble_cb_event_t gap_event;
-      esp_ble_gap_cb_param_t gap_param;
-    } gap;
-
-    // NOLINTNEXTLINE(readability-identifier-naming)
-    struct gattc_event {
-      esp_gattc_cb_event_t gattc_event;
-      esp_gatt_if_t gattc_if;
-      esp_ble_gattc_cb_param_t gattc_param;
-    } gattc;
-
-    // NOLINTNEXTLINE(readability-identifier-naming)
-    struct gatts_event {
-      esp_gatts_cb_event_t gatts_event;
-      esp_gatt_if_t gatts_if;
-      esp_ble_gatts_cb_param_t gatts_param;
-    } gatts;
-  } event_;
-
-  std::vector<uint8_t> data{};
   // NOLINTNEXTLINE(readability-identifier-naming)
   enum ble_event_t : uint8_t {
     GAP,
     GATTC,
     GATTS,
-  } type_;
+  };
+
+  // Constructor for GAP events - no external allocations needed
+  BLEEvent(esp_gap_ble_cb_event_t e, esp_ble_gap_cb_param_t *p) {
+    this->type_ = GAP;
+    this->event_.gap.gap_event = e;
+
+    if (p == nullptr) {
+      return;  // Invalid event, but we can't log in header file
+    }
+
+    // Only copy the data we actually use for each GAP event type
+    switch (e) {
+      case ESP_GAP_BLE_SCAN_RESULT_EVT:
+        // Copy only the fields we use from scan results
+        memcpy(this->event_.gap.scan_result.bda, p->scan_rst.bda, sizeof(esp_bd_addr_t));
+        this->event_.gap.scan_result.ble_addr_type = p->scan_rst.ble_addr_type;
+        this->event_.gap.scan_result.rssi = p->scan_rst.rssi;
+        this->event_.gap.scan_result.adv_data_len = p->scan_rst.adv_data_len;
+        this->event_.gap.scan_result.scan_rsp_len = p->scan_rst.scan_rsp_len;
+        this->event_.gap.scan_result.search_evt = p->scan_rst.search_evt;
+        memcpy(this->event_.gap.scan_result.ble_adv, p->scan_rst.ble_adv,
+               ESP_BLE_ADV_DATA_LEN_MAX + ESP_BLE_SCAN_RSP_DATA_LEN_MAX);
+        break;
+
+      case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
+        this->event_.gap.scan_complete.status = p->scan_param_cmpl.status;
+        break;
+
+      case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
+        this->event_.gap.scan_complete.status = p->scan_start_cmpl.status;
+        break;
+
+      case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
+        this->event_.gap.scan_complete.status = p->scan_stop_cmpl.status;
+        break;
+
+      default:
+        // We only handle 4 GAP event types, others are dropped
+        break;
+    }
+  }
+
+  // Constructor for GATTC events - uses heap allocation
+  // Creates a copy of the param struct since the original is only valid during the callback
+  BLEEvent(esp_gattc_cb_event_t e, esp_gatt_if_t i, esp_ble_gattc_cb_param_t *p) {
+    this->type_ = GATTC;
+    this->event_.gattc.gattc_event = e;
+    this->event_.gattc.gattc_if = i;
+
+    if (p == nullptr) {
+      this->event_.gattc.gattc_param = nullptr;
+      this->event_.gattc.data = nullptr;
+      return;  // Invalid event, but we can't log in header file
+    }
+
+    // Heap-allocate param and data
+    // Heap allocation is used because GATTC/GATTS events are rare (<1% of events)
+    // while GAP events (99%) are stored inline to minimize memory usage
+    this->event_.gattc.gattc_param = new esp_ble_gattc_cb_param_t(*p);
+
+    // Copy data for events that need it
+    switch (e) {
+      case ESP_GATTC_NOTIFY_EVT:
+        this->event_.gattc.data = new std::vector<uint8_t>(p->notify.value, p->notify.value + p->notify.value_len);
+        this->event_.gattc.gattc_param->notify.value = this->event_.gattc.data->data();
+        break;
+      case ESP_GATTC_READ_CHAR_EVT:
+      case ESP_GATTC_READ_DESCR_EVT:
+        this->event_.gattc.data = new std::vector<uint8_t>(p->read.value, p->read.value + p->read.value_len);
+        this->event_.gattc.gattc_param->read.value = this->event_.gattc.data->data();
+        break;
+      default:
+        this->event_.gattc.data = nullptr;
+        break;
+    }
+  }
+
+  // Constructor for GATTS events - uses heap allocation
+  // Creates a copy of the param struct since the original is only valid during the callback
+  BLEEvent(esp_gatts_cb_event_t e, esp_gatt_if_t i, esp_ble_gatts_cb_param_t *p) {
+    this->type_ = GATTS;
+    this->event_.gatts.gatts_event = e;
+    this->event_.gatts.gatts_if = i;
+
+    if (p == nullptr) {
+      this->event_.gatts.gatts_param = nullptr;
+      this->event_.gatts.data = nullptr;
+      return;  // Invalid event, but we can't log in header file
+    }
+
+    // Heap-allocate param and data
+    // Heap allocation is used because GATTC/GATTS events are rare (<1% of events)
+    // while GAP events (99%) are stored inline to minimize memory usage
+    this->event_.gatts.gatts_param = new esp_ble_gatts_cb_param_t(*p);
+
+    // Copy data for events that need it
+    switch (e) {
+      case ESP_GATTS_WRITE_EVT:
+        this->event_.gatts.data = new std::vector<uint8_t>(p->write.value, p->write.value + p->write.len);
+        this->event_.gatts.gatts_param->write.value = this->event_.gatts.data->data();
+        break;
+      default:
+        this->event_.gatts.data = nullptr;
+        break;
+    }
+  }
+
+  // Destructor to clean up heap allocations
+  ~BLEEvent() {
+    switch (this->type_) {
+      case GATTC:
+        delete this->event_.gattc.gattc_param;
+        delete this->event_.gattc.data;
+        break;
+      case GATTS:
+        delete this->event_.gatts.gatts_param;
+        delete this->event_.gatts.data;
+        break;
+      default:
+        break;
+    }
+  }
+
+  // Disable copy to prevent double-delete
+  BLEEvent(const BLEEvent &) = delete;
+  BLEEvent &operator=(const BLEEvent &) = delete;
+
+  union {
+    // NOLINTNEXTLINE(readability-identifier-naming)
+    struct gap_event {
+      esp_gap_ble_cb_event_t gap_event;
+      union {
+        BLEScanResult scan_result;  // 73 bytes
+        // This matches ESP-IDF's scan complete event structures
+        // All three (scan_param_cmpl, scan_start_cmpl, scan_stop_cmpl) have identical layout
+        struct {
+          esp_bt_status_t status;
+        } scan_complete;  // 1 byte
+      };
+    } gap;  // 80 bytes total
+
+    // NOLINTNEXTLINE(readability-identifier-naming)
+    struct gattc_event {
+      esp_gattc_cb_event_t gattc_event;
+      esp_gatt_if_t gattc_if;
+      esp_ble_gattc_cb_param_t *gattc_param;  // Heap-allocated
+      std::vector<uint8_t> *data;             // Heap-allocated
+    } gattc;                                  // 16 bytes (pointers only)
+
+    // NOLINTNEXTLINE(readability-identifier-naming)
+    struct gatts_event {
+      esp_gatts_cb_event_t gatts_event;
+      esp_gatt_if_t gatts_if;
+      esp_ble_gatts_cb_param_t *gatts_param;  // Heap-allocated
+      std::vector<uint8_t> *data;             // Heap-allocated
+    } gatts;                                  // 16 bytes (pointers only)
+  } event_;                                   // 80 bytes
+
+  ble_event_t type_;
+
+  // Helper methods to access event data
+  ble_event_t type() const { return type_; }
+  esp_gap_ble_cb_event_t gap_event_type() const { return event_.gap.gap_event; }
+  const BLEScanResult &scan_result() const { return event_.gap.scan_result; }
+  esp_bt_status_t scan_complete_status() const { return event_.gap.scan_complete.status; }
 };
 
+// BLEEvent total size: 84 bytes (80 byte union + 1 byte type + 3 bytes padding)
+
 }  // namespace esp32_ble
 }  // namespace esphome
 

esphome/components/esp32_ble/ble_scan_result.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#ifdef USE_ESP32
+
+#include <esp_gap_ble_api.h>
+
+namespace esphome {
+namespace esp32_ble {
+
+// Structure for BLE scan results - only fields we actually use
+struct __attribute__((packed)) BLEScanResult {
+  esp_bd_addr_t bda;
+  uint8_t ble_addr_type;
+  int8_t rssi;
+  uint8_t ble_adv[ESP_BLE_ADV_DATA_LEN_MAX + ESP_BLE_SCAN_RSP_DATA_LEN_MAX];
+  uint8_t adv_data_len;
+  uint8_t scan_rsp_len;
+  uint8_t search_evt;
+};  // ~73 bytes vs ~400 bytes for full esp_ble_gap_cb_param_t
+
+}  // namespace esp32_ble
+}  // namespace esphome
+
+#endif

esphome/components/esp32_ble/ble_uuid.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/helpers.h"
 #include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
 
 #ifdef USE_ESP32
 

esphome/components/esp32_ble/queue.h

@@ -45,6 +45,17 @@ template<class T> class Queue {
     return element;
   }
 
+  size_t size() const {
+    // Lock-free size check. While std::queue::size() is not thread-safe, we intentionally
+    // avoid locking here to prevent blocking the BLE callback thread. The size is only
+    // used to decide whether to drop incoming events when the queue is near capacity.
+    // With a queue limit of 40-64 events and normal processing, dropping events should
+    // be extremely rare. When it does approach capacity, being off by 1-2 events is
+    // acceptable to avoid blocking the BLE stack's time-sensitive callbacks.
+    // Trade-off: We prefer occasional dropped events over potential BLE stack delays.
+    return q_.size();
+  }
+
  protected:
   std::queue<T *> q_;
   SemaphoreHandle_t m_;

esphome/components/esp32_ble_client/ble_client_base.cpp

@@ -45,8 +45,10 @@ void BLEClientBase::loop() {
 float BLEClientBase::get_setup_priority() const { return setup_priority::AFTER_BLUETOOTH; }
 
 void BLEClientBase::dump_config() {
-  ESP_LOGCONFIG(TAG, "  Address: %s", this->address_str().c_str());
-  ESP_LOGCONFIG(TAG, "  Auto-Connect: %s", TRUEFALSE(this->auto_connect_));
+  ESP_LOGCONFIG(TAG,
+                "  Address: %s\n"
+                "  Auto-Connect: %s",
+                this->address_str().c_str(), TRUEFALSE(this->auto_connect_));
   std::string state_name;
   switch (this->state()) {
     case espbt::ClientState::INIT:

esphome/components/esp32_ble_server/__init__.py

@@ -4,7 +4,7 @@ from esphome import automation
 import esphome.codegen as cg
 from esphome.components import esp32_ble
 from esphome.components.esp32 import add_idf_sdkconfig_option
-from esphome.components.esp32_ble import bt_uuid
+from esphome.components.esp32_ble import BTLoggers, bt_uuid
 import esphome.config_validation as cv
 from esphome.config_validation import UNDEFINED
 from esphome.const import (
@@ -525,6 +525,9 @@ async def to_code_characteristic(service_var, char_conf):
 
 
 async def to_code(config):
+    # Register the loggers this component needs
+    esp32_ble.register_bt_logger(BTLoggers.GATT, BTLoggers.SMP)
+
     var = cg.new_Pvariable(config[CONF_ID])
 
     await cg.register_component(var, config)