use std::sync::Arc;
use uzor::testing::RecordingRenderContext;
use crate::runtime::{Runtime, RuntimeConfig, TickOutput};
use crate::types::bus::{HostCaps, InputEnvelope, InputEvent, WindowInput};
use crate::types::command::{AppCommand, WindowCmd};
use crate::types::ids::{Seconds, WindowId};
use crate::types::snapshot::VisualSnapshot;
use crate::types::spec::Spec;
use crate::types::window::{SizePx, WindowCommand, WindowSpec};
use crate::{App, Handle, Waker};
pub struct HeadlessHost<S: Spec, A: App<Spec = S>> {
rt: Runtime<S, A>,
handle: Handle<S>,
now: Seconds,
pub caps: HostCaps,
pub dpr: f64,
pub ctx: RecordingRenderContext,
last: TickOutput,
command_log: Vec<(WindowId, WindowCommand)>,
#[cfg(feature = "automation")]
auto: HeadlessAuto,
#[cfg(feature = "automation")]
live_ctx: Option<Box<dyn uzor::render::RenderContext>>,
}
#[cfg(feature = "automation")]
#[derive(Default)]
struct HeadlessAuto {
port: Option<crate::automation::AutomationPort>,
waits: crate::automation::FrameWaits,
background: std::collections::HashMap<WindowId, u32>,
}
impl<S: Spec, A: App<Spec = S>> HeadlessHost<S, A> {
pub fn new(app: A, cfg: RuntimeConfig) -> (Self, Handle<S>) {
Self::with_waker(app, cfg, Waker::noop())
}
pub fn with_waker(app: A, cfg: RuntimeConfig, waker: Waker) -> (Self, Handle<S>) {
let (rt, handle) = Runtime::new(app, cfg, waker);
let host = Self {
rt,
handle: handle.clone(),
now: Seconds::ZERO,
caps: HostCaps {
multi_window: true,
os_resize_bezel: false,
clipboard_async: false,
},
dpr: 1.0,
ctx: RecordingRenderContext::new(),
last: TickOutput::default(),
command_log: Vec::new(),
#[cfg(feature = "automation")]
auto: HeadlessAuto::default(),
#[cfg(feature = "automation")]
live_ctx: None,
};
(host, handle)
}
pub fn open_window(&mut self, size: SizePx, dpr: f64) -> WindowId {
let n = self.snapshot().windows.len();
let key = format!("win-{n}");
let mut spec = WindowSpec::new(key, "headless", size);
let _ = &mut spec; self.handle
.dispatch(AppCommand::Window(WindowCmd::Open(spec)))
.unwrap_or_else(|e| panic!("headless inbox: {e}"));
self.dpr = dpr;
self.advance(0.0);
self.snapshot()
.windows
.last()
.unwrap_or_else(|| panic!("window did not open"))
.id
}
pub fn input(&mut self, win: WindowId, event: InputEvent) {
#[cfg(feature = "automation")]
if let Some(port) = &self.auto.port {
crate::automation::tap_input(port, &self.rt, win, &event);
}
self.rt.push_input(InputEnvelope {
window: win,
t: self.now,
event,
});
}
pub fn advance(&mut self, dt: f64) -> &TickOutput {
self.now = self.now.after(Seconds(dt));
let mut out = self.rt.tick(self.now);
let mut echoes = Vec::new();
for (win, cmd) in &out.window_commands {
match cmd {
WindowCommand::Spawn(spec) => echoes.push((
*win,
WindowInput::Created {
size: spec.inner_size,
dpr: self.dpr,
position: Some((100, 100)),
caps: self.caps,
},
)),
WindowCommand::Close => echoes.push((*win, WindowInput::Destroyed)),
_ => {}
}
}
if !echoes.is_empty() {
for (win, event) in echoes {
self.rt.push_input(InputEnvelope {
window: win,
t: self.now,
event: InputEvent::Window(event),
});
}
let more = self.rt.tick(self.now);
out.window_commands.extend(more.window_commands);
out.frames.extend(more.frames);
out.wake = earliest(out.wake, more.wake);
}
let frames = std::mem::take(&mut out.frames);
for req in &frames {
#[cfg(feature = "automation")]
match self.live_ctx.as_deref_mut() {
Some(ctx) => self.rt.paint(req, ctx),
None => self.rt.paint(req, &mut self.ctx),
}
#[cfg(not(feature = "automation"))]
self.rt.paint(req, &mut self.ctx);
#[cfg(feature = "automation")]
{
self.auto.background.insert(req.window, req.background);
self.auto.waits.painted();
}
}
out.frames = frames;
self.command_log.extend(out.window_commands.iter().cloned());
self.last = out;
&self.last
}
pub fn paint_window(&mut self, win: WindowId, dpr: f64, ctx: &mut dyn uzor::render::RenderContext) -> Option<(f64, f64)> {
let snap = self.snapshot();
let vp = snap.window(win)?.geometry.viewport;
drop(snap);
let size = SizePx::new(vp.width.round().max(1.0) as u32, vp.height.round().max(1.0) as u32);
let req = crate::FrameRequest {
window: win,
size,
dpr,
background: 0,
regions: Default::default(),
invalidations: Default::default(),
};
self.rt.paint(&req, ctx);
Some((vp.width, vp.height))
}
#[cfg(feature = "automation")]
pub fn serve_automation(&mut self, port: &crate::automation::AutomationPort, dt: f64) {
let jobs = self.serve_jobs(port, &mut |_| dt);
if jobs == 0 && self.auto.waits.anyone_waiting() {
self.advance(dt);
}
}
#[cfg(feature = "automation")]
fn serve_jobs(&mut self, port: &crate::automation::AutomationPort, dt_of: &mut dyn FnMut(&Self) -> f64) -> usize {
use crate::automation::{answer_plain, resolve_window, AutoCmd, AutoError, AutoReply, ShotSource};
if self.auto.port.is_none() {
self.auto.port = Some(port.clone());
}
let jobs = port.drain();
let n = jobs.len();
for (cmd, reply) in jobs {
let Some((cmd, reply)) = self.auto.waits.take(cmd, reply) else { continue };
let dpr = self.dpr;
let bgs = self.auto.background.clone();
let bg_of = move |w: WindowId| bgs.get(&w).copied().unwrap_or(0xffffffff);
let answer = match &cmd {
AutoCmd::Input { win, events } => match resolve_window(&self.rt, *win) {
Some(w) => {
for ev in events.clone() {
self.input(w, ev);
}
let dt = dt_of(self);
self.advance(dt);
AutoReply::InputDone { window: w, frame: self.auto.waits.frames }
}
None => AutoReply::Error(AutoError::NoWindow),
},
AutoCmd::Screenshot { win, .. } => {
let c = AutoCmd::Screenshot { win: *win, source: ShotSource::Offscreen };
answer_plain(&mut self.rt, &c, &|_| dpr, &bg_of).unwrap_or(AutoReply::Error(AutoError::Unsupported("screenshot")))
}
other => answer_plain(&mut self.rt, other, &|_| dpr, &bg_of).unwrap_or(AutoReply::Error(AutoError::Unsupported("command"))),
};
let _ = reply.send(answer);
}
n
}
pub fn last_wake(&self) -> crate::types::frame::Wake {
self.last.wake
}
pub fn snapshot(&self) -> Arc<VisualSnapshot<S>> {
self.rt.snapshot()
}
pub fn window_commands(&self) -> &[(WindowId, WindowCommand)] {
&self.last.window_commands
}
pub fn command_log(&self) -> &[(WindowId, WindowCommand)] {
&self.command_log
}
pub fn runtime(&self) -> &Runtime<S, A> {
&self.rt
}
pub fn runtime_mut(&mut self) -> &mut Runtime<S, A> {
&mut self.rt
}
}
fn earliest(
a: crate::types::frame::Wake,
b: crate::types::frame::Wake,
) -> crate::types::frame::Wake {
use crate::types::frame::Wake;
match (a, b) {
(Wake::Immediate, _) | (_, Wake::Immediate) => Wake::Immediate,
(Wake::At(x), Wake::At(y)) => Wake::At(if x.get() <= y.get() { x } else { y }),
(Wake::At(x), Wake::Idle) | (Wake::Idle, Wake::At(x)) => Wake::At(x),
(Wake::Idle, Wake::Idle) => Wake::Idle,
}
}
#[cfg(all(feature = "automation", not(target_arch = "wasm32")))]
pub fn run_headless<S: Spec, A: App<Spec = S>>(
app: A,
cfg: RuntimeConfig,
dpr: f64,
port: crate::automation::AutomationPort,
) {
use crate::types::frame::Wake;
use std::sync::{Condvar, Mutex};
use std::time::{Duration, Instant};
#[derive(Default)]
struct Signal {
woken: Mutex<bool>,
cv: Condvar,
}
impl Signal {
fn wake(&self) {
*self.woken.lock().unwrap_or_else(|p| p.into_inner()) = true;
self.cv.notify_all();
}
fn wait(&self, max: Option<Duration>) -> bool {
let mut w = self.woken.lock().unwrap_or_else(|p| p.into_inner());
if !*w {
w = match max {
Some(d) => self.cv.wait_timeout(w, d).unwrap_or_else(|p| p.into_inner()).0,
None => self.cv.wait(w).unwrap_or_else(|p| p.into_inner()),
};
}
std::mem::replace(&mut *w, false)
}
}
const FRAME: f64 = 1.0 / 60.0;
let sig = Arc::new(Signal::default());
let s1 = Arc::clone(&sig);
let (mut host, _handle) = HeadlessHost::with_waker(app, cfg, Waker::new(move || s1.wake()));
host.dpr = if dpr > 0.0 { dpr } else { 1.0 };
host.live_ctx = Some(Box::new(uzor_render_tiny_skia::TinySkiaCpuRenderContext::new(1, 1, host.dpr)));
let s2 = Arc::clone(&sig);
port.set_waker(move || s2.wake());
let start = Instant::now();
let clock = move || start.elapsed().as_secs_f64();
host.advance(0.0);
host.ctx.ops.clear();
let mut had_window = !host.snapshot().windows.is_empty();
let mut last_tick = clock();
let mut due_now = true;
let mut want_more = false;
loop {
let now = clock();
let jobs = host.serve_jobs(&port, &mut |h: &HeadlessHost<S, A>| (now - h.now.get()).max(0.0));
if jobs > 0 {
last_tick = now;
}
let wake = host.last_wake();
let paint_more = std::mem::take(&mut want_more) || host.rt.take_paint_wants_tick();
let due = due_now
|| paint_more
|| match wake {
Wake::Immediate => now - last_tick >= FRAME,
Wake::At(t) => t.get() <= now,
Wake::Idle => false,
};
if due {
let dt = (now - host.now.get()).max(0.0);
host.advance(dt);
host.ctx.ops.clear();
last_tick = now;
}
due_now = false;
let windows = host.snapshot().windows.len();
had_window |= windows > 0;
if host.rt.should_exit() || (had_window && windows == 0) {
return;
}
let now = clock();
want_more = host.rt.take_paint_wants_tick();
let sleep = match host.last_wake() {
_ if want_more => Some((last_tick + FRAME - now).max(0.0)),
Wake::Immediate => Some((last_tick + FRAME - now).max(0.0)),
Wake::At(t) => Some((t.get() - now).max(0.0)),
Wake::Idle => None,
};
if sleep.is_some_and(|d| d <= 0.0) {
continue;
}
if sig.wait(sleep.map(Duration::from_secs_f64)) {
due_now = true;
}
}
}