Florian/esphome
1
0
Fork 0
Code Issues Pull Requests Actions 4 Packages Projects Releases Wiki Activity

lint

Browse Source
This commit is contained in:
J. Nick Koston
2025-06-06 10:40:33 +01:00
parent b4198e6592
commit 684c5a42fb
2 changed files with 187 additions and 189 deletions
Download Patch File Download Diff File Expand all files Collapse all files

248
esphome/components/api/api_connection.cpp
View File

@@ -284,30 +284,30 @@ bool APIConnection::send_binary_sensor_state(binary_sensor::BinarySensor *binary
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_,
this->schedule_message_(binary_sensor, &APIConnection::try_send_binary_sensor_info,
ListEntitiesBinarySensorResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_binary_sensor_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_binary_sensor_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *binary_sensor = static_cast<binary_sensor::BinarySensor *>(entity);
ListEntitiesBinarySensorResponse msg;
msg.device_class = binary_sensor->get_device_class();
msg.is_status_binary_sensor = binary_sensor->is_status_binary_sensor();
msg.unique_id = get_default_unique_id("binary_sensor", binary_sensor);
fill_entity_info_base_(binary_sensor, msg);
fill_entity_info_base(binary_sensor, msg);
return encode_message_to_buffer(msg, ListEntitiesBinarySensorResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
#endif
#ifdef USE_COVER
bool APIConnection::send_cover_state(cover::Cover *cover) {
return this->schedule_message_(cover, &APIConnection::try_send_cover_state_, CoverStateResponse::MESSAGE_TYPE);
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);
this->schedule_message_(cover, &APIConnection::try_send_cover_info, ListEntitiesCoverResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_cover_state_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_cover_state(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *cover = static_cast<cover::Cover *>(entity);
CoverStateResponse msg;
auto traits = cover->get_traits();
@@ -320,8 +320,8 @@ APIConnection::EncodedMessage APIConnection::try_send_cover_state_(EntityBase *e
msg.key = cover->get_object_id_hash();
return encode_message_to_buffer(msg, CoverStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
APIConnection::EncodedMessage APIConnection::try_send_cover_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_cover_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *cover = static_cast<cover::Cover *>(entity);
ListEntitiesCoverResponse msg;
auto traits = cover->get_traits();
@@ -331,7 +331,7 @@ APIConnection::EncodedMessage APIConnection::try_send_cover_info_(EntityBase *en
msg.supports_stop = traits.get_supports_stop();
msg.device_class = cover->get_device_class();
msg.unique_id = get_default_unique_id("cover", cover);
fill_entity_info_base_(cover, msg);
fill_entity_info_base(cover, msg);
return encode_message_to_buffer(msg, ListEntitiesCoverResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::cover_command(const CoverCommandRequest &msg) {
@@ -365,13 +365,13 @@ void APIConnection::cover_command(const CoverCommandRequest &msg) {
#ifdef USE_FAN
bool APIConnection::send_fan_state(fan::Fan *fan) {
return this->schedule_message_(fan, &APIConnection::try_send_fan_state_, FanStateResponse::MESSAGE_TYPE);
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);
this->schedule_message_(fan, &APIConnection::try_send_fan_info, ListEntitiesFanResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_fan_state_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_fan_state(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *fan = static_cast<fan::Fan *>(entity);
FanStateResponse msg;
auto traits = fan->get_traits();
@@ -388,8 +388,8 @@ APIConnection::EncodedMessage APIConnection::try_send_fan_state_(EntityBase *ent
msg.key = fan->get_object_id_hash();
return encode_message_to_buffer(msg, FanStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
APIConnection::EncodedMessage APIConnection::try_send_fan_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_fan_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *fan = static_cast<fan::Fan *>(entity);
ListEntitiesFanResponse msg;
auto traits = fan->get_traits();
@@ -400,7 +400,7 @@ APIConnection::EncodedMessage APIConnection::try_send_fan_info_(EntityBase *enti
for (auto const &preset : traits.supported_preset_modes())
msg.supported_preset_modes.push_back(preset);
msg.unique_id = get_default_unique_id("fan", fan);
fill_entity_info_base_(fan, msg);
fill_entity_info_base(fan, msg);
return encode_message_to_buffer(msg, ListEntitiesFanResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::fan_command(const FanCommandRequest &msg) {
@@ -427,13 +427,13 @@ void APIConnection::fan_command(const FanCommandRequest &msg) {
#ifdef USE_LIGHT
bool APIConnection::send_light_state(light::LightState *light) {
return this->schedule_message_(light, &APIConnection::try_send_light_state_, LightStateResponse::MESSAGE_TYPE);
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);
this->schedule_message_(light, &APIConnection::try_send_light_info, ListEntitiesLightResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_light_state_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_light_state(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *light = static_cast<light::LightState *>(entity);
LightStateResponse resp;
auto traits = light->get_traits();
@@ -455,8 +455,8 @@ APIConnection::EncodedMessage APIConnection::try_send_light_state_(EntityBase *e
resp.key = light->get_object_id_hash();
return encode_message_to_buffer(resp, LightStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
APIConnection::EncodedMessage APIConnection::try_send_light_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_light_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *light = static_cast<light::LightState *>(entity);
ListEntitiesLightResponse msg;
auto traits = light->get_traits();
@@ -480,7 +480,7 @@ APIConnection::EncodedMessage APIConnection::try_send_light_info_(EntityBase *en
}
}
msg.unique_id = get_default_unique_id("light", light);
fill_entity_info_base_(light, msg);
fill_entity_info_base(light, msg);
return encode_message_to_buffer(msg, ListEntitiesLightResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::light_command(const LightCommandRequest &msg) {
@@ -536,10 +536,10 @@ bool APIConnection::send_sensor_state(sensor::Sensor *sensor, float state) {
SensorStateResponse::MESSAGE_TYPE);
}
void APIConnection::send_sensor_info(sensor::Sensor *sensor) {
this->schedule_message_(sensor, &APIConnection::try_send_sensor_info_, ListEntitiesSensorResponse::MESSAGE_TYPE);
this->schedule_message_(sensor, &APIConnection::try_send_sensor_info, ListEntitiesSensorResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_sensor_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_sensor_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *sensor = static_cast<sensor::Sensor *>(entity);
ListEntitiesSensorResponse msg;
msg.unit_of_measurement = sensor->get_unit_of_measurement();
@@ -550,7 +550,7 @@ APIConnection::EncodedMessage APIConnection::try_send_sensor_info_(EntityBase *e
msg.unique_id = sensor->unique_id();
if (msg.unique_id.empty())
msg.unique_id = get_default_unique_id("sensor", sensor);
fill_entity_info_base_(sensor, msg);
fill_entity_info_base(sensor, msg);
return encode_message_to_buffer(msg, ListEntitiesSensorResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
#endif
@@ -570,16 +570,16 @@ bool APIConnection::send_switch_state(switch_::Switch *a_switch, bool 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);
this->schedule_message_(a_switch, &APIConnection::try_send_switch_info, ListEntitiesSwitchResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_switch_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_switch_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *a_switch = static_cast<switch_::Switch *>(entity);
ListEntitiesSwitchResponse msg;
msg.assumed_state = a_switch->assumed_state();
msg.device_class = a_switch->get_device_class();
msg.unique_id = get_default_unique_id("switch", a_switch);
fill_entity_info_base_(a_switch, msg);
fill_entity_info_base(a_switch, msg);
return encode_message_to_buffer(msg, ListEntitiesSwitchResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::switch_command(const SwitchCommandRequest &msg) {
@@ -611,28 +611,28 @@ bool APIConnection::send_text_sensor_state(text_sensor::TextSensor *text_sensor,
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_,
this->schedule_message_(text_sensor, &APIConnection::try_send_text_sensor_info,
ListEntitiesTextSensorResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_text_sensor_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_text_sensor_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *text_sensor = static_cast<text_sensor::TextSensor *>(entity);
ListEntitiesTextSensorResponse msg;
msg.device_class = text_sensor->get_device_class();
msg.unique_id = text_sensor->unique_id();
if (msg.unique_id.empty())
msg.unique_id = get_default_unique_id("text_sensor", text_sensor);
fill_entity_info_base_(text_sensor, msg);
fill_entity_info_base(text_sensor, msg);
return encode_message_to_buffer(msg, ListEntitiesTextSensorResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
#endif
#ifdef USE_CLIMATE
bool APIConnection::send_climate_state(climate::Climate *climate) {
return this->schedule_message_(climate, &APIConnection::try_send_climate_state_, ClimateStateResponse::MESSAGE_TYPE);
return this->schedule_message_(climate, &APIConnection::try_send_climate_state, ClimateStateResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_climate_state_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_climate_state(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *climate = static_cast<climate::Climate *>(entity);
ClimateStateResponse resp;
resp.key = climate->get_object_id_hash();
@@ -665,10 +665,10 @@ APIConnection::EncodedMessage APIConnection::try_send_climate_state_(EntityBase
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);
this->schedule_message_(climate, &APIConnection::try_send_climate_info, ListEntitiesClimateResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_climate_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_climate_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *climate = static_cast<climate::Climate *>(entity);
ListEntitiesClimateResponse msg;
auto traits = climate->get_traits();
@@ -697,7 +697,7 @@ APIConnection::EncodedMessage APIConnection::try_send_climate_info_(EntityBase *
for (auto swing_mode : traits.get_supported_swing_modes())
msg.supported_swing_modes.push_back(static_cast<enums::ClimateSwingMode>(swing_mode));
msg.unique_id = get_default_unique_id("climate", climate);
fill_entity_info_base_(climate, msg);
fill_entity_info_base(climate, msg);
return encode_message_to_buffer(msg, ListEntitiesClimateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::climate_command(const ClimateCommandRequest &msg) {
@@ -746,10 +746,10 @@ bool APIConnection::send_number_state(number::Number *number, float state) {
NumberStateResponse::MESSAGE_TYPE);
}
void APIConnection::send_number_info(number::Number *number) {
this->schedule_message_(number, &APIConnection::try_send_number_info_, ListEntitiesNumberResponse::MESSAGE_TYPE);
this->schedule_message_(number, &APIConnection::try_send_number_info, ListEntitiesNumberResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_number_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_number_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *number = static_cast<number::Number *>(entity);
ListEntitiesNumberResponse msg;
msg.unit_of_measurement = number->traits.get_unit_of_measurement();
@@ -759,7 +759,7 @@ APIConnection::EncodedMessage APIConnection::try_send_number_info_(EntityBase *e
msg.max_value = number->traits.get_max_value();
msg.step = number->traits.get_step();
msg.unique_id = get_default_unique_id("number", number);
fill_entity_info_base_(number, msg);
fill_entity_info_base(number, msg);
return encode_message_to_buffer(msg, ListEntitiesNumberResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::number_command(const NumberCommandRequest &msg) {
@@ -775,10 +775,10 @@ void APIConnection::number_command(const NumberCommandRequest &msg) {
#ifdef USE_DATETIME_DATE
bool APIConnection::send_date_state(datetime::DateEntity *date) {
return this->schedule_message_(date, &APIConnection::try_send_date_state_, DateStateResponse::MESSAGE_TYPE);
return this->schedule_message_(date, &APIConnection::try_send_date_state, DateStateResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_date_state_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_date_state(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *date = static_cast<datetime::DateEntity *>(entity);
DateStateResponse resp;
resp.missing_state = !date->has_state();
@@ -789,14 +789,14 @@ APIConnection::EncodedMessage APIConnection::try_send_date_state_(EntityBase *en
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);
this->schedule_message_(date, &APIConnection::try_send_date_info, ListEntitiesDateResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_date_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_date_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *date = static_cast<datetime::DateEntity *>(entity);
ListEntitiesDateResponse msg;
msg.unique_id = get_default_unique_id("date", date);
fill_entity_info_base_(date, msg);
fill_entity_info_base(date, msg);
return encode_message_to_buffer(msg, ListEntitiesDateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::date_command(const DateCommandRequest &msg) {
@@ -812,10 +812,10 @@ void APIConnection::date_command(const DateCommandRequest &msg) {
#ifdef USE_DATETIME_TIME
bool APIConnection::send_time_state(datetime::TimeEntity *time) {
return this->schedule_message_(time, &APIConnection::try_send_time_state_, TimeStateResponse::MESSAGE_TYPE);
return this->schedule_message_(time, &APIConnection::try_send_time_state, TimeStateResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_time_state_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_time_state(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *time = static_cast<datetime::TimeEntity *>(entity);
TimeStateResponse resp;
resp.missing_state = !time->has_state();
@@ -826,14 +826,14 @@ APIConnection::EncodedMessage APIConnection::try_send_time_state_(EntityBase *en
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);
this->schedule_message_(time, &APIConnection::try_send_time_info, ListEntitiesTimeResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_time_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_time_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *time = static_cast<datetime::TimeEntity *>(entity);
ListEntitiesTimeResponse msg;
msg.unique_id = get_default_unique_id("time", time);
fill_entity_info_base_(time, msg);
fill_entity_info_base(time, msg);
return encode_message_to_buffer(msg, ListEntitiesTimeResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::time_command(const TimeCommandRequest &msg) {
@@ -849,11 +849,11 @@ void APIConnection::time_command(const TimeCommandRequest &msg) {
#ifdef USE_DATETIME_DATETIME
bool APIConnection::send_datetime_state(datetime::DateTimeEntity *datetime) {
return this->schedule_message_(datetime, &APIConnection::try_send_datetime_state_,
return this->schedule_message_(datetime, &APIConnection::try_send_datetime_state,
DateTimeStateResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_datetime_state_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_datetime_state(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *datetime = static_cast<datetime::DateTimeEntity *>(entity);
DateTimeStateResponse resp;
resp.missing_state = !datetime->has_state();
@@ -865,15 +865,14 @@ APIConnection::EncodedMessage APIConnection::try_send_datetime_state_(EntityBase
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);
this->schedule_message_(datetime, &APIConnection::try_send_datetime_info, ListEntitiesDateTimeResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_datetime_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_datetime_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *datetime = static_cast<datetime::DateTimeEntity *>(entity);
ListEntitiesDateTimeResponse msg;
msg.unique_id = get_default_unique_id("datetime", datetime);
fill_entity_info_base_(datetime, msg);
fill_entity_info_base(datetime, msg);
return encode_message_to_buffer(msg, ListEntitiesDateTimeResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::datetime_command(const DateTimeCommandRequest &msg) {
@@ -903,10 +902,10 @@ bool APIConnection::send_text_state(text::Text *text, std::string state) {
TextStateResponse::MESSAGE_TYPE);
}
void APIConnection::send_text_info(text::Text *text) {
this->schedule_message_(text, &APIConnection::try_send_text_info_, ListEntitiesTextResponse::MESSAGE_TYPE);
this->schedule_message_(text, &APIConnection::try_send_text_info, ListEntitiesTextResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_text_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_text_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *text = static_cast<text::Text *>(entity);
ListEntitiesTextResponse msg;
msg.mode = static_cast<enums::TextMode>(text->traits.get_mode());
@@ -914,7 +913,7 @@ APIConnection::EncodedMessage APIConnection::try_send_text_info_(EntityBase *ent
msg.max_length = text->traits.get_max_length();
msg.pattern = text->traits.get_pattern();
msg.unique_id = get_default_unique_id("text", text);
fill_entity_info_base_(text, msg);
fill_entity_info_base(text, msg);
return encode_message_to_buffer(msg, ListEntitiesTextResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::text_command(const TextCommandRequest &msg) {
@@ -944,16 +943,16 @@ bool APIConnection::send_select_state(select::Select *select, std::string state)
SelectStateResponse::MESSAGE_TYPE);
}
void APIConnection::send_select_info(select::Select *select) {
this->schedule_message_(select, &APIConnection::try_send_select_info_, ListEntitiesSelectResponse::MESSAGE_TYPE);
this->schedule_message_(select, &APIConnection::try_send_select_info, ListEntitiesSelectResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_select_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_select_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *select = static_cast<select::Select *>(entity);
ListEntitiesSelectResponse msg;
for (const auto &option : select->traits.get_options())
msg.options.push_back(option);
msg.unique_id = get_default_unique_id("select", select);
fill_entity_info_base_(select, msg);
fill_entity_info_base(select, msg);
return encode_message_to_buffer(msg, ListEntitiesSelectResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::select_command(const SelectCommandRequest &msg) {
@@ -969,15 +968,15 @@ void APIConnection::select_command(const SelectCommandRequest &msg) {
#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);
this->schedule_message_(button, &APIConnection::try_send_button_info, ListEntitiesButtonResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_button_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_button_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *button = static_cast<button::Button *>(entity);
ListEntitiesButtonResponse msg;
msg.device_class = button->get_device_class();
msg.unique_id = get_default_unique_id("button", button);
fill_entity_info_base_(button, msg);
fill_entity_info_base(button, msg);
return encode_message_to_buffer(msg, ListEntitiesButtonResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void esphome::api::APIConnection::button_command(const ButtonCommandRequest &msg) {
@@ -1004,17 +1003,17 @@ bool APIConnection::send_lock_state(lock::Lock *a_lock, lock::LockState 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);
this->schedule_message_(a_lock, &APIConnection::try_send_lock_info, ListEntitiesLockResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_lock_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_lock_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *a_lock = static_cast<lock::Lock *>(entity);
ListEntitiesLockResponse msg;
msg.assumed_state = a_lock->traits.get_assumed_state();
msg.supports_open = a_lock->traits.get_supports_open();
msg.requires_code = a_lock->traits.get_requires_code();
msg.unique_id = get_default_unique_id("lock", a_lock);
fill_entity_info_base_(a_lock, msg);
fill_entity_info_base(a_lock, msg);
return encode_message_to_buffer(msg, ListEntitiesLockResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::lock_command(const LockCommandRequest &msg) {
@@ -1038,10 +1037,10 @@ void APIConnection::lock_command(const LockCommandRequest &msg) {
#ifdef USE_VALVE
bool APIConnection::send_valve_state(valve::Valve *valve) {
return this->schedule_message_(valve, &APIConnection::try_send_valve_state_, ValveStateResponse::MESSAGE_TYPE);
return this->schedule_message_(valve, &APIConnection::try_send_valve_state, ValveStateResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_valve_state_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_valve_state(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *valve = static_cast<valve::Valve *>(entity);
ValveStateResponse resp;
resp.position = valve->position;
@@ -1050,10 +1049,10 @@ APIConnection::EncodedMessage APIConnection::try_send_valve_state_(EntityBase *e
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);
this->schedule_message_(valve, &APIConnection::try_send_valve_info, ListEntitiesValveResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_valve_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_valve_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *valve = static_cast<valve::Valve *>(entity);
ListEntitiesValveResponse msg;
auto traits = valve->get_traits();
@@ -1062,7 +1061,7 @@ APIConnection::EncodedMessage APIConnection::try_send_valve_info_(EntityBase *en
msg.supports_position = traits.get_supports_position();
msg.supports_stop = traits.get_supports_stop();
msg.unique_id = get_default_unique_id("valve", valve);
fill_entity_info_base_(valve, msg);
fill_entity_info_base(valve, msg);
return encode_message_to_buffer(msg, ListEntitiesValveResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::valve_command(const ValveCommandRequest &msg) {
@@ -1081,11 +1080,11 @@ void APIConnection::valve_command(const ValveCommandRequest &msg) {
#ifdef USE_MEDIA_PLAYER
bool APIConnection::send_media_player_state(media_player::MediaPlayer *media_player) {
return this->schedule_message_(media_player, &APIConnection::try_send_media_player_state_,
return this->schedule_message_(media_player, &APIConnection::try_send_media_player_state,
MediaPlayerStateResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_media_player_state_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_media_player_state(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *media_player = static_cast<media_player::MediaPlayer *>(entity);
MediaPlayerStateResponse resp;
media_player::MediaPlayerState report_state = media_player->state == media_player::MEDIA_PLAYER_STATE_ANNOUNCING
@@ -1098,11 +1097,11 @@ APIConnection::EncodedMessage APIConnection::try_send_media_player_state_(Entity
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_,
this->schedule_message_(media_player, &APIConnection::try_send_media_player_info,
ListEntitiesMediaPlayerResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_media_player_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage 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);
ListEntitiesMediaPlayerResponse msg;
auto traits = media_player->get_traits();
@@ -1117,7 +1116,7 @@ APIConnection::EncodedMessage APIConnection::try_send_media_player_info_(EntityB
msg.supported_formats.push_back(media_format);
}
msg.unique_id = get_default_unique_id("media_player", media_player);
fill_entity_info_base_(media_player, msg);
fill_entity_info_base(media_player, msg);
return encode_message_to_buffer(msg, ListEntitiesMediaPlayerResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::media_player_command(const MediaPlayerCommandRequest &msg) {
@@ -1153,14 +1152,14 @@ void APIConnection::set_camera_state(std::shared_ptr<esp32_camera::CameraImage>
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);
this->schedule_message_(camera, &APIConnection::try_send_camera_info, ListEntitiesCameraResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_camera_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_camera_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *camera = static_cast<esp32_camera::ESP32Camera *>(entity);
ListEntitiesCameraResponse msg;
msg.unique_id = get_default_unique_id("camera", camera);
fill_entity_info_base_(camera, msg);
fill_entity_info_base(camera, msg);
return encode_message_to_buffer(msg, ListEntitiesCameraResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::camera_image(const CameraImageRequest &msg) {
@@ -1350,13 +1349,12 @@ void APIConnection::voice_assistant_set_configuration(const VoiceAssistantSetCon
#ifdef USE_ALARM_CONTROL_PANEL
bool APIConnection::send_alarm_control_panel_state(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel) {
return this->schedule_message_(a_alarm_control_panel, &APIConnection::try_send_alarm_control_panel_state_,
return this->schedule_message_(a_alarm_control_panel, &APIConnection::try_send_alarm_control_panel_state,
AlarmControlPanelStateResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_alarm_control_panel_state_(EntityBase *entity,
APIConnection *conn,
uint32_t remaining_size,
bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_alarm_control_panel_state(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size,
bool is_single) {
auto *a_alarm_control_panel = static_cast<alarm_control_panel::AlarmControlPanel *>(entity);
AlarmControlPanelStateResponse resp;
resp.state = static_cast<enums::AlarmControlPanelState>(a_alarm_control_panel->get_state());
@@ -1364,19 +1362,19 @@ APIConnection::EncodedMessage APIConnection::try_send_alarm_control_panel_state_
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_,
this->schedule_message_(a_alarm_control_panel, &APIConnection::try_send_alarm_control_panel_info,
ListEntitiesAlarmControlPanelResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_alarm_control_panel_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size,
bool is_single) {
APIConnection::EncodedMessage 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);
ListEntitiesAlarmControlPanelResponse msg;
msg.supported_features = a_alarm_control_panel->get_supported_features();
msg.requires_code = a_alarm_control_panel->get_requires_code();
msg.requires_code_to_arm = a_alarm_control_panel->get_requires_code_to_arm();
msg.unique_id = get_default_unique_id("alarm_control_panel", a_alarm_control_panel);
fill_entity_info_base_(a_alarm_control_panel, msg);
fill_entity_info_base(a_alarm_control_panel, msg);
return encode_message_to_buffer(msg, ListEntitiesAlarmControlPanelResponse::MESSAGE_TYPE, conn, remaining_size,
is_single);
}
@@ -1429,27 +1427,27 @@ void APIConnection::send_event(event::Event *event, std::string 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);
this->schedule_message_(event, &APIConnection::try_send_event_info, ListEntitiesEventResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_event_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_event_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *event = static_cast<event::Event *>(entity);
ListEntitiesEventResponse msg;
msg.device_class = event->get_device_class();
for (const auto &event_type : event->get_event_types())
msg.event_types.push_back(event_type);
msg.unique_id = get_default_unique_id("event", event);
fill_entity_info_base_(event, msg);
fill_entity_info_base(event, msg);
return encode_message_to_buffer(msg, ListEntitiesEventResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
#endif
#ifdef USE_UPDATE
bool APIConnection::send_update_state(update::UpdateEntity *update) {
return this->schedule_message_(update, &APIConnection::try_send_update_state_, UpdateStateResponse::MESSAGE_TYPE);
return this->schedule_message_(update, &APIConnection::try_send_update_state, UpdateStateResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_update_state_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_update_state(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *update = static_cast<update::UpdateEntity *>(entity);
UpdateStateResponse resp;
resp.missing_state = !update->has_state();
@@ -1469,15 +1467,15 @@ APIConnection::EncodedMessage APIConnection::try_send_update_state_(EntityBase *
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);
this->schedule_message_(update, &APIConnection::try_send_update_info, ListEntitiesUpdateResponse::MESSAGE_TYPE);
}
APIConnection::EncodedMessage APIConnection::try_send_update_info_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
APIConnection::EncodedMessage APIConnection::try_send_update_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single) {
auto *update = static_cast<update::UpdateEntity *>(entity);
ListEntitiesUpdateResponse msg;
msg.device_class = update->get_device_class();
msg.unique_id = get_default_unique_id("update", update);
fill_entity_info_base_(update, msg);
fill_entity_info_base(update, msg);
return encode_message_to_buffer(msg, ListEntitiesUpdateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
}
void APIConnection::update_command(const UpdateCommandRequest &msg) {

128
esphome/components/api/api_connection.h
View File

@@ -294,7 +294,7 @@ class APIConnection : public APIServerConnection {
protected:
// Helper function to fill common entity fields
template<typename ResponseT> static void fill_entity_info_base_(esphome::EntityBase *entity, ResponseT &response) {
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();
@@ -313,130 +313,130 @@ class APIConnection : public APIServerConnection {
uint32_t remaining_size, bool is_single);
#ifdef USE_BINARY_SENSOR
static EncodedMessage try_send_binary_sensor_state_(EntityBase *binary_sensor, APIConnection *conn,
uint32_t remaining_size, bool is_single);
static EncodedMessage try_send_binary_sensor_info_(EntityBase *binary_sensor, APIConnection *conn,
static EncodedMessage try_send_binary_sensor_state(EntityBase *binary_sensor, APIConnection *conn,
uint32_t remaining_size, bool is_single);
static EncodedMessage try_send_binary_sensor_info(EntityBase *binary_sensor, APIConnection *conn,
uint32_t remaining_size, bool is_single);
#endif
#ifdef USE_COVER
static EncodedMessage try_send_cover_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_cover_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_cover_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_cover_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_FAN
static EncodedMessage try_send_fan_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_fan_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_fan_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_fan_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_LIGHT
static EncodedMessage try_send_light_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_light_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_light_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_light_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_SENSOR
static EncodedMessage try_send_sensor_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_sensor_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_SWITCH
static EncodedMessage try_send_switch_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_switch_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_switch_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_switch_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_TEXT_SENSOR
static EncodedMessage try_send_text_sensor_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_text_sensor_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_text_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_text_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_CLIMATE
static EncodedMessage try_send_climate_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_climate_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_climate_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_climate_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_NUMBER
static EncodedMessage try_send_number_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_number_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_number_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_number_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_DATETIME_DATE
static EncodedMessage try_send_date_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_date_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_date_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_date_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_DATETIME_TIME
static EncodedMessage try_send_time_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_time_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_time_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_time_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_DATETIME_DATETIME
static EncodedMessage try_send_datetime_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_datetime_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_datetime_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_datetime_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_TEXT
static EncodedMessage try_send_text_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_text_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_text_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_text_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_SELECT
static EncodedMessage try_send_select_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_select_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_select_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_select_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_BUTTON
static EncodedMessage try_send_button_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_button_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_LOCK
static EncodedMessage try_send_lock_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_lock_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_lock_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_lock_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_VALVE
static EncodedMessage try_send_valve_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_valve_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_valve_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_valve_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_MEDIA_PLAYER
static EncodedMessage try_send_media_player_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_media_player_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_media_player_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_media_player_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_ALARM_CONTROL_PANEL
static EncodedMessage try_send_alarm_control_panel_state_(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single);
static EncodedMessage try_send_alarm_control_panel_info_(EntityBase *entity, APIConnection *conn,
static EncodedMessage try_send_alarm_control_panel_state(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single);
static EncodedMessage try_send_alarm_control_panel_info(EntityBase *entity, APIConnection *conn,
uint32_t remaining_size, bool is_single);
#endif
#ifdef USE_EVENT
static EncodedMessage try_send_event_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_event_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_UPDATE
static EncodedMessage try_send_update_state_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_update_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
static EncodedMessage try_send_update_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_update_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
#ifdef USE_ESP32_CAMERA
static EncodedMessage try_send_camera_info_(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
static EncodedMessage try_send_camera_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
bool is_single);
#endif
enum class ConnectionState {