esphome 2025.5.2__py3-none-any.whl → 2025.6.0b1__py3-none-any.whl

esphome/components/api/api_connection.h

@@ -11,6 +11,7 @@
 #include "esphome/core/entity_base.h"
 
 #include <vector>
+#include <functional>
 
 namespace esphome {
 namespace api {
@@ -18,49 +19,9 @@ namespace api {
 // Keepalive timeout in milliseconds
 static constexpr uint32_t KEEPALIVE_TIMEOUT_MS = 60000;
 
-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);
-  bool empty() const { return deferred_queue_.empty(); }
-};
-
 class APIConnection : public APIServerConnection {
  public:
+  friend class APIServer;
   APIConnection(std::unique_ptr<socket::Socket> socket, APIServer *parent);
   virtual ~APIConnection();
 
@@ -68,225 +29,105 @@ class APIConnection : public APIServerConnection {
   void loop();
 
   bool send_list_info_done() {
-    ListEntitiesDoneResponse resp;
-    return this->send_list_entities_done_response(resp);
+    return this->schedule_message_(nullptr, &APIConnection::try_send_list_info_done,
+                                   ListEntitiesDoneResponse::MESSAGE_TYPE);
   }
 #ifdef USE_BINARY_SENSOR
-  bool send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor, bool state);
+  bool send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor);
   void send_binary_sensor_info(binary_sensor::BinarySensor *binary_sensor);
-
- protected:
-  bool try_send_binary_sensor_state_(binary_sensor::BinarySensor *binary_sensor);
-  bool try_send_binary_sensor_state_(binary_sensor::BinarySensor *binary_sensor, bool state);
-  bool try_send_binary_sensor_info_(binary_sensor::BinarySensor *binary_sensor);
-
- public:
 #endif
 #ifdef USE_COVER
   bool send_cover_state(cover::Cover *cover);
   void send_cover_info(cover::Cover *cover);
   void cover_command(const CoverCommandRequest &msg) override;
-
- protected:
-  bool try_send_cover_state_(cover::Cover *cover);
-  bool try_send_cover_info_(cover::Cover *cover);
-
- public:
 #endif
 #ifdef USE_FAN
   bool send_fan_state(fan::Fan *fan);
   void send_fan_info(fan::Fan *fan);
   void fan_command(const FanCommandRequest &msg) override;
-
- protected:
-  bool try_send_fan_state_(fan::Fan *fan);
-  bool try_send_fan_info_(fan::Fan *fan);
-
- public:
 #endif
 #ifdef USE_LIGHT
   bool send_light_state(light::LightState *light);
   void send_light_info(light::LightState *light);
   void light_command(const LightCommandRequest &msg) override;
-
- protected:
-  bool try_send_light_state_(light::LightState *light);
-  bool try_send_light_info_(light::LightState *light);
-
- public:
 #endif
 #ifdef USE_SENSOR
-  bool send_sensor_state(sensor::Sensor *sensor, float state);
+  bool send_sensor_state(sensor::Sensor *sensor);
   void send_sensor_info(sensor::Sensor *sensor);
-
- protected:
-  bool try_send_sensor_state_(sensor::Sensor *sensor);
-  bool try_send_sensor_state_(sensor::Sensor *sensor, float state);
-  bool try_send_sensor_info_(sensor::Sensor *sensor);
-
- public:
 #endif
 #ifdef USE_SWITCH
-  bool send_switch_state(switch_::Switch *a_switch, bool state);
+  bool send_switch_state(switch_::Switch *a_switch);
   void send_switch_info(switch_::Switch *a_switch);
   void switch_command(const SwitchCommandRequest &msg) override;
-
- protected:
-  bool try_send_switch_state_(switch_::Switch *a_switch);
-  bool try_send_switch_state_(switch_::Switch *a_switch, bool state);
-  bool try_send_switch_info_(switch_::Switch *a_switch);
-
- public:
 #endif
 #ifdef USE_TEXT_SENSOR
-  bool send_text_sensor_state(text_sensor::TextSensor *text_sensor, std::string state);
+  bool send_text_sensor_state(text_sensor::TextSensor *text_sensor);
   void send_text_sensor_info(text_sensor::TextSensor *text_sensor);
-
- protected:
-  bool try_send_text_sensor_state_(text_sensor::TextSensor *text_sensor);
-  bool try_send_text_sensor_state_(text_sensor::TextSensor *text_sensor, std::string state);
-  bool try_send_text_sensor_info_(text_sensor::TextSensor *text_sensor);
-
- public:
 #endif
 #ifdef USE_ESP32_CAMERA
   void set_camera_state(std::shared_ptr<esp32_camera::CameraImage> image);
   void send_camera_info(esp32_camera::ESP32Camera *camera);
   void camera_image(const CameraImageRequest &msg) override;
-
- protected:
-  bool try_send_camera_info_(esp32_camera::ESP32Camera *camera);
-
- public:
 #endif
 #ifdef USE_CLIMATE
   bool send_climate_state(climate::Climate *climate);
   void send_climate_info(climate::Climate *climate);
   void climate_command(const ClimateCommandRequest &msg) override;
-
- protected:
-  bool try_send_climate_state_(climate::Climate *climate);
-  bool try_send_climate_info_(climate::Climate *climate);
-
- public:
 #endif
 #ifdef USE_NUMBER
-  bool send_number_state(number::Number *number, float state);
+  bool send_number_state(number::Number *number);
   void send_number_info(number::Number *number);
   void number_command(const NumberCommandRequest &msg) override;
-
- protected:
-  bool try_send_number_state_(number::Number *number);
-  bool try_send_number_state_(number::Number *number, float state);
-  bool try_send_number_info_(number::Number *number);
-
- public:
 #endif
 #ifdef USE_DATETIME_DATE
   bool send_date_state(datetime::DateEntity *date);
   void send_date_info(datetime::DateEntity *date);
   void date_command(const DateCommandRequest &msg) override;
-
- protected:
-  bool try_send_date_state_(datetime::DateEntity *date);
-  bool try_send_date_info_(datetime::DateEntity *date);
-
- public:
 #endif
 #ifdef USE_DATETIME_TIME
   bool send_time_state(datetime::TimeEntity *time);
   void send_time_info(datetime::TimeEntity *time);
   void time_command(const TimeCommandRequest &msg) override;
-
- protected:
-  bool try_send_time_state_(datetime::TimeEntity *time);
-  bool try_send_time_info_(datetime::TimeEntity *time);
-
- public:
 #endif
 #ifdef USE_DATETIME_DATETIME
   bool send_datetime_state(datetime::DateTimeEntity *datetime);
   void send_datetime_info(datetime::DateTimeEntity *datetime);
   void datetime_command(const DateTimeCommandRequest &msg) override;
-
- protected:
-  bool try_send_datetime_state_(datetime::DateTimeEntity *datetime);
-  bool try_send_datetime_info_(datetime::DateTimeEntity *datetime);
-
- public:
 #endif
 #ifdef USE_TEXT
-  bool send_text_state(text::Text *text, std::string state);
+  bool send_text_state(text::Text *text);
   void send_text_info(text::Text *text);
   void text_command(const TextCommandRequest &msg) override;
-
- protected:
-  bool try_send_text_state_(text::Text *text);
-  bool try_send_text_state_(text::Text *text, std::string state);
-  bool try_send_text_info_(text::Text *text);
-
- public:
 #endif
 #ifdef USE_SELECT
-  bool send_select_state(select::Select *select, std::string state);
+  bool send_select_state(select::Select *select);
   void send_select_info(select::Select *select);
   void select_command(const SelectCommandRequest &msg) override;
-
- protected:
-  bool try_send_select_state_(select::Select *select);
-  bool try_send_select_state_(select::Select *select, std::string state);
-  bool try_send_select_info_(select::Select *select);
-
- public:
 #endif
 #ifdef USE_BUTTON
   void send_button_info(button::Button *button);
   void button_command(const ButtonCommandRequest &msg) override;
-
- protected:
-  bool try_send_button_info_(button::Button *button);
-
- public:
 #endif
 #ifdef USE_LOCK
-  bool send_lock_state(lock::Lock *a_lock, lock::LockState state);
+  bool send_lock_state(lock::Lock *a_lock);
   void send_lock_info(lock::Lock *a_lock);
   void lock_command(const LockCommandRequest &msg) override;
-
- protected:
-  bool try_send_lock_state_(lock::Lock *a_lock);
-  bool try_send_lock_state_(lock::Lock *a_lock, lock::LockState state);
-  bool try_send_lock_info_(lock::Lock *a_lock);
-
- public:
 #endif
 #ifdef USE_VALVE
   bool send_valve_state(valve::Valve *valve);
   void send_valve_info(valve::Valve *valve);
   void valve_command(const ValveCommandRequest &msg) override;
-
- protected:
-  bool try_send_valve_state_(valve::Valve *valve);
-  bool try_send_valve_info_(valve::Valve *valve);
-
- public:
 #endif
 #ifdef USE_MEDIA_PLAYER
   bool send_media_player_state(media_player::MediaPlayer *media_player);
   void send_media_player_info(media_player::MediaPlayer *media_player);
   void media_player_command(const MediaPlayerCommandRequest &msg) override;
-
- protected:
-  bool try_send_media_player_state_(media_player::MediaPlayer *media_player);
-  bool try_send_media_player_info_(media_player::MediaPlayer *media_player);
-
- public:
 #endif
   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;
-    this->send_homeassistant_service_response(call);
+    this->send_message(call);
   }
 #ifdef USE_BLUETOOTH_PROXY
   void subscribe_bluetooth_le_advertisements(const SubscribeBluetoothLEAdvertisementsRequest &msg) override;
