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/preferences.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
#include <set>

namespace esphome {
namespace 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()); \
    if (!(obj)->get_icon().empty()) { \
      ESP_LOGCONFIG(TAG, "%s  Icon: '%s'", prefix, (obj)->get_icon().c_str()); \
    } \
    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
};
const char *lock_state_to_string(LockState state);

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_.count(state); }
  std::set<LockState> get_supported_states() const { return supported_states_; }
  void set_supported_states(std::set<LockState> states) { supported_states_ = std::move(states); }
  void add_supported_state(LockState state) { supported_states_.insert(state); }

 protected:
  bool supports_open_{false};
  bool requires_code_{false};
  bool assumed_state_{false};
  std::set<LockState> supported_states_ = {LOCK_STATE_NONE, LOCK_STATE_LOCKED, 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 std::string &state);

  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();

  void add_on_state_callback(std::function<void()> &&callback);

 protected:
  friend LockCall;

  virtual void open_latch() { unlock(); };

  virtual void control(const LockCall &call) = 0;

  CallbackManager<void()> state_callback_{};
  Deduplicator<LockState> publish_dedup_;
  ESPPreferenceObject rtc_;
};

}  // namespace lock
}  // namespace esphome