Crate zentime_rs_timer 

Pomodoro/Productivity timer that can transition between various states ([Paused]/[Running]), tracks intervals and can be configured.

Example

use std::sync::mpsc::{self, RecvTimeoutError};
use std::sync::mpsc::{Receiver, Sender};
use std::thread;
use std::rc::Rc;
use std::time::Duration;
use zentime_rs_timer::config::PomodoroTimerConfig;
use zentime_rs_timer::pomodoro_timer_action::PomodoroTimerAction;
use zentime_rs_timer::pomodoro_timer::{ PomodoroTimer, TimerKind, ViewState };

    let (terminal_input_sender, terminal_input_receiver): (Sender<PomodoroTimerAction>, Receiver<PomodoroTimerAction>) =
        mpsc::channel();
    let (view_sender, view_receiver): (Sender<ViewState>, Receiver<ViewState>) =
        mpsc::channel();

    let config = PomodoroTimerConfig::default();

    // Run timer in its own thread so it does not block the current one
    thread::spawn(move || {
        let timer = PomodoroTimer::new(
            config,
            Rc::new(move |state, msg, _| {
                println!("{} {}", state.round, msg.unwrap());
            }),
            Rc::new(move |view_state| -> Option<PomodoroTimerAction> {
                view_sender.send(view_state).unwrap();

                let input = terminal_input_receiver.recv_timeout(Duration::from_millis(100));

                match input {
                    Ok(action) => Some(action),
                    Err(RecvTimeoutError::Disconnected) => std::process::exit(0),
                    _ => None,
                }
            }),
        );

        timer.init();
    });

    let action_jh = thread::spawn(move || {
        // Start the timer
        terminal_input_sender.send(PomodoroTimerAction::PlayPause).unwrap();

        // Render current timer state three seconds in a row
        for _ in 0..3 {
            thread::sleep(Duration::from_millis(100));
            if let Ok(state) = view_receiver.recv() {
                println!("{}", state.time)
            }
        }

    });

    action_jh.join().unwrap();

Re-exports

pub use timer::Timer;

pub use timer_action::TimerAction;

Modules

config

Configuration of a [Timer]

pomodoro_timer

Pomodoro timer implementation. When instantiated this runs instances of [Timer] internally and allows the transitioning between various states like [Interval], [ShortBreak] or [LongBreak].

pomodoro_timer_action

Action enum that can be passed to the timer on each tick to interact with it

timer

Timer implementation The timer hast the ability to toggle playback and end. It will call a given on_tick closure on every tick update and an on_timer_end-closure, when it’s done (either by receiving a TimerAction::End) or when the internal timer is down to 0

timer_action

Action enum that can be passed to the timer on each tick to interact with it

util

Small helper fns