hex/src/rune_ui/capture_capsule/feed.rs

1080 lines
41 KiB
Rust

//! The capsule's side of the capture: it follows the newest capture in
//! `capture_host`'s published snapshot from its start to its outcome, and
//! hands presses back to the listener as `hex capture` commands.
use std::path::PathBuf;
use std::time::Duration;
use scrawl_capture::capture::Stage;
use super::CaptureCapsule;
use super::flow::{Action, Delivered, Dest, Failure, Grant, Input, Mode, Route, Undone};
use super::ink::InkOverlay;
use super::picker::PickerOverlay;
use crate::capture_host::{
AskedBy, CaptureCommand, CaptureNeed, CaptureRoute, CaptureSnapshot, CaptureTarget, NeedState,
RouteAnswer, RouteDelivery, RouteDest,
};
/// The capture the capsule shows, the stage it last showed, and whether its
/// recording got to work.
#[derive(Debug, Default)]
pub(crate) struct Follow {
shown: Option<(PathBuf, Stage)>,
worked: bool,
/// The engine started recording the shown capture, so a failure is one
/// to save it, not to start it.
began: bool,
/// The settled capture the previous snapshot held: `None` before the
/// first snapshot, so an outcome from before Hex started moves nothing.
last_seen: Option<Option<PathBuf>>,
/// The captures the previous snapshot held recording or finishing: a
/// failure among them is a background capture's, never a start's.
under_way: Vec<PathBuf>,
/// The shown capture's route as last seen, and whether its answer
/// reached the capsule.
route: Option<CaptureRoute>,
phone: bool,
/// The shown capture is a Screenshots recording: once it stops, the
/// screenshot card takes it and the capsule folds.
clip: bool,
}
impl Follow {
/// What moves the capsule between the last snapshot and `snapshot`. A
/// new recording takes the capsule over, with its switch chips when the
/// shortcut started it on the pointer's display; its first click,
/// scroll, or stroke folds them. A start that failed before any
/// snapshot showed it recording still shows its failure. A capture it
/// never showed otherwise (one that settled before Hex started, or one a
/// chip discarded) moves nothing.
pub(crate) fn next(&mut self, snapshot: &CaptureSnapshot) -> Vec<Input> {
let mut inputs = Vec::new();
if snapshot.phone.is_some() != self.phone {
self.phone = snapshot.phone.is_some();
inputs.push(Input::Phone(self.phone));
}
let last = snapshot.last.as_ref().map(|last| last.bundle.clone());
let previous = self.last_seen.replace(last.clone());
let under_way = std::mem::replace(
&mut self.under_way,
snapshot
.recording
.iter()
.map(|recording| recording.bundle.clone())
.chain(
snapshot
.finishing
.iter()
.map(|finishing| finishing.bundle.clone()),
)
.collect(),
);
// A start's failure, never one under a recording (that's newer) or
// a capture's that was already under way.
if let (Some(previous), Some(failed)) = (previous, &snapshot.last)
&& snapshot.recording.is_none()
&& !under_way.contains(&failed.bundle)
&& previous.as_ref() != Some(&failed.bundle)
&& failed.stage == Stage::Failed
&& self
.shown
.as_ref()
.is_none_or(|(bundle, _)| *bundle != failed.bundle)
{
// Took the capsule over as it started: show it as followed.
self.shown = Some((failed.bundle.clone(), Stage::Recording));
self.began = false;
}
if let Some(recording) = &snapshot.recording {
let fresh = self
.shown
.as_ref()
.is_none_or(|(bundle, _)| *bundle != recording.bundle);
if fresh {
self.shown = Some((recording.bundle.clone(), Stage::Recording));
self.route = None;
self.worked = recording.worked;
self.began = recording.screen;
self.clip = recording.clip;
// No target chips: Annotate records the screen, and the
// capsule's toolbar (the pen) takes their place.
inputs.push(Input::Stage(Stage::Recording));
} else if recording.worked && !self.worked {
self.worked = true;
inputs.push(Input::Worked);
}
self.began |= recording.screen;
return inputs;
}
// A stopped recording folds unless it failed, which still shows.
// A failed clip keeps `clip` until the failure is handled, so its
// helper returns to the picker.
if self.clip
&& let Some((bundle, Stage::Recording)) = &self.shown
&& !snapshot
.last
.as_ref()
.is_some_and(|last| last.bundle == *bundle && last.stage == Stage::Failed)
{
self.clip = false;
self.shown = None;
inputs.push(Input::Gone);
return inputs;
}
let stage = self.stage(snapshot);
if matches!(stage, Some(Input::Written { .. })) {
if heard_nothing(snapshot, self.shown.as_ref()) {
inputs.push(Input::NothingHeard);
}
if copy_failed(snapshot, self.shown.as_ref()) {
inputs.push(Input::CopyFailed);
}
}
inputs.extend(stage);
inputs.extend(self.routed(snapshot));
inputs
}
/// What a helper this capture opens should return to: a Screenshots
/// recording (`clip`) reopens its picker, any other capture records the
/// screen.
fn asked_by(&self) -> AskedBy {
if self.clip {
AskedBy::Screenshots { record: true }
} else {
AskedBy::Capture
}
}
/// What the router's news for the shown capture tells the capsule. The
/// capsule follows the answer and its refinements, the send going,
/// a send OpenCode didn't take (and its later retry), how an Undo
/// ended, and a failed send.
fn routed(&mut self, snapshot: &CaptureSnapshot) -> Vec<Input> {
let Some((bundle, _)) = &self.shown else {
return Vec::new();
};
let Some(route) = snapshot
.last
.as_ref()
.filter(|last| last.bundle == *bundle)
.and_then(|last| last.route.clone())
else {
return Vec::new();
};
let before = self.route.replace(route.clone());
if before.as_ref() == Some(&route) {
return Vec::new();
}
let mut inputs = Vec::new();
let answered = |route: Option<&CaptureRoute>| {
route.is_some_and(|route| route.answer != RouteAnswer::Looking)
};
if answered(Some(&route)) && !answered(before.as_ref()) {
inputs.extend(capsule_route(&route.answer).map(Input::Routed));
} else if before
.as_ref()
.is_some_and(|before| before.answer != route.answer)
{
inputs.extend(capsule_route(&route.answer).map(Input::Refined));
}
let was = before.and_then(|before| before.delivery);
if route.delivery == was {
return inputs;
}
match route.delivery {
Some(RouteDelivery::Queued { to, why }) => {
inputs.push(Input::Delivered(Delivered::Queued { to, why }));
}
Some(RouteDelivery::Sent { to })
if matches!(was, Some(RouteDelivery::Queued { .. })) =>
{
inputs.push(Input::Delivered(Delivered::Sent { to }));
}
Some(RouteDelivery::Sending { .. }) => inputs.push(Input::Sending),
// A send the capsule knows of, or one from `hex capture send`.
Some(RouteDelivery::Sent { .. }) => inputs.push(Input::Settled),
Some(RouteDelivery::TakenBack) => inputs.push(Input::Undone(Undone::TakenBack)),
Some(RouteDelivery::TooLate { .. }) => inputs.push(Input::Undone(Undone::TooLate)),
Some(RouteDelivery::Failed { to, why }) => {
inputs.push(Input::Failed(Failure::Send(to), Some(why)));
}
_ => {}
}
inputs
}
fn stage(&mut self, snapshot: &CaptureSnapshot) -> Option<Input> {
let followed = self.shown.as_ref().map(|(bundle, _)| bundle);
let (bundle, stage) = if let Some(finishing) = snapshot
.finishing
.iter()
.find(|finishing| Some(&finishing.bundle) == followed)
{
let stage = if finishing.cancelling {
Stage::Cancelled
} else {
finishing.stage
};
(&finishing.bundle, stage)
} else if let Some(last) = snapshot
.last
.as_ref()
.filter(|last| Some(&last.bundle) == followed)
{
(&last.bundle, last.stage)
} else {
// A recording shown that left with no outcome: discarded. It
// never comes back.
self.shown
.take_if(|(_, stage)| *stage == Stage::Recording)?;
return Some(Input::Gone);
};
// A writer's last progress tick is not its publication: the settled
// bundle also tells us whether a routing answer is still pending.
let written = if stage == Stage::Done {
let last = snapshot
.last
.as_ref()
.filter(|last| last.bundle == *bundle && last.stage == Stage::Done)?;
Some(Input::Written {
bundle: bundle.clone(),
routing: last.route.is_some(),
})
} else {
None
};
if self
.shown
.as_ref()
.is_some_and(|shown| shown.0 == *bundle && shown.1 == stage)
{
return None;
}
self.shown = Some((bundle.clone(), stage));
if stage == Stage::Failed {
let error = snapshot
.last
.as_ref()
.filter(|last| last.bundle == *bundle)
.and_then(|last| last.error.clone());
let what = if self.began {
Failure::Save
} else {
Failure::Start
};
return Some(Input::Failed(what, error));
}
written.or(Some(Input::Stage(stage)))
}
}
/// Whether the shown capture's summary didn't reach the clipboard.
fn copy_failed(snapshot: &CaptureSnapshot, shown: Option<&(PathBuf, Stage)>) -> bool {
snapshot.last.as_ref().is_some_and(|last| {
shown.is_some_and(|(bundle, _)| *bundle == last.bundle) && last.copy_error.is_some()
})
}
/// Whether the shown capture was written with a transcript that has no
/// words: none timed and none in its text, so only silence reads as "no
/// speech" for a model that gives no times. One that has no transcript at
/// all (the transcriber was missing or failed) wasn't silence.
fn heard_nothing(snapshot: &CaptureSnapshot, shown: Option<&(PathBuf, Stage)>) -> bool {
snapshot.last.as_ref().is_some_and(|last| {
shown.is_some_and(|(bundle, _)| *bundle == last.bundle)
&& last.words == Some(0)
&& last.missing_transcript.is_none()
})
}
/// The router's answer as the capsule shows it. A rule's own session leads
/// its suggestions, as in Scrawl's list; the capsule shows sessions by
/// title and sends to them by id.
fn capsule_route(answer: &RouteAnswer) -> Option<Route> {
let dests = |dests: &[RouteDest]| -> Vec<Dest> {
dests
.iter()
.map(|dest| {
let folder = dest
.directory
.as_deref()
.and_then(|directory| directory.file_name())
.map(|name| name.to_string_lossy().into_owned());
Dest::new(dest.name.clone(), dest.why.clone())
.session(dest.session.clone())
.folder(folder)
})
.collect()
};
Some(match answer {
RouteAnswer::Looking => return None,
RouteAnswer::ResolvingRule { name } => Route::ResolvingRule { name: name.clone() },
RouteAnswer::Rule {
to,
suggested,
recent,
site,
} => Route::Rule {
to: dests(std::slice::from_ref(to)).remove(0),
suggested: dests(std::slice::from_ref(to))
.into_iter()
.chain(dests(suggested))
.collect(),
recent: dests(recent),
site: site.clone(),
},
RouteAnswer::Guess {
suggested,
recent,
site,
} => Route::Guess {
suggested: dests(suggested),
recent: dests(recent),
site: site.clone(),
},
RouteAnswer::Nothing { recent } => Route::Nothing {
recent: dests(recent),
},
RouteAnswer::NoAnswer { recent } => Route::NoAnswer {
recent: dests(recent),
},
RouteAnswer::Unreachable { why } => Route::Unreachable { why: why.clone() },
})
}
#[cfg_attr(target_os = "linux", allow(dead_code))]
/// The capsule, its picker, and the ink, installed together.
pub(crate) struct CaptureOverlays {
capsule: CaptureCapsule,
picker: PickerOverlay,
ink: InkOverlay,
/// Whether screen recordings may see them.
shown: bool,
}
impl CaptureOverlays {
/// Adds the three overlays, hidden, and starts following captures. They
/// make their GPU surfaces only to show, and on macOS and Windows their
/// windows too, so a Hex that never annotates holds none: idle
/// screen-sized panels emptied macOS 27's Mission Control Space
/// thumbnails (#1315).
pub(crate) fn install<S: 'static>(app: &mut rune::App<S>) -> Self {
let picker = PickerOverlay::install(app, act);
let aim = picker.clone();
let capsule = CaptureCapsule::install(app, move |action| act(aim.resolve(action)));
capsule.attach(picker.clone());
let ink = InkOverlay::install(app);
let lit = capsule.clone();
super::ink::on_drawing(move |on| lit.input(Input::Drawing(on)));
follow(capsule.clone(), ink.clone());
let helper = capsule.clone();
crate::capture_host::on_missing(move |need, asked_by| show_helper(&helper, need, asked_by));
Self {
capsule,
picker,
ink,
shown: crate::capture_host::own_windows_recorded(),
}
}
#[cfg_attr(target_os = "linux", allow(dead_code))]
/// Follows `capture.show_overlays_in_recordings` on windows already
/// made.
pub(crate) fn follow_recordings(&mut self) {
let shown = crate::capture_host::own_windows_recorded();
if shown == self.shown {
return;
}
self.shown = shown;
self.capsule.show_in_recordings(shown);
self.picker.show_in_recordings(shown);
self.ink.show_in_recordings(shown);
}
}
/// Moves `capsule` with every published capture change, and wakes `ink` to
/// look for a recording capture's strokes, on its own thread for the life
/// of the process.
pub(crate) fn follow(capsule: CaptureCapsule, ink: InkOverlay) {
let spawned = std::thread::Builder::new()
.name("capture-capsule".into())
.spawn(move || {
let watch = crate::capture_host::watch();
let mut follow = Follow::default();
let images = rune::ImageCache::new(std::sync::Arc::new(|| {}));
loop {
let Some(snapshot) = watch.wait(Duration::from_secs(3600)) else {
continue;
};
ink.wake();
let inputs = follow.next(&snapshot);
// The first frame goes ahead of "Copied", so the capsule
// lands with it rather than swapping its check a moment on.
let mut screenless = false;
if inputs
.iter()
.any(|input| matches!(input, Input::Written { .. }))
&& let Some((bundle, _)) = &follow.shown
{
screenless = !bundle.join("frames/frame-01.png").exists();
if let Some(image) = first_frame(&images, bundle) {
capsule.thumbnail(image);
}
}
for input in inputs {
// The common first-capture failure, whose own reason is
// a ScreenCaptureKit error: the helper says what to do.
if let Input::Failed(Failure::Start | Failure::Save, _) = &input
&& screen_off()
{
show_helper(&capsule, CaptureNeed::ScreenRecording, follow.asked_by());
continue;
}
capsule.input(input);
}
// Sent with only the voice and marks: the helper follows
// once its capsule folds.
if screenless && screen_off() {
show_helper(&capsule, CaptureNeed::ScreenRecording, follow.asked_by());
}
// The capture the clip flag describes settled: a later
// failure is its own.
if follow.clip && !matches!(follow.shown, Some((_, Stage::Recording))) {
follow.clip = false;
}
}
});
if let Err(error) = spawned {
tracing::warn!(%error, "could not start the capture capsule's thread");
}
}
/// Follows `need` while the permission helper shows it, once a second on
/// its own thread, until it's granted or the helper would have folded. One
/// watch at a time: a later refusal hands the running one its need.
fn watch_grant(capsule: CaptureCapsule, need: CaptureNeed) {
use std::sync::Mutex;
use std::sync::atomic::{AtomicBool, Ordering};
static WATCHING: AtomicBool = AtomicBool::new(false);
static NEED: Mutex<Option<CaptureNeed>> = Mutex::new(None);
*NEED.lock().unwrap_or_else(|e| e.into_inner()) = Some(need);
if WATCHING.swap(true, Ordering::AcqRel) {
return;
}
let spawned = std::thread::Builder::new()
.name("capture-permission".into())
.spawn(move || {
let started = std::time::Instant::now();
while started.elapsed().as_secs_f64() < super::flow::PERMISSION_HOLD_S {
let Some(need) = *NEED.lock().unwrap_or_else(|e| e.into_inner()) else {
break;
};
let grant = match crate::capture_host::permission_state(need, false) {
None => Grant::Ready,
Some(NeedState::Restart) => Grant::Restart,
Some(NeedState::Off) => Grant::Off,
};
capsule.input(Input::Permission(need, grant));
if grant == Grant::Ready {
break;
}
std::thread::sleep(Duration::from_secs(1));
}
WATCHING.store(false, Ordering::Release);
});
if let Err(error) = spawned {
WATCHING.store(false, Ordering::Release);
tracing::warn!(%error, "could not watch a capture permission");
}
}
/// A written capture's first keyframe (or its contact sheet), decoded on
/// the image cache's worker while this thread waits; `None` when neither
/// reads or decodes.
fn first_frame(images: &rune::ImageCache, bundle: &std::path::Path) -> Option<rune::Image> {
["frames/frame-01.png", "contact-sheet.png"]
.into_iter()
.find_map(|name| {
let bytes = std::fs::read(bundle.join(name)).ok()?;
let image = images.load(bytes);
image.wait().ok()?;
Some(image)
})
}
/// Carries out a press or key on the capsule: Finish and Cancel end the
/// capture as `hex capture stop|cancel` would, a chip discards the
/// recording, the picker starts what it picked, and Record (or the
/// shortcut) without a pick records the display under the pointer. Runs on the
/// main thread, so it only queues the commands.
pub(crate) fn act(action: Action) {
use crate::capture_host::CaptureControl;
use crate::control::ScrawlCaptureAction;
let scrawl = CaptureControl::Scrawl;
let command = CaptureControl::Command;
let screen = || CaptureCommand::Start(CaptureTarget::Display { at: pointer() });
let controls: Vec<CaptureControl> = match action {
Action::Finish => vec![scrawl(ScrawlCaptureAction::Stop)],
Action::Cancel => vec![scrawl(ScrawlCaptureAction::Cancel)],
// The picker opens: look for a phone cabled since the recording
// began, as Scrawl's reveal does.
Action::Discard => vec![
command(CaptureCommand::Discard),
command(CaptureCommand::FindPhone),
],
Action::Start(target) => vec![command(CaptureCommand::Start(target))],
// The Screenshots picker's permission was granted: open it again,
// in the mode its shortcut asked for.
Action::OpenScreenshots { record } => {
#[cfg(target_os = "macos")]
crate::screenshots::open(record);
#[cfg(not(target_os = "macos"))]
let _ = record;
return;
}
// What the picker would record, when it has nothing to record yet
// (its windows still load): the pointer's display.
// Wayland lists no windows: the portal's own picker chooses one.
Action::Record(Mode::Window) if cfg!(target_os = "linux") => {
vec![command(CaptureCommand::Start(CaptureTarget::Window {
id: 0,
}))]
}
Action::Record(Mode::Screen | Mode::Window | Mode::Area) => vec![command(screen())],
Action::Record(Mode::Iphone) => vec![command(CaptureCommand::Start(CaptureTarget::Phone))],
Action::Switch(Mode::Iphone) => {
vec![command(CaptureCommand::Switch(CaptureTarget::Phone))]
}
// Screen is what the shortcut records; Window and Area discard.
Action::Switch(Mode::Screen | Mode::Window | Mode::Area) => return,
Action::Send { to, always } => vec![command(CaptureCommand::Send {
to,
always: always.is_some(),
})],
Action::Undo { .. } => vec![command(CaptureCommand::Undo)],
Action::Hold(on) => vec![command(CaptureCommand::Hold(on))],
Action::Pen => {
crate::capture_host::toggle_pen();
return;
}
Action::Paste(bundle) => vec![command(CaptureCommand::Paste(bundle))],
Action::Inspect => vec![command(CaptureCommand::Inspect)],
Action::Allow(need) => {
crate::capture_host::allow_permission(need);
return;
}
Action::Restart => {
crate::capture_host::restart_for_permission();
return;
}
};
for control in controls {
if let Err(error) = crate::capture_host::send_to_listener(control) {
tracing::warn!(%error, "the capture capsule could not reach the listener");
}
}
}
/// Whether this Hex can't record the screen now, read afresh.
fn screen_off() -> bool {
crate::capture_host::permission_state(CaptureNeed::ScreenRecording, true).is_some()
}
/// Opens the permission helper for `need` and follows its grant.
fn show_helper(capsule: &CaptureCapsule, need: CaptureNeed, asked_by: AskedBy) {
capsule.input(Input::NeedsPermission(need, asked_by));
watch_grant(capsule.clone(), need);
}
/// The pointer. Wayland tells Hex nothing of it: the portal picks the
/// screen.
#[cfg(target_os = "linux")]
fn pointer() -> [f64; 2] {
[0.0, 0.0]
}
/// The pointer, in global physical pixels, as the engine's targets are.
#[cfg(target_os = "windows")]
fn pointer() -> [f64; 2] {
scrawl_capture::screens::pointer().unwrap_or_default()
}
/// The pointer, in global top-left points.
#[cfg(target_os = "macos")]
fn pointer() -> [f64; 2] {
use core_graphics_types::geometry::CGPoint;
use std::ffi::c_void;
#[link(name = "CoreGraphics", kind = "framework")]
unsafe extern "C" {
fn CGEventCreate(source: *mut c_void) -> *mut c_void;
fn CGEventGetLocation(event: *mut c_void) -> CGPoint;
}
#[link(name = "CoreFoundation", kind = "framework")]
unsafe extern "C" {
fn CFRelease(cf: *const c_void);
}
// SAFETY: a null source makes an event at the current pointer; it is
// released once read.
unsafe {
let event = CGEventCreate(std::ptr::null_mut());
if event.is_null() {
return [0.0, 0.0];
}
let at = CGEventGetLocation(event);
CFRelease(event);
[at.x, at.y]
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::audio::CaptureInstant;
use crate::capture_host::{FinishingCapture, RecordingCapture, SettledCapture};
fn bundle(name: &str) -> PathBuf {
PathBuf::from(format!("/captures/{name}.scrawl"))
}
fn recording(name: &str) -> CaptureSnapshot {
CaptureSnapshot {
generation: 0,
recording: Some(RecordingCapture {
bundle: bundle(name),
since: CaptureInstant::now(),
screen: true,
target: crate::capture_host::TargetKind::Display,
worked: false,
clip: false,
}),
finishing: Vec::new(),
last: None,
phone: None,
}
}
fn finishing(name: &str, stage: Stage, cancelling: bool) -> CaptureSnapshot {
CaptureSnapshot {
generation: 0,
recording: None,
finishing: vec![FinishingCapture {
bundle: bundle(name),
stage,
cancelling,
}],
last: None,
phone: None,
}
}
fn settled(name: &str, stage: Stage) -> CaptureSnapshot {
CaptureSnapshot {
generation: 0,
recording: None,
finishing: Vec::new(),
last: Some(SettledCapture {
bundle: bundle(name),
stage,
words: Some(12),
gaps: Some(0),
audio_stopped_at_ms: None,
missing_transcript: None,
error: None,
copy_error: None,
route: None,
}),
phone: None,
}
}
fn written(name: &str, routing: bool) -> Input {
Input::Written {
bundle: bundle(name),
routing,
}
}
#[test]
fn paste_follows_the_displayed_bundle_not_a_later_completion() {
use super::super::{flow::Flow, surface::Id};
let mut follow = Follow::default();
let mut flow = Flow::new();
for snapshot in [
recording("shown"),
settled("shown", Stage::Done),
settled("other", Stage::Done),
] {
for input in follow.next(&snapshot) {
flow.input(input, 1.0);
}
}
assert_eq!(flow.click(Id::Paste, 1.1), [Action::Paste(bundle("shown"))]);
}
#[test]
fn it_follows_a_capture_from_start_to_outcome() {
let mut follow = Follow::default();
assert_eq!(follow.next(&settled("old", Stage::Done)), []);
let a = recording("a");
assert_eq!(follow.next(&a), [Input::Stage(Stage::Recording)]);
assert_eq!(follow.next(&a), [], "a repeat moves nothing");
let stopping = finishing("a", Stage::Stopping, false);
assert_eq!(follow.next(&stopping), [Input::Stage(Stage::Stopping)]);
assert_eq!(
follow.next(&finishing("a", Stage::Transcribing, false)),
[Input::Stage(Stage::Transcribing)]
);
assert_eq!(
follow.next(&settled("a", Stage::Done)),
[written("a", false)]
);
assert_eq!(follow.next(&settled("a", Stage::Done)), []);
}
#[test]
fn a_stopped_screenshot_recording_folds_the_capsule() {
let mut follow = Follow::default();
let mut clip = recording("a");
clip.recording.as_mut().unwrap().clip = true;
assert_eq!(follow.next(&clip), [Input::Stage(Stage::Recording)]);
assert_eq!(
follow.next(&finishing("a", Stage::Stopping, false)),
[Input::Gone]
);
assert_eq!(follow.next(&finishing("a", Stage::Writing, false)), []);
assert_eq!(follow.next(&settled("a", Stage::Done)), []);
}
/// A Screenshots recording that fails keeps its picker origin until the
/// helper is shown; one that folds normally leaves nothing behind.
#[test]
fn a_failed_screenshots_recording_asks_for_its_picker() {
let mut follow = Follow::default();
let mut clip = recording("a");
clip.recording.as_mut().unwrap().clip = true;
follow.next(&clip);
assert_eq!(follow.asked_by(), AskedBy::Screenshots { record: true });
let mut failed = settled("a", Stage::Failed);
failed.last.as_mut().unwrap().error = Some("screen recording stopped".into());
assert_eq!(
follow.next(&failed),
[Input::Failed(
Failure::Save,
Some("screen recording stopped".into())
)]
);
assert_eq!(
follow.asked_by(),
AskedBy::Screenshots { record: true },
"kept until the follow thread shows its helper"
);
let mut follow = Follow::default();
let mut clip = recording("a");
clip.recording.as_mut().unwrap().clip = true;
follow.next(&clip);
follow.next(&finishing("a", Stage::Stopping, false));
assert_eq!(
follow.asked_by(),
AskedBy::Capture,
"a folded clip leaves nothing behind"
);
}
#[test]
fn a_capture_with_no_words_says_nothing_was_heard() {
let silent = |missing: Option<&str>| {
let mut snapshot = settled("a", Stage::Done);
let last = snapshot.last.as_mut().unwrap();
last.words = Some(0);
last.missing_transcript = missing.map(Into::into);
snapshot
};
let mut follow = Follow::default();
follow.next(&recording("a"));
assert_eq!(
follow.next(&silent(None)),
[Input::NothingHeard, written("a", false)]
);
let mut follow = Follow::default();
follow.next(&recording("a"));
assert_eq!(
follow.next(&silent(Some("Transcriber unavailable."))),
[written("a", false)],
"no transcript at all isn't silence"
);
}
#[test]
fn a_capture_whose_copy_failed_says_so() {
let mut uncopied = settled("a", Stage::Done);
uncopied.last.as_mut().unwrap().copy_error = Some("pasteboard refused".into());
let mut follow = Follow::default();
follow.next(&recording("a"));
assert_eq!(
follow.next(&uncopied),
[Input::CopyFailed, written("a", false)]
);
let mut follow = Follow::default();
follow.next(&recording("a"));
assert_eq!(
follow.next(&settled("a", Stage::Done)),
[written("a", false)]
);
}
#[test]
fn a_new_recording_takes_over_and_a_cancel_hides() {
let mut follow = Follow::default();
follow.next(&recording("a"));
follow.next(&finishing("a", Stage::Writing, false));
// A second capture starts while the first is written.
let mut both = recording("b");
both.finishing = finishing("a", Stage::Writing, false).finishing;
assert_eq!(follow.next(&both), [Input::Stage(Stage::Recording)]);
// The first settling no longer moves the capsule.
let mut a_done = recording("b");
a_done.last = settled("a", Stage::Done).last;
assert_eq!(follow.next(&a_done), []);
assert_eq!(
follow.next(&finishing("b", Stage::Stopping, true)),
[Input::Stage(Stage::Cancelled)]
);
}
#[test]
fn a_start_that_failed_unseen_still_shows_why() {
let mut follow = Follow::default();
assert_eq!(follow.next(&settled("old", Stage::Failed)), []);
let mut failed = settled("a", Stage::Failed);
failed.last.as_mut().unwrap().error = Some("no screen to record".into());
assert_eq!(
follow.next(&failed),
[Input::Failed(
Failure::Start,
Some("no screen to record".into())
)]
);
assert_eq!(follow.next(&failed), []);
}
#[test]
fn a_capture_that_never_began_failed_to_start() {
let mut follow = Follow::default();
let mut starting = recording("a");
starting.recording.as_mut().unwrap().screen = false;
follow.next(&starting);
let mut failed = settled("a", Stage::Failed);
failed.last.as_mut().unwrap().error = Some("Screen Recording refused".into());
assert_eq!(
follow.next(&failed),
[Input::Failed(
Failure::Start,
Some("Screen Recording refused".into())
)]
);
}
#[test]
fn a_failure_says_why() {
let mut follow = Follow::default();
follow.next(&recording("a"));
let mut failed = settled("a", Stage::Failed);
failed.last.as_mut().unwrap().error = Some("the window closed".into());
assert_eq!(
follow.next(&failed),
[Input::Failed(
Failure::Save,
Some("the window closed".into())
)]
);
}
#[test]
fn the_shortcuts_recording_shows_no_target_chips() {
let mut follow = Follow::default();
let mut a = recording("a");
a.recording.as_mut().unwrap().target = crate::capture_host::TargetKind::Pointer;
assert_eq!(follow.next(&a), [Input::Stage(Stage::Recording)]);
a.recording.as_mut().unwrap().worked = true;
assert_eq!(follow.next(&a), [Input::Worked]);
assert_eq!(follow.next(&a), []);
assert_eq!(follow.next(&CaptureSnapshot::default()), [Input::Gone]);
assert_eq!(follow.next(&CaptureSnapshot::default()), []);
}
/// A recording discarded with no outcome (and, from an older host, a
/// switch whose start failed): the timer must not count on.
#[test]
fn a_recording_that_leaves_with_no_outcome_ends_the_capsule() {
let mut follow = Follow::default();
follow.next(&recording("a"));
assert_eq!(follow.next(&CaptureSnapshot::default()), [Input::Gone]);
// The host's failure for the start that never showed follows.
let mut failed = settled("b", Stage::Failed);
failed.last.as_mut().unwrap().error = Some("too many captures finishing".into());
assert_eq!(
follow.next(&failed),
[Input::Failed(
Failure::Start,
Some("too many captures finishing".into())
)]
);
}
#[test]
fn a_background_failure_never_takes_over_the_capture_it_follows() {
let mut follow = Follow::default();
follow.next(&recording("a"));
let mut both = recording("b");
both.finishing = finishing("a", Stage::Writing, false).finishing;
assert_eq!(follow.next(&both), [Input::Stage(Stage::Recording)]);
// "a" fails while "b" records: the timer and chips stay as they are.
let mut a_failed = recording("b");
a_failed.last = settled("a", Stage::Failed).last;
assert_eq!(follow.next(&a_failed), []);
// "c", written beside "b", fails: "b" stays shown.
let mut b_writing = finishing("b", Stage::Writing, false);
b_writing
.finishing
.extend(finishing("c", Stage::Writing, false).finishing);
assert_eq!(follow.next(&b_writing), [Input::Stage(Stage::Writing)]);
let mut c_failed = finishing("b", Stage::Writing, false);
c_failed.last = settled("c", Stage::Failed).last;
assert_eq!(follow.next(&c_failed), []);
assert_eq!(
follow.next(&settled("b", Stage::Done)),
[written("b", false)]
);
}
/// A start that fails before any snapshot shows it is the newest thing
/// asked for, so it shows even while an older capture is written.
#[test]
fn a_start_that_fails_unseen_shows_over_an_older_capture() {
let mut follow = Follow::default();
follow.next(&recording("a"));
follow.next(&finishing("a", Stage::Writing, false));
let mut b_failed = finishing("a", Stage::Writing, false);
b_failed.last = settled("b", Stage::Failed).last;
assert_eq!(
follow.next(&b_failed),
[Input::Failed(Failure::Start, None)]
);
}
fn dest(name: &str, why: &str) -> RouteDest {
RouteDest {
session: format!("ses_{name}"),
name: name.into(),
why: why.into(),
directory: None,
}
}
fn routed(name: &str, answer: RouteAnswer, delivery: Option<RouteDelivery>) -> CaptureSnapshot {
let mut snapshot = settled(name, Stage::Done);
snapshot.last.as_mut().unwrap().route = Some(CaptureRoute {
answer,
delivery,
offer: None,
});
snapshot
}
#[test]
fn a_rule_shows_once_and_only_news_the_capsule_cant_know_moves_it() {
let mut follow = Follow::default();
follow.next(&recording("a"));
assert_eq!(
follow.next(&routed("a", RouteAnswer::Looking, None)),
[written("a", true)]
);
let rule = || RouteAnswer::Rule {
to: dest("SEER", "rule"),
suggested: vec![dest("HEX", "last sent")],
recent: vec![dest("HOME", "yesterday")],
site: Some("seer.example.com".into()),
};
// The router sends a rule's answer at once.
let sending = || Some(RouteDelivery::Sending { to: "SEER".into() });
assert_eq!(
follow.next(&routed("a", rule(), sending())),
[
Input::Routed(Route::Rule {
to: Dest::new("SEER", "rule").session("ses_SEER"),
suggested: vec![
Dest::new("SEER", "rule").session("ses_SEER"),
Dest::new("HEX", "last sent").session("ses_HEX"),
],
recent: vec![Dest::new("HOME", "yesterday").session("ses_HOME")],
site: Some("seer.example.com".into()),
}),
Input::Sending
]
);
assert_eq!(follow.next(&routed("a", rule(), sending())), []);
// Sent settles it (Send to… no longer brings it back) and
// sounds Sent.
let sent = Some(RouteDelivery::Sent { to: "SEER".into() });
assert_eq!(follow.next(&routed("a", rule(), sent)), [Input::Settled]);
assert_eq!(
follow.next(&routed("a", rule(), Some(RouteDelivery::TakenBack))),
[Input::Undone(Undone::TakenBack)]
);
}
#[test]
fn a_queued_send_says_so_and_says_sent_when_it_goes() {
let mut follow = Follow::default();
follow.next(&recording("a"));
let guess = || RouteAnswer::Guess {
suggested: vec![dest("HEX", "same page")],
recent: Vec::new(),
site: None,
};
follow.next(&routed("a", guess(), None));
let queued = Some(RouteDelivery::Queued {
to: "HEX".into(),
why: "OpenCode can't see files".into(),
});
assert_eq!(
follow.next(&routed("a", guess(), queued)),
[Input::Delivered(Delivered::Queued {
to: "HEX".into(),
why: "OpenCode can't see files".into(),
})]
);
let sent = Some(RouteDelivery::Sent { to: "HEX".into() });
assert_eq!(
follow.next(&routed("a", guess(), sent)),
[Input::Delivered(Delivered::Sent { to: "HEX".into() })]
);
let failed = Some(RouteDelivery::Failed {
to: "HEX".into(),
why: "gone".into(),
});
assert_eq!(
follow.next(&routed("a", guess(), failed)),
[Input::Failed(
Failure::Send("HEX".into()),
Some("gone".into())
)]
);
}
#[test]
fn a_cabled_phone_shows_its_chip() {
let mut follow = Follow::default();
let mut snapshot = CaptureSnapshot {
phone: Some("Alex's iPhone".into()),
..CaptureSnapshot::default()
};
assert_eq!(follow.next(&snapshot), [Input::Phone(true)]);
assert_eq!(follow.next(&snapshot), []);
snapshot.phone = None;
assert_eq!(follow.next(&snapshot), [Input::Phone(false)]);
}
}