Add initial native-activity glue crate

Cargo.toml

@@ -1,5 +1,6 @@
 [workspace]
 members = [
+    "native-activity",
     "game-activity"
 ]
 

native-activity/.gitignore

@@ -0,0 +1,10 @@
+/target
+Cargo.lock
+
+
+# Added by cargo
+#
+# already existing elements were commented out
+
+#/target
+#Cargo.lock

native-activity/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "native-activity"
+version = "0.1.0"
+edition = "2021"
+keywords = ["android", "ndk"]
+readme = "../README.md"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+log = "0.4"
+jni-sys = "0.3"
+ndk = { version = "0.6" }
+ndk-sys = { version = "0.3" }
+ndk-context = { version = "0.1" }
+lazy_static = "1.4.0"
+num_enum = "0.5"
+bitflags = "1.3"
+libc = "0.2.84"
+
+[build-dependencies]
+cc = { version = "1.0", features = ["parallel"] }
+
+[package.metadata.docs.rs]
+targets = [
+    "aarch64-linux-android",
+    "armv7-linux-androideabi",
+    "i686-linux-android",
+    "x86_64-linux-android",
+]

native-activity/LICENSE

@@ -0,0 +1,12 @@
+The third-party glue code, from the Android Game Development Kit, under the csrc/ directory
+is covered by the Apache 2.0 license only:
+
+Apache License, Version 2.0 (docs/LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
+
+
+All other code is dual-licensed under either
+
+* MIT License (docs/LICENSE-MIT or http://opensource.org/licenses/MIT)
+* Apache License, Version 2.0 (docs/LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
+
+at your option.

native-activity/README.md

@@ -0,0 +1,39 @@
+This crate provides a "glue" layer for building native Rust applications on Android which aims to be API compatible with the `game-activity` crate as far as possible but is based on the `NativeActivity` class instead on `GameActivity`.
+
+The idea is to figure out if there's some minimal subset API that could potentially be factored out into a standard "glue" crate which could potentially be used by Winit. This way it might be more practical to support a wider variety of `Activity` base classes for Android applications when they don't affect how Winit works.
+
+
+# Why not pure Rust?
+
+The `android_native_app_glue` library that's provided by the NDK happens to be written in C and it has been well tested and works. Considering the somewhat fiddly thread synchronization that needs to be done for specific events like window terminations or state saves then it seems wise to re-use this logic instead of re-implementing it.
+
+The android_native_app_glue code isn't _that_ complex and could potentially be re-implemented in Rust at some point, although it's not clear how beneficial it would be. I would note that `ndk-glue` did go down the route of re-implementing the glue layer for `NativeActivity` purely in Rust but I wasn't confident that it's synchronization model was correct. (See here for more discussion: https://github.com/rust-windowing/winit/issues/2293)
+
+
+# Synchronizing with Upstream...
+
+Upstream distribute `android_native_app_glue.c` as part of the NDK under `$ANDROID_NDK_HOME/sources/android/native_app_glue/android_native_app_glue.c`
+
+This code is something like >10 years old and isn't expected to change.
+
+
+## Minor modifications
+
+`NativeActivity_onCreate` should be renamed to `NativeActivity_onCreate_C` because Rust/Cargo doesn't support compiling C/C++ code in a way that can export these symbols directly and we instead have to export wrappers from Rust code.
+
+Since we want to call the application's main function from Rust after initializing our own `AndroidApp` state, but we want to let applications use the same `android_main` symbol name then `android_main` should be renamed to `_rust_glue_entry` in `android_native_app_glue.h` and `android_native_app_glue.c`
+
+The `ID_INPUT` looper event source is disabled because we decouple polling + emitting events from input handling (I.e we expect applications to _pull_ input events when they want them instead of _push_ input events immediately). For now it's assumed that applications will explicitly check for input based as part of processing a new frame.
+
+_(The technical difficulty with the input source is that once it triggers an event then it won't stop triggering events until all the outstanding events are read - which isn't compatible with allowing applications to explicitly check for input instead of immediately pushing input events at them (all other mainloop events will become drowned out by the input source). Unfortunately the looper API doesn't expose `epoll`'s edge triggering which would probably be ideal in this case.)_
+
+
+## Generate Rust bindings
+
+Since we know we only care about android build targets then to simplify the build we pre-generate Rust bindings for the C/C++ headers using bindgen via `generate-bindings.sh`
+
+Install bindgen via `cargo install bindgen`
+
+`export ANDROID_NDK_ROOT=/path/to/ndk` so that `generate-bindings.sh` can find suitable sysroot headers.
+
+Run `./generate-bindings.sh` from the top of the repo after putting the latest prefab source/headers under `csrc/`

native-activity/build.rs

@@ -0,0 +1,8 @@
+
+fn main() {
+    cc::Build::new()
+        .include("csrc")
+        .include("csrc/native-activity/native_app_glue")
+        .file("csrc/native-activity/native_app_glue/android_native_app_glue.c")
+        .compile("libnative_app_glue.a");
+}

native-activity/csrc/native-activity/native_app_glue/android_native_app_glue.c

@@ -0,0 +1,444 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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
+ *
+ *      http://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.
+ *
+ */
+
+#include <jni.h>
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/resource.h>
+
+#include "android_native_app_glue.h"
+#include <android/log.h>
+
+#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "threaded_app", __VA_ARGS__))
+#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "threaded_app", __VA_ARGS__))
+
+/* For debug builds, always enable the debug traces in this library */
+#ifndef NDEBUG
+#  define LOGV(...)  ((void)__android_log_print(ANDROID_LOG_VERBOSE, "threaded_app", __VA_ARGS__))
+#else
+#  define LOGV(...)  ((void)0)
+#endif
+
+static void free_saved_state(struct android_app* android_app) {
+    pthread_mutex_lock(&android_app->mutex);
+    if (android_app->savedState != NULL) {
+        free(android_app->savedState);
+        android_app->savedState = NULL;
+        android_app->savedStateSize = 0;
+    }
+    pthread_mutex_unlock(&android_app->mutex);
+}
+
+int8_t android_app_read_cmd(struct android_app* android_app) {
+    int8_t cmd;
+    if (read(android_app->msgread, &cmd, sizeof(cmd)) == sizeof(cmd)) {
+        switch (cmd) {
+            case APP_CMD_SAVE_STATE:
+                free_saved_state(android_app);
+                break;
+        }
+        return cmd;
+    } else {
+        LOGE("No data on command pipe!");
+    }
+    return -1;
+}
+
+static void print_cur_config(struct android_app* android_app) {
+    char lang[2], country[2];
+    AConfiguration_getLanguage(android_app->config, lang);
+    AConfiguration_getCountry(android_app->config, country);
+
+    LOGV("Config: mcc=%d mnc=%d lang=%c%c cnt=%c%c orien=%d touch=%d dens=%d "
+            "keys=%d nav=%d keysHid=%d navHid=%d sdk=%d size=%d long=%d "
+            "modetype=%d modenight=%d",
+            AConfiguration_getMcc(android_app->config),
+            AConfiguration_getMnc(android_app->config),
+            lang[0], lang[1], country[0], country[1],
+            AConfiguration_getOrientation(android_app->config),
+            AConfiguration_getTouchscreen(android_app->config),
+            AConfiguration_getDensity(android_app->config),
+            AConfiguration_getKeyboard(android_app->config),
+            AConfiguration_getNavigation(android_app->config),
+            AConfiguration_getKeysHidden(android_app->config),
+            AConfiguration_getNavHidden(android_app->config),
+            AConfiguration_getSdkVersion(android_app->config),
+            AConfiguration_getScreenSize(android_app->config),
+            AConfiguration_getScreenLong(android_app->config),
+            AConfiguration_getUiModeType(android_app->config),
+            AConfiguration_getUiModeNight(android_app->config));
+}
+
+void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd) {
+    switch (cmd) {
+        case APP_CMD_INPUT_CHANGED:
+            LOGV("APP_CMD_INPUT_CHANGED\n");
+            pthread_mutex_lock(&android_app->mutex);
+            if (android_app->inputQueue != NULL) {
+                //AInputQueue_detachLooper(android_app->inputQueue);
+            }
+            android_app->inputQueue = android_app->pendingInputQueue;
+            if (android_app->inputQueue != NULL) {
+                //LOGV("Attaching input queue to looper");
+                //AInputQueue_attachLooper(android_app->inputQueue,
+                //        android_app->looper, LOOPER_ID_INPUT, NULL,
+                //        &android_app->inputPollSource);
+            }
+            pthread_cond_broadcast(&android_app->cond);
+            pthread_mutex_unlock(&android_app->mutex);
+            break;
+
+        case APP_CMD_INIT_WINDOW:
+            LOGV("APP_CMD_INIT_WINDOW\n");
+            pthread_mutex_lock(&android_app->mutex);
+            android_app->window = android_app->pendingWindow;
+            pthread_cond_broadcast(&android_app->cond);
+            pthread_mutex_unlock(&android_app->mutex);
+            break;
+
+        case APP_CMD_TERM_WINDOW:
+            LOGV("APP_CMD_TERM_WINDOW\n");
+            pthread_cond_broadcast(&android_app->cond);
+            break;
+
+        case APP_CMD_RESUME:
+        case APP_CMD_START:
+        case APP_CMD_PAUSE:
+        case APP_CMD_STOP:
+            LOGV("activityState=%d\n", cmd);
+            pthread_mutex_lock(&android_app->mutex);
+            android_app->activityState = cmd;
+            pthread_cond_broadcast(&android_app->cond);
+            pthread_mutex_unlock(&android_app->mutex);
+            break;
+
+        case APP_CMD_CONFIG_CHANGED:
+            LOGV("APP_CMD_CONFIG_CHANGED\n");
+            AConfiguration_fromAssetManager(android_app->config,
+                    android_app->activity->assetManager);
+            print_cur_config(android_app);
+            break;
+
+        case APP_CMD_DESTROY:
+            LOGV("APP_CMD_DESTROY\n");
+            android_app->destroyRequested = 1;
+            break;
+    }
+}
+
+void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd) {
+    switch (cmd) {
+        case APP_CMD_TERM_WINDOW:
+            LOGV("APP_CMD_TERM_WINDOW\n");
+            pthread_mutex_lock(&android_app->mutex);
+            android_app->window = NULL;
+            pthread_cond_broadcast(&android_app->cond);
+            pthread_mutex_unlock(&android_app->mutex);
+            break;
+
+        case APP_CMD_SAVE_STATE:
+            LOGV("APP_CMD_SAVE_STATE\n");
+            pthread_mutex_lock(&android_app->mutex);
+            android_app->stateSaved = 1;
+            pthread_cond_broadcast(&android_app->cond);
+            pthread_mutex_unlock(&android_app->mutex);
+            break;
+
+        case APP_CMD_RESUME:
+            free_saved_state(android_app);
+            break;
+    }
+}
+
+void app_dummy() {
+
+}
+
+static void android_app_destroy(struct android_app* android_app) {
+    LOGV("android_app_destroy!");
+    free_saved_state(android_app);
+    pthread_mutex_lock(&android_app->mutex);
+    if (android_app->inputQueue != NULL) {
+        AInputQueue_detachLooper(android_app->inputQueue);
+    }
+    AConfiguration_delete(android_app->config);
+    android_app->destroyed = 1;
+    pthread_cond_broadcast(&android_app->cond);
+    pthread_mutex_unlock(&android_app->mutex);
+    // Can't touch android_app object after this.
+}
+
+/*
+static void process_input(struct android_app* app, __attribute__((unused)) struct android_poll_source* source) {
+    AInputEvent* event = NULL;
+    while (AInputQueue_getEvent(app->inputQueue, &event) >= 0) {
+        LOGV("New input event: type=%d\n", AInputEvent_getType(event));
+        if (AInputQueue_preDispatchEvent(app->inputQueue, event)) {
+            continue;
+        }
+        int32_t handled = 0;
+        if (app->onInputEvent != NULL) handled = app->onInputEvent(app, event);
+        AInputQueue_finishEvent(app->inputQueue, event, handled);
+    }
+}
+*/
+
+static void process_cmd(struct android_app* app, __attribute__((unused)) struct android_poll_source* source) {
+    int8_t cmd = android_app_read_cmd(app);
+    android_app_pre_exec_cmd(app, cmd);
+    if (app->onAppCmd != NULL) app->onAppCmd(app, cmd);
+    android_app_post_exec_cmd(app, cmd);
+}
+
+static void* android_app_entry(void* param) {
+    struct android_app* android_app = (struct android_app*)param;
+
+    android_app->config = AConfiguration_new();
+    AConfiguration_fromAssetManager(android_app->config, android_app->activity->assetManager);
+
+    print_cur_config(android_app);
+
+    android_app->cmdPollSource.id = LOOPER_ID_MAIN;
+    android_app->cmdPollSource.app = android_app;
+    android_app->cmdPollSource.process = process_cmd;
+    //android_app->inputPollSource.id = LOOPER_ID_INPUT;
+    //android_app->inputPollSource.app = android_app;
+    //android_app->inputPollSource.process = process_input;
+
+    ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
+    ALooper_addFd(looper, android_app->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL,
+            &android_app->cmdPollSource);
+    android_app->looper = looper;
+
+    pthread_mutex_lock(&android_app->mutex);
+    android_app->running = 1;
+    pthread_cond_broadcast(&android_app->cond);
+    pthread_mutex_unlock(&android_app->mutex);
+
+    _rust_glue_entry(android_app);
+
+    android_app_destroy(android_app);
+    return NULL;
+}
+
+// --------------------------------------------------------------------
+// Native activity interaction (called from main thread)
+// --------------------------------------------------------------------
+
+static struct android_app* android_app_create(ANativeActivity* activity,
+        void* savedState, size_t savedStateSize) {
+    struct android_app* android_app = (struct android_app*)malloc(sizeof(struct android_app));
+    memset(android_app, 0, sizeof(struct android_app));
+    android_app->activity = activity;
+
+    pthread_mutex_init(&android_app->mutex, NULL);
+    pthread_cond_init(&android_app->cond, NULL);
+
+    if (savedState != NULL) {
+        android_app->savedState = malloc(savedStateSize);
+        android_app->savedStateSize = savedStateSize;
+        memcpy(android_app->savedState, savedState, savedStateSize);
+    }
+
+    int msgpipe[2];
+    if (pipe(msgpipe)) {
+        LOGE("could not create pipe: %s", strerror(errno));
+        return NULL;
+    }
+    android_app->msgread = msgpipe[0];
+    android_app->msgwrite = msgpipe[1];
+
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+    pthread_create(&android_app->thread, &attr, android_app_entry, android_app);
+
+    // Wait for thread to start.
+    pthread_mutex_lock(&android_app->mutex);
+    while (!android_app->running) {
+        pthread_cond_wait(&android_app->cond, &android_app->mutex);
+    }
+    pthread_mutex_unlock(&android_app->mutex);
+
+    return android_app;
+}
+
+static void android_app_write_cmd(struct android_app* android_app, int8_t cmd) {
+    if (write(android_app->msgwrite, &cmd, sizeof(cmd)) != sizeof(cmd)) {
+        LOGE("Failure writing android_app cmd: %s\n", strerror(errno));
+    }
+}
+
+static void android_app_set_input(struct android_app* android_app, AInputQueue* inputQueue) {
+    pthread_mutex_lock(&android_app->mutex);
+    android_app->pendingInputQueue = inputQueue;
+    android_app_write_cmd(android_app, APP_CMD_INPUT_CHANGED);
+    while (android_app->inputQueue != android_app->pendingInputQueue) {
+        pthread_cond_wait(&android_app->cond, &android_app->mutex);
+    }
+    pthread_mutex_unlock(&android_app->mutex);
+}
+
+static void android_app_set_window(struct android_app* android_app, ANativeWindow* window) {
+    pthread_mutex_lock(&android_app->mutex);
+    if (android_app->pendingWindow != NULL) {
+        android_app_write_cmd(android_app, APP_CMD_TERM_WINDOW);
+    }
+    android_app->pendingWindow = window;
+    if (window != NULL) {
+        android_app_write_cmd(android_app, APP_CMD_INIT_WINDOW);
+    }
+    while (android_app->window != android_app->pendingWindow) {
+        pthread_cond_wait(&android_app->cond, &android_app->mutex);
+    }
+    pthread_mutex_unlock(&android_app->mutex);
+}
+
+static void android_app_set_activity_state(struct android_app* android_app, int8_t cmd) {
+    pthread_mutex_lock(&android_app->mutex);
+    android_app_write_cmd(android_app, cmd);
+    while (android_app->activityState != cmd) {
+        pthread_cond_wait(&android_app->cond, &android_app->mutex);
+    }
+    pthread_mutex_unlock(&android_app->mutex);
+}
+
+static void android_app_free(struct android_app* android_app) {
+    pthread_mutex_lock(&android_app->mutex);
+    android_app_write_cmd(android_app, APP_CMD_DESTROY);
+    while (!android_app->destroyed) {
+        pthread_cond_wait(&android_app->cond, &android_app->mutex);
+    }
+    pthread_mutex_unlock(&android_app->mutex);
+
+    close(android_app->msgread);
+    close(android_app->msgwrite);
+    pthread_cond_destroy(&android_app->cond);
+    pthread_mutex_destroy(&android_app->mutex);
+    free(android_app);
+}
+
+static void onDestroy(ANativeActivity* activity) {
+    LOGV("Destroy: %p\n", activity);
+    android_app_free((struct android_app*)activity->instance);
+}
+
+static void onStart(ANativeActivity* activity) {
+    LOGV("Start: %p\n", activity);
+    android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_START);
+}
+
+static void onResume(ANativeActivity* activity) {
+    LOGV("Resume: %p\n", activity);
+    android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_RESUME);
+}
+
+static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) {
+    struct android_app* android_app = (struct android_app*)activity->instance;
+    void* savedState = NULL;
+
+    LOGV("SaveInstanceState: %p\n", activity);
+    pthread_mutex_lock(&android_app->mutex);
+    android_app->stateSaved = 0;
+    android_app_write_cmd(android_app, APP_CMD_SAVE_STATE);
+    while (!android_app->stateSaved) {
+        pthread_cond_wait(&android_app->cond, &android_app->mutex);
+    }
+
+    if (android_app->savedState != NULL) {
+        savedState = android_app->savedState;
+        *outLen = android_app->savedStateSize;
+        android_app->savedState = NULL;
+        android_app->savedStateSize = 0;
+    }
+
+    pthread_mutex_unlock(&android_app->mutex);
+
+    return savedState;
+}
+
+static void onPause(ANativeActivity* activity) {
+    LOGV("Pause: %p\n", activity);
+    android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_PAUSE);
+}
+
+static void onStop(ANativeActivity* activity) {
+    LOGV("Stop: %p\n", activity);
+    android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_STOP);
+}
+
+static void onConfigurationChanged(ANativeActivity* activity) {
+    struct android_app* android_app = (struct android_app*)activity->instance;
+    LOGV("ConfigurationChanged: %p\n", activity);
+    android_app_write_cmd(android_app, APP_CMD_CONFIG_CHANGED);
+}
+
+static void onLowMemory(ANativeActivity* activity) {
+    struct android_app* android_app = (struct android_app*)activity->instance;
+    LOGV("LowMemory: %p\n", activity);
+    android_app_write_cmd(android_app, APP_CMD_LOW_MEMORY);
+}
+
+static void onWindowFocusChanged(ANativeActivity* activity, int focused) {
+    LOGV("WindowFocusChanged: %p -- %d\n", activity, focused);
+    android_app_write_cmd((struct android_app*)activity->instance,
+            focused ? APP_CMD_GAINED_FOCUS : APP_CMD_LOST_FOCUS);
+}
+
+static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* window) {
+    LOGV("NativeWindowCreated: %p -- %p\n", activity, window);
+    android_app_set_window((struct android_app*)activity->instance, window);
+}
+
+static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* window) {
+    LOGV("NativeWindowDestroyed: %p -- %p\n", activity, window);
+    android_app_set_window((struct android_app*)activity->instance, NULL);
+}
+
+static void onInputQueueCreated(ANativeActivity* activity, AInputQueue* queue) {
+    LOGV("InputQueueCreated: %p -- %p\n", activity, queue);
+    android_app_set_input((struct android_app*)activity->instance, queue);
+}
+
+static void onInputQueueDestroyed(ANativeActivity* activity, AInputQueue* queue) {
+    LOGV("InputQueueDestroyed: %p -- %p\n", activity, queue);
+    android_app_set_input((struct android_app*)activity->instance, NULL);
+}
+
+JNIEXPORT
+void ANativeActivity_onCreate_C(ANativeActivity* activity, void* savedState,
+                              size_t savedStateSize) {
+    LOGV("Creating: %p\n", activity);
+    activity->callbacks->onDestroy = onDestroy;
+    activity->callbacks->onStart = onStart;
+    activity->callbacks->onResume = onResume;
+    activity->callbacks->onSaveInstanceState = onSaveInstanceState;
+    activity->callbacks->onPause = onPause;
+    activity->callbacks->onStop = onStop;
+    activity->callbacks->onConfigurationChanged = onConfigurationChanged;
+    activity->callbacks->onLowMemory = onLowMemory;
+    activity->callbacks->onWindowFocusChanged = onWindowFocusChanged;
+    activity->callbacks->onNativeWindowCreated = onNativeWindowCreated;
+    activity->callbacks->onNativeWindowDestroyed = onNativeWindowDestroyed;
+    activity->callbacks->onInputQueueCreated = onInputQueueCreated;
+    activity->callbacks->onInputQueueDestroyed = onInputQueueDestroyed;
+
+    activity->instance = android_app_create(activity, savedState, savedStateSize);
+}

