mirror of
https://github.com/Ark0N/Codeman.git
synced 2026-11-18 04:09:33 +01:00
The logo said one thing: agents are working. It now has a style of its own for each state the tabs show: at work, finished and waiting for you (yellow), and stopped on a permission or a question (red), set under View > Blink Apple Logo. The most urgent state with a style wins, red then yellow then work, and a state set to Off falls through to the next instead of silencing the logo. Red and yellow come from `GET /api/approvals`, the list the page rebuilds those tabs from after a reload, read natively for the reason the session list is: WebKit stalls a hidden page's stream. An idle item stops counting once it is acknowledged, so the logo stops when the tab's colour goes. The request is skipped while neither alert has a style, a 404 from an older server reads as no alerts, and a request that fails keeps the last answer. A dialog on screen costs the server one tmux capture per poll. Alarm is new: three sharp flashes and a short rest. It stays under the limit of three flashes in any second, so its urgency comes from its shape. A style saved by the earlier version stays as the one for work, and yellow and red start as Wink and Alarm, since whoever chose one asked for a logo that talks. `SETTLE` goes from 2 s to 3 s, the time the server takes to judge a new dialog, so a prompt answered before its hook landed never flashes red. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1370 lines
48 KiB
Rust
1370 lines
48 KiB
Rust
//! The lit Apple logo on the lid of a MacBook Pro with a PROLED XDR display
|
|
//! blinks with what the agents are doing, so you can read it across the room: one
|
|
//! rhythm while they work, another for a yellow tab (an agent finished and waits
|
|
//! for you) and a sharper one for a red tab (it needs a permission or an answer).
|
|
//! Opt-in (View menu, a style per state), and the menu exists only on a Mac that
|
|
//! has such a logo.
|
|
//!
|
|
//! Apple documents one control for the logo (support.apple.com/en-us/149248):
|
|
//! `sudo defaults write com.apple.CoreBrightness LEBacklightMode -int 0`. What
|
|
//! the app uses is the same setting, reached as a property of
|
|
//! `BrightnessSystemClient` in the private CoreBrightness framework, which needs
|
|
//! no administrator. Measured on a Mac17,13 with macOS 27.2 from an ad-hoc signed
|
|
//! binary: the write lands in about a millisecond with no fade, `corebrightnessd`
|
|
//! keeps it in its own defaults, and the NVRAM variable `bklb-backlight-enabled`
|
|
//! keeps its value while the logo is dark. The mode reads 2 when nothing was ever
|
|
//! set. A Mac without the logo answers nil, which is what `available` goes by; a
|
|
//! macOS that drops the property makes the feature disappear rather than fail.
|
|
//!
|
|
//! The setting is system-wide and survives a reboot, so the one thing that
|
|
//! must never happen is the app ending while the logo is dark. All of this
|
|
//! therefore runs in a child process (this same binary with `BLINK_ARG`), for as
|
|
//! long as any style is chosen and a server is open. The app hands it the server
|
|
//! and the login over a pipe (never on its command line, where `ps` shows them)
|
|
//! and keeps the pipe open. When the pipe closes, however the app ended (quit,
|
|
//! crash, `panic = "abort"`, Force Quit), the child puts the logo back and
|
|
//! exits. Switching it off closes the same pipe, so there is one way out
|
|
//! and it is the one a crash takes. For what even the child cannot survive
|
|
//! (power loss, a SIGKILL of the child itself), a marker file lies next to the
|
|
//! app's settings while a blink runs, and `recover` puts the logo back at the
|
|
//! next launch.
|
|
//!
|
|
//! When several states hold at once the most urgent one with a style is shown:
|
|
//! red, then yellow, then work.
|
|
//!
|
|
//! The child also does the asking (`agents`), so it needs nothing from the app
|
|
//! once started: a hidden window, a stalled page and App Nap cannot hold up the
|
|
//! logo, and the app's event loop gets no timers for it.
|
|
//!
|
|
//! The logo is only ever blinked from mode 2. A logo the user switched off
|
|
//! stays off, and a mode that changes under a running blink means someone else
|
|
//! wants the setting: the child leaves it as it found it and does not try again
|
|
//! until the agents have finished.
|
|
|
|
use crate::agents::Activity;
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::Value;
|
|
use std::io::Write;
|
|
use std::path::PathBuf;
|
|
use std::process::{ChildStdin, Command, Stdio};
|
|
use std::time::{Duration, Instant};
|
|
|
|
/// The argument that makes this binary the child instead of the app.
|
|
pub const BLINK_ARG: &str = "--logo-blink";
|
|
|
|
/// The logo is dark in every lighting condition (Apple's documented value).
|
|
const MODE_OFF: i64 = 0;
|
|
/// The logo follows the display and the ambient light. What the setting reads
|
|
/// on a Mac where nobody touched it.
|
|
const MODE_AUTO: i64 = 2;
|
|
|
|
/// One dark moment and the light after it.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
struct Beat {
|
|
dark: Duration,
|
|
lit: Duration,
|
|
}
|
|
|
|
const fn beat(dark_ms: u64, lit_ms: u64) -> Beat {
|
|
Beat {
|
|
dark: Duration::from_millis(dark_ms),
|
|
lit: Duration::from_millis(lit_ms),
|
|
}
|
|
}
|
|
|
|
/// A rhythm for the logo, the user's pick in the View menu for each `Signal`. A
|
|
/// style switches `LEBacklightMode`, which is on or off, so it is a rhythm of
|
|
/// hard changes.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub enum BlinkStyle {
|
|
/// The default: it changes a system-wide setting, so it is asked for.
|
|
#[default]
|
|
Off,
|
|
Calm,
|
|
Slow,
|
|
Wink,
|
|
Heartbeat,
|
|
Fast,
|
|
Alarm,
|
|
}
|
|
|
|
impl BlinkStyle {
|
|
pub const ALL: [BlinkStyle; 7] = [
|
|
BlinkStyle::Off,
|
|
BlinkStyle::Calm,
|
|
BlinkStyle::Slow,
|
|
BlinkStyle::Wink,
|
|
BlinkStyle::Heartbeat,
|
|
BlinkStyle::Fast,
|
|
BlinkStyle::Alarm,
|
|
];
|
|
|
|
pub fn label(self) -> &'static str {
|
|
match self {
|
|
BlinkStyle::Off => "Off",
|
|
BlinkStyle::Calm => "Calm",
|
|
BlinkStyle::Slow => "Slow",
|
|
BlinkStyle::Wink => "Wink",
|
|
BlinkStyle::Heartbeat => "Heartbeat",
|
|
BlinkStyle::Fast => "Fast",
|
|
BlinkStyle::Alarm => "Alarm",
|
|
}
|
|
}
|
|
|
|
pub fn menu_id(self, signal: Signal) -> String {
|
|
format!("logo-blink-{}-{}", signal.key(), self.label().to_ascii_lowercase())
|
|
}
|
|
|
|
pub fn from_menu_id(id: &str) -> Option<(Signal, Self)> {
|
|
Signal::ALL
|
|
.into_iter()
|
|
.flat_map(|signal| Self::ALL.map(|style| (signal, style)))
|
|
.find(|(signal, style)| style.menu_id(*signal) == id)
|
|
}
|
|
|
|
/// The rhythm, repeated for as long as its state holds.
|
|
const fn pattern(self) -> &'static [Beat] {
|
|
match self {
|
|
BlinkStyle::Off => &[],
|
|
BlinkStyle::Calm => CALM,
|
|
BlinkStyle::Slow => SLOW,
|
|
BlinkStyle::Wink => WINK,
|
|
BlinkStyle::Heartbeat => HEARTBEAT,
|
|
BlinkStyle::Fast => FAST,
|
|
BlinkStyle::Alarm => ALARM,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// What the logo can tell, in the order of the View menu.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum Signal {
|
|
Working,
|
|
Waiting,
|
|
NeedsYou,
|
|
}
|
|
|
|
impl Signal {
|
|
pub const ALL: [Signal; 3] = [Signal::Working, Signal::Waiting, Signal::NeedsYou];
|
|
|
|
pub fn label(self) -> &'static str {
|
|
match self {
|
|
Signal::Working => "While Working",
|
|
Signal::Waiting => "Waiting for You (Yellow)",
|
|
Signal::NeedsYou => "Needs Permission (Red)",
|
|
}
|
|
}
|
|
|
|
fn key(self) -> &'static str {
|
|
match self {
|
|
Signal::Working => "working",
|
|
Signal::Waiting => "waiting",
|
|
Signal::NeedsYou => "needs-you",
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The user's style for each `Signal`, `logoBlink` in the settings.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
|
|
#[serde(rename_all = "camelCase", default)]
|
|
pub struct BlinkStyles {
|
|
pub working: BlinkStyle,
|
|
pub waiting: BlinkStyle,
|
|
pub needs_you: BlinkStyle,
|
|
}
|
|
|
|
impl BlinkStyles {
|
|
/// Reads whatever the file holds. A bad value is off, for its state alone: it
|
|
/// must not make the file unreadable. A single style is what this setting was
|
|
/// before it had states: that was the choice for work, and whoever made it
|
|
/// gets the alerts with it, since they asked for a logo that talks.
|
|
pub fn read(value: &Value) -> Self {
|
|
let style = |value: Option<&Value>| {
|
|
value
|
|
.and_then(|value| serde_json::from_value(value.clone()).ok())
|
|
.unwrap_or_default()
|
|
};
|
|
match value {
|
|
Value::Object(styles) => BlinkStyles {
|
|
working: style(styles.get("working")),
|
|
waiting: style(styles.get("waiting")),
|
|
needs_you: style(styles.get("needsYou")),
|
|
},
|
|
Value::String(_) => match style(Some(value)) {
|
|
BlinkStyle::Off => Self::default(),
|
|
working => BlinkStyles {
|
|
working,
|
|
waiting: BlinkStyle::Wink,
|
|
needs_you: BlinkStyle::Alarm,
|
|
},
|
|
},
|
|
_ => Self::default(),
|
|
}
|
|
}
|
|
|
|
pub fn get(self, signal: Signal) -> BlinkStyle {
|
|
match signal {
|
|
Signal::Working => self.working,
|
|
Signal::Waiting => self.waiting,
|
|
Signal::NeedsYou => self.needs_you,
|
|
}
|
|
}
|
|
|
|
pub fn set(&mut self, signal: Signal, style: BlinkStyle) {
|
|
match signal {
|
|
Signal::Working => self.working = style,
|
|
Signal::Waiting => self.waiting = style,
|
|
Signal::NeedsYou => self.needs_you = style,
|
|
}
|
|
}
|
|
|
|
pub fn any(self) -> bool {
|
|
Signal::ALL.iter().any(|&signal| self.get(signal) != BlinkStyle::Off)
|
|
}
|
|
|
|
/// Whether anything but work has a style, which is what makes the alerts
|
|
/// worth asking the server for.
|
|
fn wants_alerts(self) -> bool {
|
|
self.waiting != BlinkStyle::Off || self.needs_you != BlinkStyle::Off
|
|
}
|
|
|
|
/// What the logo should do: the most urgent state that holds and has a
|
|
/// style. A state set to off is not a reason for silence, so it falls through.
|
|
fn pick(self, activity: Activity) -> BlinkStyle {
|
|
[
|
|
(activity.needs_you, self.needs_you),
|
|
(activity.waiting, self.waiting),
|
|
(activity.working, self.working),
|
|
]
|
|
.into_iter()
|
|
.find(|&(holds, style)| holds && style != BlinkStyle::Off)
|
|
.map_or(BlinkStyle::Off, |(_, style)| style)
|
|
}
|
|
}
|
|
|
|
// Every change of the logo is a preference write, so these also set how often
|
|
// that happens: from about one every two seconds (Slow, Wink) to about four a
|
|
// second (Alarm). No style goes above three flashes in any second, the limit
|
|
// accessibility guidelines set for flashing light, so what makes Alarm urgent
|
|
// is its shape: three hard flashes with a short rest, not a higher rate.
|
|
const CALM: &[Beat] = &[beat(800, 1200)];
|
|
const SLOW: &[Beat] = &[beat(1500, 3000)];
|
|
/// Mostly lit: a short dark moment every few seconds.
|
|
const WINK: &[Beat] = &[beat(250, 3500)];
|
|
/// Two quick beats, then a rest.
|
|
const HEARTBEAT: &[Beat] = &[beat(120, 180), beat(120, 1600)];
|
|
const FAST: &[Beat] = &[beat(300, 300)];
|
|
/// Three sharp flashes and a short rest, over and over: hey, I need something.
|
|
const ALARM: &[Beat] = &[beat(120, 120), beat(120, 120), beat(120, 900)];
|
|
|
|
/// How often to look again while the logo cannot be seen (the display sleeps,
|
|
/// the lid is closed). Nothing is written in that time.
|
|
const NOT_LIT_RECHECK: Duration = Duration::from_secs(2);
|
|
/// How long a change has to hold before the logo follows it, so a server
|
|
/// restart or an agent between two turns does not flicker it. Not below the 3 s
|
|
/// the server waits before it judges a new dialog: a prompt that was answered
|
|
/// before its hook landed lives that long and should never flash red.
|
|
const SETTLE: Duration = Duration::from_secs(3);
|
|
/// How often the child looks at what the poller found, and at the pipe.
|
|
const LOOK_EVERY: Duration = Duration::from_millis(250);
|
|
|
|
/// What a blink needs from the machine, so its decisions can be tested.
|
|
pub trait Logo {
|
|
/// The current mode, None if it could not be read.
|
|
fn mode(&self) -> Option<i64>;
|
|
/// Set the mode; false if the daemon did not take it.
|
|
fn set_mode(&self, mode: i64) -> bool;
|
|
/// What the logo is driven at in the current mode, in nits: 0 while it is
|
|
/// off for its own reasons (the display sleeps, the lid is closed).
|
|
fn nits(&self) -> Option<f64>;
|
|
}
|
|
|
|
/// The file that says a blink may have left the logo dark.
|
|
pub struct Marker(Option<PathBuf>);
|
|
|
|
impl Marker {
|
|
fn default_location() -> Self {
|
|
Marker(dirs::config_dir().map(|d| d.join("Codeman").join("logo-blink")))
|
|
}
|
|
|
|
fn set(&self) -> bool {
|
|
let Some(path) = &self.0 else { return false };
|
|
path.parent().is_some_and(|dir| std::fs::create_dir_all(dir).is_ok()) && std::fs::write(path, b"").is_ok()
|
|
}
|
|
|
|
fn clear(&self) {
|
|
if let Some(path) = &self.0 {
|
|
let _ = std::fs::remove_file(path);
|
|
}
|
|
}
|
|
|
|
fn is_set(&self) -> bool {
|
|
self.0.as_ref().is_some_and(|path| path.exists())
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq)]
|
|
enum Ended {
|
|
/// `wait` said stop, and the logo is lit again.
|
|
Stopped,
|
|
/// The logo is not ours to blink, or stopped doing what it is told.
|
|
Declined,
|
|
}
|
|
|
|
/// Blink until `wait` reports that it is time to stop, then leave the logo
|
|
/// lit. `wait` sleeps for the given time and answers true if the blink should
|
|
/// end. A marker that cannot be written refuses the blink: without it a power
|
|
/// cut in a dark phase would have no way back.
|
|
fn blink(logo: &impl Logo, marker: &Marker, pattern: &[Beat], mut wait: impl FnMut(Duration) -> bool) -> Ended {
|
|
if logo.mode() != Some(MODE_AUTO) || !marker.set() {
|
|
return Ended::Declined;
|
|
}
|
|
let mut dark = false;
|
|
let mut ended = Ended::Stopped;
|
|
for beat in pattern.iter().cycle() {
|
|
if logo.mode() != Some(MODE_AUTO) {
|
|
marker.clear();
|
|
return Ended::Declined;
|
|
}
|
|
if logo.nits() == Some(0.0) {
|
|
if wait(NOT_LIT_RECHECK) {
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if !logo.set_mode(MODE_OFF) {
|
|
ended = Ended::Declined;
|
|
break;
|
|
}
|
|
dark = true;
|
|
if wait(beat.dark) {
|
|
break;
|
|
}
|
|
if logo.mode() != Some(MODE_OFF) {
|
|
marker.clear();
|
|
return Ended::Declined;
|
|
}
|
|
if !logo.set_mode(MODE_AUTO) {
|
|
ended = Ended::Declined;
|
|
break;
|
|
}
|
|
dark = false;
|
|
if wait(beat.lit) {
|
|
break;
|
|
}
|
|
}
|
|
// A logo already lit needs no write, and a failed restore keeps the marker
|
|
// so the next launch tries again.
|
|
if !dark || logo.set_mode(MODE_AUTO) {
|
|
marker.clear();
|
|
}
|
|
ended
|
|
}
|
|
|
|
/// Put back a logo that a blink could not finish with.
|
|
pub fn recover(logo: &impl Logo, marker: &Marker) {
|
|
if !marker.is_set() {
|
|
return;
|
|
}
|
|
if logo.mode() != Some(MODE_OFF) || logo.set_mode(MODE_AUTO) {
|
|
marker.clear();
|
|
}
|
|
}
|
|
|
|
/// An answer that only changes once the new one has held for `SETTLE`.
|
|
struct Settled<T> {
|
|
answer: T,
|
|
latest: T,
|
|
changed_at: Instant,
|
|
}
|
|
|
|
impl<T: Copy + PartialEq> Settled<T> {
|
|
fn new(answer: T, now: Instant) -> Self {
|
|
Settled {
|
|
answer,
|
|
latest: answer,
|
|
changed_at: now,
|
|
}
|
|
}
|
|
|
|
fn update(&mut self, latest: T, now: Instant) -> T {
|
|
if latest != self.latest {
|
|
self.latest = latest;
|
|
self.changed_at = now;
|
|
}
|
|
if now.duration_since(self.changed_at) >= SETTLE {
|
|
self.answer = latest;
|
|
}
|
|
self.answer
|
|
}
|
|
}
|
|
|
|
/// What the child goes by.
|
|
trait Signals {
|
|
/// Sleep this long; true if the app went away, right when it did.
|
|
fn wait(&mut self, time: Duration) -> bool;
|
|
fn activity(&self) -> Activity;
|
|
fn now(&self) -> Instant;
|
|
}
|
|
|
|
/// The child's life: show what the agents are doing, until the app goes away. A
|
|
/// change of state ends the blink that is running, which leaves the logo lit, and
|
|
/// the next look starts the new one.
|
|
fn watch(logo: &impl Logo, marker: &Marker, styles: BlinkStyles, signals: &mut impl Signals) {
|
|
let mut settled = Settled::new(BlinkStyle::Off, signals.now());
|
|
let mut declined = false;
|
|
loop {
|
|
if signals.wait(LOOK_EVERY) {
|
|
return;
|
|
}
|
|
let style = settled.update(styles.pick(signals.activity()), signals.now());
|
|
if style == BlinkStyle::Off {
|
|
declined = false;
|
|
continue;
|
|
}
|
|
if declined {
|
|
continue;
|
|
}
|
|
let mut app_gone = false;
|
|
let ended = blink(logo, marker, style.pattern(), |time| {
|
|
let deadline = signals.now() + time;
|
|
loop {
|
|
let left = deadline.saturating_duration_since(signals.now());
|
|
if left.is_zero() {
|
|
return false;
|
|
}
|
|
if signals.wait(left.min(LOOK_EVERY)) {
|
|
app_gone = true;
|
|
return true;
|
|
}
|
|
if settled.update(styles.pick(signals.activity()), signals.now()) != style {
|
|
return true;
|
|
}
|
|
}
|
|
});
|
|
if app_gone {
|
|
return;
|
|
}
|
|
declined = ended == Ended::Declined;
|
|
}
|
|
}
|
|
|
|
/// The one line the app writes to the child.
|
|
#[derive(Serialize, Deserialize)]
|
|
struct Connection {
|
|
server: String,
|
|
authorization: Option<String>,
|
|
styles: BlinkStyles,
|
|
}
|
|
|
|
/// The app's side: the pipe to the child, which is all there is to it.
|
|
#[derive(Default)]
|
|
pub struct Watcher {
|
|
current: Option<(Connection, ChildStdin)>,
|
|
}
|
|
|
|
impl Watcher {
|
|
/// Watch this server with this login in these styles, or nothing. A child
|
|
/// for anything else ends first: its pipe closes with the old value. It is
|
|
/// back to lit well before the next child looks, which takes `SETTLE`.
|
|
pub fn sync(&mut self, want: Option<(&str, Option<&str>, BlinkStyles)>) {
|
|
let same = match (&self.current, want) {
|
|
(Some((now, _)), Some((server, authorization, styles))) => {
|
|
now.server == server && now.authorization.as_deref() == authorization && now.styles == styles
|
|
}
|
|
(None, None) => true,
|
|
_ => false,
|
|
};
|
|
if same {
|
|
return;
|
|
}
|
|
self.current = want.and_then(|(server, authorization, styles)| {
|
|
spawn_child(Connection {
|
|
server: server.to_owned(),
|
|
authorization: authorization.map(str::to_owned),
|
|
styles,
|
|
})
|
|
});
|
|
}
|
|
}
|
|
|
|
fn spawn_child(connection: Connection) -> Option<(Connection, ChildStdin)> {
|
|
let exe = std::env::current_exe().ok()?;
|
|
let mut child = Command::new(exe)
|
|
.arg(BLINK_ARG)
|
|
.stdin(Stdio::piped())
|
|
.stdout(Stdio::null())
|
|
.spawn()
|
|
.ok()?;
|
|
let mut stdin = child.stdin.take()?;
|
|
let line = serde_json::to_string(&connection).ok()? + "\n";
|
|
stdin.write_all(line.as_bytes()).ok()?;
|
|
// It ends by itself once the pipe closes. This only collects it.
|
|
std::thread::spawn(move || {
|
|
let _ = child.wait();
|
|
});
|
|
Some((connection, stdin))
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
pub use system::{available, blink_main, recover_at_launch, switched_off};
|
|
|
|
#[cfg(not(target_os = "macos"))]
|
|
pub fn available() -> bool {
|
|
false
|
|
}
|
|
|
|
#[cfg(not(target_os = "macos"))]
|
|
pub fn blink_main() -> ! {
|
|
std::process::exit(0)
|
|
}
|
|
|
|
#[cfg(not(target_os = "macos"))]
|
|
pub fn recover_at_launch() {}
|
|
|
|
#[cfg(not(target_os = "macos"))]
|
|
pub fn switched_off() -> bool {
|
|
false
|
|
}
|
|
|
|
#[cfg(target_os = "macos")]
|
|
mod system {
|
|
use super::{recover, watch, Connection, Logo, Marker, Signals, MODE_OFF};
|
|
use crate::agents::{Activity, Poll, Poller, POLL_EVERY};
|
|
use objc2::rc::{autoreleasepool, Retained};
|
|
use objc2::runtime::{AnyClass, AnyObject};
|
|
use objc2::{msg_send, sel};
|
|
use objc2_foundation::{ns_string, NSBundle, NSDictionary, NSNumber, NSString};
|
|
use std::io::Read;
|
|
use std::sync::mpsc::{self, Receiver, RecvTimeoutError};
|
|
use std::sync::{Arc, Mutex, OnceLock};
|
|
use std::time::{Duration, Instant};
|
|
use url::Url;
|
|
|
|
struct SystemLogo {
|
|
client: Retained<AnyObject>,
|
|
}
|
|
|
|
impl SystemLogo {
|
|
/// The framework is private, so it is looked up at run time and never
|
|
/// linked: on a macOS without it this is None, not a failed launch.
|
|
fn open() -> Option<Self> {
|
|
autoreleasepool(|_| {
|
|
let path = ns_string!("/System/Library/PrivateFrameworks/CoreBrightness.framework");
|
|
let bundle = NSBundle::bundleWithPath(path)?;
|
|
// SAFETY: an Apple system framework, which every process that
|
|
// shows a window has mapped already; it runs no code of ours.
|
|
if !unsafe { bundle.load() } {
|
|
return None;
|
|
}
|
|
let class = AnyClass::get(c"BrightnessSystemClient")?;
|
|
let answers = class.instance_method(sel!(copyPropertyForKey:)).is_some()
|
|
&& class.instance_method(sel!(setProperty:forKey:)).is_some();
|
|
if !answers {
|
|
return None;
|
|
}
|
|
// SAFETY: `new` is NSObject's, and the class was checked above.
|
|
let client: Option<Retained<AnyObject>> = unsafe { msg_send![class, new] };
|
|
client.map(|client| SystemLogo { client })
|
|
})
|
|
}
|
|
|
|
fn property(&self, key: &NSString) -> Option<Retained<AnyObject>> {
|
|
// SAFETY: the method was checked in `open`. It takes a string and
|
|
// answers an owned object or nil.
|
|
unsafe { msg_send![&*self.client, copyPropertyForKey: key] }
|
|
}
|
|
}
|
|
|
|
impl Logo for SystemLogo {
|
|
fn mode(&self) -> Option<i64> {
|
|
autoreleasepool(|_| {
|
|
let value = self.property(ns_string!("LEBacklightMode"))?;
|
|
Some(value.downcast_ref::<NSNumber>()?.as_i64())
|
|
})
|
|
}
|
|
|
|
fn set_mode(&self, mode: i64) -> bool {
|
|
autoreleasepool(|_| {
|
|
let value = NSNumber::new_i64(mode);
|
|
// SAFETY: the method was checked in `open`. It takes an object
|
|
// and a string and answers a BOOL.
|
|
unsafe { msg_send![&*self.client, setProperty: &*value, forKey: ns_string!("LEBacklightMode")] }
|
|
})
|
|
}
|
|
|
|
fn nits(&self) -> Option<f64> {
|
|
autoreleasepool(|_| {
|
|
let state = self.property(ns_string!("LEPWMState"))?;
|
|
let state = state.downcast_ref::<NSDictionary>()?;
|
|
// SAFETY: an NSDictionary answers objectForKey:, with nil for a
|
|
// key it does not have.
|
|
let value: Option<Retained<AnyObject>> =
|
|
unsafe { msg_send![state, objectForKey: ns_string!("FinalNits")] };
|
|
Some(value?.downcast_ref::<NSNumber>()?.as_f64())
|
|
})
|
|
}
|
|
}
|
|
|
|
/// Whether this Mac has a logo the app can drive. Asked once: the answer
|
|
/// is the hardware's and takes a few milliseconds.
|
|
pub fn available() -> bool {
|
|
static AVAILABLE: OnceLock<bool> = OnceLock::new();
|
|
*AVAILABLE.get_or_init(|| SystemLogo::open().is_some_and(|logo| logo.mode().is_some()))
|
|
}
|
|
|
|
/// The user (or anything else that is not a blink) has the logo off.
|
|
pub fn switched_off() -> bool {
|
|
SystemLogo::open().is_some_and(|logo| logo.mode() == Some(MODE_OFF))
|
|
}
|
|
|
|
pub fn recover_at_launch() {
|
|
let marker = Marker::default_location();
|
|
if marker.is_set() {
|
|
if let Some(logo) = SystemLogo::open() {
|
|
recover(&logo, &marker);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct Live {
|
|
pipe_closed: Receiver<()>,
|
|
activity: Arc<Mutex<Activity>>,
|
|
}
|
|
|
|
impl Signals for Live {
|
|
fn wait(&mut self, time: Duration) -> bool {
|
|
!matches!(self.pipe_closed.recv_timeout(time), Err(RecvTimeoutError::Timeout))
|
|
}
|
|
|
|
fn activity(&self) -> Activity {
|
|
self.activity.lock().map_or(Activity::default(), |activity| *activity)
|
|
}
|
|
|
|
fn now(&self) -> Instant {
|
|
Instant::now()
|
|
}
|
|
}
|
|
|
|
/// Runs for the life of the child. A server that does not answer counts as
|
|
/// nothing going on, and one that refuses the login is never asked again.
|
|
fn poll_until_refused(mut poller: Poller, shared: &Mutex<Activity>) {
|
|
loop {
|
|
let poll = poller.poll();
|
|
if let Ok(mut activity) = shared.lock() {
|
|
*activity = match poll {
|
|
Poll::Seen(seen) => seen,
|
|
_ => Activity::default(),
|
|
};
|
|
}
|
|
if poll == Poll::Refused {
|
|
return;
|
|
}
|
|
std::thread::sleep(POLL_EVERY);
|
|
}
|
|
}
|
|
|
|
/// The child process. It ends when the pipe from the app closes, and the
|
|
/// signals that would end it sooner are ignored, because they arrive
|
|
/// together with the app's own end (a logout, Ctrl-C on a terminal that
|
|
/// started the app) and could land in a dark phase.
|
|
pub fn blink_main() -> ! {
|
|
// SAFETY: `signal` with SIG_IGN, before any other thread exists.
|
|
unsafe {
|
|
for signal in [libc::SIGHUP, libc::SIGINT, libc::SIGTERM] {
|
|
libc::signal(signal, libc::SIG_IGN);
|
|
}
|
|
}
|
|
let mut line = String::new();
|
|
let connection = std::io::stdin()
|
|
.read_line(&mut line)
|
|
.ok()
|
|
.and_then(|_| serde_json::from_str::<Connection>(&line).ok());
|
|
let Some(Connection {
|
|
server,
|
|
authorization,
|
|
styles,
|
|
}) = connection
|
|
else {
|
|
std::process::exit(0);
|
|
};
|
|
let poller = Url::parse(&server)
|
|
.ok()
|
|
.and_then(|url| Poller::new(&url, authorization, styles.wants_alerts()));
|
|
let (Some(poller), Some(logo)) = (poller, SystemLogo::open()) else {
|
|
std::process::exit(0);
|
|
};
|
|
|
|
let (closed, pipe_closed) = mpsc::channel::<()>();
|
|
std::thread::spawn(move || {
|
|
let mut stdin = std::io::stdin().lock();
|
|
let mut buf = [0u8; 64];
|
|
while matches!(stdin.read(&mut buf), Ok(n) if n > 0) {}
|
|
let _ = closed.send(());
|
|
});
|
|
let activity = Arc::new(Mutex::new(Activity::default()));
|
|
let found = activity.clone();
|
|
std::thread::spawn(move || poll_until_refused(poller, &found));
|
|
|
|
let mut signals = Live { pipe_closed, activity };
|
|
watch(&logo, &Marker::default_location(), styles, &mut signals);
|
|
std::process::exit(0)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use std::cell::{Cell, RefCell};
|
|
|
|
const DARK_FOR: Duration = CALM[0].dark;
|
|
const LIT_FOR: Duration = CALM[0].lit;
|
|
/// The style most of these tests watch with: work only.
|
|
const WORK: BlinkStyles = BlinkStyles {
|
|
working: BlinkStyle::Calm,
|
|
waiting: BlinkStyle::Off,
|
|
needs_you: BlinkStyle::Off,
|
|
};
|
|
|
|
fn working() -> Activity {
|
|
Activity {
|
|
working: true,
|
|
..Activity::default()
|
|
}
|
|
}
|
|
|
|
fn waiting() -> Activity {
|
|
Activity {
|
|
waiting: true,
|
|
..Activity::default()
|
|
}
|
|
}
|
|
|
|
fn needs_you() -> Activity {
|
|
Activity {
|
|
needs_you: true,
|
|
..Activity::default()
|
|
}
|
|
}
|
|
|
|
/// A logo that records every write.
|
|
struct FakeLogo {
|
|
mode: Cell<i64>,
|
|
nits: Cell<f64>,
|
|
writes: RefCell<Vec<i64>>,
|
|
refuse_writes: Cell<bool>,
|
|
}
|
|
|
|
impl FakeLogo {
|
|
fn new(mode: i64) -> Self {
|
|
FakeLogo {
|
|
mode: Cell::new(mode),
|
|
nits: Cell::new(200.0),
|
|
writes: RefCell::new(Vec::new()),
|
|
refuse_writes: Cell::new(false),
|
|
}
|
|
}
|
|
|
|
fn writes(&self) -> Vec<i64> {
|
|
self.writes.borrow().clone()
|
|
}
|
|
}
|
|
|
|
impl Logo for FakeLogo {
|
|
fn mode(&self) -> Option<i64> {
|
|
Some(self.mode.get())
|
|
}
|
|
|
|
fn set_mode(&self, mode: i64) -> bool {
|
|
if self.refuse_writes.get() {
|
|
return false;
|
|
}
|
|
self.mode.set(mode);
|
|
self.writes.borrow_mut().push(mode);
|
|
true
|
|
}
|
|
|
|
fn nits(&self) -> Option<f64> {
|
|
Some(self.nits.get())
|
|
}
|
|
}
|
|
|
|
fn temp_marker(name: &str) -> (Marker, PathBuf) {
|
|
let dir = std::env::temp_dir().join(format!("codeman-logo-{}-{name}", std::process::id()));
|
|
let path = dir.join("nested").join("logo-blink");
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
(Marker(Some(path.clone())), path)
|
|
}
|
|
|
|
/// A `wait` that stops the blink on its Nth call, and records the times.
|
|
fn stop_on(call: usize, times: &RefCell<Vec<Duration>>) -> impl FnMut(Duration) -> bool + '_ {
|
|
move |time| {
|
|
times.borrow_mut().push(time);
|
|
times.borrow().len() >= call
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_blink_alternates_and_ends_lit() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, path) = temp_marker("alternates");
|
|
let times = RefCell::new(Vec::new());
|
|
blink(&logo, &marker, CALM, stop_on(4, ×));
|
|
// dark, lit, dark, and the stop in the fourth wait is a dark phase's.
|
|
assert_eq!(logo.writes(), [MODE_OFF, MODE_AUTO, MODE_OFF, MODE_AUTO]);
|
|
assert_eq!(*times.borrow(), [DARK_FOR, LIT_FOR, DARK_FOR, LIT_FOR]);
|
|
assert_eq!(logo.mode.get(), MODE_AUTO);
|
|
assert!(!path.exists(), "a finished blink leaves no marker");
|
|
}
|
|
|
|
#[test]
|
|
fn a_stop_in_a_dark_phase_restores_the_logo_at_once() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, path) = temp_marker("dark-stop");
|
|
let times = RefCell::new(Vec::new());
|
|
blink(&logo, &marker, CALM, stop_on(1, ×));
|
|
assert_eq!(logo.writes(), [MODE_OFF, MODE_AUTO]);
|
|
assert!(!path.exists());
|
|
}
|
|
|
|
#[test]
|
|
fn a_stop_while_lit_writes_nothing_more() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, _) = temp_marker("lit-stop");
|
|
let times = RefCell::new(Vec::new());
|
|
blink(&logo, &marker, CALM, stop_on(2, ×));
|
|
assert_eq!(logo.writes(), [MODE_OFF, MODE_AUTO]);
|
|
}
|
|
|
|
#[test]
|
|
fn a_logo_the_user_switched_off_is_left_alone() {
|
|
for mode in [MODE_OFF, 1, 7] {
|
|
let logo = FakeLogo::new(mode);
|
|
let (marker, path) = temp_marker("user-off");
|
|
let times = RefCell::new(Vec::new());
|
|
assert_eq!(blink(&logo, &marker, CALM, stop_on(1, ×)), Ended::Declined);
|
|
assert_eq!(logo.writes(), [] as [i64; 0]);
|
|
assert!(times.borrow().is_empty(), "it does not even wait");
|
|
assert!(!path.exists());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_marker_that_cannot_be_written_refuses_the_blink() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let times = RefCell::new(Vec::new());
|
|
assert_eq!(blink(&logo, &Marker(None), CALM, stop_on(1, ×)), Ended::Declined);
|
|
assert_eq!(logo.writes(), [] as [i64; 0]);
|
|
}
|
|
|
|
#[test]
|
|
fn a_mode_changed_from_outside_ends_the_blink_without_a_write() {
|
|
// Someone switches the logo off during a lit phase: their setting stands.
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, path) = temp_marker("outside-lit");
|
|
let mut calls = 0;
|
|
let ended = blink(&logo, &marker, CALM, |_| {
|
|
calls += 1;
|
|
if calls == 2 {
|
|
logo.mode.set(MODE_OFF);
|
|
}
|
|
false
|
|
});
|
|
assert_eq!(ended, Ended::Declined);
|
|
assert_eq!(logo.writes(), [MODE_OFF, MODE_AUTO]);
|
|
assert_eq!(logo.mode.get(), MODE_OFF);
|
|
assert!(!path.exists());
|
|
|
|
// Someone deletes the setting during a dark phase: it stays as they left it.
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, path) = temp_marker("outside-dark");
|
|
let ended = blink(&logo, &marker, CALM, |_| {
|
|
logo.mode.set(MODE_AUTO);
|
|
false
|
|
});
|
|
assert_eq!(ended, Ended::Declined);
|
|
assert_eq!(logo.writes(), [MODE_OFF]);
|
|
assert!(!path.exists());
|
|
}
|
|
|
|
#[test]
|
|
fn nothing_is_written_while_the_logo_cannot_be_seen() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
logo.nits.set(0.0);
|
|
let (marker, path) = temp_marker("not-lit");
|
|
let times = RefCell::new(Vec::new());
|
|
blink(&logo, &marker, CALM, stop_on(3, ×));
|
|
assert_eq!(logo.writes(), [] as [i64; 0]);
|
|
assert_eq!(*times.borrow(), [NOT_LIT_RECHECK; 3]);
|
|
assert!(!path.exists());
|
|
}
|
|
|
|
#[test]
|
|
fn a_blink_resumes_when_the_logo_comes_back() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
logo.nits.set(0.0);
|
|
let (marker, _) = temp_marker("wakes");
|
|
let mut calls = 0;
|
|
blink(&logo, &marker, CALM, |_| {
|
|
calls += 1;
|
|
logo.nits.set(200.0);
|
|
calls == 2
|
|
});
|
|
assert_eq!(logo.writes(), [MODE_OFF, MODE_AUTO]);
|
|
}
|
|
|
|
#[test]
|
|
fn a_failed_restore_keeps_the_marker_for_the_next_launch() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, path) = temp_marker("failed-restore");
|
|
blink(&logo, &marker, CALM, |_| {
|
|
logo.refuse_writes.set(true);
|
|
true
|
|
});
|
|
assert_eq!(logo.mode.get(), MODE_OFF);
|
|
assert!(path.exists());
|
|
logo.refuse_writes.set(false);
|
|
recover(&logo, &marker);
|
|
assert_eq!(logo.mode.get(), MODE_AUTO);
|
|
assert!(!path.exists());
|
|
}
|
|
|
|
#[test]
|
|
fn recover_needs_the_marker() {
|
|
let logo = FakeLogo::new(MODE_OFF);
|
|
let (marker, _) = temp_marker("no-marker");
|
|
recover(&logo, &marker);
|
|
assert_eq!(
|
|
logo.writes(),
|
|
[] as [i64; 0],
|
|
"without a marker a dark logo is the user's"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn recover_leaves_a_lit_logo_and_clears_the_marker() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, path) = temp_marker("lit-recover");
|
|
assert!(marker.set());
|
|
recover(&logo, &marker);
|
|
assert_eq!(logo.writes(), [] as [i64; 0]);
|
|
assert!(!path.exists());
|
|
}
|
|
|
|
#[test]
|
|
fn a_change_counts_once_it_held() {
|
|
let t0 = Instant::now();
|
|
let mut settled = Settled::new(false, t0);
|
|
assert!(!settled.update(true, t0));
|
|
assert!(!settled.update(true, t0 + SETTLE - Duration::from_millis(1)));
|
|
assert!(settled.update(true, t0 + SETTLE));
|
|
// Back to false and on again within the time changes nothing.
|
|
let t1 = t0 + Duration::from_secs(10);
|
|
assert!(settled.update(false, t1));
|
|
assert!(settled.update(true, t1 + Duration::from_secs(1)));
|
|
assert!(settled.update(true, t1 + Duration::from_secs(9)));
|
|
assert!(settled.update(false, t1 + Duration::from_secs(10)));
|
|
assert!(!settled.update(false, t1 + Duration::from_secs(10) + SETTLE));
|
|
}
|
|
|
|
#[test]
|
|
fn a_new_dialog_is_judged_before_the_logo_would_follow_it() {
|
|
// The server's check of a new dialog (`STALE_CHECK_DELAY_MS`), which a
|
|
// prompt answered before its hook landed does not survive.
|
|
assert!(SETTLE >= Duration::from_secs(3));
|
|
}
|
|
|
|
/// A clock that `wait` moves, and a server that shows the given activity in
|
|
/// the given spans of time. The app goes away at `app_gone_at`.
|
|
struct Script {
|
|
start: Instant,
|
|
clock: Cell<Instant>,
|
|
spans: Vec<(u64, u64, Activity)>,
|
|
app_gone_at: u64,
|
|
}
|
|
|
|
impl Script {
|
|
fn new(work: &[(u64, u64)], app_gone_at: u64) -> Self {
|
|
let spans: Vec<_> = work.iter().map(|&(from, to)| (from, to, working())).collect();
|
|
Self::with(&spans, app_gone_at)
|
|
}
|
|
|
|
fn with(spans: &[(u64, u64, Activity)], app_gone_at: u64) -> Self {
|
|
let start = Instant::now();
|
|
Script {
|
|
start,
|
|
clock: Cell::new(start),
|
|
spans: spans.to_vec(),
|
|
app_gone_at,
|
|
}
|
|
}
|
|
|
|
fn elapsed_ms(&self) -> u64 {
|
|
self.clock.get().duration_since(self.start).as_millis() as u64
|
|
}
|
|
}
|
|
|
|
impl Signals for Script {
|
|
fn wait(&mut self, time: Duration) -> bool {
|
|
self.clock.set(self.clock.get() + time);
|
|
self.elapsed_ms() >= self.app_gone_at
|
|
}
|
|
|
|
fn activity(&self) -> Activity {
|
|
let t = self.elapsed_ms();
|
|
self.spans
|
|
.iter()
|
|
.find(|&&(from, to, _)| t >= from && t < to)
|
|
.map_or(Activity::default(), |&(_, _, activity)| activity)
|
|
}
|
|
|
|
fn now(&self) -> Instant {
|
|
self.clock.get()
|
|
}
|
|
}
|
|
|
|
const CYCLE_MS: u64 = (LIT_FOR.as_millis() + DARK_FOR.as_millis()) as u64;
|
|
|
|
#[test]
|
|
fn nothing_is_written_while_no_agent_works() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, _) = temp_marker("watch-quiet");
|
|
watch(&logo, &marker, WORK, &mut Script::new(&[], 60_000));
|
|
assert_eq!(logo.writes(), [] as [i64; 0]);
|
|
}
|
|
|
|
#[test]
|
|
fn a_short_flicker_of_work_does_not_blink() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, _) = temp_marker("watch-flicker");
|
|
watch(&logo, &marker, WORK, &mut Script::new(&[(1_000, 2_500)], 60_000));
|
|
assert_eq!(logo.writes(), [] as [i64; 0]);
|
|
}
|
|
|
|
#[test]
|
|
fn it_blinks_for_the_length_of_the_work_and_ends_lit() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, path) = temp_marker("watch-turn");
|
|
let mut script = Script::new(&[(1_000, 21_000)], 60_000);
|
|
watch(&logo, &marker, WORK, &mut script);
|
|
let writes = logo.writes();
|
|
let dark_phases = writes.iter().filter(|&&m| m == MODE_OFF).count() as u64;
|
|
// Settling delays the start and the end alike, so the blink lasts as long
|
|
// as the 20 s of work did, with one dark phase a cycle.
|
|
let cycles = 20_000 / CYCLE_MS;
|
|
assert!(dark_phases >= cycles, "{dark_phases} dark phases, {cycles} cycles");
|
|
assert!(dark_phases <= cycles + 2, "{dark_phases} dark phases, {cycles} cycles");
|
|
assert_eq!(logo.mode.get(), MODE_AUTO);
|
|
assert!(!path.exists());
|
|
}
|
|
|
|
#[test]
|
|
fn the_end_of_the_work_stops_a_blink_in_the_middle_of_a_dark_phase() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, _) = temp_marker("watch-stop");
|
|
// Work has to hold to start and to stop. Started at about 4.25 s, a dark
|
|
// phase runs from every 2 s after that, and work that ends at 5.5 s
|
|
// settles at 8.5 s, inside the third one.
|
|
let mut script = Script::new(&[(1_000, 5_500)], 60_000);
|
|
watch(&logo, &marker, WORK, &mut script);
|
|
assert_eq!(
|
|
logo.writes(),
|
|
[MODE_OFF, MODE_AUTO, MODE_OFF, MODE_AUTO, MODE_OFF, MODE_AUTO]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_gap_between_two_turns_does_not_stop_the_blink() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, _) = temp_marker("watch-gap");
|
|
let mut script = Script::new(&[(1_000, 15_000), (16_000, 30_000)], 60_000);
|
|
watch(&logo, &marker, WORK, &mut script);
|
|
let writes = logo.writes();
|
|
let dark_phases = writes.iter().filter(|&&m| m == MODE_OFF).count() as u64;
|
|
assert!(
|
|
dark_phases >= (29_000 - 2 * SETTLE.as_millis() as u64) / CYCLE_MS,
|
|
"{dark_phases}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_app_going_away_in_a_dark_phase_puts_the_logo_back() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, path) = temp_marker("watch-gone");
|
|
// Work from the start; the first dark phase begins once it has settled.
|
|
watch(&logo, &marker, WORK, &mut Script::new(&[(0, 60_000)], 3_500));
|
|
assert_eq!(logo.writes(), [MODE_OFF, MODE_AUTO]);
|
|
assert!(!path.exists());
|
|
}
|
|
|
|
#[test]
|
|
fn a_logo_the_user_switched_off_is_not_asked_again_during_the_work() {
|
|
let logo = FakeLogo::new(MODE_OFF);
|
|
let (marker, _) = temp_marker("watch-declined");
|
|
let mut script = Script::new(&[(0, 30_000)], 60_000);
|
|
watch(&logo, &marker, WORK, &mut script);
|
|
assert_eq!(logo.writes(), [] as [i64; 0]);
|
|
}
|
|
|
|
#[test]
|
|
fn after_the_agents_finish_it_may_ask_again() {
|
|
// Declined in the first turn, the logo is back on for the second.
|
|
let logo = FakeLogo::new(MODE_OFF);
|
|
let (marker, _) = temp_marker("watch-again");
|
|
let mut script = Script::new(&[(0, 5_000), (20_000, 30_000)], 60_000);
|
|
struct TurnsOn<'a>(&'a mut Script, &'a FakeLogo);
|
|
impl Signals for TurnsOn<'_> {
|
|
fn wait(&mut self, time: Duration) -> bool {
|
|
let gone = self.0.wait(time);
|
|
if self.0.elapsed_ms() >= 10_000 && self.0.elapsed_ms() < 10_300 {
|
|
self.1.mode.set(MODE_AUTO);
|
|
}
|
|
gone
|
|
}
|
|
fn activity(&self) -> Activity {
|
|
self.0.activity()
|
|
}
|
|
fn now(&self) -> Instant {
|
|
self.0.now()
|
|
}
|
|
}
|
|
watch(&logo, &marker, WORK, &mut TurnsOn(&mut script, &logo));
|
|
assert!(logo.writes().contains(&MODE_OFF), "{:?}", logo.writes());
|
|
assert_eq!(logo.mode.get(), MODE_AUTO);
|
|
}
|
|
|
|
#[test]
|
|
fn the_connection_line_round_trips_with_and_without_a_login() {
|
|
for authorization in [None, Some("Basic abc".to_string())] {
|
|
let line = serde_json::to_string(&Connection {
|
|
server: "http://127.0.0.1:3000/".into(),
|
|
authorization: authorization.clone(),
|
|
styles: WORK,
|
|
})
|
|
.unwrap();
|
|
assert!(!line.contains('\n'), "one line");
|
|
let back: Connection = serde_json::from_str(&line).unwrap();
|
|
assert_eq!(back.server, "http://127.0.0.1:3000/");
|
|
assert_eq!(back.authorization, authorization);
|
|
assert_eq!(back.styles, WORK);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_style_of_several_beats_runs_them_in_turn() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, _) = temp_marker("beats");
|
|
let pattern = BlinkStyle::Heartbeat.pattern();
|
|
let times = RefCell::new(Vec::new());
|
|
blink(&logo, &marker, pattern, stop_on(6, ×));
|
|
let [one, two] = pattern else { panic!("two beats") };
|
|
assert_eq!(
|
|
*times.borrow(),
|
|
[one.dark, one.lit, two.dark, two.lit, one.dark, one.lit]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn every_style_but_off_has_a_rhythm_with_light_and_dark() {
|
|
for style in BlinkStyle::ALL {
|
|
if style == BlinkStyle::Off {
|
|
assert!(style.pattern().is_empty());
|
|
continue;
|
|
}
|
|
assert!(!style.pattern().is_empty(), "{style:?}");
|
|
for beat in style.pattern() {
|
|
assert!(!beat.dark.is_zero() && !beat.lit.is_zero(), "{style:?}");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn no_style_flashes_more_than_three_times_in_any_second() {
|
|
for style in BlinkStyle::ALL {
|
|
let mut starts = Vec::new();
|
|
let mut at = Duration::ZERO;
|
|
for beat in style.pattern().iter().cycle().take(40) {
|
|
starts.push(at);
|
|
at += beat.dark + beat.lit;
|
|
}
|
|
for (i, from) in starts.iter().enumerate() {
|
|
let in_a_second = starts[i..].iter().filter(|&&t| t - *from < Duration::from_secs(1));
|
|
assert!(in_a_second.count() <= 3, "{style:?}");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn a_menu_id_names_its_state_and_style_and_nothing_else() {
|
|
for signal in Signal::ALL {
|
|
for style in BlinkStyle::ALL {
|
|
assert_eq!(BlinkStyle::from_menu_id(&style.menu_id(signal)), Some((signal, style)));
|
|
}
|
|
}
|
|
assert_eq!(BlinkStyle::from_menu_id("reload"), None);
|
|
assert_eq!(BlinkStyle::from_menu_id("logo-blink-calm"), None);
|
|
assert_eq!(BlinkStyle::from_menu_id(""), None);
|
|
}
|
|
|
|
const ALL_ON: BlinkStyles = BlinkStyles {
|
|
working: BlinkStyle::Calm,
|
|
waiting: BlinkStyle::Wink,
|
|
needs_you: BlinkStyle::Alarm,
|
|
};
|
|
|
|
#[test]
|
|
fn the_most_urgent_state_wins() {
|
|
let everything = Activity {
|
|
working: true,
|
|
waiting: true,
|
|
needs_you: true,
|
|
};
|
|
assert_eq!(ALL_ON.pick(everything), BlinkStyle::Alarm);
|
|
assert_eq!(
|
|
ALL_ON.pick(Activity {
|
|
needs_you: false,
|
|
..everything
|
|
}),
|
|
BlinkStyle::Wink
|
|
);
|
|
assert_eq!(ALL_ON.pick(working()), BlinkStyle::Calm);
|
|
assert_eq!(ALL_ON.pick(Activity::default()), BlinkStyle::Off);
|
|
}
|
|
|
|
#[test]
|
|
fn a_state_set_to_off_falls_through_to_the_next_one() {
|
|
let everything = Activity {
|
|
working: true,
|
|
waiting: true,
|
|
needs_you: true,
|
|
};
|
|
let mut styles = ALL_ON;
|
|
styles.needs_you = BlinkStyle::Off;
|
|
assert_eq!(styles.pick(everything), BlinkStyle::Wink);
|
|
styles.waiting = BlinkStyle::Off;
|
|
assert_eq!(styles.pick(everything), BlinkStyle::Calm);
|
|
styles.working = BlinkStyle::Off;
|
|
assert_eq!(styles.pick(everything), BlinkStyle::Off);
|
|
}
|
|
|
|
#[test]
|
|
fn a_state_with_no_style_touches_nothing_not_even_the_marker() {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, path) = temp_marker("no-style");
|
|
struct Watching<'a>(Script, &'a PathBuf);
|
|
impl Signals for Watching<'_> {
|
|
fn wait(&mut self, time: Duration) -> bool {
|
|
assert!(!self.1.exists(), "no marker was ever needed");
|
|
self.0.wait(time)
|
|
}
|
|
fn activity(&self) -> Activity {
|
|
self.0.activity()
|
|
}
|
|
fn now(&self) -> Instant {
|
|
self.0.now()
|
|
}
|
|
}
|
|
let script = Script::with(&[(0, 30_000, waiting())], 40_000);
|
|
watch(&logo, &marker, WORK, &mut Watching(script, &path));
|
|
assert_eq!(logo.writes(), [] as [i64; 0]);
|
|
}
|
|
|
|
fn dark_phases(styles: BlinkStyles, spans: &[(u64, u64, Activity)], end: u64) -> usize {
|
|
let logo = FakeLogo::new(MODE_AUTO);
|
|
let (marker, path) = temp_marker("phases");
|
|
watch(&logo, &marker, styles, &mut Script::with(spans, end));
|
|
assert_eq!(logo.mode.get(), MODE_AUTO, "it ends lit");
|
|
assert!(!path.exists());
|
|
logo.writes().iter().filter(|&&mode| mode == MODE_OFF).count()
|
|
}
|
|
|
|
#[test]
|
|
fn a_change_of_state_moves_to_the_other_rhythm_and_back() {
|
|
let alone = dark_phases(ALL_ON, &[(0, 60_000, working())], 60_000);
|
|
let interrupted = dark_phases(
|
|
ALL_ON,
|
|
&[
|
|
(0, 20_000, working()),
|
|
(20_000, 40_000, needs_you()),
|
|
(40_000, 60_000, working()),
|
|
],
|
|
60_000,
|
|
);
|
|
// About 29 dark phases of Calm alone, and Alarm's 2 a second for a third
|
|
// of the time. Calm alone again at the end ends the same as it began.
|
|
assert!((27..=31).contains(&alone), "{alone}");
|
|
assert!(interrupted >= alone + 20, "{interrupted} against {alone}");
|
|
}
|
|
|
|
#[test]
|
|
fn red_interrupts_yellow_and_yellow_comes_back() {
|
|
let yellow_only = dark_phases(ALL_ON, &[(0, 60_000, waiting())], 60_000);
|
|
let with_red = dark_phases(
|
|
ALL_ON,
|
|
&[
|
|
(0, 20_000, waiting()),
|
|
(20_000, 40_000, needs_you()),
|
|
(40_000, 60_000, waiting()),
|
|
],
|
|
60_000,
|
|
);
|
|
assert!(with_red > yellow_only * 3, "{with_red} against {yellow_only}");
|
|
}
|
|
|
|
#[test]
|
|
fn alarm_is_the_sharpest_style_a_second_can_hold() {
|
|
let flashes = |style: BlinkStyle| {
|
|
let cycle: Duration = style.pattern().iter().map(|beat| beat.dark + beat.lit).sum();
|
|
style.pattern().len() as f64 / cycle.as_secs_f64()
|
|
};
|
|
assert!(flashes(BlinkStyle::Alarm) > flashes(BlinkStyle::Fast));
|
|
assert!(flashes(BlinkStyle::Alarm) > flashes(BlinkStyle::Heartbeat) * 2.0);
|
|
}
|
|
|
|
#[test]
|
|
fn the_setting_reads_every_shape_it_has_had() {
|
|
let read = |text: &str| BlinkStyles::read(&serde_json::from_str(text).unwrap());
|
|
// The one style of the first version keeps meaning work, and brings the alerts.
|
|
assert_eq!(
|
|
read(r#""heartbeat""#),
|
|
BlinkStyles {
|
|
working: BlinkStyle::Heartbeat,
|
|
waiting: BlinkStyle::Wink,
|
|
needs_you: BlinkStyle::Alarm,
|
|
}
|
|
);
|
|
assert_eq!(read(r#""off""#), BlinkStyles::default());
|
|
assert_eq!(read(r#""strobe""#), BlinkStyles::default());
|
|
assert_eq!(read("3"), BlinkStyles::default());
|
|
assert_eq!(read("null"), BlinkStyles::default());
|
|
// A bad style costs its own state, not the others.
|
|
assert_eq!(
|
|
read(r#"{"working":"calm","waiting":"strobe","needsYou":"alarm"}"#),
|
|
BlinkStyles {
|
|
working: BlinkStyle::Calm,
|
|
waiting: BlinkStyle::Off,
|
|
needs_you: BlinkStyle::Alarm,
|
|
}
|
|
);
|
|
let saved = serde_json::to_value(ALL_ON).unwrap();
|
|
assert_eq!(saved["needsYou"], "alarm");
|
|
assert_eq!(BlinkStyles::read(&saved), ALL_ON);
|
|
}
|
|
|
|
#[test]
|
|
fn nothing_but_work_asks_for_no_alerts() {
|
|
assert!(!WORK.wants_alerts());
|
|
assert!(ALL_ON.wants_alerts());
|
|
assert!(!BlinkStyles::default().any());
|
|
assert!(WORK.any());
|
|
}
|
|
|
|
#[test]
|
|
fn a_watcher_with_nothing_to_watch_starts_nothing() {
|
|
let mut watcher = Watcher::default();
|
|
watcher.sync(None);
|
|
assert!(watcher.current.is_none());
|
|
}
|
|
}
|