malakal 0.1.9

a day-planning calendar app based on egui
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use chrono::Duration;
use log::warn;
use notify_rust::Notification;
use sysinfo::{ProcessExt, System, SystemExt};
use timer::Timer;

use crate::backend::Backend;
use crate::event::Event;
use crate::util::{self, shared, utc_now, Result, Shared};
use crate::Config;

pub struct Notifier {
  // this guard is only used to bind the lifetime of the guard to a
  // notifier, not to be read.
  #[allow(dead_code)]
  reschedule_guard: timer::Guard,
  context: Shared<NotifierContext>,
}

struct NotifierContext {
  timer: Timer,
  guards: Vec<timer::Guard>,
  switch: bool,
  blacklist_processes: Vec<String>,
  notification_timeout: Duration,
  reschedule_interval: Duration,
  backend: Shared<dyn Backend>,
}

impl NotifierContext {
  fn new(config: &Config, backend: &Shared<dyn Backend>) -> Result<Self> {
    Ok(Self {
      timer: Timer::new(),
      guards: vec![],
      switch: config.notifier_switch,
      blacklist_processes: config.notifier_blacklist_processes.clone(),
      backend: backend.clone(),
      notification_timeout: config.notification_timeout,
      reschedule_interval: Self::reschedule_interval(),
    })
  }

  // should be const but chrono::from_std is not declared as const
  fn reschedule_interval() -> Duration {
    Duration::seconds(3600 * 24)
  }

  fn start_rescheduler(shared_context: Shared<Self>) -> timer::Guard {
    let cloned_context = shared_context.clone();
    let context_locked = shared_context.lock().unwrap();
    context_locked
      .timer
      .schedule_repeating(context_locked.reschedule_interval, move || {
        Self::reschedule_events(cloned_context.clone())
      })
  }

  fn reschedule_events(shared_context: Shared<Self>) {
    let mut context = shared_context.lock().unwrap();
    let shared_backend = context.backend.clone();
    let mut backend = shared_backend.lock().unwrap();

    let now = util::utc_now();
    let until = now + context.reschedule_interval;
    let events: Vec<_> = backend
      .get_events(now, until)
      .into_iter()
      .flatten()
      .collect();
    drop(backend);

    context.guards.clear();
    for event in events {
      if event.start < utc_now() {
        continue;
      }

      let notify_at = event.start;
      let shared_context = shared_context.clone();
      let guard =
        context.timer.schedule_with_date(
          notify_at,
          move || match Self::notify(shared_context.clone(), event.clone()) {
            Ok(_) => (),
            Err(e) => warn!("failed sending notification {e:?}"),
          },
        );

      context.guards.push(guard);
    }
  }

  fn notify(context: Shared<Self>, event: Event) -> Result<()> {
    let context = context.lock().unwrap();
    if !context.switch {
      return Ok(());
    }

    if blacklist_process_running(&context.blacklist_processes) {
      return Ok(());
    }

    Notification::new()
      .summary(&event.title)
      .appname("malakal")
      .auto_icon()
      .timeout(context.notification_timeout.to_std()?)
      .show()?;

    Ok(())
  }
}

impl Notifier {
  pub fn start(config: &Config, backend: &Shared<dyn Backend>) -> Result<Self> {
    let context = shared(NotifierContext::new(config, backend)?);
    let reschedule_guard = NotifierContext::start_rescheduler(context.clone());
    let notifier = Self {
      reschedule_guard,
      context,
    };
    notifier.events_updated();
    Ok(notifier)
  }

  pub fn events_updated(&self) {
    NotifierContext::reschedule_events(self.context.clone());
  }
}

fn blacklist_process_running(blacklist: &[String]) -> bool {
  let system = System::default();
  for process in system.processes().values() {
    let name = process.name();
    if blacklist.iter().any(|black| black == name) {
      return true;
    }
  }

  false
}