preen

This reverts commit 1226e581ec.

CODEOWNERS

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

esphome/components/absolute_humidity/absolute_humidity.cpp

@@ -40,11 +40,9 @@ void AbsoluteHumidityComponent::dump_config() {
       break;
   }
 
-  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());
+  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());
 }
 
 float AbsoluteHumidityComponent::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/ac_dimmer/ac_dimmer.cpp

@@ -214,10 +214,8 @@ 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%%\n"
-                "   Init with half cycle: %s",
-                this->store_.min_power / 10.0f, YESNO(this->init_with_half_cycle_));
+  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_));
   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,10 +77,8 @@ void ADCSensor::dump_config() {
         break;
     }
   }
-  ESP_LOGCONFIG(TAG,
-                "  Samples: %i\n"
-                "  Sampling mode: %s",
-                this->sample_count_, LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
+  ESP_LOGCONFIG(TAG, "  Samples: %i", this->sample_count_);
+  ESP_LOGCONFIG(TAG, "  Sampling mode: %s", LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/adc/adc_sensor_esp8266.cpp

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

esphome/components/adc/adc_sensor_libretiny.cpp

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

esphome/components/adc/adc_sensor_rp2040.cpp

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

esphome/components/ade7880/ade7880.cpp

@@ -177,14 +177,11 @@ 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:\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);
+    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);
   }
 
   if (this->channel_b_ != nullptr) {
@@ -196,14 +193,11 @@ 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:\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);
+    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);
   }
 
   if (this->channel_c_ != nullptr) {
@@ -215,23 +209,18 @@ 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:\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);
+    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);
   }
 
   if (this->channel_n_ != nullptr) {
     ESP_LOGCONFIG(TAG, "  Neutral:");
     LOG_SENSOR("    ", "Current", this->channel_n_->current);
-    ESP_LOGCONFIG(TAG,
-                  "    Calibration:\n"
-                  "     Current: %" PRId32,
-                  this->channel_n_->current_gain_calibration);
+    ESP_LOGCONFIG(TAG, "    Calibration:");
+    ESP_LOGCONFIG(TAG, "     Current: %" PRId32, this->channel_n_->current_gain_calibration);
   }
 
   LOG_I2C_DEVICE(this);

esphome/components/ade7953_base/ade7953_base.cpp

@@ -58,18 +58,15 @@ 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\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_);
+  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_);
 }
 
 #define ADE_PUBLISH_(name, val, factor) \

esphome/components/ade7953_i2c/ade7953_i2c.cpp

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

esphome/components/ade7953_spi/ade7953_spi.cpp

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

esphome/components/ads1118/ads1118.cpp

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

esphome/components/ags10/ags10.cpp

@@ -1,5 +1,4 @@
 #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,7 +235,6 @@ 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/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace am43 {

esphome/components/am43/cover/am43_cover.cpp

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

esphome/components/analog_threshold/analog_threshold_binary_sensor.cpp

@@ -34,10 +34,8 @@ 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\n"
-                "  Lower threshold: %.11f",
-                this->upper_threshold_.value(), this->lower_threshold_.value());
+  ESP_LOGCONFIG(TAG, "  Upper threshold: %.11f", this->upper_threshold_.value());
+  ESP_LOGCONFIG(TAG, "  Lower threshold: %.11f", this->lower_threshold_.value());
 }
 
 }  // namespace analog_threshold

esphome/components/apds9306/apds9306.cpp

@@ -108,12 +108,9 @@ void APDS9306::dump_config() {
     }
   }
 
-  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_]);
+  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_]);
 
   LOG_UPDATE_INTERVAL(this);
 }

esphome/components/api/api_connection.cpp

@@ -239,8 +239,7 @@ DisconnectResponse APIConnection::disconnect(const DisconnectRequest &msg) {
   return resp;
 }
 void APIConnection::on_disconnect_response(const DisconnectResponse &value) {
-  this->helper_->close();
-  this->remove_ = true;
+  // pass
 }
 
 // Encodes a message to the buffer and returns the total number of bytes used,
