lock.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/core/component.h"
#include "esphome/core/entity_base.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
#include "esphome/core/preferences.h"
#include <initializer_list>
 
namespace esphome::lock {
 
class Lock;
 
#define LOG_LOCK(prefix, type, obj) \
  if ((obj) != nullptr) { \
    ESP_LOGCONFIG(TAG, "%s%s '%s'", prefix, LOG_STR_LITERAL(type), (obj)->get_name().c_str()); \
    LOG_ENTITY_ICON(TAG, prefix, *(obj)); \
    if ((obj)->traits.get_assumed_state()) { \
      ESP_LOGCONFIG(TAG, "%s  Assumed State: YES", prefix); \
    } \
  }
enum LockState : uint8_t {
  LOCK_STATE_NONE = 0,
  LOCK_STATE_LOCKED = 1,
  LOCK_STATE_UNLOCKED = 2,
  LOCK_STATE_JAMMED = 3,
  LOCK_STATE_LOCKING = 4,
  LOCK_STATE_UNLOCKING = 5,
  LOCK_STATE_OPENING = 6,
  LOCK_STATE_OPEN = 7,
};
const LogString *lock_state_to_string(LockState state);
 
static constexpr size_t LOCK_STATE_STR_SIZE = 10;
 
class LockTraits {
 public:
  LockTraits() = default;
 
  bool get_supports_open() const { return this->supports_open_; }
  void set_supports_open(bool supports_open) { this->supports_open_ = supports_open; }
  bool get_requires_code() const { return this->requires_code_; }
  void set_requires_code(bool requires_code) { this->requires_code_ = requires_code; }
  bool get_assumed_state() const { return this->assumed_state_; }
  void set_assumed_state(bool assumed_state) { this->assumed_state_ = assumed_state; }
 
  bool supports_state(LockState state) const { return supported_states_mask_ & (1 << state); }
  void set_supported_states(std::initializer_list<LockState> states) {
    supported_states_mask_ = 0;
    for (auto state : states) {
      supported_states_mask_ |= (1 << state);
    }
  }
  uint8_t get_supported_states_mask() const { return supported_states_mask_; }
  void set_supported_states_mask(uint8_t mask) { supported_states_mask_ = mask; }
  void add_supported_state(LockState state) { supported_states_mask_ |= (1 << state); }
 
 protected:
  bool supports_open_{false};
  bool requires_code_{false};
  bool assumed_state_{false};
  uint8_t supported_states_mask_{(1 << LOCK_STATE_NONE) | (1 << LOCK_STATE_LOCKED) | (1 << LOCK_STATE_UNLOCKED)};
};
 
class LockCall {
 public:
  LockCall(Lock *parent) : parent_(parent) {}
 
  LockCall &set_state(LockState state);
  LockCall &set_state(optional<LockState> state);
  LockCall &set_state(const char *state);
  LockCall &set_state(const std::string &state) { return this->set_state(state.c_str()); }
 
  void perform();
 
  const optional<LockState> &get_state() const;
 
 protected:
  void validate_();
 
  Lock *const parent_;
  optional<LockState> state_;
};
 
class Lock : public EntityBase {
 public:
  explicit Lock();
 
  LockCall make_call();
 
  void publish_state(LockState state);
 
  LockState state{LOCK_STATE_NONE};
 
  LockTraits traits;
 
  void lock();
  void unlock();
  void open();
 
  template<typename F> void add_on_state_callback(F &&callback) {
    this->state_callback_.add(std::forward<F>(callback));
  }
 
 protected:
  friend LockCall;
 
  void set_state_(LockState state);
 
  virtual void open_latch() { unlock(); };
 
  virtual void control(const LockCall &call) = 0;
 
  LazyCallbackManager<void(LockState)> state_callback_{};
  Deduplicator<LockState> publish_dedup_;
  ESPPreferenceObject rtc_;
};
 
}  // namespace esphome::lock