249 lines
8.1 KiB
Rust
249 lines
8.1 KiB
Rust
use std::sync::Arc;
|
|
use std::time::Duration;
|
|
|
|
use async_trait::async_trait;
|
|
use automation_macro::LuaDeviceConfig;
|
|
use google_home::traits::OnOff;
|
|
use tokio::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
|
|
use tokio::task::JoinHandle;
|
|
use tracing::{debug, error, trace, warn};
|
|
|
|
use super::{Device, LuaDeviceCreate};
|
|
use crate::config::MqttDeviceConfig;
|
|
use crate::devices::DEFAULT_PRESENCE;
|
|
use crate::error::DeviceConfigError;
|
|
use crate::event::{OnMqtt, OnPresence};
|
|
use crate::messages::{ContactMessage, PresenceMessage};
|
|
use crate::mqtt::WrappedAsyncClient;
|
|
use crate::traits::Timeout;
|
|
|
|
// NOTE: If we add more presence devices we might need to move this out of here
|
|
#[derive(Debug, Clone, LuaDeviceConfig)]
|
|
pub struct PresenceDeviceConfig {
|
|
#[device_config(flatten)]
|
|
pub mqtt: MqttDeviceConfig,
|
|
#[device_config(with(Duration::from_secs))]
|
|
pub timeout: Duration,
|
|
}
|
|
|
|
#[derive(Debug, Clone, LuaDeviceConfig)]
|
|
pub struct TriggerConfig {
|
|
#[device_config(from_lua)]
|
|
pub devices: Vec<Box<dyn Device>>,
|
|
#[device_config(default, with(|t: Option<_>| t.map(Duration::from_secs)))]
|
|
pub timeout: Option<Duration>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, LuaDeviceConfig)]
|
|
pub struct Config {
|
|
pub identifier: String,
|
|
#[device_config(flatten)]
|
|
pub mqtt: MqttDeviceConfig,
|
|
#[device_config(from_lua, default)]
|
|
pub presence: Option<PresenceDeviceConfig>,
|
|
#[device_config(from_lua)]
|
|
pub trigger: Option<TriggerConfig>,
|
|
#[device_config(from_lua)]
|
|
pub client: WrappedAsyncClient,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct State {
|
|
overall_presence: bool,
|
|
is_closed: bool,
|
|
previous: Vec<bool>,
|
|
handle: Option<JoinHandle<()>>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct ContactSensor {
|
|
config: Config,
|
|
state: Arc<RwLock<State>>,
|
|
}
|
|
|
|
impl ContactSensor {
|
|
async fn state(&self) -> RwLockReadGuard<State> {
|
|
self.state.read().await
|
|
}
|
|
|
|
async fn state_mut(&self) -> RwLockWriteGuard<State> {
|
|
self.state.write().await
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl LuaDeviceCreate for ContactSensor {
|
|
type Config = Config;
|
|
type Error = DeviceConfigError;
|
|
|
|
async fn create(config: Self::Config) -> Result<Self, Self::Error> {
|
|
trace!(id = config.identifier, "Setting up ContactSensor");
|
|
|
|
let mut previous = Vec::new();
|
|
// Make sure the devices implement the required traits
|
|
if let Some(trigger) = &config.trigger {
|
|
for device in &trigger.devices {
|
|
{
|
|
let id = device.get_id().to_owned();
|
|
if (device.cast() as Option<&dyn OnOff>).is_none() {
|
|
return Err(DeviceConfigError::MissingTrait(id, "OnOff".into()));
|
|
}
|
|
|
|
if trigger.timeout.is_none()
|
|
&& (device.cast() as Option<&dyn Timeout>).is_none()
|
|
{
|
|
return Err(DeviceConfigError::MissingTrait(id, "Timeout".into()));
|
|
}
|
|
}
|
|
}
|
|
previous.resize(trigger.devices.len(), false);
|
|
}
|
|
|
|
config
|
|
.client
|
|
.subscribe(&config.mqtt.topic, rumqttc::QoS::AtLeastOnce)
|
|
.await?;
|
|
|
|
let state = State {
|
|
overall_presence: DEFAULT_PRESENCE,
|
|
is_closed: true,
|
|
previous,
|
|
handle: None,
|
|
};
|
|
let state = Arc::new(RwLock::new(state));
|
|
|
|
Ok(Self { config, state })
|
|
}
|
|
}
|
|
|
|
impl Device for ContactSensor {
|
|
fn get_id(&self) -> String {
|
|
self.config.identifier.clone()
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl OnPresence for ContactSensor {
|
|
async fn on_presence(&self, presence: bool) {
|
|
self.state_mut().await.overall_presence = presence;
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl OnMqtt for ContactSensor {
|
|
async fn on_mqtt(&self, message: rumqttc::Publish) {
|
|
if !rumqttc::matches(&message.topic, &self.config.mqtt.topic) {
|
|
return;
|
|
}
|
|
|
|
let is_closed = match ContactMessage::try_from(message) {
|
|
Ok(state) => state.is_closed(),
|
|
Err(err) => {
|
|
error!(id = self.get_id(), "Failed to parse message: {err}");
|
|
return;
|
|
}
|
|
};
|
|
|
|
if is_closed == self.state().await.is_closed {
|
|
return;
|
|
}
|
|
|
|
debug!(id = self.get_id(), "Updating state to {is_closed}");
|
|
self.state_mut().await.is_closed = is_closed;
|
|
|
|
if let Some(trigger) = &self.config.trigger {
|
|
if !is_closed {
|
|
for (light, previous) in trigger
|
|
.devices
|
|
.iter()
|
|
.zip(self.state_mut().await.previous.iter_mut())
|
|
{
|
|
if let Some(light) = light.cast() as Option<&dyn OnOff> {
|
|
*previous = light.on().await.unwrap();
|
|
light.set_on(true).await.ok();
|
|
}
|
|
}
|
|
} else {
|
|
for (light, previous) in trigger
|
|
.devices
|
|
.iter()
|
|
.zip(self.state_mut().await.previous.iter())
|
|
{
|
|
if !previous {
|
|
// If the timeout is zero just turn the light off directly
|
|
if trigger.timeout.is_none()
|
|
&& let Some(light) = light.cast() as Option<&dyn OnOff>
|
|
{
|
|
light.set_on(false).await.ok();
|
|
} else if let Some(timeout) = trigger.timeout
|
|
&& let Some(light) = light.cast() as Option<&dyn Timeout>
|
|
{
|
|
light.start_timeout(timeout).await.unwrap();
|
|
}
|
|
// TODO: Put a warning/error on creation if either of this has to option to fail
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check if this contact sensor works as a presence device
|
|
// If not we are done here
|
|
let presence = match &self.config.presence {
|
|
Some(presence) => presence.clone(),
|
|
None => return,
|
|
};
|
|
|
|
if !is_closed {
|
|
// Activate presence and stop any timeout once we open the door
|
|
if let Some(handle) = self.state_mut().await.handle.take() {
|
|
handle.abort();
|
|
}
|
|
|
|
// Only use the door as an presence sensor if there the current presence is set false
|
|
// This is to prevent the house from being marked as present for however long the
|
|
// timeout is set when leaving the house
|
|
if !self.state().await.overall_presence {
|
|
self.config
|
|
.client
|
|
.publish(
|
|
&presence.mqtt.topic,
|
|
rumqttc::QoS::AtLeastOnce,
|
|
false,
|
|
serde_json::to_string(&PresenceMessage::new(true)).unwrap(),
|
|
)
|
|
.await
|
|
.map_err(|err| {
|
|
warn!(
|
|
"Failed to publish presence on {}: {err}",
|
|
presence.mqtt.topic
|
|
)
|
|
})
|
|
.ok();
|
|
}
|
|
} else {
|
|
// Once the door is closed again we start a timeout for removing the presence
|
|
let device = self.clone();
|
|
self.state_mut().await.handle = Some(tokio::spawn(async move {
|
|
debug!(
|
|
id = device.get_id(),
|
|
"Starting timeout ({:?}) for contact sensor...", presence.timeout
|
|
);
|
|
tokio::time::sleep(presence.timeout).await;
|
|
debug!(id = device.get_id(), "Removing door device!");
|
|
device
|
|
.config
|
|
.client
|
|
.publish(&presence.mqtt.topic, rumqttc::QoS::AtLeastOnce, false, "")
|
|
.await
|
|
.map_err(|err| {
|
|
warn!(
|
|
"Failed to publish presence on {}: {err}",
|
|
presence.mqtt.topic
|
|
)
|
|
})
|
|
.ok();
|
|
}));
|
|
}
|
|
}
|
|
}
|