@@ -308,7 +149,7 @@ class APIConnection : public APIServerConnection {
 #ifdef USE_HOMEASSISTANT_TIME
   void send_time_request() {
     GetTimeRequest req;
-    this->send_get_time_request(req);
+    this->send_message(req);
   }
 #endif
 
@@ -328,36 +169,17 @@ class APIConnection : public APIServerConnection {
   bool send_alarm_control_panel_state(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel);
   void send_alarm_control_panel_info(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel);
   void alarm_control_panel_command(const AlarmControlPanelCommandRequest &msg) override;
-
- protected:
-  bool try_send_alarm_control_panel_state_(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel);
-  bool try_send_alarm_control_panel_info_(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel);
-
- public:
 #endif
 
 #ifdef USE_EVENT
-  void send_event(event::Event *event, std::string event_type);
+  void send_event(event::Event *event, const std::string &event_type);
   void send_event_info(event::Event *event);
-
- protected:
-  bool try_send_event_(event::Event *event);
-  bool try_send_event_(event::Event *event, std::string event_type);
-  bool try_send_event_info_(event::Event *event);
-
- public:
 #endif
 
 #ifdef USE_UPDATE
   bool send_update_state(update::UpdateEntity *update);
   void send_update_info(update::UpdateEntity *update);
   void update_command(const UpdateCommandRequest &msg) override;
-
- protected:
-  bool try_send_update_state_(update::UpdateEntity *update);
-  bool try_send_update_info_(update::UpdateEntity *update);
-
- public:
 #endif
 
   void on_disconnect_response(const DisconnectResponse &value) override;
@@ -407,102 +229,67 @@ class APIConnection : public APIServerConnection {
   void on_no_setup_connection() override;
   ProtoWriteBuffer create_buffer(uint32_t reserve_size) override {
     // FIXME: ensure no recursive writes can happen
-    this->proto_write_buffer_.clear();
+
     // Get header padding size - used for both reserve and insert
     uint8_t header_padding = this->helper_->frame_header_padding();
+
+    // Get shared buffer from parent server
+    std::vector<uint8_t> &shared_buf = this->parent_->get_shared_buffer_ref();
+    shared_buf.clear();
     // Reserve space for header padding + message + footer
     // - Header padding: space for protocol headers (7 bytes for Noise, 6 for Plaintext)
     // - Footer: space for MAC (16 bytes for Noise, 0 for Plaintext)
-    this->proto_write_buffer_.reserve(reserve_size + header_padding + this->helper_->frame_footer_size());
+    shared_buf.reserve(reserve_size + header_padding + this->helper_->frame_footer_size());
     // Insert header padding bytes so message encoding starts at the correct position
-    this->proto_write_buffer_.insert(this->proto_write_buffer_.begin(), header_padding, 0);
-    return {&this->proto_write_buffer_};
+    shared_buf.insert(shared_buf.begin(), header_padding, 0);
+    return {&shared_buf};
   }
-  bool try_to_clear_buffer(bool log_out_of_space);
-  bool send_buffer(ProtoWriteBuffer buffer, uint32_t message_type) override;
 
-  std::string get_client_combined_info() const { return this->client_combined_info_; }
-
- protected:
-  friend APIServer;
-
-  /**
-   * Generic send entity state method to reduce code duplication.
-   * Only attempts to build and send the message if the transmit buffer is available.
-   *
-   * This is the base version for entities that use their current state.
-   *
-   * @param entity The entity to send state for
-   * @param try_send_func The function that tries to send the state
-   * @return True on success or message deferred, false if subscription check failed
-   */
-  bool send_state_(esphome::EntityBase *entity, send_message_t try_send_func) {
-    if (!this->state_subscription_)
-      return false;
-    if (this->try_to_clear_buffer(true) && (this->*try_send_func)(entity)) {
-      return true;
+  // Prepare buffer for next message in batch
+  ProtoWriteBuffer prepare_message_buffer(uint16_t message_size, bool is_first_message) {
+    // Get reference to shared buffer (it maintains state between batch messages)
+    std::vector<uint8_t> &shared_buf = this->parent_->get_shared_buffer_ref();
+    size_t current_size = shared_buf.size();
+
+    if (is_first_message) {
+      // For first message, initialize buffer with header padding
+      uint8_t header_padding = this->helper_->frame_header_padding();
+      shared_buf.clear();
+      shared_buf.reserve(message_size + header_padding);
+      shared_buf.resize(header_padding);
+      // Fill header padding with zeros
+      std::fill(shared_buf.begin(), shared_buf.end(), 0);
+    } else {
+      // For subsequent messages, add footer space for previous message and header for this message
+      uint8_t footer_size = this->helper_->frame_footer_size();
+      uint8_t header_padding = this->helper_->frame_header_padding();
+
+      // Reserve additional space for everything
+      shared_buf.reserve(current_size + footer_size + header_padding + message_size);
+
+      // Single resize to add both footer and header padding
+      size_t new_size = current_size + footer_size + header_padding;
+      shared_buf.resize(new_size);
+
+      // Fill the newly added bytes with zeros (footer + header padding)
+      std::fill(shared_buf.begin() + current_size, shared_buf.end(), 0);
     }
-    this->deferred_message_queue_.defer(entity, try_send_func);
-    return true;
-  }
 
-  /**
-   * Send entity state method that handles explicit state values.
-   * Only attempts to build and send the message if the transmit buffer is available.
-   *
-   * This method accepts a state parameter to be used instead of the entity's current state.
-   * It attempts to send the state with the provided value first, and if that fails due to buffer constraints,
-   * it defers the entity for later processing using the entity-only function.
-   *
-   * @tparam EntityT The entity type
-   * @tparam StateT Type of the state parameter
-   * @tparam Args Additional argument types (if any)
-   * @param entity The entity to send state for
-   * @param try_send_entity_func The function that tries to send the state with entity pointer only
-   * @param try_send_state_func The function that tries to send the state with entity and state parameters
-   * @param state The state value to send
-   * @param args Additional arguments to pass to the try_send_state_func
-   * @return True on success or message deferred, false if subscription check failed
-   */
-  template<typename EntityT, typename StateT, typename... Args>
-  bool send_state_with_value_(EntityT *entity, bool (APIConnection::*try_send_entity_func)(EntityT *),
-                              bool (APIConnection::*try_send_state_func)(EntityT *, StateT, Args...), StateT state,
-                              Args... args) {
-    if (!this->state_subscription_)
-      return false;
-    if (this->try_to_clear_buffer(true) && (this->*try_send_state_func)(entity, state, args...)) {
-      return true;
-    }
-    this->deferred_message_queue_.defer(entity, reinterpret_cast<send_message_t>(try_send_entity_func));
-    return true;
+    return {&shared_buf};
   }
 
-  /**
-   * Generic send entity info method to reduce code duplication.
-   * Only attempts to build and send the message if the transmit buffer is available.
-   *
-   * @param entity The entity to send info for
-   * @param try_send_func The function that tries to send the info
-   */
-  void send_info_(esphome::EntityBase *entity, send_message_t try_send_func) {
-    if (this->try_to_clear_buffer(true) && (this->*try_send_func)(entity)) {
-      return;
-    }
-    this->deferred_message_queue_.defer(entity, try_send_func);
-  }
+  bool try_to_clear_buffer(bool log_out_of_space);
+  bool send_buffer(ProtoWriteBuffer buffer, uint16_t message_type) override;
 
-  /**
-   * Generic function for generating entity info response messages.
-   * This is used to reduce duplication in the try_send_*_info functions.
-   *
-   * @param entity The entity to generate info for
-   * @param response The response object
-   * @param send_response_func Function pointer to send the response
-   * @return True if the message was sent successfully
-   */
-  template<typename ResponseT>
-  bool try_send_entity_info_(esphome::EntityBase *entity, ResponseT &response,
-                             bool (APIServerConnectionBase::*send_response_func)(const ResponseT &)) {
+  std::string get_client_combined_info() const { return this->client_combined_info_; }
+
+  // Buffer allocator methods for batch processing
+  ProtoWriteBuffer allocate_single_message_buffer(uint16_t size);
+  ProtoWriteBuffer allocate_batch_message_buffer(uint16_t size);
+
+ protected:
+  // Helper function to fill common entity fields
+  template<typename ResponseT> static void fill_entity_info_base(esphome::EntityBase *entity, ResponseT &response) {
     // Set common fields that are shared by all entity types
     response.key = entity->get_object_id_hash();
     response.object_id = entity->get_object_id();
@@ -514,12 +301,137 @@ class APIConnection : public APIServerConnection {
     response.icon = entity->get_icon();
     response.disabled_by_default = entity->is_disabled_by_default();
     response.entity_category = static_cast<enums::EntityCategory>(entity->get_entity_category());
-
-    // Send the response using the provided send method
-    return (this->*send_response_func)(response);
   }
 
-  bool send_(const void *buf, size_t len, bool force);
+  // Non-template helper to encode any ProtoMessage
+  static uint16_t encode_message_to_buffer(ProtoMessage &msg, uint16_t message_type, APIConnection *conn,
+                                           uint32_t remaining_size, bool is_single);
+
+#ifdef USE_BINARY_SENSOR
+  static uint16_t try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                               bool is_single);
+  static uint16_t try_send_binary_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                              bool is_single);
+#endif
+#ifdef USE_COVER
+  static uint16_t try_send_cover_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
+  static uint16_t try_send_cover_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+#endif
+#ifdef USE_FAN
+  static uint16_t try_send_fan_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_fan_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+#endif
+#ifdef USE_LIGHT
+  static uint16_t try_send_light_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
+  static uint16_t try_send_light_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+#endif
+#ifdef USE_SENSOR
+  static uint16_t try_send_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                        bool is_single);
+  static uint16_t try_send_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
+#endif
+#ifdef USE_SWITCH
+  static uint16_t try_send_switch_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                        bool is_single);
+  static uint16_t try_send_switch_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
+#endif
+#ifdef USE_TEXT_SENSOR
+  static uint16_t try_send_text_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                             bool is_single);
+  static uint16_t try_send_text_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                            bool is_single);
+#endif
+#ifdef USE_CLIMATE
+  static uint16_t try_send_climate_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                         bool is_single);
+  static uint16_t try_send_climate_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                        bool is_single);
+#endif
+#ifdef USE_NUMBER
+  static uint16_t try_send_number_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                        bool is_single);
+  static uint16_t try_send_number_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
+#endif
+#ifdef USE_DATETIME_DATE
+  static uint16_t try_send_date_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_date_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+#endif
+#ifdef USE_DATETIME_TIME
+  static uint16_t try_send_time_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_time_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+#endif
+#ifdef USE_DATETIME_DATETIME
+  static uint16_t try_send_datetime_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                          bool is_single);
+  static uint16_t try_send_datetime_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                         bool is_single);
+#endif
+#ifdef USE_TEXT
+  static uint16_t try_send_text_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_text_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+#endif
+#ifdef USE_SELECT
+  static uint16_t try_send_select_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                        bool is_single);
+  static uint16_t try_send_select_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
+#endif
+#ifdef USE_BUTTON
+  static uint16_t try_send_button_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
+#endif
+#ifdef USE_LOCK
+  static uint16_t try_send_lock_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_lock_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+#endif
+#ifdef USE_VALVE
+  static uint16_t try_send_valve_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
+  static uint16_t try_send_valve_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+#endif
+#ifdef USE_MEDIA_PLAYER
+  static uint16_t try_send_media_player_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                              bool is_single);
+  static uint16_t try_send_media_player_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                             bool is_single);
+#endif
+#ifdef USE_ALARM_CONTROL_PANEL
+  static uint16_t try_send_alarm_control_panel_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                                     bool is_single);
+  static uint16_t try_send_alarm_control_panel_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                                    bool is_single);
+#endif
+#ifdef USE_EVENT
+  static uint16_t try_send_event_response(event::Event *event, const std::string &event_type, APIConnection *conn,
+                                          uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_event_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
+#endif
+#ifdef USE_UPDATE
+  static uint16_t try_send_update_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                        bool is_single);
+  static uint16_t try_send_update_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
+#endif
+#ifdef USE_ESP32_CAMERA
+  static uint16_t try_send_camera_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                       bool is_single);
+#endif
+
+  // Method for ListEntitiesDone batching
+  static uint16_t try_send_list_info_done(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                          bool is_single);
+
+  // Method for DisconnectRequest batching
+  static uint16_t try_send_disconnect_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+                                              bool is_single);
+
+  // Helper function to get estimated message size for buffer pre-allocation
+  static uint16_t get_estimated_message_size(uint16_t message_type);
 
   enum class ConnectionState {
     WAITING_FOR_HELLO,
@@ -529,9 +441,6 @@ class APIConnection : public APIServerConnection {
 
   bool remove_{false};
 
-  // Buffer used to encode proto messages
-  // Re-use to prevent allocations
-  std::vector<uint8_t> proto_write_buffer_;
   std::unique_ptr<APIFrameHelper> helper_;
 
   std::string client_info_;
@@ -552,10 +461,160 @@ 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;
+
+  // Function pointer type for message encoding
+  using MessageCreatorPtr = uint16_t (*)(EntityBase *, APIConnection *, uint32_t remaining_size, bool is_single);
+
+  // Optimized MessageCreator class using union dispatch
+  class MessageCreator {
+   public:
+    // Constructor for function pointer (message_type = 0)
+    MessageCreator(MessageCreatorPtr ptr) : message_type_(0) { data_.ptr = ptr; }
+
+    // Constructor for string state capture
+    MessageCreator(const std::string &value, uint16_t msg_type) : message_type_(msg_type) {
+      data_.string_ptr = new std::string(value);
+    }
+
+    // Destructor
+    ~MessageCreator() {
+      // Clean up string data for string-based message types
+      if (uses_string_data_()) {
+        delete data_.string_ptr;
+      }
+    }
+
+    // Copy constructor
+    MessageCreator(const MessageCreator &other) : message_type_(other.message_type_) {
+      if (message_type_ == 0) {
+        data_.ptr = other.data_.ptr;
+      } else if (uses_string_data_()) {
+        data_.string_ptr = new std::string(*other.data_.string_ptr);
+      } else {
+        data_ = other.data_;  // For POD types
+      }
+    }
+
+    // Move constructor
+    MessageCreator(MessageCreator &&other) noexcept : data_(other.data_), message_type_(other.message_type_) {
+      other.message_type_ = 0;  // Reset other to function pointer type
+      other.data_.ptr = nullptr;
+    }
+
+    // Assignment operators (needed for batch deduplication)
+    MessageCreator &operator=(const MessageCreator &other) {
+      if (this != &other) {
+        // Clean up current string data if needed
+        if (uses_string_data_()) {
+          delete data_.string_ptr;
+        }
+        // Copy new data
+        message_type_ = other.message_type_;
+        if (other.message_type_ == 0) {
+          data_.ptr = other.data_.ptr;
+        } else if (other.uses_string_data_()) {
+          data_.string_ptr = new std::string(*other.data_.string_ptr);
+        } else {
+          data_ = other.data_;
+        }
+      }
+      return *this;
+    }
+
+    MessageCreator &operator=(MessageCreator &&other) noexcept {
+      if (this != &other) {
+        // Clean up current string data if needed
+        if (uses_string_data_()) {
+          delete data_.string_ptr;
+        }
+        // Move data
+        message_type_ = other.message_type_;
+        data_ = other.data_;
+        // Reset other to safe state
+        other.message_type_ = 0;
+        other.data_.ptr = nullptr;
+      }
+      return *this;
+    }
+
+    // Call operator
+    uint16_t operator()(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single) const;
+
+   private:
+    // Helper to check if this message type uses heap-allocated strings
+    bool uses_string_data_() const { return message_type_ == EventResponse::MESSAGE_TYPE; }
+    union CreatorData {
+      MessageCreatorPtr ptr;    // 8 bytes
+      std::string *string_ptr;  // 8 bytes
+    } data_;                    // 8 bytes
+    uint16_t message_type_;     // 2 bytes (0 = function ptr, >0 = state capture)
+  };
+
+  // Generic batching mechanism for both state updates and entity info
+  struct DeferredBatch {
+    struct BatchItem {
+      EntityBase *entity;      // Entity pointer
+      MessageCreator creator;  // Function that creates the message when needed
+      uint16_t message_type;   // Message type for overhead calculation
+
+      // Constructor for creating BatchItem
+      BatchItem(EntityBase *entity, MessageCreator creator, uint16_t message_type)
+          : entity(entity), creator(std::move(creator)), message_type(message_type) {}
+    };
+
+    std::vector<BatchItem> items;
+    uint32_t batch_start_time{0};
+    bool batch_scheduled{false};
+
+    DeferredBatch() {
+      // Pre-allocate capacity for typical batch sizes to avoid reallocation
+      items.reserve(8);
+    }
+
+    // Add item to the batch
+    void add_item(EntityBase *entity, MessageCreator creator, uint16_t message_type);
+    void clear() {
+      items.clear();
+      batch_scheduled = false;
+      batch_start_time = 0;
+    }
+    bool empty() const { return items.empty(); }
+  };
+
+  DeferredBatch deferred_batch_;
+  uint32_t get_batch_delay_ms_() const;
+  // Message will use 8 more bytes than the minimum size, and typical
+  // MTU is 1500. Sometimes users will see as low as 1460 MTU.
+  // If its IPv6 the header is 40 bytes, and if its IPv4
+  // the header is 20 bytes. So we have 1460 - 40 = 1420 bytes
+  // available for the payload. But we also need to add the size of
+  // the protobuf overhead, which is 8 bytes.
+  //
+  // To be safe we pick 1390 bytes as the maximum size
+  // to send in one go. This is the maximum size of a single packet
+  // that can be sent over the network.
+  // This is to avoid fragmentation of the packet.
+  static constexpr size_t MAX_PACKET_SIZE = 1390;  // MTU
+
+  bool schedule_batch_();
+  void process_batch_();
+
+  // State for batch buffer allocation
+  bool batch_first_message_{false};
+
+  // Helper function to schedule a deferred message with known message type
+  bool schedule_message_(EntityBase *entity, MessageCreator creator, uint16_t message_type) {
+    this->deferred_batch_.add_item(entity, std::move(creator), message_type);
+    return this->schedule_batch_();
+  }
+
+  // Overload for function pointers (for info messages and current state reads)
+  bool schedule_message_(EntityBase *entity, MessageCreatorPtr function_ptr, uint16_t message_type) {
+    return schedule_message_(entity, MessageCreator(function_ptr), message_type);
+  }
 };
 
 }  // namespace api