@@ -270,6 +269,10 @@ 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);
@@ -278,15 +281,20 @@ 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);
-  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);
+  return try_send_binary_sensor_state_response(binary_sensor, binary_sensor->state, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_binary_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -523,21 +531,29 @@ 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);
-  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);
+  return try_send_sensor_state_response(sensor, sensor->state, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -558,20 +574,28 @@ 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);
-  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);
+  return try_send_switch_state_response(a_switch, a_switch->state, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_switch_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -598,6 +622,10 @@ 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);
@@ -606,15 +634,20 @@ 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);
-  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);
+  return try_send_text_sensor_state_response(text_sensor, text_sensor->get_state(), conn, remaining_size, is_single);
 }
 uint16_t APIConnection::try_send_text_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                   bool is_single) {
@@ -733,21 +766,29 @@ 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);
-  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);
+  return try_send_number_state_response(number, number->state, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_number_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -889,21 +930,29 @@ 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);
-  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);
+  return try_send_text_state_response(text, text->state, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_text_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -930,21 +979,29 @@ 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);
-  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);
+  return try_send_select_state_response(select, select->state, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_select_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -991,20 +1048,28 @@ 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);
-  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);
+  return try_send_lock_state_response(a_lock, a_lock->state, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_lock_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -1867,6 +1932,63 @@ 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);
@@ -1886,12 +2008,6 @@ 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) {
@@ -2027,8 +2143,6 @@ 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,6 +33,7 @@ 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
@@ -52,15 +53,18 @@ 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
@@ -75,6 +79,7 @@ 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;
@@ -95,11 +100,13 @@ 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;
@@ -109,6 +116,7 @@ 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;
@@ -308,7 +316,9 @@ class APIConnection : public APIServerConnection {
                                            uint32_t remaining_size, bool is_single);
 
 #ifdef USE_BINARY_SENSOR
-  static uint16_t try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+  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,
                                                bool is_single);
   static uint16_t try_send_binary_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single);
@@ -328,18 +338,24 @@ 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,
@@ -352,6 +368,8 @@ 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,
@@ -372,10 +390,14 @@ 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,
@@ -386,6 +408,8 @@ 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
@@ -426,10 +450,6 @@ 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);
 
@@ -474,11 +494,22 @@ 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
@@ -545,12 +576,21 @@ class APIConnection : public APIServerConnection {
 
    private:
     // Helper to check if this message type uses heap-allocated strings
-    bool uses_string_data_() const { return message_type_ == EventResponse::MESSAGE_TYPE; }
+    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;
+    }
     union CreatorData {
       MessageCreatorPtr ptr;    // 8 bytes
+      bool bool_value;          // 1 byte
+      float float_value;        // 4 bytes
       std::string *string_ptr;  // 8 bytes
-    } data_;                    // 8 bytes
-    uint16_t message_type_;     // 2 bytes (0 = function ptr, >0 = state capture)
+#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)
   };
 
   // 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/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/application.h"
 #include "proto.h"
 #include "api_pb2_size.h"
 #include <cstring>

esphome/components/api/api_server.cpp

@@ -92,12 +92,6 @@ 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);
@@ -122,8 +116,8 @@ void APIServer::setup() {
 }
 
 void APIServer::loop() {
-  // Accept new clients only if the socket exists and has incoming connections
-  if (this->socket_ && this->socket_->ready()) {
+  // Accept new clients only if the socket has incoming connections
+  if (this->socket_->ready()) {
     while (true) {
       struct sockaddr_storage source_addr;
       socklen_t addr_len = sizeof(source_addr);
@@ -179,10 +173,8 @@ void APIServer::loop() {
 }
 
 void APIServer::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "API Server:\n"
-                "  Address: %s:%u",
-                network::get_use_address().c_str(), this->port_);
+  ESP_LOGCONFIG(TAG, "API Server:");
+  ESP_LOGCONFIG(TAG, "  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()) {
@@ -227,11 +219,12 @@ 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) {
+void APIServer::on_binary_sensor_update(binary_sensor::BinarySensor *obj, bool state) {
   if (obj->is_internal())
     return;
+  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    c->send_binary_sensor_state(obj);
+    use_current ? c->send_binary_sensor_state(obj) : c->send_binary_sensor_state(obj, state);
 }
 #endif
 
@@ -266,8 +259,9 @@ 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_)
-    c->send_sensor_state(obj);
+    use_current ? c->send_sensor_state(obj) : c->send_sensor_state(obj, state);
 }
 #endif
 
@@ -275,8 +269,9 @@ 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_)
-    c->send_switch_state(obj);
+    use_current ? c->send_switch_state(obj) : c->send_switch_state(obj, state);
 }
 #endif
 
@@ -284,8 +279,9 @@ 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_)
-    c->send_text_sensor_state(obj);
+    use_current ? c->send_text_sensor_state(obj) : c->send_text_sensor_state(obj, state);
 }
 #endif
 
@@ -302,8 +298,9 @@ 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_)
-    c->send_number_state(obj);
+    use_current ? c->send_number_state(obj) : c->send_number_state(obj, state);
 }
 #endif
 
@@ -338,8 +335,9 @@ 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_)
-    c->send_text_state(obj);
+    use_current ? c->send_text_state(obj) : c->send_text_state(obj, state);
 }
 #endif
 
@@ -347,8 +345,9 @@ 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_)
-    c->send_select_state(obj);
+    use_current ? c->send_select_state(obj) : c->send_select_state(obj, state);
 }
 #endif
 
@@ -488,36 +487,10 @@ void APIServer::request_time() {
 bool APIServer::is_connected() const { return !this->clients_.empty(); }
 
 void APIServer::on_shutdown() {
-  this->shutting_down_ = true;
-
-  // Close the listening socket to prevent new connections
-  if (this->socket_) {
-    this->socket_->close();
-    this->socket_ = nullptr;
-  }
-
-  // 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);
-    }
+    c->send_message(DisconnectRequest());
   }
