Merge pull request #90 from rust-mobile/release-0.4.2

Release 0.4.2
2026-07-05 06:17:27 +00:00 · 2023-06-27 17:39:52 +01:00 · 2023-06-27 17:19:52 +01:00 · 2023-06-26 00:08:48 +01:00 · 2023-06-26 00:08:42 +01:00 · 2023-06-25 21:38:48 +01:00
389 changed files with 611 additions and 24937 deletions
@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: cargo
+    directory: /
+    schedule:
+      interval: weekly
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
@@ -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
@@ -89,28 +89,6 @@ jobs:
          -t x86
          -o app/src/main/jniLibs/ -- build

-      - name: Build agdk-egui example
-        if: matrix.rust_version == 'stable'
-        working-directory: examples/agdk-egui
-        run: >
-          cargo ndk
-          -t arm64-v8a
-          -t armeabi-v7a
-          -t x86_64
-          -t x86
-          -o app/src/main/jniLibs/ -- build
-
-      - name: Build agdk-eframe example
-        if: matrix.rust_version == 'stable'
-        working-directory: examples/agdk-eframe
-        run: >
-          cargo ndk
-          -t arm64-v8a
-          -t armeabi-v7a
-          -t x86_64
-          -t x86
-          -o app/src/main/jniLibs/ -- build
-
      - name: Documentation
        run: >
          cargo ndk -t arm64-v8a doc --no-deps
@@ -118,7 +96,7 @@ jobs:
  format:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3

      - uses: actions-rs/toolchain@v1
        with:
@@ -131,6 +109,10 @@ jobs:
        run: cargo fmt --all -- --check
        working-directory: android-activity

-      - name: Format agdk-egui example
+      - name: Format na-mainloop example
        run: cargo fmt --all -- --check
-        working-directory: examples/agdk-egui
+        working-directory: examples/na-mainloop
+
+      - name: Format agdk-mainloop example
+        run: cargo fmt --all -- --check
+        working-directory: examples/agdk-mainloop
@@ -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,22 +78,22 @@ 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/rib/android-activity/tree/main/examples) (based on both `GameActivity` and `NativeActivity`).
+See [this collection of examples](https://github.com/rust-mobile/rust-android-examples) (based on both `GameActivity` and `NativeActivity`).

 Each example is a standalone project that may also be a convenient templates for starting a new project.

 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/rib/android-activity/tree/main/examples).
+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]
@@ -129,12 +139,11 @@ fn android_main(app: AndroidApp) {
 }
 ```

-See this minimal [NativeActivity Mainloop](https://github.com/rib/android-activity/tree/main/examples/na-mainloop) for more details about how to poll for events.
+See this minimal [NativeActivity Mainloop](https://github.com/rust-mobile/android-activity/tree/main/examples/na-mainloop) for more details about how to poll for events.

 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.
@@ -4,12 +4,29 @@ 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))
+- Added `AndroidApp::activity_as_ptr()` to expose Android `Activity` JNI reference as pointer ([#60](https://github.com/rust-mobile/android-activity/issues/60))
+### Changed
+- Removed some overly-verbose logging in the `native-activity` backend ([#49](https://github.com/rust-mobile/android-activity/pull/49))
+### Removed
+- Most of the examples were moved to https://github.com/rust-mobile/rust-android-examples ([#50](https://github.com/rust-mobile/android-activity/pull/50))
+
 ## [0.4] - 2022-11-10
 ### Changed
- *Breaking*: `input_events` callback now return whether an event was handled or not to allow for fallback handling ([#31](https://github.com/rib/android-activity/issues/31))
- The native-activity backend is now implemented in Rust only, without building on `android_native_app_glue.c` ([#35](https://github.com/rib/android-activity/pull/35))
+- *Breaking*: `input_events` callback now return whether an event was handled or not to allow for fallback handling ([#31](https://github.com/rust-mobile/android-activity/issues/31))
+- The native-activity backend is now implemented in Rust only, without building on `android_native_app_glue.c` ([#35](https://github.com/rust-mobile/android-activity/pull/35))
 ### Added
- Added `Pointer::tool_type()` API to `GameActivity` backend for compatibility with `ndk` events API ([#38](https://github.com/rib/android-activity/pull/38))
+- Added `Pointer::tool_type()` API to `GameActivity` backend for compatibility with `ndk` events API ([#38](https://github.com/rust-mobile/android-activity/pull/38))

 ## [0.3] - 2022-09-15
 ### Added
@@ -1,14 +1,15 @@
 [package]
 name = "android-activity"
-version = "0.4.0"
+version = "0.4.2"
 edition = "2021"
 keywords = ["android", "ndk"]
 readme = "../README.md"
-homepage = "https://github.com/rib/android-activity"
-repository = "https://github.com/rib/android-activity"
+homepage = "https://github.com/rust-mobile/android-activity"
+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"]
@@ -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
@@ -5,13 +5,14 @@ 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;
 use std::{ptr, thread};

+use libc::c_void;
 use log::{error, trace, Level};

 use jni_sys::*;
@@ -23,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,
 };
@@ -155,6 +157,16 @@ pub struct AndroidAppInner {
 }

 impl AndroidAppInner {
+    pub fn vm_as_ptr(&self) -> *mut c_void {
+        let app_ptr = self.native_app.as_ptr();
+        unsafe { (*(*app_ptr).activity).vm as _ }
+    }
+
+    pub fn activity_as_ptr(&self) -> *mut c_void {
+        let app_ptr = self.native_app.as_ptr();
+        unsafe { (*(*app_ptr).activity).javaGameActivity as _ }
+    }
+
    pub fn native_window(&self) -> Option<NativeWindow> {
        self.native_window.read().unwrap().clone()
    }
@@ -584,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);
 }
@@ -605,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();
+    })
 }
@@ -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,
@@ -62,6 +62,7 @@ use std::sync::Arc;
 use std::sync::RwLock;
 use std::time::Duration;

+use libc::c_void;
 use ndk::asset::AssetManager;
 use ndk::native_window::NativeWindow;

@@ -72,14 +73,14 @@ compile_error!("android-activity only supports compiling for Android");

 #[cfg(all(feature = "game-activity", feature = "native-activity"))]
 compile_error!(
-    "The \"game-activity\" and \"native-activity\" features cannot be enabled at the same time"
+    r#"The "game-activity" and "native-activity" features cannot be enabled at the same time"#
 );
 #[cfg(all(
    not(any(feature = "game-activity", feature = "native-activity")),
    not(doc)
 ))]
 compile_error!(
-    r#"Either \"game-activity\" or \"native-activity\" must be enabled as features
+    r#"Either "game-activity" or "native-activity" must be enabled as features

 If you have set one of these features then this error indicates that Cargo is trying to
 link together multiple implementations of android-activity (with incompatible versions)
@@ -92,8 +93,7 @@ You can use `cargo tree` (e.g. via `cargo ndk -t arm64-v8a tree`) to identify wh
 versions have been resolved.

 You may need to add a `[patch]` into your Cargo.toml to ensure a specific version of
-android-activity is used across all of your application's crates.
-"#
+android-activity is used across all of your application's crates."#
 );

 #[cfg(any(feature = "native-activity", doc))]
@@ -473,6 +473,49 @@ impl AndroidApp {
        self.inner.read().unwrap().native_window()
    }

+    /// Returns a pointer to the Java Virtual Machine, for making JNI calls
+    ///
+    /// This returns a pointer to the Java Virtual Machine which can be used
+    /// with the [`jni`] crate (or similar crates) to make JNI calls that bridge
+    /// between native Rust code and Java/Kotlin code running within the JVM.
+    ///
+    /// If you use the [`jni`] crate you can wrap this as a [`JavaVM`] via:
+    /// ```ignore
+    /// # use jni::JavaVM;
+    /// # let app: AndroidApp = todo!();
+    /// let vm = unsafe { JavaVM::from_raw(app.vm_as_ptr()) };
+    /// ```
+    ///
+    /// [`jni`]: https://crates.io/crates/jni
+    /// [`JavaVM`]: https://docs.rs/jni/latest/jni/struct.JavaVM.html
+    pub fn vm_as_ptr(&self) -> *mut c_void {
+        self.inner.read().unwrap().vm_as_ptr()
+    }
+
+    /// Returns a JNI object reference for this application's JVM `Activity` as a pointer
+    ///
+    /// If you use the [`jni`] crate you can wrap this as an object reference via:
+    /// ```ignore
+    /// # use jni::objects::JObject;
+    /// # let app: AndroidApp = todo!();
+    /// let activity = unsafe { JObject::from_raw(app.activity_as_ptr()) };
+    /// ```
+    ///
+    /// # JNI Safety
+    ///
+    /// Note that the object reference will be a JNI global reference, not a
+    /// local reference and it should not be deleted. Don't wrap the reference
+    /// in an [`AutoLocal`] which would try to explicitly delete the reference
+    /// when dropped. Similarly, don't wrap the reference as a [`GlobalRef`]
+    /// which would also try to explicitly delete the reference when dropped.
+    ///
+    /// [`jni`]: https://crates.io/crates/jni
+    /// [`AutoLocal`]: https://docs.rs/jni/latest/jni/objects/struct.AutoLocal.html
+    /// [`GlobalRef`]: https://docs.rs/jni/latest/jni/objects/struct.GlobalRef.html
+    pub fn activity_as_ptr(&self) -> *mut c_void {
+        self.inner.read().unwrap().activity_as_ptr()
+    }
+
    /// Polls for any events associated with this [AndroidApp] and processes those events
    /// (such as lifecycle events) via the given `callback`.
    ///
