Everything is now implemented as a Device using device_traits with all events going through a single place

src/devices/audio_setup.rs

@@ -6,6 +6,7 @@ use tracing::{debug, error, trace, warn};
 
 use crate::config::{self, CreateDevice, MqttDeviceConfig};
 use crate::error::CreateDeviceError;
+use crate::event::EventChannel;
 use crate::mqtt::{OnMqtt, RemoteAction, RemoteMessage};
 use crate::presence::OnPresence;
 
@@ -34,18 +35,20 @@ impl CreateDevice for AudioSetup {
     fn create(
         identifier: &str,
         config: Self::Config,
-        client: AsyncClient,
+        event_channel: &EventChannel,
+        client: &AsyncClient,
         presence_topic: &str,
     ) -> Result<Self, CreateDeviceError> {
         trace!(id = identifier, "Setting up AudioSetup");
 
         // Create the child devices
         let mixer_id = format!("{}.mixer", identifier);
-        let mixer = (*config.mixer).create(&mixer_id, client.clone(), presence_topic)?;
+        let mixer = (*config.mixer).create(&mixer_id, event_channel, client, presence_topic)?;
         let mixer = As::consume(mixer).ok_or(CreateDeviceError::OnOffExpected(mixer_id))?;
 
         let speakers_id = format!("{}.speakers", identifier);
-        let speakers = (*config.speakers).create(&speakers_id, client, presence_topic)?;
+        let speakers =
+            (*config.speakers).create(&speakers_id, event_channel, client, presence_topic)?;
         let speakers =
             As::consume(speakers).ok_or(CreateDeviceError::OnOffExpected(speakers_id))?;
 
@@ -70,7 +73,7 @@ impl OnMqtt for AudioSetup {
         vec![&self.mqtt.topic]
     }
 
-    async fn on_mqtt(&mut self, message: &rumqttc::Publish) {
+    async fn on_mqtt(&mut self, message: rumqttc::Publish) {
         let action = match RemoteMessage::try_from(message) {
             Ok(message) => message.action(),
             Err(err) => {

src/devices/contact_sensor.rs

@@ -9,8 +9,9 @@ use tracing::{debug, error, trace, warn};
 use crate::{
     config::{CreateDevice, MqttDeviceConfig},
     error::{CreateDeviceError, MissingWildcard},
+    event::EventChannel,
     mqtt::{ContactMessage, OnMqtt, PresenceMessage},
-    presence::OnPresence,
+    presence::{self, OnPresence},
 };
 
 use super::Device;
@@ -75,7 +76,8 @@ impl CreateDevice for ContactSensor {
     fn create(
         identifier: &str,
         config: Self::Config,
-        client: AsyncClient,
+        _event_channel: &EventChannel,
+        client: &AsyncClient,
         presence_topic: &str,
     ) -> Result<Self, CreateDeviceError> {
         trace!(id = identifier, "Setting up ContactSensor");
@@ -89,8 +91,8 @@ impl CreateDevice for ContactSensor {
             identifier: identifier.to_owned(),
             mqtt: config.mqtt,
             presence,
-            client,
-            overall_presence: false,
+            client: client.clone(),
+            overall_presence: presence::DEFAULT,
             is_closed: true,
             handle: None,
         })
@@ -116,7 +118,7 @@ impl OnMqtt for ContactSensor {
         vec![&self.mqtt.topic]
     }
 
-    async fn on_mqtt(&mut self, message: &rumqttc::Publish) {
+    async fn on_mqtt(&mut self, message: rumqttc::Publish) {
         let is_closed = match ContactMessage::try_from(message) {
             Ok(state) => state.is_closed(),
             Err(err) => {

src/devices/ikea_outlet.rs

@@ -16,6 +16,7 @@ use tracing::{debug, error, trace, warn};
 use crate::config::{CreateDevice, InfoConfig, MqttDeviceConfig};
 use crate::devices::Device;
 use crate::error::CreateDeviceError;
+use crate::event::EventChannel;
 use crate::mqtt::{OnMqtt, OnOffMessage};
 use crate::presence::OnPresence;
 
@@ -60,8 +61,9 @@ impl CreateDevice for IkeaOutlet {
     fn create(
         identifier: &str,
         config: Self::Config,
-        client: AsyncClient,
-        _presence_topic: &str, // Not a big fan of passing in the global config
+        _event_channel: &EventChannel,
+        client: &AsyncClient,
+        _presence_topic: &str,
     ) -> Result<Self, CreateDeviceError> {
         trace!(
             id = identifier,
@@ -76,7 +78,7 @@ impl CreateDevice for IkeaOutlet {
             mqtt: config.mqtt,
             outlet_type: config.outlet_type,
             timeout: config.timeout,
-            client,
+            client: client.clone(),
             last_known_state: false,
             handle: None,
         })
@@ -112,7 +114,7 @@ impl OnMqtt for IkeaOutlet {
         vec![&self.mqtt.topic]
     }
 
-    async fn on_mqtt(&mut self, message: &Publish) {
+    async fn on_mqtt(&mut self, message: Publish) {
         // Update the internal state based on what the device has reported
         let state = match OnOffMessage::try_from(message) {
             Ok(state) => state.state(),

src/devices/kasa_outlet.rs

@@ -14,7 +14,7 @@ use serde::{Deserialize, Serialize};
 use thiserror::Error;
 use tracing::trace;
 
-use crate::{config::CreateDevice, error::CreateDeviceError};
+use crate::{config::CreateDevice, error::CreateDeviceError, event::EventChannel};
 
 use super::Device;
 
@@ -35,7 +35,8 @@ impl CreateDevice for KasaOutlet {
     fn create(
         identifier: &str,
         config: Self::Config,
-        _client: AsyncClient,
+        _event_channel: &EventChannel,
+        _client: &AsyncClient,
         _presence_topic: &str,
     ) -> Result<Self, CreateDeviceError> {
         trace!(id = identifier, "Setting up KasaOutlet");

src/devices/wake_on_lan.rs

@@ -16,6 +16,7 @@ use tracing::{debug, error, trace};
 use crate::{
     config::{CreateDevice, InfoConfig, MqttDeviceConfig},
     error::CreateDeviceError,
+    event::EventChannel,
     mqtt::{ActivateMessage, OnMqtt},
 };
 
@@ -51,7 +52,8 @@ impl CreateDevice for WakeOnLAN {
     fn create(
         identifier: &str,
         config: Self::Config,
-        _client: AsyncClient,
+        _event_channel: &EventChannel,
+        _client: &AsyncClient,
         _presence_topic: &str,
     ) -> Result<Self, CreateDeviceError> {
         trace!(
@@ -83,7 +85,7 @@ impl OnMqtt for WakeOnLAN {
         vec![&self.mqtt.topic]
     }
 
-    async fn on_mqtt(&mut self, message: &Publish) {
+    async fn on_mqtt(&mut self, message: Publish) {
         let activate = match ActivateMessage::try_from(message) {
             Ok(message) => message.activate(),
             Err(err) => {