native-activity/csrc/native-activity/native_app_glue/android_native_app_glue.h

@@ -0,0 +1,354 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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
+ *
+ *      http://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.
+ *
+ */
+
+#ifndef _ANDROID_NATIVE_APP_GLUE_H
+#define _ANDROID_NATIVE_APP_GLUE_H
+
+#include <poll.h>
+#include <pthread.h>
+#include <sched.h>
+
+#include <android/configuration.h>
+#include <android/looper.h>
+#include <android/native_activity.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * The native activity interface provided by <android/native_activity.h>
+ * is based on a set of application-provided callbacks that will be called
+ * by the Activity's main thread when certain events occur.
+ *
+ * This means that each one of this callbacks _should_ _not_ block, or they
+ * risk having the system force-close the application. This programming
+ * model is direct, lightweight, but constraining.
+ *
+ * The 'android_native_app_glue' static library is used to provide a different
+ * execution model where the application can implement its own main event
+ * loop in a different thread instead. Here's how it works:
+ *
+ * 1/ The application must provide a function named "android_main()" that
+ *    will be called when the activity is created, in a new thread that is
+ *    distinct from the activity's main thread.
+ *
+ * 2/ android_main() receives a pointer to a valid "android_app" structure
+ *    that contains references to other important objects, e.g. the
+ *    ANativeActivity obejct instance the application is running in.
+ *
+ * 3/ the "android_app" object holds an ALooper instance that already
+ *    listens to two important things:
+ *
+ *      - activity lifecycle events (e.g. "pause", "resume"). See APP_CMD_XXX
+ *        declarations below.
+ *
+ *      - input events coming from the AInputQueue attached to the activity.
+ *
+ *    Each of these correspond to an ALooper identifier returned by
+ *    ALooper_pollOnce with values of LOOPER_ID_MAIN and LOOPER_ID_INPUT,
+ *    respectively.
+ *
+ *    Your application can use the same ALooper to listen to additional
+ *    file-descriptors.  They can either be callback based, or with return
+ *    identifiers starting with LOOPER_ID_USER.
+ *
+ * 4/ Whenever you receive a LOOPER_ID_MAIN or LOOPER_ID_INPUT event,
+ *    the returned data will point to an android_poll_source structure.  You
+ *    can call the process() function on it, and fill in android_app->onAppCmd
+ *    and android_app->onInputEvent to be called for your own processing
+ *    of the event.
+ *
+ *    Alternatively, you can call the low-level functions to read and process
+ *    the data directly...  look at the process_cmd() and process_input()
+ *    implementations in the glue to see how to do this.
+ *
+ * See the sample named "native-activity" that comes with the NDK with a
+ * full usage example.  Also look at the JavaDoc of NativeActivity.
+ */
+
+struct android_app;
+
+/**
+ * Data associated with an ALooper fd that will be returned as the "outData"
+ * when that source has data ready.
+ */
+struct android_poll_source {
+    // The identifier of this source.  May be LOOPER_ID_MAIN or
+    // LOOPER_ID_INPUT.
+    int32_t id;
+
+    // The android_app this ident is associated with.
+    struct android_app* app;
+
+    // Function to call to perform the standard processing of data from
+    // this source.
+    void (*process)(struct android_app* app, struct android_poll_source* source);
+};
+
+/**
+ * This is the interface for the standard glue code of a threaded
+ * application.  In this model, the application's code is running
+ * in its own thread separate from the main thread of the process.
+ * It is not required that this thread be associated with the Java
+ * VM, although it will need to be in order to make JNI calls any
+ * Java objects.
+ */
+struct android_app {
+    // The application can place a pointer to its own state object
+    // here if it likes.
+    void* userData;
+
+    // Fill this in with the function to process main app commands (APP_CMD_*)
+    void (*onAppCmd)(struct android_app* app, int32_t cmd);
+
+    // Fill this in with the function to process input events.  At this point
+    // the event has already been pre-dispatched, and it will be finished upon
+    // return.  Return 1 if you have handled the event, 0 for any default
+    // dispatching.
+    int32_t (*onInputEvent)(struct android_app* app, AInputEvent* event);
+
+    // The ANativeActivity object instance that this app is running in.
+    ANativeActivity* activity;
+
+    // The current configuration the app is running in.
+    AConfiguration* config;
+
+    // This is the last instance's saved state, as provided at creation time.
+    // It is NULL if there was no state.  You can use this as you need; the
+    // memory will remain around until you call android_app_exec_cmd() for
+    // APP_CMD_RESUME, at which point it will be freed and savedState set to NULL.
+    // These variables should only be changed when processing a APP_CMD_SAVE_STATE,
+    // at which point they will be initialized to NULL and you can malloc your
+    // state and place the information here.  In that case the memory will be
+    // freed for you later.
+    void* savedState;
+    size_t savedStateSize;
+
+    // The ALooper associated with the app's thread.
+    ALooper* looper;
+
+    // When non-NULL, this is the input queue from which the app will
+    // receive user input events.
+    AInputQueue* inputQueue;
+
+    // When non-NULL, this is the window surface that the app can draw in.
+    ANativeWindow* window;
+
+    // Current content rectangle of the window; this is the area where the
+    // window's content should be placed to be seen by the user.
+    ARect contentRect;
+
+    // Current state of the app's activity.  May be either APP_CMD_START,
+    // APP_CMD_RESUME, APP_CMD_PAUSE, or APP_CMD_STOP; see below.
+    int activityState;
+
+    // This is non-zero when the application's NativeActivity is being
+    // destroyed and waiting for the app thread to complete.
+    int destroyRequested;
+
+    // -------------------------------------------------
+    // Below are "private" implementation of the glue code.
+
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+
+    int msgread;
+    int msgwrite;
+
+    pthread_t thread;
+
+    struct android_poll_source cmdPollSource;
+    struct android_poll_source inputPollSource;
+
+    int running;
+    int stateSaved;
+    int destroyed;
+    int redrawNeeded;
+    AInputQueue* pendingInputQueue;
+    ANativeWindow* pendingWindow;
+    ARect pendingContentRect;
+};
+
+enum {
+    /**
+     * Looper data ID of commands coming from the app's main thread, which
+     * is returned as an identifier from ALooper_pollOnce().  The data for this
+     * identifier is a pointer to an android_poll_source structure.
+     * These can be retrieved and processed with android_app_read_cmd()
+     * and android_app_exec_cmd().
+     */
+    LOOPER_ID_MAIN = 1,
+
+    /**
+     * Looper data ID of events coming from the AInputQueue of the
+     * application's window, which is returned as an identifier from
+     * ALooper_pollOnce().  The data for this identifier is a pointer to an
+     * android_poll_source structure.  These can be read via the inputQueue
+     * object of android_app.
+     */
+    LOOPER_ID_INPUT = 2,
+
+    /**
+     * Start of user-defined ALooper identifiers.
+     */
+    LOOPER_ID_USER = 3,
+};
+
+enum {
+    /**
+     * Command from main thread: the AInputQueue has changed.  Upon processing
+     * this command, android_app->inputQueue will be updated to the new queue
+     * (or NULL).
+     */
+    APP_CMD_INPUT_CHANGED,
+
+    /**
+     * Command from main thread: a new ANativeWindow is ready for use.  Upon
+     * receiving this command, android_app->window will contain the new window
+     * surface.
+     */
+    APP_CMD_INIT_WINDOW,
+
+    /**
+     * Command from main thread: the existing ANativeWindow needs to be
+     * terminated.  Upon receiving this command, android_app->window still
+     * contains the existing window; after calling android_app_exec_cmd
+     * it will be set to NULL.
+     */
+    APP_CMD_TERM_WINDOW,
+
+    /**
+     * Command from main thread: the current ANativeWindow has been resized.
+     * Please redraw with its new size.
+     */
+    APP_CMD_WINDOW_RESIZED,
+
+    /**
+     * Command from main thread: the system needs that the current ANativeWindow
+     * be redrawn.  You should redraw the window before handing this to
+     * android_app_exec_cmd() in order to avoid transient drawing glitches.
+     */
+    APP_CMD_WINDOW_REDRAW_NEEDED,
+
+    /**
+     * Command from main thread: the content area of the window has changed,
+     * such as from the soft input window being shown or hidden.  You can
+     * find the new content rect in android_app::contentRect.
+     */
+    APP_CMD_CONTENT_RECT_CHANGED,
+
+    /**
+     * Command from main thread: the app's activity window has gained
+     * input focus.
+     */
+    APP_CMD_GAINED_FOCUS,
+
+    /**
+     * Command from main thread: the app's activity window has lost
+     * input focus.
+     */
+    APP_CMD_LOST_FOCUS,
+
+    /**
+     * Command from main thread: the current device configuration has changed.
+     */
+    APP_CMD_CONFIG_CHANGED,
+
+    /**
+     * Command from main thread: the system is running low on memory.
+     * Try to reduce your memory use.
+     */
+    APP_CMD_LOW_MEMORY,
+
+    /**
+     * Command from main thread: the app's activity has been started.
+     */
+    APP_CMD_START,
+
+    /**
+     * Command from main thread: the app's activity has been resumed.
+     */
+    APP_CMD_RESUME,
+
+    /**
+     * Command from main thread: the app should generate a new saved state
+     * for itself, to restore from later if needed.  If you have saved state,
+     * allocate it with malloc and place it in android_app.savedState with
+     * the size in android_app.savedStateSize.  The will be freed for you
+     * later.
+     */
+    APP_CMD_SAVE_STATE,
+
+    /**
+     * Command from main thread: the app's activity has been paused.
+     */
+    APP_CMD_PAUSE,
+
+    /**
+     * Command from main thread: the app's activity has been stopped.
+     */
+    APP_CMD_STOP,
+
+    /**
+     * Command from main thread: the app's activity is being destroyed,
+     * and waiting for the app thread to clean up and exit before proceeding.
+     */
+    APP_CMD_DESTROY,
+};
+
+/**
+ * Call when ALooper_pollAll() returns LOOPER_ID_MAIN, reading the next
+ * app command message.
+ */
+int8_t android_app_read_cmd(struct android_app* android_app);
+
+/**
+ * Call with the command returned by android_app_read_cmd() to do the
+ * initial pre-processing of the given command.  You can perform your own
+ * actions for the command after calling this function.
+ */
+void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd);
+
+/**
+ * Call with the command returned by android_app_read_cmd() to do the
+ * final post-processing of the given command.  You must have done your own
+ * actions for the command before calling this function.
+ */
+void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd);
+
+/**
+ * Dummy function that used to be used to prevent the linker from stripping app
+ * glue code. No longer necessary, since __attribute__((visibility("default")))
+ * does this for us.
+ */
+__attribute__((
+    deprecated("Calls to app_dummy are no longer necessary. See "
+               "https://github.com/android-ndk/ndk/issues/381."))) void
+app_dummy();
+
+/**
+ * This is the function that application code must implement, representing
+ * the main entry to the app.
+ */
+extern void _rust_glue_entry(struct android_app* app);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ANDROID_NATIVE_APP_GLUE_H */