-}
-
-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();
+  delay(10);
 }
 
 }  // namespace api

esphome/components/api/api_server.h

@@ -34,7 +34,6 @@ 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);
@@ -54,7 +53,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) override;
+  void on_binary_sensor_update(binary_sensor::BinarySensor *obj, bool state) override;
 #endif
 #ifdef USE_COVER
   void on_cover_update(cover::Cover *obj) override;
@@ -142,7 +141,6 @@ 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, parse_log_message
+from aioesphomeapi import APIClient
 from aioesphomeapi.log_runner import async_run
 
 from esphome.const import CONF_KEY, CONF_PASSWORD, CONF_PORT, __version__
@@ -46,10 +46,9 @@ async def async_run_logs(config: dict[str, Any], address: str) -> None:
         time_ = datetime.now()
         message: bytes = msg.message
         text = message.decode("utf8", "backslashreplace")
-        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)
+        if dashboard:
+            text = text.replace("\033", "\\033")
+        print(f"[{time_.hour:02}:{time_.minute:02}:{time_.second:02}]{text}")
 
     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/automation.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/automation.h"
 #include <vector>
 
 namespace esphome {

esphome/components/api/proto.cpp

@@ -1,6 +1,5 @@
 #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/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 #include <vector>
 

esphome/components/as5600/as5600.cpp

@@ -95,13 +95,11 @@ void AS5600Component::dump_config() {
     return;
   }
 
-  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_);
+  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_);
   if (this->end_mode_ == END_MODE_POSITION) {
     ESP_LOGCONFIG(TAG, "  End Position: %d", this->end_position_);
   } else {

esphome/components/as7341/as7341.cpp

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

esphome/components/at581x/at581x.cpp

@@ -75,18 +75,15 @@ 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\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_);
+  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_);
 
   // Set frequency point
   if (!this->i2c_write_reg(FREQ_ADDR, GAIN61_VALUE)) {

esphome/components/axs15231/touchscreen/axs15231_touchscreen.cpp

@@ -60,10 +60,8 @@ 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\n"
-                "  Height: %d",
-                this->x_raw_max_, this->y_raw_max_);
+  ESP_LOGCONFIG(TAG, "  Width: %d", this->x_raw_max_);
+  ESP_LOGCONFIG(TAG, "  Height: %d", this->y_raw_max_);
 }
 
 }  // namespace axs15231

esphome/components/bang_bang/bang_bang_climate.cpp

@@ -194,14 +194,11 @@ 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\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);
+  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);
 }
 
 BangBangClimateTargetTempConfig::BangBangClimateTargetTempConfig() = default;

esphome/components/bedjet/bedjet_hub.cpp

@@ -484,11 +484,9 @@ void BedJetHub::loop() {}
 void BedJetHub::update() { this->dispatch_status_(); }
 
 void BedJetHub::dump_config() {
-  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());
+  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());
   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,10 +345,8 @@ light::ESPColorView BekenSPILEDStripLightOutput::get_view_internal(int32_t index
 }
 
 void BekenSPILEDStripLightOutput::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "Beken SPI LED Strip:\n"
-                "  Pin: %u",
-                this->pin_);
+  ESP_LOGCONFIG(TAG, "Beken SPI LED Strip:");
+  ESP_LOGCONFIG(TAG, "  Pin: %u", this->pin_);
   const char *rgb_order;
   switch (this->rgb_order_) {
     case ORDER_RGB:
@@ -373,11 +371,9 @@ void BekenSPILEDStripLightOutput::dump_config() {
       rgb_order = "UNKNOWN";
       break;
   }
-  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_);
+  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_);
 }
 
 float BekenSPILEDStripLightOutput::get_setup_priority() const { return setup_priority::HARDWARE; }

esphome/components/binary_sensor/__init__.py

@@ -1,10 +1,7 @@
-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,
@@ -101,7 +98,6 @@ 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"
@@ -131,17 +127,9 @@ 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)
@@ -156,8 +144,6 @@ 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)
 
@@ -400,14 +386,6 @@ 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)
@@ -417,12 +395,7 @@ _BINARY_SENSOR_SCHEMA = (
             cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(
                 mqtt.MQTTBinarySensorComponent
             ),
-            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_PUBLISH_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(
@@ -481,11 +454,6 @@ _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),
-                }
-            ),
         }
     )
 )
@@ -525,10 +493,8 @@ 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))
-    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 publish_initial_state := config.get(CONF_PUBLISH_INITIAL_STATE):
+        cg.add(var.set_publish_initial_state(publish_initial_state))
     if inverted := config.get(CONF_INVERTED):
         cg.add(var.set_inverted(inverted))
     if filters_config := config.get(CONF_FILTERS):
@@ -576,17 +542,6 @@ 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)
@@ -599,7 +554,6 @@ 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)
 
 
@@ -636,18 +590,3 @@ 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_->get_state_default(false);
+    this->last_state_ = this->parent_->state;
     auto f = std::bind(&MultiClickTrigger::on_state_, this, std::placeholders::_1);
     this->parent_->add_on_state_callback(f);
   }
