alarm_control_panel.h

Go to the documentation of this file.

#pragma once
 
#include "alarm_control_panel_call.h"
#include "alarm_control_panel_state.h"
 
#include "esphome/core/automation.h"
#include "esphome/core/entity_base.h"
#include "esphome/core/log.h"
 
namespace esphome::alarm_control_panel {
 
enum AlarmControlPanelFeature : uint8_t {
  // Matches Home Assistant values
  ACP_FEAT_ARM_HOME = 1 << 0,
  ACP_FEAT_ARM_AWAY = 1 << 1,
  ACP_FEAT_ARM_NIGHT = 1 << 2,
  ACP_FEAT_TRIGGER = 1 << 3,
  ACP_FEAT_ARM_CUSTOM_BYPASS = 1 << 4,
  ACP_FEAT_ARM_VACATION = 1 << 5,
};
 
class AlarmControlPanel : public EntityBase {
 public:
  AlarmControlPanelCall make_call();
 
  void publish_state(AlarmControlPanelState state);
 
  template<typename F> void add_on_state_callback(F &&callback) {
    this->state_callback_.add(std::forward<F>(callback));
  }
 
  template<typename F> void add_on_cleared_callback(F &&callback) {
    this->cleared_callback_.add(std::forward<F>(callback));
  }
 
  template<typename F> void add_on_chime_callback(F &&callback) {
    this->chime_callback_.add(std::forward<F>(callback));
  }
 
  template<typename F> void add_on_ready_callback(F &&callback) {
    this->ready_callback_.add(std::forward<F>(callback));
  }
 
  virtual uint32_t get_supported_features() const = 0;
 
  virtual bool get_requires_code() const = 0;
 
  virtual bool get_requires_code_to_arm() const = 0;
 
  void arm_away(const char *code = nullptr);
  void arm_away(const optional<std::string> &code) {
    this->arm_away(code.has_value() ? code.value().c_str() : nullptr);
  }
 
  void arm_home(const char *code = nullptr);
  void arm_home(const optional<std::string> &code) {
    this->arm_home(code.has_value() ? code.value().c_str() : nullptr);
  }
 
  void arm_night(const char *code = nullptr);
  void arm_night(const optional<std::string> &code) {
    this->arm_night(code.has_value() ? code.value().c_str() : nullptr);
  }
 
  void arm_vacation(const char *code = nullptr);
  void arm_vacation(const optional<std::string> &code) {
    this->arm_vacation(code.has_value() ? code.value().c_str() : nullptr);
  }
 
  void arm_custom_bypass(const char *code = nullptr);
  void arm_custom_bypass(const optional<std::string> &code) {
    this->arm_custom_bypass(code.has_value() ? code.value().c_str() : nullptr);
  }
 
  void disarm(const char *code = nullptr);
  void disarm(const optional<std::string> &code) { this->disarm(code.has_value() ? code.value().c_str() : nullptr); }
 
  AlarmControlPanelState get_state() const { return this->current_state_; }
 
  // is the state one of the armed states
  bool is_state_armed(AlarmControlPanelState state);
  bool is_armed_pending_or_triggered() {
    auto state = this->get_state();
    return this->is_state_armed(state) || state == ACP_STATE_PENDING || state == ACP_STATE_TRIGGERED;
  }
 
 protected:
  friend AlarmControlPanelCall;
  // Helper to reduce code duplication for arm/disarm methods
  void arm_with_code_(AlarmControlPanelCall &(AlarmControlPanelCall::*arm_method)(), const char *code);
  // in order to store last panel state in flash
  ESPPreferenceObject pref_;
  // current state
  AlarmControlPanelState current_state_{ACP_STATE_DISARMED};
  // the desired (or previous) state
  AlarmControlPanelState desired_state_{ACP_STATE_DISARMED};
  // last time the state was updated
  uint32_t last_update_{0};
  // the call control function
  virtual void control(const AlarmControlPanelCall &call) = 0;
  // state callback - passes the new state to listeners
  LazyCallbackManager<void(AlarmControlPanelState)> state_callback_{};
  // clear callback - fires when leaving TRIGGERED state
  LazyCallbackManager<void()> cleared_callback_{};
  // chime callback
  LazyCallbackManager<void()> chime_callback_{};
  // ready callback
  LazyCallbackManager<void()> ready_callback_{};
};
 
}  // namespace esphome::alarm_control_panel