Merge branch 'dev' into drop_unique_id

These are no longer used in Home Assistant. This will be a breaking
change for MQTT for the sensors that defined custom unique ids.

esphome/components/adc/adc_sensor.h

@@ -72,10 +72,6 @@ class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage
   void set_sampling_mode(SamplingMode sampling_mode);
   float sample() override;
 
-#ifdef USE_ESP8266
-  std::string unique_id() override;
-#endif  // USE_ESP8266
-
 #ifdef USE_RP2040
   void set_is_temperature() { this->is_temperature_ = true; }
 #endif  // USE_RP2040

esphome/components/adc/adc_sensor_esp8266.cpp

@@ -56,8 +56,6 @@ float ADCSensor::sample() {
   return aggr.aggregate() / 1024.0f;
 }
 
-std::string ADCSensor::unique_id() { return get_mac_address() + "-adc"; }
-
 }  // namespace adc
 }  // namespace esphome
 

esphome/components/api/api.proto

@@ -272,7 +272,6 @@ message ListEntitiesBinarySensorResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string device_class = 5;
   bool is_status_binary_sensor = 6;
@@ -302,7 +301,6 @@ message ListEntitiesCoverResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   bool assumed_state = 5;
   bool supports_position = 6;
@@ -373,7 +371,6 @@ message ListEntitiesFanResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   bool supports_oscillation = 5;
   bool supports_speed = 6;
@@ -450,7 +447,6 @@ message ListEntitiesLightResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   repeated ColorMode supported_color_modes = 12;
   // next four supports_* are for legacy clients, newer clients should use color modes
@@ -542,7 +538,6 @@ message ListEntitiesSensorResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   string unit_of_measurement = 6;
@@ -577,7 +572,6 @@ message ListEntitiesSwitchResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   bool assumed_state = 6;
@@ -613,7 +607,6 @@ message ListEntitiesTextSensorResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -795,7 +788,6 @@ message ListEntitiesCameraResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
   bool disabled_by_default = 5;
   string icon = 6;
   EntityCategory entity_category = 7;
@@ -875,7 +867,6 @@ message ListEntitiesClimateResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   bool supports_current_temperature = 5;
   bool supports_two_point_target_temperature = 6;
@@ -970,7 +961,6 @@ message ListEntitiesNumberResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   float min_value = 6;
@@ -1013,7 +1003,6 @@ message ListEntitiesSelectResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   repeated string options = 6;
@@ -1051,7 +1040,6 @@ message ListEntitiesSirenResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1108,7 +1096,6 @@ message ListEntitiesLockResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1151,7 +1138,6 @@ message ListEntitiesButtonResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1202,7 +1188,6 @@ message ListEntitiesMediaPlayerResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1741,7 +1726,6 @@ message ListEntitiesAlarmControlPanelResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
   string icon = 5;
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
@@ -1782,7 +1766,6 @@ message ListEntitiesTextResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
   string icon = 5;
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
@@ -1824,7 +1807,6 @@ message ListEntitiesDateResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1865,7 +1847,6 @@ message ListEntitiesTimeResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1906,7 +1887,6 @@ message ListEntitiesEventResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1933,7 +1913,6 @@ message ListEntitiesValveResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1982,7 +1961,6 @@ message ListEntitiesDateTimeResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -2019,7 +1997,6 @@ message ListEntitiesUpdateResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
-  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;

esphome/components/api/api_connection.cpp

@@ -225,10 +225,6 @@ void APIConnection::loop() {
   }
 }
 
