How to create surface with lifetime in WindowEvent::Resumed (wgpu 0.19)

[fr-an-k]

In Android you can only create a surface after WindowEvent::Resumed and before WindowEvent::Suspended.
It has always been impossible to get wgpu to run on Android (8.1), but I did manage to get a surface with android-activity winit + wgpu, but that's using old versions.
In wgpu 0.19 Surface gets a lifetime annotation; I cannot seem to get this to work.
There does not seem to be an example using wgpu 0.19 and WindowEvent::Resumed.
I tried to understand life times but the documentation is too vague regarding this situation.
It looks like atomics are needed like Arc to manipulate the lifetime, and the android example uses a static lifetime, which doesn't seem appropriate.
How do I achieve this?
It's very frustrating that there is no documentation or cross-platform gpu example for beginning Rust developers.

[fr-an-k]

In the end I was able to run the android-activity winit + wgpu example with wgpu bumped from 0.14 to 0.18 (!= 0.19), adding "rwh_05" to winit features (instead of the default rwh_06) and fixing the compiler errors.

So at least I can move on, but the issue above remains.

[grovesNL]

Do you have an minimal example we could help with?

A 'static lifetime for your window is totally fine if you expect one window to be available while rendering, and usually that's what you'd see in most projects. Using an Arc around the window handle should give you a 'static lifetime for example - this basically means that the window is always guaranteed to be available while wgpu is using it.

To easily get a 'static lifetime for your surface,, you could wrap it in an Arc using something like this:

 // Wrap the window in an `Arc`
let window = Arc::new(WindowBuilder::new().build(&event_loop).unwrap());

// ... then at some point later when you're creating your surface ...

// Clone the `Arc` and pass it to the surface
 let surface = instance.create_surface(window.clone()).unwrap();

The window.clone() increases the refcount so the surface can guarantee that the window is always available while we're using it.

[fr-an-k]

I managed to solve it; in an earlier attempt I moved the window variable to the run function (stack) behind an Option.
The approach from the original example worked, having window and surface in a SurfaceState struct in App.

It kind of makes sense now, the compiler abstracts the lifetime of the parameters, losing the connection to the lifetime of the App struct.

Indeed the window also needs to be wrapped in an Arc.
I'll try to do a pull request on rust-android-examples (originally from android-activity) to have the example updated.

https://github.com/rust-mobile/rust-android-examples