Add select entities and implement template select (#2067)

Co-authored-by: Otto Winter <otto@otto-winter.com>

esphome/components/template/select/__init__.py

@@ -0,0 +1,74 @@
+from esphome import automation
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import select
+from esphome.const import (
+    CONF_ID,
+    CONF_INITIAL_OPTION,
+    CONF_LAMBDA,
+    CONF_OPTIONS,
+    CONF_OPTIMISTIC,
+    CONF_RESTORE_VALUE,
+)
+from .. import template_ns
+
+TemplateSelect = template_ns.class_(
+    "TemplateSelect", select.Select, cg.PollingComponent
+)
+
+CONF_SET_ACTION = "set_action"
+
+
+def validate_initial_value_in_options(config):
+    if CONF_INITIAL_OPTION in config:
+        if config[CONF_INITIAL_OPTION] not in config[CONF_OPTIONS]:
+            raise cv.Invalid(
+                f"initial_option '{config[CONF_INITIAL_OPTION]}' is not a valid option [{', '.join(config[CONF_OPTIONS])}]"
+            )
+    else:
+        config[CONF_INITIAL_OPTION] = config[CONF_OPTIONS][0]
+    return config
+
+
+CONFIG_SCHEMA = cv.All(
+    select.SELECT_SCHEMA.extend(
+        {
+            cv.GenerateID(): cv.declare_id(TemplateSelect),
+            cv.Required(CONF_OPTIONS): cv.All(
+                cv.ensure_list(cv.string_strict), cv.Length(min=1)
+            ),
+            cv.Optional(CONF_LAMBDA): cv.returning_lambda,
+            cv.Optional(CONF_OPTIMISTIC): cv.boolean,
+            cv.Optional(CONF_SET_ACTION): automation.validate_automation(single=True),
+            cv.Optional(CONF_INITIAL_OPTION): cv.string_strict,
+            cv.Optional(CONF_RESTORE_VALUE): cv.boolean,
+        }
+    ).extend(cv.polling_component_schema("60s")),
+    validate_initial_value_in_options,
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await select.register_select(var, config, options=config[CONF_OPTIONS])
+
+    if CONF_LAMBDA in config:
+        template_ = await cg.process_lambda(
+            config[CONF_LAMBDA], [], return_type=cg.optional.template(str)
+        )
+        cg.add(var.set_template(template_))
+
+    else:
+        if CONF_OPTIMISTIC in config:
+            cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
+
+        cg.add(var.set_initial_option(config[CONF_INITIAL_OPTION]))
+
+        if CONF_RESTORE_VALUE in config:
+            cg.add(var.set_restore_value(config[CONF_RESTORE_VALUE]))
+
+    if CONF_SET_ACTION in config:
+        await automation.build_automation(
+            var.get_set_trigger(), [(cg.std_string, "x")], config[CONF_SET_ACTION]
+        )

esphome/components/template/select/template_select.cpp

@@ -0,0 +1,74 @@
+#include "template_select.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace template_ {
+
+static const char *const TAG = "template.select";
+
+void TemplateSelect::setup() {
+  if (this->f_.has_value())
+    return;
+
+  std::string value;
+  ESP_LOGD(TAG, "Setting up Template Number");
+  if (!this->restore_value_) {
+    value = this->initial_option_;
+    ESP_LOGD(TAG, "State from initial: %s", value.c_str());
+  } else {
+    size_t index;
+    this->pref_ = global_preferences.make_preference<size_t>(this->get_object_id_hash());
+    if (!this->pref_.load(&index)) {
+      value = this->initial_option_;
+      ESP_LOGD(TAG, "State from initial (could not load): %s", value.c_str());
+    } else {
+      value = this->traits.get_options().at(index);
+      ESP_LOGD(TAG, "State from restore: %s", value.c_str());
+    }
+  }
+
+  this->publish_state(value);
+}
+
+void TemplateSelect::update() {
+  if (!this->f_.has_value())
+    return;
+
+  auto val = (*this->f_)();
+  if (!val.has_value())
+    return;
+
+  auto options = this->traits.get_options();
+  if (std::find(options.begin(), options.end(), *val) == options.end()) {
+    ESP_LOGE(TAG, "lambda returned an invalid option %s", (*val).c_str());
+    return;
+  }
+
+  this->publish_state(*val);
+}
+
+void TemplateSelect::control(const std::string &value) {
+  this->set_trigger_->trigger(value);
+
+  if (this->optimistic_)
+    this->publish_state(value);
+
+  if (this->restore_value_) {
+    auto options = this->traits.get_options();
+    size_t index = std::find(options.begin(), options.end(), value) - options.begin();
+
+    this->pref_.save(&index);
+  }
+}
+void TemplateSelect::dump_config() {
+  LOG_SELECT("", "Template Select", this);
+  LOG_UPDATE_INTERVAL(this);
+  if (this->f_.has_value())
+    return;
+  ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));
+  ESP_LOGCONFIG(TAG, "  Initial Option: %s", this->initial_option_.c_str());
+  ESP_LOGCONFIG(TAG, "  Restore Value: %s", YESNO(this->restore_value_));
+}
+
+}  // namespace template_
+}  // namespace esphome

esphome/components/template/select/template_select.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "esphome/components/select/select.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "esphome/core/preferences.h"
+
+namespace esphome {
+namespace template_ {
+
+class TemplateSelect : public select::Select, public PollingComponent {
+ public:
+  void set_template(std::function<optional<std::string>()> &&f) { this->f_ = f; }
+
+  void setup() override;
+  void update() override;
+  void dump_config() override;
+  float get_setup_priority() const override { return setup_priority::HARDWARE; }
+
+  Trigger<std::string> *get_set_trigger() const { return this->set_trigger_; }
+  void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
+  void set_initial_option(std::string initial_option) { this->initial_option_ = std::move(initial_option); }
+  void set_restore_value(bool restore_value) { this->restore_value_ = restore_value; }
+
+ protected:
+  void control(const std::string &value) override;
+  bool optimistic_ = false;
+  std::string initial_option_;
+  bool restore_value_ = false;
+  Trigger<std::string> *set_trigger_ = new Trigger<std::string>();
+  optional<std::function<optional<std::string>()>> f_;
+
+  ESPPreferenceObject pref_;
+};
+
+}  // namespace template_
+}  // namespace esphome