@@ -130,14 +130,6 @@ 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) {}
@@ -162,15 +154,5 @@ 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,25 +7,42 @@ namespace binary_sensor {
 
 static const char *const TAG = "binary_sensor";
 
-void BinarySensor::publish_state(bool new_state) {
+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;
   if (this->filter_list_ == nullptr) {
-    this->send_state_internal(new_state);
+    this->send_state_internal(state, false);
   } else {
-    this->filter_list_->input(new_state);
+    this->filter_list_->input(state, false);
   }
 }
-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::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::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;
@@ -43,6 +60,7 @@ 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,5 +1,6 @@
 #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"
@@ -33,39 +34,52 @@ 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 StatefulEntityBase<bool>, public EntityBase_DeviceClass {
+class BinarySensor : public EntityBase, public EntityBase_DeviceClass {
  public:
-  explicit BinarySensor(){};
+  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);
 
   /** Publish a new state to the front-end.
    *
-   * @param new_state The new state.
+   * @param state The new state.
    */
-  void publish_state(bool new_state);
+  void publish_state(bool 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 new_state The new state.
+   * @param state The new state.
    */
-  void publish_initial_state(bool new_state);
+  void publish_initial_state(bool state);
+
+  /// The current reported state of the binary sensor.
+  bool state{false};
 
   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 new_state);
+  void send_state_internal(bool state, bool is_initial);
 
   /// 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,36 +9,37 @@ namespace binary_sensor {
 
 static const char *const TAG = "sensor.filter";
 
-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) {
+void Filter::output(bool value, bool is_initial) {
   if (!this->dedup_.next(value))
     return;
-  auto b = this->new_value(value);
+
+  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);
   if (b.has_value()) {
-    this->output(*b);
+    this->output(*b, is_initial);
   }
 }
 
-optional<bool> DelayedOnOffFilter::new_value(bool value) {
+optional<bool> DelayedOnOffFilter::new_value(bool value, bool is_initial) {
   if (value) {
-    this->set_timeout("ON_OFF", this->on_delay_.value(), [this]() { this->output(true); });
+    this->set_timeout("ON_OFF", this->on_delay_.value(), [this, is_initial]() { this->output(true, is_initial); });
   } else {
-    this->set_timeout("ON_OFF", this->off_delay_.value(), [this]() { this->output(false); });
+    this->set_timeout("ON_OFF", this->off_delay_.value(), [this, is_initial]() { this->output(false, is_initial); });
   }
   return {};
 }
 
 float DelayedOnOffFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-optional<bool> DelayedOnFilter::new_value(bool value) {
+optional<bool> DelayedOnFilter::new_value(bool value, bool is_initial) {
   if (value) {
-    this->set_timeout("ON", this->delay_.value(), [this]() { this->output(true); });
+    this->set_timeout("ON", this->delay_.value(), [this, is_initial]() { this->output(true, is_initial); });
     return {};
   } else {
     this->cancel_timeout("ON");
@@ -48,9 +49,9 @@ optional<bool> DelayedOnFilter::new_value(bool value) {
 
 float DelayedOnFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-optional<bool> DelayedOffFilter::new_value(bool value) {
+optional<bool> DelayedOffFilter::new_value(bool value, bool is_initial) {
   if (!value) {
-    this->set_timeout("OFF", this->delay_.value(), [this]() { this->output(false); });
+    this->set_timeout("OFF", this->delay_.value(), [this, is_initial]() { this->output(false, is_initial); });
     return {};
   } else {
     this->cancel_timeout("OFF");
@@ -60,11 +61,11 @@ optional<bool> DelayedOffFilter::new_value(bool value) {
 
 float DelayedOffFilter::get_setup_priority() const { return setup_priority::HARDWARE; }
 
-optional<bool> InvertFilter::new_value(bool value) { return !value; }
+optional<bool> InvertFilter::new_value(bool value, bool is_initial) { return !value; }
 
 AutorepeatFilter::AutorepeatFilter(std::vector<AutorepeatFilterTiming> timings) : timings_(std::move(timings)) {}
 
-optional<bool> AutorepeatFilter::new_value(bool value) {
+optional<bool> AutorepeatFilter::new_value(bool value, bool is_initial) {
   if (value) {
     // Ignore if already running
     if (this->active_timing_ != 0)
@@ -100,7 +101,7 @@ void AutorepeatFilter::next_timing_() {
 
 void AutorepeatFilter::next_value_(bool val) {
   const AutorepeatFilterTiming &timing = this->timings_[this->active_timing_ - 2];
-  this->output(val);  // This is at least the second one so not initial
+  this->output(val, false);  // 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); });
 }
 
@@ -108,18 +109,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) { return this->f_(value); }
+optional<bool> LambdaFilter::new_value(bool value, bool is_initial) { return this->f_(value); }
 
-optional<bool> SettleFilter::new_value(bool value) {
+optional<bool> SettleFilter::new_value(bool value, bool is_initial) {
   if (!this->steady_) {
-    this->set_timeout("SETTLE", this->delay_.value(), [this, value]() {
+    this->set_timeout("SETTLE", this->delay_.value(), [this, value, is_initial]() {
       this->steady_ = true;
-      this->output(value);
+      this->output(value, is_initial);
     });
     return {};
   } else {
     this->steady_ = false;
-    this->output(value);
+    this->output(value, is_initial);
     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) = 0;
+  virtual optional<bool> new_value(bool value, bool is_initial) = 0;
 
-  void input(bool value);
+  void input(bool value, bool is_initial);
 
-  void output(bool value);
+  void output(bool value, bool is_initial);
 
  protected:
   friend BinarySensor;
@@ -30,7 +30,7 @@ class Filter {
 
 class DelayedOnOffFilter : public Filter, public Component {
  public:
-  optional<bool> new_value(bool value) override;
+  optional<bool> new_value(bool value, bool is_initial) 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) override;
+  optional<bool> new_value(bool value, bool is_initial) 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) override;
+  optional<bool> new_value(bool value, bool is_initial) 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) override;
+  optional<bool> new_value(bool value, bool is_initial) 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) override;
+  optional<bool> new_value(bool value, bool is_initial) 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) override;
+  optional<bool> new_value(bool value, bool is_initial) 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) override;
+  optional<bool> new_value(bool value, bool is_initial) override;
 
   float get_setup_priority() const override;
 

esphome/components/bl0942/bl0942.cpp

@@ -196,17 +196,14 @@ void BL0942::received_package_(DataPacket *data) {
 }
 
 void BL0942::dump_config() {  // NOLINT(readability-function-cognitive-complexity)
-  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_);
+  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_);
   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,8 +1,7 @@
 from esphome import automation
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
-from esphome.components import esp32_ble, esp32_ble_client, esp32_ble_tracker
-from esphome.components.esp32_ble import BTLoggers
+from esphome.components import esp32_ble_client, esp32_ble_tracker
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CHARACTERISTIC_UUID,
@@ -288,9 +287,6 @@ 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,12 +10,9 @@ static const char *const TAG = "ble_binary_output";
 
 void BLEBinaryOutput::dump_config() {
   ESP_LOGCONFIG(TAG, "BLE Binary Output:");
-  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());
+  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());
   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,14 +15,11 @@ void BLESensor::loop() {}
 
 void BLESensor::dump_config() {
   LOG_SENSOR("", "BLE Sensor", this);
-  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_));
+  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_));
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/ble_client/text_sensor/ble_text_sensor.cpp

@@ -18,14 +18,11 @@ void BLETextSensor::loop() {}
 
 void BLETextSensor::dump_config() {
   LOG_TEXT_SENSOR("", "BLE Text Sensor", this);
-  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_));
+  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_));
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/bluetooth_proxy/__init__.py

@@ -1,7 +1,6 @@
 import esphome.codegen as cg
-from esphome.components import esp32_ble, esp32_ble_client, esp32_ble_tracker
+from esphome.components import 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
 
@@ -78,9 +77,6 @@ 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(const esp32_ble::BLEScanResult *scan_results, size_t count) {
+bool BluetoothProxy::parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_param *advertisements, 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(const esp32_ble::BLEScanResult *scan_results,
 
   // Add new advertisements to the batch buffer
   for (size_t i = 0; i < count; i++) {
-    auto &result = scan_results[i];
+    auto &result = advertisements[i];
     uint8_t length = result.adv_data_len + result.scan_rsp_len;
 
     batch_buffer.emplace_back();
@@ -146,11 +146,9 @@ 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\n"
-                "  Connections: %d\n"
-                "  Raw advertisements: %s",
-                YESNO(this->active_), this->connections_.size(), YESNO(this->raw_advertisements_));
+  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_));
 }
 
 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(const esp32_ble::BLEScanResult *scan_results, size_t count) override;
+  bool parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_param *advertisements, 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/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 #include <string>
 
 namespace esphome {
@@ -159,15 +159,11 @@ void BME680BSECComponent::dump_config() {
              this->bme680_status_);
   }
 
-  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_);
+  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_);
 
   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:\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_));
