custom_api_device.h

Go to the documentation of this file.

#pragma once
 
#include <map>
#include "api_server.h"
#ifdef USE_API
#ifdef USE_API_SERVICES
#include "user_services.h"
#endif
namespace esphome::api {
 
#ifdef USE_API_SERVICES
template<typename T, typename... Ts> class CustomAPIDeviceService : public UserServiceBase<Ts...> {
 public:
  CustomAPIDeviceService(const std::string &name, const std::array<std::string, sizeof...(Ts)> &arg_names, T *obj,
                         void (T::*callback)(Ts...))
      : UserServiceBase<Ts...>(name, arg_names), obj_(obj), callback_(callback) {}
 
 protected:
  void execute(Ts... x) override { (this->obj_->*this->callback_)(x...); }  // NOLINT
 
  T *obj_;
  void (T::*callback_)(Ts...);
};
#endif  // USE_API_SERVICES
 
class CustomAPIDevice {
 public:
  bool is_connected() const { return global_api_server->is_connected(); }
 
#ifdef USE_API_SERVICES
  template<typename T, typename... Ts>
  void register_service(void (T::*callback)(Ts...), const std::string &name,
                        const std::array<std::string, sizeof...(Ts)> &arg_names) {
    auto *service = new CustomAPIDeviceService<T, Ts...>(name, arg_names, (T *) this, callback);  // NOLINT
    global_api_server->register_user_service(service);
  }
#else
  template<typename T, typename... Ts>
  void register_service(void (T::*callback)(Ts...), const std::string &name,
                        const std::array<std::string, sizeof...(Ts)> &arg_names) {
    static_assert(
        sizeof(T) == 0,
        "register_service() requires 'custom_services: true' in the 'api:' section of your YAML configuration");
  }
#endif
 
#ifdef USE_API_SERVICES
  template<typename T> void register_service(void (T::*callback)(), const std::string &name) {
    auto *service = new CustomAPIDeviceService<T>(name, {}, (T *) this, callback);  // NOLINT
    global_api_server->register_user_service(service);
  }
#else
  template<typename T> void register_service(void (T::*callback)(), const std::string &name) {
    static_assert(
        sizeof(T) == 0,
        "register_service() requires 'custom_services: true' in the 'api:' section of your YAML configuration");
  }
#endif
 
#ifdef USE_API_HOMEASSISTANT_STATES
  template<typename T>
  void subscribe_homeassistant_state(void (T::*callback)(std::string), const std::string &entity_id,
                                     const std::string &attribute = "") {
    auto f = std::bind(callback, (T *) this, std::placeholders::_1);
    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), f);
  }
 
  template<typename T>
  void subscribe_homeassistant_state(void (T::*callback)(std::string, std::string), const std::string &entity_id,
                                     const std::string &attribute = "") {
    auto f = std::bind(callback, (T *) this, entity_id, std::placeholders::_1);
    global_api_server->subscribe_home_assistant_state(entity_id, optional<std::string>(attribute), f);
  }
#else
  template<typename T>
  void subscribe_homeassistant_state(void (T::*callback)(std::string), const std::string &entity_id,
                                     const std::string &attribute = "") {
    static_assert(sizeof(T) == 0,
                  "subscribe_homeassistant_state() requires 'homeassistant_states: true' in the 'api:' section "
                  "of your YAML configuration");
  }
 
  template<typename T>
  void subscribe_homeassistant_state(void (T::*callback)(std::string, std::string), const std::string &entity_id,
                                     const std::string &attribute = "") {
    static_assert(sizeof(T) == 0,
                  "subscribe_homeassistant_state() requires 'homeassistant_states: true' in the 'api:' section "
                  "of your YAML configuration");
  }
#endif
 
#ifdef USE_API_HOMEASSISTANT_SERVICES
  void call_homeassistant_service(const std::string &service_name) {
    HomeassistantServiceResponse resp;
    resp.set_service(StringRef(service_name));
    global_api_server->send_homeassistant_service_call(resp);
  }
 
  void call_homeassistant_service(const std::string &service_name, const std::map<std::string, std::string> &data) {
    HomeassistantServiceResponse resp;
    resp.set_service(StringRef(service_name));
    for (auto &it : data) {
      resp.data.emplace_back();
      auto &kv = resp.data.back();
      kv.set_key(StringRef(it.first));
      kv.value = it.second;
    }
    global_api_server->send_homeassistant_service_call(resp);
  }
 
  void fire_homeassistant_event(const std::string &event_name) {
    HomeassistantServiceResponse resp;
    resp.set_service(StringRef(event_name));
    resp.is_event = true;
    global_api_server->send_homeassistant_service_call(resp);
  }
 
  void fire_homeassistant_event(const std::string &service_name, const std::map<std::string, std::string> &data) {
    HomeassistantServiceResponse resp;
    resp.set_service(StringRef(service_name));
    resp.is_event = true;
    for (auto &it : data) {
      resp.data.emplace_back();
      auto &kv = resp.data.back();
      kv.set_key(StringRef(it.first));
      kv.value = it.second;
    }
    global_api_server->send_homeassistant_service_call(resp);
  }
#else
  template<typename T = void> void call_homeassistant_service(const std::string &service_name) {
    static_assert(sizeof(T) == 0, "call_homeassistant_service() requires 'homeassistant_services: true' in the 'api:' "
                                  "section of your YAML configuration");
  }
 
  template<typename T = void>
  void call_homeassistant_service(const std::string &service_name, const std::map<std::string, std::string> &data) {
    static_assert(sizeof(T) == 0, "call_homeassistant_service() requires 'homeassistant_services: true' in the 'api:' "
                                  "section of your YAML configuration");
  }
 
  template<typename T = void> void fire_homeassistant_event(const std::string &event_name) {
    static_assert(sizeof(T) == 0, "fire_homeassistant_event() requires 'homeassistant_services: true' in the 'api:' "
                                  "section of your YAML configuration");
  }
 
  template<typename T = void>
  void fire_homeassistant_event(const std::string &service_name, const std::map<std::string, std::string> &data) {
    static_assert(sizeof(T) == 0, "fire_homeassistant_event() requires 'homeassistant_services: true' in the 'api:' "
                                  "section of your YAML configuration");
  }
#endif
};
 
}  // namespace esphome::api
#endif