@@ -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 {
@@ -333,7 +340,7 @@ impl WaitableNativeActivityState {
            let config = super::ConfigurationRef::new(Configuration::from_ptr(
                NonNull::new_unchecked(config),
            ));
-            eprintln!("Config: {:#?}", config);
+            log::trace!("Config: {:#?}", config);
            config
        };

@@ -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,123 +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();
            }
        });
-    }

-    eprintln!(
-        "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();
-    }
+    })
 }
@@ -5,13 +5,9 @@ use std::ptr::NonNull;
 use std::sync::{Arc, RwLock};
 use std::time::Duration;

-use log::{error, info, trace};
-
-use ndk_sys::ALooper_wake;
-use ndk_sys::{ALooper, ALooper_pollAll};
-
-use ndk::asset::AssetManager;
-use ndk::native_window::NativeWindow;
+use libc::c_void;
+use log::{error, trace};
+use ndk::{asset::AssetManager, native_window::NativeWindow};

 use crate::{
    util, AndroidApp, ConfigurationRef, InputStatus, MainEvent, PollEvent, Rect, WindowManagerFlags,
@@ -62,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 {}
@@ -76,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());
        }
    }
 }
@@ -118,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 {}
@@ -130,6 +126,15 @@ pub(crate) struct AndroidAppInner {
 }

 impl AndroidAppInner {
+    pub(crate) fn vm_as_ptr(&self) -> *mut c_void {
+        unsafe { (*self.native_activity.activity).vm as _ }
+    }
+
+    pub(crate) fn activity_as_ptr(&self) -> *mut c_void {
+        // "clazz" is a completely bogus name; this is the _instance_ not class pointer
+        unsafe { (*self.native_activity.activity).clazz as _ }
+    }
+
    pub(crate) fn native_activity(&self) -> *const ndk_sys::ANativeActivity {
        self.native_activity.activity
    }
@@ -159,18 +164,18 @@ impl AndroidAppInner {
                -1
            };

-            info!("Calling ALooper_pollAll, timeout = {timeout_milliseconds}");
+            trace!("Calling ALooper_pollAll, timeout = {timeout_milliseconds}");
            assert!(
                !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,
                &mut source as *mut *mut core::ffi::c_void,
            );
-            info!("pollAll id = {id}");
+            trace!("pollAll id = {id}");
            match id {
                ndk_sys::ALOOPER_POLL_WAKE => {
                    trace!("ALooper_pollAll returned POLL_WAKE");
@@ -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();
+    })
+}
@@ -1,20 +0,0 @@
-*.iml
-.gradle
-/local.properties
-/.idea/caches
-/.idea/libraries
-/.idea/modules.xml
-/.idea/workspace.xml
-/.idea/navEditor.xml
-/.idea/assetWizardSettings.xml
-.DS_Store
-/build
-/captures
-.externalNativeBuild
-.cxx
-local.properties
-*.so
-
-# Added by cargo
-
-/target
@@ -1,3 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="11" />
-  </component>
-</project>
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GradleMigrationSettings" migrationVersion="1" />
-  <component name="GradleSettings">
-    <option name="linkedExternalProjectsSettings">
-      <GradleProjectSettings>
-        <option name="testRunner" value="GRADLE" />
-        <option name="distributionType" value="DEFAULT_WRAPPED" />
-        <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="modules">
-          <set>
-            <option value="$PROJECT_DIR$" />
-            <option value="$PROJECT_DIR$/app" />
-          </set>
-        </option>
-        <option name="resolveModulePerSourceSet" value="false" />
-      </GradleProjectSettings>
-    </option>
-  </component>
-</project>
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="Android Studio default JDK" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/build/classes" />
-  </component>
-  <component name="ProjectType">
-    <option name="id" value="Android" />
-  </component>
-</project>
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>
@@ -1,18 +0,0 @@
-[package]
-name = "agdk-cpal"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-log = "0.4"
-android_logger = "0.11.0"
-android-activity = { path="../../android-activity", features = ["game-activity"] }
-cpal = "0.14"
-atomic_float = "0.1"
-anyhow = "1"
-
-[lib]
-name="main"
-crate_type=["cdylib"]
@@ -1,16 +0,0 @@
-This is a minimal test application based on `GameActivity` that just
-runs a mainloop based on android_activity::poll_events() and plays a
-sine wave audio test using the Cpal audio library.
-
-```
-export ANDROID_NDK_HOME="path/to/ndk"
-export ANDROID_HOME="path/to/sdk"
-
-rustup target add aarch64-linux-android
-cargo install cargo-ndk
-
-cargo ndk -t arm64-v8a -o app/src/main/jniLibs/  build
-./gradlew build
-./gradlew installDebug
-adb shell am start -n co.realfit.agdkcpal/.MainActivity
-```
@@ -1 +0,0 @@
-/build
@@ -1,61 +0,0 @@
-plugins {
-    id 'com.android.application'
-}
-
-android {
-    compileSdk 31
-
-    defaultConfig {
-        applicationId "co.realfit.agdkcpal"
-        minSdk 28
-        targetSdk 31
-        versionCode 1
-        versionName "1.0"
-
-        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-    }
-
-    buildTypes {
-        release {
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
-        }
-        debug {
-            minifyEnabled false
-            //packagingOptions {
-            //    doNotStrip '**/*.so'
-            //}
-            //debuggable true
-        }
-    }
-    compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
-    }
-}
-
-dependencies {
-
-    implementation 'androidx.appcompat:appcompat:1.4.1'
-    implementation 'com.google.android.material:material:1.5.0'
-    implementation 'androidx.constraintlayout:constraintlayout:2.1.3'
-    testImplementation 'junit:junit:4.13.2'
-    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
-    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
-
-    // To use the Android Frame Pacing library
-    //implementation "androidx.games:games-frame-pacing:1.9.1"
-
-    // To use the Android Performance Tuner
-    //implementation "androidx.games:games-performance-tuner:1.5.0"
-
-    // To use the Games Activity library
-    implementation "androidx.games:games-activity:1.1.0"
-
-    // To use the Games Controller Library
-    //implementation "androidx.games:games-controller:1.1.0"
-
-    // To use the Games Text Input Library
-    //implementation "androidx.games:games-text-input:1.1.0"
-}
-
@@ -1,21 +0,0 @@
-# Add project specific ProGuard rules here.
-# You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="co.realfit.agdkcpal">
-
-    <application
-        android:allowBackup="true"
-        android:icon="@mipmap/ic_launcher"
-        android:label="AGDK Cpal"
-        android:roundIcon="@mipmap/ic_launcher_round"
-        android:supportsRtl="true"
-        android:theme="@style/Theme.RustTemplate">
-        <activity
-            android:name=".MainActivity"
-            android:configChanges="orientation|screenSize|screenLayout|keyboardHidden"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-
-            <meta-data android:name="android.app.lib_name" android:value="main" />
-        </activity>
-    </application>
-
-</manifest>
@@ -1,70 +0,0 @@
-package co.realfit.agdkcpal;
-
-import androidx.appcompat.app.AppCompatActivity;
-import androidx.core.view.WindowCompat;
-import androidx.core.view.WindowInsetsCompat;
-import androidx.core.view.WindowInsetsControllerCompat;
-
-import com.google.androidgamesdk.GameActivity;
-
-import android.os.Bundle;
-import android.content.pm.PackageManager;
-import android.os.Build.VERSION;
-import android.os.Build.VERSION_CODES;
-import android.os.Bundle;
-import android.view.View;
-import android.view.WindowManager;
-
-public class MainActivity extends GameActivity {
-
-    static {
-        // Load the STL first to workaround issues on old Android versions:
-        // "if your app targets a version of Android earlier than Android 4.3
-        // (Android API level 18),
-        // and you use libc++_shared.so, you must load the shared library before any other
-        // library that depends on it."
-        // See https://developer.android.com/ndk/guides/cpp-support#shared_runtimes
-        //System.loadLibrary("c++_shared");
-
-        // Load the native library.
-        // The name "android-game" depends on your CMake configuration, must be
-        // consistent here and inside AndroidManifect.xml
-        System.loadLibrary("main");
-    }
-
-    private void hideSystemUI() {
-        // This will put the game behind any cutouts and waterfalls on devices which have
-        // them, so the corresponding insets will be non-zero.
-        if (VERSION.SDK_INT >= VERSION_CODES.P) {
-            getWindow().getAttributes().layoutInDisplayCutoutMode
-                    = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS;
-        }
-        // From API 30 onwards, this is the recommended way to hide the system UI, rather than
-        // using View.setSystemUiVisibility.
-        View decorView = getWindow().getDecorView();
-        WindowInsetsControllerCompat controller = new WindowInsetsControllerCompat(getWindow(),
-                decorView);
-        controller.hide(WindowInsetsCompat.Type.systemBars());
-        controller.hide(WindowInsetsCompat.Type.displayCutout());
-        controller.setSystemBarsBehavior(
-                WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE);
-    }
-
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        // When true, the app will fit inside any system UI windows.
-        // When false, we render behind any system UI windows.
-        WindowCompat.setDecorFitsSystemWindows(getWindow(), false);
-        hideSystemUI();
-        // You can set IME fields here or in native code using GameActivity_setImeEditorInfoFields.
-        // We set the fields in native_engine.cpp.
-        // super.setImeEditorInfoFields(InputType.TYPE_CLASS_TEXT,
-        //     IME_ACTION_NONE, IME_FLAG_NO_FULLSCREEN );
-        super.onCreate(savedInstanceState);
-    }
-
-    public boolean isGooglePlayGames() {
-        PackageManager pm = getPackageManager();
-        return pm.hasSystemFeature("com.google.android.play.feature.HPE_EXPERIENCE");
-    }
-}
@@ -1,30 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:aapt="http://schemas.android.com/aapt"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path android:pathData="M31,63.928c0,0 6.4,-11 12.1,-13.1c7.2,-2.6 26,-1.4 26,-1.4l38.1,38.1L107,108.928l-32,-1L31,63.928z">
-        <aapt:attr name="android:fillColor">
-            <gradient
-                android:endX="85.84757"
-                android:endY="92.4963"
-                android:startX="42.9492"
-                android:startY="49.59793"
-                android:type="linear">
-                <item
-                    android:color="#44000000"
-                    android:offset="0.0" />
-                <item
-                    android:color="#00000000"
-                    android:offset="1.0" />
-            </gradient>
-        </aapt:attr>
-    </path>
-    <path
-        android:fillColor="#FFFFFF"
-        android:fillType="nonZero"
-        android:pathData="M65.3,45.828l3.8,-6.6c0.2,-0.4 0.1,-0.9 -0.3,-1.1c-0.4,-0.2 -0.9,-0.1 -1.1,0.3l-3.9,6.7c-6.3,-2.8 -13.4,-2.8 -19.7,0l-3.9,-6.7c-0.2,-0.4 -0.7,-0.5 -1.1,-0.3C38.8,38.328 38.7,38.828 38.9,39.228l3.8,6.6C36.2,49.428 31.7,56.028 31,63.928h46C76.3,56.028 71.8,49.428 65.3,45.828zM43.4,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2c-0.3,-0.7 -0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C45.3,56.528 44.5,57.328 43.4,57.328L43.4,57.328zM64.6,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2s-0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C66.5,56.528 65.6,57.328 64.6,57.328L64.6,57.328z"
-        android:strokeWidth="1"
-        android:strokeColor="#00000000" />
-</vector>
@@ -1,170 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path
-        android:fillColor="#3DDC84"
-        android:pathData="M0,0h108v108h-108z" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M9,0L9,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,0L19,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M29,0L29,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M39,0L39,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M49,0L49,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M59,0L59,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M69,0L69,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M79,0L79,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M89,0L89,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M99,0L99,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,9L108,9"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,19L108,19"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,29L108,29"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,39L108,39"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,49L108,49"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,59L108,59"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,69L108,69"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,79L108,79"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,89L108,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,99L108,99"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,29L89,29"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,39L89,39"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,49L89,49"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,59L89,59"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,69L89,69"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,79L89,79"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M29,19L29,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M39,19L39,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M49,19L49,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M59,19L59,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M69,19L69,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M79,19L79,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-</vector>
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    tools:context=".MainActivity">
-
-    <TextView
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text="Hello World!"
-        app:layout_constraintBottom_toBottomOf="parent"
-        app:layout_constraintLeft_toLeftOf="parent"
-        app:layout_constraintRight_toRightOf="parent"
-        app:layout_constraintTop_toTopOf="parent" />
-
-</androidx.constraintlayout.widget.ConstraintLayout>
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@drawable/ic_launcher_background" />
-    <foreground android:drawable="@drawable/ic_launcher_foreground" />
-</adaptive-icon>
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@drawable/ic_launcher_background" />
-    <foreground android:drawable="@drawable/ic_launcher_foreground" />
-</adaptive-icon>
@@ -1,16 +0,0 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <!-- Base application theme. -->
-    <style name="Theme.RustTemplate" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
-        <!-- Primary brand color. -->
-        <item name="colorPrimary">@color/purple_200</item>
-        <item name="colorPrimaryVariant">@color/purple_700</item>
-        <item name="colorOnPrimary">@color/black</item>
-        <!-- Secondary brand color. -->
-        <item name="colorSecondary">@color/teal_200</item>
-        <item name="colorSecondaryVariant">@color/teal_200</item>
-        <item name="colorOnSecondary">@color/black</item>
-        <!-- Status bar color. -->
-        <item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>
-        <!-- Customize your theme here. -->
-    </style>
-</resources>
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <color name="purple_200">#FFBB86FC</color>
-    <color name="purple_500">#FF6200EE</color>
-    <color name="purple_700">#FF3700B3</color>
-    <color name="teal_200">#FF03DAC5</color>
-    <color name="teal_700">#FF018786</color>
-    <color name="black">#FF000000</color>
-    <color name="white">#FFFFFFFF</color>
-</resources>
@@ -1,16 +0,0 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <!-- Base application theme. -->
-    <style name="Theme.RustTemplate" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
-        <!-- Primary brand color. -->
-        <item name="colorPrimary">@color/purple_500</item>
-        <item name="colorPrimaryVariant">@color/purple_700</item>
-        <item name="colorOnPrimary">@color/white</item>
-        <!-- Secondary brand color. -->
-        <item name="colorSecondary">@color/teal_200</item>
-        <item name="colorSecondaryVariant">@color/teal_700</item>
-        <item name="colorOnSecondary">@color/black</item>
-        <!-- Status bar color. -->
-        <item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>
-        <!-- Customize your theme here. -->
-    </style>
-</resources>
@@ -1,10 +0,0 @@
-// 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
-}
-
-task clean(type: Delete) {
-    delete rootProject.buildDir
-}
-
@@ -1,21 +0,0 @@
-# Project-wide Gradle settings.
-# IDE (e.g. Android Studio) users:
-# Gradle settings configured through the IDE *will override*
-# any settings specified in this file.
-# For more details on how to configure your build environment visit
-# http://www.gradle.org/docs/current/userguide/build_environment.html
-# Specifies the JVM arguments used for the daemon process.
-# The setting is particularly useful for tweaking memory settings.
-org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
-# When configured, Gradle will run in incubating parallel mode.
-# This option should only be used with decoupled projects. More details, visit
-# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
-# org.gradle.parallel=true
-# AndroidX package structure to make it clearer which packages are bundled with the
-# Android operating system, and which are packaged with your app"s APK
-# https://developer.android.com/topic/libraries/support-library/androidx-rn
-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
@@ -1,6 +0,0 @@
-#Mon May 02 15:39:12 BST 2022
-distributionBase=GRADLE_USER_HOME
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip
-distributionPath=wrapper/dists
-zipStorePath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME
@@ -1,185 +0,0 @@
-#!/usr/bin/env sh
-
-#
-# Copyright 2015 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
-##############################################################################
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn () {
-    echo "$*"
-}
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-        JAVACMD="$JAVA_HOME/bin/java"
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=`expr $i + 1`
-    done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
-fi
-
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=`save "$@"`
-
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-exec "$JAVACMD" "$@"
@@ -1,89 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
@@ -1,16 +0,0 @@
-pluginManagement {
-    repositories {
-        gradlePluginPortal()
-        google()
-        mavenCentral()
-    }
-}
-dependencyResolutionManagement {
-    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
-    repositories {
-        google()
-        mavenCentral()
-    }
-}
-//rootProject.name = "Rust Template"
-include ':app'
@@ -1,143 +0,0 @@
-use android_activity::{AndroidApp, InputStatus, MainEvent, PollEvent};
-use log::info;
-
-use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
-extern crate cpal;
-
-fn write_data<T>(output: &mut [T], channels: usize, next_sample: &mut dyn FnMut() -> f32)
-where
-    T: cpal::Sample,
-{
-    for frame in output.chunks_mut(channels) {
-        let value: T = cpal::Sample::from::<f32>(&next_sample());
-        for sample in frame.iter_mut() {
-            *sample = value;
-        }
-    }
-}
-
-fn make_audio_stream<T>(
-    device: &cpal::Device,
-    config: &cpal::StreamConfig,
-) -> Result<cpal::Stream, anyhow::Error>
-where
-    T: cpal::Sample,
-{
-    let sample_rate = config.sample_rate.0 as f32;
-    let channels = config.channels as usize;
-
-    // Produce a sinusoid of maximum amplitude.
-    let mut sample_clock = 0f32;
-    let mut next_value = move || {
-        sample_clock = (sample_clock + 1.0) % sample_rate;
-        (sample_clock * 440.0 * 2.0 * std::f32::consts::PI / sample_rate).sin()
-    };
-
-    let err_fn = |err| eprintln!("an error occurred on stream: {}", err);
-
-    let stream = device.build_output_stream(
-        config,
-        move |data: &mut [T], _: &cpal::OutputCallbackInfo| {
-            write_data(data, channels, &mut next_value)
-        },
-        err_fn,
-    )?;
-    Ok(stream)
-}
-
-#[no_mangle]
-fn android_main(app: AndroidApp) {
-    android_logger::init_once(android_logger::Config::default().with_min_level(log::Level::Info));
-
-    let mut quit = false;
-    let mut redraw_pending = true;
-    let mut render_state: Option<()> = Default::default();
-
-    let host = cpal::default_host();
-
-    let device = host
-        .default_output_device()
-        .expect("failed to find output device");
-
-    let config = device.default_output_config().unwrap();
-
-    let stream = match config.sample_format() {
-        cpal::SampleFormat::F32 => make_audio_stream::<f32>(&device, &config.into()).unwrap(),
-        cpal::SampleFormat::I16 => make_audio_stream::<i16>(&device, &config.into()).unwrap(),
-        cpal::SampleFormat::U16 => make_audio_stream::<u16>(&device, &config.into()).unwrap(),
-    };
-
-    while !quit {
-        app.poll_events(
-            Some(std::time::Duration::from_millis(500)), /* timeout */
-            |event| {
-                match event {
-                    PollEvent::Wake => {
-                        info!("Early wake up");
-                    }
-                    PollEvent::Timeout => {
-                        info!("Timed out");
-                        // Real app would probably rely on vblank sync via graphics API...
-                        redraw_pending = true;
-                    }
-                    PollEvent::Main(main_event) => {
-                        info!("Main event: {:?}", main_event);
-                        match main_event {
-                            MainEvent::SaveState { saver, .. } => {
-                                saver.store("foo://bar".as_bytes());
-                            }
-                            MainEvent::Pause => {
-                                if let Err(err) = stream.pause() {
-                                    log::error!("Failed to pause audio playback: {err}");
-                                }
-                            }
-                            MainEvent::Resume { loader, .. } => {
-                                if let Some(state) = loader.load() {
-                                    if let Ok(uri) = String::from_utf8(state) {
-                                        info!("Resumed with saved state = {uri:#?}");
-                                    }
-                                }
-
-                                if let Err(err) = stream.play() {
-                                    log::error!("Failed to start audio playback: {err}");
-                                }
-                            }
-                            MainEvent::InitWindow { .. } => {
-                                render_state = Some(());
-                                redraw_pending = true;
-                            }
-                            MainEvent::TerminateWindow { .. } => {
-                                render_state = None;
-                            }
-                            MainEvent::WindowResized { .. } => {
-                                redraw_pending = true;
-                            }
-                            MainEvent::RedrawNeeded { .. } => {
-                                redraw_pending = true;
-                            }
-                            MainEvent::LowMemory => {}
-
-                            MainEvent::Destroy => quit = true,
-                            _ => { /* ... */ }
-                        }
-                    }
-                    _ => {}
-                }
-
-                if redraw_pending {
-                    if let Some(_rs) = render_state {
-                        redraw_pending = false;
-
-                        // Handle input
-                        app.input_events(|event| {
-                            info!("Input Event: {event:?}");
-                            InputStatus::Unhandled
-                        });
-
-                        info!("Render...");
-                    }
-                }
-            },
-        );
-    }
-}
@@ -1,21 +0,0 @@
-*.iml
-.gradle
-/local.properties
-/.idea/caches
-/.idea/libraries
-/.idea/modules.xml
-/.idea/workspace.xml
-/.idea/navEditor.xml
-/.idea/assetWizardSettings.xml
-.DS_Store
-/build
-/captures
-.externalNativeBuild
-.cxx
-local.properties
-*.so
-
-
-# Added by cargo
-
-/target
@@ -1,3 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="11" />
-  </component>
-</project>
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GradleMigrationSettings" migrationVersion="1" />
-  <component name="GradleSettings">
-    <option name="linkedExternalProjectsSettings">
-      <GradleProjectSettings>
-        <option name="testRunner" value="GRADLE" />
-        <option name="distributionType" value="DEFAULT_WRAPPED" />
-        <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="modules">
-          <set>
-            <option value="$PROJECT_DIR$" />
-            <option value="$PROJECT_DIR$/app" />
-          </set>
-        </option>
-      </GradleProjectSettings>
-    </option>
-  </component>
-</project>
@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="DesignSurface">
-    <option name="filePathToZoomLevelMap">
-      <map>
-        <entry key="..\:/Users/Robert/src/agdk-rust/examples/agdk-winit-wgpu/app/src/main/res/layout/activity_main.xml" value="0.5546875" />
-      </map>
-    </option>
-  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="Android Studio default JDK" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/build/classes" />
-  </component>
-  <component name="ProjectType">
-    <option name="id" value="Android" />
-  </component>
-</project>
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>
@@ -1,68 +0,0 @@
-[package]
-name = "agdk-eframe"
-version = "0.1.0"
-edition = "2021"
-resolver = "2"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-log = "0.4"
-winit = { version = "0.27.2", features = [ "android-game-activity" ] }
-wgpu = "0.14.0"
-pollster = "0.2"
-egui = "0.19"
-eframe = { version = "0.19", features = [ "wgpu" ] }
-egui_demo_lib = "0.19"
-
-[target.'cfg(not(target_os = "android"))'.dependencies]
-env_logger = "0.9"
-
-[target.'cfg(target_os = "android")'.dependencies]
-android_logger = "0.11.0"
-
-[patch.crates-io]
-
-# Since Egui currently depends on Winit 0.27 we can't update the examples to use
-# Winit master just yet, and use this branch of Winit with an updated backend
-# based on android-activity
-winit = { git = "https://github.com/rib/winit", branch = "android-activity" }
-#winit = { path = "../../../winit" }
-
-# Note:
-# Since android-activity is responsible for invoking the `android_main`
-# entrypoint for a native Rust application there can only be a single
-# implementation of the crate linked with the application.
-#
-# To avoid conflicts it's generally recommend to rely on Winit to pull
-# in a compatible version of android-activity but if you'd like to build
-# this example against the local checkout of android-activity you should
-# specify a patch here to make sure you also affect the version that Winit
-# uses.
-#
-# Note: also check that the local android-activity/Cargo.toml version matches
-# the version of android-activity that Winit depends on (in case you need to check
-# out a release branch locally to be compatible)
-#android-activity = { path = "../../android-activity" }
-
-# Egui 0.19 is missing some fixes for Android so we need to build against
-# git master for now
-egui = { git = "https://github.com/emilk/egui" }
-eframe = { git = "https://github.com/emilk/egui" }
-egui_demo_lib = { git = "https://github.com/emilk/egui" }
-#egui = { path = "../../../egui/crates/egui" }
-#eframe = { path = "../../../egui/crates/eframe" }
-#egui_demo_lib = { path = "../../../egui/crates/egui_demo_lib" }
-
-[features]
-default = []
-desktop = []
-
-[lib]
-name="main"
-crate_type=["cdylib"]
-
-[[bin]]
-path="src/lib.rs"
-name="agdk-eframe"
-required-features = [ "desktop" ]
@@ -1,17 +0,0 @@
-This tests using `GameActivity` with egui, winit and wgpu.
-
-This is based on a re-worked winit backend here:
-https://github.com/rib/winit/tree/android-activity
-
-```
-export ANDROID_NDK_HOME="path/to/ndk"
-export ANDROID_HOME="path/to/sdk"
-
-rustup target add aarch64-linux-android
-cargo install cargo-ndk
-
-cargo ndk -t arm64-v8a -o app/src/main/jniLibs/  build
-./gradlew build
-./gradlew installDebug
-adb shell am start -n co.realfit.agdkeframe/.MainActivity
-```
@@ -1 +0,0 @@
-/build
@@ -1,61 +0,0 @@
-plugins {
-    id 'com.android.application'
-}
-
-android {
-    compileSdk 31
-
-    defaultConfig {
-        applicationId "co.realfit.agdkeframe"
-        minSdk 28
-        targetSdk 31
-        versionCode 1
-        versionName "1.0"
-
-        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-    }
-
-    buildTypes {
-        release {
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
-        }
-        debug {
-            minifyEnabled false
-            //packagingOptions {
-            //    doNotStrip '**/*.so'
-            //}
-            //debuggable true
-        }
-    }
-    compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
-    }
-}
-
-dependencies {
-
-    implementation 'androidx.appcompat:appcompat:1.4.1'
-    implementation 'com.google.android.material:material:1.5.0'
-    implementation 'androidx.constraintlayout:constraintlayout:2.1.3'
-    testImplementation 'junit:junit:4.13.2'
-    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
-    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
-
-    // To use the Android Frame Pacing library
-    //implementation "androidx.games:games-frame-pacing:1.9.1"
-
-    // To use the Android Performance Tuner
-    //implementation "androidx.games:games-performance-tuner:1.5.0"
-
-    // To use the Games Activity library
-    implementation "androidx.games:games-activity:1.1.0"
-
-    // To use the Games Controller Library
-    //implementation "androidx.games:games-controller:1.1.0"
-
-    // To use the Games Text Input Library
-    //implementation "androidx.games:games-text-input:1.1.0"
-}
-
@@ -1,21 +0,0 @@
-# Add project specific ProGuard rules here.
-# You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile
@@ -1,25 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="co.realfit.agdkeframe">
-
-    <application
-        android:allowBackup="true"
-        android:icon="@mipmap/ic_launcher"
-        android:label="AGDK EFrame"
-        android:roundIcon="@mipmap/ic_launcher_round"
-        android:supportsRtl="true"
-        android:theme="@style/Theme.RustTemplate">
-        <activity
-            android:name=".MainActivity"
-            android:configChanges="orientation|screenSize|screenLayout|keyboardHidden"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-
-            <meta-data android:name="android.app.lib_name" android:value="main" />
-        </activity>
-    </application>
-
-</manifest>
@@ -1,70 +0,0 @@
-package co.realfit.agdkeframe;
-
-import androidx.appcompat.app.AppCompatActivity;
-import androidx.core.view.WindowCompat;
-import androidx.core.view.WindowInsetsCompat;
-import androidx.core.view.WindowInsetsControllerCompat;
-
-import com.google.androidgamesdk.GameActivity;
-
-import android.os.Bundle;
-import android.content.pm.PackageManager;
-import android.os.Build.VERSION;
-import android.os.Build.VERSION_CODES;
-import android.os.Bundle;
-import android.view.View;
-import android.view.WindowManager;
-
-public class MainActivity extends GameActivity {
-
-    static {
-        // Load the STL first to workaround issues on old Android versions:
-        // "if your app targets a version of Android earlier than Android 4.3
-        // (Android API level 18),
-        // and you use libc++_shared.so, you must load the shared library before any other
-        // library that depends on it."
-        // See https://developer.android.com/ndk/guides/cpp-support#shared_runtimes
-        //System.loadLibrary("c++_shared");
-
-        // Load the native library.
-        // The name "android-game" depends on your CMake configuration, must be
-        // consistent here and inside AndroidManifect.xml
-        System.loadLibrary("main");
-    }
-
-    private void hideSystemUI() {
-        // This will put the game behind any cutouts and waterfalls on devices which have
-        // them, so the corresponding insets will be non-zero.
-        if (VERSION.SDK_INT >= VERSION_CODES.P) {
-            getWindow().getAttributes().layoutInDisplayCutoutMode
-                    = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS;
-        }
-        // From API 30 onwards, this is the recommended way to hide the system UI, rather than
-        // using View.setSystemUiVisibility.
-        View decorView = getWindow().getDecorView();
-        WindowInsetsControllerCompat controller = new WindowInsetsControllerCompat(getWindow(),
-                decorView);
-        controller.hide(WindowInsetsCompat.Type.systemBars());
-        controller.hide(WindowInsetsCompat.Type.displayCutout());
-        controller.setSystemBarsBehavior(
-                WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE);
-    }
-
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        // When true, the app will fit inside any system UI windows.
-        // When false, we render behind any system UI windows.
-        WindowCompat.setDecorFitsSystemWindows(getWindow(), false);
-        hideSystemUI();
-        // You can set IME fields here or in native code using GameActivity_setImeEditorInfoFields.
-        // We set the fields in native_engine.cpp.
-        // super.setImeEditorInfoFields(InputType.TYPE_CLASS_TEXT,
-        //     IME_ACTION_NONE, IME_FLAG_NO_FULLSCREEN );
-        super.onCreate(savedInstanceState);
-    }
-
-    public boolean isGooglePlayGames() {
-        PackageManager pm = getPackageManager();
-        return pm.hasSystemFeature("com.google.android.play.feature.HPE_EXPERIENCE");
-    }
-}
@@ -1,30 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:aapt="http://schemas.android.com/aapt"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path android:pathData="M31,63.928c0,0 6.4,-11 12.1,-13.1c7.2,-2.6 26,-1.4 26,-1.4l38.1,38.1L107,108.928l-32,-1L31,63.928z">
-        <aapt:attr name="android:fillColor">
-            <gradient
-                android:endX="85.84757"
-                android:endY="92.4963"
-                android:startX="42.9492"
-                android:startY="49.59793"
-                android:type="linear">
-                <item
-                    android:color="#44000000"
-                    android:offset="0.0" />
-                <item
-                    android:color="#00000000"
-                    android:offset="1.0" />
-            </gradient>
-        </aapt:attr>
-    </path>
-    <path
-        android:fillColor="#FFFFFF"
-        android:fillType="nonZero"
-        android:pathData="M65.3,45.828l3.8,-6.6c0.2,-0.4 0.1,-0.9 -0.3,-1.1c-0.4,-0.2 -0.9,-0.1 -1.1,0.3l-3.9,6.7c-6.3,-2.8 -13.4,-2.8 -19.7,0l-3.9,-6.7c-0.2,-0.4 -0.7,-0.5 -1.1,-0.3C38.8,38.328 38.7,38.828 38.9,39.228l3.8,6.6C36.2,49.428 31.7,56.028 31,63.928h46C76.3,56.028 71.8,49.428 65.3,45.828zM43.4,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2c-0.3,-0.7 -0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C45.3,56.528 44.5,57.328 43.4,57.328L43.4,57.328zM64.6,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2s-0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C66.5,56.528 65.6,57.328 64.6,57.328L64.6,57.328z"
-        android:strokeWidth="1"
-        android:strokeColor="#00000000" />
-</vector>
@@ -1,170 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path
-        android:fillColor="#3DDC84"
-        android:pathData="M0,0h108v108h-108z" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M9,0L9,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,0L19,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M29,0L29,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M39,0L39,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M49,0L49,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M59,0L59,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M69,0L69,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M79,0L79,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M89,0L89,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M99,0L99,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,9L108,9"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,19L108,19"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,29L108,29"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,39L108,39"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,49L108,49"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,59L108,59"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,69L108,69"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,79L108,79"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,89L108,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,99L108,99"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,29L89,29"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,39L89,39"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,49L89,49"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,59L89,59"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,69L89,69"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,79L89,79"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M29,19L29,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M39,19L39,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M49,19L49,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M59,19L59,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M69,19L69,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M79,19L79,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-</vector>
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    tools:context=".MainActivity">
-
-    <TextView
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text="Hello World!"
-        app:layout_constraintBottom_toBottomOf="parent"
-        app:layout_constraintLeft_toLeftOf="parent"
-        app:layout_constraintRight_toRightOf="parent"
-        app:layout_constraintTop_toTopOf="parent" />
-
-</androidx.constraintlayout.widget.ConstraintLayout>
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@drawable/ic_launcher_background" />
-    <foreground android:drawable="@drawable/ic_launcher_foreground" />
-</adaptive-icon>
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@drawable/ic_launcher_background" />
-    <foreground android:drawable="@drawable/ic_launcher_foreground" />
-</adaptive-icon>
@@ -1,16 +0,0 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <!-- Base application theme. -->
-    <style name="Theme.RustTemplate" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
-        <!-- Primary brand color. -->
-        <item name="colorPrimary">@color/purple_200</item>
-        <item name="colorPrimaryVariant">@color/purple_700</item>
-        <item name="colorOnPrimary">@color/black</item>
-        <!-- Secondary brand color. -->
-        <item name="colorSecondary">@color/teal_200</item>
-        <item name="colorSecondaryVariant">@color/teal_200</item>
-        <item name="colorOnSecondary">@color/black</item>
-        <!-- Status bar color. -->
-        <item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>
-        <!-- Customize your theme here. -->
-    </style>
-</resources>
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <color name="purple_200">#FFBB86FC</color>
-    <color name="purple_500">#FF6200EE</color>
-    <color name="purple_700">#FF3700B3</color>
-    <color name="teal_200">#FF03DAC5</color>
-    <color name="teal_700">#FF018786</color>
-    <color name="black">#FF000000</color>
-    <color name="white">#FFFFFFFF</color>
-</resources>
@@ -1,16 +0,0 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <!-- Base application theme. -->
-    <style name="Theme.RustTemplate" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
-        <!-- Primary brand color. -->
-        <item name="colorPrimary">@color/purple_500</item>
-        <item name="colorPrimaryVariant">@color/purple_700</item>
-        <item name="colorOnPrimary">@color/white</item>
-        <!-- Secondary brand color. -->
-        <item name="colorSecondary">@color/teal_200</item>
-        <item name="colorSecondaryVariant">@color/teal_700</item>
-        <item name="colorOnSecondary">@color/black</item>
-        <!-- Status bar color. -->
-        <item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>
-        <!-- Customize your theme here. -->
-    </style>
-</resources>
@@ -1,10 +0,0 @@
-// 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
-}
-
-task clean(type: Delete) {
-    delete rootProject.buildDir
-}
-
@@ -1,21 +0,0 @@
-# Project-wide Gradle settings.
-# IDE (e.g. Android Studio) users:
-# Gradle settings configured through the IDE *will override*
-# any settings specified in this file.
-# For more details on how to configure your build environment visit
-# http://www.gradle.org/docs/current/userguide/build_environment.html
-# Specifies the JVM arguments used for the daemon process.
-# The setting is particularly useful for tweaking memory settings.
-org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
-# When configured, Gradle will run in incubating parallel mode.
-# This option should only be used with decoupled projects. More details, visit
-# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
-# org.gradle.parallel=true
-# AndroidX package structure to make it clearer which packages are bundled with the
-# Android operating system, and which are packaged with your app"s APK
-# https://developer.android.com/topic/libraries/support-library/androidx-rn
-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
@@ -1,6 +0,0 @@
-#Mon May 02 15:39:12 BST 2022
-distributionBase=GRADLE_USER_HOME
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip
-distributionPath=wrapper/dists
-zipStorePath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME
@@ -1,185 +0,0 @@
-#!/usr/bin/env sh
-
-#
-# Copyright 2015 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
-##############################################################################
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn () {
-    echo "$*"
-}
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-        JAVACMD="$JAVA_HOME/bin/java"
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=`expr $i + 1`
-    done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
-fi
-
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=`save "$@"`
-
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-exec "$JAVACMD" "$@"
@@ -1,89 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
@@ -1,16 +0,0 @@
-pluginManagement {
-    repositories {
-        gradlePluginPortal()
-        google()
-        mavenCentral()
-    }
-}
-dependencyResolutionManagement {
-    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
-    repositories {
-        google()
-        mavenCentral()
-    }
-}
-
-include ':app'
@@ -1,49 +0,0 @@
-use eframe::egui;
-use eframe::{NativeOptions, Renderer};
-
-#[cfg(target_os = "android")]
-use winit::platform::android::activity::AndroidApp;
-
-#[derive(Default)]
-struct DemoApp {
-    demo_windows: egui_demo_lib::DemoWindows,
-}
-
-impl eframe::App for DemoApp {
-    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        self.demo_windows.ui(ctx);
-    }
-}
-
-fn _main(mut options: NativeOptions) {
-    options.renderer = Renderer::Wgpu;
-    eframe::run_native(
-        "My egui App",
-        options,
-        Box::new(|_cc| Box::new(DemoApp::default())),
-    );
-}
-
-#[cfg(target_os = "android")]
-#[no_mangle]
-fn android_main(app: AndroidApp) {
-    use winit::platform::android::EventLoopBuilderExtAndroid;
-
-    android_logger::init_once(android_logger::Config::default().with_min_level(log::Level::Info));
-
-    let mut options = NativeOptions::default();
-    options.event_loop_builder = Some(Box::new(move |builder| {
-        builder.with_android_app(app);
-    }));
-    _main(options);
-}
-
-#[cfg(not(target_os = "android"))]
-fn main() {
-    env_logger::builder()
-        .filter_level(log::LevelFilter::Warn) // Default Log Level
-        .parse_default_env()
-        .init();
-
-    _main(NativeOptions::default());
-}
@@ -1,21 +0,0 @@
-*.iml
-.gradle
-/local.properties
-/.idea/caches
-/.idea/libraries
-/.idea/modules.xml
-/.idea/workspace.xml
-/.idea/navEditor.xml
-/.idea/assetWizardSettings.xml
-.DS_Store
-/build
-/captures
-.externalNativeBuild
-.cxx
-local.properties
-*.so
-
-
-# Added by cargo
-
-/target
@@ -1,3 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="11" />
-  </component>
-</project>
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GradleMigrationSettings" migrationVersion="1" />
-  <component name="GradleSettings">
-    <option name="linkedExternalProjectsSettings">
-      <GradleProjectSettings>
-        <option name="testRunner" value="GRADLE" />
-        <option name="distributionType" value="DEFAULT_WRAPPED" />
-        <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="modules">
-          <set>
-            <option value="$PROJECT_DIR$" />
-            <option value="$PROJECT_DIR$/app" />
-          </set>
-        </option>
-      </GradleProjectSettings>
-    </option>
-  </component>
-</project>
@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="DesignSurface">
-    <option name="filePathToZoomLevelMap">
-      <map>
-        <entry key="..\:/Users/Robert/src/agdk-rust/examples/agdk-winit-wgpu/app/src/main/res/layout/activity_main.xml" value="0.5546875" />
-      </map>
-    </option>
-  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="Android Studio default JDK" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/build/classes" />
-  </component>
-  <component name="ProjectType">
-    <option name="id" value="Android" />
-  </component>
-</project>
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>
@@ -1,60 +0,0 @@
-[package]
-name = "agdk-egui"
-version = "0.1.0"
-edition = "2021"
-resolver = "2"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-log = "0.4"
-winit = { version = "0.27", features = [ "android-game-activity" ] }
-wgpu = "0.13.0"
-pollster = "0.2"
-egui = "0.19"
-egui-wgpu = { version = "0.19", features = [ "winit" ] }
-egui-winit = { version = "0.19", default-features = false }
-egui_demo_lib = "0.19"
-
-[target.'cfg(not(target_os = "android"))'.dependencies]
-env_logger = "0.9"
-
-[target.'cfg(target_os = "android")'.dependencies]
-android_logger = "0.11.0"
-
-[patch.crates-io]
-
-# Since Egui currently depends on Winit 0.27 we can't update the examples to use
-# Winit master just yet, and use this branch of Winit with an updated backend
-# based on android-activity
-winit = { git = "https://github.com/rib/winit", branch = "android-activity" }
-#winit = { path = "../../../winit" }
-
-# Note:
-# Since android-activity is responsible for invoking the `android_main`
-# entrypoint for a native Rust application there can only be a single
-# implementation of the crate linked with the application.
-#
-# To avoid conflicts it's generally recommend to rely on Winit to pull
-# in a compatible version of android-activity but if you'd like to build
-# this example against the local checkout of android-activity you should
-# specify a patch here to make sure you also affect the version that Winit
-# uses.
-#
-# Note: also check that the local android-activity/Cargo.toml version matches
-# the version of android-activity that Winit depends on (in case you need to check
-# out a release branch locally to be compatible)
-#android-activity = { path = "../../android-activity" }
-
-[features]
-default = []
-desktop = []
-
-[lib]
-name="main"
-crate_type=["cdylib"]
-
-[[bin]]
-path="src/lib.rs"
-name="egui-test"
-required-features = [ "desktop" ]
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Robert Bragg	0f00a58a41	Merge pull request #90 from rust-mobile/release-0.4.2 Release 0.4.2	2023-06-27 17:39:52 +01:00
Robert Bragg	9a713c823d	Release 0.4.2	2023-06-27 17:19:52 +01:00
Robert Bragg	230035526b	Update na-mainloop	2023-06-26 00:08:48 +01:00
Robert Bragg	cd81420638	Update agdk-mainloop	2023-06-26 00:08:42 +01:00
Robert Bragg	1ad3abd934	Merge pull request #87 from rust-mobile/rust-version cargo: Fix `rust_version` -> `rust-version` property typo	2023-06-25 21:38:48 +01:00
Marijn Suijten	ca0d2eb3aa	cargo: Fix `rust_version` -> `rust-version` property typo Cargo complains: warning: android-activity/Cargo.toml: unused manifest key: package.rust_version Solve this by replacing the underscore with a hyphen.	2023-06-24 00:43:14 +02:00
Robert Bragg	79e03e08fb	Merge pull request #81 from rib/finish-activity Call Activity.finish() when android_main returns	2023-06-19 21:05:41 +01:00
Robert Bragg	120d2f66c7	Merge pull request #86 from rust-mobile/readme-badges README: Add badges to CI, crates.io, docs.rs and show the MSRV	2023-06-16 19:34:51 +01:00
Marijn Suijten	4a4efd871a	README: Add badges to CI, crates.io, docs.rs and show the MSRV I was trying to quickly get to the documentation of this crate and had the GitHub page open... but there was no link on the front-page: let's fix that.	2023-06-16 17:37:41 +02:00
Robert Bragg	3843a7cfaa	Call Activity.finish() when android_main returns Calling Activity.finish() is what ensures the Activity will get gracefully destroyed, including calling the Activity's onDestroy method. Fixes: #67	2023-05-24 23:10:29 +01:00
Robert Bragg	924e5405c2	Merge pull request #84 from yunsash/pointer_index_fix game_activity: Fix `pointer_index()` always returning `0`	2023-05-24 22:39:49 +01:00
kukie	049e660219	fix: pointer_index always returns 0	2023-05-23 15:43:03 +03:00
Robert Bragg	6559dc8133	Merge pull request #68 from notgull/abort-guards Add panic guards to extern "C" functions	2023-04-27 20:55:55 +01:00
jtnunley	d6ccefaf77	Add catch unwind wrappers to extern "C" functions Co-authored-by: Robert Bragg <robert@sixbynine.org>	2023-04-27 20:42:45 +01:00
Robert Bragg	9229bb20c1	Merge pull request #77 from rib/rust-version-0-64-typo Fix rust_version typo s/0.64/1.64/	2023-04-24 16:12:08 +01:00
Robert Bragg	4976cbad44	Fix rust_version typo s/0.64/1.64/ Also removes a stale comment about MSVR policy in ci.yml	2023-04-24 11:42:17 +01:00
jtnunley	e0c96ad6b4	Dedup android_log	2023-04-24 11:36:27 +01:00
Robert Bragg	c70e5d852f	Merge pull request #73 from rust-mobile/dependabot/github_actions/actions/checkout-3 build(deps): bump actions/checkout from 2 to 3	2023-04-23 20:00:03 +01:00
Robert Bragg	f28d6adc55	Merge pull request #74 from rust-mobile/dependabot/cargo/num_enum-0.6 build(deps): update num_enum requirement from 0.5 to 0.6	2023-04-23 19:59:50 +01:00
dependabot[bot]	0fa6888484	build(deps): update num_enum requirement from 0.5 to 0.6 Updates the requirements on [num_enum](https://github.com/illicitonion/num_enum) to permit the latest version. - [Release notes](https://github.com/illicitonion/num_enum/releases) - [Commits](https://github.com/illicitonion/num_enum/compare/0.5.0...0.6.1) --- updated-dependencies: - dependency-name: num_enum dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com>	2023-04-23 15:14:30 +00:00
dependabot[bot]	d4a3d5845d	build(deps): bump actions/checkout from 2 to 3 Bumps [actions/checkout](https://github.com/actions/checkout) from 2 to 3. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v2...v3) --- updated-dependencies: - dependency-name: actions/checkout dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com>	2023-04-23 15:11:09 +00:00
Robert Bragg	c91745a39d	Merge pull request #76 from rib/cargo-ndk-2-for-ci Add MSRV policy to README and bump `rust_version` to 0.64, due to `ndk` -> `raw_window_handle` dependency	2023-04-23 16:10:34 +01:00
Robert Bragg	1b44d38822	Bump MSRV to 0.64 and and MSRV policy to README	2023-04-23 15:57:07 +01:00
Robert Bragg	9ac7891664	CI: test with cargo-ndk 2, which compiles with rustc 1.60	2023-04-22 17:37:55 +01:00
Robert Bragg	03b06b8c5e	Merge pull request #70 from MarijnS95/na-resize native-activity: Propagate `NativeWindow` redraw/resize and `ContentRectChanged` callbacks to main loop	2023-04-19 13:44:52 +01:00
Robert Bragg	caf2a624b2	Merge pull request #72 from notgull/dependabot Add dependabot support	2023-04-19 13:41:41 +01:00
Marijn Suijten	fe9d68c99e	Clean up partial module imports Some items were imported in scope while most of the code uses fully qualified names.	2023-04-19 14:09:39 +02:00
Marijn Suijten	0c3f16c9ba	native-activity: Propagate `onContentRectChanged` callback to main loop	2023-04-19 14:09:30 +02:00
Marijn Suijten	87fe6a8465	native-activity: Propagate `onNativeWindowRedrawNeeded` callback to main loop	2023-04-19 14:09:24 +02:00
Marijn Suijten	a04c483d79	native-activity: Propagate `onNativeWindowResized` callback to main loop	2023-04-19 14:09:12 +02:00
jtnunley	507cfe072e	Add dependabot support	2023-04-10 09:45:05 -07:00
Robert Bragg	36ddfaa9ce	Merge pull request #64 from rib/release-0.4.1 Release 0.4.1	2023-02-15 15:38:40 +00:00
Robert Bragg	b2467cb028	Release 0.4.1	2023-02-15 14:28:55 +00:00
Robert Bragg	6dd3c0c02a	Merge pull request #62 from rib/rust-mobile-org-urls Update Github URL since moving to rust-mobile org	2023-02-14 12:02:18 +00:00
Robert Bragg	6ae2e427d6	Merge pull request #61 from rib/jni-vm-and-activity-ptrs Add AndroidApp::vm_as_ptr() and ::activity_as_ptr() APIs	2023-02-14 12:01:33 +00:00
Robert Bragg	dc9ca832c5	Add AndroidApp::vm_as_ptr() and ::activity_as_ptr() APIs This enables applications to make JNI calls without needing the `ndk-context` crate - which we would like to deprecate. Fixes: #60	2023-02-14 11:49:38 +00:00
Robert Bragg	9d06f62a4e	Update Github URL since moving to rust-mobile org	2023-02-13 17:20:11 +00:00
Robert Bragg	6942637c3c	Merge pull request #56 from rib/remove-example-lock-files Remove Cargo.lock files for examples	2022-12-23 01:25:51 +00:00
Robert Bragg	47b2e279e0	Remove Cargo.lock files for examples When splitting out the rust-android-examples we kept the agdk-mainloop and na-mainloop examples in part so we would have some simple code we can build as integration tests. Since it's less likely that these will be referenced directly as examples now, compared to those in rust-android-examples this removes the lock files so we will instead always build against the latest semver compatible dependencies. Considering the simplicity of these examples, and minimal dependencies these lock files probably weren't that worthwhile before either.	2022-12-23 01:00:57 +00:00
Robert Bragg	40fb012000	Merge pull request #52 from rib/update-readme-example-links README: update example links	2022-12-21 23:28:48 +00:00
Robert Bragg	4155fbc9db	README: update example links	2022-12-21 23:27:09 +00:00
Robert Bragg	435e183a58	Merge pull request #50 from rib/remove-most-examples Remove most examples (see https://github.com/rust-mobile/rust-android-examples)	2022-12-21 16:15:30 +00:00
Robert Bragg	2e279210a3	Remove most examples Most of the examples weren't strictly just demonstrating how to use the android-activity API - rather they demonstrated using other libraries in conjunction with android-activity. Most of the examples have now been split into a standalone repository under: https://github.com/rust-mobile/rust-android-examples The na-mainloop and agdk-mainloop examples have been kept here since they can be built against the local/in-tree version of android-activity and are useful to keep for CI purposes. This also runs `cargo update` for the na-mainloop and agdk-mainloop.	2022-12-20 19:55:10 +00:00
Robert Bragg	14eb2f0a17	Merge pull request #49 from rust-mobile/demote-spam native_activity: Demote spammy `info!`/`eprintln!` debug logs to `trace!`	2022-12-20 16:59:40 +00:00
Robert Bragg	8f68cb5db9	Merge pull request #47 from rust-mobile/remove-unneeded-backslash-escape Remove backslash-escaping of quotes in raw string	2022-12-20 16:29:53 +00:00
Marijn Suijten	b217ad546c	Remove backslash-escaping of quotes in raw string In a raw string [no escaping is processed] nor are these quotes treated specially unless it was postfixed with `#`; the backslashes show up in the compiler error displayed to the user instead. For consistency the string this was likely copied from is now also turned into a raw string literal, with backslashes equivalently removed. [no escaping is processed]: https://doc.rust-lang.org/reference/tokens.html#raw-string-literals	2022-12-14 20:51:39 +01:00
Marijn Suijten	bf251c63cd	native_activity: Demote spammy `info!`/`eprintln!` debug logs to `trace!` Ideally information - especially when spamming per `Looper` poll - used for debugging `android-activity` doesn't show to the user unless they use the `Trace` level (eventually for this specific crate/module). This is already adhered to in most places of the code but there were a few high-volume cases still remaining.	2022-12-14 20:09:16 +01:00
Robert Bragg	1633f62d0d	Merge pull request #39 from rib/release-0.4 Release 0.4	2022-11-14 16:06:52 +00:00