-std::string get_default_unique_id(const std::string &component_type, EntityBase *entity) {
-  return App.get_name() + component_type + entity->get_object_id();
-}
-
 DisconnectResponse APIConnection::disconnect(const DisconnectRequest &msg) {
   // remote initiated disconnect_client
   // don't close yet, we still need to send the disconnect response
@@ -295,7 +291,6 @@ uint16_t APIConnection::try_send_binary_sensor_info(EntityBase *entity, APIConne
   ListEntitiesBinarySensorResponse msg;
   msg.device_class = binary_sensor->get_device_class();
   msg.is_status_binary_sensor = binary_sensor->is_status_binary_sensor();
-  msg.unique_id = get_default_unique_id("binary_sensor", binary_sensor);
   fill_entity_info_base(binary_sensor, msg);
   return encode_message_to_buffer(msg, ListEntitiesBinarySensorResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -332,7 +327,6 @@ uint16_t APIConnection::try_send_cover_info(EntityBase *entity, APIConnection *c
   msg.supports_tilt = traits.get_supports_tilt();
   msg.supports_stop = traits.get_supports_stop();
   msg.device_class = cover->get_device_class();
-  msg.unique_id = get_default_unique_id("cover", cover);
   fill_entity_info_base(cover, msg);
   return encode_message_to_buffer(msg, ListEntitiesCoverResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -401,7 +395,6 @@ uint16_t APIConnection::try_send_fan_info(EntityBase *entity, APIConnection *con
   msg.supported_speed_count = traits.supported_speed_count();
   for (auto const &preset : traits.supported_preset_modes())
     msg.supported_preset_modes.push_back(preset);
-  msg.unique_id = get_default_unique_id("fan", fan);
   fill_entity_info_base(fan, msg);
   return encode_message_to_buffer(msg, ListEntitiesFanResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -481,7 +474,6 @@ uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *c
       msg.effects.push_back(effect->get_name());
     }
   }
-  msg.unique_id = get_default_unique_id("light", light);
   fill_entity_info_base(light, msg);
   return encode_message_to_buffer(msg, ListEntitiesLightResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -549,9 +541,6 @@ uint16_t APIConnection::try_send_sensor_info(EntityBase *entity, APIConnection *
   msg.force_update = sensor->get_force_update();
   msg.device_class = sensor->get_device_class();
   msg.state_class = static_cast<enums::SensorStateClass>(sensor->get_state_class());
-  msg.unique_id = sensor->unique_id();
-  if (msg.unique_id.empty())
-    msg.unique_id = get_default_unique_id("sensor", sensor);
   fill_entity_info_base(sensor, msg);
   return encode_message_to_buffer(msg, ListEntitiesSensorResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -580,7 +569,6 @@ uint16_t APIConnection::try_send_switch_info(EntityBase *entity, APIConnection *
   ListEntitiesSwitchResponse msg;
   msg.assumed_state = a_switch->assumed_state();
   msg.device_class = a_switch->get_device_class();
-  msg.unique_id = get_default_unique_id("switch", a_switch);
   fill_entity_info_base(a_switch, msg);
   return encode_message_to_buffer(msg, ListEntitiesSwitchResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -621,9 +609,6 @@ uint16_t APIConnection::try_send_text_sensor_info(EntityBase *entity, APIConnect
   auto *text_sensor = static_cast<text_sensor::TextSensor *>(entity);
   ListEntitiesTextSensorResponse msg;
   msg.device_class = text_sensor->get_device_class();
-  msg.unique_id = text_sensor->unique_id();
-  if (msg.unique_id.empty())
-    msg.unique_id = get_default_unique_id("text_sensor", text_sensor);
   fill_entity_info_base(text_sensor, msg);
   return encode_message_to_buffer(msg, ListEntitiesTextSensorResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -698,7 +683,6 @@ uint16_t APIConnection::try_send_climate_info(EntityBase *entity, APIConnection
     msg.supported_custom_presets.push_back(custom_preset);
   for (auto swing_mode : traits.get_supported_swing_modes())
     msg.supported_swing_modes.push_back(static_cast<enums::ClimateSwingMode>(swing_mode));
-  msg.unique_id = get_default_unique_id("climate", climate);
   fill_entity_info_base(climate, msg);
   return encode_message_to_buffer(msg, ListEntitiesClimateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -760,7 +744,6 @@ uint16_t APIConnection::try_send_number_info(EntityBase *entity, APIConnection *
   msg.min_value = number->traits.get_min_value();
   msg.max_value = number->traits.get_max_value();
   msg.step = number->traits.get_step();
-  msg.unique_id = get_default_unique_id("number", number);
   fill_entity_info_base(number, msg);
   return encode_message_to_buffer(msg, ListEntitiesNumberResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -797,7 +780,6 @@ uint16_t APIConnection::try_send_date_info(EntityBase *entity, APIConnection *co
                                            bool is_single) {
   auto *date = static_cast<datetime::DateEntity *>(entity);
   ListEntitiesDateResponse msg;
-  msg.unique_id = get_default_unique_id("date", date);
   fill_entity_info_base(date, msg);
   return encode_message_to_buffer(msg, ListEntitiesDateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -834,7 +816,6 @@ uint16_t APIConnection::try_send_time_info(EntityBase *entity, APIConnection *co
                                            bool is_single) {
   auto *time = static_cast<datetime::TimeEntity *>(entity);
   ListEntitiesTimeResponse msg;
-  msg.unique_id = get_default_unique_id("time", time);
   fill_entity_info_base(time, msg);
   return encode_message_to_buffer(msg, ListEntitiesTimeResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -873,7 +854,6 @@ uint16_t APIConnection::try_send_datetime_info(EntityBase *entity, APIConnection
                                                bool is_single) {
   auto *datetime = static_cast<datetime::DateTimeEntity *>(entity);
   ListEntitiesDateTimeResponse msg;
-  msg.unique_id = get_default_unique_id("datetime", datetime);
   fill_entity_info_base(datetime, msg);
   return encode_message_to_buffer(msg, ListEntitiesDateTimeResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -914,7 +894,6 @@ uint16_t APIConnection::try_send_text_info(EntityBase *entity, APIConnection *co
   msg.min_length = text->traits.get_min_length();
   msg.max_length = text->traits.get_max_length();
   msg.pattern = text->traits.get_pattern();
-  msg.unique_id = get_default_unique_id("text", text);
   fill_entity_info_base(text, msg);
   return encode_message_to_buffer(msg, ListEntitiesTextResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -953,7 +932,6 @@ uint16_t APIConnection::try_send_select_info(EntityBase *entity, APIConnection *
   ListEntitiesSelectResponse msg;
   for (const auto &option : select->traits.get_options())
     msg.options.push_back(option);
-  msg.unique_id = get_default_unique_id("select", select);
   fill_entity_info_base(select, msg);
   return encode_message_to_buffer(msg, ListEntitiesSelectResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -977,7 +955,6 @@ uint16_t APIConnection::try_send_button_info(EntityBase *entity, APIConnection *
   auto *button = static_cast<button::Button *>(entity);
   ListEntitiesButtonResponse msg;
   msg.device_class = button->get_device_class();
-  msg.unique_id = get_default_unique_id("button", button);
   fill_entity_info_base(button, msg);
   return encode_message_to_buffer(msg, ListEntitiesButtonResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -1014,7 +991,6 @@ uint16_t APIConnection::try_send_lock_info(EntityBase *entity, APIConnection *co
   msg.assumed_state = a_lock->traits.get_assumed_state();
   msg.supports_open = a_lock->traits.get_supports_open();
   msg.requires_code = a_lock->traits.get_requires_code();
-  msg.unique_id = get_default_unique_id("lock", a_lock);
   fill_entity_info_base(a_lock, msg);
   return encode_message_to_buffer(msg, ListEntitiesLockResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -1062,7 +1038,6 @@ uint16_t APIConnection::try_send_valve_info(EntityBase *entity, APIConnection *c
   msg.assumed_state = traits.get_is_assumed_state();
   msg.supports_position = traits.get_supports_position();
   msg.supports_stop = traits.get_supports_stop();
-  msg.unique_id = get_default_unique_id("valve", valve);
   fill_entity_info_base(valve, msg);
   return encode_message_to_buffer(msg, ListEntitiesValveResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -1117,7 +1092,6 @@ uint16_t APIConnection::try_send_media_player_info(EntityBase *entity, APIConnec
     media_format.sample_bytes = supported_format.sample_bytes;
     msg.supported_formats.push_back(media_format);
   }
-  msg.unique_id = get_default_unique_id("media_player", media_player);
   fill_entity_info_base(media_player, msg);
   return encode_message_to_buffer(msg, ListEntitiesMediaPlayerResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -1160,7 +1134,6 @@ uint16_t APIConnection::try_send_camera_info(EntityBase *entity, APIConnection *
                                              bool is_single) {
   auto *camera = static_cast<esp32_camera::ESP32Camera *>(entity);
   ListEntitiesCameraResponse msg;
-  msg.unique_id = get_default_unique_id("camera", camera);
   fill_entity_info_base(camera, msg);
   return encode_message_to_buffer(msg, ListEntitiesCameraResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -1373,7 +1346,6 @@ uint16_t APIConnection::try_send_alarm_control_panel_info(EntityBase *entity, AP
   msg.supported_features = a_alarm_control_panel->get_supported_features();
   msg.requires_code = a_alarm_control_panel->get_requires_code();
   msg.requires_code_to_arm = a_alarm_control_panel->get_requires_code_to_arm();
-  msg.unique_id = get_default_unique_id("alarm_control_panel", a_alarm_control_panel);
   fill_entity_info_base(a_alarm_control_panel, msg);
   return encode_message_to_buffer(msg, ListEntitiesAlarmControlPanelResponse::MESSAGE_TYPE, conn, remaining_size,
                                   is_single);
@@ -1434,7 +1406,6 @@ uint16_t APIConnection::try_send_event_info(EntityBase *entity, APIConnection *c
   msg.device_class = event->get_device_class();
   for (const auto &event_type : event->get_event_types())
     msg.event_types.push_back(event_type);
-  msg.unique_id = get_default_unique_id("event", event);
   fill_entity_info_base(event, msg);
   return encode_message_to_buffer(msg, ListEntitiesEventResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -1472,7 +1443,6 @@ uint16_t APIConnection::try_send_update_info(EntityBase *entity, APIConnection *
   auto *update = static_cast<update::UpdateEntity *>(entity);
   ListEntitiesUpdateResponse msg;
   msg.device_class = update->get_device_class();
-  msg.unique_id = get_default_unique_id("update", update);
   fill_entity_info_base(update, msg);
   return encode_message_to_buffer(msg, ListEntitiesUpdateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }

esphome/components/api/api_pb2.cpp

@@ -1079,10 +1079,6 @@ bool ListEntitiesBinarySensorResponse::decode_length(uint32_t field_id, ProtoLen
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->device_class = value.as_string();
       return true;
@@ -1109,7 +1105,6 @@ void ListEntitiesBinarySensorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->device_class);
   buffer.encode_bool(6, this->is_status_binary_sensor);
   buffer.encode_bool(7, this->disabled_by_default);
@@ -1120,7 +1115,6 @@ void ListEntitiesBinarySensorResponse::calculate_size(uint32_t &total_size) cons
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->device_class, false);
   ProtoSize::add_bool_field(total_size, 1, this->is_status_binary_sensor, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
@@ -1144,10 +1138,6 @@ void ListEntitiesBinarySensorResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  device_class: ");
   out.append("'").append(this->device_class).append("'");
   out.append("\n");
@@ -1263,10 +1253,6 @@ bool ListEntitiesCoverResponse::decode_length(uint32_t field_id, ProtoLengthDeli
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 8: {
       this->device_class = value.as_string();
       return true;
@@ -1293,7 +1279,6 @@ void ListEntitiesCoverResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_bool(5, this->assumed_state);
   buffer.encode_bool(6, this->supports_position);
   buffer.encode_bool(7, this->supports_tilt);
@@ -1307,7 +1292,6 @@ void ListEntitiesCoverResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_bool_field(total_size, 1, this->assumed_state, false);
   ProtoSize::add_bool_field(total_size, 1, this->supports_position, false);
   ProtoSize::add_bool_field(total_size, 1, this->supports_tilt, false);
@@ -1334,10 +1318,6 @@ void ListEntitiesCoverResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  assumed_state: ");
   out.append(YESNO(this->assumed_state));
   out.append("\n");
@@ -1592,10 +1572,6 @@ bool ListEntitiesFanResponse::decode_length(uint32_t field_id, ProtoLengthDelimi
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 10: {
       this->icon = value.as_string();
       return true;
@@ -1622,7 +1598,6 @@ void ListEntitiesFanResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_bool(5, this->supports_oscillation);
   buffer.encode_bool(6, this->supports_speed);
   buffer.encode_bool(7, this->supports_direction);
@@ -1638,7 +1613,6 @@ void ListEntitiesFanResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_bool_field(total_size, 1, this->supports_oscillation, false);
   ProtoSize::add_bool_field(total_size, 1, this->supports_speed, false);
   ProtoSize::add_bool_field(total_size, 1, this->supports_direction, false);
@@ -1669,10 +1643,6 @@ void ListEntitiesFanResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  supports_oscillation: ");
   out.append(YESNO(this->supports_oscillation));
   out.append("\n");
@@ -2014,10 +1984,6 @@ bool ListEntitiesLightResponse::decode_length(uint32_t field_id, ProtoLengthDeli
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 11: {
       this->effects.push_back(value.as_string());
       return true;
@@ -2052,7 +2018,6 @@ void ListEntitiesLightResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   for (auto &it : this->supported_color_modes) {
     buffer.encode_enum<enums::ColorMode>(12, it, true);
   }
@@ -2073,7 +2038,6 @@ void ListEntitiesLightResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   if (!this->supported_color_modes.empty()) {
     for (const auto &it : this->supported_color_modes) {
       ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(it), true);
@@ -2111,10 +2075,6 @@ void ListEntitiesLightResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   for (const auto &it : this->supported_color_modes) {
     out.append("  supported_color_modes: ");
     out.append(proto_enum_to_string<enums::ColorMode>(it));
@@ -2685,10 +2645,6 @@ bool ListEntitiesSensorResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -2719,7 +2675,6 @@ void ListEntitiesSensorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_string(6, this->unit_of_measurement);
   buffer.encode_int32(7, this->accuracy_decimals);
@@ -2734,7 +2689,6 @@ void ListEntitiesSensorResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_string_field(total_size, 1, this->unit_of_measurement, false);
   ProtoSize::add_int32_field(total_size, 1, this->accuracy_decimals, false);
@@ -2762,10 +2716,6 @@ void ListEntitiesSensorResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -2887,10 +2837,6 @@ bool ListEntitiesSwitchResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -2917,7 +2863,6 @@ void ListEntitiesSwitchResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->assumed_state);
   buffer.encode_bool(7, this->disabled_by_default);
@@ -2928,7 +2873,6 @@ void ListEntitiesSwitchResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->assumed_state, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
@@ -2952,10 +2896,6 @@ void ListEntitiesSwitchResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -3088,10 +3028,6 @@ bool ListEntitiesTextSensorResponse::decode_length(uint32_t field_id, ProtoLengt
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -3118,7 +3054,6 @@ void ListEntitiesTextSensorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -3128,7 +3063,6 @@ void ListEntitiesTextSensorResponse::calculate_size(uint32_t &total_size) const
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -3151,10 +3085,6 @@ void ListEntitiesTextSensorResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -3955,10 +3885,6 @@ bool ListEntitiesCameraResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 6: {
       this->icon = value.as_string();
       return true;
@@ -3981,7 +3907,6 @@ void ListEntitiesCameraResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_bool(5, this->disabled_by_default);
   buffer.encode_string(6, this->icon);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -3990,7 +3915,6 @@ void ListEntitiesCameraResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -4012,10 +3936,6 @@ void ListEntitiesCameraResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  disabled_by_default: ");
   out.append(YESNO(this->disabled_by_default));
   out.append("\n");
@@ -4189,10 +4109,6 @@ bool ListEntitiesClimateResponse::decode_length(uint32_t field_id, ProtoLengthDe
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 15: {
       this->supported_custom_fan_modes.push_back(value.as_string());
       return true;
@@ -4247,7 +4163,6 @@ void ListEntitiesClimateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_bool(5, this->supports_current_temperature);
   buffer.encode_bool(6, this->supports_two_point_target_temperature);
   for (auto &it : this->supported_modes) {
@@ -4286,7 +4201,6 @@ void ListEntitiesClimateResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_bool_field(total_size, 1, this->supports_current_temperature, false);
   ProtoSize::add_bool_field(total_size, 1, this->supports_two_point_target_temperature, false);
   if (!this->supported_modes.empty()) {
@@ -4350,10 +4264,6 @@ void ListEntitiesClimateResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  supports_current_temperature: ");
   out.append(YESNO(this->supports_current_temperature));
   out.append("\n");
@@ -4934,10 +4844,6 @@ bool ListEntitiesNumberResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -4980,7 +4886,6 @@ void ListEntitiesNumberResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_float(6, this->min_value);
   buffer.encode_float(7, this->max_value);
@@ -4995,7 +4900,6 @@ void ListEntitiesNumberResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->min_value != 0.0f, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->max_value != 0.0f, false);
@@ -5023,10 +4927,6 @@ void ListEntitiesNumberResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -5184,10 +5084,6 @@ bool ListEntitiesSelectResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -5214,7 +5110,6 @@ void ListEntitiesSelectResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   for (auto &it : this->options) {
     buffer.encode_string(6, it, true);
@@ -5226,7 +5121,6 @@ void ListEntitiesSelectResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   if (!this->options.empty()) {
     for (const auto &it : this->options) {
@@ -5253,10 +5147,6 @@ void ListEntitiesSelectResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -5411,10 +5301,6 @@ bool ListEntitiesSirenResponse::decode_length(uint32_t field_id, ProtoLengthDeli
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -5441,7 +5327,6 @@ void ListEntitiesSirenResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   for (auto &it : this->tones) {
@@ -5455,7 +5340,6 @@ void ListEntitiesSirenResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   if (!this->tones.empty()) {
@@ -5484,10 +5368,6 @@ void ListEntitiesSirenResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -5716,10 +5596,6 @@ bool ListEntitiesLockResponse::decode_length(uint32_t field_id, ProtoLengthDelim
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -5746,7 +5622,6 @@ void ListEntitiesLockResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -5759,7 +5634,6 @@ void ListEntitiesLockResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -5785,10 +5659,6 @@ void ListEntitiesLockResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -5955,10 +5825,6 @@ bool ListEntitiesButtonResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -5985,7 +5851,6 @@ void ListEntitiesButtonResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -5995,7 +5860,6 @@ void ListEntitiesButtonResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -6018,10 +5882,6 @@ void ListEntitiesButtonResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -6168,10 +6028,6 @@ bool ListEntitiesMediaPlayerResponse::decode_length(uint32_t field_id, ProtoLeng
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -6198,7 +6054,6 @@ void ListEntitiesMediaPlayerResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -6211,7 +6066,6 @@ void ListEntitiesMediaPlayerResponse::calculate_size(uint32_t &total_size) const
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -6235,10 +6089,6 @@ void ListEntitiesMediaPlayerResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -8590,10 +8440,6 @@ bool ListEntitiesAlarmControlPanelResponse::decode_length(uint32_t field_id, Pro
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -8616,7 +8462,6 @@ void ListEntitiesAlarmControlPanelResponse::encode(ProtoWriteBuffer buffer) cons
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -8628,7 +8473,6 @@ void ListEntitiesAlarmControlPanelResponse::calculate_size(uint32_t &total_size)
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -8653,10 +8497,6 @@ void ListEntitiesAlarmControlPanelResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -8822,10 +8662,6 @@ bool ListEntitiesTextResponse::decode_length(uint32_t field_id, ProtoLengthDelim
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -8852,7 +8688,6 @@ void ListEntitiesTextResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -8865,7 +8700,6 @@ void ListEntitiesTextResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -8891,10 +8725,6 @@ void ListEntitiesTextResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -9053,10 +8883,6 @@ bool ListEntitiesDateResponse::decode_length(uint32_t field_id, ProtoLengthDelim
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -9079,7 +8905,6 @@ void ListEntitiesDateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -9088,7 +8913,6 @@ void ListEntitiesDateResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -9110,10 +8934,6 @@ void ListEntitiesDateResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -9294,10 +9114,6 @@ bool ListEntitiesTimeResponse::decode_length(uint32_t field_id, ProtoLengthDelim
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -9320,7 +9136,6 @@ void ListEntitiesTimeResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -9329,7 +9144,6 @@ void ListEntitiesTimeResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -9351,10 +9165,6 @@ void ListEntitiesTimeResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -9535,10 +9345,6 @@ bool ListEntitiesEventResponse::decode_length(uint32_t field_id, ProtoLengthDeli
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -9569,7 +9375,6 @@ void ListEntitiesEventResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -9582,7 +9387,6 @@ void ListEntitiesEventResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -9610,10 +9414,6 @@ void ListEntitiesEventResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -9717,10 +9517,6 @@ bool ListEntitiesValveResponse::decode_length(uint32_t field_id, ProtoLengthDeli
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -9747,7 +9543,6 @@ void ListEntitiesValveResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -9760,7 +9555,6 @@ void ListEntitiesValveResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -9786,10 +9580,6 @@ void ListEntitiesValveResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -9962,10 +9752,6 @@ bool ListEntitiesDateTimeResponse::decode_length(uint32_t field_id, ProtoLengthD
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -9988,7 +9774,6 @@ void ListEntitiesDateTimeResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -9997,7 +9782,6 @@ void ListEntitiesDateTimeResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -10019,10 +9803,6 @@ void ListEntitiesDateTimeResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -10153,10 +9933,6 @@ bool ListEntitiesUpdateResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->name = value.as_string();
       return true;
     }
-    case 4: {
-      this->unique_id = value.as_string();
-      return true;
-    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -10183,7 +9959,6 @@ void ListEntitiesUpdateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
-  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -10193,7 +9968,6 @@ void ListEntitiesUpdateResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
-  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -10216,10 +9990,6 @@ void ListEntitiesUpdateResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
-  out.append("  unique_id: ");
-  out.append("'").append(this->unique_id).append("'");
-  out.append("\n");
-
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");

esphome/components/api/api_pb2.h

@@ -494,7 +494,6 @@ class ListEntitiesBinarySensorResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string device_class{};
   bool is_status_binary_sensor{false};
   bool disabled_by_default{false};
@@ -541,7 +540,6 @@ class ListEntitiesCoverResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   bool assumed_state{false};
   bool supports_position{false};
   bool supports_tilt{false};
@@ -618,7 +616,6 @@ class ListEntitiesFanResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   bool supports_oscillation{false};
   bool supports_speed{false};
   bool supports_direction{false};
@@ -704,7 +701,6 @@ class ListEntitiesLightResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::vector<enums::ColorMode> supported_color_modes{};
   bool legacy_supports_brightness{false};
   bool legacy_supports_rgb{false};
@@ -813,7 +809,6 @@ class ListEntitiesSensorResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   std::string unit_of_measurement{};
   int32_t accuracy_decimals{0};
@@ -864,7 +859,6 @@ class ListEntitiesSwitchResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   bool assumed_state{false};
   bool disabled_by_default{false};
@@ -929,7 +923,6 @@ class ListEntitiesTextSensorResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -1259,7 +1252,6 @@ class ListEntitiesCameraResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   bool disabled_by_default{false};
   std::string icon{};
   enums::EntityCategory entity_category{};
@@ -1323,7 +1315,6 @@ class ListEntitiesClimateResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   bool supports_current_temperature{false};
   bool supports_two_point_target_temperature{false};
   std::vector<enums::ClimateMode> supported_modes{};
@@ -1440,7 +1431,6 @@ class ListEntitiesNumberResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   float min_value{0.0f};
   float max_value{0.0f};
@@ -1509,7 +1499,6 @@ class ListEntitiesSelectResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   std::vector<std::string> options{};
   bool disabled_by_default{false};
@@ -1575,7 +1564,6 @@ class ListEntitiesSirenResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   std::vector<std::string> tones{};
@@ -1649,7 +1637,6 @@ class ListEntitiesLockResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -1719,7 +1706,6 @@ class ListEntitiesButtonResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -1779,7 +1765,6 @@ class ListEntitiesMediaPlayerResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -2663,7 +2648,6 @@ class ListEntitiesAlarmControlPanelResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -2731,7 +2715,6 @@ class ListEntitiesTextResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -2800,7 +2783,6 @@ class ListEntitiesDateResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -2868,7 +2850,6 @@ class ListEntitiesTimeResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -2936,7 +2917,6 @@ class ListEntitiesEventResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -2982,7 +2962,6 @@ class ListEntitiesValveResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -3052,7 +3031,6 @@ class ListEntitiesDateTimeResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -3115,7 +3093,6 @@ class ListEntitiesUpdateResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
-  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};

esphome/components/api/api_server.cpp

@@ -227,7 +227,7 @@ 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;
   for (auto &c : this->clients_)

esphome/components/api/api_server.h

@@ -54,7 +54,7 @@ class APIServer : public Component, public Controller {
 
   void handle_disconnect(APIConnection *conn);
 #ifdef USE_BINARY_SENSOR
-  void on_binary_sensor_update(binary_sensor::BinarySensor *obj) 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;

esphome/components/api/client.py

@@ -46,10 +46,12 @@ async def async_run_logs(config: dict[str, Any], address: str) -> None:
         time_ = datetime.now()
         message: bytes = msg.message
         text = message.decode("utf8", "backslashreplace")
+        if dashboard:
+            text = text.replace("\033", "\\033")
         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)
+            print(parsed_msg)
 
     stop = await async_run(cli, on_log, name=name)
     try:

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)
@@ -636,18 +591,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/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();

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/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/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; }

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/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_tracker/__init__.py

@@ -268,7 +268,6 @@ async def to_code(config):
 
     parent = await cg.get_variable(config[esp32_ble.CONF_BLE_ID])
     cg.add(parent.register_gap_event_handler(var))
-    cg.add(parent.register_gap_scan_event_handler(var))
     cg.add(parent.register_gattc_event_handler(var))
     cg.add(parent.register_ble_status_event_handler(var))
     cg.add(var.set_parent(parent))

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -50,8 +50,9 @@ void ESP32BLETracker::setup() {
     ESP_LOGE(TAG, "BLE Tracker was marked failed by ESP32BLE");
     return;
   }
-  ExternalRAMAllocator<BLEScanResult> allocator(ExternalRAMAllocator<BLEScanResult>::ALLOW_FAILURE);
-  this->scan_result_buffer_ = allocator.allocate(SCAN_RESULT_BUFFER_SIZE);
+  ExternalRAMAllocator<esp_ble_gap_cb_param_t::ble_scan_result_evt_param> allocator(
+      ExternalRAMAllocator<esp_ble_gap_cb_param_t::ble_scan_result_evt_param>::ALLOW_FAILURE);
+  this->scan_result_buffer_ = allocator.allocate(ESP32BLETracker::SCAN_RESULT_BUFFER_SIZE);
 
   if (this->scan_result_buffer_ == nullptr) {
     ESP_LOGE(TAG, "Could not allocate buffer for BLE Tracker!");
@@ -123,7 +124,7 @@ void ESP32BLETracker::loop() {
       this->scan_result_index_ &&  // if it looks like we have a scan result we will take the lock
       xSemaphoreTake(this->scan_result_lock_, 0)) {
     uint32_t index = this->scan_result_index_;
-    if (index >= SCAN_RESULT_BUFFER_SIZE) {
+    if (index >= ESP32BLETracker::SCAN_RESULT_BUFFER_SIZE) {
       ESP_LOGW(TAG, "Too many BLE events to process. Some devices may not show up.");
     }
 
@@ -369,6 +370,9 @@ void ESP32BLETracker::recalculate_advertisement_parser_types() {
 
 void ESP32BLETracker::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
   switch (event) {
+    case ESP_GAP_BLE_SCAN_RESULT_EVT:
+      this->gap_scan_result_(param->scan_rst);
+      break;
     case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
       this->gap_scan_set_param_complete_(param->scan_param_cmpl);
       break;
@@ -381,42 +385,11 @@ void ESP32BLETracker::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_ga
     default:
       break;
   }
-  // Forward all events to clients (scan results are handled separately via gap_scan_event_handler)
   for (auto *client : this->clients_) {
     client->gap_event_handler(event, param);
   }
 }
 
-void ESP32BLETracker::gap_scan_event_handler(const BLEScanResult &scan_result) {
-  ESP_LOGV(TAG, "gap_scan_result - event %d", scan_result.search_evt);
-
-  if (scan_result.search_evt == ESP_GAP_SEARCH_INQ_RES_EVT) {
-    if (xSemaphoreTake(this->scan_result_lock_, 0)) {
-      if (this->scan_result_index_ < SCAN_RESULT_BUFFER_SIZE) {
-        // Store BLEScanResult directly in our buffer
-        this->scan_result_buffer_[this->scan_result_index_++] = scan_result;
-      }
-      xSemaphoreGive(this->scan_result_lock_);
-    }
-  } else if (scan_result.search_evt == ESP_GAP_SEARCH_INQ_CMPL_EVT) {
-    // Scan finished on its own
-    if (this->scanner_state_ != ScannerState::RUNNING) {
-      if (this->scanner_state_ == ScannerState::STOPPING) {
-        ESP_LOGE(TAG, "Scan was not running when scan completed.");
-      } else if (this->scanner_state_ == ScannerState::STARTING) {
-        ESP_LOGE(TAG, "Scan was not started when scan completed.");
-      } else if (this->scanner_state_ == ScannerState::FAILED) {
-        ESP_LOGE(TAG, "Scan was in failed state when scan completed.");
-      } else if (this->scanner_state_ == ScannerState::IDLE) {
-        ESP_LOGE(TAG, "Scan was idle when scan completed.");
-      } else if (this->scanner_state_ == ScannerState::STOPPED) {
-        ESP_LOGE(TAG, "Scan was stopped when scan completed.");
-      }
-    }
-    this->set_scanner_state_(ScannerState::STOPPED);
-  }
-}
-
 void ESP32BLETracker::gap_scan_set_param_complete_(const esp_ble_gap_cb_param_t::ble_scan_param_cmpl_evt_param &param) {
   ESP_LOGV(TAG, "gap_scan_set_param_complete - status %d", param.status);
   if (param.status == ESP_BT_STATUS_DONE) {
@@ -471,6 +444,34 @@ void ESP32BLETracker::gap_scan_stop_complete_(const esp_ble_gap_cb_param_t::ble_
   this->set_scanner_state_(ScannerState::STOPPED);
 }
 
+void ESP32BLETracker::gap_scan_result_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) {
+  ESP_LOGV(TAG, "gap_scan_result - event %d", param.search_evt);
+  if (param.search_evt == ESP_GAP_SEARCH_INQ_RES_EVT) {
+    if (xSemaphoreTake(this->scan_result_lock_, 0)) {
+      if (this->scan_result_index_ < ESP32BLETracker::SCAN_RESULT_BUFFER_SIZE) {
+        this->scan_result_buffer_[this->scan_result_index_++] = param;
+      }
+      xSemaphoreGive(this->scan_result_lock_);
+    }
+  } else if (param.search_evt == ESP_GAP_SEARCH_INQ_CMPL_EVT) {
+    // Scan finished on its own
+    if (this->scanner_state_ != ScannerState::RUNNING) {
+      if (this->scanner_state_ == ScannerState::STOPPING) {
+        ESP_LOGE(TAG, "Scan was not running when scan completed.");
+      } else if (this->scanner_state_ == ScannerState::STARTING) {
+        ESP_LOGE(TAG, "Scan was not started when scan completed.");
+      } else if (this->scanner_state_ == ScannerState::FAILED) {
+        ESP_LOGE(TAG, "Scan was in failed state when scan completed.");
+      } else if (this->scanner_state_ == ScannerState::IDLE) {
+        ESP_LOGE(TAG, "Scan was idle when scan completed.");
+      } else if (this->scanner_state_ == ScannerState::STOPPED) {
+        ESP_LOGE(TAG, "Scan was stopped when scan completed.");
+      }
+    }
+    this->set_scanner_state_(ScannerState::STOPPED);
+  }
+}
+
 void ESP32BLETracker::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                                           esp_ble_gattc_cb_param_t *param) {
   for (auto *client : this->clients_) {
@@ -493,15 +494,13 @@ optional<ESPBLEiBeacon> ESPBLEiBeacon::from_manufacturer_data(const ServiceData
   return ESPBLEiBeacon(data.data.data());
 }
 
-void ESPBTDevice::parse_scan_rst(const BLEScanResult &scan_result) {
+void ESPBTDevice::parse_scan_rst(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) {
+  this->scan_result_ = param;
   for (uint8_t i = 0; i < ESP_BD_ADDR_LEN; i++)
-    this->address_[i] = scan_result.bda[i];
-  this->address_type_ = static_cast<esp_ble_addr_type_t>(scan_result.ble_addr_type);
-  this->rssi_ = scan_result.rssi;
-
-  // Parse advertisement data directly
-  uint8_t total_len = scan_result.adv_data_len + scan_result.scan_rsp_len;
-  this->parse_adv_(scan_result.ble_adv, total_len);
+    this->address_[i] = param.bda[i];
+  this->address_type_ = param.ble_addr_type;
+  this->rssi_ = param.rssi;
+  this->parse_adv_(param);
 
 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
   ESP_LOGVV(TAG, "Parse Result:");
@@ -559,13 +558,13 @@ void ESPBTDevice::parse_scan_rst(const BLEScanResult &scan_result) {
     ESP_LOGVV(TAG, "    Data: %s", format_hex_pretty(data.data).c_str());
   }
 
-  ESP_LOGVV(TAG, "  Adv data: %s",
-            format_hex_pretty(scan_result.ble_adv, scan_result.adv_data_len + scan_result.scan_rsp_len).c_str());
+  ESP_LOGVV(TAG, "  Adv data: %s", format_hex_pretty(param.ble_adv, param.adv_data_len + param.scan_rsp_len).c_str());
 #endif
 }
-
-void ESPBTDevice::parse_adv_(const uint8_t *payload, uint8_t len) {
+void ESPBTDevice::parse_adv_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) {
   size_t offset = 0;
+  const uint8_t *payload = param.ble_adv;
+  uint8_t len = param.adv_data_len + param.scan_rsp_len;
 
   while (offset + 2 < len) {
     const uint8_t field_length = payload[offset++];  // First byte is length of adv record

esphome/components/esp32_ble_tracker/esp32_ble_tracker.h

@@ -62,7 +62,7 @@ class ESPBLEiBeacon {
 
 class ESPBTDevice {
  public:
-  void parse_scan_rst(const BLEScanResult &scan_result);
+  void parse_scan_rst(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param);
 
   std::string address_str() const;
 
@@ -84,6 +84,8 @@ class ESPBTDevice {
 
   const std::vector<ServiceData> &get_service_datas() const { return service_datas_; }
 
+  const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &get_scan_result() const { return scan_result_; }
+
   bool resolve_irk(const uint8_t *irk) const;
 
   optional<ESPBLEiBeacon> get_ibeacon() const {
@@ -96,7 +98,7 @@ class ESPBTDevice {
   }
 
  protected:
-  void parse_adv_(const uint8_t *payload, uint8_t len);
+  void parse_adv_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param);
 
   esp_bd_addr_t address_{
       0,
@@ -110,6 +112,7 @@ class ESPBTDevice {
   std::vector<ESPBTUUID> service_uuids_{};
   std::vector<ServiceData> manufacturer_datas_{};
   std::vector<ServiceData> service_datas_{};
+  esp_ble_gap_cb_param_t::ble_scan_result_evt_param scan_result_{};
 };
 
 class ESP32BLETracker;
@@ -118,7 +121,9 @@ class ESPBTDeviceListener {
  public:
   virtual void on_scan_end() {}
   virtual bool parse_device(const ESPBTDevice &device) = 0;
-  virtual bool parse_devices(const BLEScanResult *scan_results, size_t count) { return false; };
+  virtual bool parse_devices(esp_ble_gap_cb_param_t::ble_scan_result_evt_param *advertisements, size_t count) {
+    return false;
+  };
   virtual AdvertisementParserType get_advertisement_parser_type() {
     return AdvertisementParserType::PARSED_ADVERTISEMENTS;
   };
@@ -205,7 +210,6 @@ class ESPBTClient : public ESPBTDeviceListener {
 
 class ESP32BLETracker : public Component,
                         public GAPEventHandler,
-                        public GAPScanEventHandler,
                         public GATTcEventHandler,
                         public BLEStatusEventHandler,
                         public Parented<ESP32BLE> {
@@ -236,7 +240,6 @@ class ESP32BLETracker : public Component,
   void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                            esp_ble_gattc_cb_param_t *param) override;
   void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) override;
-  void gap_scan_event_handler(const BLEScanResult &scan_result) override;
   void ble_before_disabled_event_handler() override;
 
   void add_scanner_state_callback(std::function<void(ScannerState)> &&callback) {
@@ -284,7 +287,12 @@ class ESP32BLETracker : public Component,
   bool parse_advertisements_{false};
   SemaphoreHandle_t scan_result_lock_;
   size_t scan_result_index_{0};
-  BLEScanResult *scan_result_buffer_;
+#ifdef USE_PSRAM
+  const static u_int8_t SCAN_RESULT_BUFFER_SIZE = 32;
+#else
+  const static u_int8_t SCAN_RESULT_BUFFER_SIZE = 20;
+#endif  // USE_PSRAM
+  esp_ble_gap_cb_param_t::ble_scan_result_evt_param *scan_result_buffer_;
   esp_bt_status_t scan_start_failed_{ESP_BT_STATUS_SUCCESS};
   esp_bt_status_t scan_set_param_failed_{ESP_BT_STATUS_SUCCESS};
   int connecting_{0};

esphome/components/esp32_hall/esp32_hall.cpp

@@ -16,7 +16,6 @@ void ESP32HallSensor::update() {
   ESP_LOGD(TAG, "'%s': Got reading %.0f µT", this->name_.c_str(), value);
   this->publish_state(value);
 }
-std::string ESP32HallSensor::unique_id() { return get_mac_address() + "-hall"; }
 void ESP32HallSensor::dump_config() { LOG_SENSOR("", "ESP32 Hall Sensor", this); }
 
 }  // namespace esp32_hall

esphome/components/esp32_hall/esp32_hall.h

@@ -13,8 +13,6 @@ class ESP32HallSensor : public sensor::Sensor, public PollingComponent {
   void dump_config() override;
 
   void update() override;
-
-  std::string unique_id() override;
 };
 
 }  // namespace esp32_hall

esphome/components/ethernet_info/ethernet_info_text_sensor.h

@@ -29,7 +29,6 @@ class IPAddressEthernetInfo : public PollingComponent, public text_sensor::TextS
   }
 
   float get_setup_priority() const override { return setup_priority::ETHERNET; }
-  std::string unique_id() override { return get_mac_address() + "-ethernetinfo"; }
   void dump_config() override;
   void add_ip_sensors(uint8_t index, text_sensor::TextSensor *s) { this->ip_sensors_[index] = s; }
 
@@ -52,7 +51,6 @@ class DNSAddressEthernetInfo : public PollingComponent, public text_sensor::Text
     }
   }
   float get_setup_priority() const override { return setup_priority::ETHERNET; }
-  std::string unique_id() override { return get_mac_address() + "-ethernetinfo-dns"; }
   void dump_config() override;
 
  protected:
@@ -63,7 +61,6 @@ class MACAddressEthernetInfo : public Component, public text_sensor::TextSensor
  public:
   void setup() override { this->publish_state(ethernet::global_eth_component->get_eth_mac_address_pretty()); }
   float get_setup_priority() const override { return setup_priority::ETHERNET; }
-  std::string unique_id() override { return get_mac_address() + "-ethernetinfo-mac"; }
   void dump_config() override;
 };
 

esphome/components/logger/logger.cpp

@@ -116,7 +116,7 @@ void Logger::log_vprintf_(int level, const char *tag, int line, const __FlashStr
   if (this->baud_rate_ > 0) {
     this->write_msg_(this->tx_buffer_ + msg_start);
   }
-  this->log_callback_.call(level, tag, this->tx_buffer_ + msg_start);
+  this->call_log_callbacks_(level, tag, this->tx_buffer_ + msg_start);
 
   global_recursion_guard_ = false;
 }
@@ -129,6 +129,19 @@ inline int Logger::level_for(const char *tag) {
   return this->current_level_;
 }
 
+void HOT Logger::call_log_callbacks_(int level, const char *tag, const char *msg) {
+#ifdef USE_ESP32
+  // Suppress network-logging if memory constrained
+  // In some configurations (eg BLE enabled) there may be some transient
+  // memory exhaustion, and trying to log when OOM can lead to a crash. Skipping
+  // here usually allows the stack to recover instead.
+  // See issue #1234 for analysis.
+  if (xPortGetFreeHeapSize() < 2048)
+    return;
+#endif
+  this->log_callback_.call(level, tag, msg);
+}
+
 Logger::Logger(uint32_t baud_rate, size_t tx_buffer_size) : baud_rate_(baud_rate), tx_buffer_size_(tx_buffer_size) {
   // add 1 to buffer size for null terminator
   this->tx_buffer_ = new char[this->tx_buffer_size_ + 1];  // NOLINT
@@ -176,7 +189,7 @@ void Logger::loop() {
                                   this->tx_buffer_size_);
       this->write_footer_to_buffer_(this->tx_buffer_, &this->tx_buffer_at_, this->tx_buffer_size_);
       this->tx_buffer_[this->tx_buffer_at_] = '\0';
-      this->log_callback_.call(message->level, message->tag, this->tx_buffer_);
+      this->call_log_callbacks_(message->level, message->tag, this->tx_buffer_);
       // At this point all the data we need from message has been transferred to the tx_buffer
       // so we can release the message to allow other tasks to use it as soon as possible.
       this->log_buffer_->release_message_main_loop(received_token);

esphome/components/logger/logger.h

@@ -156,6 +156,7 @@ class Logger : public Component {
 #endif
 
  protected:
+  void call_log_callbacks_(int level, const char *tag, const char *msg);
   void write_msg_(const char *msg);
 
   // Format a log message with printf-style arguments and write it to a buffer with header, footer, and null terminator
@@ -190,7 +191,7 @@ class Logger : public Component {
     if (this->baud_rate_ > 0) {
       this->write_msg_(this->tx_buffer_);  // If logging is enabled, write to console
     }
-    this->log_callback_.call(level, tag, this->tx_buffer_);
+    this->call_log_callbacks_(level, tag, this->tx_buffer_);
   }
 
   // Write the body of the log message to the buffer

esphome/components/mcp23016/__init__.py

@@ -50,7 +50,7 @@ MCP23016_PIN_SCHEMA = pins.gpio_base_schema(
     cv.int_range(min=0, max=15),
     modes=[CONF_INPUT, CONF_OUTPUT],
     mode_validator=validate_mode,
-    invertible=True,
+    invertable=True,
 ).extend(
     {
         cv.Required(CONF_MCP23016): cv.use_id(MCP23016),

esphome/components/mcp23xxx_base/__init__.py

@@ -60,7 +60,7 @@ MCP23XXX_PIN_SCHEMA = pins.gpio_base_schema(
     cv.int_range(min=0, max=15),
     modes=[CONF_INPUT, CONF_OUTPUT, CONF_PULLUP],
     mode_validator=validate_mode,
-    invertible=True,
+    invertable=True,
 ).extend(
     {
         cv.Required(CONF_MCP23XXX): cv.use_id(MCP23XXXBase),

esphome/components/mqtt/mqtt_component.cpp

@@ -128,21 +128,16 @@ bool MQTTComponent::send_discovery_() {
             root[MQTT_PAYLOAD_NOT_AVAILABLE] = this->availability_->payload_not_available;
         }
 
-        std::string unique_id = this->unique_id();
         const MQTTDiscoveryInfo &discovery_info = global_mqtt_client->get_discovery_info();
-        if (!unique_id.empty()) {
-          root[MQTT_UNIQUE_ID] = unique_id;
+        if (discovery_info.unique_id_generator == MQTT_MAC_ADDRESS_UNIQUE_ID_GENERATOR) {
+          char friendly_name_hash[9];
+          sprintf(friendly_name_hash, "%08" PRIx32, fnv1_hash(this->friendly_name()));
+          friendly_name_hash[8] = 0;  // ensure the hash-string ends with null
+          root[MQTT_UNIQUE_ID] = get_mac_address() + "-" + this->component_type() + "-" + friendly_name_hash;
         } else {
-          if (discovery_info.unique_id_generator == MQTT_MAC_ADDRESS_UNIQUE_ID_GENERATOR) {
-            char friendly_name_hash[9];
-            sprintf(friendly_name_hash, "%08" PRIx32, fnv1_hash(this->friendly_name()));
-            friendly_name_hash[8] = 0;  // ensure the hash-string ends with null
-            root[MQTT_UNIQUE_ID] = get_mac_address() + "-" + this->component_type() + "-" + friendly_name_hash;
-          } else {
-            // default to almost-unique ID. It's a hack but the only way to get that
-            // gorgeous device registry view.
-            root[MQTT_UNIQUE_ID] = "ESP" + this->component_type() + this->get_default_object_id_();
-          }
+          // default to almost-unique ID. It's a hack but the only way to get that
+          // gorgeous device registry view.
+          root[MQTT_UNIQUE_ID] = "ESP" + this->component_type() + this->get_default_object_id_();
         }
 
         const std::string &node_name = App.get_name();
@@ -284,7 +279,6 @@ void MQTTComponent::call_dump_config() {
   this->dump_config();
 }
 void MQTTComponent::schedule_resend_state() { this->resend_state_ = true; }
-std::string MQTTComponent::unique_id() { return ""; }
 bool MQTTComponent::is_connected_() const { return global_mqtt_client->is_connected(); }
 
 // Pull these properties from EntityBase if not overridden

esphome/components/mqtt/mqtt_component.h

@@ -164,13 +164,6 @@ class MQTTComponent : public Component {
    */
   virtual const EntityBase *get_entity() const = 0;
 
-  /** A unique ID for this MQTT component, empty for no unique id. See unique ID requirements:
-   * https://developers.home-assistant.io/docs/en/entity_registry_index.html#unique-id-requirements
-   *
-   * @return The unique id as a string.
-   */
-  virtual std::string unique_id();
-
   /// Get the friendly name of this MQTT component.
   virtual std::string friendly_name() const;
 

esphome/components/mqtt/mqtt_sensor.cpp

@@ -74,7 +74,6 @@ bool MQTTSensorComponent::publish_state(float value) {
   int8_t accuracy = this->sensor_->get_accuracy_decimals();
   return this->publish(this->get_state_topic_(), value_accuracy_to_string(value, accuracy));
 }
-std::string MQTTSensorComponent::unique_id() { return this->sensor_->unique_id(); }
 
 }  // namespace mqtt
 }  // namespace esphome

esphome/components/mqtt/mqtt_sensor.h

@@ -46,7 +46,6 @@ class MQTTSensorComponent : public mqtt::MQTTComponent {
   /// Override for MQTTComponent, returns "sensor".
   std::string component_type() const override;
   const EntityBase *get_entity() const override;
-  std::string unique_id() override;
 
   sensor::Sensor *sensor_;
   optional<uint32_t> expire_after_;  // Override the expire after advertised to Home Assistant

esphome/components/mqtt/mqtt_text_sensor.cpp

@@ -38,7 +38,6 @@ bool MQTTTextSensor::send_initial_state() {
 }
 std::string MQTTTextSensor::component_type() const { return "sensor"; }
 const EntityBase *MQTTTextSensor::get_entity() const { return this->sensor_; }
-std::string MQTTTextSensor::unique_id() { return this->sensor_->unique_id(); }
 
 }  // namespace mqtt
 }  // namespace esphome

esphome/components/mqtt/mqtt_text_sensor.h

@@ -28,7 +28,6 @@ class MQTTTextSensor : public mqtt::MQTTComponent {
  protected:
   std::string component_type() const override;
   const EntityBase *get_entity() const override;
-  std::string unique_id() override;
 
   text_sensor::TextSensor *sensor_;
 };

esphome/components/one_wire/one_wire.cpp

@@ -11,8 +11,6 @@ const std::string &OneWireDevice::get_address_name() {
   return this->address_name_;
 }
 
-std::string OneWireDevice::unique_id() { return "dallas-" + str_lower_case(format_hex(this->address_)); }
-
 bool OneWireDevice::send_command_(uint8_t cmd) {
   if (!this->bus_->select(this->address_))
     return false;

esphome/components/one_wire/one_wire.h

@@ -24,8 +24,6 @@ class OneWireDevice {
   /// Helper to create (and cache) the name for this sensor. For example "0xfe0000031f1eaf29".
   const std::string &get_address_name();
 
-  std::string unique_id();
-
  protected:
   uint64_t address_{0};
   OneWireBus *bus_{nullptr};  ///< pointer to OneWireBus instance

esphome/components/pcf8574/__init__.py

@@ -53,7 +53,7 @@ PCF8574_PIN_SCHEMA = pins.gpio_base_schema(
     cv.int_range(min=0, max=17),
     modes=[CONF_INPUT, CONF_OUTPUT],
     mode_validator=validate_mode,
-    invertible=True,
+    invertable=True,
 ).extend(
     {
         cv.Required(CONF_PCF8574): cv.use_id(PCF8574Component),

esphome/components/runtime_stats/__init__.py

@@ -1,26 +0,0 @@
-"""
-Runtime statistics component for ESPHome.
-"""
-
-import esphome.codegen as cg
-import esphome.config_validation as cv
-
-DEPENDENCIES = []
-
-CONF_ENABLED = "enabled"
-CONF_LOG_INTERVAL = "log_interval"
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.Optional(CONF_ENABLED, default=True): cv.boolean,
-        cv.Optional(
-            CONF_LOG_INTERVAL, default=60000
-        ): cv.positive_time_period_milliseconds,
-    }
-)
-
-
-async def to_code(config):
-    """Generate code for the runtime statistics component."""
-    cg.add(cg.App.set_runtime_stats_enabled(config[CONF_ENABLED]))
-    cg.add(cg.App.set_runtime_stats_log_interval(config[CONF_LOG_INTERVAL]))

esphome/components/sensor/sensor.cpp

@@ -85,7 +85,6 @@ void Sensor::clear_filters() {
 }
 float Sensor::get_state() const { return this->state; }
 float Sensor::get_raw_state() const { return this->raw_state; }
-std::string Sensor::unique_id() { return ""; }
 
 void Sensor::internal_send_state_to_frontend(float state) {
   this->has_state_ = true;

esphome/components/sensor/sensor.h

@@ -27,9 +27,6 @@ namespace sensor {
     if (!(obj)->get_icon().empty()) { \
       ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
     } \
-    if (!(obj)->unique_id().empty()) { \
-      ESP_LOGV(TAG, "%s  Unique ID: '%s'", prefix, (obj)->unique_id().c_str()); \
-    } \
     if ((obj)->get_force_update()) { \
       ESP_LOGV(TAG, "%s  Force Update: YES", prefix); \
     } \
@@ -143,12 +140,6 @@ class Sensor : public EntityBase, public EntityBase_DeviceClass, public EntityBa
   /// Return whether this sensor has gotten a full state (that passed through all filters) yet.
   bool has_state() const;
 
-  /** Override this method to set the unique ID of this sensor.
-   *
-   * @deprecated Do not use for new sensors, a suitable unique ID is automatically generated (2023.4).
-   */
-  virtual std::string unique_id();
-
   void internal_send_state_to_frontend(float state);
 
  protected:

esphome/components/sn74hc595/__init__.py

@@ -95,7 +95,7 @@ SN74HC595_PIN_SCHEMA = pins.gpio_base_schema(
     cv.int_range(min=0, max=2047),
     modes=[CONF_OUTPUT],
     mode_validator=_validate_output_mode,
-    invertible=True,
+    invertable=True,
 ).extend(
     {
         cv.Required(CONF_SN74HC595): cv.use_id(SN74HC595Component),

esphome/components/tca9555/__init__.py

@@ -53,7 +53,7 @@ TCA9555_PIN_SCHEMA = pins.gpio_base_schema(
     cv.int_range(min=0, max=15),
     modes=[CONF_INPUT, CONF_OUTPUT],
     mode_validator=validate_mode,
-    invertible=True,
+    invertable=True,
 ).extend(
     {
         cv.Required(CONF_TCA9555): cv.use_id(TCA9555Component),

esphome/components/template/binary_sensor/template_binary_sensor.cpp

@@ -6,8 +6,16 @@ namespace template_ {
 
 static const char *const TAG = "template.binary_sensor";
 
-void TemplateBinarySensor::setup() { this->loop(); }
+void TemplateBinarySensor::setup() {
+  if (!this->publish_initial_state_)
+    return;
 
+  if (this->f_ != nullptr) {
+    this->publish_initial_state(this->f_().value_or(false));
+  } else {
+    this->publish_initial_state(false);
+  }
+}
 void TemplateBinarySensor::loop() {
   if (this->f_ == nullptr)
     return;

esphome/components/text_sensor/text_sensor.cpp

@@ -65,7 +65,6 @@ void TextSensor::internal_send_state_to_frontend(const std::string &state) {
   this->callback_.call(state);
 }
 
-std::string TextSensor::unique_id() { return ""; }
 bool TextSensor::has_state() { return this->has_state_; }
 
 }  // namespace text_sensor

esphome/components/text_sensor/text_sensor.h

@@ -19,9 +19,6 @@ namespace text_sensor {
     if (!(obj)->get_icon().empty()) { \
       ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
     } \
-    if (!(obj)->unique_id().empty()) { \
-      ESP_LOGV(TAG, "%s  Unique ID: '%s'", prefix, (obj)->unique_id().c_str()); \
-    } \
   }
 
 #define SUB_TEXT_SENSOR(name) \
@@ -61,11 +58,6 @@ class TextSensor : public EntityBase, public EntityBase_DeviceClass {
 
   // ========== INTERNAL METHODS ==========
   // (In most use cases you won't need these)
-  /** Override this method to set the unique ID of this sensor.
-   *
-   * @deprecated Do not use for new sensors, a suitable unique ID is automatically generated (2023.4).
-   */
-  virtual std::string unique_id();
 
   bool has_state();
 

esphome/components/uptime/sensor/uptime_seconds_sensor.cpp

@@ -27,7 +27,6 @@ void UptimeSecondsSensor::update() {
   const float seconds = float(seconds_int) + (this->uptime_ % 1000ULL) / 1000.0f;
   this->publish_state(seconds);
 }
-std::string UptimeSecondsSensor::unique_id() { return get_mac_address() + "-uptime"; }
 float UptimeSecondsSensor::get_setup_priority() const { return setup_priority::HARDWARE; }
 void UptimeSecondsSensor::dump_config() {
   LOG_SENSOR("", "Uptime Sensor", this);

esphome/components/uptime/sensor/uptime_seconds_sensor.h

@@ -13,8 +13,6 @@ class UptimeSecondsSensor : public sensor::Sensor, public PollingComponent {
 
   float get_setup_priority() const override;
 
-  std::string unique_id() override;
-
  protected:
   uint64_t uptime_{0};
 };

esphome/components/version/version_text_sensor.cpp

@@ -17,7 +17,6 @@ void VersionTextSensor::setup() {
 }
 float VersionTextSensor::get_setup_priority() const { return setup_priority::DATA; }
 void VersionTextSensor::set_hide_timestamp(bool hide_timestamp) { this->hide_timestamp_ = hide_timestamp; }
-std::string VersionTextSensor::unique_id() { return get_mac_address() + "-version"; }
 void VersionTextSensor::dump_config() { LOG_TEXT_SENSOR("", "Version Text Sensor", this); }
 
 }  // namespace version

esphome/components/version/version_text_sensor.h

@@ -12,7 +12,6 @@ class VersionTextSensor : public text_sensor::TextSensor, public Component {
   void setup() override;
   void dump_config() override;
   float get_setup_priority() const override;
-  std::string unique_id() override;
 
  protected:
   bool hide_timestamp_{false};

esphome/components/web_server/web_server.cpp

@@ -555,7 +555,7 @@ std::string WebServer::button_json(button::Button *obj, JsonDetail start_config)
 #endif
 
 #ifdef USE_BINARY_SENSOR
-void WebServer::on_binary_sensor_update(binary_sensor::BinarySensor *obj) {
+void WebServer::on_binary_sensor_update(binary_sensor::BinarySensor *obj, bool state) {
   if (this->events_.empty())
     return;
   this->events_.deferrable_send_state(obj, "state", binary_sensor_state_json_generator);

esphome/components/web_server/web_server.h

@@ -269,7 +269,7 @@ class WebServer : public Controller, public Component, public AsyncWebHandler {
 #endif
 
 #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;
 
   /// Handle a binary sensor request under '/binary_sensor/<id>'.
   void handle_binary_sensor_request(AsyncWebServerRequest *request, const UrlMatch &match);

esphome/components/wifi_info/wifi_info_text_sensor.h

@@ -28,7 +28,6 @@ class IPAddressWiFiInfo : public PollingComponent, public text_sensor::TextSenso
     }
   }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
-  std::string unique_id() override { return get_mac_address() + "-wifiinfo-ip"; }
   void dump_config() override;
   void add_ip_sensors(uint8_t index, text_sensor::TextSensor *s) { this->ip_sensors_[index] = s; }
 
@@ -51,7 +50,6 @@ class DNSAddressWifiInfo : public PollingComponent, public text_sensor::TextSens
     }
   }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
-  std::string unique_id() override { return get_mac_address() + "-wifiinfo-dns"; }
   void dump_config() override;
 
  protected:
@@ -80,7 +78,6 @@ class ScanResultsWiFiInfo : public PollingComponent, public text_sensor::TextSen
     }
   }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
-  std::string unique_id() override { return get_mac_address() + "-wifiinfo-scanresults"; }
   void dump_config() override;
 
  protected:
@@ -97,7 +94,6 @@ class SSIDWiFiInfo : public PollingComponent, public text_sensor::TextSensor {
     }
   }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
-  std::string unique_id() override { return get_mac_address() + "-wifiinfo-ssid"; }
   void dump_config() override;
 
  protected:
@@ -116,7 +112,6 @@ class BSSIDWiFiInfo : public PollingComponent, public text_sensor::TextSensor {
     }
   }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
-  std::string unique_id() override { return get_mac_address() + "-wifiinfo-bssid"; }
   void dump_config() override;
 
  protected:
@@ -126,7 +121,6 @@ class BSSIDWiFiInfo : public PollingComponent, public text_sensor::TextSensor {
 class MacAddressWifiInfo : public Component, public text_sensor::TextSensor {
  public:
   void setup() override { this->publish_state(get_mac_address_pretty()); }
-  std::string unique_id() override { return get_mac_address() + "-wifiinfo-macadr"; }
   void dump_config() override;
 };
 

esphome/components/wifi_signal/wifi_signal_sensor.h

@@ -13,7 +13,6 @@ class WiFiSignalSensor : public sensor::Sensor, public PollingComponent {
   void update() override { this->publish_state(wifi::global_wifi_component->wifi_rssi()); }
   void dump_config() override;
 
-  std::string unique_id() override { return get_mac_address() + "-wifisignal"; }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
 };
 

esphome/core/application.cpp

@@ -117,9 +117,7 @@ void Application::loop() {
   // Use the last component's end time instead of calling millis() again
   auto elapsed = last_op_end_time - this->last_loop_;
   if (elapsed >= this->loop_interval_ || HighFrequencyLoopRequester::is_high_frequency()) {
-    // Even if we overran the loop interval, we still need to select()
-    // to know if any sockets have data ready
-    this->yield_with_select_(0);
+    yield();
   } else {
     uint32_t delay_time = this->loop_interval_ - elapsed;
     uint32_t next_schedule = this->scheduler.next_schedule_in().value_or(delay_time);
@@ -128,7 +126,7 @@ void Application::loop() {
     next_schedule = std::max(next_schedule, delay_time / 2);
     delay_time = std::min(next_schedule, delay_time);
 
-    this->yield_with_select_(delay_time);
+    this->delay_with_select_(delay_time);
   }
   this->last_loop_ = last_op_end_time;
 
@@ -217,7 +215,7 @@ void Application::teardown_components(uint32_t timeout_ms) {
 
     // Give some time for I/O operations if components are still pending
     if (!pending_components.empty()) {
-      this->yield_with_select_(1);
+      this->delay_with_select_(1);
     }
 
     // Update time for next iteration
@@ -295,6 +293,8 @@ bool Application::is_socket_ready(int fd) const {
   // This function is thread-safe for reading the result of select()
   // However, it should only be called after select() has been executed in the main loop
   // The read_fds_ is only modified by select() in the main loop
+  if (HighFrequencyLoopRequester::is_high_frequency())
+    return true;  // fd sets via select are not updated in high frequency looping - so force true fallback behavior
   if (fd < 0 || fd >= FD_SETSIZE)
     return false;
 
@@ -302,9 +302,7 @@ bool Application::is_socket_ready(int fd) const {
 }
 #endif
 
-void Application::yield_with_select_(uint32_t delay_ms) {
-  // Delay while monitoring sockets. When delay_ms is 0, always yield() to ensure other tasks run
-  // since select() with 0 timeout only polls without yielding.
+void Application::delay_with_select_(uint32_t delay_ms) {
 #ifdef USE_SOCKET_SELECT_SUPPORT
   if (!this->socket_fds_.empty()) {
     // Update fd_set if socket list has changed
@@ -342,10 +340,6 @@ void Application::yield_with_select_(uint32_t delay_ms) {
       ESP_LOGW(TAG, "select() failed with errno %d", errno);
       delay(delay_ms);
     }
-    // When delay_ms is 0, we need to yield since select(0) doesn't yield
-    if (delay_ms == 0) {
-      yield();
-    }
   } else {
     // No sockets registered, use regular delay
     delay(delay_ms);

esphome/core/application.h

@@ -7,7 +7,6 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
-#include "esphome/core/runtime_stats.h"
 #include "esphome/core/scheduler.h"
 
 #ifdef USE_SOCKET_SELECT_SUPPORT
@@ -315,18 +314,6 @@ class Application {
 
   uint32_t get_loop_interval() const { return this->loop_interval_; }
 
-  /** Enable or disable runtime statistics collection.
-   *
-   * @param enable Whether to enable runtime statistics collection.
-   */
-  void set_runtime_stats_enabled(bool enable) { runtime_stats.set_enabled(enable); }
-
-  /** Set the interval at which runtime statistics are logged.
-   *
-   * @param interval The interval in milliseconds between logging of runtime statistics.
-   */
-  void set_runtime_stats_log_interval(uint32_t interval) { runtime_stats.set_log_interval(interval); }
-
   void schedule_dump_config() { this->dump_config_at_ = 0; }
 
   void feed_wdt(uint32_t time = 0);
@@ -588,7 +575,7 @@ class Application {
   void feed_wdt_arch_();
 
   /// Perform a delay while also monitoring socket file descriptors for readiness
-  void yield_with_select_(uint32_t delay_ms);
+  void delay_with_select_(uint32_t delay_ms);
 
   std::vector<Component *> components_{};
   std::vector<Component *> looping_components_{};

esphome/core/component.cpp

@@ -246,9 +246,6 @@ uint32_t WarnIfComponentBlockingGuard::finish() {
   uint32_t curr_time = millis();
 
   uint32_t blocking_time = curr_time - this->started_;
-
-  // Record component runtime stats
-  runtime_stats.record_component_time(this->component_, blocking_time, curr_time);
   bool should_warn;
   if (this->component_ != nullptr) {
     should_warn = this->component_->should_warn_of_blocking(blocking_time);

esphome/core/component.h

@@ -6,7 +6,6 @@
 #include <string>
 
 #include "esphome/core/optional.h"
-#include "esphome/core/runtime_stats.h"
 
 namespace esphome {
 

esphome/core/controller.cpp

@@ -7,10 +7,8 @@ namespace esphome {
 void Controller::setup_controller(bool include_internal) {
 #ifdef USE_BINARY_SENSOR
   for (auto *obj : App.get_binary_sensors()) {
-    if (include_internal || !obj->is_internal()) {
-      obj->add_full_state_callback(
-          [this, obj](optional<bool> previous, optional<bool> state) { this->on_binary_sensor_update(obj); });
-    }
+    if (include_internal || !obj->is_internal())
+      obj->add_on_state_callback([this, obj](bool state) { this->on_binary_sensor_update(obj, state); });
   }
 #endif
 #ifdef USE_FAN

esphome/core/controller.h

@@ -71,7 +71,7 @@ class Controller {
  public:
   void setup_controller(bool include_internal = false);
 #ifdef USE_BINARY_SENSOR
-  virtual void on_binary_sensor_update(binary_sensor::BinarySensor *obj){};
+  virtual void on_binary_sensor_update(binary_sensor::BinarySensor *obj, bool state){};
 #endif
 #ifdef USE_FAN
   virtual void on_fan_update(fan::Fan *obj){};

esphome/core/entity_base.h

@@ -3,8 +3,6 @@
 #include <string>
 #include <cstdint>
 #include "string_ref.h"
-#include "helpers.h"
-#include "log.h"
 
 namespace esphome {
 
@@ -31,7 +29,7 @@ class EntityBase {
   // Get the unique Object ID of this Entity
   uint32_t get_object_id_hash();
 
-  // Get/set whether this Entity should be hidden outside ESPHome
+  // Get/set whether this Entity should be hidden from outside of ESPHome
   bool is_internal() const;
   void set_internal(bool internal);
 
@@ -58,12 +56,11 @@ class EntityBase {
   StringRef name_;
   const char *object_id_c_str_{nullptr};
   const char *icon_c_str_{nullptr};
-  uint32_t object_id_hash_{};
+  uint32_t object_id_hash_;
   bool has_own_name_{false};
   bool internal_{false};
   bool disabled_by_default_{false};
   EntityCategory entity_category_{ENTITY_CATEGORY_NONE};
-  bool has_state_{};
 };
 
 class EntityBase_DeviceClass {  // NOLINT(readability-identifier-naming)
@@ -88,58 +85,4 @@ class EntityBase_UnitOfMeasurement {  // NOLINT(readability-identifier-naming)
   const char *unit_of_measurement_{nullptr};  ///< Unit of measurement override
 };
 
-/**
- * An entity that has a state.
- * @tparam T The type of the state
- */
-template<typename T> class StatefulEntityBase : public EntityBase {
- public:
-  virtual bool has_state() const { return this->state_.has_value(); }
-  virtual const T &get_state() const { return this->state_.value(); }
-  virtual T get_state_default(T default_value) const { return this->state_.value_or(default_value); }
-  void invalidate_state() { this->set_state_({}); }
-
-  void add_full_state_callback(std::function<void(optional<T> previous, optional<T> current)> &&callback) {
-    if (this->full_state_callbacks_ == nullptr)
-      this->full_state_callbacks_ = new CallbackManager<void(optional<T> previous, optional<T> current)>();  // NOLINT
-    this->full_state_callbacks_->add(std::move(callback));
-  }
-  void add_on_state_callback(std::function<void(T)> &&callback) {
-    if (this->state_callbacks_ == nullptr)
-      this->state_callbacks_ = new CallbackManager<void(T)>();  // NOLINT
-    this->state_callbacks_->add(std::move(callback));
-  }
-
-  void set_trigger_on_initial_state(bool trigger_on_initial_state) {
-    this->trigger_on_initial_state_ = trigger_on_initial_state;
-  }
-
- protected:
-  optional<T> state_{};
-  /**
-   * Set a new state for this entity. This will trigger callbacks only if the new state is different from the previous.
-   *
-   * @param state The new state.
-   * @return True if the state was changed, false if it was the same as before.
-   */
-  bool set_state_(const optional<T> &state) {
-    if (this->state_ != state) {
-      // call the full state callbacks with the previous and new state
-      if (this->full_state_callbacks_ != nullptr)
-        this->full_state_callbacks_->call(this->state_, state);
-      // trigger legacy callbacks only if the new state is valid and either the trigger on initial state is enabled or
-      // the previous state was valid
-      auto had_state = this->has_state();
-      this->state_ = state;
-      if (this->state_callbacks_ != nullptr && state.has_value() && (this->trigger_on_initial_state_ || had_state))
-        this->state_callbacks_->call(state.value());
-      return true;
-    }
-    return false;
-  }
-  bool trigger_on_initial_state_{true};
-  // callbacks with full state and previous state
-  CallbackManager<void(optional<T> previous, optional<T> current)> *full_state_callbacks_{};
-  CallbackManager<void(T)> *state_callbacks_{};
-};
 }  // namespace esphome

esphome/core/log.h

@@ -165,8 +165,6 @@ int esp_idf_log_vprintf_(const char *format, va_list args);  // NOLINT
 #define YESNO(b) ((b) ? "YES" : "NO")
 #define ONOFF(b) ((b) ? "ON" : "OFF")
 #define TRUEFALSE(b) ((b) ? "TRUE" : "FALSE")
-// for use with optional values
-#define ONOFFMAYBE(b) (((b).has_value()) ? ONOFF((b).value()) : "UNKNOWN")
 
 // Helper class that identifies strings that may be stored in flash storage (similar to Arduino's __FlashStringHelper)
 struct LogString;

esphome/core/optional.h

@@ -52,11 +52,6 @@ template<typename T> class optional {  // NOLINT
     reset();
     return *this;
   }
-  bool operator==(optional<T> const &rhs) const {
-    if (has_value() && rhs.has_value())
-      return value() == rhs.value();
-    return !has_value() && !rhs.has_value();
-  }
 
   template<class U> optional &operator=(optional<U> const &other) {
     has_value_ = other.has_value();

esphome/core/runtime_stats.cpp

@@ -1,28 +0,0 @@
-#include "esphome/core/runtime_stats.h"
-#include "esphome/core/component.h"
-
-namespace esphome {
-
-RuntimeStatsCollector runtime_stats;
-
-void RuntimeStatsCollector::record_component_time(Component *component, uint32_t duration_ms, uint32_t current_time) {
-  if (!this->enabled_ || component == nullptr)
-    return;
-
-  const char *component_source = component->get_component_source();
-  this->component_stats_[component_source].record_time(duration_ms);
-
-  // If next_log_time_ is 0, initialize it
-  if (this->next_log_time_ == 0) {
-    this->next_log_time_ = current_time + this->log_interval_;
-    return;
-  }
-
-  if (current_time >= this->next_log_time_) {
-    this->log_stats_();
-    this->reset_stats_();
-    this->next_log_time_ = current_time + this->log_interval_;
-  }
-}
-
-}  // namespace esphome

esphome/core/runtime_stats.h

@@ -1,161 +0,0 @@
-#pragma once
-
-#include <map>
-#include <string>
-#include <vector>
-#include <cstdint>
-#include <algorithm>
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome {
-
-static const char *const RUNTIME_TAG = "runtime";
-
-class Component;  // Forward declaration
-
-class ComponentRuntimeStats {
- public:
-  ComponentRuntimeStats()
-      : period_count_(0),
-        total_count_(0),
-        period_time_ms_(0),
-        total_time_ms_(0),
-        period_max_time_ms_(0),
-        total_max_time_ms_(0) {}
-
-  void record_time(uint32_t duration_ms) {
-    // Update period counters
-    this->period_count_++;
-    this->period_time_ms_ += duration_ms;
-    if (duration_ms > this->period_max_time_ms_)
-      this->period_max_time_ms_ = duration_ms;
-
-    // Update total counters
-    this->total_count_++;
-    this->total_time_ms_ += duration_ms;
-    if (duration_ms > this->total_max_time_ms_)
-      this->total_max_time_ms_ = duration_ms;
-  }
-
-  void reset_period_stats() {
-    this->period_count_ = 0;
-    this->period_time_ms_ = 0;
-    this->period_max_time_ms_ = 0;
-  }
-
-  // Period stats (reset each logging interval)
-  uint32_t get_period_count() const { return this->period_count_; }
-  uint32_t get_period_time_ms() const { return this->period_time_ms_; }
-  uint32_t get_period_max_time_ms() const { return this->period_max_time_ms_; }
-  float get_period_avg_time_ms() const {
-    return this->period_count_ > 0 ? this->period_time_ms_ / static_cast<float>(this->period_count_) : 0.0f;
-  }
-
-  // Total stats (persistent until reboot)
-  uint32_t get_total_count() const { return this->total_count_; }
-  uint32_t get_total_time_ms() const { return this->total_time_ms_; }
-  uint32_t get_total_max_time_ms() const { return this->total_max_time_ms_; }
-  float get_total_avg_time_ms() const {
-    return this->total_count_ > 0 ? this->total_time_ms_ / static_cast<float>(this->total_count_) : 0.0f;
-  }
-
- protected:
-  // Period stats (reset each logging interval)
-  uint32_t period_count_;
-  uint32_t period_time_ms_;
-  uint32_t period_max_time_ms_;
-
-  // Total stats (persistent until reboot)
-  uint32_t total_count_;
-  uint32_t total_time_ms_;
-  uint32_t total_max_time_ms_;
-};
-
-// For sorting components by run time
-struct ComponentStatPair {
-  std::string name;
-  const ComponentRuntimeStats *stats;
-
-  bool operator>(const ComponentStatPair &other) const {
-    // Sort by period time as that's what we're displaying in the logs
-    return stats->get_period_time_ms() > other.stats->get_period_time_ms();
-  }
-};
-
-class RuntimeStatsCollector {
- public:
-  RuntimeStatsCollector() : log_interval_(60000), next_log_time_(0), enabled_(true) {}
-
-  void set_log_interval(uint32_t log_interval) { this->log_interval_ = log_interval; }
-  uint32_t get_log_interval() const { return this->log_interval_; }
-
-  void set_enabled(bool enabled) { this->enabled_ = enabled; }
-  bool is_enabled() const { return this->enabled_; }
-
-  void record_component_time(Component *component, uint32_t duration_ms, uint32_t current_time);
-
- protected:
-  void log_stats_() {
-    ESP_LOGI(RUNTIME_TAG, "Component Runtime Statistics");
-    ESP_LOGI(RUNTIME_TAG, "Period stats (last %" PRIu32 "ms):", this->log_interval_);
-
-    // First collect stats we want to display
-    std::vector<ComponentStatPair> stats_to_display;
-
-    for (const auto &it : this->component_stats_) {
-      const ComponentRuntimeStats &stats = it.second;
-      if (stats.get_period_count() > 0) {
-        ComponentStatPair pair = {it.first, &stats};
-        stats_to_display.push_back(pair);
-      }
-    }
-
-    // Sort by period runtime (descending)
-    std::sort(stats_to_display.begin(), stats_to_display.end(), std::greater<ComponentStatPair>());
-
-    // Log top components by period runtime
-    for (const auto &it : stats_to_display) {
-      const std::string &source = it.name;
-      const ComponentRuntimeStats *stats = it.stats;
-
-      ESP_LOGI(RUNTIME_TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms",
-               source.c_str(), stats->get_period_count(), stats->get_period_avg_time_ms(),
-               stats->get_period_max_time_ms(), stats->get_period_time_ms());
-    }
-
-    // Log total stats since boot
-    ESP_LOGI(RUNTIME_TAG, "Total stats (since boot):");
-
-    // Re-sort by total runtime for all-time stats
-    std::sort(stats_to_display.begin(), stats_to_display.end(),
-              [](const ComponentStatPair &a, const ComponentStatPair &b) {
-                return a.stats->get_total_time_ms() > b.stats->get_total_time_ms();
-              });
-
-    for (const auto &it : stats_to_display) {
-      const std::string &source = it.name;
-      const ComponentRuntimeStats *stats = it.stats;
-
-      ESP_LOGI(RUNTIME_TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms",
-               source.c_str(), stats->get_total_count(), stats->get_total_avg_time_ms(), stats->get_total_max_time_ms(),
-               stats->get_total_time_ms());
-    }
-  }
-
-  void reset_stats_() {
-    for (auto &it : this->component_stats_) {
-      it.second.reset_period_stats();
-    }
-  }
-
-  std::map<std::string, ComponentRuntimeStats> component_stats_;
-  uint32_t log_interval_;
-  uint32_t next_log_time_;
-  bool enabled_;
-};
-
-// Global instance for runtime stats collection
-extern RuntimeStatsCollector runtime_stats;
-
-}  // namespace esphome

esphome/pins.py

@@ -1,8 +1,5 @@
-from collections.abc import Callable
 from functools import reduce
-from logging import Logger
 import operator
-from typing import Any
 
 import esphome.config_validation as cv
 from esphome.const import (
@@ -18,7 +15,6 @@ from esphome.const import (
     CONF_PULLUP,
 )
 from esphome.core import CORE
-from esphome.cpp_generator import MockObjClass
 
 
 class PinRegistry(dict):
@@ -266,7 +262,7 @@ internal_gpio_input_pullup_pin_number = _internal_number_creator(
 )
 
 
-def check_strapping_pin(conf, strapping_pin_list: set[int], logger: Logger):
+def check_strapping_pin(conf, strapping_pin_list, logger):
     num = conf[CONF_NUMBER]
     if num in strapping_pin_list and not conf.get(CONF_IGNORE_STRAPPING_WARNING):
         logger.warning(
@@ -295,11 +291,11 @@ def gpio_validate_modes(value):
 
 
 def gpio_base_schema(
-    pin_type: MockObjClass,
-    number_validator: Callable[[Any], Any],
+    pin_type,
+    number_validator,
     modes=GPIO_STANDARD_MODES,
-    mode_validator: Callable[[Any], Any] = gpio_validate_modes,
-    invertible: bool = True,
+    mode_validator=gpio_validate_modes,
+    invertable=True,
 ):
     """
     Generate a base gpio pin schema
@@ -307,7 +303,7 @@ def gpio_base_schema(
     :param number_validator: A validator for the pin number
     :param modes: The available modes, default is all standard modes
     :param mode_validator: A validator function for the pin mode
-    :param invertible: If the pin supports hardware inversion
+    :param invertable: If the pin supports hardware inversion
     :return: A schema for the pin
     """
     mode_default = len(modes) == 1
@@ -332,7 +328,7 @@ def gpio_base_schema(
         }
     )
 
-    if invertible:
+    if invertable:
         return schema.extend({cv.Optional(CONF_INVERTED, default=False): cv.boolean})
 
     return schema

tests/components/binary_sensor/common.yaml

@@ -1,15 +0,0 @@
-binary_sensor:
-  - platform: template
-    trigger_on_initial_state: true
-    id: some_binary_sensor
-    name: "Random binary"
-    lambda: return (random_uint32() & 1) == 0;
-    on_state_change:
-      then:
-        - logger.log:
-            format: "Old state was %s"
-            args: ['x_previous.has_value() ? ONOFF(x_previous) : "Unknown"']
-        - logger.log:
-            format: "New state is %s"
-            args: ['x.has_value() ? ONOFF(x) : "Unknown"']
-        - binary_sensor.invalidate_state: some_binary_sensor

tests/components/binary_sensor/test.bk72xx-ard.yaml

@@ -1,2 +0,0 @@
-packages:
-  common: !include common.yaml

tests/components/binary_sensor/test.esp32-ard.yaml

@@ -1,2 +0,0 @@
-packages:
-  common: !include common.yaml

tests/components/binary_sensor/test.esp32-c3-ard.yaml

@@ -1,2 +0,0 @@
-packages:
-  common: !include common.yaml

tests/components/binary_sensor/test.esp32-c3-idf.yaml

@@ -1,2 +0,0 @@
-packages:
-  common: !include common.yaml

tests/components/binary_sensor/test.esp32-idf.yaml

@@ -1,2 +0,0 @@
-packages:
-  common: !include common.yaml

tests/components/binary_sensor/test.esp32-s3-idf.yaml

@@ -1,2 +0,0 @@
-packages:
-  common: !include common.yaml

tests/components/binary_sensor/test.esp8266-ard.yaml

@@ -1,2 +0,0 @@
-packages:
-  common: !include common.yaml

tests/components/binary_sensor/test.rp2040-ard.yaml

@@ -1,2 +0,0 @@
-packages:
-  common: !include common.yaml

tests/components/lvgl/common.yaml

@@ -63,7 +63,7 @@ binary_sensor:
     id: lvgl_pressbutton
     name: Pressbutton
     widget: spin_up
-    trigger_on_initial_state: true
+    publish_initial_state: true
   - platform: lvgl
     name: ButtonMatrix button
     widget: button_a