Add select entities and implement template select (#2067)

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

esphome/components/select/__init__.py

@@ -0,0 +1,102 @@
+from typing import List
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome import automation
+from esphome.components import mqtt
+from esphome.const import (
+    CONF_ICON,
+    CONF_ID,
+    CONF_INTERNAL,
+    CONF_ON_VALUE,
+    CONF_OPTION,
+    CONF_TRIGGER_ID,
+    CONF_NAME,
+    CONF_MQTT_ID,
+    ICON_EMPTY,
+)
+from esphome.core import CORE, coroutine_with_priority
+
+CODEOWNERS = ["@esphome/core"]
+IS_PLATFORM_COMPONENT = True
+
+select_ns = cg.esphome_ns.namespace("select")
+Select = select_ns.class_("Select", cg.Nameable)
+SelectPtr = Select.operator("ptr")
+
+# Triggers
+SelectStateTrigger = select_ns.class_(
+    "SelectStateTrigger", automation.Trigger.template(cg.float_)
+)
+
+# Actions
+SelectSetAction = select_ns.class_("SelectSetAction", automation.Action)
+
+icon = cv.icon
+
+
+SELECT_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend(
+    {
+        cv.OnlyWith(CONF_MQTT_ID, "mqtt"): cv.declare_id(mqtt.MQTTSelectComponent),
+        cv.GenerateID(): cv.declare_id(Select),
+        cv.Optional(CONF_ICON, default=ICON_EMPTY): icon,
+        cv.Optional(CONF_ON_VALUE): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(SelectStateTrigger),
+            }
+        ),
+    }
+)
+
+
+async def setup_select_core_(var, config, *, options: List[str]):
+    cg.add(var.set_name(config[CONF_NAME]))
+    if CONF_INTERNAL in config:
+        cg.add(var.set_internal(config[CONF_INTERNAL]))
+
+    cg.add(var.traits.set_icon(config[CONF_ICON]))
+    cg.add(var.traits.set_options(options))
+
+    for conf in config.get(CONF_ON_VALUE, []):
+        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
+        await automation.build_automation(trigger, [(cg.std_string, "x")], conf)
+
+    if CONF_MQTT_ID in config:
+        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
+        await mqtt.register_mqtt_component(mqtt_, config)
+
+
+async def register_select(var, config, *, options: List[str]):
+    if not CORE.has_id(config[CONF_ID]):
+        var = cg.Pvariable(config[CONF_ID], var)
+    cg.add(cg.App.register_select(var))
+    await setup_select_core_(var, config, options=options)
+
+
+async def new_select(config, *, options: List[str]):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await register_select(var, config, options=options)
+    return var
+
+
+@coroutine_with_priority(40.0)
+async def to_code(config):
+    cg.add_define("USE_SELECT")
+    cg.add_global(select_ns.using)
+
+
+@automation.register_action(
+    "select.set",
+    SelectSetAction,
+    cv.Schema(
+        {
+            cv.Required(CONF_ID): cv.use_id(Select),
+            cv.Required(CONF_OPTION): cv.templatable(cv.string_strict),
+        }
+    ),
+)
+async def select_set_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+    template_ = await cg.templatable(config[CONF_OPTION], args, str)
+    cg.add(var.set_option(template_))
+    return var

esphome/components/select/automation.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "select.h"
+
+namespace esphome {
+namespace select {
+
+class SelectStateTrigger : public Trigger<std::string> {
+ public:
+  explicit SelectStateTrigger(Select *parent) {
+    parent->add_on_state_callback([this](std::string value) { this->trigger(std::move(value)); });
+  }
+};
+
+template<typename... Ts> class SelectSetAction : public Action<Ts...> {
+ public:
+  SelectSetAction(Select *select) : select_(select) {}
+  TEMPLATABLE_VALUE(std::string, option)
+
+  void play(Ts... x) override {
+    auto call = this->select_->make_call();
+    call.set_option(this->option_.value(x...));
+    call.perform();
+  }
+
+ protected:
+  Select *select_;
+};
+
+}  // namespace select
+}  // namespace esphome

esphome/components/select/select.cpp

@@ -0,0 +1,43 @@
+#include "select.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace select {
+
+static const char *const TAG = "select";
+
+void SelectCall::perform() {
+  ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
+  if (!this->option_.has_value()) {
+    ESP_LOGW(TAG, "No value set for SelectCall");
+    return;
+  }
+
+  const auto &traits = this->parent_->traits;
+  auto value = *this->option_;
+  auto options = traits.get_options();
+
+  if (std::find(options.begin(), options.end(), value) == options.end()) {
+    ESP_LOGW(TAG, "  Option %s is not a valid option.", value.c_str());
+    return;
+  }
+
+  ESP_LOGD(TAG, "  Option: %s", (*this->option_).c_str());
+  this->parent_->control(*this->option_);
+}
+
+void Select::publish_state(const std::string &state) {
+  this->has_state_ = true;
+  this->state = state;
+  ESP_LOGD(TAG, "'%s': Sending state %s", this->get_name().c_str(), state.c_str());
+  this->state_callback_.call(state);
+}
+
+void Select::add_on_state_callback(std::function<void(std::string)> &&callback) {
+  this->state_callback_.add(std::move(callback));
+}
+
+uint32_t Select::hash_base() { return 2812997003UL; }
+
+}  // namespace select
+}  // namespace esphome

esphome/components/select/select.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include <set>
+#include <utility>
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace select {
+
+#define LOG_SELECT(prefix, type, obj) \
+  if ((obj) != nullptr) { \
+    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, type, (obj)->get_name().c_str()); \
+    if (!(obj)->traits.get_icon().empty()) { \
+      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->traits.get_icon().c_str()); \
+    } \
+  }
+
+class Select;
+
+class SelectCall {
+ public:
+  explicit SelectCall(Select *parent) : parent_(parent) {}
+  void perform();
+
+  SelectCall &set_option(const std::string &option) {
+    option_ = option;
+    return *this;
+  }
+  const optional<std::string> &get_option() const { return option_; }
+
+ protected:
+  Select *const parent_;
+  optional<std::string> option_;
+};
+
+class SelectTraits {
+ public:
+  void set_options(std::vector<std::string> options) { this->options_ = std::move(options); }
+  const std::vector<std::string> get_options() const { return this->options_; }
+  void set_icon(std::string icon) { icon_ = std::move(icon); }
+  const std::string &get_icon() const { return icon_; }
+
+ protected:
+  std::vector<std::string> options_;
+  std::string icon_;
+};
+
+/** Base-class for all selects.
+ *
+ * A select can use publish_state to send out a new value.
+ */
+class Select : public Nameable {
+ public:
+  std::string state;
+
+  void publish_state(const std::string &state);
+
+  SelectCall make_call() { return SelectCall(this); }
+  void set(const std::string &value) { make_call().set_option(value).perform(); }
+
+  void add_on_state_callback(std::function<void(std::string)> &&callback);
+
+  SelectTraits traits;
+
+  /// Return whether this select has gotten a full state yet.
+  bool has_state() const { return has_state_; }
+
+ protected:
+  friend class SelectCall;
+
+  /** Set the value of the select, this is a virtual method that each select integration must implement.
+   *
+   * This method is called by the SelectCall.
+   *
+   * @param value The value as validated by the SelectCall.
+   */
+  virtual void control(const std::string &value) = 0;
+
+  uint32_t hash_base() override;
+
+  CallbackManager<void(std::string)> state_callback_;
+  bool has_state_{false};
+};
+
+}  // namespace select
+}  // namespace esphome