native-activity/docs/LICENSE-APACHE

@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

native-activity/docs/LICENSE-MIT

@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

native-activity/generate-bindings.sh

@@ -0,0 +1,43 @@
+#!/bin/sh
+
+SYSROOT="${ANDROID_NDK_ROOT}"/toolchains/llvm/prebuilt/linux-x86_64/sysroot/
+if ! test -d $SYSROOT; then
+    SYSROOT="${ANDROID_NDK_ROOT}"/toolchains/llvm/prebuilt/windows-x86_64/sysroot/
+fi
+
+while read ARCH && read TARGET ; do
+
+    # --module-raw-line 'use '
+    bindgen wrapper.h -o src/ffi_$ARCH.rs \
+        --blocklist-item 'JNI\w+' \
+        --blocklist-item 'C?_?JNIEnv' \
+        --blocklist-item '_?JavaVM' \
+        --blocklist-item '_?j\w+' \
+        --blocklist-item 'ALooper\w*' \
+        --blocklist-function 'ALooper\w*' \
+        --blocklist-item 'AAsset\w*' \
+        --blocklist-item 'AAssetManager\w*' \
+        --blocklist-function 'AAssetManager\w*' \
+        --blocklist-item 'ANativeWindow\w*' \
+        --blocklist-function 'ANativeWindow\w*' \
+        --blocklist-item 'AConfiguration\w*' \
+        --blocklist-function 'AConfiguration\w*' \
+        --blocklist-function 'android_main' \
+        --blocklist-item 'AInputQueue\w*' \
+        --blocklist-function 'AInputQueue\w*' \
+        --blocklist-item 'GameActivity_onCreate' \
+        --blocklist-function 'GameActivity_onCreate_C' \
+        --newtype-enum '\w+_(result|status)_t' \
+        -- \
+        -Icsrc \
+        --sysroot="$SYSROOT" --target=$TARGET
+done << EOF
+arm
+arm-linux-androideabi
+aarch64
+aarch64-linux-android
+i686
+i686-linux-android
+x86_64
+x86_64-linux-android
+EOF

