From 22ecbd237ef4fd77cd38dec94d75a79fb83c7e74 Mon Sep 17 00:00:00 2001 From: Egor Kolesnikov Date: Fri, 20 Nov 2026 14:13:20 +0200 Subject: [PATCH 01/12] companion-rpc: weather asks for hours and reads the hourly record Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_01CQSU8Mpie8VxG5uXTwzf2a --- AGENTS.md | 2 +- crates/companion-rpc/src/lib.rs | 53 +++++++++++++--- crates/companion-rpc/tests/rpc-vectors.json | 70 +++++++++++++++++++++ crates/companion-rpc/tests/vectors.rs | 42 ++++++++++++- docs/companion.md | 2 +- 5 files changed, 157 insertions(+), 12 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index caa6336..9085a80 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -129,7 +129,7 @@ again when the spec changes). `make test` runs it. Worked examples: `apps/calend | `reminders` | `0x11` | `reminders` | iOS | open reminders (≤ 20): id, due day and minute, flags, list colour, title | | `reminders.complete` | `0x12` | `reminders` | iOS | marks one done | | `location` | `0x20` | `location` | both | lat/lon in 0.1°, fix age, locality name | -| `weather` | `0x30` | `weather` | both | now and up to 7 days | +| `weather` | `0x30` | `weather` | both | now, the next hours (up to 24: temperature, code, precipitation chance, night) and up to 7 days. Hours need a companion of 2026-11-20 or later: an older one answers `BAD_REQUEST` (Android) or without the hourly record (iOS), so ask again with `hours` 0 and show no hours | | `http.get` | `0x40` | `http:` | both | status, length, body (≤ 2048 B) of an `https://` GET | | `http.request` | `0x41` | `http:` | both | any method with a body (multi-part), the same reply | | `notifications` | `0x50` | `notifications` | Android | the notifications shown now (≤ 10) | diff --git a/crates/companion-rpc/src/lib.rs b/crates/companion-rpc/src/lib.rs index feecd3a..98f1099 100644 --- a/crates/companion-rpc/src/lib.rs +++ b/crates/companion-rpc/src/lib.rs @@ -216,9 +216,14 @@ pub fn location(id: u8) -> Msg { Msg::small(id, method::LOCATION, &[]) } -/// `weather`: the current record, then daily ones for `days` (0-7) days. -pub fn weather(id: u8, days: u8) -> Msg { - Msg::small(id, method::WEATHER, &[days]) +/// `weather`: the current record, the hourly one for the next `hours` (0-24, over counts as 24), then daily ones +/// for `days` (0-7) days. `hours` 0 asks the way every companion understands; a companion from before hours +/// answers `BAD_REQUEST` (Android) or without the hourly record (iOS) to anything else. +pub fn weather(id: u8, days: u8, hours: u8) -> Msg { + if hours == 0 { + return Msg::small(id, method::WEATHER, &[days]); + } + Msg::small(id, method::WEATHER, &[days, hours.min(24)]) } /// `http.get` of an `https://` URL of at most 123 bytes. @@ -349,7 +354,7 @@ pub fn storage_put<'a>(id: u8, key: &str, value: &[u8], out: &'a mut [u8; JOINED #[derive(Clone, Copy, Debug)] pub enum Job<'a> { Web { method: u8, url: &'a str, body: &'a [u8] }, - Weather { days: u8 }, + Weather { days: u8, hours: u8 }, Calendar { from_day: i8, days: u8, limit: u8 }, } @@ -372,10 +377,11 @@ pub fn job_set<'a>(id: u8, job: u8, minutes: u16, what: Job<'_>, target: u8, out out[3] = 0; 5 + http_payload(&mut out[5..], method, url, body)? } - Job::Weather { days } => { + Job::Weather { days, hours } => { out[3] = 1; out[5] = days; - 6 + out[6] = hours.min(24); + if hours == 0 { 6 } else { 7 } } Job::Calendar { from_day, days, limit } => { out[3] = 2; @@ -689,13 +695,24 @@ impl Location { } } -/// `weather` records: the current one first, then one per day. +/// One hour of `Weather::Hours`: `temp` °C, `code` WMO, `precip` probability %, `night` for a moon instead of a sun. +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Hour { + pub temp: i8, + pub code: u8, + pub precip: u8, + pub night: bool, +} + +/// `weather` records: the current one first, then the hourly one if hours were asked, then one per day. #[derive(Clone, Copy, PartialEq, Eq, Debug)] pub enum Weather { /// `temp` 0.1 °C, `code` WMO, `wind` m/s, `humidity` %, `age` minutes since fetched (≤ 255). Now { temp: i16, code: u8, wind: u8, humidity: u8, age: u8 }, /// `day` 0 = today, `min`/`max` °C, `precip` probability %. Day { day: i8, min: i8, max: i8, code: u8, precip: u8 }, + /// `n` (≤ 24) consecutive hours from `hour`, the local hour (0-23) that contains now: read them with `hour(i)`. + Hours { hour: u8, n: u8, data: [u8; 72] }, } impl Weather { @@ -704,6 +721,24 @@ impl Weather { match r.u8()? { 0 => Some(Weather::Now { temp: r.u16()? as i16, code: r.u8()?, wind: r.u8()?, humidity: r.u8()?, age: r.u8()? }), 1 => Some(Weather::Day { day: r.u8()? as i8, min: r.u8()? as i8, max: r.u8()? as i8, code: r.u8()?, precip: r.u8()? }), + 2 => { + let hour = r.u8()?; + let n = (r.0.len() / 3).min(24); // a cut entry is dropped + let mut data = [0; 72]; + data[..n * 3].copy_from_slice(&r.0[..n * 3]); + Some(Weather::Hours { hour, n: n as u8, data }) + } + _ => None, + } + } + + /// Hour `i` of an hourly record, 0 the one that contains now. + pub fn hour(&self, i: usize) -> Option { + match self { + Weather::Hours { n, data, .. } if i < *n as usize => { + let e = &data[i * 3..]; + Some(Hour { temp: e[0] as i8, code: e[1], precip: e[2] & 0x7F, night: e[2] & 0x80 != 0 }) + } _ => None, } } @@ -856,8 +891,8 @@ mod tests { assert!(http_request(1, http::GET, "http://e.com", b"", &mut out).is_none()); assert!(storage_put(1, "k", &[0; JOINED_MAX - 2], &mut out).is_some_and(|p| p.total() == 9)); assert!(storage_put(1, "k", &[0; JOINED_MAX - 1], &mut out).is_none()); - assert!(job_set(1, 0, 30, Job::Weather { days: 3 }, JOB_WIDGET, &mut out).is_none()); - assert!(job_set(1, 4, 30, Job::Weather { days: 3 }, JOB_BLOB, &mut out).is_none()); + assert!(job_set(1, 0, 30, Job::Weather { days: 3, hours: 0 }, JOB_WIDGET, &mut out).is_none()); + assert!(job_set(1, 4, 30, Job::Weather { days: 3, hours: 0 }, JOB_BLOB, &mut out).is_none()); } #[test] diff --git a/crates/companion-rpc/tests/rpc-vectors.json b/crates/companion-rpc/tests/rpc-vectors.json index cf37535..bdcc362 100644 --- a/crates/companion-rpc/tests/rpc-vectors.json +++ b/crates/companion-rpc/tests/rpc-vectors.json @@ -178,6 +178,59 @@ "precip": 40 }, "hex": "0101f9ff0328" + }, + { + "in": { + "kind": "hours", + "hour": 13, + "hours": [ + { + "temp": -3, + "code": 3, + "precip": 20, + "night": false + }, + { + "temp": -4.4, + "code": 71, + "precip": 100, + "night": true + } + ] + }, + "hex": "020dfd0314fc47e4" + } + ], + "weather_args": [ + { + "args": "03", + "days": 3, + "hours": 0 + }, + { + "args": "030c", + "days": 3, + "hours": 12 + }, + { + "args": "0718", + "days": 7, + "hours": 24 + }, + { + "args": "0319", + "bad": true, + "note": "over 24 hours" + }, + { + "args": "030c00", + "bad": true, + "note": "a third byte" + }, + { + "args": "", + "bad": true, + "note": "no days" } ], "http": [ @@ -789,6 +842,18 @@ "cap": "http:example.com" } }, + { + "payload": "011e000101030c", + "job": { + "id": 1, + "minutes": 30, + "kind": 1, + "target": 1, + "spec": "030c", + "cap": "weather" + }, + "note": "the weather with 12 hours" + }, { "payload": "001e00010003", "bad": true, @@ -828,6 +893,11 @@ "payload": "000100", "bad": true, "note": "cut short" + }, + { + "payload": "011e0001010319", + "bad": true, + "note": "weather with 25 hours" } ] } diff --git a/crates/companion-rpc/tests/vectors.rs b/crates/companion-rpc/tests/vectors.rs index 2a40fc8..780c8d5 100644 --- a/crates/companion-rpc/tests/vectors.rs +++ b/crates/companion-rpc/tests/vectors.rs @@ -266,6 +266,22 @@ fn location() { fn weather() { for r in vectors().get("weather").arr() { let i = r.get("in"); + if i.get("kind").str() == "hours" { + let Some(w @ Weather::Hours { hour, n, .. }) = Weather::decode(&r.get("hex").hex()) else { panic!("not hours") }; + let hours = i.get("hours").arr(); + assert_eq!((hour as i64, n as usize), (i.get("hour").int(), hours.len())); + for (k, h) in hours.iter().enumerate() { + let want = Hour { + temp: h.get("temp").num().round() as i8, + code: h.get("code").int() as u8, + precip: h.get("precip").int() as u8, + night: h.get("night").truthy(), + }; + assert_eq!(w.hour(k), Some(want)); + } + assert_eq!(w.hour(hours.len()), None); + continue; + } let want = if i.get("kind").str() == "now" { Weather::Now { temp: (i.get("temp").num() * 10.0).round() as i16, @@ -287,6 +303,30 @@ fn weather() { } } +#[test] +fn weather_args() { + for r in vectors().get("weather_args").arr() { + if r.get("bad").truthy() { + continue; // what the phone refuses; `weather` can't build them except hours over 24, cut below + } + let m = companion_rpc::weather(9, r.get("days").int() as u8, r.get("hours").int() as u8); + assert_eq!(&m[..], &[&hex("52315109")[..], &[0x30], &r.get("args").hex()[..]].concat()[..]); + } + assert_eq!(&companion_rpc::weather(9, 3, 30)[..], &hex("5231510930").iter().copied().chain([3, 24]).collect::>()[..], "hours over 24 are 24"); +} + +#[test] +fn weather_hours_odd_lengths() { + // a cut entry is dropped; more than 24 hours are 24; no entry at all is still a record + let Some(w @ Weather::Hours { n: 1, .. }) = Weather::decode(&[2, 5, 1, 2, 3, 9, 9]) else { panic!() }; + assert_eq!(w.hour(0), Some(Hour { temp: 1, code: 2, precip: 3, night: false })); + let long = [&[2u8, 23][..], &[0x80u8; 90][..]].concat(); + let Some(w @ Weather::Hours { n: 24, hour: 23, .. }) = Weather::decode(&long) else { panic!() }; + assert_eq!(w.hour(23), Some(Hour { temp: -128, code: 0x80, precip: 0, night: true })); + assert!(matches!(Weather::decode(&[2, 7]), Some(Weather::Hours { n: 0, .. }))); + assert_eq!(Weather::decode(&[2]), None); +} + #[test] fn http() { let v = vectors(); @@ -397,7 +437,7 @@ fn jobs() { let (url_len, url) = (spec[1] as usize, &spec[2..2 + spec[1] as usize]); Job::Web { method: spec[0], url: std::str::from_utf8(url).unwrap(), body: &spec[2 + url_len..] } } - 1 => Job::Weather { days: spec[0] }, + 1 => Job::Weather { days: spec[0], hours: spec.get(1).copied().unwrap_or(0) }, _ => Job::Calendar { from_day: spec[0] as i8, days: spec[1], limit: spec[2] }, }; // the vectors' `minutes` is what the phone makes of the payload's; build from the payload's own diff --git a/docs/companion.md b/docs/companion.md index e365975..b1e8698 100644 --- a/docs/companion.md +++ b/docs/companion.md @@ -18,7 +18,7 @@ phone answers `UNAVAILABLE` and `caps` doesn't list it. Request and record layou | `calendar.events` | `calendar` | both | the next 1-7 days of events | | `reminders`, `reminders.complete` | `reminders` | iOS | open reminders; mark one done | | `location` | `location` | both | 0.1° and the town | -| `weather` | `weather` | both | now and up to 7 days | +| `weather` | `weather` | both | now, the next hours (up to 24) and up to 7 days; hours need a companion of 2026-11-20 or later | | `http.get`, `http.request` | `http:` | both | an HTTPS request to that host, body ≤ 2048 B | | `notifications` | `notifications` | Android | the notifications shown now | | `notify` | `notify` | both | a notification on the phone, or "find my phone" | From 0815703971e7cd4e81e7e61e7973b61db3c0f018 Mon Sep 17 00:00:00 2001 From: Egor Kolesnikov Date: Fri, 20 Nov 2026 14:18:29 +0200 Subject: [PATCH 02/12] weather: the model Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_01CQSU8Mpie8VxG5uXTwzf2a --- apps/weather/Cargo.toml | 16 + apps/weather/icon.svg | 25 ++ apps/weather/src/main.rs | 7 + apps/weather/src/model.rs | 533 ++++++++++++++++++++++++++++++++ apps/weather/src/model_tests.rs | 302 ++++++++++++++++++ apps/weather/store.md | 5 + apps/weather/store.toml | 4 + 7 files changed, 892 insertions(+) create mode 100644 apps/weather/Cargo.toml create mode 100644 apps/weather/icon.svg create mode 100644 apps/weather/src/main.rs create mode 100644 apps/weather/src/model.rs create mode 100644 apps/weather/src/model_tests.rs create mode 100644 apps/weather/store.md create mode 100644 apps/weather/store.toml diff --git a/apps/weather/Cargo.toml b/apps/weather/Cargo.toml new file mode 100644 index 0000000..1d5c8a6 --- /dev/null +++ b/apps/weather/Cargo.toml @@ -0,0 +1,16 @@ +[package] +name = "weather" +edition.workspace = true +license.workspace = true +version.workspace = true + +[dependencies] +cmf-wp2-app.workspace = true +companion-rpc.workspace = true + +[dev-dependencies] +wp2-core.workspace = true + +[[bin]] +name = "weather" +bench = false diff --git a/apps/weather/icon.svg b/apps/weather/icon.svg new file mode 100644 index 0000000..8179614 --- /dev/null +++ b/apps/weather/icon.svg @@ -0,0 +1,25 @@ + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/apps/weather/src/main.rs b/apps/weather/src/main.rs new file mode 100644 index 0000000..ab30682 --- /dev/null +++ b/apps/weather/src/main.rs @@ -0,0 +1,7 @@ +#![cfg_attr(target_os = "none", no_std, no_main)] + +#[cfg_attr(not(target_os = "none"), allow(dead_code))] +mod model; + +#[cfg(not(target_os = "none"))] +fn main() {} diff --git a/apps/weather/src/model.rs b/apps/weather/src/model.rs new file mode 100644 index 0000000..b5c7c25 --- /dev/null +++ b/apps/weather/src/model.rs @@ -0,0 +1,533 @@ +//! Weather's state, without `Api`: the two calls to the phone (`location` once for the place, `weather` every 15 +//! minutes while open), what they answered, the cache blob, and the texts and geometry the screens show. +//! +//! Hours and days count from the phone's answer (`at`, wall minutes): a cached answer moves with the clock, so the +//! hours that passed and yesterday drop out instead of being shown as now and today. + +use companion_rpc as rpc; +use core::fmt::Write; + +/// The degree sign after a temperature. +pub const DEG: &str = "°"; +/// A fresh answer this often while the app is open; the phone itself caches for 30 minutes. +pub const PERIOD_MS: u32 = 15 * 60_000; +/// While the phone waits for the user's "allow". +pub const ASK_AGAIN_MS: u32 = 10_000; +/// Hours asked for and shown. +pub const ASK_HOURS: u8 = 12; +pub const HOURS: usize = 24; +pub const DAYS: usize = 7; +const MAGIC: &[u8; 2] = b"W1"; +pub const BLOB_MAX: usize = 2 + 4 + 1 + rpc::TEXT_MAX + 8 + HOURS * 3 + 1 + DAYS * 5; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub enum Status { + /// No answer to this run's request yet. + Waiting, + Ok, + Ask, + Denied, + Unavailable, +} + +/// What a message changed. +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub enum Got { + Nothing, + /// The status: redraw. + Changed, + /// The data: redraw and store. + Saved, +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub enum Icon { + Clear, + Partly, + Cloud, + Fog, + Drizzle, + Rain, + Snow, + Storm, +} + +/// `temp` in 0.1 °C, `wind` m/s, `humidity` %. +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Now { + pub temp: i16, + pub code: u8, + pub wind: u8, + pub humidity: u8, +} + +/// `day` counts from the day of the answer; `min`/`max` °C, `precip` %. +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Day { + pub day: i8, + pub min: i8, + pub max: i8, + pub code: u8, + pub precip: u8, +} + +const NO_HOUR: rpc::Hour = rpc::Hour { temp: 0, code: 0, precip: 0, night: false }; +const NO_DAY: Day = Day { day: 0, min: 0, max: 0, code: 0, precip: 0 }; + +/// One answer of `weather`. +#[derive(Clone, Copy)] +struct Data { + now: Option, + /// Minutes the phone's data was old when it answered. + age: u8, + hour0: u8, + nh: usize, + hours: [rpc::Hour; HOURS], + nd: usize, + /// Sorted by `day`, each day once. + days: [Day; DAYS], +} + +const EMPTY: Data = Data { now: None, age: 0, hour0: 0, nh: 0, hours: [NO_HOUR; HOURS], nd: 0, days: [NO_DAY; DAYS] }; + +pub struct Model { + pub status: Status, + pub now: Option, + /// The last answer had no hours: a companion from before them (or a source without). + pub no_hours: bool, + data: Data, + pending: Data, + /// Wall minutes of the answer `data` is. + at: i32, + place: rpc::Text, + /// `location` answered in this run, with a place or a refusal. + located: bool, + /// Ask with hours; off once the phone called that a bad request. + with_hours: bool, + weather: rpc::Call, + location: rpc::Call, + ids: u8, +} + +/// Days since 1970-01-01 of a civil date. +pub fn days(y: i32, m: u32, d: u32) -> i32 { + let y = if m <= 2 { y - 1 } else { y }; + let (era, yoe) = (y.div_euclid(400), y.rem_euclid(400)); + let doy = (153 * ((m as i32 + 9) % 12) + 2) / 5 + d as i32 - 1; + era * 146_097 + yoe * 365 + yoe / 4 - yoe / 100 + doy - 719_468 +} + +/// Wall-clock minutes since 1970: what `at` and every `wall` argument are. +pub fn wall_min(y: i32, m: u32, d: u32, hour: u32, minute: u32) -> i32 { + days(y, m, d) * 1440 + (hour * 60 + minute) as i32 +} + +pub fn icon(code: u8) -> Icon { + match code { + 0 => Icon::Clear, + 1 | 2 => Icon::Partly, + 45 | 48 => Icon::Fog, + 51..=57 => Icon::Drizzle, + 61..=67 | 80..=82 => Icon::Rain, + 71..=77 | 85 | 86 => Icon::Snow, + 95..=99 => Icon::Storm, + _ => Icon::Cloud, + } +} + +pub fn condition(code: u8) -> &'static str { + match icon(code) { + Icon::Clear => "Clear", + Icon::Partly => "Partly cloudy", + Icon::Cloud => "Cloudy", + Icon::Fog => "Fog", + Icon::Drizzle => "Drizzle", + Icon::Rain => "Rain", + Icon::Snow => "Snow", + Icon::Storm => "Storm", + } +} + +/// 0.1 °C to whole degrees, halves away from zero; −0.4 is 0, never "-0". +pub fn deg(t10: i16) -> i16 { + let t = t10 as i32; + (if t >= 0 { (t + 5) / 10 } else { -((5 - t) / 10) }) as i16 +} + +/// A short text built in place; what doesn't fit is cut at a character. +#[derive(Clone, Copy)] +pub struct Line { + buf: [u8; 64], + len: usize, +} + +impl Line { + pub const fn new() -> Line { + Line { buf: [0; 64], len: 0 } + } + pub fn as_str(&self) -> &str { + core::str::from_utf8(&self.buf[..self.len]).unwrap_or("") + } +} + +impl Write for Line { + fn write_str(&mut self, s: &str) -> core::fmt::Result { + let s = rpc::utf8_cut(s.as_bytes(), self.buf.len() - self.len); + self.buf[self.len..self.len + s.len()].copy_from_slice(s.as_bytes()); + self.len += s.len(); + Ok(()) + } +} + +/// "-3°". +pub fn temp_text(deg: i16) -> Line { + let mut l = Line::new(); + let _ = write!(l, "{deg}{DEG}"); + l +} + +/// The hour of day of entry `i` of hours that start at `first`. +pub fn hour_label(first: u8, i: u8) -> u8 { + ((first as u16 + i as u16) % 24) as u8 +} + +/// Of a day number (days since 1970, a Thursday). +pub fn weekday(abs_day: i32) -> &'static str { + ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"][(abs_day + 3).rem_euclid(7) as usize] +} + +/// Where a day's `min..max` lies on a track `width` wide that spans the week's `lo..hi`: (x, length), the length +/// at least `min_len` and always inside the track. +pub fn bar(min: i8, max: i8, lo: i8, hi: i8, width: i16, min_len: i16) -> (i16, i16) { + if hi <= lo { + return (0, width); + } + let (lo, hi, w) = (lo as i32, hi as i32, width as i32); + let (a, b) = ((min as i32).clamp(lo, hi), (max as i32).clamp(lo, hi)); + let (a, b) = (a.min(b), a.max(b)); + let x = (a - lo) * w / (hi - lo); + let len = ((b - lo) * w / (hi - lo) - x).max(min_len as i32).min(w); + (x.min(w - len) as i16, len as i16) +} + +/// "Updated 50 min ago" once the data is older than the phone's own cache keeps it. +pub fn updated(stale_min: i32) -> Option { + if stale_min <= 45 { + return None; + } + let mut l = Line::new(); + let _ = match stale_min { + ..90 => write!(l, "Updated {stale_min} min ago"), + ..2880 => write!(l, "Updated {} h ago", stale_min / 60), + _ => write!(l, "Updated {} d ago", stale_min / 1440), + }; + Some(l) +} + +struct Rd<'a>(&'a [u8]); + +impl<'a> Rd<'a> { + fn take(&mut self, n: usize) -> Option<&'a [u8]> { + if self.0.len() < n { + return None; + } + let (a, b) = self.0.split_at(n); + self.0 = b; + Some(a) + } + fn u8(&mut self) -> Option { + self.take(1).map(|b| b[0]) + } +} + +impl Model { + pub const fn new() -> Self { + Model { + status: Status::Waiting, + now: None, + no_hours: false, + data: EMPTY, + pending: EMPTY, + at: 0, + place: rpc::Text::EMPTY, + located: false, + with_hours: true, + weather: rpc::Call::new(60_000), + location: rpc::Call::new(60_000), + ids: 0, + } + } + + /// Ask at once (start, `RESUME`, the page shown again); the place only until the phone answered about it. + pub fn ask_now(&mut self, now: u32) { + self.weather.now(now); + if !self.located { + self.location.now(now); + } + } + + /// A request to send now, if one is due. + pub fn poll(&mut self, now: u32) -> Option { + if let Some(id) = self.location.due(now, &mut self.ids) { + return Some(rpc::location(id)); + } + let id = self.weather.due(now, &mut self.ids)?; + self.pending = EMPTY; + Some(rpc::weather(id, DAYS as u8, if self.with_hours { ASK_HOURS } else { 0 })) + } + + /// Ms until [`Model::poll`] has something to do. + pub fn wait(&self, now: u32) -> u32 { + self.weather.wait(now).min(self.location.wait(now)) + } + + /// The phone left the last weather request unanswered. + pub fn silent(&self) -> bool { + self.weather.silent() + } + + /// One message from the phone, at `now` ms and `wall` minutes. + pub fn reply(&mut self, m: &[u8], now: u32, wall: i32) -> Got { + match self.location.take(m) { + rpc::Got::Nothing => {} + rpc::Got::Status(rpc::ASK) => { + self.location.after(now, ASK_AGAIN_MS); + return Got::Nothing; + } + // denied, no fix: the weather shows without a place + rpc::Got::Status(_) => { + self.located = true; + self.location.stop(); + return Got::Nothing; + } + rpc::Got::Record { record, .. } => { + self.located = true; + self.location.stop(); + let Some(l) = rpc::Location::decode(record) else { return Got::Nothing }; + self.place = l.place; + return Got::Saved; + } + } + match self.weather.take(m) { + rpc::Got::Nothing => Got::Nothing, + // a companion from before hours (Android): once more the old way + rpc::Got::Status(rpc::BAD_REQUEST) if self.with_hours => { + self.with_hours = false; + self.weather.now(now); + Got::Nothing + } + rpc::Got::Status(s) => { + self.status = match s { + rpc::ASK => Status::Ask, + rpc::DENIED => Status::Denied, + _ => Status::Unavailable, // OK without records too + }; + self.weather.after(now, if self.status == Status::Ask { ASK_AGAIN_MS } else { PERIOD_MS }); + Got::Changed + } + // any order; one that doesn't decode is left out + rpc::Got::Record { record, last, .. } => { + self.record(record); + if !last { + return Got::Nothing; + } + self.weather.after(now, PERIOD_MS); + if self.pending.now.is_none() { + self.status = Status::Unavailable; + return Got::Changed; + } + self.data = self.pending; + self.now = self.data.now; + self.at = wall; + self.no_hours = self.data.nh == 0; + self.status = Status::Ok; + Got::Saved + } + } + } + + fn record(&mut self, record: &[u8]) { + let p = &mut self.pending; + match rpc::Weather::decode(record) { + Some(rpc::Weather::Now { temp, code, wind, humidity, age }) => { + p.now = Some(Now { temp, code, wind, humidity }); + p.age = age; + } + Some(w @ rpc::Weather::Hours { hour, n, .. }) => { + p.hour0 = hour % 24; + p.nh = (n as usize).min(HOURS); + for i in 0..p.nh { + p.hours[i] = w.hour(i).unwrap_or(NO_HOUR); + } + } + Some(rpc::Weather::Day { day, min, max, code, precip }) => { + Self::add_day(p, Day { day, min, max, code, precip }); + } + None => {} + } + } + + /// Keeps `days` sorted; a day before the answer's, a repeat or an eighth is dropped. + fn add_day(p: &mut Data, d: Day) { + if d.day < 0 || p.nd == DAYS || p.days[..p.nd].iter().any(|x| x.day == d.day) { + return; + } + let at = p.days[..p.nd].iter().position(|x| x.day > d.day).unwrap_or(p.nd); + p.days.copy_within(at..p.nd, at + 1); + p.days[at] = d; + p.nd += 1; + } + + /// The locality, empty when the phone gave none. + pub fn place(&self) -> &str { + self.place.as_str() + } + + /// Minutes since the phone fetched what is shown. + pub fn stale_min(&self, wall: i32) -> i32 { + wall - self.at + self.data.age as i32 + } + + /// Hours of the answer that passed by `wall`. + fn hours_gone(&self, wall: i32) -> usize { + (wall.div_euclid(60) - self.at.div_euclid(60)).clamp(0, self.data.nh as i32) as usize + } + + pub fn hours_len(&self, wall: i32) -> usize { + self.data.nh - self.hours_gone(wall) + } + + /// Row `k` of the hours at `wall`: the hour of day, whether it is the current hour, the hour. + pub fn hour_at(&self, k: usize, wall: i32) -> Option<(u8, bool, rpc::Hour)> { + let i = self.hours_gone(wall) + k; + if i >= self.data.nh { + return None; + } + let is_now = self.at.div_euclid(60) + i as i32 == wall.div_euclid(60); + Some((hour_label(self.data.hour0, i as u8), is_now, self.data.hours[i])) + } + + /// `wall`'s day counted from the answer's. + fn today_index(&self, wall: i32) -> i32 { + wall.div_euclid(1440) - self.at.div_euclid(1440) + } + + fn shown_days(&self, wall: i32) -> &[Day] { + let t = self.today_index(wall); + let d = &self.data.days[..self.data.nd]; + &d[d.iter().position(|x| x.day as i32 >= t).unwrap_or(d.len())..] + } + + pub fn days_len(&self, wall: i32) -> usize { + self.shown_days(wall).len() + } + + /// Row `k` of the days at `wall`: the day's number (days since 1970), whether it is today, the day. + pub fn day_at(&self, k: usize, wall: i32) -> Option<(i32, bool, Day)> { + let d = *self.shown_days(wall).get(k)?; + Some((self.at.div_euclid(1440) + d.day as i32, d.day as i32 == self.today_index(wall), d)) + } + + pub fn today(&self, wall: i32) -> Option { + self.day_at(0, wall).filter(|x| x.1).map(|x| x.2) + } + + /// Lowest min and highest max of the days shown. + pub fn range(&self, wall: i32) -> (i8, i8) { + let d = self.shown_days(wall); + (d.iter().map(|x| x.min).min().unwrap_or(0), d.iter().map(|x| x.max).max().unwrap_or(0)) + } + + /// The widget card: title (≤ 23 bytes) and value (≤ 39 bytes, two lines). + pub fn card(&self, wall: i32) -> (Line, Line) { + let (mut t, mut v) = (Line::new(), Line::new()); + let place = rpc::utf8_cut(self.place.as_str().as_bytes(), 23); + let _ = t.write_str(if place.is_empty() { "Weather" } else { place }); + let Some(n) = self.now else { + let _ = v.write_str("Open the app"); + return (t, v); + }; + let _ = write!(v, "{}{DEG} {}", deg(n.temp), condition(n.code)); + if let Some(d) = self.today(wall) { + let _ = write!(v, "\nH {}{DEG} L {}{DEG}", d.max, d.min); + } + (t, v) + } + + /// The cache blob; 0 before the first answer. + pub fn save(&self, out: &mut [u8]) -> usize { + let (Some(n), d) = (self.data.now, &self.data) else { return 0 }; + let place = self.place.as_str().as_bytes(); + let len = 2 + 4 + 1 + place.len() + 8 + d.nh * 3 + 1 + d.nd * 5; + if out.len() < len { + return 0; + } + let mut k = 0; + let mut put = |b: &[u8]| { + out[k..k + b.len()].copy_from_slice(b); + k += b.len(); + }; + put(MAGIC); + put(&self.at.to_le_bytes()); + put(&[place.len() as u8]); + put(place); + put(&n.temp.to_le_bytes()); + put(&[n.code, n.wind, n.humidity, d.age, d.hour0, d.nh as u8]); + for h in &d.hours[..d.nh] { + put(&[h.temp as u8, h.code, h.precip | (h.night as u8) << 7]); + } + put(&[d.nd as u8]); + for x in &d.days[..d.nd] { + put(&[x.day as u8, x.min as u8, x.max as u8, x.code, x.precip]); + } + len + } + + /// Reads a blob of [`Model::save`]; anything else (another version, cut short, counts out of range) is left + /// alone and the model stays as it was. + pub fn load(&mut self, b: &[u8]) -> bool { + let Some((at, place, data)) = Self::parse(b) else { return false }; + (self.at, self.place, self.data, self.now) = (at, place, data, data.now); + self.no_hours = false; // not known until the phone answers + true + } + + fn parse(b: &[u8]) -> Option<(i32, rpc::Text, Data)> { + let mut r = Rd(b); + if r.take(2)? != MAGIC { + return None; + } + let at = i32::from_le_bytes(r.take(4)?.try_into().ok()?); + let n = r.u8()? as usize; + let place = core::str::from_utf8(r.take(n)?).ok()?; + let mut d = EMPTY; + let temp = i16::from_le_bytes(r.take(2)?.try_into().ok()?); + d.now = Some(Now { temp, code: r.u8()?, wind: r.u8()?, humidity: r.u8()? }); + d.age = r.u8()?; + d.hour0 = r.u8()?; + d.nh = r.u8()? as usize; + if d.hour0 > 23 || d.nh > HOURS { + return None; + } + for i in 0..d.nh { + let e = r.take(3)?; + d.hours[i] = rpc::Hour { temp: e[0] as i8, code: e[1], precip: e[2] & 0x7F, night: e[2] & 0x80 != 0 }; + } + let nd = r.u8()? as usize; + if nd > DAYS { + return None; + } + for _ in 0..nd { + let e = r.take(5)?; + Self::add_day(&mut d, Day { day: e[0] as i8, min: e[1] as i8, max: e[2] as i8, code: e[3], precip: e[4] }); + } + if !r.0.is_empty() || d.nd != nd { + return None; + } + Some((at, rpc::Text::new(place.as_bytes()), d)) + } +} + +#[cfg(test)] +#[path = "model_tests.rs"] +mod tests; diff --git a/apps/weather/src/model_tests.rs b/apps/weather/src/model_tests.rs new file mode 100644 index 0000000..174d96f --- /dev/null +++ b/apps/weather/src/model_tests.rs @@ -0,0 +1,302 @@ +extern crate std; +use super::*; +use std::vec::Vec; + +// 2026-11-20 (a Friday) 13:20 +const WALL: i32 = 20_777 * 1440 + 13 * 60 + 20; + +fn msg(id: u8, status: u8, index: u8, total: u8, record: &[u8]) -> Vec { + [&b"R1A"[..], &[id, status, index, total], record].concat() +} + +/// The id of the request the model sends now. +fn sent(m: &mut Model, now: u32) -> Vec> { + let mut out = Vec::new(); + while let Some(q) = m.poll(now) { + out.push(q.to_vec()); + } + out +} + +const NOW: [u8; 7] = [0, 0xDE, 0xFF, 71, 5, 88, 10]; // -3.4°, snow, 5 m/s, 88 %, 10 min old +fn hours(first: u8, n: usize) -> Vec { + let mut r = Vec::from([2, first]); + for i in 0..n { + r.extend([(i as i8 - 4) as u8, 3, if i >= 6 { 0x80 | 40 } else { 20 }]); + } + r +} +fn day(d: i8, min: i8, max: i8) -> [u8; 6] { + [1, d as u8, min as u8, max as u8, 3, 40] +} + +/// A model that asked and got `recs` as its weather, at WALL; the place refused. +fn answered(recs: &[Vec]) -> Model { + answered_in(recs, "") +} + +fn answered_in(recs: &[Vec], place: &str) -> Model { + let mut m = Model::new(); + m.ask_now(0); + let q = sent(&mut m, 0); + let l = q.iter().find(|q| q[4] == 0x20).expect("asks the place"); + if place.is_empty() { + m.reply(&msg(l[3], rpc::DENIED, 0, 0, &[]), 50, WALL); + } else { + m.reply(&msg(l[3], 0, 0, 1, &[&[0u8; 6][..], place.as_bytes()].concat()), 50, WALL); + } + let weather = q.iter().find(|q| q[4] == 0x30).expect("asks the weather"); + for (i, r) in recs.iter().enumerate() { + m.reply(&msg(weather[3], 0, i as u8, recs.len() as u8, r), 100, WALL); + } + m +} + +fn week() -> Vec> { + let mut v = Vec::from([NOW.to_vec(), hours(13, 12)]); + for d in 0..7 { + v.push(day(d, -5 - d, 1 - d).to_vec()); + } + v +} + +#[test] +fn asks_location_and_weather_with_hours() { + let mut m = Model::new(); + m.ask_now(0); + let q = sent(&mut m, 0); + assert_eq!(q.len(), 2); + assert!(q.iter().any(|q| q[4] == 0x20 && q.len() == 5), "location"); + assert!(q.iter().any(|q| q[4] == 0x30 && q[5..] == [7, 12]), "7 days, 12 hours"); + assert_eq!(m.status, Status::Waiting); +} + +#[test] +fn an_answer_fills_now_hours_and_days() { + let m = answered(&week()); + assert_eq!(m.status, Status::Ok); + assert_eq!(m.now, Some(Now { temp: -34, code: 71, wind: 5, humidity: 88 })); + assert_eq!(m.hours_len(WALL), 12); + let (hod, is_now, h) = m.hour_at(0, WALL).unwrap(); + assert_eq!((hod, is_now, h.temp, h.night), (13, true, -4, false)); + let (hod, is_now, h) = m.hour_at(11, WALL).unwrap(); + assert_eq!((hod, is_now, h.temp, h.night, h.precip), (0, false, 7, true, 40), "13 + 11 is midnight"); + assert_eq!(m.hour_at(12, WALL), None); + assert_eq!(m.days_len(WALL), 7); + assert_eq!(m.day_at(0, WALL).map(|(d, today, x)| (d, today, x.min, x.max)), Some((20_777, true, -5, 1))); + assert_eq!(m.day_at(6, WALL).map(|(d, today, x)| (d, today, x.min)), Some((20_783, false, -11))); + assert_eq!(m.today(WALL).map(|d| (d.min, d.max)), Some((-5, 1))); + assert_eq!(m.range(WALL), (-11, 1)); + assert_eq!(m.stale_min(WALL), 10); + assert!(!m.no_hours); +} + +#[test] +fn records_in_any_order_and_days_sorted() { + let mut v = week(); + v.reverse(); + let m = answered(&v); + assert_eq!(m.day_at(0, WALL).map(|(d, ..)| d), Some(20_777)); + assert_eq!(m.day_at(6, WALL).map(|(d, ..)| d), Some(20_783)); + assert!(m.now.is_some()); +} + +#[test] +fn a_cache_moves_with_the_clock() { + let m = answered(&week()); + // three hours later: the hours that passed are gone, the labels stay absolute + let later = WALL + 3 * 60; + assert_eq!(m.hours_len(later), 9); + assert_eq!(m.hour_at(0, later).map(|(h, n, x)| (h, n, x.temp)), Some((16, true, -1))); + assert_eq!(m.stale_min(later), 190); + // two days later: today is the third day of the answer; the hours are all past + let later = WALL + 2 * 1440; + assert_eq!(m.hours_len(later), 0); + assert_eq!(m.days_len(later), 5); + assert_eq!(m.day_at(0, later).map(|(d, t, x)| (d, t, x.min)), Some((20_779, true, -7))); + assert_eq!(m.today(later).map(|d| d.max), Some(-1)); + // a clock set back: nothing before the answer's first hour + assert_eq!(m.hours_len(WALL - 600), 12); + // ten days later: no day left + assert_eq!((m.days_len(WALL + 10 * 1440), m.today(WALL + 10 * 1440)), (0, None)); +} + +#[test] +fn fewer_hours_than_asked_or_none() { + let m = answered(&[NOW.to_vec(), hours(22, 5), day(0, 1, 2).to_vec()]); + assert_eq!(m.hours_len(WALL), 5); + assert_eq!((0..5).map(|k| m.hour_at(k, WALL).unwrap().0).collect::>(), [22, 23, 0, 1, 2]); + assert_eq!(m.hour_at(5, WALL), None); + // an hourly record without entries, and no hourly record (an iPhone with an old companion) + let m = answered(&[NOW.to_vec(), hours(13, 0)]); + assert_eq!((m.hours_len(WALL), m.hour_at(0, WALL), m.no_hours), (0, None, true)); + let m = answered(&[NOW.to_vec(), day(0, 1, 2).to_vec()]); + assert_eq!((m.hours_len(WALL), m.no_hours, m.status), (0, true, Status::Ok)); +} + +#[test] +fn an_old_android_companion_is_asked_again_without_hours() { + let mut m = Model::new(); + m.ask_now(0); + let q = sent(&mut m, 0); + let w = q.iter().find(|q| q[4] == 0x30).unwrap(); + assert_eq!(m.reply(&msg(w[3], rpc::BAD_REQUEST, 0, 0, &[]), 10, WALL), Got::Nothing); + let q = sent(&mut m, 10); + assert_eq!(q.len(), 1); + assert_eq!(q[0][4..], [0x30, 7], "days only"); + m.reply(&msg(q[0][3], 0, 0, 2, &NOW), 20, WALL); + assert_eq!(m.reply(&msg(q[0][3], 0, 1, 2, &day(0, 1, 2)), 20, WALL), Got::Saved); + assert!(m.no_hours && m.status == Status::Ok); + // and BAD_REQUEST to that is not asked a third time at once + m.ask_now(30); + let q = sent(&mut m, 30); + let w = q.iter().find(|q| q[4] == 0x30).unwrap(); + assert_eq!(w[5..], [7]); + assert_eq!(m.reply(&msg(w[3], rpc::BAD_REQUEST, 0, 0, &[]), 40, WALL), Got::Changed); + assert!(sent(&mut m, 40).iter().all(|q| q[4] != 0x30)); +} + +#[test] +fn statuses_keep_the_cache() { + let mut m = answered(&week()); + for (s, want, again) in [ + (rpc::ASK, Status::Ask, ASK_AGAIN_MS), + (rpc::DENIED, Status::Denied, PERIOD_MS), + (rpc::UNAVAILABLE, Status::Unavailable, PERIOD_MS), + ] { + m.ask_now(1000); + let q = sent(&mut m, 1000); + let w = q.iter().find(|q| q[4] == 0x30).unwrap(); + assert_eq!(m.reply(&msg(w[3], s, 0, 0, &[]), 1100, WALL), Got::Changed); + assert_eq!((m.status, m.wait(1100)), (want, again)); + assert!(m.now.is_some() && m.days_len(WALL) == 7, "the last answer stays"); + } + // an answer without the current record is no answer + m.ask_now(2000); + let q = sent(&mut m, 2000); + let w = q.iter().find(|q| q[4] == 0x30).unwrap(); + m.reply(&msg(w[3], 0, 0, 1, &day(0, 9, 9)), 2100, WALL); + assert_eq!(m.status, Status::Unavailable); + assert_eq!(m.today(WALL).map(|d| d.max), Some(1)); +} + +#[test] +fn the_place_comes_from_location_and_its_refusal_is_not_an_error() { + let mut m = Model::new(); + m.ask_now(0); + let q = sent(&mut m, 0); + let l = q.iter().find(|q| q[4] == 0x20).unwrap(); + let rec = [&[0x2Cu8, 2, 0x78, 1, 5, 0][..], "Москва".as_bytes()].concat(); + assert_eq!(m.reply(&msg(l[3], 0, 0, 1, &rec), 10, WALL), Got::Saved); + assert_eq!(m.place(), "Москва"); + let mut m = Model::new(); + m.ask_now(0); + let q = sent(&mut m, 0); + let l = q.iter().find(|q| q[4] == 0x20).unwrap(); + assert_eq!(m.reply(&msg(l[3], rpc::DENIED, 0, 0, &[]), 10, WALL), Got::Nothing); + assert_eq!((m.place(), m.status), ("", Status::Waiting)); + // answered once, it is not asked again while the app runs + m.ask_now(100); + assert!(sent(&mut m, 100).iter().all(|q| q[4] != 0x20)); +} + +#[test] +fn save_and_load() { + let m = answered_in(&week(), "Berlin"); + let mut blob = [0u8; BLOB_MAX]; + let n = m.save(&mut blob); + assert!(n > 0 && n <= BLOB_MAX); + let mut back = Model::new(); + assert!(back.load(&blob[..n])); + assert_eq!(back.place(), "Berlin"); + assert_eq!(back.now, m.now); + assert_eq!(back.status, Status::Waiting, "a cache is not an answer"); + assert_eq!((back.hours_len(WALL), back.days_len(WALL), back.stale_min(WALL)), (12, 7, 10)); + assert_eq!(back.hour_at(11, WALL), m.hour_at(11, WALL)); + assert_eq!(back.day_at(6, WALL), m.day_at(6, WALL)); + // another version, cut short, empty, garbage counts: ignored, the model stays empty + let mut other = blob; + other[1] = b'9'; + for bad in [&other[..n], &blob[..n - 1], &blob[..3], &[][..]] { + let mut x = Model::new(); + assert!(!x.load(bad)); + assert!(x.now.is_none() && x.days_len(WALL) == 0 && x.hours_len(WALL) == 0 && x.place().is_empty()); + } + // nothing to save before the first answer + assert_eq!(Model::new().save(&mut blob), 0); +} + +#[test] +fn temperatures() { + assert_eq!([deg(-34), deg(-35), deg(-4), deg(4), deg(5), deg(0), deg(-5), deg(216)], [-3, -4, 0, 0, 1, 0, -1, 22]); + assert_eq!(temp_text(0).as_str(), "0°"); + assert_eq!(temp_text(-12).as_str(), "-12°"); + assert_eq!(temp_text(deg(-4)).as_str(), "0°", "never -0"); +} + +#[test] +fn hour_labels_wrap_at_midnight() { + assert_eq!([hour_label(22, 0), hour_label(22, 1), hour_label(22, 2), hour_label(22, 3)], [22, 23, 0, 1]); + assert_eq!(hour_label(23, 23), 22); +} + +#[test] +fn weekdays() { + assert_eq!(weekday(20_777), "Fri"); + assert_eq!(weekday(20_779), "Sun"); + assert_eq!(weekday(20_780), "Mon"); + assert_eq!(wall_min(2026, 11, 20, 13, 20), WALL); +} + +#[test] +fn icons_and_names() { + for (code, i, name) in [ + (0, Icon::Clear, "Clear"), (1, Icon::Partly, "Partly cloudy"), (2, Icon::Partly, "Partly cloudy"), + (3, Icon::Cloud, "Cloudy"), (45, Icon::Fog, "Fog"), (48, Icon::Fog, "Fog"), (55, Icon::Drizzle, "Drizzle"), + (63, Icon::Rain, "Rain"), (81, Icon::Rain, "Rain"), (73, Icon::Snow, "Snow"), (86, Icon::Snow, "Snow"), + (95, Icon::Storm, "Storm"), (99, Icon::Storm, "Storm"), (200, Icon::Cloud, "Cloudy"), + ] { + assert_eq!((icon(code), condition(code)), (i, name), "{code}"); + } +} + +#[test] +fn bars_stay_in_the_track() { + // (x, length) of a day's range within the week's, on a track 100 wide, at least 12 long + assert_eq!(bar(-9, 1, -9, 1, 100, 12), (0, 100)); + assert_eq!(bar(-5, 1, -9, 1, 100, 12), (40, 60)); + assert_eq!(bar(3, 3, 3, 3, 100, 12), (0, 100), "a week of one temperature"); + assert_eq!(bar(1, 1, -9, 1, 100, 12), (88, 12), "a point at the warm end keeps its length inside"); + assert_eq!(bar(-9, -9, -9, 1, 100, 12), (0, 12)); + for (min, max) in [(-128i8, 127i8), (5, -5), (0, 0)] { + let (x, len) = bar(min, max, -20, 20, 100, 12); + assert!(x >= 0 && len >= 12 && x + len <= 100, "{min}..{max}: {x}+{len}"); + } +} + +#[test] +fn updated_line() { + assert_eq!(updated(10).map(|l| l.as_str().len()), None); + assert_eq!(updated(45).map(|_| ()), None); + assert_eq!(updated(46).unwrap().as_str(), "Updated 46 min ago"); + assert_eq!(updated(190).unwrap().as_str(), "Updated 3 h ago"); + assert_eq!(updated(3 * 1440 + 5).unwrap().as_str(), "Updated 3 d ago"); + assert_eq!(updated(-500).map(|_| ()), None, "a clock set back"); +} + +#[test] +fn the_card() { + let m = Model::new(); + let (t, v) = m.card(WALL); + assert_eq!((t.as_str(), v.as_str()), ("Weather", "Open the app")); + let m = answered(&week()); + let (t, v) = m.card(WALL); + assert_eq!((t.as_str(), v.as_str()), ("Weather", "-3° Snow\nH 1° L -5°")); + let m = answered_in(&week(), "Санкт-Петербург и область"); + let (t, v) = m.card(WALL); + assert!(t.as_str().len() <= 23 && t.as_str().starts_with("Санкт-Петер"), "{}", t.as_str()); + assert!(v.as_str().len() <= 39); + // no day for today: the first line alone + let m = answered(&[NOW.to_vec()]); + assert_eq!(m.card(WALL).1.as_str(), "-3° Snow"); +} diff --git a/apps/weather/store.md b/apps/weather/store.md new file mode 100644 index 0000000..e5c0894 --- /dev/null +++ b/apps/weather/store.md @@ -0,0 +1,5 @@ +What weather does. + +## Requirements + +The [patched firmware](/firmware) and the [App Loader](/firmware). diff --git a/apps/weather/store.toml b/apps/weather/store.toml new file mode 100644 index 0000000..5ec3213 --- /dev/null +++ b/apps/weather/store.toml @@ -0,0 +1,4 @@ +name = "weather" +summary = "" +version = "0.1.0" +author = "" From 50fd6192e5dda24a4dbc9553d141078ec35f7160 Mon Sep 17 00:00:00 2001 From: Egor Kolesnikov Date: Fri, 20 Nov 2026 14:22:57 +0200 Subject: [PATCH 03/12] weather: the screens and the loop Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_01CQSU8Mpie8VxG5uXTwzf2a --- apps/weather/src/main.rs | 184 ++++++++++++++++ apps/weather/src/screen.rs | 359 +++++++++++++++++++++++++++++++ apps/weather/src/screen_tests.rs | 201 +++++++++++++++++ 3 files changed, 744 insertions(+) create mode 100644 apps/weather/src/screen.rs create mode 100644 apps/weather/src/screen_tests.rs diff --git a/apps/weather/src/main.rs b/apps/weather/src/main.rs index ab30682..7a02709 100644 --- a/apps/weather/src/main.rs +++ b/apps/weather/src/main.rs @@ -1,7 +1,191 @@ +//! weather: now, the next hours and the next days, from FMC Companion (`location` for the place, `weather`). +//! +//! - The menu app is three pages in the stock pager (`screen::pages_view`): now, hours, days. The crown or a +//! swipe pages; the hours and days scroll first. BUTTON exits. +//! - The page next to the watch face (`app_features!(PAGE)`) is the now screen alone (`screen::face_view`). +//! - The card left of the face (`WIDGET`): the place, the temperature with the condition, high and low; written +//! whenever it changes while the app runs. +//! +//! The weather comes from the phone at start and every 15 minutes while shown, and is kept in the app's storage so +//! it opens at once without the phone (`model.rs`). #![cfg_attr(target_os = "none", no_std, no_main)] #[cfg_attr(not(target_os = "none"), allow(dead_code))] mod model; +#[cfg_attr(not(target_os = "none"), allow(dead_code))] +mod screen; #[cfg(not(target_os = "none"))] fn main() {} + +#[cfg(target_os = "none")] +mod device { + use crate::model::{BLOB_MAX, Got, Line, Model, wall_min}; + use crate::screen::{self, View}; + use cmf_wp2_app::lv::{Batch, Lv, ROOT}; + use cmf_wp2_app::{Api, BUTTON, MESSAGE, MSG_MAX, PAUSE, RESUME}; + + cmf_wp2_app::entry!(main); + cmf_wp2_app::app_icon!(); + cmf_wp2_app::app_features!(cmf_wp2_app::WIDGET | cmf_wp2_app::PAGE); + + /// How often to look at the clock: a new hour moves the hours, the "Updated" line ages. + const TICK_MS: u32 = 60_000; + /// On the page next to the face, coming back asks the phone only when the copy is older than this. + const FRESH_MIN: i32 = 30; + + static mut STORE: [u8; BLOB_MAX] = [0; BLOB_MAX]; + static mut MODEL: Model = Model::new(); + + fn wall(api: &Api) -> i32 { + api.time().map_or(0, |t| wall_min(t.year as i32, t.month as u32, t.day as u32, t.hour as u32, t.minute as u32)) + } + + struct App { + api: &'static Api, + lv: Lv, + b: Batch, + model: &'static mut Model, + view: View, + /// The pager's page, kept over a redraw. + page: usize, + on_page: bool, + /// What the screen shows depends on, besides the data. + shown: (i32, bool, i32), + card: (Line, Line), + } + + impl App { + /// The hour, whether the phone is silent, and the age once it is worth a line. + fn key(&self, w: i32) -> (i32, bool, i32) { + let stale = self.model.stale_min(w); + (w.div_euclid(60), self.model.silent(), if self.model.now.is_some() && stale > 45 { stale / 10 } else { 0 }) + } + + fn draw(&mut self) { + let (lv, w) = (self.lv, wall(self.api)); + let mut flush = |b: &mut Batch| b.submit(&lv); + let r = screen::leave(&mut self.b, self.view.root) + .and_then(|_| { + if self.on_page { + screen::face_view(&mut self.b, &mut flush, self.model, w) + } else { + screen::pages_view(&mut self.b, &mut flush, self.model, w, self.page) + } + }) + .and_then(|v| self.b.submit(&lv).map(|_| v)); + if let Ok(v) = r { + self.view = v; + } + self.shown = self.key(w); + } + + fn save(&mut self) { + let blob = unsafe { &mut *core::ptr::addr_of_mut!(STORE) }; + let n = self.model.save(blob); + if n > 0 { + self.api.save(&blob[..n]); // on change: the app can end without notice + } + } + + /// The card, when its text changes. + fn card(&mut self) { + let (t, v) = self.model.card(wall(self.api)); + if t.as_str() != self.card.0.as_str() || v.as_str() != self.card.1.as_str() { + self.api.widget(t.as_str(), v.as_str()); + self.card = (t, v); + } + } + + fn poll(&mut self) { + let now = self.api.now(); + while let Some(req) = self.model.poll(now) { + if self.api.send(&req) == -11 { + break; // outbox full: the retry timer sends it again + } // -107 with no phone: the retry timer covers it too + } + } + + fn message(&mut self, m: &[u8]) { + let got = self.model.reply(m, self.api.now(), wall(self.api)); + if got == Got::Saved { + self.save(); + } + if got != Got::Nothing { + self.draw(); + self.card(); + } + } + + /// The clock moved, or the phone went silent. + fn tick(&mut self) { + if self.key(wall(self.api)) != self.shown { + self.draw(); + self.card(); + } + } + } + + fn main(api: &'static Api) -> i32 { + let Some(lv) = api.lv() else { return -95 }; // loader older than ABI 1.2 + let Some(mut b) = Batch::new() else { return -1 }; + if screen::fonts(&mut b).and_then(|_| b.submit(&lv)).is_err() { + return 1; + } + if screen::theme(&mut b).and_then(|_| b.submit(&lv)).is_err() { + return 2; + } + let model = unsafe { &mut *core::ptr::addr_of_mut!(MODEL) }; + let blob = unsafe { &mut *core::ptr::addr_of_mut!(STORE) }; + let n = api.load(blob); + if n > 0 { + model.load(&blob[..n as usize]); + } + model.ask_now(api.now()); + let view = View { root: ROOT, pager: None }; + let mut app = + App { api, lv, b, model, view, page: 0, on_page: api.on_page(), shown: (0, false, 0), card: (Line::new(), Line::new()) }; + app.draw(); + app.card(); + let mut paused = false; + let mut msg = [0u8; MSG_MAX]; + loop { + if !paused { + app.poll(); + } + let wait = if paused { u32::MAX } else { app.model.wait(api.now()).min(TICK_MS) }; + let e = api.event(wait); + if !paused { + app.tick(); + } + let Some(e) = e else { continue }; + match e.kind { + BUTTON => break, + PAUSE => paused = true, + RESUME => { + paused = false; + if app.model.now.is_none() || app.model.stale_min(wall(api)) > FRESH_MIN { + app.model.ask_now(api.now()); + } + app.tick(); + } + MESSAGE => { + while let Some(m) = api.recv(&mut msg) { + app.message(m); + } + } + _ if !paused => { + // the pager settled on a page: move its dots + if let Some(p) = app.view.pager.as_mut() { + if let Ok(Some(i)) = p.event(&mut app.b, &e) { + app.page = i; + let _ = app.b.submit(&lv); + } + } + } + _ => {} + } + } + 0 + } +} diff --git a/apps/weather/src/screen.rs b/apps/weather/src/screen.rs new file mode 100644 index 0000000..95b1450 --- /dev/null +++ b/apps/weather/src/screen.rs @@ -0,0 +1,359 @@ +//! The screens, from the watch's own LVGL parts and stock fonts (`cmf_wp2_app::stock`): +//! - in the menu app, three pages in the stock vertical pager: now (place, temperature, condition, high and low, +//! wind and humidity), the next hours, the next days with a range bar each; +//! - on the page next to the watch face, the now screen alone; +//! - before the first answer, one line saying what is missing. +//! +//! LVGL here has no images, so a condition icon is two to four plain rounded objects: a disc for the sun, a pill +//! and a bump for a cloud, short pills for rain. Each screen is one root under `ROOT`; leaving it deletes the root +//! and everything in it. + +use crate::model::{self, Icon, Line, Model, Status}; +use cmf_wp2_app::lv::*; +use cmf_wp2_app::stock::{self, BLACK, CIRCLE, GREY, Pager, SCREEN, WHITE}; +use core::fmt::Write; + +/// Font slots: the system font is 0. +pub const F24: u8 = 1; +pub const F48: u8 = 2; + +const SUN: i32 = 0xFE60; // #FFCC00 +const MOON: i32 = 0xE73D; // #E5E5EA +const CLOUD: i32 = 0xD69A; // #D1D1D6 +const STORM: i32 = 0x8C72; // #8E8E93 +const WET: i32 = 0x669F; // #64D2FF +const TRACK: i32 = 0x39C7; // #3A3A3C + +const MSG_W: i32 = 300; +/// The first row of the hours and days pages, and their rows' height. +const ROWS_Y: i32 = 96; +const HOUR_H: i32 = 58; +const DAY_H: i32 = 54; +/// The range bar's track. +const BAR_W: i16 = 70; +const BAR_H: i16 = 8; + +// bytes one row with its icon can take: flush first when fewer are left +const GROUP: usize = 760; + +pub type Flush<'a> = dyn FnMut(&mut Batch) -> Result<(), LvError> + 'a; + +fn room(b: &mut Batch, flush: &mut Flush) -> Result<(), LvError> { + if b.bytes().len() + GROUP > BUF { flush(b) } else { Ok(()) } +} + +/// The fonts, in a batch of their own. +pub fn fonts(b: &mut Batch) -> Result<(), LvError> { + stock::font(b)?; + b.font(F24, StockFont::F24M)?; + b.font(F48, StockFont::F48M) +} + +/// Black behind everything, the system font and white text: first, once. +pub fn theme(b: &mut Batch) -> Result<(), LvError> { + stock::theme(b)?; + b.style(ROOT, Prop::BgColor, 0, BLACK) +} + +/// What to say instead of the weather while there is none to show. +pub fn message(m: &Model) -> &'static str { + match m.status { + Status::Ask => "Allow Weather in FMC Companion on your phone", + Status::Denied => "Turn Weather on in FMC Companion", + Status::Unavailable => "No weather right now", + _ if m.silent() => "Open FMC Companion on your phone", + _ => "Asking your phone...", + } +} + +/// A line under the weather from the cache, when the phone isn't giving a fresh one. +pub fn note(m: &Model, wall: i32) -> Option { + let fixed = match m.status { + Status::Ask => Some("Allow Weather in FMC Companion"), + Status::Denied => Some("Weather is off in FMC Companion"), + _ if m.silent() => Some("Phone not reachable"), + _ => None, + }; + match fixed { + Some(t) => { + let mut l = Line::new(); + let _ = l.write_str(t); + Some(l) + } + None => model::updated(m.stale_min(wall)), + } +} + +/// The range bar's colour for a day, by the middle of its range: cold blue to hot red. +pub fn bar_color(min: i8, max: i8) -> i32 { + match (min as i32 + max as i32).div_euclid(2) { + ..0 => 0x351F, // #30A0FF + ..10 => 0x5EDC, // #5AD8E6 + ..18 => 0x9F09, // #9BE04A + ..25 => SUN, + ..32 => 0xFCA0, // #FF9500 + _ => 0xFA27, // #FF453A + } +} + +fn plain(b: &mut Batch, o: Obj) -> Result<(), LvError> { + for p in [Prop::PadTop, Prop::PadBottom, Prop::PadLeft, Prop::PadRight, Prop::BorderWidth, Prop::BgOpa, Prop::Radius] { + b.style(o, p, 0, 0)?; + } + Ok(()) +} + +/// A full-screen root, hidden until the screen is built. +fn root(b: &mut Batch) -> Result { + let r = b.create(Class::Obj, ROOT)?; + b.size(r, SCREEN, SCREEN)?; + plain(b, r)?; + b.flags(r, &[Flag::Hidden], &[Flag::Scrollable])?; + Ok(r) +} + +/// A label `w` wide whose centre is `cx` right of the parent's and whose top is at `y`; `align` 1 left, 2 centre, +/// 3 right. +fn label(b: &mut Batch, parent: Obj, text: &str, w: i32, cx: i32, y: i32, align: i32) -> Result { + let l = b.create(Class::Label, parent)?; + b.size(l, w, CONTENT)?; + b.style(l, Prop::TextAlign, 0, align)?; + b.text(l, text)?; + b.align(l, Align::TopMid, cx as i16, y as i16)?; + Ok(l) +} + +fn small(b: &mut Batch, l: Obj, color: i32) -> Result<(), LvError> { + b.style(l, Prop::TextFont, 0, F24 as i32)?; + b.style(l, Prop::TextColor, 0, color) +} + +/// A filled rounded shape, centre `cx` right of the parent's, top at `y`. +fn shape(b: &mut Batch, parent: Obj, cx: i32, y: i32, w: i32, h: i32, color: i32) -> Result { + let o = b.create(Class::Obj, parent)?; + b.size(o, w, h)?; + b.style(o, Prop::Radius, 0, CIRCLE)?; + b.style(o, Prop::BorderWidth, 0, 0)?; + b.style(o, Prop::BgColor, 0, color)?; + b.style(o, Prop::BgOpa, 0, 255)?; + b.flags(o, &[], &[Flag::Clickable, Flag::Scrollable])?; + b.align(o, Align::TopMid, cx as i16, y as i16)?; + Ok(o) +} + +/// A condition icon in a box 48 wide and 40 high at scale `s`/40, centred at `cx`, top at `y`: at most four +/// objects. It sits on black: the moon's bite is a black disc. +pub fn icon(b: &mut Batch, parent: Obj, kind: Icon, night: bool, cx: i32, y: i32, s: i32) -> Result<(), LvError> { + let u = |n: i32| n * s / 40; + let disc = |b: &mut Batch, dx: i32, dy: i32, d: i32, color: i32| shape(b, parent, cx + u(dx), y + u(dy), u(d), u(d), color).map(|_| ()); + // a cloud whose top is `dy` down the box + let cloud = |b: &mut Batch, dy: i32, color: i32| -> Result<(), LvError> { + shape(b, parent, cx - u(5), y + u(dy), u(22), u(22), color)?; + shape(b, parent, cx, y + u(dy + 10), u(40), u(18), color).map(|_| ()) + }; + // what falls from a cloud at the top of the box + let fall = |b: &mut Batch, w: i32, h: i32, color: i32| -> Result<(), LvError> { + shape(b, parent, cx - u(8), y + u(31), u(w), u(h), color)?; + shape(b, parent, cx + u(8), y + u(31), u(w), u(h), color).map(|_| ()) + }; + match kind { + Icon::Clear if night => { + disc(b, 0, 7, 26, MOON)?; + disc(b, 8, 3, 22, BLACK) + } + Icon::Clear => disc(b, 0, 6, 28, SUN), + Icon::Partly => { + disc(b, 10, 2, 20, if night { MOON } else { SUN })?; + cloud(b, 8, CLOUD) + } + Icon::Cloud => cloud(b, 6, CLOUD), + Icon::Fog => { + for dy in [8, 18, 28] { + shape(b, parent, cx, y + u(dy), u(40), u(5), STORM)?; + } + Ok(()) + } + Icon::Drizzle => { + cloud(b, 2, CLOUD)?; + fall(b, 4, 5, WET) + } + Icon::Rain => { + cloud(b, 2, CLOUD)?; + fall(b, 4, 9, WET) + } + Icon::Snow => { + cloud(b, 2, CLOUD)?; + fall(b, 6, 6, WHITE) + } + Icon::Storm => { + cloud(b, 2, STORM)?; + shape(b, parent, cx, y + u(30), u(6), u(10), SUN).map(|_| ()) + } + } +} + +/// The now screen's content, into a full-screen `parent`. +fn now_content(b: &mut Batch, flush: &mut Flush, parent: Obj, m: &Model, wall: i32) -> Result<(), LvError> { + let Some(n) = m.now else { return Ok(()) }; + room(b, flush)?; + if !m.place().is_empty() { + let l = label(b, parent, m.place(), MSG_W, 0, 62, 2)?; + b.long_mode(l, LongMode::Dot)?; + small(b, l, GREY)?; + } + let t = label(b, parent, model::temp_text(model::deg(n.temp)).as_str(), MSG_W, 0, 98, 2)?; + b.style(t, Prop::TextFont, 0, F48 as i32)?; + // night for the icon: what the current hour says, when there are hours + let night = m.hour_at(0, wall).is_some_and(|(_, is_now, h)| is_now && h.night); + icon(b, parent, model::icon(n.code), night, 0, 160, 52)?; + room(b, flush)?; + label(b, parent, model::condition(n.code), MSG_W, 0, 220, 2)?; + let mut y = 266; + if let Some(d) = m.today(wall) { + let mut l = Line::new(); + let _ = write!(l, "H:{} L:{}", model::temp_text(d.max as i16).as_str(), model::temp_text(d.min as i16).as_str()); + let h = label(b, parent, l.as_str(), MSG_W, 0, y, 2)?; + small(b, h, WHITE)?; + y += 36; + } + let mut l = Line::new(); + let _ = write!(l, "{} m/s {}%", n.wind, n.humidity); + let w = label(b, parent, l.as_str(), MSG_W, 0, y, 2)?; + small(b, w, GREY)?; + if let Some(t) = note(m, wall) { + let l = label(b, parent, t.as_str(), 280, 0, y + 36, 2)?; + small(b, l, GREY)?; + b.long_mode(l, LongMode::Wrap)?; + } + Ok(()) +} + +/// A grey line in the middle of a page that has nothing else. +fn empty(b: &mut Batch, parent: Obj, text: &str) -> Result<(), LvError> { + let l = label(b, parent, text, MSG_W, 0, 180, 2)?; + b.style(l, Prop::TextColor, 0, GREY)?; + b.long_mode(l, LongMode::Wrap) +} + +/// What the hours page says without hours. +pub fn no_hours_text(m: &Model) -> &'static str { + if m.no_hours { "Update FMC Companion for the hourly forecast" } else { "No hours to show yet" } +} + +fn hours_content(b: &mut Batch, flush: &mut Flush, page: Obj, m: &Model, wall: i32) -> Result<(), LvError> { + let n = m.hours_len(wall).min(model::ASK_HOURS as usize); + if n == 0 { + room(b, flush)?; + return empty(b, page, no_hours_text(m)); + } + for k in 0..n { + let Some((hod, is_now, h)) = m.hour_at(k, wall) else { break }; + room(b, flush)?; + let y = ROWS_Y + k as i32 * HOUR_H; + let mut l = Line::new(); + let _ = if is_now { l.write_str("Now") } else { write!(l, "{hod:02}") }; + let t = label(b, page, l.as_str(), 80, -110, y + 8, 1)?; + if !is_now { + b.style(t, Prop::TextColor, 0, GREY)?; + } + icon(b, page, model::icon(h.code), h.night, -22, y + 6, 40)?; + if h.precip >= 30 { + let mut l = Line::new(); + let _ = write!(l, "{}%", h.precip); + let p = label(b, page, l.as_str(), 64, 42, y + 14, 2)?; + small(b, p, WET)?; + } + label(b, page, model::temp_text(h.temp as i16).as_str(), 80, 110, y + 8, 3)?; + } + b.style(page, Prop::PadBottom, 0, 130) // the last row can scroll up clear of the round edge +} + +fn days_content(b: &mut Batch, flush: &mut Flush, page: Obj, m: &Model, wall: i32) -> Result<(), LvError> { + let n = m.days_len(wall); + if n == 0 { + room(b, flush)?; + return empty(b, page, "No forecast to show yet"); + } + let (lo, hi) = m.range(wall); + for k in 0..n { + let Some((abs, today, d)) = m.day_at(k, wall) else { break }; + room(b, flush)?; + let y = ROWS_Y + k as i32 * DAY_H; + label(b, page, if today { "Today" } else { model::weekday(abs) }, 96, -112, y + 6, 1)?; + icon(b, page, model::icon(d.code), false, -42, y + 4, 40)?; + let lo_l = label(b, page, model::temp_text(d.min as i16).as_str(), 56, 6, y + 12, 3)?; + small(b, lo_l, GREY)?; + let track = shape(b, page, 73, y + 22, BAR_W as i32, BAR_H as i32, TRACK)?; + b.style(track, Prop::PadLeft, 0, 0)?; + let (x, len) = model::bar(d.min, d.max, lo, hi, BAR_W, BAR_H); + let seg = b.create(Class::Obj, track)?; + b.size(seg, len as i32, BAR_H as i32)?; + b.style(seg, Prop::Radius, 0, CIRCLE)?; + b.style(seg, Prop::BorderWidth, 0, 0)?; + b.style(seg, Prop::BgColor, 0, bar_color(d.min, d.max))?; + b.style(seg, Prop::BgOpa, 0, 255)?; + b.flags(seg, &[], &[Flag::Clickable, Flag::Scrollable])?; + b.align(seg, Align::LeftMid, x, 0)?; + let hi_l = label(b, page, model::temp_text(d.max as i16).as_str(), 56, 138, y + 12, 3)?; + small(b, hi_l, WHITE)?; + } + b.style(page, Prop::PadBottom, 0, 130) +} + +/// A screen: its root, and the pager when it has pages. +#[derive(Clone, Copy)] +pub struct View { + pub root: Obj, + pub pager: Option>, +} + +/// One line in the middle of the screen. +pub fn message_view(b: &mut Batch, flush: &mut Flush, text: &str) -> Result { + room(b, flush)?; + let r = root(b)?; + let l = label(b, r, text, MSG_W, 0, 170, 2)?; + b.style(l, Prop::TextColor, 0, GREY)?; + b.long_mode(l, LongMode::Wrap)?; + b.flags(r, &[], &[Flag::Hidden])?; + Ok(View { root: r, pager: None }) +} + +/// The menu app: now, hours, days, opened on `page`. +pub fn pages_view(b: &mut Batch, flush: &mut Flush, m: &Model, wall: i32, page: usize) -> Result { + if m.now.is_none() { + return message_view(b, flush, message(m)); + } + room(b, flush)?; + let mut p = stock::pager::<3>(b, 3)?; + b.flags(p.root, &[Flag::Hidden], &[])?; + now_content(b, flush, p.pages[0], m, wall)?; + hours_content(b, flush, p.pages[1], m, wall)?; + days_content(b, flush, p.pages[2], m, wall)?; + room(b, flush)?; + if page > 0 { + p.jump(b, page.min(2))?; + } + b.flags(p.root, &[], &[Flag::Hidden])?; + Ok(View { root: p.root, pager: Some(p) }) +} + +/// The page next to the watch face: the now screen alone. +pub fn face_view(b: &mut Batch, flush: &mut Flush, m: &Model, wall: i32) -> Result { + if m.now.is_none() { + return message_view(b, flush, message(m)); + } + room(b, flush)?; + let r = root(b)?; + now_content(b, flush, r, m, wall)?; + b.flags(r, &[], &[Flag::Hidden])?; + Ok(View { root: r, pager: None }) +} + +/// Deletes a screen. +pub fn leave(b: &mut Batch, root: Obj) -> Result<(), LvError> { + if root != ROOT { b.del(root) } else { Ok(()) } +} + +#[cfg(test)] +#[path = "screen_tests.rs"] +mod tests; diff --git a/apps/weather/src/screen_tests.rs b/apps/weather/src/screen_tests.rs new file mode 100644 index 0000000..4a1770b --- /dev/null +++ b/apps/weather/src/screen_tests.rs @@ -0,0 +1,201 @@ +extern crate std; +use super::*; +use companion_rpc as rpc; +use std::boxed::Box; +use std::vec::Vec; +use wp2_core::lvcmd::{self, Table}; + +// 2026-11-20 13:20 +const WALL: i32 = 20_777 * 1440 + 13 * 60 + 20; +const FONTS: u8 = 0b111; + +fn batch() -> Batch { + Batch::with_buf(Box::leak(Box::new([0; BUF]))) +} + +/// Runs `build` with a flush that validates each batch against the loader's table and applies it; returns the +/// result and the batches' sizes. +fn run(t: &mut Table, b: &mut Batch, build: impl FnOnce(&mut Batch, &mut Flush) -> Result) -> (T, Vec) { + let sizes = std::cell::RefCell::new(Vec::new()); + let mut flush = |b: &mut Batch| -> Result<(), LvError> { + assert_eq!(lvcmd::validate(b.bytes(), t, FONTS), Ok(())); + for r in lvcmd::records(b.bytes()) { + lvcmd::apply(t, &r.unwrap()); + } + sizes.borrow_mut().push(b.bytes().len()); + b.clear(); + Ok(()) + }; + let out = build(b, &mut flush).unwrap(); + flush(b).unwrap(); + (out, sizes.into_inner()) +} + +fn msg(id: u8, status: u8, index: u8, total: u8, record: &[u8]) -> Vec { + [&b"R1A"[..], &[id, status, index, total], record].concat() +} + +/// A model the phone answered with `recs` at WALL, in "Санкт-Петербург". +fn answered(recs: &[Vec]) -> Model { + let mut m = Model::new(); + m.ask_now(0); + while let Some(q) = m.poll(0) { + if q[4] == 0x20 { + m.reply(&msg(q[3], 0, 0, 1, &[&[0u8; 6][..], "Санкт-Петербург".as_bytes()].concat()), 10, WALL); + } else { + for (i, r) in recs.iter().enumerate() { + m.reply(&msg(q[3], 0, i as u8, recs.len() as u8, r), 10, WALL); + } + } + } + m +} + +/// Every hour and day with `code`, the hours at night with rain likely: the most objects a code can cost. +fn full(code: u8, hours: usize, days: i8) -> Model { + let mut v = Vec::from([[0, 0x38, 0xFF, code, 12, 100, 200].to_vec()]); // -20.0° + if hours > 0 { + let mut h = Vec::from([2, 13]); + for _ in 0..hours { + h.extend([(-128i8) as u8, code, 0x80 | 100]); + } + v.push(h); + } + for d in 0..days { + v.push([1, d as u8, (-128i8) as u8, 127, code, 100].to_vec()); + } + answered(&v) +} + +fn live(t: &Table) -> usize { + (0..lvcmd::MAX_OBJS as u16).filter(|&h| t.class(h).is_some()).count() +} + +#[test] +fn fonts_validate_on_their_own() { + let mut b = batch(); + fonts(&mut b).unwrap(); + assert_eq!(lvcmd::validate(b.bytes(), &Table::new(), 0), Ok(())); +} + +#[test] +fn every_icon_builds_within_four_objects() { + for kind in [Icon::Clear, Icon::Partly, Icon::Cloud, Icon::Fog, Icon::Drizzle, Icon::Rain, Icon::Snow, Icon::Storm] { + for night in [false, true] { + let mut t = Table::new(); + let mut b = batch(); + run(&mut t, &mut b, |b, _| { + theme(b)?; + icon(b, ROOT, kind, night, 0, 0, 40) + }); + let n = live(&t) - 1; // the root + assert!((1..=4).contains(&n), "{kind:?} night {night}: {n}"); + } + } +} + +#[test] +fn the_pages_validate_within_the_budgets_and_free_everything() { + // every WMO group, with all 12 hours and 7 days, then the short and empty shapes + let mut models = Vec::new(); + for code in [0, 2, 3, 45, 55, 63, 73, 95] { + models.push(full(code, 24, 7)); + } + models.extend([full(63, 0, 7), full(63, 5, 0), full(63, 0, 0), full(63, 1, 1)]); + for m in &models { + let mut t = Table::new(); + let mut b = batch(); + let before = { + run(&mut t, &mut b, |b, _| theme(b)); + live(&t) + }; + for page in 0..3 { + let (v, sizes) = run(&mut t, &mut b, |b, f| pages_view(b, f, m, WALL, page)); + assert!(sizes.iter().all(|&s| s <= BUF)); + let p = v.pager.expect("pages"); + assert_eq!((p.at, p.n), (page, 3)); + assert!(live(&t) <= lvcmd::MAX_OBJS, "{} objects", live(&t)); + std::println!("page {page}: {} objects, batches {sizes:?}", live(&t)); + // leaving frees every handle + run(&mut t, &mut b, |b, _| leave(b, v.root)); + assert_eq!(live(&t), before); + } + let (v, _) = run(&mut t, &mut b, |b, f| face_view(b, f, m, WALL)); + assert!(v.pager.is_none()); + run(&mut t, &mut b, |b, _| leave(b, v.root)); + assert_eq!(live(&t), before); + } +} + +#[test] +fn a_stale_cache_still_builds() { + // three days later: no hours left, four days left, "Updated 3 d ago" + let m = full(63, 12, 7); + let later = WALL + 3 * 1440; + let mut t = Table::new(); + let mut b = batch(); + run(&mut t, &mut b, |b, f| { + theme(b)?; + pages_view(b, f, &m, later, 1) + }); + assert_eq!(note(&m, later).unwrap().as_str(), "Updated 3 d ago"); + assert_eq!((m.hours_len(later), m.days_len(later)), (0, 4)); +} + +#[test] +fn without_weather_it_says_why() { + let mut m = Model::new(); + assert_eq!(message(&m), "Asking your phone..."); + for (s, want) in [ + (rpc::ASK, "Allow Weather in FMC Companion on your phone"), + (rpc::DENIED, "Turn Weather on in FMC Companion"), + (rpc::UNAVAILABLE, "No weather right now"), + ] { + m.ask_now(0); + while let Some(q) = m.poll(0) { + if q[4] == 0x30 { + m.reply(&msg(q[3], s, 0, 0, &[]), 10, WALL); + } + } + assert_eq!(message(&m), want); + } + // the phone never answers: after the first retry it is told what to open + let mut m = Model::new(); + m.ask_now(0); + while m.poll(0).is_some() {} + while m.poll(10_000).is_some() {} + assert_eq!(message(&m), "Open FMC Companion on your phone"); + let mut t = Table::new(); + let mut b = batch(); + for build in [pages_view as fn(&mut Batch, &mut Flush, &Model, i32, usize) -> Result] { + let (v, _) = run(&mut t, &mut b, |b, f| { + theme(b)?; + build(b, f, &m, WALL, 0) + }); + assert!(v.pager.is_none()); + } + let (v, _) = run(&mut t, &mut b, |b, f| face_view(b, f, &m, WALL)); + assert!(v.pager.is_none()); +} + +#[test] +fn notes_and_empty_pages() { + let m = full(63, 0, 7); + assert!(m.no_hours); + assert_eq!(no_hours_text(&m), "Update FMC Companion for the hourly forecast"); + assert_eq!(note(&m, WALL).unwrap().as_str(), "Updated 200 min ago".replace("200 min", "3 h")); + let m = full(63, 12, 7); + assert_eq!(no_hours_text(&m), "No hours to show yet"); +} + +#[test] +fn bar_colours_run_cold_to_hot() { + let c = [(-20, -10), (-2, 6), (8, 14), (15, 25), (22, 30), (30, 40)].map(|(a, b)| bar_color(a, b)); + for i in 0..c.len() { + for j in 0..i { + assert_ne!(c[i], c[j]); + } + } + assert_eq!(bar_color(-128, -128), c[0]); + assert_eq!(bar_color(127, 127), c[5]); +} From e217175b52dfaa12bd89a8384936627f6febf9a0 Mon Sep 17 00:00:00 2001 From: Egor Kolesnikov Date: Fri, 20 Nov 2026 14:28:04 +0200 Subject: [PATCH 04/12] weather: icon, store listing, README row Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_01CQSU8Mpie8VxG5uXTwzf2a --- README.md | 1 + apps/weather/icon.svg | 14 +++++--------- apps/weather/store.md | 21 +++++++++++++++++++-- apps/weather/store.toml | 7 ++++--- 4 files changed, 29 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index 3fe30b5..1c7c642 100644 --- a/README.md +++ b/README.md @@ -15,6 +15,7 @@ An app runs on a watch with the patched firmware and the App Loader, both on the | [`vela-nav`](apps/vela-nav) | Turn-by-turn directions from the Vela maps app on an Android phone | | [`calendar`](apps/calendar) | A month with the phone's events as dots, a page next to the face and a widget card (needs FMC Companion) | | [`reminders`](apps/reminders) | The iPhone's open reminders: overdue, today, later; tick one off with a tap, and a widget card (needs FMC Companion on an iPhone) | +| [`weather`](apps/weather) | Now, the next hours and the week ahead, in stock LVGL parts; a page next to the face and a widget card (needs FMC Companion) | | [`ha-remote`](apps/ha-remote) | Up to five Home Assistant light and group toggles with an Android companion | ## Make your own app diff --git a/apps/weather/icon.svg b/apps/weather/icon.svg index 8179614..6c97534 100644 --- a/apps/weather/icon.svg +++ b/apps/weather/icon.svg @@ -1,6 +1,7 @@ + - + @@ -13,13 +14,8 @@ - - - - - - - - + + + diff --git a/apps/weather/store.md b/apps/weather/store.md index e5c0894..5c498b9 100644 --- a/apps/weather/store.md +++ b/apps/weather/store.md @@ -1,5 +1,22 @@ -What weather does. +The weather where your phone is, in three pages you turn with the crown or a swipe: + +- **Now**: the place, the temperature, the condition, today's high and low, wind and humidity. +- **Hours**: the next 12 hours with the temperature and, when it is likely, the chance of rain or snow. +- **Days**: the week ahead, each day with its low, its high and a bar that shows where they sit in the week. + +Long-press **Weather** in Apps and choose **Add page** to keep the Now screen one swipe from the watch face, or +**Add widget** for a card with the temperature, the condition and today's high and low. + +The watch asks the phone when you open the app and every 15 minutes while it's shown, and keeps the last answer, so +it opens at once without the phone and says how old the weather is. Temperatures are in °C. + +The first time, the watch says "Allow Weather in FMC Companion on your phone": open FMC Companion, Apps, Weather, and +allow it (the phone then asks for your location). The watch gets the weather and the name of the place, never where +you are. ## Requirements -The [patched firmware](/firmware) and the [App Loader](/firmware). +- A phone with **FMC Companion** (iOS or Android), paired with the watch. The hours need FMC Companion from + 2026-11-20 or later; with an older one the Hours page asks you to update it and the rest works. +- The [patched firmware](/firmware) with the channel key (2026-11-13 or later) and the [App Loader](/firmware) + (2026-11-15 or later for the page and the widget). diff --git a/apps/weather/store.toml b/apps/weather/store.toml index 5ec3213..3259ed0 100644 --- a/apps/weather/store.toml +++ b/apps/weather/store.toml @@ -1,4 +1,5 @@ -name = "weather" -summary = "" +# The app's listing in the FMC store (README.md, "store.toml"). The page's body is store.md. +name = "Weather" +summary = "Now, the next hours and the week ahead where you are, with a page next to the watch face and a widget card" version = "0.1.0" -author = "" +author = "Egor Kolesnikov" From 19e1b7143acf2eee6b0d7bfdfe00bafb2f7d8295 Mon Sep 17 00:00:00 2001 From: Egor Kolesnikov Date: Fri, 20 Nov 2026 14:35:50 +0200 Subject: [PATCH 05/12] weather: Cargo.lock Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_01CQSU8Mpie8VxG5uXTwzf2a --- apps/Cargo.lock | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/apps/Cargo.lock b/apps/Cargo.lock index 1a3121c..3c1b13a 100644 --- a/apps/Cargo.lock +++ b/apps/Cargo.lock @@ -115,6 +115,15 @@ dependencies = [ "cmf-wp2-app", ] +[[package]] +name = "weather" +version = "0.1.0" +dependencies = [ + "cmf-wp2-app", + "companion-rpc", + "wp2-core", +] + [[package]] name = "wp2-core" version = "0.1.0" From 4a9358936ee17903462a3f6cc1c993f05f24b450 Mon Sep 17 00:00:00 2001 From: Egor Kolesnikov Date: Fri, 20 Nov 2026 15:09:20 +0200 Subject: [PATCH 06/12] companion-rpc: vectors for half degrees Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_01CQSU8Mpie8VxG5uXTwzf2a --- crates/companion-rpc/tests/rpc-vectors.json | 52 +++++++++++++++++++++ crates/companion-rpc/tests/vectors.rs | 4 +- 2 files changed, 54 insertions(+), 2 deletions(-) diff --git a/crates/companion-rpc/tests/rpc-vectors.json b/crates/companion-rpc/tests/rpc-vectors.json index bdcc362..5ae0b35 100644 --- a/crates/companion-rpc/tests/rpc-vectors.json +++ b/crates/companion-rpc/tests/rpc-vectors.json @@ -199,6 +199,58 @@ ] }, "hex": "020dfd0314fc47e4" + }, + { + "in": { + "kind": "now", + "temp": -0.25, + "code": 0, + "wind": 1, + "humidity": 50, + "age_min": 0 + }, + "hex": "00fdff00013200", + "note": "a half rounds away from zero: -2.5 tenths are -3" + }, + { + "in": { + "kind": "day", + "day": 0, + "min": -2.5, + "max": -0.5, + "code": 0, + "precip": 0 + }, + "hex": "0100fdff0000", + "note": "halves away from zero" + }, + { + "in": { + "kind": "hours", + "hour": 0, + "hours": [ + { + "temp": -0.5, + "code": 0, + "precip": 0, + "night": true + }, + { + "temp": -2.5, + "code": 0, + "precip": 0, + "night": true + }, + { + "temp": 2.5, + "code": 0, + "precip": 0, + "night": true + } + ] + }, + "hex": "0200ff0080fd0080030080", + "note": "halves away from zero" } ], "weather_args": [ diff --git a/crates/companion-rpc/tests/vectors.rs b/crates/companion-rpc/tests/vectors.rs index 780c8d5..f93f908 100644 --- a/crates/companion-rpc/tests/vectors.rs +++ b/crates/companion-rpc/tests/vectors.rs @@ -293,8 +293,8 @@ fn weather() { } else { Weather::Day { day: i.get("day").int() as i8, - min: i.get("min").int() as i8, - max: i.get("max").int() as i8, + min: i.get("min").num().round() as i8, + max: i.get("max").num().round() as i8, code: i.get("code").int() as u8, precip: i.get("precip").int() as u8, } From a558d2e5a85600bd0bbb167127403042161c467a Mon Sep 17 00:00:00 2001 From: Egor Kolesnikov Date: Fri, 20 Nov 2026 15:09:20 +0200 Subject: [PATCH 07/12] companion-rpc: vectors for half degrees Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_01CQSU8Mpie8VxG5uXTwzf2a --- crates/companion-rpc/tests/rpc-vectors.json | 52 +++++++++++++++++++++ crates/companion-rpc/tests/vectors.rs | 4 +- 2 files changed, 54 insertions(+), 2 deletions(-) diff --git a/crates/companion-rpc/tests/rpc-vectors.json b/crates/companion-rpc/tests/rpc-vectors.json index bdcc362..5ae0b35 100644 --- a/crates/companion-rpc/tests/rpc-vectors.json +++ b/crates/companion-rpc/tests/rpc-vectors.json @@ -199,6 +199,58 @@ ] }, "hex": "020dfd0314fc47e4" + }, + { + "in": { + "kind": "now", + "temp": -0.25, + "code": 0, + "wind": 1, + "humidity": 50, + "age_min": 0 + }, + "hex": "00fdff00013200", + "note": "a half rounds away from zero: -2.5 tenths are -3" + }, + { + "in": { + "kind": "day", + "day": 0, + "min": -2.5, + "max": -0.5, + "code": 0, + "precip": 0 + }, + "hex": "0100fdff0000", + "note": "halves away from zero" + }, + { + "in": { + "kind": "hours", + "hour": 0, + "hours": [ + { + "temp": -0.5, + "code": 0, + "precip": 0, + "night": true + }, + { + "temp": -2.5, + "code": 0, + "precip": 0, + "night": true + }, + { + "temp": 2.5, + "code": 0, + "precip": 0, + "night": true + } + ] + }, + "hex": "0200ff0080fd0080030080", + "note": "halves away from zero" } ], "weather_args": [ diff --git a/crates/companion-rpc/tests/vectors.rs b/crates/companion-rpc/tests/vectors.rs index 780c8d5..f93f908 100644 --- a/crates/companion-rpc/tests/vectors.rs +++ b/crates/companion-rpc/tests/vectors.rs @@ -293,8 +293,8 @@ fn weather() { } else { Weather::Day { day: i.get("day").int() as i8, - min: i.get("min").int() as i8, - max: i.get("max").int() as i8, + min: i.get("min").num().round() as i8, + max: i.get("max").num().round() as i8, code: i.get("code").int() as u8, precip: i.get("precip").int() as u8, } From 6dc195b8b91ed661f6608dc954889ed15180417a Mon Sep 17 00:00:00 2001 From: Egor Kolesnikov Date: Fri, 20 Nov 2026 15:09:21 +0200 Subject: [PATCH 08/12] weather: hours and days count from the phone's hour The watch's clock at the moment the answer came can be on the other side of an hour or of midnight from the phone's: then "Now" sat one hour off and "Today" on yesterday until the next answer, and in the cache. Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_01CQSU8Mpie8VxG5uXTwzf2a --- apps/weather/src/model.rs | 24 +++++++++++++----- apps/weather/src/model_tests.rs | 43 ++++++++++++++++++++++++++++++--- 2 files changed, 58 insertions(+), 9 deletions(-) diff --git a/apps/weather/src/model.rs b/apps/weather/src/model.rs index b5c7c25..3b9761f 100644 --- a/apps/weather/src/model.rs +++ b/apps/weather/src/model.rs @@ -1,8 +1,9 @@ //! Weather's state, without `Api`: the two calls to the phone (`location` once for the place, `weather` every 15 //! minutes while open), what they answered, the cache blob, and the texts and geometry the screens show. //! -//! Hours and days count from the phone's answer (`at`, wall minutes): a cached answer moves with the clock, so the -//! hours that passed and yesterday drop out instead of being shown as now and today. +//! Hours and days count from the phone's answer: a cached answer moves with the clock, so the hours that passed and +//! yesterday drop out instead of being shown as now and today. They count from the phone's hour, not the watch's +//! at the moment the answer came (`Model::base`): the two clocks can sit on either side of an hour or of midnight. use companion_rpc as rpc; use core::fmt::Write; @@ -388,9 +389,20 @@ impl Model { wall - self.at + self.data.age as i32 } + /// The hour (hours since 1970, wall clock) the phone was in when it answered: the first hourly entry's, and + /// the one its day 0 is the day of. The watch's own hour at `at`, moved to the nearest one that is `hour0` + /// o'clock; without hours, the watch's. + fn base(&self) -> i32 { + let h = self.at.div_euclid(60); + if self.data.nh == 0 { + return h; + } + h + (self.data.hour0 as i32 - h.rem_euclid(24) + 36).rem_euclid(24) - 12 + } + /// Hours of the answer that passed by `wall`. fn hours_gone(&self, wall: i32) -> usize { - (wall.div_euclid(60) - self.at.div_euclid(60)).clamp(0, self.data.nh as i32) as usize + (wall.div_euclid(60) - self.base()).clamp(0, self.data.nh as i32) as usize } pub fn hours_len(&self, wall: i32) -> usize { @@ -403,13 +415,13 @@ impl Model { if i >= self.data.nh { return None; } - let is_now = self.at.div_euclid(60) + i as i32 == wall.div_euclid(60); + let is_now = self.base() + i as i32 == wall.div_euclid(60); Some((hour_label(self.data.hour0, i as u8), is_now, self.data.hours[i])) } /// `wall`'s day counted from the answer's. fn today_index(&self, wall: i32) -> i32 { - wall.div_euclid(1440) - self.at.div_euclid(1440) + wall.div_euclid(1440) - self.base().div_euclid(24) } fn shown_days(&self, wall: i32) -> &[Day] { @@ -425,7 +437,7 @@ impl Model { /// Row `k` of the days at `wall`: the day's number (days since 1970), whether it is today, the day. pub fn day_at(&self, k: usize, wall: i32) -> Option<(i32, bool, Day)> { let d = *self.shown_days(wall).get(k)?; - Some((self.at.div_euclid(1440) + d.day as i32, d.day as i32 == self.today_index(wall), d)) + Some((self.base().div_euclid(24) + d.day as i32, d.day as i32 == self.today_index(wall), d)) } pub fn today(&self, wall: i32) -> Option { diff --git a/apps/weather/src/model_tests.rs b/apps/weather/src/model_tests.rs index 174d96f..ce7d9ff 100644 --- a/apps/weather/src/model_tests.rs +++ b/apps/weather/src/model_tests.rs @@ -36,18 +36,23 @@ fn answered(recs: &[Vec]) -> Model { } fn answered_in(recs: &[Vec], place: &str) -> Model { + answered_at(recs, place, WALL) +} + +/// The same, with the watch's clock at `wall` when the answer comes. +fn answered_at(recs: &[Vec], place: &str, wall: i32) -> Model { let mut m = Model::new(); m.ask_now(0); let q = sent(&mut m, 0); let l = q.iter().find(|q| q[4] == 0x20).expect("asks the place"); if place.is_empty() { - m.reply(&msg(l[3], rpc::DENIED, 0, 0, &[]), 50, WALL); + m.reply(&msg(l[3], rpc::DENIED, 0, 0, &[]), 50, wall); } else { - m.reply(&msg(l[3], 0, 0, 1, &[&[0u8; 6][..], place.as_bytes()].concat()), 50, WALL); + m.reply(&msg(l[3], 0, 0, 1, &[&[0u8; 6][..], place.as_bytes()].concat()), 50, wall); } let weather = q.iter().find(|q| q[4] == 0x30).expect("asks the weather"); for (i, r) in recs.iter().enumerate() { - m.reply(&msg(weather[3], 0, i as u8, recs.len() as u8, r), 100, WALL); + m.reply(&msg(weather[3], 0, i as u8, recs.len() as u8, r), 100, wall); } m } @@ -300,3 +305,35 @@ fn the_card() { let m = answered(&[NOW.to_vec()]); assert_eq!(m.card(WALL).1.as_str(), "-3° Snow"); } + +#[test] +fn hours_and_days_count_from_the_phones_clock_not_the_watchs() { + // the phone answered in its 13th hour; the watch got it at 14:02: 13 is past, 14 is now + let at = 20_777 * 1440 + 14 * 60 + 2; + let m = answered_at(&week(), "", at); + assert_eq!(m.hours_len(at), 11); + assert_eq!(m.hour_at(0, at).map(|(h, n, x)| (h, n, x.temp)), Some((14, true, -3))); + // the other way: the phone is already in 14, the watch still at 13:59; nothing is past, 14 is not now yet + let at = 20_777 * 1440 + 13 * 60 + 59; + let mut v = week(); + v[1] = hours(14, 12); + let m = answered_at(&v, "", at); + assert_eq!(m.hours_len(at), 12); + assert_eq!(m.hour_at(0, at).map(|(h, n, _)| (h, n)), Some((14, false))); + assert_eq!(m.hour_at(0, at + 1).map(|(h, n, _)| (h, n)), Some((14, true))); + // midnight: the phone answered at 23:59 of the 20th, the watch got it at 00:01 of the 21st + let at = 20_778 * 1440 + 1; + let mut v = week(); + v[1] = hours(23, 12); + let m = answered_at(&v, "", at); + assert_eq!(m.day_at(0, at).map(|(d, today, x)| (d, today, x.min)), Some((20_778, true, -6)), "the phone's tomorrow"); + assert_eq!(m.days_len(at), 6); + assert_eq!(m.hour_at(0, at).map(|(h, n, _)| (h, n)), Some((0, true))); + // and it survives the cache + let mut blob = [0u8; BLOB_MAX]; + let n = m.save(&mut blob); + let mut back = Model::new(); + assert!(back.load(&blob[..n])); + assert_eq!(back.day_at(0, at), m.day_at(0, at)); + assert_eq!(back.hour_at(0, at), m.hour_at(0, at)); +} From 83ee69185228f460dcb676d58f4452c93104a9dd Mon Sep 17 00:00:00 2001 From: Egor Kolesnikov Date: Fri, 20 Nov 2026 16:12:17 +0200 Subject: [PATCH 09/12] weather: no degree sign in text, a ring after the temperature; the now screen centred The emulator showed the stock fonts have no degree glyph: it drew as a blank a letter wide, on the screens and on the widget card. Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_01CQSU8Mpie8VxG5uXTwzf2a --- apps/weather/src/model.rs | 7 ++++--- apps/weather/src/model_tests.rs | 11 ++++++----- apps/weather/src/screen.rs | 30 +++++++++++++++++++++++++----- 3 files changed, 35 insertions(+), 13 deletions(-) diff --git a/apps/weather/src/model.rs b/apps/weather/src/model.rs index 3b9761f..4394608 100644 --- a/apps/weather/src/model.rs +++ b/apps/weather/src/model.rs @@ -8,8 +8,9 @@ use companion_rpc as rpc; use core::fmt::Write; -/// The degree sign after a temperature. -pub const DEG: &str = "°"; +/// After a temperature in text: nothing. The watch's fonts have no degree sign (it draws as a blank the width of +/// a letter, seen in the emulator), so texts carry plain numbers and the now screen draws a ring instead. +pub const DEG: &str = ""; /// A fresh answer this often while the app is open; the phone itself caches for 30 minutes. pub const PERIOD_MS: u32 = 15 * 60_000; /// While the phone waits for the user's "allow". @@ -180,7 +181,7 @@ impl Write for Line { } } -/// "-3°". +/// "-3". pub fn temp_text(deg: i16) -> Line { let mut l = Line::new(); let _ = write!(l, "{deg}{DEG}"); diff --git a/apps/weather/src/model_tests.rs b/apps/weather/src/model_tests.rs index ce7d9ff..4b462b9 100644 --- a/apps/weather/src/model_tests.rs +++ b/apps/weather/src/model_tests.rs @@ -234,9 +234,10 @@ fn save_and_load() { #[test] fn temperatures() { assert_eq!([deg(-34), deg(-35), deg(-4), deg(4), deg(5), deg(0), deg(-5), deg(216)], [-3, -4, 0, 0, 1, 0, -1, 22]); - assert_eq!(temp_text(0).as_str(), "0°"); - assert_eq!(temp_text(-12).as_str(), "-12°"); - assert_eq!(temp_text(deg(-4)).as_str(), "0°", "never -0"); + // the watch's fonts have no degree sign (it draws as a blank): plain numbers + assert_eq!(temp_text(0).as_str(), "0"); + assert_eq!(temp_text(-12).as_str(), "-12"); + assert_eq!(temp_text(deg(-4)).as_str(), "0", "never -0"); } #[test] @@ -296,14 +297,14 @@ fn the_card() { assert_eq!((t.as_str(), v.as_str()), ("Weather", "Open the app")); let m = answered(&week()); let (t, v) = m.card(WALL); - assert_eq!((t.as_str(), v.as_str()), ("Weather", "-3° Snow\nH 1° L -5°")); + assert_eq!((t.as_str(), v.as_str()), ("Weather", "-3 Snow\nH 1 L -5")); let m = answered_in(&week(), "Санкт-Петербург и область"); let (t, v) = m.card(WALL); assert!(t.as_str().len() <= 23 && t.as_str().starts_with("Санкт-Петер"), "{}", t.as_str()); assert!(v.as_str().len() <= 39); // no day for today: the first line alone let m = answered(&[NOW.to_vec()]); - assert_eq!(m.card(WALL).1.as_str(), "-3° Snow"); + assert_eq!(m.card(WALL).1.as_str(), "-3 Snow"); } #[test] diff --git a/apps/weather/src/screen.rs b/apps/weather/src/screen.rs index 95b1450..c00e2e0 100644 --- a/apps/weather/src/screen.rs +++ b/apps/weather/src/screen.rs @@ -25,6 +25,8 @@ const WET: i32 = 0x669F; // #64D2FF const TRACK: i32 = 0x39C7; // #3A3A3C const MSG_W: i32 = 300; +/// The top of the now screen's content: the place; the rest hangs below it. +const NOW_Y: i32 = 92; /// The first row of the hours and days pages, and their rows' height. const ROWS_Y: i32 = 96; const HOUR_H: i32 = 58; @@ -197,18 +199,36 @@ fn now_content(b: &mut Batch, flush: &mut Flush, parent: Obj, m: &Model, wall: i let Some(n) = m.now else { return Ok(()) }; room(b, flush)?; if !m.place().is_empty() { - let l = label(b, parent, m.place(), MSG_W, 0, 62, 2)?; + let l = label(b, parent, m.place(), MSG_W, 0, NOW_Y, 2)?; b.long_mode(l, LongMode::Dot)?; small(b, l, GREY)?; } - let t = label(b, parent, model::temp_text(model::deg(n.temp)).as_str(), MSG_W, 0, 98, 2)?; + // the temperature and, since the fonts have no degree sign, a ring after it: a row as wide as the two, moved + // right by half the ring so the number stays in the middle + let row = b.create(Class::Obj, parent)?; + b.size(row, CONTENT, CONTENT)?; + plain(b, row)?; + b.flags(row, &[], &[Flag::Clickable, Flag::Scrollable])?; + b.flex(row, Flow::Row, FlexAlign::Start, FlexAlign::Start, FlexAlign::Start)?; + b.style(row, Prop::PadColumn, 0, 4)?; + b.align(row, Align::TopMid, 9, (NOW_Y + 36) as i16)?; + let t = b.create(Class::Label, row)?; + b.text(t, model::temp_text(model::deg(n.temp)).as_str())?; b.style(t, Prop::TextFont, 0, F48 as i32)?; + let ring = b.create(Class::Obj, row)?; + b.size(ring, 14, 14)?; + b.style(ring, Prop::Radius, 0, CIRCLE)?; + b.style(ring, Prop::BgOpa, 0, 0)?; + b.style(ring, Prop::BorderWidth, 0, 3)?; + b.style(ring, Prop::BorderColor, 0, WHITE)?; + b.style(ring, Prop::TranslateY, 0, 8)?; + b.flags(ring, &[], &[Flag::Clickable, Flag::Scrollable])?; // night for the icon: what the current hour says, when there are hours let night = m.hour_at(0, wall).is_some_and(|(_, is_now, h)| is_now && h.night); - icon(b, parent, model::icon(n.code), night, 0, 160, 52)?; + icon(b, parent, model::icon(n.code), night, 0, NOW_Y + 98, 52)?; room(b, flush)?; - label(b, parent, model::condition(n.code), MSG_W, 0, 220, 2)?; - let mut y = 266; + label(b, parent, model::condition(n.code), MSG_W, 0, NOW_Y + 158, 2)?; + let mut y = NOW_Y + 204; if let Some(d) = m.today(wall) { let mut l = Line::new(); let _ = write!(l, "H:{} L:{}", model::temp_text(d.max as i16).as_str(), model::temp_text(d.min as i16).as_str()); From cc7648b18fb580922dba5ebbccc54d299174e1fd Mon Sep 17 00:00:00 2001 From: Egor Kolesnikov Date: Fri, 20 Nov 2026 22:35:53 +0200 Subject: [PATCH 10/12] weather: the pager came out black on a mixed forecast; screenshots A day's row and the top of the now screen wrote more records than the room asked for before them, so with some forecasts the batch filled up mid-view and the pager stayed hidden. The emulator showed it; the tests built only uniform forecasts, which happened to fit. They now build every view from every fill level of the batch. A failed draw also left its records in the batch, failing every later one. Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_01CQSU8Mpie8VxG5uXTwzf2a --- apps/weather/shots/card.png | Bin 0 -> 7130 bytes apps/weather/shots/days.png | Bin 0 -> 8361 bytes apps/weather/shots/hours.png | Bin 0 -> 8037 bytes apps/weather/shots/now.png | Bin 0 -> 5124 bytes apps/weather/src/main.rs | 5 +-- apps/weather/src/screen.rs | 5 +++ apps/weather/src/screen_tests.rs | 51 +++++++++++++++++++++++++++++++ apps/weather/store.toml | 1 + 8 files changed, 60 insertions(+), 2 deletions(-) create mode 100644 apps/weather/shots/card.png create mode 100644 apps/weather/shots/days.png create mode 100644 apps/weather/shots/hours.png create mode 100644 apps/weather/shots/now.png diff --git a/apps/weather/shots/card.png b/apps/weather/shots/card.png new file mode 100644 index 0000000000000000000000000000000000000000..cedec67fde05e5c8f406063c7f1d25c537e49ad5 GIT binary patch literal 7130 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 literal 0 HcmV?d00001 diff --git a/apps/weather/shots/days.png b/apps/weather/shots/days.png new file mode 100644 index 0000000000000000000000000000000000000000..bc436d4a0590601a9aac9cb271405cbce6210847 GIT binary patch literal 8361 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 N^x($Y<(du;{vW}JJ4^ro literal 0 HcmV?d00001 diff --git a/apps/weather/shots/now.png b/apps/weather/shots/now.png new file mode 100644 index 0000000000000000000000000000000000000000..e75aa802c427327096acf41be03756df9c66febc GIT binary patch literal 5124 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 RCCNWtU9kdLR#|xc{U0tJ(=7l1 literal 0 HcmV?d00001 diff --git a/apps/weather/src/main.rs b/apps/weather/src/main.rs index 7a02709..7a59628 100644 --- a/apps/weather/src/main.rs +++ b/apps/weather/src/main.rs @@ -74,8 +74,9 @@ mod device { } }) .and_then(|v| self.b.submit(&lv).map(|_| v)); - if let Ok(v) = r { - self.view = v; + match r { + Ok(v) => self.view = v, + Err(_) => self.b.clear(), // or the records left in it fail every later draw } self.shown = self.key(w); } diff --git a/apps/weather/src/screen.rs b/apps/weather/src/screen.rs index c00e2e0..d4017f5 100644 --- a/apps/weather/src/screen.rs +++ b/apps/weather/src/screen.rs @@ -40,6 +40,8 @@ const GROUP: usize = 760; pub type Flush<'a> = dyn FnMut(&mut Batch) -> Result<(), LvError> + 'a; +/// Flushes unless a group of records still fits: called before each one, and none is longer than GROUP (the +/// tests build the views from every fill level). fn room(b: &mut Batch, flush: &mut Flush) -> Result<(), LvError> { if b.bytes().len() + GROUP > BUF { flush(b) } else { Ok(()) } } @@ -205,6 +207,7 @@ fn now_content(b: &mut Batch, flush: &mut Flush, parent: Obj, m: &Model, wall: i } // the temperature and, since the fonts have no degree sign, a ring after it: a row as wide as the two, moved // right by half the ring so the number stays in the middle + room(b, flush)?; let row = b.create(Class::Obj, parent)?; b.size(row, CONTENT, CONTENT)?; plain(b, row)?; @@ -225,6 +228,7 @@ fn now_content(b: &mut Batch, flush: &mut Flush, parent: Obj, m: &Model, wall: i b.flags(ring, &[], &[Flag::Clickable, Flag::Scrollable])?; // night for the icon: what the current hour says, when there are hours let night = m.hour_at(0, wall).is_some_and(|(_, is_now, h)| is_now && h.night); + room(b, flush)?; icon(b, parent, model::icon(n.code), night, 0, NOW_Y + 98, 52)?; room(b, flush)?; label(b, parent, model::condition(n.code), MSG_W, 0, NOW_Y + 158, 2)?; @@ -303,6 +307,7 @@ fn days_content(b: &mut Batch, flush: &mut Flush, page: Obj, m: &Model, wall: i3 icon(b, page, model::icon(d.code), false, -42, y + 4, 40)?; let lo_l = label(b, page, model::temp_text(d.min as i16).as_str(), 56, 6, y + 12, 3)?; small(b, lo_l, GREY)?; + room(b, flush)?; let track = shape(b, page, 73, y + 22, BAR_W as i32, BAR_H as i32, TRACK)?; b.style(track, Prop::PadLeft, 0, 0)?; let (x, len) = model::bar(d.min, d.max, lo, hi, BAR_W, BAR_H); diff --git a/apps/weather/src/screen_tests.rs b/apps/weather/src/screen_tests.rs index 4a1770b..f0f4934 100644 --- a/apps/weather/src/screen_tests.rs +++ b/apps/weather/src/screen_tests.rs @@ -199,3 +199,54 @@ fn bar_colours_run_cold_to_hot() { assert_eq!(bar_color(-128, -128), c[0]); assert_eq!(bar_color(127, 127), c[5]); } + +/// What the emulator's fake phone answers: mixed hours and days, in "Berlin" (the pager came out black there). +fn mixed(hour0: u8) -> Model { + let hours = [(-3, 2, 10, 0), (-3, 2, 10, 0), (-4, 3, 20, 0), (-4, 3, 30, 0), (-5, 71, 60, 1), (-5, 71, 70, 1), + (-6, 73, 80, 1), (-6, 3, 20, 1), (-6, 0, 0, 1), (-5, 0, 0, 1), (-4, 1, 10, 1), (-3, 61, 40, 1)]; + let days = [(-6, -2, 2, 20), (-8, -3, 71, 70), (-4, 1, 3, 30), (0, 5, 61, 80), (2, 8, 1, 10), (4, 11, 0, 0), (-1, 6, 95, 60)]; + let mut v = Vec::from([[0, 0xDE, 0xFF, 2, 5, 78, 3].to_vec()]); + let mut h = Vec::from([2, hour0]); + for (t, code, p, night) in hours { + h.extend([t as i8 as u8, code, p | night << 7]); + } + v.push(h); + for (d, (lo, hi, code, p)) in days.iter().enumerate() { + v.push([1, d as u8, *lo as i8 as u8, *hi as i8 as u8, *code, *p].to_vec()); + } + answered(&v) +} + +/// A view is built into whatever the batch already holds, so no group of records may be longer than the room +/// asked for before it: every fill level the batch can start at, every icon. +#[test] +fn the_views_build_from_any_fill_level() { + let mut models = Vec::from([mixed(22), mixed(9)]); + for code in [0, 2, 3, 45, 55, 63, 73, 95] { + models.push(full(code, 12, 7)); + } + for (i, m) in models.iter().enumerate() { + for fill in 0..200 { + let mut t = Table::new(); + let mut b = batch(); + let mut flush = |b: &mut Batch| -> Result<(), LvError> { + assert_eq!(lvcmd::validate(b.bytes(), &t, FONTS), Ok(())); + for r in lvcmd::records(b.bytes()) { + lvcmd::apply(&mut t, &r.unwrap()); + } + b.clear(); + Ok(()) + }; + for _ in 0..fill { + if b.style(ROOT, Prop::BgColor, 0, BLACK).is_err() { + break; // full to the brim is a fill level too + } + } + let at = b.bytes().len(); + let r = pages_view(&mut b, &mut flush, m, WALL, 0).map(|_| ()); + assert_eq!(r, Ok(()), "model {i}, {at} bytes in the batch"); + let r = face_view(&mut b, &mut flush, m, WALL).map(|_| ()); + assert_eq!(r, Ok(()), "model {i}, the face page"); + } + } +} diff --git a/apps/weather/store.toml b/apps/weather/store.toml index 3259ed0..fc81177 100644 --- a/apps/weather/store.toml +++ b/apps/weather/store.toml @@ -3,3 +3,4 @@ name = "Weather" summary = "Now, the next hours and the week ahead where you are, with a page next to the watch face and a widget card" version = "0.1.0" author = "Egor Kolesnikov" +screenshots = ["shots/now.png", "shots/hours.png", "shots/days.png", "shots/card.png"] From fa7c65064c1c8d2c7c66d36cd4286e0b02b6a781 Mon Sep 17 00:00:00 2001 From: Egor Kolesnikov Date: Sat, 21 Nov 2026 15:31:34 +0200 Subject: [PATCH 11/12] weather: room between Today and its icon on the Days page Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01CQSU8Lx87AsgWNq9fwhXi1 --- apps/weather/shots/card.png | Bin 7130 -> 7264 bytes apps/weather/shots/days.png | Bin 8361 -> 8053 bytes apps/weather/shots/hours.png | Bin 8037 -> 8012 bytes apps/weather/src/screen.rs | 2 +- 4 files changed, 1 insertion(+), 1 deletion(-) diff --git a/apps/weather/shots/card.png b/apps/weather/shots/card.png index cedec67fde05e5c8f406063c7f1d25c537e49ad5..6c208e33a1659329f76b0f5526a0ea7419a8a893 100644 GIT binary patch literal 7264 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 diff --git a/apps/weather/shots/days.png b/apps/weather/shots/days.png index bc436d4a0590601a9aac9cb271405cbce6210847..a06ee0fb4864e9f65bf328e75a4c43d0b3b7b08b 100644 GIT binary patch literal 8053 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 literal 8361 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 literal 8037 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 N^x($Y<(du;{vW}JJ4^ro diff --git a/apps/weather/src/screen.rs b/apps/weather/src/screen.rs index d4017f5..a2e1a55 100644 --- a/apps/weather/src/screen.rs +++ b/apps/weather/src/screen.rs @@ -304,7 +304,7 @@ fn days_content(b: &mut Batch, flush: &mut Flush, page: Obj, m: &Model, wall: i3 room(b, flush)?; let y = ROWS_Y + k as i32 * DAY_H; label(b, page, if today { "Today" } else { model::weekday(abs) }, 96, -112, y + 6, 1)?; - icon(b, page, model::icon(d.code), false, -42, y + 4, 40)?; + icon(b, page, model::icon(d.code), false, -34, y + 4, 40)?; let lo_l = label(b, page, model::temp_text(d.min as i16).as_str(), 56, 6, y + 12, 3)?; small(b, lo_l, GREY)?; room(b, flush)?; From 12676019514efacad61829ba947c9f76ee2361a4 Mon Sep 17 00:00:00 2001 From: Egor Kolesnikov Date: Sat, 21 Nov 2026 22:25:16 +0200 Subject: [PATCH 12/12] weather: the stock round scroll bar on the hours and the days The crown stays with the pager, which scrolls a page first and pages at its end; the bar shows while its page scrolls and hides a second later, as in stock lists. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01CQSU8Lx87AsgWNq9fwhXi1 --- apps/weather/src/main.rs | 2 +- apps/weather/src/screen.rs | 19 +++++++++++++++---- apps/weather/src/screen_tests.rs | 4 ++++ 3 files changed, 20 insertions(+), 5 deletions(-) diff --git a/apps/weather/src/main.rs b/apps/weather/src/main.rs index 7a59628..0214e28 100644 --- a/apps/weather/src/main.rs +++ b/apps/weather/src/main.rs @@ -143,7 +143,7 @@ mod device { model.load(&blob[..n as usize]); } model.ask_now(api.now()); - let view = View { root: ROOT, pager: None }; + let view = View { root: ROOT, pager: None, bars: [ROOT; 3] }; let mut app = App { api, lv, b, model, view, page: 0, on_page: api.on_page(), shown: (0, false, 0), card: (Line::new(), Line::new()) }; app.draw(); diff --git a/apps/weather/src/screen.rs b/apps/weather/src/screen.rs index a2e1a55..7520886 100644 --- a/apps/weather/src/screen.rs +++ b/apps/weather/src/screen.rs @@ -330,8 +330,11 @@ fn days_content(b: &mut Batch, flush: &mut Flush, page: Obj, m: &Model, wall: i3 pub struct View { pub root: Obj, pub pager: Option>, + /// The stock round scroll bar of each page that scrolls (hours, days); `ROOT` for the rest. + pub bars: [Obj; 3], } + /// One line in the middle of the screen. pub fn message_view(b: &mut Batch, flush: &mut Flush, text: &str) -> Result { room(b, flush)?; @@ -340,7 +343,7 @@ pub fn message_view(b: &mut Batch, flush: &mut Flush, text: &str) -> Result 0 { - p.jump(b, page.min(2))?; + p.jump(b, page)?; } b.flags(p.root, &[], &[Flag::Hidden])?; - Ok(View { root: p.root, pager: Some(p) }) + Ok(View { root: p.root, pager: Some(p), bars }) } /// The page next to the watch face: the now screen alone. @@ -371,7 +382,7 @@ pub fn face_view(b: &mut Batch, flush: &mut Flush, m: &Model, wall: i32) -> Resu let r = root(b)?; now_content(b, flush, r, m, wall)?; b.flags(r, &[], &[Flag::Hidden])?; - Ok(View { root: r, pager: None }) + Ok(View { root: r, pager: None, bars: [ROOT; 3] }) } /// Deletes a screen. diff --git a/apps/weather/src/screen_tests.rs b/apps/weather/src/screen_tests.rs index f0f4934..58f5936 100644 --- a/apps/weather/src/screen_tests.rs +++ b/apps/weather/src/screen_tests.rs @@ -114,6 +114,10 @@ fn the_pages_validate_within_the_budgets_and_free_everything() { assert!(sizes.iter().all(|&s| s <= BUF)); let p = v.pager.expect("pages"); assert_eq!((p.at, p.n), (page, 3)); + assert_eq!(v.bars[0], ROOT, "now has no scroll bar"); + for bar in &v.bars[1..] { + assert_eq!(t.class(bar.0), Some(lvcmd::Class::ScrollBar)); + } assert!(live(&t) <= lvcmd::MAX_OBJS, "{} objects", live(&t)); std::println!("page {page}: {} objects, batches {sizes:?}", live(&t)); // leaving frees every handle