+  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_));
   if (this->bsec2_configuration_ != nullptr && this->bsec2_configuration_length_) {
     ESP_LOGCONFIG(TAG, "    Size: %" PRIu32, this->bsec2_configuration_length_);
   }
@@ -77,14 +77,11 @@ 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\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_);
+  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_);
 
 #ifdef USE_SENSOR
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);

esphome/components/bmp3xx_base/bmp3xx_base.cpp

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

esphome/components/bmp581/bmp581.cpp

@@ -98,20 +98,14 @@ void BMP581Component::dump_config() {
 
   if (this->temperature_sensor_) {
     LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
-    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_)));
+    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_)));
   }
 
   if (this->pressure_sensor_) {
     LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
-    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_)));
+    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_)));
   }
 }
 

esphome/components/bp1658cj/bp1658cj.cpp

@@ -26,10 +26,8 @@ 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\n"
-                "  White Channels Max Power: %u",
-                this->max_power_color_channels_, this->max_power_white_channels_);
+  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_);
 }
 
 void BP1658CJ::loop() {

esphome/components/button/__init__.py

@@ -108,7 +108,6 @@ 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,11 +52,9 @@ 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\n"
-                "  Manufacture ID: 0x%x\n"
-                "  Revision ID: 0x%x",
-                this->cap1188_product_id_, this->cap1188_manufacture_id_, this->cap1188_revision_);
+  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_);
 
   switch (this->error_code_) {
     case COMMUNICATION_FAILED:

esphome/components/ccs811/ccs811.cpp

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

esphome/components/chsc6x/chsc6x_touchscreen.cpp

@@ -38,11 +38,9 @@ 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\n"
-                "  x_raw_max_: %d\n"
-                "  y_raw_max_: %d",
-                this->touch_timeout_, this->x_raw_max_, this->y_raw_max_);
+  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_);
 }
 
 }  // namespace chsc6x

