wgame_app/
windowed_task.rs1use crate::{
2 Window,
3 executor::TaskId,
4 output::{CallOutput, Terminated},
5 runtime::{CallbackTrigger, Runtime, Task},
6 window::create_window,
7};
8use futures::{FutureExt, future::FusedFuture};
9use std::{
10 cell::{Cell, RefCell},
11 pin::Pin,
12 rc::Rc,
13 task::{Context, Poll, Waker},
14};
15use thiserror::Error;
16use winit::{error::OsError, window::WindowAttributes};
17
18pub fn create_windowed_task<T, F>(
19 rt: &Runtime,
20 attributes: WindowAttributes,
21 window_fn: F,
22) -> WindowedTask<T>
23where
24 T: 'static,
25 F: AsyncFnOnce(Window<'_>) -> T + 'static,
26{
27 let app = rt.clone();
28 let cancelled = Rc::new(Cell::new(false));
29 let token = cancelled.clone();
30 let output = rt.run_within_event_loop(
31 move |event_loop| {
32 if token.get() {
33 Ok(None)
34 } else {
35 create_window(app, attributes, event_loop, window_fn).map(Some)
36 }
37 },
38 CallbackTrigger::PollResumed,
39 );
40 WindowedTask(Rc::new(RefCell::new(State {
41 stage: Stage::Create(output),
42 cancelled,
43 finished: false,
44 waker: None,
45 })))
46}
47#[derive(Debug, Error)]
48pub enum WindowError {
49 #[error("Cannot create window: {0}")]
50 Creation(OsError),
51 #[error("Application suspended")]
52 Suspended,
53 #[error("Window task terminated")]
54 Terminated,
55}
56pub struct WindowedTask<T>(Rc<RefCell<State<T>>>);
62pub struct WindowTaskHandle<T>(Rc<RefCell<State<T>>>);
64impl<T> Clone for WindowTaskHandle<T> {
65 fn clone(&self) -> Self {
66 Self(self.0.clone())
67 }
68}
69impl<T> WindowTaskHandle<T> {
70 pub fn terminate(&self) {
71 let waker = {
72 let mut state = self.0.borrow_mut();
73 if state.finished {
74 return;
75 }
76 state.cancelled.set(true);
77 match &state.stage {
78 Stage::Run(task) => task.terminate(),
79 Stage::Create(output) => output.with_ready(|result| {
80 if let Ok(Some(task)) = result {
81 task.terminate();
82 }
83 }),
84 }
85 state.waker.take()
86 };
87 if let Some(waker) = waker {
88 waker.wake();
89 }
90 }
91}
92struct State<T> {
93 stage: Stage<T>,
94 cancelled: Rc<Cell<bool>>,
95 finished: bool,
96 waker: Option<Waker>,
97}
98enum Stage<T> {
99 Create(CallOutput<Result<Option<Task<T>>, OsError>>),
100 Run(Task<T>),
101}
102impl<T> WindowedTask<T> {
103 pub fn id(&self) -> Option<TaskId> {
104 match &self.0.borrow().stage {
105 Stage::Run(task) => Some(task.id()),
106 _ => None,
107 }
108 }
109 pub fn handle(&self) -> WindowTaskHandle<T> {
110 WindowTaskHandle(self.0.clone())
111 }
112 pub fn terminate(&self) {
113 self.handle().terminate();
114 }
115}
116impl<T> Future for WindowedTask<T> {
117 type Output = Result<T, WindowError>;
118 fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
119 let mut state = self.0.borrow_mut();
120 assert!(!state.finished, "Window task result already consumed");
121 state.waker = Some(cx.waker().clone());
122 if state.cancelled.get() {
123 if let Stage::Create(output) = &state.stage
124 && let Some(Ok(Some(task))) = output.try_take()
125 {
126 task.terminate();
127 }
128 state.finished = true;
129 return Poll::Ready(Err(WindowError::Terminated));
130 }
131 if let Stage::Create(output) = &mut state.stage {
132 match output.poll_unpin(cx) {
133 Poll::Pending => return Poll::Pending,
134 Poll::Ready(Ok(Some(task))) => state.stage = Stage::Run(task),
135 Poll::Ready(Ok(None)) => {
136 state.finished = true;
137 return Poll::Ready(Err(WindowError::Terminated));
138 }
139 Poll::Ready(Err(err)) => {
140 state.finished = true;
141 return Poll::Ready(Err(WindowError::Creation(err)));
142 }
143 }
144 }
145 let Stage::Run(task) = &mut state.stage else {
146 unreachable!()
147 };
148 match task.poll_unpin(cx) {
149 Poll::Pending => Poll::Pending,
150 Poll::Ready(result) => {
151 state.finished = true;
152 Poll::Ready(result.map_err(|Terminated| WindowError::Suspended))
153 }
154 }
155 }
156}
157impl<T> FusedFuture for WindowedTask<T> {
158 fn is_terminated(&self) -> bool {
159 self.0.borrow().finished
160 }
161}
162
163#[cfg(test)]
164mod tests {
165 use super::*;
166 #[test]
167 fn cancelling_detached_creation_also_cancels_created_task() {
168 let mut executor = crate::executor::Executor::with_waker_factory(|_| Waker::noop().clone());
169 let rt = Runtime {
170 state: Default::default(),
171 executor: executor.proxy(),
172 timers: Default::default(),
173 callbacks: Default::default(),
174 };
175 let task = rt.create_task(async {
176 panic!("cancelled window ran");
177 });
178 let output = CallOutput::default();
179 output.set_ready(Ok(Some(task)));
180 let window = WindowedTask(Rc::new(RefCell::new(State {
181 stage: Stage::Create(output),
182 cancelled: Rc::new(Cell::new(false)),
183 finished: false,
184 waker: None,
185 })));
186 let handle = window.handle();
187 drop(window);
188 handle.terminate();
189 assert!(executor.poll().is_ready());
190 }
191 #[test]
192 fn cancel_before_creation_completes_without_resume() {
193 let mut task: WindowedTask<()> = WindowedTask(Rc::new(RefCell::new(State {
194 stage: Stage::Create(CallOutput::default()),
195 cancelled: Rc::new(Cell::new(false)),
196 finished: false,
197 waker: None,
198 })));
199 let mut cx = Context::from_waker(Waker::noop());
200 assert!(Pin::new(&mut task).poll(&mut cx).is_pending());
201 task.handle().terminate();
202 assert!(matches!(
203 Pin::new(&mut task).poll(&mut cx),
204 Poll::Ready(Err(WindowError::Terminated))
205 ));
206 assert!(task.is_terminated());
207 }
208}