Revert "Implement sensor status debouncing"

This reverts commit 0ed1871042.

src/main.rs

@@ -24,8 +24,7 @@ mod matrix;
 mod mqtt;
 
 use tokio::{
-    sync::{Notify, broadcast, mpsc},
-    time::{sleep, Duration},
+    sync::{Notify, broadcast},
     task::JoinHandle,
 };
 
@@ -49,16 +48,11 @@ struct Args {
     config: String,
 }
 
-#[derive(PartialEq, Clone, Copy, Debug)]
-enum DoorSensorStatus {
+#[derive(PartialEq)]
+enum LolOpenerStatus {
     Open,
     Closed,
 }
-#[derive(Debug)]
-struct LolOpenerState {
-    sensor_status: Option<DoorSensorStatus>,
-    update_pending: bool,
-}
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
@@ -86,54 +80,25 @@ async fn main() -> anyhow::Result<()> {
             matrix_ready.notified().await;
             info!("Matrix is ready");
 
-            let current_state = Arc::new(Mutex::new(LolOpenerState {
-                sensor_status: None,
-                update_pending: false
-            }));
-            let current_state = Arc::clone(&current_state);
-
-            let (debounce_tx, mut debounce_rx) = mpsc::unbounded_channel::<(DoorSensorStatus, String)>();
-            let debounce_delay = config.debounce_delay;
-            let rooms = config.rooms.clone();
-            let handle = tokio::spawn(async move {
-
-                while let Some((new_status, msg)) = debounce_rx.recv().await {
-                    let should_wait = {
-                        //XXX: Panic if the lock is poisoned
-                        let state = current_state.lock().unwrap();
-                        !state.update_pending
-                    };
-
-                    if should_wait {
-                        sleep(Duration::from_secs(debounce_delay)).await;
-                        //XXX: Panic if the lock is poisoned
-                        let mut state = current_state.lock().unwrap();
-                        state.update_pending = false;
-
-                        if Some(new_status) != state.sensor_status {
-                            debug!("Sending msg {}", msg);
-                            //XXX: Panic if the matrix module can't get the message
-                            bcast_tx.send((msg, rooms.clone())).unwrap();
-                            state.sensor_status = Some(new_status);
-                        }
-                    }
-                }
-            });
+            let current_status = Arc::new(Mutex::new(None));
+            let current_status = Arc::clone(&current_status);
 
             let mut mqtt = MQTT::new(config.mqtt.clone()).await;
             mqtt.subscribe(move |status: StatusMessage| {
                 let (new_status, msg) = match status {
-                    StatusMessage { contact: true, .. } => (DoorSensorStatus::Closed, "🔴 Le LOL est fermé :("),
-                    StatusMessage { contact: false, .. } => (DoorSensorStatus::Open, "🟢 Le LOL est ouvert :)"),
+                    StatusMessage { contact: true, .. } => (Some(LolOpenerStatus::Closed), "🔴 Le LOL est fermé :("),
+                    StatusMessage { contact: false, .. } => (Some(LolOpenerStatus::Open), "🟢 Le LOL est ouvert :)"),
                 };
 
-                //XXX: Panic if the channel is closed
-                debounce_tx.send((new_status, String::from(msg))).unwrap();
-
+                //XXX: Panic if the lock is poisoned (why would that happen?)
+                let mut current_status = current_status.lock().unwrap();
+                if new_status != *current_status {
+                    debug!("Sending msg {}", msg);
+                    //XXX: Panic if the matrix module can't get the message
+                    bcast_tx.send((msg.into(), config.rooms.clone())).unwrap();
+                    *current_status = new_status;
+                }
             }).await.unwrap(); //XXX: Panic if the mqtt broker fails
-
-            handle.abort();
-            handle.await.unwrap();
         })
     };