kamat/tauclock
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Write more code in Rust

Browse Source
This commit is contained in:
Yuya KAMATAKI
2026-01-12 02:31:25 +09:00
parent c8c90f0641
commit 0b36c2a8a3
3 changed files with 947 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

113
src-tauri/Cargo.lock generated
View File

@@ -775,13 +775,34 @@ dependencies = [
"crypto-common",
]
[[package]]
name = "dirs"
version = "5.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
dependencies = [
"dirs-sys 0.4.1",
]
[[package]]
name = "dirs"
version = "6.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
dependencies = [
"dirs-sys",
"dirs-sys 0.5.0",
]
[[package]]
name = "dirs-sys"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
dependencies = [
"libc",
"option-ext",
"redox_users 0.4.6",
"windows-sys 0.48.0",
]
[[package]]
@@ -792,7 +813,7 @@ checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
dependencies = [
"libc",
"option-ext",
"redox_users",
"redox_users 0.5.2",
"windows-sys 0.61.2",
]
@@ -2976,6 +2997,17 @@ dependencies = [
"bitflags 2.10.0",
]
[[package]]
name = "redox_users"
version = "0.4.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43"
dependencies = [
"getrandom 0.2.16",
"libredox",
"thiserror 1.0.69",
]
[[package]]
name = "redox_users"
version = "0.5.2"
@@ -3727,12 +3759,15 @@ name = "tauclock"
version = "0.1.0"
dependencies = [
"chrono",
"dirs 5.0.1",
"log",
"serde",
"serde_json",
"tauri",
"tauri-build",
"tauri-plugin-log",
"tauri-plugin-opener",
"uuid",
]
[[package]]
@@ -3744,7 +3779,7 @@ dependencies = [
"anyhow",
"bytes",
"cookie",
"dirs",
"dirs 6.0.0",
"dunce",
"embed_plist",
"getrandom 0.3.4",
@@ -3794,7 +3829,7 @@ checksum = "17fcb8819fd16463512a12f531d44826ce566f486d7ccd211c9c8cebdaec4e08"
dependencies = [
"anyhow",
"cargo_toml",
"dirs",
"dirs 6.0.0",
"glob",
"heck 0.5.0",
"json-patch",
@@ -4339,7 +4374,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e3d5572781bee8e3f994d7467084e1b1fd7a93ce66bd480f8156ba89dee55a2b"
dependencies = [
"crossbeam-channel",
"dirs",
"dirs 6.0.0",
"libappindicator",
"muda",
"objc2",
@@ -4923,6 +4958,15 @@ dependencies = [
"windows-targets 0.42.2",
]
[[package]]
name = "windows-sys"
version = "0.48.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
dependencies = [
"windows-targets 0.48.5",
]
[[package]]
name = "windows-sys"
version = "0.59.0"
@@ -4965,6 +5009,21 @@ dependencies = [
"windows_x86_64_msvc 0.42.2",
]
[[package]]
name = "windows-targets"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
dependencies = [
"windows_aarch64_gnullvm 0.48.5",
"windows_aarch64_msvc 0.48.5",
"windows_i686_gnu 0.48.5",
"windows_i686_msvc 0.48.5",
"windows_x86_64_gnu 0.48.5",
"windows_x86_64_gnullvm 0.48.5",
"windows_x86_64_msvc 0.48.5",
]
[[package]]
name = "windows-targets"
version = "0.52.6"
@@ -5022,6 +5081,12 @@ version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
[[package]]
name = "windows_aarch64_gnullvm"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
[[package]]
name = "windows_aarch64_gnullvm"
version = "0.52.6"
@@ -5040,6 +5105,12 @@ version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
[[package]]
name = "windows_aarch64_msvc"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
[[package]]
name = "windows_aarch64_msvc"
version = "0.52.6"
@@ -5058,6 +5129,12 @@ version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
[[package]]
name = "windows_i686_gnu"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
[[package]]
name = "windows_i686_gnu"
version = "0.52.6"
@@ -5088,6 +5165,12 @@ version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
[[package]]
name = "windows_i686_msvc"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
[[package]]
name = "windows_i686_msvc"
version = "0.52.6"
@@ -5106,6 +5189,12 @@ version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
[[package]]
name = "windows_x86_64_gnu"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
[[package]]
name = "windows_x86_64_gnu"
version = "0.52.6"
@@ -5124,6 +5213,12 @@ version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.52.6"
@@ -5142,6 +5237,12 @@ version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
[[package]]
name = "windows_x86_64_msvc"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
[[package]]
name = "windows_x86_64_msvc"
version = "0.52.6"
@@ -5204,7 +5305,7 @@ dependencies = [
"block2",
"cookie",
"crossbeam-channel",
"dirs",
"dirs 6.0.0",
"dpi",
"dunce",
"gdkx11",

4
src-tauri/Cargo.toml
View File

@@ -24,4 +24,6 @@ serde = { version = "1", features = ["derive"] }
serde_json = "1"
chrono = "0.4.42"
tauri-plugin-log = "2"
uuid = { version = "1", features = ["v4"] }
dirs = "5"
log = "0.4"

837
src-tauri/src/state.rs Normal file
View File

@@ -0,0 +1,837 @@
use chrono::{
DateTime, Datelike, Days, Local, LocalResult, NaiveDate, NaiveDateTime, NaiveTime, TimeZone,
Timelike, Utc, Weekday,
};
use log::{debug, error, info, trace, warn};
use serde::{Deserialize, Serialize};
use std::{
fs,
path::{Path, PathBuf},
sync::Mutex,
};
use uuid::Uuid;
const STATUS_DURATION_MS: i64 = 4000;
const RINGING_DURATION_MS: i64 = 6000;
const TIMER_MIN_MS: u64 = 1000;
pub struct AppState {
inner: Mutex<StateInner>,
storage_path: PathBuf,
}
impl AppState {
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,
}
}
pub fn snapshot(&self) -> FrontendState {
trace!("Building snapshot for frontend");
self.apply(|_, _, _| {})
}
pub fn tick(&self) -> FrontendState {
trace!("Processing tick request");
self.apply(|_, _, _| {})
}
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);
})
}
pub fn toggle_alarm(&self, id: String) -> FrontendState {
self.apply(|inner, _now_ms, now_local| {
inner.toggle_alarm(&id, now_local);
})
}
pub fn delete_alarm(&self, id: String) -> FrontendState {
self.apply(|inner, now_ms, _| {
inner.delete_alarm(&id, now_ms);
})
}
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);
})
}
pub fn reset_timer(&self) -> FrontendState {
self.apply(|inner, _, _| inner.reset_timer())
}
pub fn toggle_stopwatch(&self) -> FrontendState {
self.apply(|inner, now_ms, _| inner.toggle_stopwatch(now_ms))
}
pub fn add_lap(&self) -> FrontendState {
self.apply(|inner, now_ms, _| inner.add_lap(now_ms))
}
pub fn reset_stopwatch(&self) -> FrontendState {
self.apply(|inner, _, _| inner.reset_stopwatch())
}
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
}
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)]
struct StateInner {
alarms: Vec<Alarm>,
timer: TimerState,
stopwatch: StopwatchState,
status: Option<StatusMessage>,
play_chime: bool,
alarms_dirty: bool,
}
impl StateInner {
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);
}
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.weekday(), 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.weekday(), 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,
}
}
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);
}
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);
}
}
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);
}
}
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)
);
}
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);
}
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");
}
}
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
);
}
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");
}
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);
}
}
}
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;
}
}
}
}
fn expire_status(&mut self, now_ms: i64) {
if let Some(status) = &self.status {
if status.expires_at <= now_ms {
self.status = None;
}
}
}
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,
}
}
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,
}
}
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,
}
}
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
}
}
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)]
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)]
pub struct ClockState {
pub local_time: String,
pub local_date: String,
pub utc_time: String,
pub utc_date: String,
}
#[derive(Serialize)]
pub struct AlarmSection {
pub items: Vec<AlarmView>,
pub next_summary: String,
}
#[derive(Serialize)]
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)]
pub struct TimerView {
pub display: String,
pub toggle_label: String,
pub status_text: Option<String>,
}
#[derive(Serialize)]
pub struct StopwatchView {
pub display: String,
pub toggle_label: String,
pub laps: Vec<LapView>,
}
#[derive(Serialize)]
pub struct LapView {
pub id: String,
pub label: String,
pub total: String,
pub delta: String,
}
#[derive(Serialize, Deserialize, Clone)]
struct PersistedAlarm {
id: String,
hour: u8,
minute: u8,
label: String,
active: bool,
}
#[derive(Serialize, Deserialize, Default)]
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,
}
}
}
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
}
}
}
fn format_time(hour: u32, minute: u32, second: u32) -> String {
format!("{:02}:{:02}:{:02}", hour, minute, second)
}
fn format_date(weekday: Weekday, month: u32, day: u32) -> String {
let weekday_label = match weekday {
Weekday::Mon => "月",
Weekday::Tue => "火",
Weekday::Wed => "水",
Weekday::Thu => "木",
Weekday::Fri => "金",
Weekday::Sat => "土",
Weekday::Sun => "日",
};
format!("{} {}月{:02}日", weekday_label, month, day)
}
fn format_time_label(hour: u8, minute: u8) -> String {
format!("{:02}:{:02}", hour, minute)
}
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)
}
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)
}
}
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)
}
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()
}
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))
}
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)
}
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
}
}
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()
}
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)
}
}
}