use std::sync::Mutex;
use crate::types::window::Insets;
#[derive(Default)]
struct State {
safe: Option<Insets>,
keyboard: f64,
dirty: bool,
wake: Option<std::sync::Arc<dyn Fn() + Send + Sync>>,
}
static STATE: Mutex<Option<State>> = Mutex::new(None);
fn with<R>(f: impl FnOnce(&mut State) -> R) -> R {
let mut g = STATE.lock().unwrap_or_else(|e| e.into_inner());
f(g.get_or_insert_with(State::default))
}
fn changed(s: &mut State) -> Option<std::sync::Arc<dyn Fn() + Send + Sync>> {
s.dirty = true;
s.wake.clone()
}
pub fn set_safe_area(safe: Insets) {
let wake = with(|s| {
if s.safe == Some(safe) {
return None;
}
s.safe = Some(safe);
changed(s)
});
if let Some(w) = wake {
w();
}
}
pub fn set_keyboard(height: f64) {
let height = height.max(0.0);
let wake = with(|s| {
if s.keyboard == height {
return None;
}
s.keyboard = height;
changed(s)
});
if let Some(w) = wake {
w();
}
}
pub fn current() -> (Option<Insets>, f64) {
with(|s| (s.safe, s.keyboard))
}
#[allow(dead_code)]
pub(crate) fn take_changed() -> Option<(Option<Insets>, f64)> {
with(|s| std::mem::take(&mut s.dirty).then_some((s.safe, s.keyboard)))
}
#[allow(dead_code)]
pub(crate) fn wake() {
if let Some(w) = with(|s| s.wake.clone()) {
w();
}
}
#[allow(dead_code)]
pub(crate) fn set_wake(f: impl Fn() + Send + Sync + 'static) {
with(|s| s.wake = Some(std::sync::Arc::new(f)));
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn changes_are_taken_once_and_wake_the_loop() {
use std::sync::atomic::{AtomicUsize, Ordering};
static WOKE: AtomicUsize = AtomicUsize::new(0);
set_wake(|| {
WOKE.fetch_add(1, Ordering::Relaxed);
});
let _ = take_changed();
set_keyboard(300.0);
set_keyboard(300.0);
assert_eq!(WOKE.load(Ordering::Relaxed), 1, "same value does not wake again");
assert_eq!(take_changed().map(|c| c.1), Some(300.0));
assert_eq!(take_changed(), None);
set_safe_area(Insets::new(24.0, 0.0, 48.0, 0.0));
assert_eq!(take_changed(), Some((Some(Insets::new(24.0, 0.0, 48.0, 0.0)), 300.0)));
set_keyboard(-5.0);
assert_eq!(current().1, 0.0);
}
}