native-activity/src/ffi.rs

@@ -0,0 +1,34 @@
+//! The bindings are pre-generated and the right one for the platform is selected at compile time.
+
+// Bindgen lints
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(improper_ctypes)]
+#![allow(clippy::all)]
+// Temporarily allow UB nullptr dereference in bindgen layout tests until fixed upstream:
+// https://github.com/rust-lang/rust-bindgen/pull/2055
+// https://github.com/rust-lang/rust-bindgen/pull/2064
+#![allow(deref_nullptr)]
+#![allow(dead_code)]
+
+use jni_sys::*;
+use ndk_sys::AAssetManager;
+use ndk_sys::ANativeWindow;
+use ndk_sys::{ALooper, AConfiguration, AInputQueue};
+
+
+#[cfg(all(
+    any(target_os = "android", feature = "test"),
+    any(target_arch = "arm", target_arch = "armv7")
+))]
+include!("ffi_arm.rs");
+
+#[cfg(all(any(target_os = "android", feature = "test"), target_arch = "aarch64"))]
+include!("ffi_aarch64.rs");
+
+#[cfg(all(any(target_os = "android", feature = "test"), target_arch = "x86"))]
+include!("ffi_i686.rs");
+
+#[cfg(all(any(target_os = "android", feature = "test"), target_arch = "x86_64"))]
+include!("ffi_x86_64.rs");

