JHHM

lol-cal

terminal lolesports schedule viewer
git clone https://jhhm.no/repos/lol-cal.git

lol-cal/src/event.rs

get raw file: event.rs

1use color_eyre::eyre::OptionExt;
2use futures::{FutureExt, StreamExt};
3use ratatui::crossterm::event::Event as CrosstermEvent;
4use tokio::sync::mpsc::{self, UnboundedSender};
5use tracing::error;
6
7use crate::widgets;
8
9#[derive(Clone, Debug)]
10pub enum Event {
11    Crossterm(CrosstermEvent),
12    App(AppEvent),
13}
14
15#[derive(Clone, Debug)]
16pub enum AppEvent {
17    Quit,
18    Up,
19    Down,
20    Left,
21    Right,
22    Select,
23    GotoToday,
24    ToggleSpoilResults,
25    ToggleSpoilMatches,
26    ReloadLeagues,
27    RecieveLeagues(Vec<widgets::leagues::League>),
28    ReloadSchedule,
29    RecieveSchedule((String, Vec<widgets::events::Event>)),
30}
31
32#[derive(Debug)]
33pub struct EventHandler {
34    sender: mpsc::UnboundedSender<Event>,
35    receiver: mpsc::UnboundedReceiver<Event>,
36}
37
38impl EventHandler {
39    pub fn new() -> Self {
40        let (sender, receiver) = mpsc::unbounded_channel();
41        let actor = EventTask::new(sender.clone());
42        tokio::spawn(async { actor.run().await });
43        Self { sender, receiver }
44    }
45
46    pub fn get_sender_clone(&self) -> UnboundedSender<Event> {
47        return self.sender.clone();
48    }
49
50    pub async fn next(&mut self) -> color_eyre::Result<Event> {
51        self.receiver
52            .recv()
53            .await
54            .ok_or_eyre("Failed to receive event")
55    }
56
57    pub fn send(&mut self, app_event: AppEvent) {
58        if let Err(e) = self.sender.send(Event::App(app_event)) {
59            error!("Failed to send app event: {e}");
60        }
61    }
62}
63
64struct EventTask {
65    sender: mpsc::UnboundedSender<Event>,
66}
67
68impl EventTask {
69    fn new(sender: mpsc::UnboundedSender<Event>) -> Self {
70        Self { sender }
71    }
72
73    async fn run(self) -> color_eyre::Result<()> {
74        let mut reader = crossterm::event::EventStream::new();
75        loop {
76            let crossterm_event = reader.next().fuse();
77            tokio::select! {
78              _ = self.sender.closed() => {
79                break;
80              }
81              Some(Ok(evt)) = crossterm_event => {
82                self.send(Event::Crossterm(evt));
83              }
84            };
85        }
86        Ok(())
87    }
88
89    fn send(&self, event: Event) {
90        let _ = self.sender.send(event);
91    }
92}