esphome 2025.2.1__py3-none-any.whl → 2025.3.0b1__py3-none-any.whl

esphome/components/api/api_connection.h

@@ -14,6 +14,46 @@
 namespace esphome {
 namespace api {
 
+using send_message_t = bool(APIConnection *, void *);
+
+/*
+  This class holds a pointer to the source component that wants to publish a message, and a pointer to a function that
+  will lazily publish that message.  The two pointers allow dedup in the deferred queue if multiple publishes for the
+  same component are backed up, and take up only 8 bytes of memory.  The entry in the deferred queue (a std::vector) is
+  the DeferredMessage instance itself (not a pointer to one elsewhere in heap) so still only 8 bytes per entry.  Even
+  100 backed up messages (you'd have to have at least 100 sensors publishing because of dedup) would take up only 0.8
+  kB.
+*/
+class DeferredMessageQueue {
+  struct DeferredMessage {
+    friend class DeferredMessageQueue;
+
+   protected:
+    void *source_;
+    send_message_t *send_message_;
+
+   public:
+    DeferredMessage(void *source, send_message_t *send_message) : source_(source), send_message_(send_message) {}
+    bool operator==(const DeferredMessage &test) const {
+      return (source_ == test.source_ && send_message_ == test.send_message_);
+    }
+  } __attribute__((packed));
+
+ protected:
+  // vector is used very specifically for its zero memory overhead even though items are popped from the front (memory
+  // footprint is more important than speed here)
+  std::vector<DeferredMessage> deferred_queue_;
+  APIConnection *api_connection_;
+
+  // helper for allowing only unique entries in the queue
+  void dmq_push_back_with_dedup_(void *source, send_message_t *send_message);
+
+ public:
+  DeferredMessageQueue(APIConnection *api_connection) : api_connection_(api_connection) {}
+  void process_queue();
+  void defer(void *source, send_message_t *send_message);
+};
+
 class APIConnection : public APIServerConnection {
  public:
   APIConnection(std::unique_ptr<socket::Socket> socket, APIServer *parent);
@@ -28,96 +68,140 @@ class APIConnection : public APIServerConnection {
   }
 #ifdef USE_BINARY_SENSOR
   bool send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor, bool state);
-  bool send_binary_sensor_info(binary_sensor::BinarySensor *binary_sensor);
+  void send_binary_sensor_info(binary_sensor::BinarySensor *binary_sensor);
+  static bool try_send_binary_sensor_state(APIConnection *api, void *v_binary_sensor);
+  static bool try_send_binary_sensor_state(APIConnection *api, binary_sensor::BinarySensor *binary_sensor, bool state);
+  static bool try_send_binary_sensor_info(APIConnection *api, void *v_binary_sensor);
 #endif
 #ifdef USE_COVER
   bool send_cover_state(cover::Cover *cover);
-  bool send_cover_info(cover::Cover *cover);
+  void send_cover_info(cover::Cover *cover);
+  static bool try_send_cover_state(APIConnection *api, void *v_cover);
+  static bool try_send_cover_info(APIConnection *api, void *v_cover);
   void cover_command(const CoverCommandRequest &msg) override;
 #endif
 #ifdef USE_FAN
   bool send_fan_state(fan::Fan *fan);
-  bool send_fan_info(fan::Fan *fan);
+  void send_fan_info(fan::Fan *fan);
+  static bool try_send_fan_state(APIConnection *api, void *v_fan);
+  static bool try_send_fan_info(APIConnection *api, void *v_fan);
   void fan_command(const FanCommandRequest &msg) override;
 #endif
 #ifdef USE_LIGHT
   bool send_light_state(light::LightState *light);
-  bool send_light_info(light::LightState *light);
+  void send_light_info(light::LightState *light);
+  static bool try_send_light_state(APIConnection *api, void *v_light);
+  static bool try_send_light_info(APIConnection *api, void *v_light);
   void light_command(const LightCommandRequest &msg) override;
 #endif
 #ifdef USE_SENSOR
   bool send_sensor_state(sensor::Sensor *sensor, float state);
-  bool send_sensor_info(sensor::Sensor *sensor);
+  void send_sensor_info(sensor::Sensor *sensor);
+  static bool try_send_sensor_state(APIConnection *api, void *v_sensor);
+  static bool try_send_sensor_state(APIConnection *api, sensor::Sensor *sensor, float state);
+  static bool try_send_sensor_info(APIConnection *api, void *v_sensor);
 #endif
 #ifdef USE_SWITCH
   bool send_switch_state(switch_::Switch *a_switch, bool state);
-  bool send_switch_info(switch_::Switch *a_switch);
+  void send_switch_info(switch_::Switch *a_switch);
+  static bool try_send_switch_state(APIConnection *api, void *v_a_switch);
+  static bool try_send_switch_state(APIConnection *api, switch_::Switch *a_switch, bool state);
+  static bool try_send_switch_info(APIConnection *api, void *v_a_switch);
   void switch_command(const SwitchCommandRequest &msg) override;
 #endif
 #ifdef USE_TEXT_SENSOR
   bool send_text_sensor_state(text_sensor::TextSensor *text_sensor, std::string state);
-  bool send_text_sensor_info(text_sensor::TextSensor *text_sensor);
+  void send_text_sensor_info(text_sensor::TextSensor *text_sensor);
+  static bool try_send_text_sensor_state(APIConnection *api, void *v_text_sensor);
+  static bool try_send_text_sensor_state(APIConnection *api, text_sensor::TextSensor *text_sensor, std::string state);
+  static bool try_send_text_sensor_info(APIConnection *api, void *v_text_sensor);
 #endif
 #ifdef USE_ESP32_CAMERA
-  void send_camera_state(std::shared_ptr<esp32_camera::CameraImage> image);
-  bool send_camera_info(esp32_camera::ESP32Camera *camera);
+  void set_camera_state(std::shared_ptr<esp32_camera::CameraImage> image);
+  void send_camera_info(esp32_camera::ESP32Camera *camera);
+  static bool try_send_camera_info(APIConnection *api, void *v_camera);
   void camera_image(const CameraImageRequest &msg) override;
 #endif
 #ifdef USE_CLIMATE
   bool send_climate_state(climate::Climate *climate);
-  bool send_climate_info(climate::Climate *climate);
+  void send_climate_info(climate::Climate *climate);
+  static bool try_send_climate_state(APIConnection *api, void *v_climate);
+  static bool try_send_climate_info(APIConnection *api, void *v_climate);
   void climate_command(const ClimateCommandRequest &msg) override;
 #endif
 #ifdef USE_NUMBER
   bool send_number_state(number::Number *number, float state);
-  bool send_number_info(number::Number *number);
+  void send_number_info(number::Number *number);
+  static bool try_send_number_state(APIConnection *api, void *v_number);
+  static bool try_send_number_state(APIConnection *api, number::Number *number, float state);
+  static bool try_send_number_info(APIConnection *api, void *v_number);
   void number_command(const NumberCommandRequest &msg) override;
 #endif
 #ifdef USE_DATETIME_DATE
   bool send_date_state(datetime::DateEntity *date);
-  bool send_date_info(datetime::DateEntity *date);
+  void send_date_info(datetime::DateEntity *date);
+  static bool try_send_date_state(APIConnection *api, void *v_date);
+  static bool try_send_date_info(APIConnection *api, void *v_date);
   void date_command(const DateCommandRequest &msg) override;
 #endif
 #ifdef USE_DATETIME_TIME
   bool send_time_state(datetime::TimeEntity *time);
-  bool send_time_info(datetime::TimeEntity *time);
+  void send_time_info(datetime::TimeEntity *time);
+  static bool try_send_time_state(APIConnection *api, void *v_time);
+  static bool try_send_time_info(APIConnection *api, void *v_time);
   void time_command(const TimeCommandRequest &msg) override;
 #endif
 #ifdef USE_DATETIME_DATETIME
   bool send_datetime_state(datetime::DateTimeEntity *datetime);
-  bool send_datetime_info(datetime::DateTimeEntity *datetime);
+  void send_datetime_info(datetime::DateTimeEntity *datetime);
+  static bool try_send_datetime_state(APIConnection *api, void *v_datetime);
+  static bool try_send_datetime_info(APIConnection *api, void *v_datetime);
   void datetime_command(const DateTimeCommandRequest &msg) override;
 #endif
 #ifdef USE_TEXT
   bool send_text_state(text::Text *text, std::string state);
-  bool send_text_info(text::Text *text);
+  void send_text_info(text::Text *text);
+  static bool try_send_text_state(APIConnection *api, void *v_text);
+  static bool try_send_text_state(APIConnection *api, text::Text *text, std::string state);
+  static bool try_send_text_info(APIConnection *api, void *v_text);
   void text_command(const TextCommandRequest &msg) override;
 #endif
 #ifdef USE_SELECT
   bool send_select_state(select::Select *select, std::string state);
-  bool send_select_info(select::Select *select);
+  void send_select_info(select::Select *select);
+  static bool try_send_select_state(APIConnection *api, void *v_select);
+  static bool try_send_select_state(APIConnection *api, select::Select *select, std::string state);
+  static bool try_send_select_info(APIConnection *api, void *v_select);
   void select_command(const SelectCommandRequest &msg) override;
 #endif
 #ifdef USE_BUTTON
-  bool send_button_info(button::Button *button);
+  void send_button_info(button::Button *button);
+  static bool try_send_button_info(APIConnection *api, void *v_button);
   void button_command(const ButtonCommandRequest &msg) override;
 #endif
 #ifdef USE_LOCK
   bool send_lock_state(lock::Lock *a_lock, lock::LockState state);
-  bool send_lock_info(lock::Lock *a_lock);
+  void send_lock_info(lock::Lock *a_lock);
+  static bool try_send_lock_state(APIConnection *api, void *v_a_lock);
+  static bool try_send_lock_state(APIConnection *api, lock::Lock *a_lock, lock::LockState state);
+  static bool try_send_lock_info(APIConnection *api, void *v_a_lock);
   void lock_command(const LockCommandRequest &msg) override;
 #endif
 #ifdef USE_VALVE
   bool send_valve_state(valve::Valve *valve);
-  bool send_valve_info(valve::Valve *valve);
+  void send_valve_info(valve::Valve *valve);
+  static bool try_send_valve_state(APIConnection *api, void *v_valve);
+  static bool try_send_valve_info(APIConnection *api, void *v_valve);
   void valve_command(const ValveCommandRequest &msg) override;
 #endif
 #ifdef USE_MEDIA_PLAYER
   bool send_media_player_state(media_player::MediaPlayer *media_player);
-  bool send_media_player_info(media_player::MediaPlayer *media_player);
+  void send_media_player_info(media_player::MediaPlayer *media_player);
+  static bool try_send_media_player_state(APIConnection *api, void *v_media_player);
+  static bool try_send_media_player_info(APIConnection *api, void *v_media_player);
   void media_player_command(const MediaPlayerCommandRequest &msg) override;
 #endif
-  bool send_log_message(int level, const char *tag, const char *line);
+  bool try_send_log_message(int level, const char *tag, const char *line);
   void send_homeassistant_service_call(const HomeassistantServiceResponse &call) {
     if (!this->service_call_subscription_)
       return;
@@ -160,18 +244,25 @@ class APIConnection : public APIServerConnection {
 
 #ifdef USE_ALARM_CONTROL_PANEL
   bool send_alarm_control_panel_state(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel);
-  bool send_alarm_control_panel_info(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel);
+  void send_alarm_control_panel_info(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel);
+  static bool try_send_alarm_control_panel_state(APIConnection *api, void *v_a_alarm_control_panel);
+  static bool try_send_alarm_control_panel_info(APIConnection *api, void *v_a_alarm_control_panel);
   void alarm_control_panel_command(const AlarmControlPanelCommandRequest &msg) override;
 #endif
 
 #ifdef USE_EVENT
-  bool send_event(event::Event *event, std::string event_type);
-  bool send_event_info(event::Event *event);
+  void send_event(event::Event *event, std::string event_type);
+  void send_event_info(event::Event *event);
+  static bool try_send_event(APIConnection *api, void *v_event);
+  static bool try_send_event(APIConnection *api, event::Event *event, std::string event_type);
+  static bool try_send_event_info(APIConnection *api, void *v_event);
 #endif
 
 #ifdef USE_UPDATE
   bool send_update_state(update::UpdateEntity *update);
-  bool send_update_info(update::UpdateEntity *update);
+  void send_update_info(update::UpdateEntity *update);
+  static bool try_send_update_state(APIConnection *api, void *v_update);
+  static bool try_send_update_info(APIConnection *api, void *v_update);
   void update_command(const UpdateCommandRequest &msg) override;
 #endif
 
@@ -262,6 +353,7 @@ class APIConnection : public APIServerConnection {
   bool service_call_subscription_{false};
   bool next_close_ = false;
   APIServer *parent_;
+  DeferredMessageQueue deferred_message_queue_;
   InitialStateIterator initial_state_iterator_;
   ListEntitiesIterator list_entities_iterator_;
   int state_subs_at_ = -1;

esphome/components/api/api_pb2.cpp

@@ -838,6 +838,10 @@ bool DeviceInfoResponse::decode_length(uint32_t field_id, ProtoLengthDelimited v
       this->suggested_area = value.as_string();
       return true;
     }
+    case 18: {
+      this->bluetooth_mac_address = value.as_string();
+      return true;
+    }
     default:
       return false;
   }
@@ -860,6 +864,7 @@ void DeviceInfoResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint32(14, this->legacy_voice_assistant_version);
   buffer.encode_uint32(17, this->voice_assistant_feature_flags);
   buffer.encode_string(16, this->suggested_area);
+  buffer.encode_string(18, this->bluetooth_mac_address);
 }
 #ifdef HAS_PROTO_MESSAGE_DUMP
 void DeviceInfoResponse::dump_to(std::string &out) const {
@@ -937,6 +942,10 @@ void DeviceInfoResponse::dump_to(std::string &out) const {
   out.append("  suggested_area: ");
   out.append("'").append(this->suggested_area).append("'");
   out.append("\n");
+
+  out.append("  bluetooth_mac_address: ");
+  out.append("'").append(this->bluetooth_mac_address).append("'");
+  out.append("\n");
   out.append("}");
 }
 #endif

esphome/components/api/api_pb2.h

@@ -354,6 +354,7 @@ class DeviceInfoResponse : public ProtoMessage {
   uint32_t legacy_voice_assistant_version{0};
   uint32_t voice_assistant_feature_flags{0};
   std::string suggested_area{};
+  std::string bluetooth_mac_address{};
   void encode(ProtoWriteBuffer buffer) const override;
 #ifdef HAS_PROTO_MESSAGE_DUMP
   void dump_to(std::string &out) const override;

esphome/components/api/api_server.cpp

@@ -72,7 +72,7 @@ void APIServer::setup() {
     logger::global_logger->add_on_log_callback([this](int level, const char *tag, const char *message) {
       for (auto &c : this->clients_) {
         if (!c->remove_)
-          c->send_log_message(level, tag, message);
+          c->try_send_log_message(level, tag, message);
       }
     });
   }
@@ -86,7 +86,7 @@ void APIServer::setup() {
         [this](const std::shared_ptr<esp32_camera::CameraImage> &image) {
           for (auto &c : this->clients_) {
             if (!c->remove_)
-              c->send_camera_state(image);
+              c->set_camera_state(image);
           }
         });
   }

esphome/components/api/list_entities.cpp

@@ -10,37 +10,63 @@ namespace api {
 
 #ifdef USE_BINARY_SENSOR
 bool ListEntitiesIterator::on_binary_sensor(binary_sensor::BinarySensor *binary_sensor) {
-  return this->client_->send_binary_sensor_info(binary_sensor);
+  this->client_->send_binary_sensor_info(binary_sensor);
+  return true;
 }
 #endif
 #ifdef USE_COVER
-bool ListEntitiesIterator::on_cover(cover::Cover *cover) { return this->client_->send_cover_info(cover); }
+bool ListEntitiesIterator::on_cover(cover::Cover *cover) {
+  this->client_->send_cover_info(cover);
+  return true;
+}
 #endif
 #ifdef USE_FAN
-bool ListEntitiesIterator::on_fan(fan::Fan *fan) { return this->client_->send_fan_info(fan); }
+bool ListEntitiesIterator::on_fan(fan::Fan *fan) {
+  this->client_->send_fan_info(fan);
+  return true;
+}
 #endif
 #ifdef USE_LIGHT
-bool ListEntitiesIterator::on_light(light::LightState *light) { return this->client_->send_light_info(light); }
+bool ListEntitiesIterator::on_light(light::LightState *light) {
+  this->client_->send_light_info(light);
+  return true;
+}
 #endif
 #ifdef USE_SENSOR
-bool ListEntitiesIterator::on_sensor(sensor::Sensor *sensor) { return this->client_->send_sensor_info(sensor); }
+bool ListEntitiesIterator::on_sensor(sensor::Sensor *sensor) {
+  this->client_->send_sensor_info(sensor);
+  return true;
+}
 #endif
 #ifdef USE_SWITCH
-bool ListEntitiesIterator::on_switch(switch_::Switch *a_switch) { return this->client_->send_switch_info(a_switch); }
+bool ListEntitiesIterator::on_switch(switch_::Switch *a_switch) {
+  this->client_->send_switch_info(a_switch);
+  return true;
+}
 #endif
 #ifdef USE_BUTTON
-bool ListEntitiesIterator::on_button(button::Button *button) { return this->client_->send_button_info(button); }
+bool ListEntitiesIterator::on_button(button::Button *button) {
+  this->client_->send_button_info(button);
+  return true;
+}
 #endif
 #ifdef USE_TEXT_SENSOR
 bool ListEntitiesIterator::on_text_sensor(text_sensor::TextSensor *text_sensor) {
-  return this->client_->send_text_sensor_info(text_sensor);
+  this->client_->send_text_sensor_info(text_sensor);
+  return true;
 }
 #endif
 #ifdef USE_LOCK
-bool ListEntitiesIterator::on_lock(lock::Lock *a_lock) { return this->client_->send_lock_info(a_lock); }
+bool ListEntitiesIterator::on_lock(lock::Lock *a_lock) {
+  this->client_->send_lock_info(a_lock);
+  return true;
+}
 #endif
 #ifdef USE_VALVE
-bool ListEntitiesIterator::on_valve(valve::Valve *valve) { return this->client_->send_valve_info(valve); }
+bool ListEntitiesIterator::on_valve(valve::Valve *valve) {
+  this->client_->send_valve_info(valve);
+  return true;
+}
 #endif
 
 bool ListEntitiesIterator::on_end() { return this->client_->send_list_info_done(); }
@@ -52,55 +78,83 @@ bool ListEntitiesIterator::on_service(UserServiceDescriptor *service) {
 
 #ifdef USE_ESP32_CAMERA
 bool ListEntitiesIterator::on_camera(esp32_camera::ESP32Camera *camera) {
-  return this->client_->send_camera_info(camera);
+  this->client_->send_camera_info(camera);
+  return true;
 }
 #endif
 
 #ifdef USE_CLIMATE
-bool ListEntitiesIterator::on_climate(climate::Climate *climate) { return this->client_->send_climate_info(climate); }
+bool ListEntitiesIterator::on_climate(climate::Climate *climate) {
+  this->client_->send_climate_info(climate);
+  return true;
+}
 #endif
 
 #ifdef USE_NUMBER
-bool ListEntitiesIterator::on_number(number::Number *number) { return this->client_->send_number_info(number); }
+bool ListEntitiesIterator::on_number(number::Number *number) {
+  this->client_->send_number_info(number);
+  return true;
+}
 #endif
 
 #ifdef USE_DATETIME_DATE
-bool ListEntitiesIterator::on_date(datetime::DateEntity *date) { return this->client_->send_date_info(date); }
+bool ListEntitiesIterator::on_date(datetime::DateEntity *date) {
+  this->client_->send_date_info(date);
+  return true;
+}
 #endif
 
 #ifdef USE_DATETIME_TIME
-bool ListEntitiesIterator::on_time(datetime::TimeEntity *time) { return this->client_->send_time_info(time); }
+bool ListEntitiesIterator::on_time(datetime::TimeEntity *time) {
+  this->client_->send_time_info(time);
+  return true;
+}
 #endif
 
 #ifdef USE_DATETIME_DATETIME
 bool ListEntitiesIterator::on_datetime(datetime::DateTimeEntity *datetime) {
-  return this->client_->send_datetime_info(datetime);
+  this->client_->send_datetime_info(datetime);
+  return true;
 }
 #endif
 
 #ifdef USE_TEXT
-bool ListEntitiesIterator::on_text(text::Text *text) { return this->client_->send_text_info(text); }
+bool ListEntitiesIterator::on_text(text::Text *text) {
+  this->client_->send_text_info(text);
+  return true;
+}
 #endif
 
 #ifdef USE_SELECT
-bool ListEntitiesIterator::on_select(select::Select *select) { return this->client_->send_select_info(select); }
+bool ListEntitiesIterator::on_select(select::Select *select) {
+  this->client_->send_select_info(select);
+  return true;
+}
 #endif
 
 #ifdef USE_MEDIA_PLAYER
 bool ListEntitiesIterator::on_media_player(media_player::MediaPlayer *media_player) {
-  return this->client_->send_media_player_info(media_player);
+  this->client_->send_media_player_info(media_player);
+  return true;
 }
 #endif
 #ifdef USE_ALARM_CONTROL_PANEL
 bool ListEntitiesIterator::on_alarm_control_panel(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel) {
-  return this->client_->send_alarm_control_panel_info(a_alarm_control_panel);
+  this->client_->send_alarm_control_panel_info(a_alarm_control_panel);
+  return true;
 }
 #endif
 #ifdef USE_EVENT
-bool ListEntitiesIterator::on_event(event::Event *event) { return this->client_->send_event_info(event); }
+bool ListEntitiesIterator::on_event(event::Event *event) {
+  this->client_->send_event_info(event);
+  return true;
+}
 #endif
 #ifdef USE_UPDATE
-bool ListEntitiesIterator::on_update(update::UpdateEntity *update) { return this->client_->send_update_info(update); }
+bool ListEntitiesIterator::on_update(update::UpdateEntity *update) {
+  this->client_->send_update_info(update);
+  return true;
+}
 #endif
 
 }  // namespace api

esphome/components/api/list_entities.h

@@ -80,6 +80,7 @@ class ListEntitiesIterator : public ComponentIterator {
   bool on_update(update::UpdateEntity *update) override;
 #endif
   bool on_end() override;
+  bool completed() { return this->state_ == IteratorState::NONE; }
 
  protected:
   APIConnection *client_;

esphome/components/api/subscribe_state.h

@@ -76,6 +76,8 @@ class InitialStateIterator : public ComponentIterator {
 #ifdef USE_UPDATE
   bool on_update(update::UpdateEntity *update) override;
 #endif
+  bool completed() { return this->state_ == IteratorState::NONE; }
+
  protected:
   APIConnection *client_;
 };

esphome/components/audio/audio_reader.cpp

@@ -15,6 +15,8 @@ namespace audio {
 
 static const uint32_t READ_WRITE_TIMEOUT_MS = 20;
 
+static const uint32_t CONNECTION_TIMEOUT_MS = 5000;
+
 // The number of times the http read times out with no data before throwing an error
 static const uint32_t ERROR_COUNT_NO_DATA_READ_TIMEOUT = 100;
 
@@ -97,7 +99,7 @@ esp_err_t AudioReader::start(const std::string &uri, AudioFileType &file_type) {
   client_config.user_data = this;
   client_config.buffer_size = HTTP_STREAM_BUFFER_SIZE;
   client_config.keep_alive_enable = true;
-  client_config.timeout_ms = 5000;  // Shouldn't trigger watchdog resets if caller runs in a task
+  client_config.timeout_ms = CONNECTION_TIMEOUT_MS;  // Shouldn't trigger watchdog resets if caller runs in a task
 
 #if CONFIG_MBEDTLS_CERTIFICATE_BUNDLE
   if (uri.find("https:") != std::string::npos) {
@@ -189,7 +191,7 @@ esp_err_t AudioReader::start(const std::string &uri, AudioFileType &file_type) {
     file_type = this->audio_file_type_;
   }
 
-  this->no_data_read_count_ = 0;
+  this->last_data_read_ms_ = millis();
 
   this->output_transfer_buffer_ = AudioSinkTransferBuffer::create(this->buffer_size_);
   if (this->output_transfer_buffer_ == nullptr) {
@@ -271,8 +273,7 @@ AudioReaderState AudioReader::http_read_() {
 
     if (received_len > 0) {
       this->output_transfer_buffer_->increase_buffer_length(received_len);
-
-      this->no_data_read_count_ = 0;
+      this->last_data_read_ms_ = millis();
     } else if (received_len < 0) {
       // HTTP read error
       this->cleanup_connection_();
@@ -280,12 +281,11 @@ AudioReaderState AudioReader::http_read_() {
     } else {
       if (bytes_to_read > 0) {
         // Read timed out
-        ++this->no_data_read_count_;
-        if (this->no_data_read_count_ >= ERROR_COUNT_NO_DATA_READ_TIMEOUT) {
-          // Timed out with no data read too many times, so the http read has failed
+        if ((millis() - this->last_data_read_ms_) > CONNECTION_TIMEOUT_MS) {
           this->cleanup_connection_();
           return AudioReaderState::FAILED;
         }
+
         delay(READ_WRITE_TIMEOUT_MS);
       }
     }

esphome/components/audio/audio_reader.h

@@ -71,7 +71,7 @@ class AudioReader {
   void cleanup_connection_();
 
   size_t buffer_size_;
-  uint32_t no_data_read_count_;
+  uint32_t last_data_read_ms_;
 
   esp_http_client_handle_t client_{nullptr};
 

esphome/components/bluetooth_proxy/bluetooth_proxy.h

@@ -15,6 +15,9 @@
 
 #include "bluetooth_connection.h"
 
+#include <esp_bt.h>
+#include <esp_bt_device.h>
+
 namespace esphome {
 namespace bluetooth_proxy {
 
@@ -114,6 +117,11 @@ class BluetoothProxy : public esp32_ble_tracker::ESPBTDeviceListener, public Com
     return flags;
   }
 
+  std::string get_bluetooth_mac_address_pretty() {
+    const uint8_t *mac = esp_bt_dev_get_address();
+    return str_snprintf("%02X:%02X:%02X:%02X:%02X:%02X", 17, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+  }
+
  protected:
   void send_api_packet_(const esp32_ble_tracker::ESPBTDevice &device);
 

esphome/components/bmp085/bmp085.cpp

@@ -95,7 +95,7 @@ void BMP085Component::read_pressure_() {
     return;
   }
 
-  uint32_t value = (uint32_t(buffer[0]) << 16) | (uint32_t(buffer[1]) << 8) | uint32_t(buffer[0]);
+  uint32_t value = (uint32_t(buffer[0]) << 16) | (uint32_t(buffer[1]) << 8) | uint32_t(buffer[2]);
   if ((value >> 5) == 0) {
     ESP_LOGW(TAG, "Invalid pressure!");
     this->status_set_warning();

esphome/components/chsc6x/__init__.py

@@ -0,0 +1,2 @@
+CODEOWNERS = ["@kkosik20"]
+DEPENDENCIES = ["i2c"]

esphome/components/chsc6x/chsc6x_touchscreen.cpp

@@ -0,0 +1,47 @@
+#include "chsc6x_touchscreen.h"
+
+namespace esphome {
+namespace chsc6x {
+
+void CHSC6XTouchscreen::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up CHSC6X Touchscreen...");
+  if (this->interrupt_pin_ != nullptr) {
+    this->interrupt_pin_->setup();
+    this->attach_interrupt_(this->interrupt_pin_, gpio::INTERRUPT_FALLING_EDGE);
+  }
+  if (this->x_raw_max_ == this->x_raw_min_) {
+    this->x_raw_max_ = this->display_->get_native_width();
+  }
+  if (this->y_raw_max_ == this->y_raw_min_) {
+    this->y_raw_max_ = this->display_->get_native_height();
+  }
+
+  ESP_LOGCONFIG(TAG, "CHSC6X Touchscreen setup complete");
+}
+
+void CHSC6XTouchscreen::update_touches() {
+  uint8_t data[CHSC6X_REG_STATUS_LEN];
+  if (!this->read_bytes(CHSC6X_REG_STATUS, data, sizeof(data))) {
+    return;
+  }
+
+  uint8_t num_of_touches = data[CHSC6X_REG_STATUS_TOUCH];
+
+  if (num_of_touches == 1) {
+    uint16_t x = data[CHSC6X_REG_STATUS_X_COR];
+    uint16_t y = data[CHSC6X_REG_STATUS_Y_COR];
+    this->add_raw_touch_position_(0, x, y);
+  }
+}
+
+void CHSC6XTouchscreen::dump_config() {
+  ESP_LOGCONFIG(TAG, "CHSC6X Touchscreen:");
+  LOG_I2C_DEVICE(this);
+  LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
+  ESP_LOGCONFIG(TAG, "  Touch timeout: %d", this->touch_timeout_);
+  ESP_LOGCONFIG(TAG, "  x_raw_max_: %d", this->x_raw_max_);
+  ESP_LOGCONFIG(TAG, "  y_raw_max_: %d", this->y_raw_max_);
+}
+
+}  // namespace chsc6x
+}  // namespace esphome

esphome/components/chsc6x/chsc6x_touchscreen.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/components/touchscreen/touchscreen.h"
+#include "esphome/core/component.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace chsc6x {
+
+static const char *const TAG = "chsc6x.touchscreen";
+
+static const uint8_t CHSC6X_REG_STATUS = 0x00;
+static const uint8_t CHSC6X_REG_STATUS_TOUCH = 0x00;
+static const uint8_t CHSC6X_REG_STATUS_X_COR = 0x02;
+static const uint8_t CHSC6X_REG_STATUS_Y_COR = 0x04;
+static const uint8_t CHSC6X_REG_STATUS_LEN = 0x05;
+static const uint8_t CHSC6X_CHIP_ID = 0x2e;
+
+class CHSC6XTouchscreen : public touchscreen::Touchscreen, public i2c::I2CDevice {
+ public:
+  void setup() override;
+  void update_touches() override;
+  void dump_config() override;
+
+  void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
+
+ protected:
+  InternalGPIOPin *interrupt_pin_{};
+};
+
+}  // namespace chsc6x
+}  // namespace esphome