mirror of https://github.com/esphome/esphome.git
110 lines
3.3 KiB
C++
110 lines
3.3 KiB
C++
#include "lock.h"
|
|
#include "esphome/core/log.h"
|
|
|
|
namespace esphome {
|
|
namespace lock {
|
|
|
|
static const char *const TAG = "lock";
|
|
|
|
const char *lock_state_to_string(LockState state) {
|
|
switch (state) {
|
|
case LOCK_STATE_LOCKED:
|
|
return "LOCKED";
|
|
case LOCK_STATE_UNLOCKED:
|
|
return "UNLOCKED";
|
|
case LOCK_STATE_JAMMED:
|
|
return "JAMMED";
|
|
case LOCK_STATE_LOCKING:
|
|
return "LOCKING";
|
|
case LOCK_STATE_UNLOCKING:
|
|
return "UNLOCKING";
|
|
case LOCK_STATE_NONE:
|
|
default:
|
|
return "UNKNOWN";
|
|
}
|
|
}
|
|
|
|
Lock::Lock(const std::string &name) : EntityBase(name), state(LOCK_STATE_NONE) {}
|
|
Lock::Lock() : Lock("") {}
|
|
LockCall Lock::make_call() { return LockCall(this); }
|
|
|
|
void Lock::lock() {
|
|
auto call = this->make_call();
|
|
call.set_state(LOCK_STATE_LOCKED);
|
|
this->control(call);
|
|
}
|
|
void Lock::unlock() {
|
|
auto call = this->make_call();
|
|
call.set_state(LOCK_STATE_UNLOCKED);
|
|
this->control(call);
|
|
}
|
|
void Lock::open() {
|
|
if (traits.get_supports_open()) {
|
|
ESP_LOGD(TAG, "'%s' Opening.", this->get_name().c_str());
|
|
this->open_latch();
|
|
} else {
|
|
ESP_LOGW(TAG, "'%s' Does not support Open.", this->get_name().c_str());
|
|
}
|
|
}
|
|
void Lock::publish_state(LockState state) {
|
|
if (!this->publish_dedup_.next(state))
|
|
return;
|
|
|
|
this->state = state;
|
|
this->rtc_.save(&this->state);
|
|
ESP_LOGD(TAG, "'%s': Sending state %s", this->name_.c_str(), lock_state_to_string(state));
|
|
this->state_callback_.call();
|
|
}
|
|
|
|
void Lock::add_on_state_callback(std::function<void()> &&callback) { this->state_callback_.add(std::move(callback)); }
|
|
uint32_t Lock::hash_base() { return 856245656UL; }
|
|
|
|
void LockCall::perform() {
|
|
ESP_LOGD(TAG, "'%s' - Setting", this->parent_->get_name().c_str());
|
|
this->validate_();
|
|
if (this->state_.has_value()) {
|
|
const char *state_s = lock_state_to_string(*this->state_);
|
|
ESP_LOGD(TAG, " State: %s", state_s);
|
|
}
|
|
this->parent_->control(*this);
|
|
}
|
|
void LockCall::validate_() {
|
|
if (this->state_.has_value()) {
|
|
auto state = *this->state_;
|
|
if (!this->parent_->traits.supports_state(state)) {
|
|
ESP_LOGW(TAG, " State %s is not supported by this device!", lock_state_to_string(*this->state_));
|
|
this->state_.reset();
|
|
}
|
|
}
|
|
}
|
|
LockCall &LockCall::set_state(LockState state) {
|
|
this->state_ = state;
|
|
return *this;
|
|
}
|
|
LockCall &LockCall::set_state(optional<LockState> state) {
|
|
this->state_ = state;
|
|
return *this;
|
|
}
|
|
LockCall &LockCall::set_state(const std::string &state) {
|
|
if (str_equals_case_insensitive(state, "LOCKED")) {
|
|
this->set_state(LOCK_STATE_LOCKED);
|
|
} else if (str_equals_case_insensitive(state, "UNLOCKED")) {
|
|
this->set_state(LOCK_STATE_UNLOCKED);
|
|
} else if (str_equals_case_insensitive(state, "JAMMED")) {
|
|
this->set_state(LOCK_STATE_JAMMED);
|
|
} else if (str_equals_case_insensitive(state, "LOCKING")) {
|
|
this->set_state(LOCK_STATE_LOCKING);
|
|
} else if (str_equals_case_insensitive(state, "UNLOCKING")) {
|
|
this->set_state(LOCK_STATE_UNLOCKING);
|
|
} else if (str_equals_case_insensitive(state, "NONE")) {
|
|
this->set_state(LOCK_STATE_NONE);
|
|
} else {
|
|
ESP_LOGW(TAG, "'%s' - Unrecognized state %s", this->parent_->get_name().c_str(), state.c_str());
|
|
}
|
|
return *this;
|
|
}
|
|
const optional<LockState> &LockCall::get_state() const { return this->state_; }
|
|
|
|
} // namespace lock
|
|
} // namespace esphome
|