examples: Implement proper Event::Resumed semantics

On Android the backing buffer (`NativeWindow`) disappears when the
application is not focussed and/or the screen is locked.  Winit handles
this by requiring apps to create their `raw_window_handle()` consumers
_after_ `Event::Resumed` and to clean it up _before_ returning from
`Event::Suspended`.  For consistency Winit also sends `Resumed` on all
other platforms during init.

examples/utils/winit_app.rs

@@ -31,76 +31,95 @@ pub(crate) fn make_window(
 }
 
 /// Easily constructable winit application.
-pub(crate) struct WinitApp<T, Init, Handler> {
-    /// Closure to initialize state.
+pub(crate) struct WinitApp<T, S, Init, InitSurface, Handler> {
+    /// Closure to initialize `state`.
     init: Init,
 
+    /// Closure to initialize `surface_state`.
+    init_surface: InitSurface,
+
     /// Closure to run on window events.
     event: Handler,
 
     /// Contained state.
     state: Option<T>,
+
+    ///
+    surface_state: Option<S>,
 }
 
 /// Builder that makes it so we don't have to name `T`.
-pub(crate) struct WinitAppBuilder<T, Init> {
-    /// Closure to initialize state.
+pub(crate) struct WinitAppBuilder<T, S, Init, InitSurface> {
+    /// Closure to initialize `state`.
     init: Init,
 
+    /// Closure to initialize `surface_state`.
+    init_surface: InitSurface,
+
     /// Eat the type parameter.
-    _marker: PhantomData<Option<T>>,
+    _marker: PhantomData<(Option<T>, Option<S>)>,
 }
 
-impl<T, Init> WinitAppBuilder<T, Init>
+impl<T, S, Init, InitSurface> WinitAppBuilder<T, S, Init, InitSurface>
 where
     Init: FnMut(&ActiveEventLoop) -> T,
+    InitSurface: FnMut(&ActiveEventLoop, &mut T) -> S,
 {
     /// Create with an "init" closure.
-    pub(crate) fn with_init(init: Init) -> Self {
+    pub(crate) fn with_init(init: Init, init_surface: InitSurface) -> Self {
         Self {
             init,
+            init_surface,
             _marker: PhantomData,
         }
     }
 
     /// Build a new application.
-    pub(crate) fn with_event_handler<F>(self, handler: F) -> WinitApp<T, Init, F>
+    pub(crate) fn with_event_handler<F>(self, handler: F) -> WinitApp<T, S, Init, InitSurface, F>
     where
-        F: FnMut(&mut T, Event<()>, &ActiveEventLoop),
+        F: FnMut(&mut T, Option<&mut S>, Event<()>, &ActiveEventLoop),
     {
-        WinitApp::new(self.init, handler)
+        WinitApp::new(self.init, self.init_surface, handler)
     }
 }
 
-impl<T, Init, Handler> WinitApp<T, Init, Handler>
+impl<T, S, Init, InitSurface, Handler> WinitApp<T, S, Init, InitSurface, Handler>
 where
     Init: FnMut(&ActiveEventLoop) -> T,
-    Handler: FnMut(&mut T, Event<()>, &ActiveEventLoop),
+    InitSurface: FnMut(&ActiveEventLoop, &mut T) -> S,
+    Handler: FnMut(&mut T, Option<&mut S>, Event<()>, &ActiveEventLoop),
 {
     /// Create a new application.
-    pub(crate) fn new(init: Init, event: Handler) -> Self {
+    pub(crate) fn new(init: Init, init_surface: InitSurface, event: Handler) -> Self {
         Self {
             init,
+            init_surface,
             event,
             state: None,
+            surface_state: None,
         }
     }
 }
 
-impl<T, Init, Handler> ApplicationHandler for WinitApp<T, Init, Handler>
+impl<T, S, Init, InitSurface, Handler> ApplicationHandler
+    for WinitApp<T, S, Init, InitSurface, Handler>
 where
     Init: FnMut(&ActiveEventLoop) -> T,
-    Handler: FnMut(&mut T, Event<()>, &ActiveEventLoop),
+    InitSurface: FnMut(&ActiveEventLoop, &mut T) -> S,
+    Handler: FnMut(&mut T, Option<&mut S>, Event<()>, &ActiveEventLoop),
 {
     fn resumed(&mut self, el: &ActiveEventLoop) {
         debug_assert!(self.state.is_none());
-        self.state = Some((self.init)(el));
+        let mut state = (self.init)(el);
+        self.surface_state = Some((self.init_surface)(el, &mut state));
+        self.state = Some(state);
     }
 
     fn suspended(&mut self, _event_loop: &ActiveEventLoop) {
-        let state = self.state.take();
-        debug_assert!(state.is_some());
-        drop(state);
+        // TODO: Should we run a destruction function for the user?
+        let surface_state = self.surface_state.take();
+        debug_assert!(surface_state.is_some());
+        drop(surface_state);
     }
 
     fn window_event(
@@ -110,12 +129,23 @@ where
         event: WindowEvent,
     ) {
         let state = self.state.as_mut().unwrap();
-        (self.event)(state, Event::WindowEvent { window_id, event }, event_loop);
+        let surface_state = self.surface_state.as_mut();
+        (self.event)(
+            state,
+            surface_state,
+            Event::WindowEvent { window_id, event },
+            event_loop,
+        );
     }
 
     fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
         if let Some(state) = self.state.as_mut() {
-            (self.event)(state, Event::AboutToWait, event_loop);
+            (self.event)(
+                state,
+                self.surface_state.as_mut(),
+                Event::AboutToWait,
+                event_loop,
+            );
         }
     }
 }

examples/winit.rs

@@ -9,23 +9,28 @@ mod winit_app;
 fn main() {
     let event_loop = EventLoop::new().unwrap();
 
-    let app = winit_app::WinitAppBuilder::with_init(|elwt| {
-        let window = winit_app::make_window(elwt, |w| w);
+    let app = winit_app::WinitAppBuilder::with_init(
+        |elwt| {
+            let window = winit_app::make_window(elwt, |w| w);
 
-        let context = softbuffer::Context::new(window.clone()).unwrap();
-        let surface = softbuffer::Surface::new(&context, window.clone()).unwrap();
+            let context = softbuffer::Context::new(window.clone()).unwrap();
 
-        (window, surface)
-    })
-    .with_event_handler(|state, event, elwt| {
-        let (window, surface) = state;
+            (window, context)
+        },
+        |_elwt, (window, context)| softbuffer::Surface::new(context, window.clone()).unwrap(),
+    )
+    .with_event_handler(|(window, _context), surface, event, elwt| {
         elwt.set_control_flow(ControlFlow::Wait);
 
         match event {
             Event::WindowEvent {
                 window_id,
                 event: WindowEvent::RedrawRequested,
             } if window_id == window.id() => {
+                let Some(surface) = surface else {
+                    eprintln!("RedrawRequested fired before Resumed or after Suspended");
+                    return;
+                };
                 if let (Some(width), Some(height)) = {
                     let size = window.inner_size();
                     (NonZeroU32::new(size.width), NonZeroU32::new(size.height))