esphome/components/climate/__init__.py

@@ -443,7 +443,6 @@ 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,22 +569,17 @@ 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:\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());
+  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());
   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\n"
-                  "      - Max humidity: %.0f",
-                  traits.get_visual_min_humidity(), traits.get_visual_max_humidity());
+    ESP_LOGCONFIG(tag, "      - Min humidity: %.0f", traits.get_visual_min_humidity());
+    ESP_LOGCONFIG(tag, "      - Max humidity: %.0f", 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/log.h"
 #include "esphome/core/preferences.h"
+#include "esphome/core/log.h"
 #include "climate_mode.h"
 #include "climate_traits.h"
 

esphome/components/climate_ir/climate_ir.cpp

@@ -75,13 +75,10 @@ void ClimateIR::control(const climate::ClimateCall &call) {
 }
 void ClimateIR::dump_config() {
   LOG_CLIMATE("", "IR Climate", this);
-  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_));
+  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_));
 }
 
 }  // namespace climate_ir

esphome/components/const/__init__.py

@@ -3,5 +3,4 @@
 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,7 +189,6 @@ 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,23 +319,18 @@ bool CS5460AComponent::check_status_() {
 void CS5460AComponent::dump_config() {
   uint32_t state = this->get_component_state();
 
-  ESP_LOGCONFIG(TAG,
-                "CS5460A:\n"
-                "  Init status: %s",
+  ESP_LOGCONFIG(TAG, "CS5460A:");
+  ESP_LOGCONFIG(TAG, "  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 "\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_);
+  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_);
   LOG_SENSOR("  ", "Voltage", voltage_sensor_);
   LOG_SENSOR("  ", "Current", current_sensor_);
   LOG_SENSOR("  ", "Power", power_sensor_);

esphome/components/cse7766/cse7766.cpp

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

esphome/components/cst816/touchscreen/cst816_touchscreen.cpp

@@ -1,5 +1,4 @@
 #include "cst816_touchscreen.h"
-#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace cst816 {
@@ -75,10 +74,8 @@ 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\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_);
+  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_);
   const char *name;
   switch (this->chip_id_) {
     case CST820_CHIP_ID:

esphome/components/current_based/current_based_cover.cpp

@@ -151,10 +151,8 @@ 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\n"
-                "Malfunction detection: %s",
-                this->start_sensing_delay_ / 1e3f, YESNO(this->malfunction_detection_));
+  ESP_LOGCONFIG(TAG, "Start sensing delay: %.1fs", this->start_sensing_delay_ / 1e3f);
+  ESP_LOGCONFIG(TAG, "Malfunction detection: %s", 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/hal.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/hal.h"
 
 namespace esphome {
 namespace dac7678 {

esphome/components/daly_bms/daly_bms.cpp

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

esphome/components/datetime/__init__.py

@@ -158,9 +158,7 @@ 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)
-    entity_type = config[CONF_TYPE].lower()
-    cg.add(getattr(cg.App, f"register_{entity_type}")(var))
-    CORE.register_platform_component(entity_type, var)
+    cg.add(getattr(cg.App, f"register_{config[CONF_TYPE].lower()}")(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/helpers.h"
 #include "esphome/core/macros.h"
+#include "esphome/core/helpers.h"
 
 #ifdef USE_SENSOR
 #include "esphome/components/sensor/sensor.h"

esphome/components/debug/debug_esp32.cpp

@@ -107,10 +107,8 @@ std::string DebugComponent::get_wakeup_cause_() {
 }
 
 void DebugComponent::log_partition_info_() {
-  ESP_LOGCONFIG(TAG,
-                "Partition table:\n"
-                "  %-12s %-4s %-8s %-10s %-10s",
-                "Name", "Type", "Subtype", "Address", "Size");
+  ESP_LOGCONFIG(TAG, "Partition table:");
+  ESP_LOGCONFIG(TAG, "  %-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,8 +6,6 @@ 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)
 
@@ -64,10 +62,6 @@ 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,12 +46,10 @@ 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\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);
+    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);
   }
 }
 

esphome/components/dht/dht.cpp

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

esphome/components/display/display.h

@@ -182,11 +182,9 @@ using display_writer_t = std::function<void(Display &)>;
 
 #define LOG_DISPLAY(prefix, type, obj) \
   if ((obj) != nullptr) { \
-    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()); \
+    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()); \
   }
 
 /// Turn the pixel OFF.

