Merge tag 'v0.4.2' into v0.4

Release 0.4.2

.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: cargo
+    directory: /
+    schedule:
+      interval: weekly
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly

.github/workflows/ci.yml

@@ -16,12 +16,10 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        # We need to support the same MSRV as Winit which we are currently
-        # assuming will be bumped to 1.60.0 soon:
-        # https://github.com/rust-windowing/winit/pull/2453
-        rust_version: [1.60.0, stable]
+        # See top README for MSRV policy
+        rust_version: [1.64.0, stable]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - uses: hecrj/setup-rust-action@v1
         with:
@@ -36,7 +34,9 @@ jobs:
           i686-linux-android
 
       - name: Install cargo-ndk
-        run: cargo install cargo-ndk
+        # We're currently sticking with cargo-ndk 2, until we bump our
+        # MSRV to 1.68+
+        run: cargo install cargo-ndk --version "^2"
 
       - name: Setup Java
         uses: actions/setup-java@v3
@@ -96,7 +96,7 @@ jobs:
   format:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - uses: actions-rs/toolchain@v1
         with:

README.md

@@ -1,4 +1,11 @@
-# Overview
+# `android-activity`
+
+[![ci](https://github.com/rust-mobile/android-activity/actions/workflows/ci.yml/badge.svg)](https://github.com/rust-mobile/android-activity/actions/workflows/ci.yml)
+[![crates.io](https://img.shields.io/crates/v/android-activity.svg)](https://crates.io/crates/android-activity)
+[![Docs](https://docs.rs/android-activity/badge.svg)](https://docs.rs/android-activity)
+[![MSRV](https://img.shields.io/badge/rustc-1.64.0+-ab6000.svg)](https://blog.rust-lang.org/2022/09/22/Rust-1.64.0.html)
+
+## Overview
 
 `android-activity` provides a "glue" layer for building native Rust
 applications on Android, supporting multiple [`Activity`] base classes.
@@ -22,10 +29,11 @@ applications.
 [ndk-glue]: https://crates.io/crates/ndk-glue
 [agdk]: https://developer.android.com/games/agdk
 
-# Example
+## Example
 
 Cargo.toml
-```
+
+```toml
 [dependencies]
 log = "0.4"
 android_logger = "0.11"
@@ -38,6 +46,7 @@ crate_type = ["cdylib"]
 _Note: that you will need to either specify the **"native-activity"** feature or **"game-activity"** feature to identify which `Activity` base class your application is based on_
 
 lib.rs
+
 ```rust
 use android_activity::{AndroidApp, InputStatus, MainEvent, PollEvent};
 
@@ -69,14 +78,14 @@ fn android_main(app: AndroidApp) {
 }
 ```
 
-```
+```sh
 rustup target add aarch64-linux-android
 cargo install cargo-apk
 cargo apk run
 adb logcat example:V *:S
 ```
 
-# Full Examples
+## Full Examples
 
 See [this collection of examples](https://github.com/rust-mobile/rust-android-examples) (based on both `GameActivity` and `NativeActivity`).
 
@@ -84,7 +93,7 @@ Each example is a standalone project that may also be a convenient templates for
 
 For the examples based on middleware frameworks (Winit and or Egui) they also aim to demonstrate how it's possible to write portable code that will run on Android and other systems.
 
-# Should I use NativeActivity or GameActivity?
+## Should I use NativeActivity or GameActivity?
 
 To learn more about the `NativeActivity` class that's shipped with Android see [here](https://developer.android.com/ndk/guides/concepts#naa).
 
@@ -96,22 +105,23 @@ It's expected that the `GameActivity` backend will gain more sophisticated input
 
 Even if you start out using `NativeActivity` for the convenience, it's likely that most moderately complex applications will eventually need to define their own `Activity` subclass (either subclassing `NativeActivity` or `GameActivity`) which will require compiling at least a small amount of Java or Kotlin code. This is generally due to Android's design which directs numerous events via the `Activity` class which can only be processed by overloading some associated Activity method.
 
-# Switching from ndk-glue to android-activity
+## Switching from ndk-glue to android-activity
+
+### Winit-based applications
 
-## Winit-based applications
 Firstly; if you have a [Winit](https://crates.io/crates/winit) based application and also have an explicit dependency on `ndk-glue` your application will need to remove its dependency on `ndk-glue` for the 0.28 release of Winit which will be based on android-activity (Since glue crates, due to their nature, can't be compatible with alternative glue crates).
 
 Winit-based applications can follow the [Android README](https://github.com/rust-windowing/winit#android) guidance for advice on how to switch over. Most Winit-based applications should aim to remove any explicit dependency on a specific glue crate (so not depend directly on `ndk-glue` or `android-activity` and instead rely on Winit to pull in the right glue crate). The main practical change will then be to add a `#[no_mangle]fn android_main(app: AndroidApp)` entry point.
 
 See the [Android README](https://github.com/rust-windowing/winit#android) for more details and also see the [Winit-based examples here](https://github.com/rust-mobile/rust-android-examples).
 
-## Middleware crates (i.e. not applications)
+### Middleware crates (i.e. not applications)
 
 If you have a crate that would be considered a middleware library (for example using JNI to support access to Bluetooth, or Android's Camera APIs) then the crate should almost certainly remove any dependence on a specific glue crate because this imposes a strict compatibility constraint that means the crate can only be used by applications that use that exact same glue crate version.
 
 Middleware libraries can instead look at using the [ndk-context](https://crates.io/crates/ndk-context) crate as a means for being able to use JNI without making any assumptions about the applications overall architecture. This way a middleware crate can work with alternative glue crates (including `ndk-glue` and `android-activity`) as well as work with embedded use cases (i.e. non-native applications that may just embed a dynamic library written in Rust to implement certain native functions).
 
-## Other, non-Winit-based applications
+### Other, non-Winit-based applications
 
 The steps to switch a simple standalone application over from `ndk-glue` to `android-activity` (still based on `NativeActivity`) should be:
 
@@ -120,7 +130,7 @@ The steps to switch a simple standalone application over from `ndk-glue` to `and
 3. Optionally add a dependency on `android_logger = "0.11.0"`
 4. Update the `main` entry point to look like this:
 
-```
+```rust
 use android_activity::AndroidApp;
 
 #[no_mangle]
@@ -133,8 +143,7 @@ See this minimal [NativeActivity Mainloop](https://github.com/rust-mobile/androi
 
 There is is no `#[ndk_glue::main]` replacement considering that `android_main()` entry point needs to be passed an `AndroidApp` argument which isn't compatible with a traditional `main()` function. Having an Android specific entry point also gives a place to initialize Android logging and handle other Android specific details (such as building an event loop based on the `app` argument)
 
-
-## Design Summary / Motivation behind android-activity
+### Design Summary / Motivation behind android-activity
 
 Prior to working on android-activity, the existing glue crates available for building standalone Rust applications on Android were found to have a number of technical limitations that this crate aimed to solve:
 
@@ -142,8 +151,14 @@ Prior to working on android-activity, the existing glue crates available for bui
 2. **Encapsulate IPC + synchronization between the native thread and the JVM thread**: For example with `ndk-glue` the application itself needs to avoid race conditions between the native and Java thread by following a locking convention) and it wasn't clear how this would extend to support other requests (like state saving) that also require synchronization.
 3. **Avoid static global state**: Keeping in mind the possibility of supporting applications with multiple native activities there was interest in having an API that didn't rely on global statics to track top-level state. Instead of having global getters for state then `android-activity` passes an explicit `app: AndroidApp` argument to the entry point that encapsulates the state connected with a single `Activity`.
 
-
 [`GameTextInput`]: https://developer.android.com/games/agdk/add-support-for-text-input
 [`AppCompatActivity`]: https://developer.android.com/reference/androidx/appcompat/app/AppCompatActivity
 
+## MSRV
 
+We aim to (at least) support stable releases of Rust from the last three months. Rust has a 6 week release cycle which means we will support the last three stable releases.
+For example, when Rust 1.69 is released we would limit our `rust_version` to 1.67.
+
+We will only bump the `rust_version` at the point where we either depend on a new features or a dependency has increased its MSRV, and we won't be greedy. In other words we will only set the MSRV to the lowest version that's _needed_.
+
+MSRV updates are not considered to be inherently semver breaking (unless a new feature is exposed in the public API) and so a `rust_version` change may happen in patch releases.

android-activity/CHANGELOG.md

@@ -4,6 +4,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+
+## [0.4.2] - 2022-02-16
+### Changed
+- The `Activity.finish()` method is now called when `android_main` returns so the `Activity` will be destroyed ([#67](https://github.com/rust-mobile/android-activity/issues/67))
+- The `native-activity` backend now propagates `NativeWindow` redraw/resize and `ContentRectChanged` callbacks to main loop ([#70](https://github.com/rust-mobile/android-activity/pull/70))
+- The `game-activity` implementation of `pointer_index()` was fixed to not always return `0` ([#80](https://github.com/rust-mobile/android-activity/pull/84))
+- Added `panic` guards around application's `android_main()` and native code that could potentially unwind across a Java FFI boundary ([#68](https://github.com/rust-mobile/android-activity/pull/68))
+
 ## [0.4.1] - 2022-02-16
 ### Added
 - Added `AndroidApp::vm_as_ptr()` to expose JNI `JavaVM` pointer ([#60](https://github.com/rust-mobile/android-activity/issues/60))

android-activity/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "android-activity"
-version = "0.4.1"
+version = "0.4.2"
 edition = "2021"
 keywords = ["android", "ndk"]
 readme = "../README.md"
@@ -9,6 +9,7 @@ repository = "https://github.com/rust-mobile/android-activity"
 documentation = "https://docs.rs/android-activity"
 description = "Glue for building Rust applications on Android with NativeActivity or GameActivity"
 license = "MIT OR Apache-2.0"
+rust-version = "1.64"
 
 [features]
 # Note: we don't enable any backend by default since features
@@ -17,7 +18,7 @@ license = "MIT OR Apache-2.0"
 #
 # In general it's only the final application crate that needs
 # to decide on a backend.
-default=[]
+default = []
 game-activity = []
 native-activity = []
 
@@ -28,7 +29,7 @@ ndk = "0.7"
 ndk-sys = "0.4"
 ndk-context = "0.1"
 android-properties = "0.2"
-num_enum = "0.5"
+num_enum = "0.6"
 bitflags = "1.3"
 libc = "0.2"
 
@@ -43,4 +44,4 @@ targets = [
     "x86_64-linux-android",
 ]
 
-rustdoc-args = ["--cfg", "docsrs" ]
+rustdoc-args = ["--cfg", "docsrs"]

android-activity/src/game_activity/input.rs

@@ -332,7 +332,7 @@ impl<'a> MotionEvent<'a> {
     /// or [`PointerDown`](MotionAction::PointerDown).
     #[inline]
     pub fn pointer_index(&self) -> usize {
-        let action = self.action as u32 & ndk_sys::AMOTION_EVENT_ACTION_MASK;
+        let action = self.action as u32;
         let index = (action & ndk_sys::AMOTION_EVENT_ACTION_POINTER_INDEX_MASK)
             >> ndk_sys::AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
         index as usize

android-activity/src/game_activity/mod.rs

@@ -5,8 +5,8 @@ use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::marker::PhantomData;
 use std::ops::Deref;
-use std::os::raw;
 use std::os::unix::prelude::*;
+use std::panic::catch_unwind;
 use std::ptr::NonNull;
 use std::sync::{Arc, RwLock};
 use std::time::Duration;
@@ -24,6 +24,7 @@ use ndk::asset::AssetManager;
 use ndk::configuration::Configuration;
 use ndk::native_window::NativeWindow;
 
+use crate::util::{abort_on_panic, android_log, log_panic};
 use crate::{
     util, AndroidApp, ConfigurationRef, InputStatus, MainEvent, PollEvent, Rect, WindowManagerFlags,
 };
@@ -595,19 +596,6 @@ pub unsafe extern "C" fn GameActivity_onCreate(
     GameActivity_onCreate_C(activity, saved_state, saved_state_size);
 }
 
-fn android_log(level: Level, tag: &CStr, msg: &CStr) {
-    let prio = match level {
-        Level::Error => ndk_sys::android_LogPriority::ANDROID_LOG_ERROR,
-        Level::Warn => ndk_sys::android_LogPriority::ANDROID_LOG_WARN,
-        Level::Info => ndk_sys::android_LogPriority::ANDROID_LOG_INFO,
-        Level::Debug => ndk_sys::android_LogPriority::ANDROID_LOG_DEBUG,
-        Level::Trace => ndk_sys::android_LogPriority::ANDROID_LOG_VERBOSE,
-    };
-    unsafe {
-        ndk_sys::__android_log_write(prio.0 as raw::c_int, tag.as_ptr(), msg.as_ptr());
-    }
-}
-
 extern "Rust" {
     pub fn android_main(app: AndroidApp);
 }
@@ -616,56 +604,76 @@ extern "Rust" {
 // `app_main` function. This is run on a dedicated thread spawned
 // by android_native_app_glue.
 #[no_mangle]
-pub unsafe extern "C" fn _rust_glue_entry(app: *mut ffi::android_app) {
-    // Maybe make this stdout/stderr redirection an optional / opt-in feature?...
-    let mut logpipe: [RawFd; 2] = Default::default();
-    libc::pipe(logpipe.as_mut_ptr());
-    libc::dup2(logpipe[1], libc::STDOUT_FILENO);
-    libc::dup2(logpipe[1], libc::STDERR_FILENO);
-    thread::spawn(move || {
-        let tag = CStr::from_bytes_with_nul(b"RustStdoutStderr\0").unwrap();
-        let file = File::from_raw_fd(logpipe[0]);
-        let mut reader = BufReader::new(file);
-        let mut buffer = String::new();
-        loop {
-            buffer.clear();
-            if let Ok(len) = reader.read_line(&mut buffer) {
-                if len == 0 {
-                    break;
-                } else if let Ok(msg) = CString::new(buffer.clone()) {
-                    android_log(Level::Info, tag, &msg);
+#[allow(unused_unsafe)] // Otherwise rust 1.64 moans about using unsafe{} in unsafe functions
+pub unsafe extern "C" fn _rust_glue_entry(native_app: *mut ffi::android_app) {
+    abort_on_panic(|| {
+        // Maybe make this stdout/stderr redirection an optional / opt-in feature?...
+        let mut logpipe: [RawFd; 2] = Default::default();
+        libc::pipe(logpipe.as_mut_ptr());
+        libc::dup2(logpipe[1], libc::STDOUT_FILENO);
+        libc::dup2(logpipe[1], libc::STDERR_FILENO);
+        thread::spawn(move || {
+            let tag = CStr::from_bytes_with_nul(b"RustStdoutStderr\0").unwrap();
+            let file = File::from_raw_fd(logpipe[0]);
+            let mut reader = BufReader::new(file);
+            let mut buffer = String::new();
+            loop {
+                buffer.clear();
+                if let Ok(len) = reader.read_line(&mut buffer) {
+                    if len == 0 {
+                        break;
+                    } else if let Ok(msg) = CString::new(buffer.clone()) {
+                        android_log(Level::Info, tag, &msg);
+                    }
                 }
             }
+        });
+
+        let jvm = unsafe {
+            let jvm = (*(*native_app).activity).vm;
+            let activity: jobject = (*(*native_app).activity).javaGameActivity;
+            ndk_context::initialize_android_context(jvm.cast(), activity.cast());
+
+            // Since this is a newly spawned thread then the JVM hasn't been attached
+            // to the thread yet. Attach before calling the applications main function
+            // so they can safely make JNI calls
+            let mut jenv_out: *mut core::ffi::c_void = std::ptr::null_mut();
+            if let Some(attach_current_thread) = (*(*jvm)).AttachCurrentThread {
+                attach_current_thread(jvm, &mut jenv_out, std::ptr::null_mut());
+            }
+
+            jvm
+        };
+
+        unsafe {
+            let app = AndroidApp::from_ptr(NonNull::new(native_app).unwrap());
+
+            // We want to specifically catch any panic from the application's android_main
+            // so we can finish + destroy the Activity gracefully via the JVM
+            catch_unwind(|| {
+                // XXX: If we were in control of the Java Activity subclass then
+                // we could potentially run the android_main function via a Java native method
+                // springboard (e.g. call an Activity subclass method that calls a jni native
+                // method that then just calls android_main()) that would make sure there was
+                // a Java frame at the base of our call stack which would then be recognised
+                // when calling FindClass to lookup a suitable classLoader, instead of
+                // defaulting to the system loader. Without this then it's difficult for native
+                // code to look up non-standard Java classes.
+                android_main(app);
+            })
+            .unwrap_or_else(|panic| log_panic(panic));
+
+            // Let JVM know that our Activity can be destroyed before detaching from the JVM
+            //
+            // "Note that this method can be called from any thread; it will send a message
+            //  to the main thread of the process where the Java finish call will take place"
+            ffi::GameActivity_finish((*native_app).activity);
+
+            if let Some(detach_current_thread) = (*(*jvm)).DetachCurrentThread {
+                detach_current_thread(jvm);
+            }
+
+            ndk_context::release_android_context();
         }
-    });
-
-    let jvm: *mut JavaVM = (*(*app).activity).vm;
-    let activity: jobject = (*(*app).activity).javaGameActivity;
-    ndk_context::initialize_android_context(jvm.cast(), activity.cast());
-
-    let app = AndroidApp::from_ptr(NonNull::new(app).unwrap());
-
-    // Since this is a newly spawned thread then the JVM hasn't been attached
-    // to the thread yet. Attach before calling the applications main function
-    // so they can safely make JNI calls
-    let mut jenv_out: *mut core::ffi::c_void = std::ptr::null_mut();
-    if let Some(attach_current_thread) = (*(*jvm)).AttachCurrentThread {
-        attach_current_thread(jvm, &mut jenv_out, std::ptr::null_mut());
-    }
-
-    // XXX: If we were in control of the Java Activity subclass then
-    // we could potentially run the android_main function via a Java native method
-    // springboard (e.g. call an Activity subclass method that calls a jni native
-    // method that then just calls android_main()) that would make sure there was
-    // a Java frame at the base of our call stack which would then be recognised
-    // when calling FindClass to lookup a suitable classLoader, instead of
-    // defaulting to the system loader. Without this then it's difficult for native
-    // code to look up non-standard Java classes.
-    android_main(app);
-
-    if let Some(detach_current_thread) = (*(*jvm)).DetachCurrentThread {
-        detach_current_thread(jvm);
-    }
-
-    ndk_context::release_android_context();
+    })
 }

android-activity/src/input.rs

@@ -63,7 +63,7 @@ pub enum Class {
 
 impl From<u32> for Class {
     fn from(source: u32) -> Self {
-        let class = SourceFlags::from_bits_truncate(source as u32);
+        let class = SourceFlags::from_bits_truncate(source);
         match class {
             SourceFlags::BUTTON => Class::Button,
             SourceFlags::POINTER => Class::Pointer,

android-activity/src/native_activity/glue.rs

@@ -8,15 +8,19 @@ use std::{
     io::{BufRead, BufReader},
     ops::Deref,
     os::unix::prelude::{FromRawFd, RawFd},
+    panic::catch_unwind,
     ptr::{self, NonNull},
     sync::{Arc, Condvar, Mutex, Weak},
 };
 
 use log::Level;
 use ndk::{configuration::Configuration, input_queue::InputQueue, native_window::NativeWindow};
-use ndk_sys::ANativeActivity;
 
-use crate::ConfigurationRef;
+use crate::{
+    util::android_log,
+    util::{abort_on_panic, log_panic},
+    ConfigurationRef,
+};
 
 use super::{AndroidApp, Rect};
 
@@ -99,7 +103,7 @@ impl Deref for NativeActivityGlue {
 
 impl NativeActivityGlue {
     pub fn new(
-        activity: *mut ANativeActivity,
+        activity: *mut ndk_sys::ANativeActivity,
         saved_state: *const libc::c_void,
         saved_state_size: libc::size_t,
     ) -> Self {
@@ -126,9 +130,13 @@ impl NativeActivityGlue {
             (*(*activity).callbacks).onLowMemory = Some(on_low_memory);
             (*(*activity).callbacks).onWindowFocusChanged = Some(on_window_focus_changed);
             (*(*activity).callbacks).onNativeWindowCreated = Some(on_native_window_created);
+            (*(*activity).callbacks).onNativeWindowResized = Some(on_native_window_resized);
+            (*(*activity).callbacks).onNativeWindowRedrawNeeded =
+                Some(on_native_window_redraw_needed);
             (*(*activity).callbacks).onNativeWindowDestroyed = Some(on_native_window_destroyed);
             (*(*activity).callbacks).onInputQueueCreated = Some(on_input_queue_created);
             (*(*activity).callbacks).onInputQueueDestroyed = Some(on_input_queue_destroyed);
+            (*(*activity).callbacks).onContentRectChanged = Some(on_content_rect_changed);
         }
 
         glue
@@ -145,7 +153,7 @@ impl NativeActivityGlue {
         self.inner.mutex.lock().unwrap().read_cmd()
     }
 
-    /// For the Rust main thread to get an ndk::InputQueue that wraps the AInputQueue pointer
+    /// For the Rust main thread to get an [`InputQueue`] that wraps the AInputQueue pointer
     /// we have and at the same time ensure that the input queue is attached to the given looper.
     ///
     /// NB: it's expected that the input queue is detached as soon as we know there is new
@@ -208,7 +216,6 @@ pub struct NativeActivityState {
     pub redraw_needed: bool,
     pub pending_input_queue: *mut ndk_sys::AInputQueue,
     pub pending_window: Option<NativeWindow>,
-    pub pending_content_rect: ndk_sys::ARect,
 }
 
 impl NativeActivityState {
@@ -355,7 +362,6 @@ impl WaitableNativeActivityState {
                 redraw_needed: false,
                 pending_input_queue: ptr::null_mut(),
                 pending_window: None,
-                pending_content_rect: Rect::empty().into(),
             }),
             cond: Condvar::new(),
         }
@@ -396,6 +402,26 @@ impl WaitableNativeActivityState {
         });
     }
 
+    pub fn notify_window_resized(&self, native_window: *mut ndk_sys::ANativeWindow) {
+        let mut guard = self.mutex.lock().unwrap();
+        // set_window always syncs .pending_window back to .window before returning. This callback
+        // from Android can never arrive at an interim state, and validates that Android:
+        // 1. Only provides resizes in between onNativeWindowCreated and onNativeWindowDestroyed;
+        // 2. Doesn't call it on a bogus window pointer that we don't know about.
+        debug_assert_eq!(guard.window.as_ref().unwrap().ptr().as_ptr(), native_window);
+        guard.write_cmd(AppCmd::WindowResized);
+    }
+
+    pub fn notify_window_redraw_needed(&self, native_window: *mut ndk_sys::ANativeWindow) {
+        let mut guard = self.mutex.lock().unwrap();
+        // set_window always syncs .pending_window back to .window before returning. This callback
+        // from Android can never arrive at an interim state, and validates that Android:
+        // 1. Only provides resizes in between onNativeWindowCreated and onNativeWindowDestroyed;
+        // 2. Doesn't call it on a bogus window pointer that we don't know about.
+        debug_assert_eq!(guard.window.as_ref().unwrap().ptr().as_ptr(), native_window);
+        guard.write_cmd(AppCmd::WindowRedrawNeeded);
+    }
+
     unsafe fn set_input(&self, input_queue: *mut ndk_sys::AInputQueue) {
         let mut guard = self.mutex.lock().unwrap();
 
@@ -436,6 +462,12 @@ impl WaitableNativeActivityState {
         guard.pending_window = None;
     }
 
+    unsafe fn set_content_rect(&self, rect: *const ndk_sys::ARect) {
+        let mut guard = self.mutex.lock().unwrap();
+        guard.content_rect = *rect;
+        guard.write_cmd(AppCmd::ContentRectChanged);
+    }
+
     unsafe fn set_activity_state(&self, state: State) {
         let mut guard = self.mutex.lock().unwrap();
 
@@ -584,19 +616,6 @@ extern "Rust" {
     pub fn android_main(app: AndroidApp);
 }
 
-fn android_log(level: Level, tag: &CStr, msg: &CStr) {
-    let prio = match level {
-        Level::Error => ndk_sys::android_LogPriority::ANDROID_LOG_ERROR,
-        Level::Warn => ndk_sys::android_LogPriority::ANDROID_LOG_WARN,
-        Level::Info => ndk_sys::android_LogPriority::ANDROID_LOG_INFO,
-        Level::Debug => ndk_sys::android_LogPriority::ANDROID_LOG_DEBUG,
-        Level::Trace => ndk_sys::android_LogPriority::ANDROID_LOG_VERBOSE,
-    };
-    unsafe {
-        ndk_sys::__android_log_write(prio.0 as libc::c_int, tag.as_ptr(), msg.as_ptr());
-    }
-}
-
 unsafe fn try_with_waitable_activity_ref(
     activity: *mut ndk_sys::ANativeActivity,
     closure: impl FnOnce(Arc<WaitableNativeActivityState>),
@@ -613,91 +632,131 @@ unsafe fn try_with_waitable_activity_ref(
 }
 
 unsafe extern "C" fn on_destroy(activity: *mut ndk_sys::ANativeActivity) {
-    log::debug!("Destroy: {:p}\n", activity);
-    try_with_waitable_activity_ref(activity, |waitable_activity| {
-        waitable_activity.notify_destroyed()
-    });
+    abort_on_panic(|| {
+        log::debug!("Destroy: {:p}\n", activity);
+        try_with_waitable_activity_ref(activity, |waitable_activity| {
+            waitable_activity.notify_destroyed()
+        });
+    })
 }
 
 unsafe extern "C" fn on_start(activity: *mut ndk_sys::ANativeActivity) {
-    log::debug!("Start: {:p}\n", activity);
-    try_with_waitable_activity_ref(activity, |waitable_activity| {
-        waitable_activity.set_activity_state(State::Start);
-    });
+    abort_on_panic(|| {
+        log::debug!("Start: {:p}\n", activity);
+        try_with_waitable_activity_ref(activity, |waitable_activity| {
+            waitable_activity.set_activity_state(State::Start);
+        });
+    })
 }
 
 unsafe extern "C" fn on_resume(activity: *mut ndk_sys::ANativeActivity) {
-    log::debug!("Resume: {:p}\n", activity);
-    try_with_waitable_activity_ref(activity, |waitable_activity| {
-        waitable_activity.set_activity_state(State::Resume);
-    });
+    abort_on_panic(|| {
+        log::debug!("Resume: {:p}\n", activity);
+        try_with_waitable_activity_ref(activity, |waitable_activity| {
+            waitable_activity.set_activity_state(State::Resume);
+        });
+    })
 }
 
 unsafe extern "C" fn on_save_instance_state(
     activity: *mut ndk_sys::ANativeActivity,
     out_len: *mut ndk_sys::size_t,
 ) -> *mut libc::c_void {
-    log::debug!("SaveInstanceState: {:p}\n", activity);
-    *out_len = 0;
-    let mut ret = ptr::null_mut();
-    try_with_waitable_activity_ref(activity, |waitable_activity| {
-        let (state, len) = waitable_activity.request_save_state();
-        *out_len = len as ndk_sys::size_t;
-        ret = state
-    });
+    abort_on_panic(|| {
+        log::debug!("SaveInstanceState: {:p}\n", activity);
+        *out_len = 0;
+        let mut ret = ptr::null_mut();
+        try_with_waitable_activity_ref(activity, |waitable_activity| {
+            let (state, len) = waitable_activity.request_save_state();
+            *out_len = len as ndk_sys::size_t;
+            ret = state
+        });
 
-    log::debug!("Saved state = {:p}, len = {}", ret, *out_len);
-    ret
+        log::debug!("Saved state = {:p}, len = {}", ret, *out_len);
+        ret
+    })
 }
 
 unsafe extern "C" fn on_pause(activity: *mut ndk_sys::ANativeActivity) {
-    log::debug!("Pause: {:p}\n", activity);
-    try_with_waitable_activity_ref(activity, |waitable_activity| {
-        waitable_activity.set_activity_state(State::Pause);
-    });
+    abort_on_panic(|| {
+        log::debug!("Pause: {:p}\n", activity);
+        try_with_waitable_activity_ref(activity, |waitable_activity| {
+            waitable_activity.set_activity_state(State::Pause);
+        });
+    })
 }
 
 unsafe extern "C" fn on_stop(activity: *mut ndk_sys::ANativeActivity) {
-    log::debug!("Stop: {:p}\n", activity);
-    try_with_waitable_activity_ref(activity, |waitable_activity| {
-        waitable_activity.set_activity_state(State::Stop);
-    });
+    abort_on_panic(|| {
+        log::debug!("Stop: {:p}\n", activity);
+        try_with_waitable_activity_ref(activity, |waitable_activity| {
+            waitable_activity.set_activity_state(State::Stop);
+        });
+    })
 }
 
 unsafe extern "C" fn on_configuration_changed(activity: *mut ndk_sys::ANativeActivity) {
-    log::debug!("ConfigurationChanged: {:p}\n", activity);
-    try_with_waitable_activity_ref(activity, |waitable_activity| {
-        waitable_activity.notify_config_changed();
-    });
+    abort_on_panic(|| {
+        log::debug!("ConfigurationChanged: {:p}\n", activity);
+        try_with_waitable_activity_ref(activity, |waitable_activity| {
+            waitable_activity.notify_config_changed();
+        });
+    })
 }
 
 unsafe extern "C" fn on_low_memory(activity: *mut ndk_sys::ANativeActivity) {
-    log::debug!("LowMemory: {:p}\n", activity);
-    try_with_waitable_activity_ref(activity, |waitable_activity| {
-        waitable_activity.notify_low_memory();
-    });
+    abort_on_panic(|| {
+        log::debug!("LowMemory: {:p}\n", activity);
+        try_with_waitable_activity_ref(activity, |waitable_activity| {
+            waitable_activity.notify_low_memory();
+        });
+    })
 }
 
 unsafe extern "C" fn on_window_focus_changed(
     activity: *mut ndk_sys::ANativeActivity,
     focused: libc::c_int,
 ) {
-    log::debug!("WindowFocusChanged: {:p} -- {}\n", activity, focused);
-    try_with_waitable_activity_ref(activity, |waitable_activity| {
-        waitable_activity.notify_focus_changed(focused != 0);
-    });
+    abort_on_panic(|| {
+        log::debug!("WindowFocusChanged: {:p} -- {}\n", activity, focused);
+        try_with_waitable_activity_ref(activity, |waitable_activity| {
+            waitable_activity.notify_focus_changed(focused != 0);
+        });
+    })
 }
 
 unsafe extern "C" fn on_native_window_created(
     activity: *mut ndk_sys::ANativeActivity,
     window: *mut ndk_sys::ANativeWindow,
 ) {
-    log::debug!("NativeWindowCreated: {:p} -- {:p}\n", activity, window);
+    abort_on_panic(|| {
+        log::debug!("NativeWindowCreated: {:p} -- {:p}\n", activity, window);
+        try_with_waitable_activity_ref(activity, |waitable_activity| {
+            // Use clone_from_ptr to acquire additional ownership on the NativeWindow,
+            // which will unconditionally be _release()'d on Drop.
+            let window = NativeWindow::clone_from_ptr(NonNull::new_unchecked(window));
+            waitable_activity.set_window(Some(window));
+        });
+    })
+}
+
+unsafe extern "C" fn on_native_window_resized(
+    activity: *mut ndk_sys::ANativeActivity,
+    window: *mut ndk_sys::ANativeWindow,
+) {
+    log::debug!("NativeWindowResized: {:p} -- {:p}\n", activity, window);
     try_with_waitable_activity_ref(activity, |waitable_activity| {
-        // It's important that we use ::clone_from_ptr() here because NativeWindow
-        // has a Drop implementation that will unconditionally _release() the native window
-        let window = NativeWindow::clone_from_ptr(NonNull::new_unchecked(window));
-        waitable_activity.set_window(Some(window));
+        waitable_activity.notify_window_resized(window);
+    });
+}
+
+unsafe extern "C" fn on_native_window_redraw_needed(
+    activity: *mut ndk_sys::ANativeActivity,
+    window: *mut ndk_sys::ANativeWindow,
+) {
+    log::debug!("NativeWindowRedrawNeeded: {:p} -- {:p}\n", activity, window);
+    try_with_waitable_activity_ref(activity, |waitable_activity| {
+        waitable_activity.notify_window_redraw_needed(window)
     });
 }
 
@@ -705,125 +764,155 @@ unsafe extern "C" fn on_native_window_destroyed(
     activity: *mut ndk_sys::ANativeActivity,
     window: *mut ndk_sys::ANativeWindow,
 ) {
-    log::debug!("NativeWindowDestroyed: {:p} -- {:p}\n", activity, window);
-    try_with_waitable_activity_ref(activity, |waitable_activity| {
-        waitable_activity.set_window(None);
-    });
+    abort_on_panic(|| {
+        log::debug!("NativeWindowDestroyed: {:p} -- {:p}\n", activity, window);
+        try_with_waitable_activity_ref(activity, |waitable_activity| {
+            waitable_activity.set_window(None);
+        });
+    })
 }
 
 unsafe extern "C" fn on_input_queue_created(
     activity: *mut ndk_sys::ANativeActivity,
     queue: *mut ndk_sys::AInputQueue,
 ) {
-    log::debug!("InputQueueCreated: {:p} -- {:p}\n", activity, queue);
-    try_with_waitable_activity_ref(activity, |waitable_activity| {
-        waitable_activity.set_input(queue);
-    });
+    abort_on_panic(|| {
+        log::debug!("InputQueueCreated: {:p} -- {:p}\n", activity, queue);
+        try_with_waitable_activity_ref(activity, |waitable_activity| {
+            waitable_activity.set_input(queue);
+        });
+    })
 }
 
 unsafe extern "C" fn on_input_queue_destroyed(
     activity: *mut ndk_sys::ANativeActivity,
     queue: *mut ndk_sys::AInputQueue,
 ) {
-    log::debug!("InputQueueDestroyed: {:p} -- {:p}\n", activity, queue);
+    abort_on_panic(|| {
+        log::debug!("InputQueueDestroyed: {:p} -- {:p}\n", activity, queue);
+        try_with_waitable_activity_ref(activity, |waitable_activity| {
+            waitable_activity.set_input(ptr::null_mut());
+        });
+    })
+}
+
+unsafe extern "C" fn on_content_rect_changed(
+    activity: *mut ndk_sys::ANativeActivity,
+    rect: *const ndk_sys::ARect,
+) {
+    log::debug!("ContentRectChanged: {:p} -- {:p}\n", activity, rect);
     try_with_waitable_activity_ref(activity, |waitable_activity| {
-        waitable_activity.set_input(ptr::null_mut());
+        waitable_activity.set_content_rect(rect)
     });
 }
 
 /// This is the native entrypoint for our cdylib library that `ANativeActivity` will look for via `dlsym`
 #[no_mangle]
+#[allow(unused_unsafe)] // Otherwise rust 1.64 moans about using unsafe{} in unsafe functions
 extern "C" fn ANativeActivity_onCreate(
     activity: *mut ndk_sys::ANativeActivity,
     saved_state: *const libc::c_void,
     saved_state_size: libc::size_t,
 ) {
-    // Maybe make this stdout/stderr redirection an optional / opt-in feature?...
-    unsafe {
-        let mut logpipe: [RawFd; 2] = Default::default();
-        libc::pipe(logpipe.as_mut_ptr());
-        libc::dup2(logpipe[1], libc::STDOUT_FILENO);
-        libc::dup2(logpipe[1], libc::STDERR_FILENO);
-        std::thread::spawn(move || {
-            let tag = CStr::from_bytes_with_nul(b"RustStdoutStderr\0").unwrap();
-            let file = File::from_raw_fd(logpipe[0]);
-            let mut reader = BufReader::new(file);
-            let mut buffer = String::new();
-            loop {
-                buffer.clear();
-                if let Ok(len) = reader.read_line(&mut buffer) {
-                    if len == 0 {
-                        break;
-                    } else if let Ok(msg) = CString::new(buffer.clone()) {
-                        android_log(Level::Info, tag, &msg);
+    abort_on_panic(|| {
+        // Maybe make this stdout/stderr redirection an optional / opt-in feature?...
+        unsafe {
+            let mut logpipe: [RawFd; 2] = Default::default();
+            libc::pipe(logpipe.as_mut_ptr());
+            libc::dup2(logpipe[1], libc::STDOUT_FILENO);
+            libc::dup2(logpipe[1], libc::STDERR_FILENO);
+            std::thread::spawn(move || {
+                let tag = CStr::from_bytes_with_nul(b"RustStdoutStderr\0").unwrap();
+                let file = File::from_raw_fd(logpipe[0]);
+                let mut reader = BufReader::new(file);
+                let mut buffer = String::new();
+                loop {
+                    buffer.clear();
+                    if let Ok(len) = reader.read_line(&mut buffer) {
+                        if len == 0 {
+                            break;
+                        } else if let Ok(msg) = CString::new(buffer.clone()) {
+                            android_log(Level::Info, tag, &msg);
+                        }
                     }
                 }
+            });
+        }
+
+        log::trace!(
+            "Creating: {:p}, saved_state = {:p}, save_state_size = {}",
+            activity,
+            saved_state,
+            saved_state_size
+        );
+
+        // Conceptually we associate a glue reference with the JVM main thread, and another
+        // reference with the Rust main thread
+        let jvm_glue = NativeActivityGlue::new(activity, saved_state, saved_state_size);
+
+        let rust_glue = jvm_glue.clone();
+        // Let us Send the NativeActivity pointer to the Rust main() thread without a wrapper type
+        let activity_ptr: libc::intptr_t = activity as _;
+
+        // Note: we drop the thread handle which will detach the thread
+        std::thread::spawn(move || {
+            let activity: *mut ndk_sys::ANativeActivity = activity_ptr as *mut _;
+
+            let jvm = unsafe {
+                let na = activity;
+                let jvm = (*na).vm;
+                let activity = (*na).clazz; // Completely bogus name; this is the _instance_ not class pointer
+                ndk_context::initialize_android_context(jvm.cast(), activity.cast());
+
+                // Since this is a newly spawned thread then the JVM hasn't been attached
+                // to the thread yet. Attach before calling the applications main function
+                // so they can safely make JNI calls
+                let mut jenv_out: *mut core::ffi::c_void = std::ptr::null_mut();
+                if let Some(attach_current_thread) = (*(*jvm)).AttachCurrentThread {
+                    attach_current_thread(jvm, &mut jenv_out, std::ptr::null_mut());
+                }
+
+                jvm
+            };
+
+            let app = AndroidApp::new(rust_glue.clone());
+
+            rust_glue.notify_main_thread_running();
+
+            unsafe {
+                // We want to specifically catch any panic from the application's android_main
+                // so we can finish + destroy the Activity gracefully via the JVM
+                catch_unwind(|| {
+                    // XXX: If we were in control of the Java Activity subclass then
+                    // we could potentially run the android_main function via a Java native method
+                    // springboard (e.g. call an Activity subclass method that calls a jni native
+                    // method that then just calls android_main()) that would make sure there was
+                    // a Java frame at the base of our call stack which would then be recognised
+                    // when calling FindClass to lookup a suitable classLoader, instead of
+                    // defaulting to the system loader. Without this then it's difficult for native
+                    // code to look up non-standard Java classes.
+                    android_main(app);
+                })
+                .unwrap_or_else(|panic| log_panic(panic));
+
+                // Let JVM know that our Activity can be destroyed before detaching from the JVM
+                //
+                // "Note that this method can be called from any thread; it will send a message
+                //  to the main thread of the process where the Java finish call will take place"
+                ndk_sys::ANativeActivity_finish(activity);
+
+                if let Some(detach_current_thread) = (*(*jvm)).DetachCurrentThread {
+                    detach_current_thread(jvm);
+                }
+
+                ndk_context::release_android_context();
             }
         });
-    }
 
-    log::trace!(
-        "Creating: {:p}, saved_state = {:p}, save_state_size = {}",
-        activity,
-        saved_state,
-        saved_state_size
-    );
-
-    // Conceptually we associate a glue reference with the JVM main thread, and another
-    // reference with the Rust main thread
-    let jvm_glue = NativeActivityGlue::new(activity, saved_state, saved_state_size);
-
-    let rust_glue = jvm_glue.clone();
-    // Let us Send the NativeActivity pointer to the Rust main() thread without a wrapper type
-    let activity_ptr: libc::intptr_t = activity as _;
-
-    // Note: we drop the thread handle which will detach the thread
-    std::thread::spawn(move || {
-        let activity: *mut ANativeActivity = activity_ptr as *mut _;
-
-        let jvm = unsafe {
-            let na = activity;
-            let jvm = (*na).vm;
-            let activity = (*na).clazz; // Completely bogus name; this is the _instance_ not class pointer
-            ndk_context::initialize_android_context(jvm.cast(), activity.cast());
-
-            // Since this is a newly spawned thread then the JVM hasn't been attached
-            // to the thread yet. Attach before calling the applications main function
-            // so they can safely make JNI calls
-            let mut jenv_out: *mut core::ffi::c_void = std::ptr::null_mut();
-            if let Some(attach_current_thread) = (*(*jvm)).AttachCurrentThread {
-                attach_current_thread(jvm, &mut jenv_out, std::ptr::null_mut());
-            }
-
-            jvm
-        };
-
-        let app = AndroidApp::new(rust_glue.clone());
-
-        rust_glue.notify_main_thread_running();
-
-        unsafe {
-            // XXX: If we were in control of the Java Activity subclass then
-            // we could potentially run the android_main function via a Java native method
-            // springboard (e.g. call an Activity subclass method that calls a jni native
-            // method that then just calls android_main()) that would make sure there was
-            // a Java frame at the base of our call stack which would then be recognised
-            // when calling FindClass to lookup a suitable classLoader, instead of
-            // defaulting to the system loader. Without this then it's difficult for native
-            // code to look up non-standard Java classes.
-            android_main(app);
-
-            if let Some(detach_current_thread) = (*(*jvm)).DetachCurrentThread {
-                detach_current_thread(jvm);
-            }
-
-            ndk_context::release_android_context();
+        // Wait for thread to start.
+        let mut guard = jvm_glue.mutex.lock().unwrap();
+        while !guard.running {
+            guard = jvm_glue.cond.wait(guard).unwrap();
         }
-    });
-
-    // Wait for thread to start.
-    let mut guard = jvm_glue.mutex.lock().unwrap();
-    while !guard.running {
-        guard = jvm_glue.cond.wait(guard).unwrap();
-    }
+    })
 }

android-activity/src/native_activity/mod.rs

@@ -7,12 +7,7 @@ use std::time::Duration;
 
 use libc::c_void;
 use log::{error, trace};
-
-use ndk_sys::ALooper_wake;
-use ndk_sys::{ALooper, ALooper_pollAll};
-
-use ndk::asset::AssetManager;
-use ndk::native_window::NativeWindow;
+use ndk::{asset::AssetManager, native_window::NativeWindow};
 
 use crate::{
     util, AndroidApp, ConfigurationRef, InputStatus, MainEvent, PollEvent, Rect, WindowManagerFlags,
@@ -63,7 +58,7 @@ pub struct AndroidAppWaker {
     // The looper pointer is owned by the android_app and effectively
     // has a 'static lifetime, and the ALooper_wake C API is thread
     // safe, so this can be cloned safely and is send + sync safe
-    looper: NonNull<ALooper>,
+    looper: NonNull<ndk_sys::ALooper>,
 }
 unsafe impl Send for AndroidAppWaker {}
 unsafe impl Sync for AndroidAppWaker {}
@@ -77,7 +72,7 @@ impl AndroidAppWaker {
     /// [wake_event]: crate::PollEvent::Wake
     pub fn wake(&self) {
         unsafe {
-            ALooper_wake(self.looper.as_ptr());
+            ndk_sys::ALooper_wake(self.looper.as_ptr());
         }
     }
 }
@@ -119,7 +114,7 @@ impl AndroidApp {
 
 #[derive(Debug)]
 struct Looper {
-    pub ptr: *mut ALooper,
+    pub ptr: *mut ndk_sys::ALooper,
 }
 unsafe impl Send for Looper {}
 unsafe impl Sync for Looper {}
@@ -174,7 +169,7 @@ impl AndroidAppInner {
                 !ndk_sys::ALooper_forThread().is_null(),
                 "Application tried to poll events from non-main thread"
             );
-            let id = ALooper_pollAll(
+            let id = ndk_sys::ALooper_pollAll(
                 timeout_milliseconds,
                 &mut fd,
                 &mut events,

android-activity/src/util.rs

@@ -1,4 +1,8 @@
-use std::{ffi::CStr, os::raw::c_char};
+use log::Level;
+use std::{
+    ffi::{CStr, CString},
+    os::raw::c_char,
+};
 
 pub fn try_get_path_from_ptr(path: *const c_char) -> Option<std::path::PathBuf> {
     if path.is_null() {
@@ -13,3 +17,54 @@ pub fn try_get_path_from_ptr(path: *const c_char) -> Option<std::path::PathBuf>
     }
     Some(std::path::PathBuf::from(cstr))
 }
+
+pub(crate) fn android_log(level: Level, tag: &CStr, msg: &CStr) {
+    let prio = match level {
+        Level::Error => ndk_sys::android_LogPriority::ANDROID_LOG_ERROR,
+        Level::Warn => ndk_sys::android_LogPriority::ANDROID_LOG_WARN,
+        Level::Info => ndk_sys::android_LogPriority::ANDROID_LOG_INFO,
+        Level::Debug => ndk_sys::android_LogPriority::ANDROID_LOG_DEBUG,
+        Level::Trace => ndk_sys::android_LogPriority::ANDROID_LOG_VERBOSE,
+    };
+    unsafe {
+        ndk_sys::__android_log_write(prio.0 as libc::c_int, tag.as_ptr(), msg.as_ptr());
+    }
+}
+
+pub(crate) fn log_panic(panic: Box<dyn std::any::Any + Send>) {
+    let rust_panic = unsafe { CStr::from_bytes_with_nul_unchecked(b"RustPanic\0") };
+
+    if let Some(panic) = panic.downcast_ref::<String>() {
+        if let Ok(msg) = CString::new(panic.clone()) {
+            android_log(Level::Error, rust_panic, &msg);
+        }
+    } else if let Ok(panic) = panic.downcast::<&str>() {
+        if let Ok(msg) = CString::new(*panic) {
+            android_log(Level::Error, rust_panic, &msg);
+        }
+    } else {
+        let unknown_panic = unsafe { CStr::from_bytes_with_nul_unchecked(b"UnknownPanic\0") };
+        android_log(Level::Error, unknown_panic, unsafe {
+            CStr::from_bytes_with_nul_unchecked(b"\0")
+        });
+    }
+}
+
+/// Run a closure and abort the program if it panics.
+///
+/// This is generally used to ensure Rust callbacks won't unwind past the JNI boundary, which leads
+/// to undefined behaviour.
+///
+/// TODO(rib): throw a Java exception instead of aborting. An Android Activity does not necessarily
+/// own the entire process because other application Services (or even Activities) may run in
+/// threads within the same process, and so we're tearing down too much by aborting the process.
+pub(crate) fn abort_on_panic<R>(f: impl FnOnce() -> R) -> R {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)).unwrap_or_else(|panic| {
+        // Try logging the panic before aborting
+        //
+        // Just in case our attempt to log a panic could itself cause a panic we use a
+        // second catch_unwind here.
+        let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| log_panic(panic)));
+        std::process::abort();
+    })
+}

examples/agdk-mainloop/Cargo.toml

@@ -9,6 +9,8 @@ edition = "2021"
 log = "0.4"
 android_logger = "0.11.0"
 android-activity = { path="../../android-activity", features = ["game-activity"] }
+ndk-sys = "0.4"
+ndk = "0.7"
 
 [lib]
 name="main"

examples/agdk-mainloop/app/build.gradle

@@ -3,6 +3,7 @@ plugins {
 }
 
 android {
+    ndkVersion "25.2.9519653"
     compileSdk 31
 
     defaultConfig {
@@ -32,6 +33,7 @@ android {
         sourceCompatibility JavaVersion.VERSION_1_8
         targetCompatibility JavaVersion.VERSION_1_8
     }
+    namespace 'co.realfit.agdkmainloop'
 }
 
 dependencies {

examples/agdk-mainloop/app/src/main/AndroidManifest.xml

@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="co.realfit.agdkmainloop">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <application
         android:allowBackup="true"

examples/agdk-mainloop/build.gradle

@@ -1,7 +1,7 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
-    id 'com.android.application' version '7.1.2' apply false
-    id 'com.android.library' version '7.1.2' apply false
+    id 'com.android.application' version '8.0.0' apply false
+    id 'com.android.library' version '8.0.0' apply false
 }
 
 task clean(type: Delete) {

examples/agdk-mainloop/gradle.properties

@@ -18,4 +18,6 @@ android.useAndroidX=true
 # Enables namespacing of each library's R class so that its R class includes only the
 # resources declared in the library itself and none from the library's dependencies,
 # thereby reducing the size of the R class for that library
-android.nonTransitiveRClass=true
+android.nonTransitiveRClass=true
+android.defaults.buildfeatures.buildconfig=true
+android.nonFinalResIds=false

examples/agdk-mainloop/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 #Mon May 02 15:39:12 BST 2022
 distributionBase=GRADLE_USER_HOME
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-bin.zip
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME

examples/agdk-mainloop/src/lib.rs

@@ -7,7 +7,7 @@ fn android_main(app: AndroidApp) {
 
     let mut quit = false;
     let mut redraw_pending = true;
-    let mut render_state: Option<()> = Default::default();
+    let mut native_window: Option<ndk::native_window::NativeWindow> = None;
 
     while !quit {
         app.poll_events(
@@ -37,11 +37,11 @@ fn android_main(app: AndroidApp) {
                                 }
                             }
                             MainEvent::InitWindow { .. } => {
-                                render_state = Some(());
+                                native_window = app.native_window();
                                 redraw_pending = true;
                             }
                             MainEvent::TerminateWindow { .. } => {
-                                render_state = None;
+                                native_window = None;
                             }
                             MainEvent::WindowResized { .. } => {
                                 redraw_pending = true;
@@ -65,7 +65,7 @@ fn android_main(app: AndroidApp) {
                 }
 
                 if redraw_pending {
-                    if let Some(_rs) = render_state {
+                    if let Some(native_window) = &native_window {
                         redraw_pending = false;
 
                         // Handle input
@@ -75,9 +75,32 @@ fn android_main(app: AndroidApp) {
                         });
 
                         info!("Render...");
+                        dummy_render(native_window);
                     }
                 }
             },
         );
     }
 }
+
+/// Post a NOP frame to the window
+///
+/// Since this is a bare minimum test app we don't depend
+/// on any GPU graphics APIs but we do need to at least
+/// convince Android that we're drawing something and are
+/// responsive, otherwise it will stop delivering input
+/// events to us.
+fn dummy_render(native_window: &ndk::native_window::NativeWindow) {
+    unsafe {
+        let mut buf: ndk_sys::ANativeWindow_Buffer = std::mem::zeroed();
+        let mut rect: ndk_sys::ARect = std::mem::zeroed();
+        ndk_sys::ANativeWindow_lock(
+            native_window.ptr().as_ptr() as _,
+            &mut buf as _,
+            &mut rect as _,
+        );
+        // Note: we don't try and touch the buffer since that
+        // also requires us to handle various buffer formats
+        ndk_sys::ANativeWindow_unlockAndPost(native_window.ptr().as_ptr() as _);
+    }
+}

examples/na-mainloop/Cargo.toml

@@ -9,6 +9,8 @@ edition = "2021"
 log = "0.4"
 android_logger = "0.11.0"
 android-activity = { path="../../android-activity", features = [ "native-activity" ] }
+ndk-sys = "0.4"
+ndk = "0.7"
 
 [lib]
 #name="na_mainloop"

examples/na-mainloop/app/build.gradle

@@ -3,6 +3,7 @@ plugins {
 }
 
 android {
+    ndkVersion "25.2.9519653"
     compileSdk 31
 
     defaultConfig {
@@ -32,6 +33,7 @@ android {
         sourceCompatibility JavaVersion.VERSION_1_8
         targetCompatibility JavaVersion.VERSION_1_8
     }
+    namespace 'co.realfit.namainloop'
 }
 
 dependencies {

examples/na-mainloop/app/src/main/AndroidManifest.xml

@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="co.realfit.namainloop">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <application
         android:allowBackup="true"

examples/na-mainloop/build.gradle

@@ -1,7 +1,7 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
-    id 'com.android.application' version '7.1.2' apply false
-    id 'com.android.library' version '7.1.2' apply false
+    id 'com.android.application' version '8.0.0' apply false
+    id 'com.android.library' version '8.0.0' apply false
 }
 
 task clean(type: Delete) {

examples/na-mainloop/gradle.properties

@@ -18,4 +18,6 @@ android.useAndroidX=true
 # Enables namespacing of each library's R class so that its R class includes only the
 # resources declared in the library itself and none from the library's dependencies,
 # thereby reducing the size of the R class for that library
-android.nonTransitiveRClass=true
+android.nonTransitiveRClass=true
+android.defaults.buildfeatures.buildconfig=true
+android.nonFinalResIds=false

examples/na-mainloop/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 #Mon May 02 15:39:12 BST 2022
 distributionBase=GRADLE_USER_HOME
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-bin.zip
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME

examples/na-mainloop/src/lib.rs

@@ -7,7 +7,7 @@ fn android_main(app: AndroidApp) {
 
     let mut quit = false;
     let mut redraw_pending = true;
-    let mut render_state: Option<()> = Default::default();
+    let mut native_window: Option<ndk::native_window::NativeWindow> = None;
 
     while !quit {
         app.poll_events(
@@ -37,11 +37,11 @@ fn android_main(app: AndroidApp) {
                                 }
                             }
                             MainEvent::InitWindow { .. } => {
-                                render_state = Some(());
+                                native_window = app.native_window();
                                 redraw_pending = true;
                             }
                             MainEvent::TerminateWindow { .. } => {
-                                render_state = None;
+                                native_window = None;
                             }
                             MainEvent::WindowResized { .. } => {
                                 redraw_pending = true;
@@ -65,7 +65,7 @@ fn android_main(app: AndroidApp) {
                 }
 
                 if redraw_pending {
-                    if let Some(_rs) = render_state {
+                    if let Some(native_window) = &native_window {
                         redraw_pending = false;
 
                         // Handle input
@@ -75,9 +75,32 @@ fn android_main(app: AndroidApp) {
                         });
 
                         info!("Render...");
+                        dummy_render(native_window);
                     }
                 }
             },
         );
     }
 }
+
+/// Post a NOP frame to the window
+///
+/// Since this is a bare minimum test app we don't depend
+/// on any GPU graphics APIs but we do need to at least
+/// convince Android that we're drawing something and are
+/// responsive, otherwise it will stop delivering input
+/// events to us.
+fn dummy_render(native_window: &ndk::native_window::NativeWindow) {
+    unsafe {
+        let mut buf: ndk_sys::ANativeWindow_Buffer = std::mem::zeroed();
+        let mut rect: ndk_sys::ARect = std::mem::zeroed();
+        ndk_sys::ANativeWindow_lock(
+            native_window.ptr().as_ptr() as _,
+            &mut buf as _,
+            &mut rect as _,
+        );
+        // Note: we don't try and touch the buffer since that
+        // also requires us to handle various buffer formats
+        ndk_sys::ANativeWindow_unlockAndPost(native_window.ptr().as_ptr() as _);
+    }
+}