897 lines
30 KiB
Rust
897 lines
30 KiB
Rust
use chrono::{
|
|
DateTime, Datelike, Days, Local, LocalResult, NaiveDate, NaiveDateTime, NaiveTime, TimeZone,
|
|
Timelike, Utc,
|
|
};
|
|
use log::{debug, error, info, trace, warn};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::{
|
|
fs,
|
|
path::{Path, PathBuf},
|
|
sync::Mutex,
|
|
};
|
|
use uuid::Uuid;
|
|
|
|
/// Duration (ms) an informational status message remains visible.
|
|
const STATUS_DURATION_MS: i64 = 4000;
|
|
/// Amount of time (ms) an alarm is considered to be "ringing" once triggered.
|
|
const RINGING_DURATION_MS: i64 = 6000;
|
|
/// Minimum timer duration accepted from the UI to avoid accidental zero timers.
|
|
const TIMER_MIN_MS: u64 = 1000;
|
|
|
|
/// Shared state container held by Tauri. It wraps a mutex-protected
|
|
/// [`StateInner`] and is responsible for persistence plus providing immutable
|
|
/// snapshots to the frontend.
|
|
pub struct AppState {
|
|
inner: Mutex<StateInner>,
|
|
storage_path: PathBuf,
|
|
}
|
|
|
|
impl AppState {
|
|
/// Constructs a new state container and eagerly loads persisted alarms.
|
|
pub fn new(storage_path: PathBuf) -> Self {
|
|
let mut inner = StateInner::default();
|
|
if let Some(list) = load_alarms(&storage_path) {
|
|
let now = Local::now();
|
|
inner.alarms = list
|
|
.into_iter()
|
|
.map(|alarm| Alarm {
|
|
id: alarm.id,
|
|
hour: alarm.hour,
|
|
minute: alarm.minute,
|
|
label: alarm.label,
|
|
active: alarm.active,
|
|
next_trigger: resolve_next_trigger(alarm.hour, alarm.minute, &now),
|
|
ringing_until: None,
|
|
})
|
|
.collect();
|
|
}
|
|
Self {
|
|
inner: Mutex::new(inner),
|
|
storage_path,
|
|
}
|
|
}
|
|
|
|
/// Returns a `FrontendState` without mutating anything. Primarily used when
|
|
/// the UI first boots.
|
|
pub fn snapshot(&self) -> FrontendState {
|
|
trace!("Building snapshot for frontend");
|
|
self.apply(|_, _, _| {})
|
|
}
|
|
|
|
/// Executes the housekeeping refresh logic and returns an updated snapshot.
|
|
pub fn tick(&self) -> FrontendState {
|
|
trace!("Processing tick request");
|
|
self.apply(|_, _, _| {})
|
|
}
|
|
|
|
/// Creates a new alarm entry using the provided time and label.
|
|
pub fn create_alarm(&self, time: String, label: Option<String>) -> FrontendState {
|
|
self.apply(|inner, now_ms, now_local| {
|
|
inner.create_alarm(&time, label.as_deref(), now_ms, now_local);
|
|
})
|
|
}
|
|
|
|
/// Toggles an existing alarm's active state.
|
|
pub fn toggle_alarm(&self, id: String) -> FrontendState {
|
|
self.apply(|inner, _now_ms, now_local| {
|
|
inner.toggle_alarm(&id, now_local);
|
|
})
|
|
}
|
|
|
|
/// Deletes an alarm permanently.
|
|
pub fn delete_alarm(&self, id: String) -> FrontendState {
|
|
self.apply(|inner, now_ms, _| {
|
|
inner.delete_alarm(&id, now_ms);
|
|
})
|
|
}
|
|
|
|
/// Starts or pauses the timer depending on the current state.
|
|
pub fn toggle_timer(&self, input: Option<String>, force_parse: bool) -> FrontendState {
|
|
self.apply(|inner, now_ms, _| {
|
|
inner.toggle_timer(input.as_deref(), force_parse, now_ms);
|
|
})
|
|
}
|
|
|
|
/// Resets the timer to its initial duration.
|
|
pub fn reset_timer(&self) -> FrontendState {
|
|
self.apply(|inner, _, _| inner.reset_timer())
|
|
}
|
|
|
|
/// Starts or pauses the stopwatch.
|
|
pub fn toggle_stopwatch(&self) -> FrontendState {
|
|
self.apply(|inner, now_ms, _| inner.toggle_stopwatch(now_ms))
|
|
}
|
|
|
|
/// Records a lap for the stopwatch if running.
|
|
pub fn add_lap(&self) -> FrontendState {
|
|
self.apply(|inner, now_ms, _| inner.add_lap(now_ms))
|
|
}
|
|
|
|
/// Resets the stopwatch to zero elapsed time and clears laps.
|
|
pub fn reset_stopwatch(&self) -> FrontendState {
|
|
self.apply(|inner, _, _| inner.reset_stopwatch())
|
|
}
|
|
|
|
/// Executes a state mutation closure while handling locking, refresh logic,
|
|
/// snapshot generation, and persistence side effects.
|
|
fn apply<F>(&self, mutator: F) -> FrontendState
|
|
where
|
|
F: FnOnce(&mut StateInner, i64, &DateTime<Local>),
|
|
{
|
|
let now_local = Local::now();
|
|
let now_ms = now_local.timestamp_millis();
|
|
let mut guard = self.inner.lock().expect("state mutex poisoned");
|
|
trace!("Running state mutation (now_ms={})", now_ms);
|
|
mutator(&mut guard, now_ms, &now_local);
|
|
guard.refresh(now_ms, &now_local);
|
|
let snapshot = guard.to_frontend(&now_local);
|
|
let persisted = if guard.alarms_dirty {
|
|
Some(
|
|
guard
|
|
.alarms
|
|
.iter()
|
|
.map(PersistedAlarm::from)
|
|
.collect::<Vec<_>>(),
|
|
)
|
|
} else {
|
|
None
|
|
};
|
|
guard.alarms_dirty = false;
|
|
drop(guard);
|
|
if let Some(list) = persisted {
|
|
debug!("Persisting {} alarms to disk", list.len());
|
|
self.save_alarms(&list);
|
|
}
|
|
snapshot
|
|
}
|
|
|
|
/// Persists the alarm list to disk, creating directories as needed.
|
|
fn save_alarms(&self, alarms: &[PersistedAlarm]) {
|
|
if let Some(parent) = self.storage_path.parent() {
|
|
if let Err(error) = fs::create_dir_all(parent) {
|
|
error!(
|
|
"Failed to create alarm storage directory {}: {error}",
|
|
parent.display()
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
let payload = AlarmStore {
|
|
alarms: alarms.to_vec(),
|
|
};
|
|
match serde_json::to_string_pretty(&payload) {
|
|
Ok(json) => {
|
|
if let Err(error) = fs::write(&self.storage_path, json) {
|
|
error!(
|
|
"Failed to persist alarms to {}: {error}",
|
|
self.storage_path.display()
|
|
);
|
|
} else {
|
|
debug!(
|
|
"Persisted {} alarms to {}",
|
|
payload.alarms.len(),
|
|
self.storage_path.display()
|
|
);
|
|
}
|
|
}
|
|
Err(error) => {
|
|
error!("Failed to serialize alarms: {error}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
/// Mutable inner state containing alarms, timers, and transient UI messaging.
|
|
struct StateInner {
|
|
alarms: Vec<Alarm>,
|
|
timer: TimerState,
|
|
stopwatch: StopwatchState,
|
|
status: Option<StatusMessage>,
|
|
play_chime: bool,
|
|
alarms_dirty: bool,
|
|
}
|
|
|
|
impl StateInner {
|
|
/// Executes periodic tasks that should run on every mutation or tick.
|
|
fn refresh(&mut self, now_ms: i64, now_local: &DateTime<Local>) {
|
|
self.process_alarms(now_ms, now_local);
|
|
self.update_timer(now_ms);
|
|
self.expire_status(now_ms);
|
|
}
|
|
|
|
/// Builds a full [`FrontendState`] representation of the current data.
|
|
fn to_frontend(&mut self, now_local: &DateTime<Local>) -> FrontendState {
|
|
let now_ms = now_local.timestamp_millis();
|
|
let now_utc = now_local.with_timezone(&Utc);
|
|
let clock = ClockState {
|
|
local_time: format_time(now_local.hour(), now_local.minute(), now_local.second()),
|
|
local_date: format_date(now_local.year(), now_local.month(), now_local.day()),
|
|
utc_time: format_time(now_utc.hour(), now_utc.minute(), now_utc.second()),
|
|
utc_date: format_date(now_utc.year(), now_utc.month(), now_utc.day()),
|
|
};
|
|
let alarms = self.build_alarm_view(now_ms);
|
|
let timer = self.build_timer_view();
|
|
let stopwatch = self.build_stopwatch_view(now_ms);
|
|
let status = self.status.as_ref().map(|message| message.text.clone());
|
|
let should_chime = std::mem::take(&mut self.play_chime);
|
|
FrontendState {
|
|
clock,
|
|
alarms,
|
|
timer,
|
|
stopwatch,
|
|
status,
|
|
should_chime,
|
|
}
|
|
}
|
|
|
|
/// Adds a new alarm and schedules its next trigger time.
|
|
fn create_alarm(
|
|
&mut self,
|
|
raw_time: &str,
|
|
label: Option<&str>,
|
|
now_ms: i64,
|
|
now_local: &DateTime<Local>,
|
|
) {
|
|
let Some((hour, minute)) = parse_alarm_time(raw_time) else {
|
|
warn!("Invalid alarm time input: {}", raw_time);
|
|
self.push_status("時刻の形式が正しくありません", now_ms);
|
|
return;
|
|
};
|
|
let label_text = label
|
|
.map(|value| value.trim().to_string())
|
|
.filter(|value| !value.is_empty())
|
|
.unwrap_or_else(|| "アラーム".to_string());
|
|
let alarm = Alarm {
|
|
id: Uuid::new_v4().to_string(),
|
|
hour,
|
|
minute,
|
|
label: label_text.clone(),
|
|
active: true,
|
|
next_trigger: resolve_next_trigger(hour, minute, now_local),
|
|
ringing_until: None,
|
|
};
|
|
self.alarms.push(alarm);
|
|
self.alarms_dirty = true;
|
|
info!(
|
|
"Alarm created: '{}' scheduled for {:02}:{:02}",
|
|
label_text, hour, minute
|
|
);
|
|
self.push_status(&format!("アラーム追加: {}", label_text), now_ms);
|
|
}
|
|
|
|
/// Toggles an alarm's active state and recalculates its next trigger.
|
|
fn toggle_alarm(&mut self, id: &str, now_local: &DateTime<Local>) {
|
|
if let Some(alarm) = self.alarms.iter_mut().find(|alarm| alarm.id == id) {
|
|
alarm.active = !alarm.active;
|
|
alarm.ringing_until = None;
|
|
alarm.next_trigger = resolve_next_trigger(alarm.hour, alarm.minute, now_local);
|
|
self.alarms_dirty = true;
|
|
info!(
|
|
"Alarm {} toggled -> {}",
|
|
id,
|
|
if alarm.active { "active" } else { "inactive" }
|
|
);
|
|
} else {
|
|
warn!("Requested toggle for unknown alarm id {}", id);
|
|
}
|
|
}
|
|
|
|
/// Removes an alarm completely.
|
|
fn delete_alarm(&mut self, id: &str, now_ms: i64) {
|
|
if let Some(index) = self.alarms.iter().position(|alarm| alarm.id == id) {
|
|
let removed = self.alarms.remove(index);
|
|
self.alarms_dirty = true;
|
|
info!("Alarm {} deleted", removed.id);
|
|
self.push_status(&format!("アラーム削除: {}", removed.label), now_ms);
|
|
} else {
|
|
warn!("Requested delete for unknown alarm id {}", id);
|
|
}
|
|
}
|
|
|
|
/// Handles timer start/pause logic, parsing inputs when necessary.
|
|
fn toggle_timer(&mut self, input: Option<&str>, force_parse: bool, now_ms: i64) {
|
|
if self.timer.running {
|
|
if let Some(target) = self.timer.target_epoch_ms {
|
|
self.timer.remaining_ms = target.saturating_sub(now_ms) as u64;
|
|
}
|
|
self.timer.running = false;
|
|
self.timer.target_epoch_ms = None;
|
|
info!("Timer paused with {}ms remaining", self.timer.remaining_ms);
|
|
return;
|
|
}
|
|
|
|
let next_input = input.unwrap_or("").trim();
|
|
let needs_parse = force_parse
|
|
|| self.timer.initial_ms == 0
|
|
|| (!next_input.is_empty() && Some(next_input) != self.timer.last_input.as_deref());
|
|
|
|
if needs_parse {
|
|
if next_input.is_empty() {
|
|
warn!("Timer start requested without duration input");
|
|
self.push_status("タイマーの時間を入力してください", now_ms);
|
|
return;
|
|
}
|
|
let Some(duration) = parse_duration(next_input) else {
|
|
warn!("Failed to parse timer duration from '{}'", next_input);
|
|
self.push_status("時間の形式が正しくありません", now_ms);
|
|
return;
|
|
};
|
|
if duration < TIMER_MIN_MS {
|
|
warn!("Timer duration below minimum: {}ms", duration);
|
|
self.push_status("1秒以上の時間を入力してください", now_ms);
|
|
return;
|
|
}
|
|
self.timer.initial_ms = duration;
|
|
self.timer.remaining_ms = duration;
|
|
self.timer.last_input = Some(next_input.to_string());
|
|
}
|
|
|
|
if self.timer.remaining_ms == 0 {
|
|
self.timer.remaining_ms = self.timer.initial_ms;
|
|
}
|
|
|
|
if self.timer.remaining_ms == 0 {
|
|
self.push_status("1秒以上の時間を入力してください", now_ms);
|
|
return;
|
|
}
|
|
|
|
self.timer.running = true;
|
|
self.timer.target_epoch_ms = Some(now_ms + self.timer.remaining_ms as i64);
|
|
info!(
|
|
"Timer started for {}ms (target epoch {})",
|
|
self.timer.remaining_ms,
|
|
self.timer.target_epoch_ms.unwrap_or(now_ms)
|
|
);
|
|
}
|
|
|
|
/// Restores the timer to its initial duration without starting it.
|
|
fn reset_timer(&mut self) {
|
|
self.timer.running = false;
|
|
self.timer.target_epoch_ms = None;
|
|
self.timer.remaining_ms = self.timer.initial_ms;
|
|
info!("Timer reset to {}ms", self.timer.initial_ms);
|
|
}
|
|
|
|
/// Starts or pauses the stopwatch while accounting for elapsed time.
|
|
fn toggle_stopwatch(&mut self, now_ms: i64) {
|
|
if self.stopwatch.running {
|
|
if let Some(start) = self.stopwatch.start_epoch_ms {
|
|
let delta = now_ms.saturating_sub(start);
|
|
self.stopwatch.elapsed_before_ms += delta as u64;
|
|
}
|
|
self.stopwatch.running = false;
|
|
self.stopwatch.start_epoch_ms = None;
|
|
info!("Stopwatch paused at {}ms", self.stopwatch.elapsed_before_ms);
|
|
} else {
|
|
self.stopwatch.running = true;
|
|
self.stopwatch.start_epoch_ms = Some(now_ms);
|
|
info!("Stopwatch started");
|
|
}
|
|
}
|
|
|
|
/// Records a lap entry capturing both the total elapsed time and the delta
|
|
/// since the previous lap.
|
|
fn add_lap(&mut self, now_ms: i64) {
|
|
let elapsed = self.stopwatch_elapsed(now_ms);
|
|
if elapsed == 0 {
|
|
debug!("Lap ignored because stopwatch has not started");
|
|
return;
|
|
}
|
|
let previous_total = self
|
|
.stopwatch
|
|
.laps
|
|
.last()
|
|
.map(|lap| lap.total_ms)
|
|
.unwrap_or(0);
|
|
let entry = LapEntry {
|
|
id: Uuid::new_v4().to_string(),
|
|
total_ms: elapsed,
|
|
delta_ms: elapsed.saturating_sub(previous_total),
|
|
};
|
|
self.stopwatch.laps.push(entry);
|
|
debug!(
|
|
"Lap recorded: {} (total {}ms)",
|
|
self.stopwatch
|
|
.laps
|
|
.last()
|
|
.map(|lap| lap.id.clone())
|
|
.unwrap_or_default(),
|
|
elapsed
|
|
);
|
|
}
|
|
|
|
/// Stops the stopwatch and clears any lap history.
|
|
fn reset_stopwatch(&mut self) {
|
|
self.stopwatch.running = false;
|
|
self.stopwatch.start_epoch_ms = None;
|
|
self.stopwatch.elapsed_before_ms = 0;
|
|
self.stopwatch.laps.clear();
|
|
info!("Stopwatch reset");
|
|
}
|
|
|
|
/// Iterates configured alarms, triggering those scheduled for the current
|
|
/// tick and scheduling their next activation.
|
|
fn process_alarms(&mut self, now_ms: i64, now_local: &DateTime<Local>) {
|
|
let mut triggered_labels = Vec::new();
|
|
for alarm in &mut self.alarms {
|
|
if let Some(until) = alarm.ringing_until {
|
|
if until <= now_ms {
|
|
alarm.ringing_until = None;
|
|
}
|
|
}
|
|
if !alarm.active {
|
|
continue;
|
|
}
|
|
if now_ms >= alarm.next_trigger {
|
|
alarm.ringing_until = Some(now_ms + RINGING_DURATION_MS);
|
|
alarm.next_trigger = resolve_next_trigger(alarm.hour, alarm.minute, now_local);
|
|
triggered_labels.push(alarm.label.clone());
|
|
}
|
|
}
|
|
if !triggered_labels.is_empty() {
|
|
self.play_chime = true;
|
|
self.alarms_dirty = true;
|
|
info!(
|
|
"Triggered {} alarm(s): {:?}",
|
|
triggered_labels.len(),
|
|
triggered_labels
|
|
);
|
|
for label in triggered_labels {
|
|
self.push_status(&format!("アラーム: {}", label), now_ms);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Updates timer countdown bookkeeping and fires completion status when the
|
|
/// clock hits zero.
|
|
fn update_timer(&mut self, now_ms: i64) {
|
|
if self.timer.running {
|
|
if let Some(target) = self.timer.target_epoch_ms {
|
|
if now_ms >= target {
|
|
self.timer.running = false;
|
|
self.timer.target_epoch_ms = None;
|
|
self.timer.remaining_ms = 0;
|
|
self.play_chime = true;
|
|
info!("Timer completed");
|
|
self.push_status("タイマー終了", now_ms);
|
|
} else {
|
|
self.timer.remaining_ms = target.saturating_sub(now_ms) as u64;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Expires the active status message once its TTL elapses.
|
|
fn expire_status(&mut self, now_ms: i64) {
|
|
if let Some(status) = &self.status {
|
|
if status.expires_at <= now_ms {
|
|
self.status = None;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Builds the alarm section view model that the frontend expects.
|
|
fn build_alarm_view(&self, now_ms: i64) -> AlarmSection {
|
|
let mut sorted = self.alarms.iter().collect::<Vec<_>>();
|
|
sorted.sort_by_key(|alarm| alarm.next_trigger);
|
|
let items: Vec<AlarmView> = sorted
|
|
.into_iter()
|
|
.map(|alarm| AlarmView {
|
|
id: alarm.id.clone(),
|
|
label: alarm.label.clone(),
|
|
time_label: format_time_label(alarm.hour, alarm.minute),
|
|
active: alarm.active,
|
|
ringing: alarm
|
|
.ringing_until
|
|
.map(|until| until > now_ms)
|
|
.unwrap_or(false),
|
|
next_relative: format_relative(alarm.next_trigger, now_ms),
|
|
})
|
|
.collect();
|
|
let active_alarms: Vec<&Alarm> = self.alarms.iter().filter(|alarm| alarm.active).collect();
|
|
let next_summary = if active_alarms.is_empty() {
|
|
"アクティブなアラームはありません".to_string()
|
|
} else {
|
|
let soonest = active_alarms
|
|
.into_iter()
|
|
.min_by_key(|alarm| alarm.next_trigger)
|
|
.expect("active alarm available");
|
|
format!(
|
|
"次のアラーム: {} ({}) - {}",
|
|
format_time_label(soonest.hour, soonest.minute),
|
|
soonest.label,
|
|
format_relative(soonest.next_trigger, now_ms)
|
|
)
|
|
};
|
|
AlarmSection {
|
|
items,
|
|
next_summary,
|
|
}
|
|
}
|
|
|
|
/// Builds the timer view model by formatting durations and button labels.
|
|
fn build_timer_view(&self) -> TimerView {
|
|
let display_ms = if self.timer.running {
|
|
self.timer.remaining_ms
|
|
} else if self.timer.remaining_ms > 0 {
|
|
self.timer.remaining_ms
|
|
} else {
|
|
self.timer.initial_ms
|
|
};
|
|
let toggle_label = if self.timer.running {
|
|
"一時停止"
|
|
} else if self.timer.remaining_ms > 0 && self.timer.remaining_ms < self.timer.initial_ms {
|
|
"再開"
|
|
} else {
|
|
"スタート"
|
|
};
|
|
let status_text = if self.timer.running {
|
|
Some("カウント中".to_string())
|
|
} else if self.timer.remaining_ms > 0 && self.timer.remaining_ms < self.timer.initial_ms {
|
|
Some("一時停止".to_string())
|
|
} else if !self.timer.running && self.timer.initial_ms > 0 && self.timer.remaining_ms == 0 {
|
|
Some("完了".to_string())
|
|
} else {
|
|
None
|
|
};
|
|
TimerView {
|
|
display: format_duration(display_ms),
|
|
toggle_label: toggle_label.to_string(),
|
|
status_text,
|
|
}
|
|
}
|
|
|
|
/// Builds the stopwatch view model including lap breakdowns.
|
|
fn build_stopwatch_view(&self, now_ms: i64) -> StopwatchView {
|
|
let elapsed = self.stopwatch_elapsed(now_ms);
|
|
let toggle_label = if self.stopwatch.running {
|
|
"停止"
|
|
} else {
|
|
"スタート"
|
|
};
|
|
let laps = build_lap_views(&self.stopwatch.laps);
|
|
StopwatchView {
|
|
display: format_stopwatch(elapsed),
|
|
toggle_label: toggle_label.to_string(),
|
|
laps,
|
|
}
|
|
}
|
|
|
|
/// Returns the total stopwatch elapsed milliseconds, optionally including
|
|
/// the in-flight span if the stopwatch is currently running.
|
|
fn stopwatch_elapsed(&self, now_ms: i64) -> u64 {
|
|
self.stopwatch.elapsed_before_ms
|
|
+ if self.stopwatch.running {
|
|
now_ms.saturating_sub(self.stopwatch.start_epoch_ms.unwrap_or(now_ms)) as u64
|
|
} else {
|
|
0
|
|
}
|
|
}
|
|
|
|
/// Stores a transient status message that the UI can render for users.
|
|
fn push_status(&mut self, message: &str, now_ms: i64) {
|
|
self.status = Some(StatusMessage {
|
|
text: message.to_string(),
|
|
expires_at: now_ms + STATUS_DURATION_MS,
|
|
});
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
struct Alarm {
|
|
id: String,
|
|
hour: u8,
|
|
minute: u8,
|
|
label: String,
|
|
active: bool,
|
|
next_trigger: i64,
|
|
ringing_until: Option<i64>,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct TimerState {
|
|
initial_ms: u64,
|
|
remaining_ms: u64,
|
|
running: bool,
|
|
target_epoch_ms: Option<i64>,
|
|
last_input: Option<String>,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct StopwatchState {
|
|
running: bool,
|
|
start_epoch_ms: Option<i64>,
|
|
elapsed_before_ms: u64,
|
|
laps: Vec<LapEntry>,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
struct LapEntry {
|
|
id: String,
|
|
total_ms: u64,
|
|
delta_ms: u64,
|
|
}
|
|
|
|
struct StatusMessage {
|
|
text: String,
|
|
expires_at: i64,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
/// Comprehensive state payload consumed by the frontend.
|
|
pub struct FrontendState {
|
|
pub clock: ClockState,
|
|
pub alarms: AlarmSection,
|
|
pub timer: TimerView,
|
|
pub stopwatch: StopwatchView,
|
|
pub status: Option<String>,
|
|
pub should_chime: bool,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
/// Clock label strings rendered in the UI.
|
|
pub struct ClockState {
|
|
pub local_time: String,
|
|
pub local_date: String,
|
|
pub utc_time: String,
|
|
pub utc_date: String,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
/// Aggregated alarm listing plus small summary for the next trigger.
|
|
pub struct AlarmSection {
|
|
pub items: Vec<AlarmView>,
|
|
pub next_summary: String,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
/// Individual alarm entry displayed in the frontend list.
|
|
pub struct AlarmView {
|
|
pub id: String,
|
|
pub label: String,
|
|
pub time_label: String,
|
|
pub active: bool,
|
|
pub ringing: bool,
|
|
pub next_relative: String,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
/// Timer labels consumed by the UI controls.
|
|
pub struct TimerView {
|
|
pub display: String,
|
|
pub toggle_label: String,
|
|
pub status_text: Option<String>,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
/// Stopwatch value for the UI including lap breakdowns.
|
|
pub struct StopwatchView {
|
|
pub display: String,
|
|
pub toggle_label: String,
|
|
pub laps: Vec<LapView>,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
/// Single lap renderable information.
|
|
pub struct LapView {
|
|
pub id: String,
|
|
pub label: String,
|
|
pub total: String,
|
|
pub delta: String,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone)]
|
|
/// Minimal alarm representation stored on disk.
|
|
struct PersistedAlarm {
|
|
id: String,
|
|
hour: u8,
|
|
minute: u8,
|
|
label: String,
|
|
active: bool,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Default)]
|
|
/// Wrapper used when serializing alarm lists to JSON.
|
|
struct AlarmStore {
|
|
alarms: Vec<PersistedAlarm>,
|
|
}
|
|
|
|
impl From<&Alarm> for PersistedAlarm {
|
|
fn from(value: &Alarm) -> Self {
|
|
Self {
|
|
id: value.id.clone(),
|
|
hour: value.hour,
|
|
minute: value.minute,
|
|
label: value.label.clone(),
|
|
active: value.active,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Attempts to load the alarm store JSON file from disk.
|
|
fn load_alarms(path: &Path) -> Option<Vec<PersistedAlarm>> {
|
|
match fs::read(path) {
|
|
Ok(bytes) => match serde_json::from_slice::<AlarmStore>(&bytes) {
|
|
Ok(store) => {
|
|
debug!("Loaded {} persisted alarms", store.alarms.len());
|
|
Some(store.alarms)
|
|
}
|
|
Err(error) => {
|
|
warn!("Failed to parse alarm store at {}: {error}", path.display());
|
|
None
|
|
}
|
|
},
|
|
Err(error) => {
|
|
debug!(
|
|
"No persisted alarms available at {} ({error})",
|
|
path.display()
|
|
);
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Formats a timestamp as HH:MM:SS.
|
|
fn format_time(hour: u32, minute: u32, second: u32) -> String {
|
|
format!("{:02}:{:02}:{:02}", hour, minute, second)
|
|
}
|
|
|
|
/// Formats a date as YYYY-MM-DD.
|
|
fn format_date(year: i32, month: u32, day: u32) -> String {
|
|
format!("{year:04}-{month:02}-{day:02}")
|
|
}
|
|
|
|
/// Formats an alarm display label.
|
|
fn format_time_label(hour: u8, minute: u8) -> String {
|
|
format!("{:02}:{:02}", hour, minute)
|
|
}
|
|
|
|
/// Produces a human-friendly relative time string describing when an alarm
|
|
/// will next trigger.
|
|
fn format_relative(target_ms: i64, now_ms: i64) -> String {
|
|
let diff = target_ms - now_ms;
|
|
if diff <= 0 {
|
|
return "まもなく".to_string();
|
|
}
|
|
if diff <= 60_000 {
|
|
return "まもなく".to_string();
|
|
}
|
|
let minutes = diff / 60_000;
|
|
if minutes < 60 {
|
|
return format!("{}分後", minutes);
|
|
}
|
|
let hours = minutes / 60;
|
|
let mins = minutes % 60;
|
|
format!("{}時間{}分後", hours, mins)
|
|
}
|
|
|
|
/// Formats a duration for timer display, switching to HH:MM:SS when needed.
|
|
fn format_duration(ms: u64) -> String {
|
|
let total_seconds = (ms / 1000) as u64;
|
|
let minutes = total_seconds / 60;
|
|
let seconds = total_seconds % 60;
|
|
let hundredths = (ms % 1000) / 10;
|
|
if minutes >= 60 {
|
|
let hours = minutes / 60;
|
|
let rem_minutes = minutes % 60;
|
|
format!("{:02}:{:02}:{:02}", hours, rem_minutes, seconds)
|
|
} else {
|
|
format!("{:02}:{:02}.{:02}", minutes, seconds, hundredths)
|
|
}
|
|
}
|
|
|
|
/// Formats stopwatch durations with millisecond precision.
|
|
fn format_stopwatch(ms: u64) -> String {
|
|
let total_seconds = ms / 1000;
|
|
let minutes = total_seconds / 60;
|
|
let seconds = total_seconds % 60;
|
|
let millis = ms % 1000;
|
|
format!("{:02}:{:02}.{:03}", minutes, seconds, millis)
|
|
}
|
|
|
|
/// Converts raw lap entries into renderable view data.
|
|
fn build_lap_views(entries: &[LapEntry]) -> Vec<LapView> {
|
|
if entries.is_empty() {
|
|
return Vec::new();
|
|
}
|
|
let total = entries.len();
|
|
entries
|
|
.iter()
|
|
.rev()
|
|
.enumerate()
|
|
.map(|(index, lap)| LapView {
|
|
id: lap.id.clone(),
|
|
label: format!("Lap {}", total - index),
|
|
total: format!("合計 {}", format_stopwatch(lap.total_ms)),
|
|
delta: format!("+{}", format_stopwatch(lap.delta_ms)),
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// Parses HH:MM strings emitted by the UI.
|
|
fn parse_alarm_time(value: &str) -> Option<(u8, u8)> {
|
|
let trimmed = value.trim();
|
|
let mut parts = trimmed.split(':');
|
|
let hour = parts.next()?.parse::<u8>().ok()?;
|
|
let minute = parts.next()?.parse::<u8>().ok()?;
|
|
if parts.next().is_some() || hour > 23 || minute > 59 {
|
|
return None;
|
|
}
|
|
Some((hour, minute))
|
|
}
|
|
|
|
/// Parses timer duration input supporting seconds, MM:SS, or `1h 30m` formats.
|
|
fn parse_duration(value: &str) -> Option<u64> {
|
|
let trimmed = value.trim();
|
|
if trimmed.is_empty() {
|
|
return None;
|
|
}
|
|
if trimmed.chars().all(|ch| ch.is_ascii_digit()) {
|
|
return trimmed.parse::<u64>().ok().map(|seconds| seconds * 1000);
|
|
}
|
|
if trimmed.contains(':') {
|
|
let mut parts = trimmed.split(':');
|
|
let minutes = parts.next()?.parse::<u64>().ok()?;
|
|
let seconds = parts.next()?.parse::<u64>().ok()?;
|
|
if parts.next().is_some() {
|
|
return None;
|
|
}
|
|
return Some((minutes * 60 + seconds) * 1000);
|
|
}
|
|
parse_unit_duration(trimmed)
|
|
}
|
|
|
|
/// Helper that parses unit-suffixed duration tokens like `10m 5s`.
|
|
fn parse_unit_duration(value: &str) -> Option<u64> {
|
|
let mut total_ms = 0u64;
|
|
for chunk in value.split_whitespace() {
|
|
if chunk.is_empty() {
|
|
continue;
|
|
}
|
|
let split_index = chunk.find(|c: char| !c.is_ascii_digit())?;
|
|
let (number_part, unit_part) = chunk.split_at(split_index);
|
|
if number_part.is_empty() {
|
|
return None;
|
|
}
|
|
let amount = number_part.parse::<u64>().ok()?;
|
|
let unit = unit_part.chars().next()?.to_ascii_lowercase();
|
|
match unit {
|
|
'h' => total_ms += amount * 3_600_000,
|
|
'm' => total_ms += amount * 60_000,
|
|
's' => total_ms += amount * 1000,
|
|
_ => return None,
|
|
}
|
|
}
|
|
if total_ms > 0 {
|
|
Some(total_ms)
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
/// Calculates the next trigger timestamp in milliseconds for an alarm.
|
|
fn resolve_next_trigger(hour: u8, minute: u8, now_local: &DateTime<Local>) -> i64 {
|
|
let naive_time = NaiveTime::from_hms_opt(hour as u32, minute as u32, 0)
|
|
.unwrap_or_else(|| NaiveTime::from_hms_opt(0, 0, 0).unwrap());
|
|
let mut candidate = combine_local(now_local.date_naive(), naive_time);
|
|
if candidate.timestamp_millis() <= now_local.timestamp_millis() {
|
|
let next_day = now_local.date_naive() + Days::new(1);
|
|
candidate = combine_local(next_day, naive_time);
|
|
}
|
|
candidate.timestamp_millis()
|
|
}
|
|
|
|
/// Safely combines a date and time within the Local timezone, falling back to
|
|
/// UTC if the local conversion is ambiguous or invalid.
|
|
fn combine_local(date: NaiveDate, time: NaiveTime) -> DateTime<Local> {
|
|
let naive = NaiveDateTime::new(date, time);
|
|
match Local.from_local_datetime(&naive) {
|
|
LocalResult::Single(value) => value,
|
|
LocalResult::Ambiguous(first, _second) => first,
|
|
LocalResult::None => {
|
|
DateTime::<Utc>::from_naive_utc_and_offset(naive, Utc).with_timezone(&Local)
|
|
}
|
|
}
|
|
}
|