esphome/components/dps310/dps310.cpp

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

esphome/components/dsmr/dsmr.cpp

@@ -278,11 +278,9 @@ bool Dsmr::parse_telegram() {
 }
 
 void Dsmr::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "DSMR:\n"
-                "  Max telegram length: %d\n"
-                "  Receive timeout: %.1fs",
-                this->max_telegram_len_, this->receive_timeout_ / 1e3f);
+  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);
   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/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace duty_cycle {

esphome/components/duty_time/duty_time_sensor.cpp

@@ -94,11 +94,9 @@ void DutyTimeSensor::publish_and_save_(const uint32_t sec, const uint32_t ms) {
 }
 
 void DutyTimeSensor::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "Duty Time:\n"
-                "  Update Interval: %" PRId32 "ms\n"
-                "  Restore: %s",
-                this->get_update_interval(), ONOFF(this->restore_));
+  ESP_LOGCONFIG(TAG, "Duty Time:");
+  ESP_LOGCONFIG(TAG, "  Update Interval: %" PRId32 "ms", this->get_update_interval());
+  ESP_LOGCONFIG(TAG, "  Restore: %s", 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/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace ee895 {

esphome/components/emc2101/emc2101.cpp

@@ -100,10 +100,8 @@ 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\n"
-                  "  PWM Divider: %02X",
-                  this->pwm_resolution_, this->pwm_divider_);
+    ESP_LOGCONFIG(TAG, "  PWM Resolution: %02X", this->pwm_resolution_);
+    ESP_LOGCONFIG(TAG, "  PWM Divider: %02X", this->pwm_divider_);
   }
   ESP_LOGCONFIG(TAG, "  Inverted: %s", YESNO(this->inverted_));
 }

esphome/components/es7210/es7210.cpp

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

esphome/components/es8311/es8311.cpp

@@ -52,13 +52,11 @@ void ES8311::setup() {
 }
 
 void ES8311::dump_config() {
-  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_);
+  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_);
 
   if (this->is_failed()) {
     ESP_LOGCONFIG(TAG, "  Failed to initialize!");

esphome/components/esp32/__init__.py

@@ -71,28 +71,12 @@ from .const import (  # noqa
 from .gpio import esp32_pin_to_code  # noqa
 
 _LOGGER = logging.getLogger(__name__)
-AUTO_LOAD = ["preferences"]
 CODEOWNERS = ["@esphome/core"]
+AUTO_LOAD = ["preferences"]
 IS_TARGET_PLATFORM = True
 
-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",
-}
+CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES = "enable_idf_experimental_features"
 
 
 def get_cpu_frequencies(*frequencies):
@@ -467,8 +451,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/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"
+                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}"
         # if platform version is a valid version constraint, prefix the default package
         cv.platformio_version_constraint(value)
         return f"platformio/espressif32@{value}"
@@ -558,10 +542,6 @@ 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(
         {
@@ -574,30 +554,11 @@ 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,
-                    # 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_ENABLE_IDF_EXPERIMENTAL_FEATURES): cv.boolean,
                 }
             ),
             cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
@@ -680,7 +641,7 @@ async def to_code(config):
     conf = config[CONF_FRAMEWORK]
     cg.add_platformio_option("platform", conf[CONF_PLATFORM_VERSION])
 
-    if conf[CONF_ADVANCED][CONF_IGNORE_EFUSE_CUSTOM_MAC]:
+    if CONF_ADVANCED in conf and conf[CONF_ADVANCED][CONF_IGNORE_EFUSE_CUSTOM_MAC]:
         cg.add_define("USE_ESP32_IGNORE_EFUSE_CUSTOM_MAC")
 
     add_extra_script(
@@ -711,6 +672,8 @@ 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)
@@ -724,41 +687,16 @@ 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])
             )
 
-        if assertion_level := advanced.get(CONF_ASSERTION_LEVEL):
-            for key, flag in ASSERTION_LEVELS.items():
-                add_idf_sdkconfig_option(flag, assertion_level == key)
+        for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():
+            add_idf_sdkconfig_option(name, RawSdkconfigValue(value))
 
