Init Commit

src/event.rs

@@ -0,0 +1,62 @@
+use color_eyre::eyre::{Result, eyre};
+use crossterm;
+use crossterm::event;
+use futures::FutureExt;
+use futures::StreamExt;
+use std::time::Duration;
+use tokio::sync::mpsc::UnboundedSender;
+use tokio::task::JoinHandle;
+
+pub(crate) enum Event {
+    Error,
+    Tick,
+    Key(event::KeyEvent),
+}
+
+pub(crate) struct EventHandler {
+    _tx: UnboundedSender<Event>,
+    rx: tokio::sync::mpsc::UnboundedReceiver<Event>,
+    task: Option<JoinHandle<()>>,
+}
+
+impl EventHandler {
+    pub fn new(tick_rate: Duration) -> Self {
+        let mut interval = tokio::time::interval(tick_rate);
+        let mut event_reader = crossterm::event::EventStream::new();
+        let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
+
+        let _tx = tx.clone();
+
+        let task = tokio::spawn(async move {
+            loop {
+                let delay = interval.tick();
+                let crossterm_event = event_reader.next().fuse();
+                tokio::select! {
+                    maybe_event = crossterm_event => {
+                        if let Some(Err(_)) = maybe_event {
+                            tx.send(Event::Error).unwrap()
+                        }
+                        else if let Some(Ok(event)) = maybe_event &&
+                                let event::Event::Key(key) = event &&
+                                key.kind == event::KeyEventKind::Press
+                        {
+                            tx.send(Event::Key(key)).unwrap()
+                        }
+                    }
+                    _ = delay => {
+                        tx.send(Event::Tick).unwrap()
+                    }
+                }
+            }
+        });
+        Self {
+            _tx,
+            rx,
+            task: Some(task),
+        }
+    }
+
+    pub(crate) async fn next(&mut self) -> Result<Event> {
+        self.rx.recv().await.ok_or(eyre!("Unable to get event"))
+    }
+}