homeassistant_select.cpp

Go to the documentation of this file.

#include "homeassistant_select.h"
 
#include <cstring>
 
#include "../homeassistant.h"
 
#include "esphome/components/api/api_pb2.h"
#include "esphome/components/api/api_server.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
#include "esphome/core/progmem.h"
#include "esphome/core/string_ref.h"
 
namespace esphome::homeassistant {
 
ESPHOME_LOG_TAG(TAG, "homeassistant.select");
 
void HomeassistantSelect::setup() {
  this->options_buffer_ = std::make_unique<char[]>(this->options_buffer_size_);
  this->option_list_ = std::make_unique<const char *[]>(this->max_options_);
 
  // Subscribe to the options first: Home Assistant answers subscriptions in order, so the options are
  // known by the time the first state arrives.
  api::global_api_server->subscribe_home_assistant_state(
      this->entity_id_, "options", [this](StringRef options) { this->options_changed_(options); });
  api::global_api_server->subscribe_home_assistant_state(this->entity_id_, nullptr,
                                                         [this](StringRef state) { this->state_changed_(state); });
}
 
void HomeassistantSelect::options_changed_(StringRef options) {
  // First pass: validate and measure the new options, and look for the active option among them, before
  // anything is overwritten. A list that does not fit leaves the current options in place.
  const char *active = this->has_state() ? this->option_at(this->active_index_) : nullptr;
  size_t count = 0;
  size_t bytes = 0;
  size_t match_len = 0;
  bool matching = active != nullptr;
  optional<size_t> new_active;
  bool valid = parse_python_list(
      options,
      [&](char c) {
        bytes++;
        if (matching && active[match_len] == c) {
          match_len++;
        } else {
          matching = false;
        }
      },
      [&]() {
        bytes++;  // NUL terminator
        if (matching && active[match_len] == '\0' && !new_active.has_value())
          new_active = count;
        count++;
        match_len = 0;
        matching = active != nullptr;
      });
  if (!valid) {
    ESP_LOGW(TAG, "'%s': Can't parse options %s", this->entity_id_, options.c_str());
    return;
  }
  if (count > this->max_options_) {
    ESP_LOGE(TAG, "'%s': %zu options exceed max_options (%u)", this->entity_id_, count, this->max_options_);
    return;
  }
  if (bytes > this->options_buffer_size_) {
    ESP_LOGE(TAG, "'%s': Options need %zu bytes, more than options_buffer_size (%u)", this->entity_id_, bytes,
             this->options_buffer_size_);
    return;
  }
 
  // Second pass: the input is known to be valid and to fit, so write it out
  char *buffer = this->options_buffer_.get();
  size_t offset = 0;
  size_t option_start = 0;
  size_t index = 0;
  parse_python_list(
      options, [&](char c) { buffer[offset++] = c; },
      [&]() {
        buffer[offset++] = '\0';
        this->option_list_[index++] = buffer + option_start;
        option_start = offset;
      });
  // The traits only point at the list, which this select owns; set_options() would copy it to the heap
  this->traits.set_options_static(this->option_list_.get(), count);
 
  // The active option may have moved to another index, or may be gone
  if (new_active.has_value()) {
    this->active_index_ = *new_active;
  } else {
    this->set_has_state(false);
  }
  ESP_LOGD(TAG, "'%s': Got %zu options", this->entity_id_, count);
}
 
void HomeassistantSelect::state_changed_(StringRef state) {
  auto index = this->index_of(state.c_str(), state.size());
  if (!index.has_value()) {
    ESP_LOGW(TAG, "'%s': State '%s' is not one of the options", this->entity_id_, state.c_str());
    return;
  }
  if (this->has_state() && this->active_index_ == *index)
    return;
  ESP_LOGD(TAG, "'%s': Got state '%s'", this->entity_id_, state.c_str());
  this->publish_state(*index);
}
 
void HomeassistantSelect::dump_config() {
  LOG_SELECT("", "Homeassistant Select", this);
  ESP_LOGCONFIG(TAG,
                "  Entity ID: '%s'\n"
                "  Max options: %u\n"
                "  Options buffer size: %u",
                this->entity_id_, this->max_options_, this->options_buffer_size_);
}
 
float HomeassistantSelect::get_setup_priority() const { return setup_priority::AFTER_CONNECTION; }
 
void HomeassistantSelect::control(size_t index) {
  if (!api::global_api_server->is_connected()) {
    ESP_LOGE(TAG, "No clients connected to API server");
    return;
  }
 
#ifdef USE_API_WIZARD_LINKED_INPUTS
  if (this->entity_id_[0] == '\0') {
    ESP_LOGW(TAG, "'%s': No entity ID set yet", this->get_name().c_str());
    return;
  }
#endif
 
  // In flash on the ESP8266 and encoded from there
  static const char SERVICE_SELECT[] PROGMEM = "select.select_option";
  static const char SERVICE_INPUT_SELECT[] PROGMEM = "input_select.select_option";
  static const char ENTITY_ID_KEY[] PROGMEM = "entity_id";
  static const char OPTION_KEY[] PROGMEM = "option";
 
  api::HomeassistantActionRequest resp;
  // An input helper entity id starts with the "input_" its action name starts with
  const bool input_helper = ESPHOME_strncmp_P(this->entity_id_, SERVICE_INPUT_SELECT, sizeof("input_") - 1) == 0;
  resp.service =
      input_helper ? ProgmemStringRef::from_lit(SERVICE_INPUT_SELECT) : ProgmemStringRef::from_lit(SERVICE_SELECT);
 
  resp.data.init(2);
  auto &entity_id = resp.data.emplace_back();
  entity_id.key = ProgmemStringRef::from_lit(ENTITY_ID_KEY);
  entity_id.value = ProgmemStringRef(StringRef(this->entity_id_));
 
  auto &option = resp.data.emplace_back();
  option.key = ProgmemStringRef::from_lit(OPTION_KEY);
  option.value = ProgmemStringRef(StringRef(this->option_at(index)));
 
  api::global_api_server->send_homeassistant_action(resp);
}
 
}  // namespace esphome::homeassistant