-        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):
+        if conf[CONF_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(
@@ -768,7 +706,7 @@ async def to_code(config):
                 add_idf_sdkconfig_option(
                     "CONFIG_ESP32_PHY_CALIBRATION_AND_DATA_STORAGE", False
                 )
-        if advanced.get(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES):
+        if conf[CONF_ADVANCED].get(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES):
             _LOGGER.warning(
                 "Using experimental features in ESP-IDF may result in unexpected failures."
             )
@@ -781,9 +719,6 @@ 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,4 +1,3 @@
-from enum import Enum
 import re
 
 from esphome import automation
@@ -13,110 +12,9 @@ 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]
 
@@ -164,9 +62,6 @@ 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)
 
@@ -245,16 +140,6 @@ 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,9 +23,6 @@ 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);
 
@@ -307,52 +304,20 @@ void ESP32BLE::loop() {
   BLEEvent *ble_event = this->ble_events_.pop();
   while (ble_event != nullptr) {
     switch (ble_event->type_) {
-      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);
-        }
+      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);
         break;
-      }
-      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);
-        }
+      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);
         break;
-      }
-      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));
-          }
-        }
+      case BLEEvent::GAP:
+        this->real_gap_event_handler_(ble_event->event_.gap.gap_event, &ble_event->event_.gap.gap_param);
         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();
@@ -362,55 +327,59 @@ void ESP32BLE::loop() {
   }
 }
 
-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;
-  }
-
+void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_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(args...);
+  new (new_event) BLEEvent(event, param);
   global_ble->ble_events_.push(new_event);
 }  // NOLINT(clang-analyzer-unix.Malloc)
 
-// 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;
+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);
   }
-  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) {
-  enqueue_ble_event(event, gatts_if, 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);
+  }
 }
 
 void ESP32BLE::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                                    esp_ble_gattc_cb_param_t *param) {
-  enqueue_ble_event(event, gattc_if, 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);
+  }
 }
 
 float ESP32BLE::get_setup_priority() const { return setup_priority::BLUETOOTH; }
@@ -439,12 +408,10 @@ void ESP32BLE::dump_config() {
         io_capability_s = "invalid";
         break;
     }
-    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);
+    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);
   } else {
     ESP_LOGCONFIG(TAG, "ESP32 BLE: bluetooth stack is not enabled");
   }

esphome/components/esp32_ble/ble.h

@@ -2,7 +2,6 @@
 
 #include "ble_advertising.h"
 #include "ble_uuid.h"
-#include "ble_scan_result.h"
 
 #include <functional>
 
@@ -23,13 +22,6 @@
 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)
@@ -65,11 +57,6 @@ 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,
@@ -114,9 +101,6 @@ 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) {
@@ -129,16 +113,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,232 +2,92 @@
 
 #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 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.
+// This class stores each event in a single type.
 class BLEEvent {
  public:
-  // NOLINTNEXTLINE(readability-identifier-naming)
-  enum ble_event_t : uint8_t {
-    GAP,
-    GATTC,
-    GATTS,
+  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;
   };
 
-  // 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
+    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->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();
+        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->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();
+        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:
-        this->event_.gattc.data = nullptr;
         break;
     }
-  }
+    this->type_ = GATTC;
+  };
 
-  // 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
+    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->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;
+        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;
     }
-  }
-
-  // Disable copy to prevent double-delete
-  BLEEvent(const BLEEvent &) = delete;
-  BLEEvent &operator=(const BLEEvent &) = delete;
+    this->type_ = GATTS;
+  };
 
   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
+      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;  // Heap-allocated
-      std::vector<uint8_t> *data;             // Heap-allocated
-    } gattc;                                  // 16 bytes (pointers only)
+      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;  // Heap-allocated
-      std::vector<uint8_t> *data;             // Heap-allocated
-    } gatts;                                  // 16 bytes (pointers only)
-  } event_;                                   // 80 bytes
+      esp_ble_gatts_cb_param_t gatts_param;
+    } gatts;
+  } event_;
 
-  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; }
+  std::vector<uint8_t> data{};
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  enum ble_event_t : uint8_t {
+    GAP,
+    GATTC,
+    GATTS,
+  } type_;
 };
 
-// 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

@@ -1,24 +0,0 @@
-#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/hal.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/hal.h"
 
 #ifdef USE_ESP32
 

esphome/components/esp32_ble/queue.h

@@ -45,17 +45,6 @@ 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,10 +45,8 @@ void BLEClientBase::loop() {
 float BLEClientBase::get_setup_priority() const { return setup_priority::AFTER_BLUETOOTH; }
 
 void BLEClientBase::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "  Address: %s\n"
-                "  Auto-Connect: %s",
-                this->address_str().c_str(), TRUEFALSE(this->auto_connect_));
+  ESP_LOGCONFIG(TAG, "  Address: %s", this->address_str().c_str());
+  ESP_LOGCONFIG(TAG, "  Auto-Connect: %s", 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 BTLoggers, bt_uuid
+from esphome.components.esp32_ble import bt_uuid
 import esphome.config_validation as cv
 from esphome.config_validation import UNDEFINED
 from esphome.const import (
@@ -525,9 +525,6 @@ 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)