Reduce web_server code duplication by extracting detail parameter parsing

esphome/components/api/api_connection.cpp

@@ -303,6 +303,10 @@ bool APIConnection::send_binary_sensor_state(binary_sensor::BinarySensor *binary
   return this->schedule_message_(binary_sensor, &APIConnection::try_send_binary_sensor_state,
                                  BinarySensorStateResponse::MESSAGE_TYPE);
 }
+void APIConnection::send_binary_sensor_info(binary_sensor::BinarySensor *binary_sensor) {
+  this->schedule_message_(binary_sensor, &APIConnection::try_send_binary_sensor_info,
+                          ListEntitiesBinarySensorResponse::MESSAGE_TYPE);
+}
 
 uint16_t APIConnection::try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                      bool is_single) {
@@ -330,6 +334,9 @@ uint16_t APIConnection::try_send_binary_sensor_info(EntityBase *entity, APIConne
 bool APIConnection::send_cover_state(cover::Cover *cover) {
   return this->schedule_message_(cover, &APIConnection::try_send_cover_state, CoverStateResponse::MESSAGE_TYPE);
 }
+void APIConnection::send_cover_info(cover::Cover *cover) {
+  this->schedule_message_(cover, &APIConnection::try_send_cover_info, ListEntitiesCoverResponse::MESSAGE_TYPE);
+}
 uint16_t APIConnection::try_send_cover_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                              bool is_single) {
   auto *cover = static_cast<cover::Cover *>(entity);
@@ -391,6 +398,9 @@ void APIConnection::cover_command(const CoverCommandRequest &msg) {
 bool APIConnection::send_fan_state(fan::Fan *fan) {
   return this->schedule_message_(fan, &APIConnection::try_send_fan_state, FanStateResponse::MESSAGE_TYPE);
 }
+void APIConnection::send_fan_info(fan::Fan *fan) {
+  this->schedule_message_(fan, &APIConnection::try_send_fan_info, ListEntitiesFanResponse::MESSAGE_TYPE);
+}
 uint16_t APIConnection::try_send_fan_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                            bool is_single) {
   auto *fan = static_cast<fan::Fan *>(entity);
@@ -450,6 +460,9 @@ void APIConnection::fan_command(const FanCommandRequest &msg) {
 bool APIConnection::send_light_state(light::LightState *light) {
   return this->schedule_message_(light, &APIConnection::try_send_light_state, LightStateResponse::MESSAGE_TYPE);
 }
+void APIConnection::send_light_info(light::LightState *light) {
+  this->schedule_message_(light, &APIConnection::try_send_light_info, ListEntitiesLightResponse::MESSAGE_TYPE);
+}
 uint16_t APIConnection::try_send_light_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                              bool is_single) {
   auto *light = static_cast<light::LightState *>(entity);
@@ -542,6 +555,9 @@ void APIConnection::light_command(const LightCommandRequest &msg) {
 bool APIConnection::send_sensor_state(sensor::Sensor *sensor) {
   return this->schedule_message_(sensor, &APIConnection::try_send_sensor_state, SensorStateResponse::MESSAGE_TYPE);
 }
+void APIConnection::send_sensor_info(sensor::Sensor *sensor) {
+  this->schedule_message_(sensor, &APIConnection::try_send_sensor_info, ListEntitiesSensorResponse::MESSAGE_TYPE);
+}
 
 uint16_t APIConnection::try_send_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single) {
@@ -574,6 +590,9 @@ uint16_t APIConnection::try_send_sensor_info(EntityBase *entity, APIConnection *
 bool APIConnection::send_switch_state(switch_::Switch *a_switch) {
   return this->schedule_message_(a_switch, &APIConnection::try_send_switch_state, SwitchStateResponse::MESSAGE_TYPE);
 }
+void APIConnection::send_switch_info(switch_::Switch *a_switch) {
+  this->schedule_message_(a_switch, &APIConnection::try_send_switch_info, ListEntitiesSwitchResponse::MESSAGE_TYPE);
+}
 
 uint16_t APIConnection::try_send_switch_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single) {
@@ -612,6 +631,10 @@ bool APIConnection::send_text_sensor_state(text_sensor::TextSensor *text_sensor)
   return this->schedule_message_(text_sensor, &APIConnection::try_send_text_sensor_state,
                                  TextSensorStateResponse::MESSAGE_TYPE);
 }
+void APIConnection::send_text_sensor_info(text_sensor::TextSensor *text_sensor) {
+  this->schedule_message_(text_sensor, &APIConnection::try_send_text_sensor_info,
+                          ListEntitiesTextSensorResponse::MESSAGE_TYPE);
+}
 
 uint16_t APIConnection::try_send_text_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                    bool is_single) {
@@ -672,6 +695,9 @@ uint16_t APIConnection::try_send_climate_state(EntityBase *entity, APIConnection
     resp.target_humidity = climate->target_humidity;
   return encode_message_to_buffer(resp, ClimateStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
+void APIConnection::send_climate_info(climate::Climate *climate) {
+  this->schedule_message_(climate, &APIConnection::try_send_climate_info, ListEntitiesClimateResponse::MESSAGE_TYPE);
+}
 uint16_t APIConnection::try_send_climate_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single) {
   auto *climate = static_cast<climate::Climate *>(entity);
@@ -739,6 +765,9 @@ void APIConnection::climate_command(const ClimateCommandRequest &msg) {
 bool APIConnection::send_number_state(number::Number *number) {
   return this->schedule_message_(number, &APIConnection::try_send_number_state, NumberStateResponse::MESSAGE_TYPE);
 }
+void APIConnection::send_number_info(number::Number *number) {
+  this->schedule_message_(number, &APIConnection::try_send_number_info, ListEntitiesNumberResponse::MESSAGE_TYPE);
+}
 
 uint16_t APIConnection::try_send_number_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single) {
@@ -790,6 +819,9 @@ uint16_t APIConnection::try_send_date_state(EntityBase *entity, APIConnection *c
   fill_entity_state_base(date, resp);
   return encode_message_to_buffer(resp, DateStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
+void APIConnection::send_date_info(datetime::DateEntity *date) {
+  this->schedule_message_(date, &APIConnection::try_send_date_info, ListEntitiesDateResponse::MESSAGE_TYPE);
+}
 uint16_t APIConnection::try_send_date_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                            bool is_single) {
   auto *date = static_cast<datetime::DateEntity *>(entity);
@@ -824,6 +856,9 @@ uint16_t APIConnection::try_send_time_state(EntityBase *entity, APIConnection *c
   fill_entity_state_base(time, resp);
   return encode_message_to_buffer(resp, TimeStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
+void APIConnection::send_time_info(datetime::TimeEntity *time) {
+  this->schedule_message_(time, &APIConnection::try_send_time_info, ListEntitiesTimeResponse::MESSAGE_TYPE);
+}
 uint16_t APIConnection::try_send_time_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                            bool is_single) {
   auto *time = static_cast<datetime::TimeEntity *>(entity);
@@ -860,6 +895,9 @@ uint16_t APIConnection::try_send_datetime_state(EntityBase *entity, APIConnectio
   fill_entity_state_base(datetime, resp);
   return encode_message_to_buffer(resp, DateTimeStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
+void APIConnection::send_datetime_info(datetime::DateTimeEntity *datetime) {
+  this->schedule_message_(datetime, &APIConnection::try_send_datetime_info, ListEntitiesDateTimeResponse::MESSAGE_TYPE);
+}
 uint16_t APIConnection::try_send_datetime_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                bool is_single) {
   auto *datetime = static_cast<datetime::DateTimeEntity *>(entity);
@@ -883,6 +921,9 @@ void APIConnection::datetime_command(const DateTimeCommandRequest &msg) {
 bool APIConnection::send_text_state(text::Text *text) {
   return this->schedule_message_(text, &APIConnection::try_send_text_state, TextStateResponse::MESSAGE_TYPE);
 }
+void APIConnection::send_text_info(text::Text *text) {
+  this->schedule_message_(text, &APIConnection::try_send_text_info, ListEntitiesTextResponse::MESSAGE_TYPE);
+}
 
 uint16_t APIConnection::try_send_text_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                             bool is_single) {
@@ -921,6 +962,9 @@ void APIConnection::text_command(const TextCommandRequest &msg) {
 bool APIConnection::send_select_state(select::Select *select) {
   return this->schedule_message_(select, &APIConnection::try_send_select_state, SelectStateResponse::MESSAGE_TYPE);
 }
+void APIConnection::send_select_info(select::Select *select) {
+  this->schedule_message_(select, &APIConnection::try_send_select_info, ListEntitiesSelectResponse::MESSAGE_TYPE);
+}
 
 uint16_t APIConnection::try_send_select_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single) {
@@ -954,6 +998,9 @@ void APIConnection::select_command(const SelectCommandRequest &msg) {
 #endif
 
 #ifdef USE_BUTTON
+void esphome::api::APIConnection::send_button_info(button::Button *button) {
+  this->schedule_message_(button, &APIConnection::try_send_button_info, ListEntitiesButtonResponse::MESSAGE_TYPE);
+}
 uint16_t APIConnection::try_send_button_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                              bool is_single) {
   auto *button = static_cast<button::Button *>(entity);
@@ -976,6 +1023,9 @@ void esphome::api::APIConnection::button_command(const ButtonCommandRequest &msg
 bool APIConnection::send_lock_state(lock::Lock *a_lock) {
   return this->schedule_message_(a_lock, &APIConnection::try_send_lock_state, LockStateResponse::MESSAGE_TYPE);
 }
+void APIConnection::send_lock_info(lock::Lock *a_lock) {
+  this->schedule_message_(a_lock, &APIConnection::try_send_lock_info, ListEntitiesLockResponse::MESSAGE_TYPE);
+}
 
 uint16_t APIConnection::try_send_lock_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                             bool is_single) {
@@ -1029,6 +1079,9 @@ uint16_t APIConnection::try_send_valve_state(EntityBase *entity, APIConnection *
   fill_entity_state_base(valve, resp);
   return encode_message_to_buffer(resp, ValveStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
+void APIConnection::send_valve_info(valve::Valve *valve) {
+  this->schedule_message_(valve, &APIConnection::try_send_valve_info, ListEntitiesValveResponse::MESSAGE_TYPE);
+}
 uint16_t APIConnection::try_send_valve_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                             bool is_single) {
   auto *valve = static_cast<valve::Valve *>(entity);
@@ -1074,6 +1127,10 @@ uint16_t APIConnection::try_send_media_player_state(EntityBase *entity, APIConne
   fill_entity_state_base(media_player, resp);
   return encode_message_to_buffer(resp, MediaPlayerStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
+void APIConnection::send_media_player_info(media_player::MediaPlayer *media_player) {
+  this->schedule_message_(media_player, &APIConnection::try_send_media_player_info,
+                          ListEntitiesMediaPlayerResponse::MESSAGE_TYPE);
+}
 uint16_t APIConnection::try_send_media_player_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                    bool is_single) {
   auto *media_player = static_cast<media_player::MediaPlayer *>(entity);
@@ -1125,6 +1182,9 @@ void APIConnection::set_camera_state(std::shared_ptr<esp32_camera::CameraImage>
       image->was_requested_by(esphome::esp32_camera::IDLE))
     this->image_reader_.set_image(std::move(image));
 }
+void APIConnection::send_camera_info(esp32_camera::ESP32Camera *camera) {
+  this->schedule_message_(camera, &APIConnection::try_send_camera_info, ListEntitiesCameraResponse::MESSAGE_TYPE);
+}
 uint16_t APIConnection::try_send_camera_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                              bool is_single) {
   auto *camera = static_cast<esp32_camera::ESP32Camera *>(entity);
@@ -1331,6 +1391,10 @@ uint16_t APIConnection::try_send_alarm_control_panel_state(EntityBase *entity, A
   fill_entity_state_base(a_alarm_control_panel, resp);
   return encode_message_to_buffer(resp, AlarmControlPanelStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
+void APIConnection::send_alarm_control_panel_info(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel) {
+  this->schedule_message_(a_alarm_control_panel, &APIConnection::try_send_alarm_control_panel_info,
+                          ListEntitiesAlarmControlPanelResponse::MESSAGE_TYPE);
+}
 uint16_t APIConnection::try_send_alarm_control_panel_info(EntityBase *entity, APIConnection *conn,
                                                           uint32_t remaining_size, bool is_single) {
   auto *a_alarm_control_panel = static_cast<alarm_control_panel::AlarmControlPanel *>(entity);
@@ -1381,6 +1445,9 @@ void APIConnection::alarm_control_panel_command(const AlarmControlPanelCommandRe
 void APIConnection::send_event(event::Event *event, const std::string &event_type) {
   this->schedule_message_(event, MessageCreator(event_type), EventResponse::MESSAGE_TYPE);
 }
+void APIConnection::send_event_info(event::Event *event) {
+  this->schedule_message_(event, &APIConnection::try_send_event_info, ListEntitiesEventResponse::MESSAGE_TYPE);
+}
 uint16_t APIConnection::try_send_event_response(event::Event *event, const std::string &event_type, APIConnection *conn,
                                                 uint32_t remaining_size, bool is_single) {
   EventResponse resp;
@@ -1426,6 +1493,9 @@ uint16_t APIConnection::try_send_update_state(EntityBase *entity, APIConnection
   fill_entity_state_base(update, resp);
   return encode_message_to_buffer(resp, UpdateStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
+void APIConnection::send_update_info(update::UpdateEntity *update) {
+  this->schedule_message_(update, &APIConnection::try_send_update_info, ListEntitiesUpdateResponse::MESSAGE_TYPE);
+}
 uint16_t APIConnection::try_send_update_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                              bool is_single) {
   auto *update = static_cast<update::UpdateEntity *>(entity);

esphome/components/api/api_connection.h

@@ -22,7 +22,6 @@ static constexpr uint32_t KEEPALIVE_TIMEOUT_MS = 60000;
 class APIConnection : public APIServerConnection {
  public:
   friend class APIServer;
-  friend class ListEntitiesIterator;
   APIConnection(std::unique_ptr<socket::Socket> socket, APIServer *parent);
   virtual ~APIConnection();
 
@@ -35,74 +34,93 @@ class APIConnection : public APIServerConnection {
   }
 #ifdef USE_BINARY_SENSOR
   bool send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor);
+  void send_binary_sensor_info(binary_sensor::BinarySensor *binary_sensor);
 #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;
 #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;
 #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;
 #endif
 #ifdef USE_SENSOR
   bool send_sensor_state(sensor::Sensor *sensor);
+  void send_sensor_info(sensor::Sensor *sensor);
 #endif
 #ifdef USE_SWITCH
   bool send_switch_state(switch_::Switch *a_switch);
+  void send_switch_info(switch_::Switch *a_switch);
   void switch_command(const SwitchCommandRequest &msg) override;
 #endif
 #ifdef USE_TEXT_SENSOR
   bool send_text_sensor_state(text_sensor::TextSensor *text_sensor);
+  void send_text_sensor_info(text_sensor::TextSensor *text_sensor);
 #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;
 #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;
 #endif
 #ifdef USE_NUMBER
   bool send_number_state(number::Number *number);
+  void send_number_info(number::Number *number);
   void number_command(const NumberCommandRequest &msg) override;
 #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;
 #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;
 #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;
 #endif
 #ifdef USE_TEXT
   bool send_text_state(text::Text *text);
+  void send_text_info(text::Text *text);
   void text_command(const TextCommandRequest &msg) override;
 #endif
 #ifdef USE_SELECT
   bool send_select_state(select::Select *select);
+  void send_select_info(select::Select *select);
   void select_command(const SelectCommandRequest &msg) override;
 #endif
 #ifdef USE_BUTTON
+  void send_button_info(button::Button *button);
   void button_command(const ButtonCommandRequest &msg) override;
 #endif
 #ifdef USE_LOCK
   bool send_lock_state(lock::Lock *a_lock);
+  void send_lock_info(lock::Lock *a_lock);
   void lock_command(const LockCommandRequest &msg) override;
 #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;
 #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;
 #endif
   bool try_send_log_message(int level, const char *tag, const char *line);
@@ -149,15 +167,18 @@ class APIConnection : public APIServerConnection {
 
 #ifdef USE_ALARM_CONTROL_PANEL
   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;
 #endif
 
 #ifdef USE_EVENT
   void send_event(event::Event *event, const std::string &event_type);
+  void send_event_info(event::Event *event);
 #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;
 #endif
 

esphome/components/api/api_pb2_service.cpp

@@ -14,7 +14,7 @@ void APIServerConnectionBase::log_send_message_(const char *name, const std::str
 }
 #endif
 
-void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) {
+bool APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) {
   switch (msg_type) {
     case 1: {
       HelloRequest msg;
@@ -106,50 +106,50 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       this->on_subscribe_logs_request(msg);
       break;
     }
-#ifdef USE_COVER
     case 30: {
+#ifdef USE_COVER
       CoverCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_cover_command_request: %s", msg.dump().c_str());
 #endif
       this->on_cover_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_FAN
     case 31: {
+#ifdef USE_FAN
       FanCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_fan_command_request: %s", msg.dump().c_str());
 #endif
       this->on_fan_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_LIGHT
     case 32: {
+#ifdef USE_LIGHT
       LightCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_light_command_request: %s", msg.dump().c_str());
 #endif
       this->on_light_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_SWITCH
     case 33: {
+#ifdef USE_SWITCH
       SwitchCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_switch_command_request: %s", msg.dump().c_str());
 #endif
       this->on_switch_command_request(msg);
+#endif
       break;
     }
-#endif
     case 34: {
       SubscribeHomeassistantServicesRequest msg;
       msg.decode(msg_data, msg_size);
@@ -204,394 +204,395 @@ void APIServerConnectionBase::read_message(uint32_t msg_size, uint32_t msg_type,
       this->on_execute_service_request(msg);
       break;
     }
-#ifdef USE_ESP32_CAMERA
     case 45: {
+#ifdef USE_ESP32_CAMERA
       CameraImageRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_camera_image_request: %s", msg.dump().c_str());
 #endif
       this->on_camera_image_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_CLIMATE
     case 48: {
+#ifdef USE_CLIMATE
       ClimateCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_climate_command_request: %s", msg.dump().c_str());
 #endif
       this->on_climate_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_NUMBER
     case 51: {
+#ifdef USE_NUMBER
       NumberCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_number_command_request: %s", msg.dump().c_str());
 #endif
       this->on_number_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_SELECT
     case 54: {
+#ifdef USE_SELECT
       SelectCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_select_command_request: %s", msg.dump().c_str());
 #endif
       this->on_select_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_SIREN
     case 57: {
+#ifdef USE_SIREN
       SirenCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_siren_command_request: %s", msg.dump().c_str());
 #endif
       this->on_siren_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_LOCK
     case 60: {
+#ifdef USE_LOCK
       LockCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_lock_command_request: %s", msg.dump().c_str());
 #endif
       this->on_lock_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_BUTTON
     case 62: {
+#ifdef USE_BUTTON
       ButtonCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_button_command_request: %s", msg.dump().c_str());
 #endif
       this->on_button_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_MEDIA_PLAYER
     case 65: {
+#ifdef USE_MEDIA_PLAYER
       MediaPlayerCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_media_player_command_request: %s", msg.dump().c_str());
 #endif
       this->on_media_player_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_BLUETOOTH_PROXY
     case 66: {
+#ifdef USE_BLUETOOTH_PROXY
       SubscribeBluetoothLEAdvertisementsRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_subscribe_bluetooth_le_advertisements_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_bluetooth_le_advertisements_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_BLUETOOTH_PROXY
     case 68: {
+#ifdef USE_BLUETOOTH_PROXY
       BluetoothDeviceRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_bluetooth_device_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_device_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_BLUETOOTH_PROXY
     case 70: {
+#ifdef USE_BLUETOOTH_PROXY
       BluetoothGATTGetServicesRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_bluetooth_gatt_get_services_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_get_services_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_BLUETOOTH_PROXY
     case 73: {
+#ifdef USE_BLUETOOTH_PROXY
       BluetoothGATTReadRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_bluetooth_gatt_read_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_read_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_BLUETOOTH_PROXY
     case 75: {
+#ifdef USE_BLUETOOTH_PROXY
       BluetoothGATTWriteRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_bluetooth_gatt_write_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_write_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_BLUETOOTH_PROXY
     case 76: {
+#ifdef USE_BLUETOOTH_PROXY
       BluetoothGATTReadDescriptorRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_bluetooth_gatt_read_descriptor_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_read_descriptor_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_BLUETOOTH_PROXY
     case 77: {
+#ifdef USE_BLUETOOTH_PROXY
       BluetoothGATTWriteDescriptorRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_bluetooth_gatt_write_descriptor_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_write_descriptor_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_BLUETOOTH_PROXY
     case 78: {
+#ifdef USE_BLUETOOTH_PROXY
       BluetoothGATTNotifyRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_bluetooth_gatt_notify_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_gatt_notify_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_BLUETOOTH_PROXY
     case 80: {
+#ifdef USE_BLUETOOTH_PROXY
       SubscribeBluetoothConnectionsFreeRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_subscribe_bluetooth_connections_free_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_bluetooth_connections_free_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_BLUETOOTH_PROXY
     case 87: {
+#ifdef USE_BLUETOOTH_PROXY
       UnsubscribeBluetoothLEAdvertisementsRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_unsubscribe_bluetooth_le_advertisements_request: %s", msg.dump().c_str());
 #endif
       this->on_unsubscribe_bluetooth_le_advertisements_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_VOICE_ASSISTANT
     case 89: {
+#ifdef USE_VOICE_ASSISTANT
       SubscribeVoiceAssistantRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_subscribe_voice_assistant_request: %s", msg.dump().c_str());
 #endif
       this->on_subscribe_voice_assistant_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_VOICE_ASSISTANT
     case 91: {
+#ifdef USE_VOICE_ASSISTANT
       VoiceAssistantResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_voice_assistant_response: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_response(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_VOICE_ASSISTANT
     case 92: {
+#ifdef USE_VOICE_ASSISTANT
       VoiceAssistantEventResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_voice_assistant_event_response: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_event_response(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_ALARM_CONTROL_PANEL
     case 96: {
+#ifdef USE_ALARM_CONTROL_PANEL
       AlarmControlPanelCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_alarm_control_panel_command_request: %s", msg.dump().c_str());
 #endif
       this->on_alarm_control_panel_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_TEXT
     case 99: {
+#ifdef USE_TEXT
       TextCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_text_command_request: %s", msg.dump().c_str());
 #endif
       this->on_text_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_DATETIME_DATE
     case 102: {
+#ifdef USE_DATETIME_DATE
       DateCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_date_command_request: %s", msg.dump().c_str());
 #endif
       this->on_date_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_DATETIME_TIME
     case 105: {
+#ifdef USE_DATETIME_TIME
       TimeCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_time_command_request: %s", msg.dump().c_str());
 #endif
       this->on_time_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_VOICE_ASSISTANT
     case 106: {
+#ifdef USE_VOICE_ASSISTANT
       VoiceAssistantAudio msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_voice_assistant_audio: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_audio(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_VALVE
     case 111: {
+#ifdef USE_VALVE
       ValveCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_valve_command_request: %s", msg.dump().c_str());
 #endif
       this->on_valve_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_DATETIME_DATETIME
     case 114: {
+#ifdef USE_DATETIME_DATETIME
       DateTimeCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_date_time_command_request: %s", msg.dump().c_str());
 #endif
       this->on_date_time_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_VOICE_ASSISTANT
     case 115: {
+#ifdef USE_VOICE_ASSISTANT
       VoiceAssistantTimerEventResponse msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_voice_assistant_timer_event_response: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_timer_event_response(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_UPDATE
     case 118: {
+#ifdef USE_UPDATE
       UpdateCommandRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_update_command_request: %s", msg.dump().c_str());
 #endif
       this->on_update_command_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_VOICE_ASSISTANT
     case 119: {
+#ifdef USE_VOICE_ASSISTANT
       VoiceAssistantAnnounceRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_voice_assistant_announce_request: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_announce_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_VOICE_ASSISTANT
     case 121: {
+#ifdef USE_VOICE_ASSISTANT
       VoiceAssistantConfigurationRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_voice_assistant_configuration_request: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_configuration_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_VOICE_ASSISTANT
     case 123: {
+#ifdef USE_VOICE_ASSISTANT
       VoiceAssistantSetConfiguration msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_voice_assistant_set_configuration: %s", msg.dump().c_str());
 #endif
       this->on_voice_assistant_set_configuration(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_API_NOISE
     case 124: {
+#ifdef USE_API_NOISE
       NoiseEncryptionSetKeyRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_noise_encryption_set_key_request: %s", msg.dump().c_str());
 #endif
       this->on_noise_encryption_set_key_request(msg);
+#endif
       break;
     }
-#endif
-#ifdef USE_BLUETOOTH_PROXY
     case 127: {
+#ifdef USE_BLUETOOTH_PROXY
       BluetoothScannerSetModeRequest msg;
       msg.decode(msg_data, msg_size);
 #ifdef HAS_PROTO_MESSAGE_DUMP
       ESP_LOGVV(TAG, "on_bluetooth_scanner_set_mode_request: %s", msg.dump().c_str());
 #endif
       this->on_bluetooth_scanner_set_mode_request(msg);
+#endif
       break;
     }
-#endif
     default:
-      break;
+      return false;
   }
+  return true;
 }
 
 void APIServerConnection::on_hello_request(const HelloRequest &msg) {

esphome/components/api/api_pb2_service.h

@@ -199,7 +199,7 @@ class APIServerConnectionBase : public ProtoService {
   virtual void on_update_command_request(const UpdateCommandRequest &value){};
 #endif
  protected:
-  void read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;
+  bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;
 };
 
 class APIServerConnection : public APIServerConnectionBase {

esphome/components/api/list_entities.cpp

@@ -1,7 +1,6 @@
 #include "list_entities.h"
 #ifdef USE_API
 #include "api_connection.h"
-#include "api_pb2.h"
 #include "esphome/core/application.h"
 #include "esphome/core/log.h"
 #include "esphome/core/util.h"
@@ -11,62 +10,62 @@ namespace api {
 
 #ifdef USE_BINARY_SENSOR
 bool ListEntitiesIterator::on_binary_sensor(binary_sensor::BinarySensor *binary_sensor) {
-  return this->client_->schedule_message_(binary_sensor, &APIConnection::try_send_binary_sensor_info,
-                                          ListEntitiesBinarySensorResponse::MESSAGE_TYPE);
+  this->client_->send_binary_sensor_info(binary_sensor);
+  return true;
 }
 #endif
 #ifdef USE_COVER
 bool ListEntitiesIterator::on_cover(cover::Cover *cover) {
-  return this->client_->schedule_message_(cover, &APIConnection::try_send_cover_info,
-                                          ListEntitiesCoverResponse::MESSAGE_TYPE);
+  this->client_->send_cover_info(cover);
+  return true;
 }
 #endif
 #ifdef USE_FAN
 bool ListEntitiesIterator::on_fan(fan::Fan *fan) {
-  return this->client_->schedule_message_(fan, &APIConnection::try_send_fan_info,
-                                          ListEntitiesFanResponse::MESSAGE_TYPE);
+  this->client_->send_fan_info(fan);
+  return true;
 }
 #endif
 #ifdef USE_LIGHT
 bool ListEntitiesIterator::on_light(light::LightState *light) {
-  return this->client_->schedule_message_(light, &APIConnection::try_send_light_info,
-                                          ListEntitiesLightResponse::MESSAGE_TYPE);
+  this->client_->send_light_info(light);
+  return true;
 }
 #endif
 #ifdef USE_SENSOR
 bool ListEntitiesIterator::on_sensor(sensor::Sensor *sensor) {
-  return this->client_->schedule_message_(sensor, &APIConnection::try_send_sensor_info,
-                                          ListEntitiesSensorResponse::MESSAGE_TYPE);
+  this->client_->send_sensor_info(sensor);
+  return true;
 }
 #endif
 #ifdef USE_SWITCH
 bool ListEntitiesIterator::on_switch(switch_::Switch *a_switch) {
-  return this->client_->schedule_message_(a_switch, &APIConnection::try_send_switch_info,
-                                          ListEntitiesSwitchResponse::MESSAGE_TYPE);
+  this->client_->send_switch_info(a_switch);
+  return true;
 }
 #endif
 #ifdef USE_BUTTON
 bool ListEntitiesIterator::on_button(button::Button *button) {
-  return this->client_->schedule_message_(button, &APIConnection::try_send_button_info,
-                                          ListEntitiesButtonResponse::MESSAGE_TYPE);
+  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_->schedule_message_(text_sensor, &APIConnection::try_send_text_sensor_info,
-                                          ListEntitiesTextSensorResponse::MESSAGE_TYPE);
+  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_->schedule_message_(a_lock, &APIConnection::try_send_lock_info,
-                                          ListEntitiesLockResponse::MESSAGE_TYPE);
+  this->client_->send_lock_info(a_lock);
+  return true;
 }
 #endif
 #ifdef USE_VALVE
 bool ListEntitiesIterator::on_valve(valve::Valve *valve) {
-  return this->client_->schedule_message_(valve, &APIConnection::try_send_valve_info,
-                                          ListEntitiesValveResponse::MESSAGE_TYPE);
+  this->client_->send_valve_info(valve);
+  return true;
 }
 #endif
 
@@ -79,82 +78,82 @@ bool ListEntitiesIterator::on_service(UserServiceDescriptor *service) {
 
 #ifdef USE_ESP32_CAMERA
 bool ListEntitiesIterator::on_camera(esp32_camera::ESP32Camera *camera) {
-  return this->client_->schedule_message_(camera, &APIConnection::try_send_camera_info,
-                                          ListEntitiesCameraResponse::MESSAGE_TYPE);
+  this->client_->send_camera_info(camera);
+  return true;
 }
 #endif
 
 #ifdef USE_CLIMATE
 bool ListEntitiesIterator::on_climate(climate::Climate *climate) {
-  return this->client_->schedule_message_(climate, &APIConnection::try_send_climate_info,
-                                          ListEntitiesClimateResponse::MESSAGE_TYPE);
+  this->client_->send_climate_info(climate);
+  return true;
 }
 #endif
 
 #ifdef USE_NUMBER
 bool ListEntitiesIterator::on_number(number::Number *number) {
-  return this->client_->schedule_message_(number, &APIConnection::try_send_number_info,
-                                          ListEntitiesNumberResponse::MESSAGE_TYPE);
+  this->client_->send_number_info(number);
+  return true;
 }
 #endif
 
 #ifdef USE_DATETIME_DATE
 bool ListEntitiesIterator::on_date(datetime::DateEntity *date) {
-  return this->client_->schedule_message_(date, &APIConnection::try_send_date_info,
-                                          ListEntitiesDateResponse::MESSAGE_TYPE);
+  this->client_->send_date_info(date);
+  return true;
 }
 #endif
 
 #ifdef USE_DATETIME_TIME
 bool ListEntitiesIterator::on_time(datetime::TimeEntity *time) {
-  return this->client_->schedule_message_(time, &APIConnection::try_send_time_info,
-                                          ListEntitiesTimeResponse::MESSAGE_TYPE);
+  this->client_->send_time_info(time);
+  return true;
 }
 #endif
 
 #ifdef USE_DATETIME_DATETIME
 bool ListEntitiesIterator::on_datetime(datetime::DateTimeEntity *datetime) {
-  return this->client_->schedule_message_(datetime, &APIConnection::try_send_datetime_info,
-                                          ListEntitiesDateTimeResponse::MESSAGE_TYPE);
+  this->client_->send_datetime_info(datetime);
+  return true;
 }
 #endif
 
 #ifdef USE_TEXT
 bool ListEntitiesIterator::on_text(text::Text *text) {
-  return this->client_->schedule_message_(text, &APIConnection::try_send_text_info,
-                                          ListEntitiesTextResponse::MESSAGE_TYPE);
+  this->client_->send_text_info(text);
+  return true;
 }
 #endif
 
 #ifdef USE_SELECT
 bool ListEntitiesIterator::on_select(select::Select *select) {
-  return this->client_->schedule_message_(select, &APIConnection::try_send_select_info,
-                                          ListEntitiesSelectResponse::MESSAGE_TYPE);
+  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_->schedule_message_(media_player, &APIConnection::try_send_media_player_info,
-                                          ListEntitiesMediaPlayerResponse::MESSAGE_TYPE);
+  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_->schedule_message_(a_alarm_control_panel, &APIConnection::try_send_alarm_control_panel_info,
-                                          ListEntitiesAlarmControlPanelResponse::MESSAGE_TYPE);
+  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_->schedule_message_(event, &APIConnection::try_send_event_info,
-                                          ListEntitiesEventResponse::MESSAGE_TYPE);
+  this->client_->send_event_info(event);
+  return true;
 }
 #endif
 #ifdef USE_UPDATE
 bool ListEntitiesIterator::on_update(update::UpdateEntity *update) {
-  return this->client_->schedule_message_(update, &APIConnection::try_send_update_info,
-                                          ListEntitiesUpdateResponse::MESSAGE_TYPE);
+  this->client_->send_update_info(update);
+  return true;
 }
 #endif
 

esphome/components/web_server/web_server.cpp

@@ -372,6 +372,12 @@ void WebServer::handle_js_request(AsyncWebServerRequest *request) {
   set_json_value(root, obj, sensor, value, start_config); \
   (root)["state"] = state;
 
+// Helper to get request detail parameter
+static JsonDetail get_request_detail_(AsyncWebServerRequest *request) {
+  auto *param = request->getParam("detail");
+  return (param && param->value() == "all") ? DETAIL_ALL : DETAIL_STATE;
+}
+
 #ifdef USE_SENSOR
 void WebServer::on_sensor_update(sensor::Sensor *obj, float state) {
   if (this->events_.empty())
@@ -383,11 +389,7 @@ void WebServer::handle_sensor_request(AsyncWebServerRequest *request, const UrlM
     if (obj->get_object_id() != match.id)
       continue;
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->sensor_json(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
@@ -432,11 +434,7 @@ void WebServer::handle_text_sensor_request(AsyncWebServerRequest *request, const
     if (obj->get_object_id() != match.id)
       continue;
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->text_sensor_json(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
@@ -475,11 +473,7 @@ void WebServer::handle_switch_request(AsyncWebServerRequest *request, const UrlM
       continue;
 
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->switch_json(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method == "toggle") {
@@ -521,11 +515,7 @@ void WebServer::handle_button_request(AsyncWebServerRequest *request, const UrlM
     if (obj->get_object_id() != match.id)
       continue;
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->button_json(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method == "press") {
@@ -566,11 +556,7 @@ void WebServer::handle_binary_sensor_request(AsyncWebServerRequest *request, con
     if (obj->get_object_id() != match.id)
       continue;
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->binary_sensor_json(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
@@ -609,11 +595,7 @@ void WebServer::handle_fan_request(AsyncWebServerRequest *request, const UrlMatc
       continue;
 
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->fan_json(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method == "toggle") {
@@ -694,11 +676,7 @@ void WebServer::handle_light_request(AsyncWebServerRequest *request, const UrlMa
       continue;
 
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->light_json(obj, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method == "toggle") {
@@ -814,11 +792,7 @@ void WebServer::handle_cover_request(AsyncWebServerRequest *request, const UrlMa
       continue;
 
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->cover_json(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
@@ -899,11 +873,7 @@ void WebServer::handle_number_request(AsyncWebServerRequest *request, const UrlM
       continue;
 
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->number_json(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
@@ -973,11 +943,7 @@ void WebServer::handle_date_request(AsyncWebServerRequest *request, const UrlMat
     if (obj->get_object_id() != match.id)
       continue;
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->date_json(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
@@ -1036,11 +1002,7 @@ void WebServer::handle_time_request(AsyncWebServerRequest *request, const UrlMat
     if (obj->get_object_id() != match.id)
       continue;
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->time_json(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
@@ -1098,11 +1060,7 @@ void WebServer::handle_datetime_request(AsyncWebServerRequest *request, const Ur
     if (obj->get_object_id() != match.id)
       continue;
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->datetime_json(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
@@ -1162,11 +1120,7 @@ void WebServer::handle_text_request(AsyncWebServerRequest *request, const UrlMat
       continue;
 
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->text_json(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
@@ -1227,11 +1181,7 @@ void WebServer::handle_select_request(AsyncWebServerRequest *request, const UrlM
       continue;
 
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->select_json(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
       return;
@@ -1290,11 +1240,7 @@ void WebServer::handle_climate_request(AsyncWebServerRequest *request, const Url
       continue;
 
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->climate_json(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
@@ -1453,11 +1399,7 @@ void WebServer::handle_lock_request(AsyncWebServerRequest *request, const UrlMat
       continue;
 
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->lock_json(obj, obj->state, detail);
       request->send(200, "application/json", data.c_str());
     } else if (match.method == "lock") {
@@ -1505,11 +1447,7 @@ void WebServer::handle_valve_request(AsyncWebServerRequest *request, const UrlMa
       continue;
 
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->valve_json(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;
@@ -1581,11 +1519,7 @@ void WebServer::handle_alarm_control_panel_request(AsyncWebServerRequest *reques
       continue;
 
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->alarm_control_panel_json(obj, obj->get_state(), detail);
       request->send(200, "application/json", data.c_str());
       return;
@@ -1652,11 +1586,7 @@ void WebServer::handle_event_request(AsyncWebServerRequest *request, const UrlMa
       continue;
 
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->event_json(obj, "", detail);
       request->send(200, "application/json", data.c_str());
       return;
@@ -1702,11 +1632,7 @@ void WebServer::handle_update_request(AsyncWebServerRequest *request, const UrlM
       continue;
 
     if (request->method() == HTTP_GET && match.method.empty()) {
-      auto detail = DETAIL_STATE;
-      auto *param = request->getParam("detail");
-      if (param && param->value() == "all") {
-        detail = DETAIL_ALL;
-      }
+      auto detail = get_request_detail_(request);
       std::string data = this->update_json(obj, detail);
       request->send(200, "application/json", data.c_str());
       return;

script/api_protobuf/api_protobuf.py

@@ -1034,7 +1034,7 @@ SOURCE_BOTH = 0
 SOURCE_SERVER = 1
 SOURCE_CLIENT = 2
 
-RECEIVE_CASES: dict[int, tuple[str, str | None]] = {}
+RECEIVE_CASES: dict[int, str] = {}
 
 ifdefs: dict[str, str] = {}
 
@@ -1208,6 +1208,8 @@ def build_service_message_type(
         func = f"on_{snake}"
         hout += f"virtual void {func}(const {mt.name} &value){{}};\n"
         case = ""
+        if ifdef is not None:
+            case += f"#ifdef {ifdef}\n"
         case += f"{mt.name} msg;\n"
         case += "msg.decode(msg_data, msg_size);\n"
         if log:
@@ -1215,9 +1217,10 @@ def build_service_message_type(
             case += f'ESP_LOGVV(TAG, "{func}: %s", msg.dump().c_str());\n'
             case += "#endif\n"
         case += f"this->{func}(msg);\n"
+        if ifdef is not None:
+            case += "#endif\n"
         case += "break;"
-        # Store the ifdef with the case for later use
-        RECEIVE_CASES[id_] = (case, ifdef)
+        RECEIVE_CASES[id_] = case
 
         # Only close ifdef if we opened it
         if ifdef is not None:
@@ -1376,21 +1379,18 @@ def main() -> None:
     cases = list(RECEIVE_CASES.items())
     cases.sort()
     hpp += " protected:\n"
-    hpp += "  void read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;\n"
-    out = f"void {class_name}::read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) {{\n"
+    hpp += "  bool read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) override;\n"
+    out = f"bool {class_name}::read_message(uint32_t msg_size, uint32_t msg_type, uint8_t *msg_data) {{\n"
     out += "  switch (msg_type) {\n"
-    for i, (case, ifdef) in cases:
-        if ifdef is not None:
-            out += f"#ifdef {ifdef}\n"
-        c = f"    case {i}: {{\n"
-        c += indent(case, "      ") + "\n"
-        c += "    }"
-        out += c + "\n"
-        if ifdef is not None:
-            out += "#endif\n"
+    for i, case in cases:
+        c = f"case {i}: {{\n"
+        c += indent(case) + "\n"
+        c += "}"
+        out += indent(c, "    ") + "\n"
     out += "    default:\n"
-    out += "      break;\n"
+    out += "      return false;\n"
     out += "  }\n"
+    out += "  return true;\n"
     out += "}\n"
     cpp += out
     hpp += "};\n"