tomato_timer 0.2.1

A simple tomato timer
Documentation 
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

#![warn(clippy::all, rust_2018_idioms)]

mod app;
mod colors;
mod sounds;
use sounds::{finish_sound, start_sound};
use std::{
    thread,
    time::{Duration, SystemTime},
};

pub use app::{TimerStatus, TomatoTimer};

pub fn get_elapsed_time(status: &TimerStatus) -> f32 {
    let current_time = SystemTime::now();
    match status {
        TimerStatus::Running(start_time) => current_time
            .duration_since(*start_time)
            .unwrap()
            .as_secs_f32(),
        TimerStatus::Break(break_start) => current_time
            .duration_since(*break_start)
            .unwrap()
            .as_secs_f32(),
        _ => 0.0,
    }
}

pub fn get_remaining_time(status: &TimerStatus, time_per_round: &f32, time_per_break: &f32) -> f32 {
    let elapsed_time = get_elapsed_time(status);
    match status {
        TimerStatus::Running(_) => (*time_per_round * 60.0) - elapsed_time,
        TimerStatus::Break(_) => (*time_per_break * 60.0) - elapsed_time,
        _ => 0.0,
    }
}

pub fn get_is_round_complete(
    status: &TimerStatus,
    time_per_round: &f32,
    time_per_break: &f32,
) -> bool {
    let remaining_time = get_remaining_time(status, time_per_round, time_per_break);
    remaining_time <= 0.0
}

pub fn handle_round_complete(status: &mut TimerStatus, round_complete: bool) {
    if round_complete {
        match status {
            TimerStatus::Running(_) => {
                notifica::notify("Time is up!", "Take a break").expect("Failed to notify");
                *status = TimerStatus::Break(SystemTime::now());
                thread::spawn(|| {
                    finish_sound();
                });
            }
            TimerStatus::Break(_) => {
                notifica::notify("Back to work!", "Start focusing again :)")
                    .expect("Failed to notify");
                *status = TimerStatus::Running(SystemTime::now());
                thread::spawn(|| {
                    start_sound();
                });
            }
            _ => {}
        }
    }
}

pub fn display_time_remaining(remaining_time: f32) -> String {
    match remaining_time as u32 {
        60..=u32::MAX => format!(
            "{} Minutes left in round",
            (Duration::from_secs_f32(remaining_time).as_secs() / 60) + 1
        ),
        1..=59 => format!(
            "{} Seconds left in round",
            Duration::from_secs_f32(remaining_time).as_secs()
        ),
        _ => format!("Time is up!"),
    }
}