use std::collections::HashMap;
use std::future::Future;
use std::pin::Pin;
use std::sync::{Arc, Mutex};
use std::task::{Context, Poll, Wake, Waker};
use crate::component::ComponentId;
use crate::post::Poster;
use crate::ui::Ui;
impl Poster {
pub fn post_to(&self, owner: ComponentId, job: impl FnOnce(&mut Ui) + Send + 'static) {
self.post(move |ui| {
if ui.contains(owner) {
job(ui);
}
});
}
}
type Finish = Box<dyn FnOnce(&mut Ui)>;
pub(crate) struct LocalTask {
owner: ComponentId,
future: Pin<Box<dyn Future<Output = Finish>>>,
}
#[derive(Default)]
pub(crate) struct Tasks {
next: u64,
running: HashMap<u64, LocalTask>,
}
struct TaskWaker {
id: u64,
poster: Poster,
}
impl Wake for TaskWaker {
fn wake(self: Arc<Self>) {
let id = self.id;
self.poster.post(move |ui| ui.poll_task(id));
}
}
impl Ui {
pub fn background<T: Send + 'static>(
&mut self,
owner: ComponentId,
work: impl FnOnce() -> T + Send + 'static,
done: impl FnOnce(&mut Ui, T) + Send + 'static,
) {
let poster = self.poster();
#[cfg(not(target_arch = "wasm32"))]
std::thread::spawn(move || {
let value = work();
poster.post_to(owner, move |ui| done(ui, value));
});
#[cfg(target_arch = "wasm32")]
{
let value = work();
poster.post_to(owner, move |ui| done(ui, value));
}
}
pub fn spawn_local<T: 'static>(&mut self, owner: ComponentId, future: impl Future<Output = T> + 'static, done: impl FnOnce(&mut Ui, T) + 'static) {
let future: Pin<Box<dyn Future<Output = Finish>>> = Box::pin(async move {
let value = future.await;
Box::new(move |ui: &mut Ui| done(ui, value)) as Finish
});
let id = self.tasks.next;
self.tasks.next += 1;
self.tasks.running.insert(id, LocalTask { owner, future });
self.poll_task(id);
}
pub(crate) fn poll_task(&mut self, id: u64) {
let Some(mut task) = self.tasks.running.remove(&id) else { return };
if !self.contains(task.owner) {
return; }
let waker = Waker::from(Arc::new(TaskWaker { id, poster: self.poster() }));
let mut cx = Context::from_waker(&waker);
let owner = task.owner;
let polled = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| task.future.as_mut().poll(&mut cx)));
match polled {
Ok(Poll::Ready(finish)) => {
self.guarded(owner, "spawn_local", finish);
}
Ok(Poll::Pending) => {
self.tasks.running.insert(id, task);
}
Err(payload) => {
let message = crate::exception::panic_message(payload.as_ref());
self.raise_exception(crate::Exception { message, path: self.path_of(owner), event: "spawn_local".into() });
}
}
}
pub(crate) fn drop_tasks_of(&mut self, doomed: &[ComponentId]) {
self.tasks.running.retain(|_, t| !doomed.contains(&t.owner));
}
pub fn running_tasks(&self) -> usize {
self.tasks.running.len()
}
pub fn http_get(&mut self, url: &str) -> CallbackFuture<Result<Vec<u8>, String>> {
match self.services_mut().http.as_mut() {
Some(http) => from_callback(|done| http.get(url, done)),
None => CallbackFuture::ready(Err("sem o serviço de HTTP nesta plataforma".into())),
}
}
pub fn choose_files(&mut self, options: crate::platform::FileDialogOptions) -> CallbackFuture<Vec<String>> {
match self.services_mut().file_dialogs.as_mut() {
Some(dialogs) => from_callback(|done| dialogs.show(options, done)),
None => CallbackFuture::ready(Vec::new()),
}
}
pub fn request_permissions(
&mut self,
permissions: Vec<crate::platform::Permission>,
) -> CallbackFuture<Vec<(crate::platform::Permission, crate::platform::PermissionState)>> {
match self.services_mut().permissions.as_mut() {
Some(service) => from_callback(|done| service.request(permissions, done)),
None => CallbackFuture::ready(Vec::new()),
}
}
pub fn print_pages(&mut self, title: &str, pages: crate::pages::PageSet) -> CallbackFuture<Result<bool, String>> {
match self.services_mut().printer.as_mut() {
Some(printer) => from_callback(|done| printer.print(title, pages, done)),
None => CallbackFuture::ready(Err("sem impressão nesta plataforma".into())),
}
}
}
pub struct CallbackFuture<T> {
shared: Arc<Mutex<(Option<T>, Option<Waker>)>>,
}
impl<T> CallbackFuture<T> {
pub fn ready(value: T) -> Self {
CallbackFuture { shared: Arc::new(Mutex::new((Some(value), None))) }
}
}
impl<T> Future for CallbackFuture<T> {
type Output = T;
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
let Ok(mut shared) = self.shared.lock() else { return Poll::Pending };
match shared.0.take() {
Some(value) => Poll::Ready(value),
None => {
shared.1 = Some(cx.waker().clone());
Poll::Pending
}
}
}
}
pub fn from_callback<T: Send + 'static>(start: impl FnOnce(Box<dyn FnOnce(T) + Send>)) -> CallbackFuture<T> {
let shared: Arc<Mutex<(Option<T>, Option<Waker>)>> = Arc::new(Mutex::new((None, None)));
let answer = shared.clone();
start(Box::new(move |value| {
let waker = answer.lock().ok().and_then(|mut s| {
s.0 = Some(value);
s.1.take()
});
if let Some(waker) = waker {
waker.wake();
}
}));
CallbackFuture { shared }
}