native-activity/src/lib.rs

@@ -0,0 +1,637 @@
+use log::{Level, error, info, trace};
+use ndk::asset::AssetManager;
+use ndk::configuration::Configuration;
+use ndk::input_queue::InputQueue;
+use ndk::looper::{FdEvent};
+use ndk::native_activity::NativeActivity;
+use ndk::native_window::NativeWindow;
+use ndk_sys::ALooper_wake;
+use ndk_sys::{ALooper, ALooper_pollAll};
+use std::ffi::{CStr, CString};
+use std::fs::File;
+use std::io::{BufRead, BufReader};
+use std::ops::Deref;
+use std::os::raw;
+use std::ptr::NonNull;
+use std::sync::Arc;
+use std::sync::RwLock;
+use std::sync::RwLockReadGuard;
+use std::time::Duration;
+use std::{thread, ptr};
+use std::os::unix::prelude::*;
+use lazy_static::lazy_static;
+
+#[cfg(not(any(target_os = "android", feature = "test")))]
+compile_error!("android-ndk-sys only supports compiling for Android");
+
+mod ffi;
+
+pub mod input {
+    pub use ndk::event::{
+        InputEvent, Source, MetaState,
+        MotionEvent, Pointer, MotionAction, Axis, ButtonState, EdgeFlags, MotionEventFlags,
+        KeyEvent, KeyAction, Keycode, KeyEventFlags
+    };
+}
+
+//pub mod input;
+
+// We provide a side-band way to access the global AndroidApp
+// via `android_app()` since there's no FFI safe way of calling
+// an `extern "C" android_main()` with the AndroidApp while it's
+// based on an `Arc<RwLock<>>` (without extra steps to pass an
+// ffi safe handle/pointer).
+//
+// Technically is should actually be safe to pass the app as an
+// argument, regardless of the unspecified layout for FFI, since
+// we can assume that android_main is compiled at the same time
+// by the same compiler as part of the same cdylib, so we could
+// consider removing this static global if there's a good way to
+// squash the compiler warnings.
+//
+// Note: for winit if we removed the `android_app()` getter then
+// apps would have to explicitly pass the AndroidApp via an
+// android specific event loop builder api /
+// PlatformSpecificEventLoopAttributes - so having this global
+// getter also helps keep simple winit usage portable.
+static mut ANDROID_APP: Option<AndroidApp> = None;
+
+// This is mainly just for convenience for implementing a winit backend
+// although ideally it shouldn't be necessary to have a static global.
+//
+// Removing this would just require moving the `native_window()` getter
+// to be an AndroidApp method and require winit to pass around the
+// app wherever it needs to query the window.
+lazy_static! {
+    static ref NATIVE_WINDOW: RwLock<Option<NativeWindow>> = Default::default();
+}
+
+pub type InputEvent = ndk::event::InputEvent;
+
+// Note: unlike in ndk-glue this has signed components (consistent
+// with Android's ARect) which generally allows for representing
+// rectangles with a negative/off-screen origin. Even though this
+// is currently just used to represent the content rect (that probably
+// wouldn't have any negative components) we keep the generality
+// since this is a primitive type that could potentially be used
+// for more things in the future.
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct Rect {
+    pub left: i32,
+    pub top: i32,
+    pub right: i32,
+    pub bottom: i32,
+}
+
+// The only time it's safe to update the android_app->savedState pointer is
+// while handling a SaveState event, so this API is only exposed for those
+// events...
+#[derive(Debug)]
+pub struct StateSaver<'a> {
+    app: &'a AndroidApp,
+}
+
+impl<'a> StateSaver<'a> {
+    pub fn store(&self, state: &'a [u8]) {
+
+        // android_native_app_glue specifically expects savedState to have been allocated
+        // via libc::malloc since it will automatically handle freeing the data once it
+        // has been handed over to the Java Activity / main thread.
+        unsafe {
+            let app_ptr = self.app.ptr.as_ptr();
+
+            // In case the application calls store() multiple times for some reason we
+            // make sure to free any pre-existing state...
+            if (*app_ptr).savedState != ptr::null_mut() {
+                libc::free((*app_ptr).savedState);
+                (*app_ptr).savedState = ptr::null_mut();
+                (*app_ptr).savedStateSize = 0;
+            }
+
+            let buf = libc::malloc(state.len());
+            if buf == ptr::null_mut() {
+                panic!("Failed to allocate save_state buffer");
+            }
+
+            // Since it's a byte array there's no special alignment requirement here.
+            //
+            // Since we re-define `buf` we ensure it's not possible to access the buffer
+            // via its original pointer for the lifetime of the slice.
+            {
+                let buf: &mut [u8] = std::slice::from_raw_parts_mut(buf.cast(), state.len());
+                buf.copy_from_slice(state);
+            }
+
+            (*app_ptr).savedState = buf;
+            (*app_ptr).savedStateSize = state.len() as u64;
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct StateLoader<'a> {
+    app: &'a AndroidApp,
+}
+impl<'a> StateLoader<'a> {
+    pub fn load(&self) -> Option<Vec<u8>> {
+        unsafe {
+            let app_ptr = self.app.ptr.as_ptr();
+            if (*app_ptr).savedState != ptr::null_mut() && (*app_ptr).savedStateSize > 0 {
+                let buf: &mut [u8] = std::slice::from_raw_parts_mut((*app_ptr).savedState.cast(), (*app_ptr).savedStateSize as usize);
+                let state = buf.to_vec();
+                Some(state)
+            } else {
+                None
+            }
+        }
+    }
+}
+
+// TODO: make more of these into non_exhaustive structs so it's possible to
+// extend what data is passed to each event without breaking the API..
+#[non_exhaustive]
+#[derive(Debug)]
+pub enum MainEvent<'a> {
+
+    // XXX: No need to expose for now, and isn't applicable with GameActivity
+    // Command from main thread: the input queue has changed.
+    // Note: since the internal `AInputQueue` is not exposed directly, applications
+    // won't typically need to react to this.
+    //InputQueueChanged,
+
+    /// Command from main thread: a new [`NativeWindow`] is ready for use.  Upon
+    /// receiving this command, [`native_window()`] will return the new window
+    #[non_exhaustive]
+    InitWindow { },
+
+    /// Command from main thread: the existing [`NativeWindow`] needs to be
+    /// terminated.  Upon receiving this command, [`native_window()`] still
+    /// returns the existing window; after returning from the [`AndroidApp::poll_events()`]
+    /// callback then [`native_window()`] will return `None`.
+    #[non_exhaustive]
+    TerminateWindow {},
+
+    // TODO: include the prev and new size in the event
+    /// Command from main thread: the current [`NativeWindow`] has been resized.
+    /// Please redraw with its new size.
+    #[non_exhaustive]
+    WindowResized {},
+
+    /// Command from main thread: the current [`NativeWindow`] needs to be redrawn.
+    /// You should redraw the window before the [`AndroidApp::poll_events()`]
+    /// callback returns in order to avoid transient drawing glitches.
+    #[non_exhaustive]
+    RedrawNeeded {},
+
+    /// Command from main thread: the content area of the window has changed,
+    /// such as from the soft input window being shown or hidden.  You can
+    /// get the new content rect by calling [`AndroidApp::content_rect()`]
+    ContentRectChanged,
+
+    /// Command from main thread: the app's activity window has gained
+    /// input focus.
+    GainedFocus,
+
+    /// Command from main thread: the app's activity window has lost
+    /// input focus.
+    LostFocus,
+
+    /// Command from main thread: the current device configuration has changed.
+    /// You can get a copy of the latest [Configuration] by calling
+    /// [`AndroidApp::config()`]
+    ConfigChanged,
+
+    /// Command from main thread: the system is running low on memory.
+    /// Try to reduce your memory use.
+    LowMemory,
+
+    /// Command from main thread: the app's activity has been started.
+    Start,
+
+    /// Command from main thread: the app's activity has been resumed.
+    #[non_exhaustive]
+    Resume { loader: StateLoader<'a> },
+
+    /// Command from main thread: the app should generate a new saved state
+    /// for itself, to restore from later if needed.  If you have saved state,
+    /// allocate it with malloc and place it in android_app.savedState with
+    /// the size in android_app.savedStateSize.  The will be freed for you
+    /// later.
+    #[non_exhaustive]
+    SaveState { saver: StateSaver<'a> },
+
+    /// Command from main thread: the app's activity has been paused.
+    Pause,
+
+    /// Command from main thread: the app's activity has been stopped.
+    Stop,
+
+    /// Command from main thread: the app's activity is being destroyed,
+    /// and waiting for the app thread to clean up and exit before proceeding.
+    Destroy,
+
+    /// Command from main thread: the app's insets have changed.
+    #[non_exhaustive]
+    InsetsChanged {},
+}
+
+#[derive(Debug)]
+#[non_exhaustive]
+pub enum PollEvent<'a> {
+    Wake,
+    Timeout,
+    Main(MainEvent<'a>),
+
+    #[non_exhaustive]
+    FdEvent { ident: i32, fd: RawFd, events: FdEvent, data: *mut std::ffi::c_void },
+
+    Error
+}
+
+#[derive(Clone)]
+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>
+}
+unsafe impl Send for AndroidAppWaker {}
+unsafe impl Sync for AndroidAppWaker {}
+
+impl AndroidAppWaker {
+    pub fn wake(&self) {
+        unsafe { ALooper_wake(self.looper.as_ptr()); }
+    }
+}
+#[derive(Debug, Clone)]
+pub struct AndroidApp {
+    inner: Arc<AndroidAppInner>
+}
+
+impl Deref for AndroidApp {
+    type Target = Arc<AndroidAppInner>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+#[derive(Debug)]
+pub struct AndroidAppInner {
+    ptr: NonNull<ffi::android_app>,
+    config: RwLock<Configuration>,
+}
+
+impl AndroidApp {
+
+    pub(crate) unsafe fn from_ptr(ptr: NonNull<ffi::android_app>) -> Self {
+
+        // Note: we don't use from_ptr since we don't own the android_app.config
+        // and need to keep in mind that the Drop handler is going to call
+        // AConfiguration_delete()
+        //
+        // Whenever we get a ConfigChanged notification we synchronize this
+        // config state with a deep copy.
+        let config = Configuration::clone_from_ptr(NonNull::new_unchecked((*ptr.as_ptr()).config));
+
+        Self {
+            inner: Arc::new(AndroidAppInner {
+                ptr,
+                config: RwLock::new(config),
+            })
+        }
+    }
+
+    /// Calls [`ALooper_pollAll`] on the looper associated with this AndroidApp as well
+    /// as processing any events (such as lifecycle events) via the given `callback`.
+    ///
+    /// It's important to use this API for polling, and not call [`ALooper_pollAll`] directly since
+    /// some events require pre- and post-processing either side of the callback. For correct
+    /// behavior events should be handled immediately, before returning from the callback and
+    /// not simply queued for batch processing later. For example the existing [`NativeWindow`]
+    /// is accessible during a [`MainEvent::TerminateWindow`] callback and will be
+    /// set to `None` once the callback returns, and this is also synchronized with the Java
+    /// main thread. The [`MainEvent::SaveState`] event is also synchronized with the
+    /// Java main thread.
+    ///
+    /// # Safety
+    /// This API must only be called from the applications main thread
+    pub fn poll_events<F>(&self, timeout: Option<Duration>, mut callback: F)
+        where F: FnMut(PollEvent)
+    {
+        trace!("poll_events");
+
+        unsafe {
+            let app_ptr = self.ptr;
+
+            let mut fd: i32 = 0;
+            let mut events: i32 = 0;
+            let mut source: *mut core::ffi::c_void = ptr::null_mut();
+
+            let timeout_milliseconds = if let Some(timeout) = timeout { timeout.as_millis() as i32 } else { -1 };
+            info!("Calling ALooper_pollAll, timeout = {timeout_milliseconds}");
+            let id = ALooper_pollAll(timeout_milliseconds, &mut fd, &mut events, &mut source as *mut *mut core::ffi::c_void);
+            info!("pollAll id = {id}");
+            match id {
+                ffi::ALOOPER_POLL_WAKE => {
+                    trace!("ALooper_pollAll returned POLL_WAKE");
+                    callback(PollEvent::Wake);
+                }
+                ffi::ALOOPER_POLL_CALLBACK => {
+                    // ALooper_pollAll is documented to handle all callback sources internally so it should
+                    // never return a _CALLBACK source id...
+                    error!("Spurious ALOOPER_POLL_CALLBACK from ALopper_pollAll() (ignored)");
+                }
+                ffi::ALOOPER_POLL_TIMEOUT => {
+                    trace!("ALooper_pollAll returned POLL_TIMEOUT");
+                    callback(PollEvent::Timeout);
+                }
+                ffi::ALOOPER_POLL_ERROR => {
+                    trace!("ALooper_pollAll returned POLL_ERROR");
+                    callback(PollEvent::Error);
+
+                    // Considering that this API is quite likely to be used in `android_main`
+                    // it's rather unergonomic to require the call to unwrap a Result for each
+                    // call to poll_events(). Alternatively we could maybe even just panic!()
+                    // here, while it's hard to imagine practically being able to recover
+                    //return Err(LooperError);
+                }
+                id if id >= 0 => {
+                    match id as u32 {
+                        ffi::LOOPER_ID_MAIN => {
+                            trace!("ALooper_pollAll returned ID_MAIN");
+                            let source: *mut ffi::android_poll_source = source.cast();
+                            if source != ptr::null_mut() {
+                                let cmd_i = ffi::android_app_read_cmd(app_ptr.as_ptr());
+
+                                let cmd = match cmd_i as u32 {
+                                    // We don't forward info about the AInputQueue to apps since it's
+                                    // an implementation details that's also not compatible with
+                                    // GameActivity
+                                    ffi::APP_CMD_INPUT_CHANGED => None,
+
+                                    ffi::APP_CMD_INIT_WINDOW => Some(MainEvent::InitWindow {}),
+                                    ffi::APP_CMD_TERM_WINDOW => Some(MainEvent::TerminateWindow {}),
+                                    ffi::APP_CMD_WINDOW_RESIZED => Some(MainEvent::WindowResized {}),
+                                    ffi::APP_CMD_WINDOW_REDRAW_NEEDED => Some(MainEvent::RedrawNeeded {}),
+                                    ffi::APP_CMD_CONTENT_RECT_CHANGED => Some(MainEvent::ContentRectChanged),
+                                    ffi::APP_CMD_GAINED_FOCUS => Some(MainEvent::GainedFocus),
+                                    ffi::APP_CMD_LOST_FOCUS => Some(MainEvent::LostFocus),
+                                    ffi::APP_CMD_CONFIG_CHANGED => Some(MainEvent::ConfigChanged),
+                                    ffi::APP_CMD_LOW_MEMORY => Some(MainEvent::LowMemory),
+                                    ffi::APP_CMD_START => Some(MainEvent::Start),
+                                    ffi::APP_CMD_RESUME => Some(MainEvent::Resume { loader: StateLoader { app: &self } }),
+                                    ffi::APP_CMD_SAVE_STATE => Some(MainEvent::SaveState { saver: StateSaver { app: &self } }),
+                                    ffi::APP_CMD_PAUSE => Some(MainEvent::Pause),
+                                    ffi::APP_CMD_STOP => Some(MainEvent::Stop),
+                                    ffi::APP_CMD_DESTROY => Some(MainEvent::Destroy),
+
+                                    //ffi::NativeAppGlueAppCmd_APP_CMD_WINDOW_INSETS_CHANGED => MainEvent::InsetsChanged {},
+                                    _ => unreachable!()
+                                };
+
+                                trace!("Calling android_app_pre_exec_cmd({cmd_i})");
+                                ffi::android_app_pre_exec_cmd(app_ptr.as_ptr(), cmd_i);
+
+                                if let Some(cmd) = cmd {
+                                    trace!("Read ID_MAIN command {cmd_i} = {cmd:?}");
+                                    match cmd {
+                                        MainEvent::ConfigChanged => {
+                                            *self.config.write().unwrap() =
+                                                Configuration::clone_from_ptr(NonNull::new_unchecked((*app_ptr.as_ptr()).config));
+                                        }
+                                        MainEvent::InitWindow { .. } => {
+                                            let win_ptr = (*app_ptr.as_ptr()).window;
+                                            *NATIVE_WINDOW.write().unwrap() =
+                                                Some(NativeWindow::from_ptr(NonNull::new(win_ptr).unwrap()));
+                                        }
+                                        MainEvent::TerminateWindow { .. } => {
+                                            *NATIVE_WINDOW.write().unwrap() = None;
+                                        }
+                                        _ => {}
+                                    }
+
+                                    trace!("Invoking callback for ID_MAIN command = {:?}", cmd);
+                                    callback(PollEvent::Main(cmd));
+                                }
+
+                                trace!("Calling android_app_post_exec_cmd({cmd_i})");
+                                ffi::android_app_post_exec_cmd(app_ptr.as_ptr(), cmd_i);
+                            } else {
+                                panic!("ALooper_pollAll returned ID_MAIN event with NULL android_poll_source!");
+                            }
+                        }
+                        ffi::LOOPER_ID_INPUT => {
+                            trace!("ALooper_pollAll returned ID_INPUT");
+                            // For now we don't forward notifications of input events specifically, we just
+                            // forward the notifications as a wake up, and assume the application main loop
+                            // will unconditionally check events for each iteration of it's event loop
+                            //
+                            // (Specifically notifying when input events are received would be inconsistent
+                            // with the current design of GameActivity input handling which we want to stay
+                            // compatible with))
+                            //
+                            // XXX: Actually it was a bad idea to emit a Wake for input since applications
+                            // are likely to _not_ consider that on its own a cause to redraw and it could
+                            // end up spamming enough wake ups to interfere with other events that would
+                            // trigger a redraw + input handling
+                            //callback(PollEvent::Wake);
+                        }
+                        _ => {
+                            let events = FdEvent::from_bits(events as u32)
+                                .expect(&format!("Spurious ALooper_pollAll event flags {:#04x}", events as u32));
+                            trace!("Custom ALooper event source: id = {id}, fd = {fd}, events = {events:?}, data = {source:?}");
+                            callback(PollEvent::FdEvent{ ident: id, fd: fd as RawFd, events, data: source });
+                        }
+                    }
+                }
+                _ => {
+                    error!("Spurious ALooper_pollAll return value {id} (ignored)");
+                }
+            }
+        }
+    }
+
+    /// Creates a means to wake up the main loop while it is blocked waiting for
+    /// events within [`poll_events()`].
+    ///
+    /// Internally this uses [`ALooper_wake`] on the looper associated with this
+    /// [AndroidApp].
+    ///
+    /// # Safety
+    /// This API can be used from any thread
+    pub fn create_waker(&self) -> AndroidAppWaker {
+        unsafe {
+            // From the application's pov we assume the app_ptr and looper pointer
+            // have static lifetimes and we can safely assume they are never NULL.
+            let app_ptr = self.ptr.as_ptr();
+            AndroidAppWaker { looper: NonNull::new_unchecked((*app_ptr).looper) }
+        }
+    }
+
+    /// Returns a deep copy of this application's [`Configuration`]
+    pub fn config(&self) -> Configuration {
+        self.config.read().unwrap().clone()
+    }
+
+    /// Queries the current content rectangle of the window; this is the area where the
+    /// window's content should be placed to be seen by the user.
+    ///
+    /// # Safety
+    /// This API must only be called from the applications main thread
+    pub fn content_rect(&self) -> Rect {
+        unsafe {
+            let app_ptr = self.ptr.as_ptr();
+            Rect {
+                left: (*app_ptr).contentRect.left,
+                right: (*app_ptr).contentRect.right,
+                top: (*app_ptr).contentRect.top,
+                bottom: (*app_ptr).contentRect.bottom,
+            }
+        }
+    }
+
+    /// Queries the Asset Manager instance for the application.
+    ///
+    /// Use this to access binary assets bundled inside your application's .apk file.
+    ///
+    /// # Safety
+    /// This API must only be called from the applications main thread
+    pub fn asset_manager(&self) -> AssetManager {
+        unsafe {
+            let app_ptr = self.ptr.as_ptr();
+            let am_ptr = NonNull::new_unchecked((*(*app_ptr).activity).assetManager);
+            AssetManager::from_ptr(am_ptr)
+        }
+    }
+
+    pub fn input_events<'b, F>(&self, mut callback: F)
+        where F: FnMut(&InputEvent)
+    {
+        let queue = unsafe {
+            let app_ptr = self.ptr.as_ptr();
+            if (*app_ptr).inputQueue == ptr::null_mut() {
+                return;
+            }
+            let queue = NonNull::new_unchecked((*app_ptr).inputQueue);
+            InputQueue::from_ptr(queue)
+        };
+
+        info!("collect_events: START");
+        while let Some(event) = queue.get_event() {
+            info!("Got input event {event:?}");
+            if let Some(event) = queue.pre_dispatch(event) {
+                trace!("Pre dispatched input event {event:?}");
+
+                callback(&event);
+
+                // Always report events as 'handled'. This means we won't get
+                // so called 'fallback' events generated (such as converting trackball
+                // events into emulated keypad events), but we could conceivably
+                // implement similar emulation somewhere else in the stack if
+                // necessary, and this will be more consistent with the GameActivity
+                // input handling that doesn't do any kind of emulation.
+                info!("Finishing input event {event:?}");
+                queue.finish_event(event, true);
+            }
+        }
+    }
+}
+
+/// Gets the global [`AndroidApp`] for this process
+pub fn android_app() -> AndroidApp {
+    if let Some(app) = unsafe { &ANDROID_APP } {
+        return app.clone()
+    } else {
+        unreachable!()
+    }
+}
+
+/// Queries the current [`NativeWindow`] for the application.
+///
+/// This will only return `Some(window)` between
+/// [`AndroidAppMainEvent::InitWindow`] and [`AndroidAppMainEvent::TerminateWindow`]
+/// events.
+pub fn native_window() -> RwLockReadGuard<'static, Option<NativeWindow>> {
+    NATIVE_WINDOW.read().unwrap()
+}
+
+// Rust doesn't give us a clean way to directly export symbols from C/C++
+// so we rename the C/C++ symbols and re-export this entrypoint from
+// Rust...
+//
+// https://github.com/rust-lang/rfcs/issues/2771
+extern "C" {
+    pub fn ANativeActivity_onCreate_C(
+        activity: *mut std::os::raw::c_void,
+        savedState: *mut ::std::os::raw::c_void,
+        savedStateSize: usize,
+    );
+
+    pub fn android_main();
+}
+
+#[no_mangle]
+unsafe extern "C" fn ANativeActivity_onCreate(
+    activity: *mut std::os::raw::c_void,
+    saved_state: *mut std::os::raw::c_void,
+    saved_state_size: usize,
+) {
+    ANativeActivity_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 as raw::c_int, tag.as_ptr(), msg.as_ptr());
+    }
+}
+
+// This is a spring board between android_native_app_glue and the user's
+// `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);
+                }
+            }
+        }
+    });
+
+    let activity = NonNull::<ndk_sys::ANativeActivity>::new((*app).activity.cast()).unwrap();
+    let activity = NativeActivity::from_ptr(activity);
+    ndk_context::initialize_android_context(activity.vm().cast(), activity.activity().cast());
+
+    let app = AndroidApp::from_ptr(NonNull::new(app).unwrap());
+
+    ANDROID_APP = Some(app.clone());
+
+    android_main();
+
+    ANDROID_APP = None;
+
+    ndk_context::release_android_context();
+}

native-activity/wrapper.h

@@ -0,0 +1 @@
+#include <native-activity/native_app_glue/android_native_app_glue.h>