frameworks/SDL2.git - OutOfOrder git server

			@@ -1,6 +1,6 @@
			/*
			Simple DirectMedia Layer
			Copyright (C) 1997-2014 Sam Lantinga <slouken@libsdl.org>
			Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>

			This software is provided 'as-is', without any express or implied
			warranty. In no event will the authors be held liable for any damages
			@@ -21,263 +21,1063 @@
			#include "../../SDL_internal.h"
			#include "SDL_stdinc.h"
			#include "SDL_assert.h"
			#include "SDL_atomic.h"
			#include "SDL_hints.h"
			#include "SDL_log.h"
			#include "SDL_main.h"
			#include "SDL_timer.h"

			#ifdef __ANDROID__

			#include "SDL_system.h"
			#include "SDL_android.h"
			#include <EGL/egl.h>

			#include "keyinfotable.h"

			#include "../../events/SDL_events_c.h"
			#include "../../video/android/SDL_androidkeyboard.h"
			#include "../../video/android/SDL_androidmouse.h"
			#include "../../video/android/SDL_androidtouch.h"
			#include "../../video/android/SDL_androidvideo.h"
			#include "../../video/android/SDL_androidwindow.h"
			#include "../../joystick/android/SDL_sysjoystick_c.h"
			#include "../../haptic/android/SDL_syshaptic_c.h"

			#include <android/log.h>
			#include <sys/system_properties.h>
			#include <pthread.h>
			#include <sys/types.h>
			#include <unistd.h>
			#define LOG_TAG "SDL_android"
			/* #define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__) */
			/* #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__) */
			#define LOGI(...) do {} while (false)
			#define LOGE(...) do {} while (false)
			#include <dlfcn.h>

			#define SDL_JAVA_PREFIX org_libsdl_app
			#define CONCAT1(prefix, class, function) CONCAT2(prefix, class, function)
			#define CONCAT2(prefix, class, function) Java_ ## prefix ## _ ## class ## _ ## function
			#define SDL_JAVA_INTERFACE(function) CONCAT1(SDL_JAVA_PREFIX, SDLActivity, function)
			#define SDL_JAVA_AUDIO_INTERFACE(function) CONCAT1(SDL_JAVA_PREFIX, SDLAudioManager, function)
			#define SDL_JAVA_CONTROLLER_INTERFACE(function) CONCAT1(SDL_JAVA_PREFIX, SDLControllerManager, function)
			#define SDL_JAVA_INTERFACE_INPUT_CONNECTION(function) CONCAT1(SDL_JAVA_PREFIX, SDLInputConnection, function)

			/* Audio encoding definitions */
			#define ENCODING_PCM_8BIT 3
			#define ENCODING_PCM_16BIT 2
			#define ENCODING_PCM_FLOAT 4

			/* Java class SDLActivity */
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetupJNI)(
			JNIEnv *env, jclass cls);

			JNIEXPORT int JNICALL SDL_JAVA_INTERFACE(nativeRunMain)(
			JNIEnv *env, jclass cls,
			jstring library, jstring function, jobject array);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeDropFile)(
			JNIEnv *env, jclass jcls,
			jstring filename);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetScreenResolution)(
			JNIEnv *env, jclass jcls,
			jint surfaceWidth, jint surfaceHeight,
			jint deviceWidth, jint deviceHeight, jint format, jfloat rate);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeResize)(
			JNIEnv *env, jclass cls);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceCreated)(
			JNIEnv *env, jclass jcls);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceChanged)(
			JNIEnv *env, jclass jcls);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceDestroyed)(
			JNIEnv *env, jclass jcls);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyDown)(
			JNIEnv *env, jclass jcls,
			jint keycode);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyUp)(
			JNIEnv *env, jclass jcls,
			jint keycode);

			JNIEXPORT jboolean JNICALL SDL_JAVA_INTERFACE(onNativeSoftReturnKey)(
			JNIEnv *env, jclass jcls);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyboardFocusLost)(
			JNIEnv *env, jclass jcls);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeTouch)(
			JNIEnv *env, jclass jcls,
			jint touch_device_id_in, jint pointer_finger_id_in,
			jint action, jfloat x, jfloat y, jfloat p);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeMouse)(
			JNIEnv *env, jclass jcls,
			jint button, jint action, jfloat x, jfloat y, jboolean relative);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeAccel)(
			JNIEnv *env, jclass jcls,
			jfloat x, jfloat y, jfloat z);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeClipboardChanged)(
			JNIEnv *env, jclass jcls);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeLowMemory)(
			JNIEnv *env, jclass cls);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSendQuit)(
			JNIEnv *env, jclass cls);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeQuit)(
			JNIEnv *env, jclass cls);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativePause)(
			JNIEnv *env, jclass cls);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeResume)(
			JNIEnv *env, jclass cls);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeFocusChanged)(
			JNIEnv *env, jclass cls, jboolean hasFocus);

			JNIEXPORT jstring JNICALL SDL_JAVA_INTERFACE(nativeGetHint)(
			JNIEnv *env, jclass cls,
			jstring name);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetenv)(
			JNIEnv *env, jclass cls,
			jstring name, jstring value);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeOrientationChanged)(
			JNIEnv *env, jclass cls,
			jint orientation);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeAddTouch)(
			JNIEnv* env, jclass cls,
			jint touchId, jstring name);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativePermissionResult)(
			JNIEnv* env, jclass cls,
			jint requestCode, jboolean result);

			static JNINativeMethod SDLActivity_tab[] = {
			{ "nativeSetupJNI", "()I", SDL_JAVA_INTERFACE(nativeSetupJNI) },
			{ "nativeRunMain", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)I", SDL_JAVA_INTERFACE(nativeRunMain) },
			{ "onNativeDropFile", "(Ljava/lang/String;)V", SDL_JAVA_INTERFACE(onNativeDropFile) },
			{ "nativeSetScreenResolution", "(IIIIIF)V", SDL_JAVA_INTERFACE(nativeSetScreenResolution) },
			{ "onNativeResize", "()V", SDL_JAVA_INTERFACE(onNativeResize) },
			{ "onNativeSurfaceCreated", "()V", SDL_JAVA_INTERFACE(onNativeSurfaceCreated) },
			{ "onNativeSurfaceChanged", "()V", SDL_JAVA_INTERFACE(onNativeSurfaceChanged) },
			{ "onNativeSurfaceDestroyed", "()V", SDL_JAVA_INTERFACE(onNativeSurfaceDestroyed) },
			{ "onNativeKeyDown", "(I)V", SDL_JAVA_INTERFACE(onNativeKeyDown) },
			{ "onNativeKeyUp", "(I)V", SDL_JAVA_INTERFACE(onNativeKeyUp) },
			{ "onNativeSoftReturnKey", "()Z", SDL_JAVA_INTERFACE(onNativeSoftReturnKey) },
			{ "onNativeKeyboardFocusLost", "()V", SDL_JAVA_INTERFACE(onNativeKeyboardFocusLost) },
			{ "onNativeTouch", "(IIIFFF)V", SDL_JAVA_INTERFACE(onNativeTouch) },
			{ "onNativeMouse", "(IIFFZ)V", SDL_JAVA_INTERFACE(onNativeMouse) },
			{ "onNativeAccel", "(FFF)V", SDL_JAVA_INTERFACE(onNativeAccel) },
			{ "onNativeClipboardChanged", "()V", SDL_JAVA_INTERFACE(onNativeClipboardChanged) },
			{ "nativeLowMemory", "()V", SDL_JAVA_INTERFACE(nativeLowMemory) },
			{ "nativeSendQuit", "()V", SDL_JAVA_INTERFACE(nativeSendQuit) },
			{ "nativeQuit", "()V", SDL_JAVA_INTERFACE(nativeQuit) },
			{ "nativePause", "()V", SDL_JAVA_INTERFACE(nativePause) },
			{ "nativeResume", "()V", SDL_JAVA_INTERFACE(nativeResume) },
			{ "nativeFocusChanged", "(Z)V", SDL_JAVA_INTERFACE(nativeFocusChanged) },
			{ "nativeGetHint", "(Ljava/lang/String;)Ljava/lang/String;", SDL_JAVA_INTERFACE(nativeGetHint) },
			{ "nativeSetenv", "(Ljava/lang/String;Ljava/lang/String;)V", SDL_JAVA_INTERFACE(nativeSetenv) },
			{ "onNativeOrientationChanged", "(I)V", SDL_JAVA_INTERFACE(onNativeOrientationChanged) },
			{ "nativeAddTouch", "(ILjava/lang/String;)V", SDL_JAVA_INTERFACE(nativeAddTouch) },
			{ "nativePermissionResult", "(IZ)V", SDL_JAVA_INTERFACE(nativePermissionResult) }
			};

			/* Java class SDLInputConnection */
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeCommitText)(
			JNIEnv *env, jclass cls,
			jstring text, jint newCursorPosition);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeGenerateScancodeForUnichar)(
			JNIEnv *env, jclass cls,
			jchar chUnicode);

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeSetComposingText)(
			JNIEnv *env, jclass cls,
			jstring text, jint newCursorPosition);

			static JNINativeMethod SDLInputConnection_tab[] = {
			{ "nativeCommitText", "(Ljava/lang/String;I)V", SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeCommitText) },
			{ "nativeGenerateScancodeForUnichar", "(C)V", SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeGenerateScancodeForUnichar) },
			{ "nativeSetComposingText", "(Ljava/lang/String;I)V", SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeSetComposingText) }
			};

			/* Java class SDLAudioManager */
			JNIEXPORT void JNICALL SDL_JAVA_AUDIO_INTERFACE(nativeSetupJNI)(
			JNIEnv *env, jclass jcls);

			static JNINativeMethod SDLAudioManager_tab[] = {
			{ "nativeSetupJNI", "()I", SDL_JAVA_AUDIO_INTERFACE(nativeSetupJNI) }
			};

			/* Java class SDLControllerManager */
			JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeSetupJNI)(
			JNIEnv *env, jclass jcls);

			JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativePadDown)(
			JNIEnv *env, jclass jcls,
			jint device_id, jint keycode);

			JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativePadUp)(
			JNIEnv *env, jclass jcls,
			jint device_id, jint keycode);

			JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativeJoy)(
			JNIEnv *env, jclass jcls,
			jint device_id, jint axis, jfloat value);

			JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativeHat)(
			JNIEnv *env, jclass jcls,
			jint device_id, jint hat_id, jint x, jint y);

			JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeAddJoystick)(
			JNIEnv *env, jclass jcls,
			jint device_id, jstring device_name, jstring device_desc, jint vendor_id, jint product_id,
			jboolean is_accelerometer, jint button_mask, jint naxes, jint nhats, jint nballs);

			JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveJoystick)(
			JNIEnv *env, jclass jcls,
			jint device_id);

			JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeAddHaptic)(
			JNIEnv *env, jclass jcls,
			jint device_id, jstring device_name);

			JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveHaptic)(
			JNIEnv *env, jclass jcls,
			jint device_id);

			static JNINativeMethod SDLControllerManager_tab[] = {
			{ "nativeSetupJNI", "()I", SDL_JAVA_CONTROLLER_INTERFACE(nativeSetupJNI) },
			{ "onNativePadDown", "(II)I", SDL_JAVA_CONTROLLER_INTERFACE(onNativePadDown) },
			{ "onNativePadUp", "(II)I", SDL_JAVA_CONTROLLER_INTERFACE(onNativePadUp) },
			{ "onNativeJoy", "(IIF)V", SDL_JAVA_CONTROLLER_INTERFACE(onNativeJoy) },
			{ "onNativeHat", "(IIII)V", SDL_JAVA_CONTROLLER_INTERFACE(onNativeHat) },
			{ "nativeAddJoystick", "(ILjava/lang/String;Ljava/lang/String;IIZIIII)I", SDL_JAVA_CONTROLLER_INTERFACE(nativeAddJoystick) },
			{ "nativeRemoveJoystick", "(I)I", SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveJoystick) },
			{ "nativeAddHaptic", "(ILjava/lang/String;)I", SDL_JAVA_CONTROLLER_INTERFACE(nativeAddHaptic) },
			{ "nativeRemoveHaptic", "(I)I", SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveHaptic) }
			};


			/* Uncomment this to log messages entering and exiting methods in this file */
			/* #define DEBUG_JNI */

			static void Android_JNI_ThreadDestroyed(void*);
			static void checkJNIReady(void);

			/*******************************************************************************
			This file links the Java side of Android with libsdl
			*******************************************************************************/
			#include <jni.h>
			#include <android/log.h>
			#include <stdbool.h>


			/*******************************************************************************
			Globals
			*******************************************************************************/
			static pthread_key_t mThreadKey;
			static JavaVM* mJavaVM;
			static pthread_once_t key_once = PTHREAD_ONCE_INIT;
			static JavaVM *mJavaVM = NULL;

			/* Main activity */
			static jclass mActivityClass;

			/* method signatures */
			static jmethodID midClipboardGetText;
			static jmethodID midClipboardHasText;
			static jmethodID midClipboardSetText;
			static jmethodID midCreateCustomCursor;
			static jmethodID midGetContext;
			static jmethodID midGetDisplayDPI;
			static jmethodID midGetManifestEnvironmentVariables;
			static jmethodID midGetNativeSurface;
			static jmethodID midFlipBuffers;
			static jmethodID midAudioInit;
			static jmethodID midAudioWriteShortBuffer;
			static jmethodID midInitTouch;
			static jmethodID midIsAndroidTV;
			static jmethodID midIsChromebook;
			static jmethodID midIsDeXMode;
			static jmethodID midIsScreenKeyboardShown;
			static jmethodID midIsTablet;
			static jmethodID midManualBackButton;
			static jmethodID midMinimizeWindow;
			static jmethodID midOpenAPKExpansionInputStream;
			static jmethodID midRequestPermission;
			static jmethodID midSendMessage;
			static jmethodID midSetActivityTitle;
			static jmethodID midSetCustomCursor;
			static jmethodID midSetOrientation;
			static jmethodID midSetRelativeMouseEnabled;
			static jmethodID midSetSurfaceViewFormat;
			static jmethodID midSetSystemCursor;
			static jmethodID midSetWindowStyle;
			static jmethodID midShouldMinimizeOnFocusLoss;
			static jmethodID midShowTextInput;
			static jmethodID midSupportsRelativeMouse;

			/* audio manager */
			static jclass mAudioManagerClass;

			/* method signatures */
			static jmethodID midAudioOpen;
			static jmethodID midAudioWriteByteBuffer;
			static jmethodID midAudioQuit;
			static jmethodID midAudioWriteShortBuffer;
			static jmethodID midAudioWriteFloatBuffer;
			static jmethodID midAudioClose;
			static jmethodID midCaptureOpen;
			static jmethodID midCaptureReadByteBuffer;
			static jmethodID midCaptureReadShortBuffer;
			static jmethodID midCaptureReadFloatBuffer;
			static jmethodID midCaptureClose;
			static jmethodID midAudioSetThreadPriority;

			/* controller manager */
			static jclass mControllerManagerClass;

			/* method signatures */
			static jmethodID midPollInputDevices;
			static jmethodID midPollHapticDevices;
			static jmethodID midHapticRun;
			static jmethodID midHapticStop;

			/* Accelerometer data storage */
			static SDL_DisplayOrientation displayOrientation;
			static float fLastAccelerometer[3];
			static bool bHasNewData;
			static SDL_bool bHasNewData;

			static SDL_bool bHasEnvironmentVariables;

			static SDL_atomic_t bPermissionRequestPending;
			static SDL_bool bPermissionRequestResult;

			/*******************************************************************************
			Functions called by JNI
			*******************************************************************************/

			/* Library init */
			jint JNI_OnLoad(JavaVM* vm, void* reserved)
			/* From http://developer.android.com/guide/practices/jni.html
			* All threads are Linux threads, scheduled by the kernel.
			* They're usually started from managed code (using Thread.start), but they can also be created elsewhere and then
			* attached to the JavaVM. For example, a thread started with pthread_create can be attached with the
			* JNI AttachCurrentThread or AttachCurrentThreadAsDaemon functions. Until a thread is attached, it has no JNIEnv,
			* and cannot make JNI calls.
			* Attaching a natively-created thread causes a java.lang.Thread object to be constructed and added to the "main"
			* ThreadGroup, making it visible to the debugger. Calling AttachCurrentThread on an already-attached thread
			* is a no-op.
			* Note: You can call this function any number of times for the same thread, there's no harm in it
			*/

			/* From http://developer.android.com/guide/practices/jni.html
			* Threads attached through JNI must call DetachCurrentThread before they exit. If coding this directly is awkward,
			* in Android 2.0 (Eclair) and higher you can use pthread_key_create to define a destructor function that will be
			* called before the thread exits, and call DetachCurrentThread from there. (Use that key with pthread_setspecific
			* to store the JNIEnv in thread-local-storage; that way it'll be passed into your destructor as the argument.)
			* Note: The destructor is not called unless the stored value is != NULL
			* Note: You can call this function any number of times for the same thread, there's no harm in it
			* (except for some lost CPU cycles)
			*/

			/* Set local storage value */
			static int
			Android_JNI_SetEnv(JNIEnv *env) {
			int status = pthread_setspecific(mThreadKey, env);
			if (status < 0) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "Failed pthread_setspecific() in Android_JNI_SetEnv() (err=%d)", status);
			}
			return status;
			}

			/* Get local storage value */
			JNIEnv* Android_JNI_GetEnv(void)
			{
			/* Get JNIEnv from the Thread local storage */
			JNIEnv *env = pthread_getspecific(mThreadKey);
			if (env == NULL) {
			/* If it fails, try to attach ! (e.g the thread isn't created with SDL_CreateThread() */
			int status;

			/* There should be a JVM */
			if (mJavaVM == NULL) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "Failed, there is no JavaVM");
			return NULL;
			}

			/* Attach the current thread to the JVM and get a JNIEnv.
			* It will be detached by pthread_create destructor 'Android_JNI_ThreadDestroyed' */
			status = (*mJavaVM)->AttachCurrentThread(mJavaVM, &env, NULL);
			if (status < 0) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "Failed to attach current thread (err=%d)", status);
			return NULL;
			}

			/* Save JNIEnv into the Thread local storage */
			if (Android_JNI_SetEnv(env) < 0) {
			return NULL;
			}
			}

			return env;
			}

			/* Set up an external thread for using JNI with Android_JNI_GetEnv() */
			int Android_JNI_SetupThread(void)
			{
			JNIEnv *env;
			int status;

			/* There should be a JVM */
			if (mJavaVM == NULL) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "Failed, there is no JavaVM");
			return 0;
			}

			/* Attach the current thread to the JVM and get a JNIEnv.
			* It will be detached by pthread_create destructor 'Android_JNI_ThreadDestroyed' */
			status = (*mJavaVM)->AttachCurrentThread(mJavaVM, &env, NULL);
			if (status < 0) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "Failed to attach current thread (err=%d)", status);
			return 0;
			}

			/* Save JNIEnv into the Thread local storage */
			if (Android_JNI_SetEnv(env) < 0) {
			return 0;
			}

			return 1;
			}

			/* Destructor called for each thread where mThreadKey is not NULL */
			static void
			Android_JNI_ThreadDestroyed(void *value)
			{
			/* The thread is being destroyed, detach it from the Java VM and set the mThreadKey value to NULL as required */
			JNIEnv env = (JNIEnv ) value;
			if (env != NULL) {
			(*mJavaVM)->DetachCurrentThread(mJavaVM);
			Android_JNI_SetEnv(NULL);
			}
			}

			/* Creation of local storage mThreadKey */
			static void
			Android_JNI_CreateKey(void)
			{
			int status = pthread_key_create(&mThreadKey, Android_JNI_ThreadDestroyed);
			if (status < 0) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "Error initializing mThreadKey with pthread_key_create() (err=%d)", status);
			}
			}

			static void
			Android_JNI_CreateKey_once(void)
			{
			int status = pthread_once(&key_once, Android_JNI_CreateKey);
			if (status < 0) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "Error initializing mThreadKey with pthread_once() (err=%d)", status);
			}
			}

			static void
			register_methods(JNIEnv env, const char classname, JNINativeMethod *methods, int nb)
			{
			jclass clazz = (*env)->FindClass(env, classname);
			if (clazz == NULL \|\| (*env)->RegisterNatives(env, clazz, methods, nb) < 0) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "Failed to register methods of %s", classname);
			return;
			}
			}

			/* Library init */
			JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM vm, void reserved)
			{
			mJavaVM = vm;
			LOGI("JNI_OnLoad called");
			if ((mJavaVM)->GetEnv(mJavaVM, (void*) &env, JNI_VERSION_1_4) != JNI_OK) {
			LOGE("Failed to get the environment using GetEnv()");
			return -1;
			JNIEnv *env = NULL;

			if ((mJavaVM)->GetEnv(mJavaVM, (void *)&env, JNI_VERSION_1_4) != JNI_OK) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "Failed to get JNI Env");
			return JNI_VERSION_1_4;
			}
			/*
			* Create mThreadKey so we can keep track of the JNIEnv assigned to each thread
			* Refer to http://developer.android.com/guide/practices/design/jni.html for the rationale behind this
			*/
			if (pthread_key_create(&mThreadKey, Android_JNI_ThreadDestroyed) != 0) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "Error initializing pthread key");
			}
			Android_JNI_SetupThread();

			register_methods(env, "org/libsdl/app/SDLActivity", SDLActivity_tab, SDL_arraysize(SDLActivity_tab));
			register_methods(env, "org/libsdl/app/SDLInputConnection", SDLInputConnection_tab, SDL_arraysize(SDLInputConnection_tab));
			register_methods(env, "org/libsdl/app/SDLAudioManager", SDLAudioManager_tab, SDL_arraysize(SDLAudioManager_tab));
			register_methods(env, "org/libsdl/app/SDLControllerManager", SDLControllerManager_tab, SDL_arraysize(SDLControllerManager_tab));

			return JNI_VERSION_1_4;
			}

			/* Called before SDL_main() to initialize JNI bindings */
			void SDL_Android_Init(JNIEnv* mEnv, jclass cls)
			void checkJNIReady(void)
			{
			__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL_Android_Init()");

			Android_JNI_SetupThread();

			mActivityClass = (jclass)((*mEnv)->NewGlobalRef(mEnv, cls));

			midGetNativeSurface = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
			"getNativeSurface","()Landroid/view/Surface;");
			midFlipBuffers = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
			"flipBuffers","()V");
			midAudioInit = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
			"audioInit", "(IZZI)I");
			midAudioWriteShortBuffer = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
			"audioWriteShortBuffer", "([S)V");
			midAudioWriteByteBuffer = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
			"audioWriteByteBuffer", "([B)V");
			midAudioQuit = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
			"audioQuit", "()V");
			midPollInputDevices = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
			"pollInputDevices", "()V");

			bHasNewData = false;

			if(!midGetNativeSurface \|\| !midFlipBuffers \|\| !midAudioInit \|\|
			!midAudioWriteShortBuffer \|\| !midAudioWriteByteBuffer \|\| !midAudioQuit \|\| !midPollInputDevices) {
			__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL: Couldn't locate Java callbacks, check that they're named and typed correctly");
			if (!mActivityClass \|\| !mAudioManagerClass \|\| !mControllerManagerClass) {
			/* We aren't fully initialized, let's just return. */
			return;
			}
			__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL_Android_Init() finished!");

			SDL_SetMainReady();
			}

			/* Activity initialization -- called before SDL_main() to initialize JNI bindings */
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetupJNI)(JNIEnv *env, jclass cls)
			{
			__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativeSetupJNI()");

			/*
			* Create mThreadKey so we can keep track of the JNIEnv assigned to each thread
			* Refer to http://developer.android.com/guide/practices/design/jni.html for the rationale behind this
			*/
			Android_JNI_CreateKey_once();

			/* Save JNIEnv of SDLActivity */
			Android_JNI_SetEnv(env);

			if (mJavaVM == NULL) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "failed to found a JavaVM");
			}

			/* Use a mutex to prevent concurrency issues between Java Activity and Native thread code, when using 'Android_Window'.
			* (Eg. Java sending Touch events, while native code is destroying the main SDL_Window. )
			*/
			if (Android_ActivityMutex == NULL) {
			Android_ActivityMutex = SDL_CreateMutex(); /* Could this be created twice if onCreate() is called a second time ? */
			}

			if (Android_ActivityMutex == NULL) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "failed to create Android_ActivityMutex mutex");
			}


			Android_PauseSem = SDL_CreateSemaphore(0);
			if (Android_PauseSem == NULL) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "failed to create Android_PauseSem semaphore");
			}

			Android_ResumeSem = SDL_CreateSemaphore(0);
			if (Android_ResumeSem == NULL) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "failed to create Android_ResumeSem semaphore");
			}

			mActivityClass = (jclass)((*env)->NewGlobalRef(env, cls));

			midClipboardGetText = (*env)->GetStaticMethodID(env, mActivityClass, "clipboardGetText", "()Ljava/lang/String;");
			midClipboardHasText = (*env)->GetStaticMethodID(env, mActivityClass, "clipboardHasText", "()Z");
			midClipboardSetText = (*env)->GetStaticMethodID(env, mActivityClass, "clipboardSetText", "(Ljava/lang/String;)V");
			midCreateCustomCursor = (*env)->GetStaticMethodID(env, mActivityClass, "createCustomCursor", "([IIIII)I");
			midGetContext = (*env)->GetStaticMethodID(env, mActivityClass, "getContext","()Landroid/content/Context;");
			midGetDisplayDPI = (*env)->GetStaticMethodID(env, mActivityClass, "getDisplayDPI", "()Landroid/util/DisplayMetrics;");
			midGetManifestEnvironmentVariables = (*env)->GetStaticMethodID(env, mActivityClass, "getManifestEnvironmentVariables", "()Z");
			midGetNativeSurface = (*env)->GetStaticMethodID(env, mActivityClass, "getNativeSurface","()Landroid/view/Surface;");
			midInitTouch = (*env)->GetStaticMethodID(env, mActivityClass, "initTouch", "()V");
			midIsAndroidTV = (*env)->GetStaticMethodID(env, mActivityClass, "isAndroidTV","()Z");
			midIsChromebook = (*env)->GetStaticMethodID(env, mActivityClass, "isChromebook", "()Z");
			midIsDeXMode = (*env)->GetStaticMethodID(env, mActivityClass, "isDeXMode", "()Z");
			midIsScreenKeyboardShown = (*env)->GetStaticMethodID(env, mActivityClass, "isScreenKeyboardShown","()Z");
			midIsTablet = (*env)->GetStaticMethodID(env, mActivityClass, "isTablet", "()Z");
			midManualBackButton = (*env)->GetStaticMethodID(env, mActivityClass, "manualBackButton", "()V");
			midMinimizeWindow = (*env)->GetStaticMethodID(env, mActivityClass, "minimizeWindow","()V");
			midOpenAPKExpansionInputStream = (*env)->GetStaticMethodID(env, mActivityClass, "openAPKExpansionInputStream", "(Ljava/lang/String;)Ljava/io/InputStream;");
			midRequestPermission = (*env)->GetStaticMethodID(env, mActivityClass, "requestPermission", "(Ljava/lang/String;I)V");
			midSendMessage = (*env)->GetStaticMethodID(env, mActivityClass, "sendMessage", "(II)Z");
			midSetActivityTitle = (*env)->GetStaticMethodID(env, mActivityClass, "setActivityTitle","(Ljava/lang/String;)Z");
			midSetCustomCursor = (*env)->GetStaticMethodID(env, mActivityClass, "setCustomCursor", "(I)Z");
			midSetOrientation = (*env)->GetStaticMethodID(env, mActivityClass, "setOrientation","(IIZLjava/lang/String;)V");
			midSetRelativeMouseEnabled = (*env)->GetStaticMethodID(env, mActivityClass, "setRelativeMouseEnabled", "(Z)Z");
			midSetSurfaceViewFormat = (*env)->GetStaticMethodID(env, mActivityClass, "setSurfaceViewFormat","(I)V");
			midSetSystemCursor = (*env)->GetStaticMethodID(env, mActivityClass, "setSystemCursor", "(I)Z");
			midSetWindowStyle = (*env)->GetStaticMethodID(env, mActivityClass, "setWindowStyle","(Z)V");
			midShouldMinimizeOnFocusLoss = (*env)->GetStaticMethodID(env, mActivityClass, "shouldMinimizeOnFocusLoss","()Z");
			midShowTextInput = (*env)->GetStaticMethodID(env, mActivityClass, "showTextInput", "(IIII)Z");
			midSupportsRelativeMouse = (*env)->GetStaticMethodID(env, mActivityClass, "supportsRelativeMouse", "()Z");

			if (!midClipboardGetText \|\|
			!midClipboardHasText \|\|
			!midClipboardSetText \|\|
			!midCreateCustomCursor \|\|
			!midGetContext \|\|
			!midGetDisplayDPI \|\|
			!midGetManifestEnvironmentVariables \|\|
			!midGetNativeSurface \|\|
			!midInitTouch \|\|
			!midIsAndroidTV \|\|
			!midIsChromebook \|\|
			!midIsDeXMode \|\|
			!midIsScreenKeyboardShown \|\|
			!midIsTablet \|\|
			!midManualBackButton \|\|
			!midMinimizeWindow \|\|
			!midOpenAPKExpansionInputStream \|\|
			!midRequestPermission \|\|
			!midSendMessage \|\|
			!midSetActivityTitle \|\|
			!midSetCustomCursor \|\|
			!midSetOrientation \|\|
			!midSetRelativeMouseEnabled \|\|
			!midSetSurfaceViewFormat \|\|
			!midSetSystemCursor \|\|
			!midSetWindowStyle \|\|
			!midShouldMinimizeOnFocusLoss \|\|
			!midShowTextInput \|\|
			!midSupportsRelativeMouse) {
			__android_log_print(ANDROID_LOG_WARN, "SDL", "Missing some Java callbacks, do you have the latest version of SDLActivity.java?");
			}

			checkJNIReady();
			}

			/* Audio initialization -- called before SDL_main() to initialize JNI bindings */
			JNIEXPORT void JNICALL SDL_JAVA_AUDIO_INTERFACE(nativeSetupJNI)(JNIEnv *env, jclass cls)
			{
			__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "AUDIO nativeSetupJNI()");

			mAudioManagerClass = (jclass)((*env)->NewGlobalRef(env, cls));

			midAudioOpen = (*env)->GetStaticMethodID(env, mAudioManagerClass,
			"audioOpen", "(IIII)[I");
			midAudioWriteByteBuffer = (*env)->GetStaticMethodID(env, mAudioManagerClass,
			"audioWriteByteBuffer", "([B)V");
			midAudioWriteShortBuffer = (*env)->GetStaticMethodID(env, mAudioManagerClass,
			"audioWriteShortBuffer", "([S)V");
			midAudioWriteFloatBuffer = (*env)->GetStaticMethodID(env, mAudioManagerClass,
			"audioWriteFloatBuffer", "([F)V");
			midAudioClose = (*env)->GetStaticMethodID(env, mAudioManagerClass,
			"audioClose", "()V");
			midCaptureOpen = (*env)->GetStaticMethodID(env, mAudioManagerClass,
			"captureOpen", "(IIII)[I");
			midCaptureReadByteBuffer = (*env)->GetStaticMethodID(env, mAudioManagerClass,
			"captureReadByteBuffer", "([BZ)I");
			midCaptureReadShortBuffer = (*env)->GetStaticMethodID(env, mAudioManagerClass,
			"captureReadShortBuffer", "([SZ)I");
			midCaptureReadFloatBuffer = (*env)->GetStaticMethodID(env, mAudioManagerClass,
			"captureReadFloatBuffer", "([FZ)I");
			midCaptureClose = (*env)->GetStaticMethodID(env, mAudioManagerClass,
			"captureClose", "()V");
			midAudioSetThreadPriority = (*env)->GetStaticMethodID(env, mAudioManagerClass,
			"audioSetThreadPriority", "(ZI)V");

			if (!midAudioOpen \|\| !midAudioWriteByteBuffer \|\| !midAudioWriteShortBuffer \|\| !midAudioWriteFloatBuffer \|\| !midAudioClose \|\|
			!midCaptureOpen \|\| !midCaptureReadByteBuffer \|\| !midCaptureReadShortBuffer \|\| !midCaptureReadFloatBuffer \|\| !midCaptureClose \|\| !midAudioSetThreadPriority) {
			__android_log_print(ANDROID_LOG_WARN, "SDL", "Missing some Java callbacks, do you have the latest version of SDLAudioManager.java?");
			}

			checkJNIReady();
			}

			/* Controller initialization -- called before SDL_main() to initialize JNI bindings */
			JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeSetupJNI)(JNIEnv *env, jclass cls)
			{
			__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "CONTROLLER nativeSetupJNI()");

			mControllerManagerClass = (jclass)((*env)->NewGlobalRef(env, cls));

			midPollInputDevices = (*env)->GetStaticMethodID(env, mControllerManagerClass,
			"pollInputDevices", "()V");
			midPollHapticDevices = (*env)->GetStaticMethodID(env, mControllerManagerClass,
			"pollHapticDevices", "()V");
			midHapticRun = (*env)->GetStaticMethodID(env, mControllerManagerClass,
			"hapticRun", "(IFI)V");
			midHapticStop = (*env)->GetStaticMethodID(env, mControllerManagerClass,
			"hapticStop", "(I)V");

			if (!midPollInputDevices \|\| !midPollHapticDevices \|\| !midHapticRun \|\| !midHapticStop) {
			__android_log_print(ANDROID_LOG_WARN, "SDL", "Missing some Java callbacks, do you have the latest version of SDLControllerManager.java?");
			}

			checkJNIReady();
			}

			/* SDL main function prototype */
			typedef int (SDL_main_func)(int argc, char argv[]);

			/* Start up the SDL app */
			JNIEXPORT int JNICALL SDL_JAVA_INTERFACE(nativeRunMain)(JNIEnv *env, jclass cls, jstring library, jstring function, jobject array)
			{
			int status = -1;
			const char *library_file;
			void *library_handle;

			__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativeRunMain()");

			/* Save JNIEnv of SDLThread */
			Android_JNI_SetEnv(env);

			library_file = (*env)->GetStringUTFChars(env, library, NULL);
			library_handle = dlopen(library_file, RTLD_GLOBAL);

			if (!library_handle) {
			/* When deploying android app bundle format uncompressed native libs may not extract from apk to filesystem.
			In this case we should use lib name without path. https://bugzilla.libsdl.org/show_bug.cgi?id=4739 */
			const char *library_name = SDL_strrchr(library_file, '/');
			if (library_name && *library_name) {
			library_name += 1;
			library_handle = dlopen(library_name, RTLD_GLOBAL);
			}
			}

			if (library_handle) {
			const char *function_name;
			SDL_main_func SDL_main;

			function_name = (*env)->GetStringUTFChars(env, function, NULL);
			SDL_main = (SDL_main_func)dlsym(library_handle, function_name);
			if (SDL_main) {
			int i;
			int argc;
			int len;
			char **argv;
			SDL_bool isstack;

			/* Prepare the arguments. */
			len = (*env)->GetArrayLength(env, array);
			argv = SDL_small_alloc(char , 1 + len + 1, &isstack); / !!! FIXME: check for NULL */
			argc = 0;
			/* Use the name "app_process" so PHYSFS_platformCalcBaseDir() works.
			https://bitbucket.org/MartinFelis/love-android-sdl2/issue/23/release-build-crash-on-start
			*/
			argv[argc++] = SDL_strdup("app_process");
			for (i = 0; i < len; ++i) {
			const char *utf;
			char *arg = NULL;
			jstring string = (*env)->GetObjectArrayElement(env, array, i);
			if (string) {
			utf = (*env)->GetStringUTFChars(env, string, 0);
			if (utf) {
			arg = SDL_strdup(utf);
			(*env)->ReleaseStringUTFChars(env, string, utf);
			}
			(*env)->DeleteLocalRef(env, string);
			}
			if (!arg) {
			arg = SDL_strdup("");
			}
			argv[argc++] = arg;
			}
			argv[argc] = NULL;


			/* Run the application. */
			status = SDL_main(argc, argv);

			/* Release the arguments. */
			for (i = 0; i < argc; ++i) {
			SDL_free(argv[i]);
			}
			SDL_small_free(argv, isstack);

			} else {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "nativeRunMain(): Couldn't find function %s in library %s", function_name, library_file);
			}
			(*env)->ReleaseStringUTFChars(env, function, function_name);

			dlclose(library_handle);

			} else {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "nativeRunMain(): Couldn't load library %s", library_file);
			}
			(*env)->ReleaseStringUTFChars(env, library, library_file);

			/* This is a Java thread, it doesn't need to be Detached from the JVM.
			* Set to mThreadKey value to NULL not to call pthread_create destructor 'Android_JNI_ThreadDestroyed' */
			Android_JNI_SetEnv(NULL);

			/* Do not issue an exit or the whole application will terminate instead of just the SDL thread */
			/* exit(status); */

			return status;
			}

			/* Drop file */
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeDropFile)(
			JNIEnv *env, jclass jcls,
			jstring filename)
			{
			const char path = (env)->GetStringUTFChars(env, filename, NULL);
			SDL_SendDropFile(NULL, path);
			(*env)->ReleaseStringUTFChars(env, filename, path);
			SDL_SendDropComplete(NULL);
			}

			/* Lock / Unlock Mutex */
			void Android_ActivityMutex_Lock() {
			SDL_LockMutex(Android_ActivityMutex);
			}

			void Android_ActivityMutex_Unlock() {
			SDL_UnlockMutex(Android_ActivityMutex);
			}

			/* Lock the Mutex when the Activity is in its 'Running' state */
			void Android_ActivityMutex_Lock_Running() {
			int pauseSignaled = 0;
			int resumeSignaled = 0;

			retry:

			SDL_LockMutex(Android_ActivityMutex);

			pauseSignaled = SDL_SemValue(Android_PauseSem);
			resumeSignaled = SDL_SemValue(Android_ResumeSem);

			if (pauseSignaled > resumeSignaled) {
			SDL_UnlockMutex(Android_ActivityMutex);
			SDL_Delay(50);
			goto retry;
			}
			}

			/* Set screen resolution */
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetScreenResolution)(
			JNIEnv *env, jclass jcls,
			jint surfaceWidth, jint surfaceHeight,
			jint deviceWidth, jint deviceHeight, jint format, jfloat rate)
			{
			SDL_LockMutex(Android_ActivityMutex);

			Android_SetScreenResolution(surfaceWidth, surfaceHeight, deviceWidth, deviceHeight, format, rate);

			SDL_UnlockMutex(Android_ActivityMutex);
			}

			/* Resize */
			void Java_org_libsdl_app_SDLActivity_onNativeResize(
			JNIEnv* env, jclass jcls,
			jint width, jint height, jint format)
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeResize)(
			JNIEnv *env, jclass jcls)
			{
			Android_SetScreenResolution(width, height, format);
			SDL_LockMutex(Android_ActivityMutex);

			if (Android_Window)
			{
			Android_SendResize(Android_Window);
			}

			SDL_UnlockMutex(Android_ActivityMutex);
			}

			// Paddown
			int Java_org_libsdl_app_SDLActivity_onNativePadDown(
			JNIEnv* env, jclass jcls,
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeOrientationChanged)(
			JNIEnv *env, jclass jcls,
			jint orientation)
			{
			SDL_LockMutex(Android_ActivityMutex);

			displayOrientation = (SDL_DisplayOrientation)orientation;

			if (Android_Window)
			{
			SDL_VideoDisplay *display = SDL_GetDisplay(0);
			SDL_SendDisplayEvent(display, SDL_DISPLAYEVENT_ORIENTATION, orientation);
			}

			SDL_UnlockMutex(Android_ActivityMutex);
			}

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeAddTouch)(
			JNIEnv* env, jclass cls,
			jint touchId, jstring name)
			{
			const char utfname = (env)->GetStringUTFChars(env, name, NULL);

			SDL_AddTouch((SDL_TouchID) touchId, SDL_TOUCH_DEVICE_DIRECT, utfname);

			(*env)->ReleaseStringUTFChars(env, name, utfname);
			}

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativePermissionResult)(
			JNIEnv* env, jclass cls,
			jint requestCode, jboolean result)
			{
			bPermissionRequestResult = result;
			SDL_AtomicSet(&bPermissionRequestPending, SDL_FALSE);
			}

			/* Paddown */
			JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativePadDown)(
			JNIEnv *env, jclass jcls,
			jint device_id, jint keycode)
			{
			return Android_OnPadDown(device_id, keycode);
			}

			// Padup
			int Java_org_libsdl_app_SDLActivity_onNativePadUp(
			JNIEnv* env, jclass jcls,
			jint device_id, jint keycode)
			/* Padup */
			JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativePadUp)(
			JNIEnv *env, jclass jcls,
			jint device_id, jint keycode)
			{
			return Android_OnPadUp(device_id, keycode);
			}

			/* Joy */
			void Java_org_libsdl_app_SDLActivity_onNativeJoy(
			JNIEnv* env, jclass jcls,
			JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativeJoy)(
			JNIEnv *env, jclass jcls,
			jint device_id, jint axis, jfloat value)
			{
			Android_OnJoy(device_id, axis, value);
			}

			/* POV Hat */
			void Java_org_libsdl_app_SDLActivity_onNativeHat(
			JNIEnv* env, jclass jcls,
			JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativeHat)(
			JNIEnv *env, jclass jcls,
			jint device_id, jint hat_id, jint x, jint y)
			{
			Android_OnHat(device_id, hat_id, x, y);
			}


			int Java_org_libsdl_app_SDLActivity_nativeAddJoystick(
			JNIEnv* env, jclass jcls,
			jint device_id, jstring device_name, jint is_accelerometer,
			jint nbuttons, jint naxes, jint nhats, jint nballs)
			JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeAddJoystick)(
			JNIEnv *env, jclass jcls,
			jint device_id, jstring device_name, jstring device_desc,
			jint vendor_id, jint product_id, jboolean is_accelerometer,
			jint button_mask, jint naxes, jint nhats, jint nballs)
			{
			int retval;
			const char name = (env)->GetStringUTFChars(env, device_name, NULL);
			const char desc = (env)->GetStringUTFChars(env, device_desc, NULL);

			retval = Android_AddJoystick(device_id, name, (SDL_bool) is_accelerometer, nbuttons, naxes, nhats, nballs);
			retval = Android_AddJoystick(device_id, name, desc, vendor_id, product_id, is_accelerometer ? SDL_TRUE : SDL_FALSE, button_mask, naxes, nhats, nballs);

			(*env)->ReleaseStringUTFChars(env, device_name, name);

			(*env)->ReleaseStringUTFChars(env, device_desc, desc);

			return retval;
			}

			int Java_org_libsdl_app_SDLActivity_nativeRemoveJoystick(
			JNIEnv* env, jclass jcls, jint device_id)
			JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveJoystick)(
			JNIEnv *env, jclass jcls,
			jint device_id)
			{
			return Android_RemoveJoystick(device_id);
			}


			/* Surface Created */
			void Java_org_libsdl_app_SDLActivity_onNativeSurfaceChanged(JNIEnv* env, jclass jcls)
			JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeAddHaptic)(
			JNIEnv *env, jclass jcls, jint device_id, jstring device_name)
			{
			SDL_WindowData *data;
			SDL_VideoDevice *_this;
			int retval;
			const char name = (env)->GetStringUTFChars(env, device_name, NULL);

			if (Android_Window == NULL \|\| Android_Window->driverdata == NULL ) {
			return;
			}

			_this = SDL_GetVideoDevice();
			data = (SDL_WindowData *) Android_Window->driverdata;

			/* If the surface has been previously destroyed by onNativeSurfaceDestroyed, recreate it here */
			if (data->egl_surface == EGL_NO_SURFACE) {
			if(data->native_window) {
			ANativeWindow_release(data->native_window);
			}
			retval = Android_AddHaptic(device_id, name);

			(*env)->ReleaseStringUTFChars(env, device_name, name);

			return retval;
			}

			JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveHaptic)(
			JNIEnv *env, jclass jcls, jint device_id)
			{
			return Android_RemoveHaptic(device_id);
			}

			/* Called from surfaceCreated() */
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceCreated)(JNIEnv *env, jclass jcls)
			{
			SDL_LockMutex(Android_ActivityMutex);

			if (Android_Window)
			{
			SDL_WindowData data = (SDL_WindowData ) Android_Window->driverdata;

			data->native_window = Android_JNI_GetNativeWindow();
			data->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) data->native_window);
			if (data->native_window == NULL) {
			SDL_SetError("Could not fetch native window from UI thread");
			}
			}

			/* GL Context handling is done in the event loop because this function is run from the Java thread */


			SDL_UnlockMutex(Android_ActivityMutex);
			}

			/* Surface Destroyed */
			void Java_org_libsdl_app_SDLActivity_onNativeSurfaceDestroyed(JNIEnv* env, jclass jcls)
			/* Called from surfaceChanged() */
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceChanged)(JNIEnv *env, jclass jcls)
			{
			/* We have to clear the current context and destroy the egl surface here
			* Otherwise there's BAD_NATIVE_WINDOW errors coming from eglCreateWindowSurface on resume
			* Ref: http://stackoverflow.com/questions/8762589/eglcreatewindowsurface-on-ics-and-switching-from-2d-to-3d
			*/
			SDL_WindowData *data;
			SDL_VideoDevice *_this;

			if (Android_Window == NULL \|\| Android_Window->driverdata == NULL ) {
			return;
			}

			_this = SDL_GetVideoDevice();
			data = (SDL_WindowData *) Android_Window->driverdata;

			if (data->egl_surface != EGL_NO_SURFACE) {
			SDL_EGL_MakeCurrent(_this, NULL, NULL);
			SDL_EGL_DestroySurface(_this, data->egl_surface);
			data->egl_surface = EGL_NO_SURFACE;
			}

			/* GL Context handling is done in the event loop because this function is run from the Java thread */
			SDL_LockMutex(Android_ActivityMutex);

			if (Android_Window)
			{
			SDL_VideoDevice *_this = SDL_GetVideoDevice();
			SDL_WindowData data = (SDL_WindowData ) Android_Window->driverdata;

			/* If the surface has been previously destroyed by onNativeSurfaceDestroyed, recreate it here */
			if (data->egl_surface == EGL_NO_SURFACE) {
			data->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) data->native_window);
			}

			/* GL Context handling is done in the event loop because this function is run from the Java thread */
			}

			SDL_UnlockMutex(Android_ActivityMutex);
			}

			void Java_org_libsdl_app_SDLActivity_nativeFlipBuffers(JNIEnv* env, jclass jcls)
			/* Called from surfaceDestroyed() */
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceDestroyed)(JNIEnv *env, jclass jcls)
			{
			SDL_GL_SwapWindow(Android_Window);
			int nb_attempt = 50;

			retry:

			SDL_LockMutex(Android_ActivityMutex);

			if (Android_Window)
			{
			SDL_VideoDevice *_this = SDL_GetVideoDevice();
			SDL_WindowData data = (SDL_WindowData ) Android_Window->driverdata;

			/* Wait for Main thread being paused and context un-activated to release 'egl_surface' */
			if (! data->backup_done) {
			nb_attempt -= 1;
			if (nb_attempt == 0) {
			SDL_SetError("Try to release egl_surface with context probably still active");
			} else {
			SDL_UnlockMutex(Android_ActivityMutex);
			SDL_Delay(10);
			goto retry;
			}
			}

			if (data->egl_surface != EGL_NO_SURFACE) {
			SDL_EGL_DestroySurface(_this, data->egl_surface);
			data->egl_surface = EGL_NO_SURFACE;
			}

			if (data->native_window) {
			ANativeWindow_release(data->native_window);
			data->native_window = NULL;
			}

			/* GL Context handling is done in the event loop because this function is run from the Java thread */
			}

			SDL_UnlockMutex(Android_ActivityMutex);
			}

			/* Keydown */
			void Java_org_libsdl_app_SDLActivity_onNativeKeyDown(
			JNIEnv* env, jclass jcls, jint keycode)
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyDown)(
			JNIEnv *env, jclass jcls,
			jint keycode)
			{
			Android_OnKeyDown(keycode);
			}

			/* Keyup */
			void Java_org_libsdl_app_SDLActivity_onNativeKeyUp(
			JNIEnv* env, jclass jcls, jint keycode)
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyUp)(
			JNIEnv *env, jclass jcls,
			jint keycode)
			{
			Android_OnKeyUp(keycode);
			}

			/* Virtual keyboard return key might stop text input */
			JNIEXPORT jboolean JNICALL SDL_JAVA_INTERFACE(onNativeSoftReturnKey)(
			JNIEnv *env, jclass jcls)
			{
			if (SDL_GetHintBoolean(SDL_HINT_RETURN_KEY_HIDES_IME, SDL_FALSE)) {
			SDL_StopTextInput();
			return JNI_TRUE;
			}
			return JNI_FALSE;
			}

			/* Keyboard Focus Lost */
			void Java_org_libsdl_app_SDLActivity_onNativeKeyboardFocusLost(
			JNIEnv* env, jclass jcls)
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyboardFocusLost)(
			JNIEnv *env, jclass jcls)
			{
			/* Calling SDL_StopTextInput will take care of hiding the keyboard and cleaning up the DummyText widget */
			SDL_StopTextInput();
			@@ -285,86 +1085,143 @@


			/* Touch */
			void Java_org_libsdl_app_SDLActivity_onNativeTouch(
			JNIEnv* env, jclass jcls,
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeTouch)(
			JNIEnv *env, jclass jcls,
			jint touch_device_id_in, jint pointer_finger_id_in,
			jint action, jfloat x, jfloat y, jfloat p)
			{
			Android_OnTouch(touch_device_id_in, pointer_finger_id_in, action, x, y, p);
			SDL_LockMutex(Android_ActivityMutex);

			Android_OnTouch(Android_Window, touch_device_id_in, pointer_finger_id_in, action, x, y, p);

			SDL_UnlockMutex(Android_ActivityMutex);
			}

			/* Mouse */
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeMouse)(
			JNIEnv *env, jclass jcls,
			jint button, jint action, jfloat x, jfloat y, jboolean relative)
			{
			SDL_LockMutex(Android_ActivityMutex);

			Android_OnMouse(Android_Window, button, action, x, y, relative);

			SDL_UnlockMutex(Android_ActivityMutex);
			}

			/* Accelerometer */
			void Java_org_libsdl_app_SDLActivity_onNativeAccel(
			JNIEnv* env, jclass jcls,
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeAccel)(
			JNIEnv *env, jclass jcls,
			jfloat x, jfloat y, jfloat z)
			{
			fLastAccelerometer[0] = x;
			fLastAccelerometer[1] = y;
			fLastAccelerometer[2] = z;
			bHasNewData = true;
			bHasNewData = SDL_TRUE;
			}

			/* Clipboard */
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeClipboardChanged)(
			JNIEnv *env, jclass jcls)
			{
			SDL_SendClipboardUpdate();
			}

			/* Low memory */
			void Java_org_libsdl_app_SDLActivity_nativeLowMemory(
			JNIEnv* env, jclass cls)
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeLowMemory)(
			JNIEnv *env, jclass cls)
			{
			SDL_SendAppEvent(SDL_APP_LOWMEMORY);
			}

			/* Quit */
			void Java_org_libsdl_app_SDLActivity_nativeQuit(
			JNIEnv* env, jclass cls)
			/* Send Quit event to "SDLThread" thread */
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSendQuit)(
			JNIEnv *env, jclass cls)
			{
			/* Discard previous events. The user should have handled state storage
			* in SDL_APP_WILLENTERBACKGROUND. After nativeQuit() is called, no
			* in SDL_APP_WILLENTERBACKGROUND. After nativeSendQuit() is called, no
			* events other than SDL_QUIT and SDL_APP_TERMINATING should fire */
			SDL_FlushEvents(SDL_FIRSTEVENT, SDL_LASTEVENT);
			/* Inject a SDL_QUIT event */
			SDL_SendQuit();
			SDL_SendAppEvent(SDL_APP_TERMINATING);
			/* Robustness: clear any pending Pause */
			while (SDL_SemTryWait(Android_PauseSem) == 0) {
			/* empty */
			}
			/* Resume the event loop so that the app can catch SDL_QUIT which
			* should now be the top event in the event queue. */
			if (!SDL_SemValue(Android_ResumeSem)) SDL_SemPost(Android_ResumeSem);
			SDL_SemPost(Android_ResumeSem);
			}

			/* Activity ends */
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeQuit)(
			JNIEnv *env, jclass cls)
			{
			const char *str;

			if (Android_ActivityMutex) {
			SDL_DestroyMutex(Android_ActivityMutex);
			Android_ActivityMutex = NULL;
			}

			if (Android_PauseSem) {
			SDL_DestroySemaphore(Android_PauseSem);
			Android_PauseSem = NULL;
			}

			if (Android_ResumeSem) {
			SDL_DestroySemaphore(Android_ResumeSem);
			Android_ResumeSem = NULL;
			}

			str = SDL_GetError();
			if (str && str[0]) {
			__android_log_print(ANDROID_LOG_ERROR, "SDL", "SDLActivity thread ends (error=%s)", str);
			} else {
			__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "SDLActivity thread ends");
			}
			}

			/* Pause */
			void Java_org_libsdl_app_SDLActivity_nativePause(
			JNIEnv* env, jclass cls)
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativePause)(
			JNIEnv *env, jclass cls)
			{
			__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativePause()");
			if (Android_Window) {
			SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_FOCUS_LOST, 0, 0);
			SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
			SDL_SendAppEvent(SDL_APP_WILLENTERBACKGROUND);
			SDL_SendAppEvent(SDL_APP_DIDENTERBACKGROUND);

			/* After sending the relevant events, signal the pause semaphore
			* so the event loop knows to pause and (optionally) block itself */
			if (!SDL_SemValue(Android_PauseSem)) SDL_SemPost(Android_PauseSem);
			}

			/* Signal the pause semaphore so the event loop knows to pause and (optionally) block itself.
			* Sometimes 2 pauses can be queued (eg pause/resume/pause), so it's always increased. */
			SDL_SemPost(Android_PauseSem);
			}

			/* Resume */
			void Java_org_libsdl_app_SDLActivity_nativeResume(
			JNIEnv* env, jclass cls)
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeResume)(
			JNIEnv *env, jclass cls)
			{
			__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativeResume()");

			if (Android_Window) {
			SDL_SendAppEvent(SDL_APP_WILLENTERFOREGROUND);
			SDL_SendAppEvent(SDL_APP_DIDENTERFOREGROUND);
			SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_FOCUS_GAINED, 0, 0);
			SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_RESTORED, 0, 0);
			/* Signal the resume semaphore so the event loop knows to resume and restore the GL Context
			* We can't restore the GL Context here because it needs to be done on the SDL main thread
			* and this function will be called from the Java thread instead.
			*/
			if (!SDL_SemValue(Android_ResumeSem)) SDL_SemPost(Android_ResumeSem);
			}
			/* Signal the resume semaphore so the event loop knows to resume and restore the GL Context
			* We can't restore the GL Context here because it needs to be done on the SDL main thread
			* and this function will be called from the Java thread instead.
			*/
			SDL_SemPost(Android_ResumeSem);
			}

			void Java_org_libsdl_app_SDLInputConnection_nativeCommitText(
			JNIEnv* env, jclass cls,
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeFocusChanged)(
			JNIEnv *env, jclass cls, jboolean hasFocus)
			{
			SDL_LockMutex(Android_ActivityMutex);

			if (Android_Window) {
			__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativeFocusChanged()");
			SDL_SendWindowEvent(Android_Window, (hasFocus ? SDL_WINDOWEVENT_FOCUS_GAINED : SDL_WINDOWEVENT_FOCUS_LOST), 0, 0);
			}

			SDL_UnlockMutex(Android_ActivityMutex);
			}

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeCommitText)(
			JNIEnv *env, jclass cls,
			jstring text, jint newCursorPosition)
			{
			const char utftext = (env)->GetStringUTFChars(env, text, NULL);
			@@ -374,8 +1231,37 @@
			(*env)->ReleaseStringUTFChars(env, text, utftext);
			}

			void Java_org_libsdl_app_SDLInputConnection_nativeSetComposingText(
			JNIEnv* env, jclass cls,
			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeGenerateScancodeForUnichar)(
			JNIEnv *env, jclass cls,
			jchar chUnicode)
			{
			SDL_Scancode code = SDL_SCANCODE_UNKNOWN;
			uint16_t mod = 0;

			/* We do not care about bigger than 127. */
			if (chUnicode < 127) {
			AndroidKeyInfo info = unicharToAndroidKeyInfoTable[chUnicode];
			code = info.code;
			mod = info.mod;
			}

			if (mod & KMOD_SHIFT) {
			/* If character uses shift, press shift down */
			SDL_SendKeyboardKey(SDL_PRESSED, SDL_SCANCODE_LSHIFT);
			}

			/* send a keydown and keyup even for the character */
			SDL_SendKeyboardKey(SDL_PRESSED, code);
			SDL_SendKeyboardKey(SDL_RELEASED, code);

			if (mod & KMOD_SHIFT) {
			/* If character uses shift, press shift back up */
			SDL_SendKeyboardKey(SDL_RELEASED, SDL_SCANCODE_LSHIFT);
			}
			}

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeSetComposingText)(
			JNIEnv *env, jclass cls,
			jstring text, jint newCursorPosition)
			{
			const char utftext = (env)->GetStringUTFChars(env, text, NULL);
			@@ -385,13 +1271,38 @@
			(*env)->ReleaseStringUTFChars(env, text, utftext);
			}

			JNIEXPORT jstring JNICALL SDL_JAVA_INTERFACE(nativeGetHint)(
			JNIEnv *env, jclass cls,
			jstring name)
			{
			const char utfname = (env)->GetStringUTFChars(env, name, NULL);
			const char *hint = SDL_GetHint(utfname);

			jstring result = (*env)->NewStringUTF(env, hint);
			(*env)->ReleaseStringUTFChars(env, name, utfname);

			return result;
			}

			JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetenv)(
			JNIEnv *env, jclass cls,
			jstring name, jstring value)
			{
			const char utfname = (env)->GetStringUTFChars(env, name, NULL);
			const char utfvalue = (env)->GetStringUTFChars(env, value, NULL);

			SDL_setenv(utfname, utfvalue, 1);

			(*env)->ReleaseStringUTFChars(env, name, utfname);
			(*env)->ReleaseStringUTFChars(env, value, utfvalue);

			}

			/*******************************************************************************
			Functions called by SDL into Java
			*******************************************************************************/

			static int s_active = 0;
			static SDL_atomic_t s_active;
			struct LocalReferenceHolder
			{
			JNIEnv *m_env;
			@@ -416,7 +1327,7 @@
			SDL_SetError("Failed to allocate enough JVM local references");
			return SDL_FALSE;
			}
			++s_active;
			SDL_AtomicIncRef(&s_active);
			refholder->m_env = env;
			return SDL_TRUE;
			}
			@@ -427,46 +1338,81 @@
			SDL_Log("Leaving function %s", refholder->m_func);
			#endif
			if (refholder->m_env) {
			JNIEnv* env = refholder->m_env;
			JNIEnv *env = refholder->m_env;
			(*env)->PopLocalFrame(env, NULL);
			--s_active;
			SDL_AtomicDecRef(&s_active);
			}
			}

			static SDL_bool LocalReferenceHolder_IsActive()
			{
			return s_active > 0;
			}

			ANativeWindow* Android_JNI_GetNativeWindow(void)
			{
			ANativeWindow* anw;
			ANativeWindow *anw = NULL;
			jobject s;
			JNIEnv *env = Android_JNI_GetEnv();

			s = (*env)->CallStaticObjectMethod(env, mActivityClass, midGetNativeSurface);
			anw = ANativeWindow_fromSurface(env, s);
			(*env)->DeleteLocalRef(env, s);

			if (s) {
			anw = ANativeWindow_fromSurface(env, s);
			(*env)->DeleteLocalRef(env, s);
			}

			return anw;
			}

			void Android_JNI_SwapWindow()
			void Android_JNI_SetSurfaceViewFormat(int format)
			{
			JNIEnv *mEnv = Android_JNI_GetEnv();
			(*mEnv)->CallStaticVoidMethod(mEnv, mActivityClass, midFlipBuffers);
			JNIEnv *env = Android_JNI_GetEnv();
			int new_format = 0;

			/* Format from android/native_window.h,
			* convert to temporary arbitrary values,
			* then to java PixelFormat */
			if (format == WINDOW_FORMAT_RGBA_8888) {
			new_format = 1;
			} else if (format == WINDOW_FORMAT_RGBX_8888) {
			new_format = 2;
			} else if (format == WINDOW_FORMAT_RGB_565) {
			/* Default */
			new_format = 0;
			}

			(*env)->CallStaticVoidMethod(env, mActivityClass, midSetSurfaceViewFormat, new_format);
			}

			void Android_JNI_SetActivityTitle(const char *title)
			{
			jmethodID mid;
			JNIEnv *mEnv = Android_JNI_GetEnv();
			mid = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,"setActivityTitle","(Ljava/lang/String;)Z");
			if (mid) {
			jstring jtitle = (jstring)((*mEnv)->NewStringUTF(mEnv, title));
			(*mEnv)->CallStaticBooleanMethod(mEnv, mActivityClass, mid, jtitle);
			(*mEnv)->DeleteLocalRef(mEnv, jtitle);
			}
			JNIEnv *env = Android_JNI_GetEnv();

			jstring jtitle = (*env)->NewStringUTF(env, title);
			(*env)->CallStaticBooleanMethod(env, mActivityClass, midSetActivityTitle, jtitle);
			(*env)->DeleteLocalRef(env, jtitle);
			}

			void Android_JNI_SetWindowStyle(SDL_bool fullscreen)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			(*env)->CallStaticVoidMethod(env, mActivityClass, midSetWindowStyle, fullscreen ? 1 : 0);
			}

			void Android_JNI_SetOrientation(int w, int h, int resizable, const char *hint)
			{
			JNIEnv *env = Android_JNI_GetEnv();

			jstring jhint = (*env)->NewStringUTF(env, (hint ? hint : ""));
			(*env)->CallStaticVoidMethod(env, mActivityClass, midSetOrientation, w, h, (resizable? 1 : 0), jhint);
			(*env)->DeleteLocalRef(env, jhint);
			}

			void Android_JNI_MinizeWindow()
			{
			JNIEnv *env = Android_JNI_GetEnv();
			(*env)->CallStaticVoidMethod(env, mActivityClass, midMinimizeWindow);
			}

			SDL_bool Android_JNI_ShouldMinimizeOnFocusLoss()
			{
			JNIEnv *env = Android_JNI_GetEnv();
			return (*env)->CallStaticBooleanMethod(env, mActivityClass, midShouldMinimizeOnFocusLoss);
			}

			SDL_bool Android_JNI_GetAccelerometerValues(float values[3])
			@@ -478,207 +1424,380 @@
			for (i = 0; i < 3; ++i) {
			values[i] = fLastAccelerometer[i];
			}
			bHasNewData = false;
			bHasNewData = SDL_FALSE;
			retval = SDL_TRUE;
			}

			return retval;
			}

			static void Android_JNI_ThreadDestroyed(void* value)
			{
			/* The thread is being destroyed, detach it from the Java VM and set the mThreadKey value to NULL as required */
			JNIEnv env = (JNIEnv) value;
			if (env != NULL) {
			(*mJavaVM)->DetachCurrentThread(mJavaVM);
			pthread_setspecific(mThreadKey, NULL);
			}
			}

			JNIEnv* Android_JNI_GetEnv(void)
			{
			/* From http://developer.android.com/guide/practices/jni.html
			* All threads are Linux threads, scheduled by the kernel.
			* They're usually started from managed code (using Thread.start), but they can also be created elsewhere and then
			* attached to the JavaVM. For example, a thread started with pthread_create can be attached with the
			* JNI AttachCurrentThread or AttachCurrentThreadAsDaemon functions. Until a thread is attached, it has no JNIEnv,
			* and cannot make JNI calls.
			* Attaching a natively-created thread causes a java.lang.Thread object to be constructed and added to the "main"
			* ThreadGroup, making it visible to the debugger. Calling AttachCurrentThread on an already-attached thread
			* is a no-op.
			* Note: You can call this function any number of times for the same thread, there's no harm in it
			*/

			JNIEnv *env;
			int status = (*mJavaVM)->AttachCurrentThread(mJavaVM, &env, NULL);
			if(status < 0) {
			LOGE("failed to attach current thread");
			return 0;
			}

			/* From http://developer.android.com/guide/practices/jni.html
			* Threads attached through JNI must call DetachCurrentThread before they exit. If coding this directly is awkward,
			* in Android 2.0 (Eclair) and higher you can use pthread_key_create to define a destructor function that will be
			* called before the thread exits, and call DetachCurrentThread from there. (Use that key with pthread_setspecific
			* to store the JNIEnv in thread-local-storage; that way it'll be passed into your destructor as the argument.)
			* Note: The destructor is not called unless the stored value is != NULL
			* Note: You can call this function any number of times for the same thread, there's no harm in it
			* (except for some lost CPU cycles)
			*/
			pthread_setspecific(mThreadKey, (void*) env);

			return env;
			}

			int Android_JNI_SetupThread(void)
			{
			Android_JNI_GetEnv();
			return 1;
			}

			/*
			* Audio support
			*/
			static jboolean audioBuffer16Bit = JNI_FALSE;
			static jboolean audioBufferStereo = JNI_FALSE;
			static int audioBufferFormat = 0;
			static jobject audioBuffer = NULL;
			static void* audioBufferPinned = NULL;
			static void *audioBufferPinned = NULL;
			static int captureBufferFormat = 0;
			static jobject captureBuffer = NULL;

			int Android_JNI_OpenAudioDevice(int sampleRate, int is16Bit, int channelCount, int desiredBufferFrames)
			int Android_JNI_OpenAudioDevice(int iscapture, SDL_AudioSpec *spec)
			{
			int audioBufferFrames;
			int audioformat;
			jobject jbufobj = NULL;
			jobject result;
			int *resultElements;
			jboolean isCopy;

			JNIEnv *env = Android_JNI_GetEnv();

			if (!env) {
			LOGE("callback_handler: failed to attach current thread");
			switch (spec->format) {
			case AUDIO_U8:
			audioformat = ENCODING_PCM_8BIT;
			break;
			case AUDIO_S16:
			audioformat = ENCODING_PCM_16BIT;
			break;
			case AUDIO_F32:
			audioformat = ENCODING_PCM_FLOAT;
			break;
			default:
			return SDL_SetError("Unsupported audio format: 0x%x", spec->format);
			}
			Android_JNI_SetupThread();

			__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "SDL audio: opening device");
			audioBuffer16Bit = is16Bit;
			audioBufferStereo = channelCount > 1;

			if ((*env)->CallStaticIntMethod(env, mActivityClass, midAudioInit, sampleRate, audioBuffer16Bit, audioBufferStereo, desiredBufferFrames) != 0) {
			/* Error during audio initialization */
			__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: error on AudioTrack initialization!");
			return 0;
			if (iscapture) {
			__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "SDL audio: opening device for capture");
			result = (*env)->CallStaticObjectMethod(env, mAudioManagerClass, midCaptureOpen, spec->freq, audioformat, spec->channels, spec->samples);
			} else {
			__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "SDL audio: opening device for output");
			result = (*env)->CallStaticObjectMethod(env, mAudioManagerClass, midAudioOpen, spec->freq, audioformat, spec->channels, spec->samples);
			}
			if (result == NULL) {
			/* Error during audio initialization, error printed from Java */
			return SDL_SetError("Java-side initialization failed");
			}

			if ((*env)->GetArrayLength(env, (jintArray)result) != 4) {
			return SDL_SetError("Unexpected results from Java, expected 4, got %d", (*env)->GetArrayLength(env, (jintArray)result));
			}
			isCopy = JNI_FALSE;
			resultElements = (*env)->GetIntArrayElements(env, (jintArray)result, &isCopy);
			spec->freq = resultElements[0];
			audioformat = resultElements[1];
			switch (audioformat) {
			case ENCODING_PCM_8BIT:
			spec->format = AUDIO_U8;
			break;
			case ENCODING_PCM_16BIT:
			spec->format = AUDIO_S16;
			break;
			case ENCODING_PCM_FLOAT:
			spec->format = AUDIO_F32;
			break;
			default:
			return SDL_SetError("Unexpected audio format from Java: %d\n", audioformat);
			}
			spec->channels = resultElements[2];
			spec->samples = resultElements[3];
			(*env)->ReleaseIntArrayElements(env, (jintArray)result, resultElements, JNI_ABORT);
			(*env)->DeleteLocalRef(env, result);

			/* Allocating the audio buffer from the Java side and passing it as the return value for audioInit no longer works on
			* Android >= 4.2 due to a "stale global reference" error. So now we allocate this buffer directly from this side. */

			if (is16Bit) {
			jshortArray audioBufferLocal = (env)->NewShortArray(env, desiredBufferFrames (audioBufferStereo ? 2 : 1));
			if (audioBufferLocal) {
			audioBuffer = (*env)->NewGlobalRef(env, audioBufferLocal);
			(*env)->DeleteLocalRef(env, audioBufferLocal);
			switch (audioformat) {
			case ENCODING_PCM_8BIT:
			{
			jbyteArray audioBufferLocal = (env)->NewByteArray(env, spec->samples spec->channels);
			if (audioBufferLocal) {
			jbufobj = (*env)->NewGlobalRef(env, audioBufferLocal);
			(*env)->DeleteLocalRef(env, audioBufferLocal);
			}
			}
			}
			else {
			jbyteArray audioBufferLocal = (env)->NewByteArray(env, desiredBufferFrames (audioBufferStereo ? 2 : 1));
			if (audioBufferLocal) {
			audioBuffer = (*env)->NewGlobalRef(env, audioBufferLocal);
			(*env)->DeleteLocalRef(env, audioBufferLocal);
			break;
			case ENCODING_PCM_16BIT:
			{
			jshortArray audioBufferLocal = (env)->NewShortArray(env, spec->samples spec->channels);
			if (audioBufferLocal) {
			jbufobj = (*env)->NewGlobalRef(env, audioBufferLocal);
			(*env)->DeleteLocalRef(env, audioBufferLocal);
			}
			}
			break;
			case ENCODING_PCM_FLOAT:
			{
			jfloatArray audioBufferLocal = (env)->NewFloatArray(env, spec->samples spec->channels);
			if (audioBufferLocal) {
			jbufobj = (*env)->NewGlobalRef(env, audioBufferLocal);
			(*env)->DeleteLocalRef(env, audioBufferLocal);
			}
			}
			break;
			default:
			return SDL_SetError("Unexpected audio format from Java: %d\n", audioformat);
			}

			if (audioBuffer == NULL) {
			__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: could not allocate an audio buffer!");
			return 0;
			if (jbufobj == NULL) {
			__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: could not allocate an audio buffer");
			return SDL_OutOfMemory();
			}

			jboolean isCopy = JNI_FALSE;
			if (audioBuffer16Bit) {
			audioBufferPinned = (*env)->GetShortArrayElements(env, (jshortArray)audioBuffer, &isCopy);
			audioBufferFrames = (*env)->GetArrayLength(env, (jshortArray)audioBuffer);
			if (iscapture) {
			captureBufferFormat = audioformat;
			captureBuffer = jbufobj;
			} else {
			audioBufferPinned = (*env)->GetByteArrayElements(env, (jbyteArray)audioBuffer, &isCopy);
			audioBufferFrames = (*env)->GetArrayLength(env, (jbyteArray)audioBuffer);
			}
			if (audioBufferStereo) {
			audioBufferFrames /= 2;
			audioBufferFormat = audioformat;
			audioBuffer = jbufobj;
			}

			return audioBufferFrames;
			if (!iscapture) {
			isCopy = JNI_FALSE;

			switch (audioformat) {
			case ENCODING_PCM_8BIT:
			audioBufferPinned = (*env)->GetByteArrayElements(env, (jbyteArray)audioBuffer, &isCopy);
			break;
			case ENCODING_PCM_16BIT:
			audioBufferPinned = (*env)->GetShortArrayElements(env, (jshortArray)audioBuffer, &isCopy);
			break;
			case ENCODING_PCM_FLOAT:
			audioBufferPinned = (*env)->GetFloatArrayElements(env, (jfloatArray)audioBuffer, &isCopy);
			break;
			default:
			return SDL_SetError("Unexpected audio format from Java: %d\n", audioformat);
			}
			}
			return 0;
			}

			void * Android_JNI_GetAudioBuffer()
			SDL_DisplayOrientation Android_JNI_GetDisplayOrientation(void)
			{
			return displayOrientation;
			}

			int Android_JNI_GetDisplayDPI(float ddpi, float xdpi, float *ydpi)
			{
			JNIEnv *env = Android_JNI_GetEnv();

			jobject jDisplayObj = (*env)->CallStaticObjectMethod(env, mActivityClass, midGetDisplayDPI);
			jclass jDisplayClass = (*env)->GetObjectClass(env, jDisplayObj);

			jfieldID fidXdpi = (*env)->GetFieldID(env, jDisplayClass, "xdpi", "F");
			jfieldID fidYdpi = (*env)->GetFieldID(env, jDisplayClass, "ydpi", "F");
			jfieldID fidDdpi = (*env)->GetFieldID(env, jDisplayClass, "densityDpi", "I");

			float nativeXdpi = (*env)->GetFloatField(env, jDisplayObj, fidXdpi);
			float nativeYdpi = (*env)->GetFloatField(env, jDisplayObj, fidYdpi);
			int nativeDdpi = (*env)->GetIntField(env, jDisplayObj, fidDdpi);


			(*env)->DeleteLocalRef(env, jDisplayObj);
			(*env)->DeleteLocalRef(env, jDisplayClass);

			if (ddpi) {
			*ddpi = (float)nativeDdpi;
			}
			if (xdpi) {
			*xdpi = nativeXdpi;
			}
			if (ydpi) {
			*ydpi = nativeYdpi;
			}

			return 0;
			}

			void * Android_JNI_GetAudioBuffer(void)
			{
			return audioBufferPinned;
			}

			void Android_JNI_WriteAudioBuffer()
			void Android_JNI_WriteAudioBuffer(void)
			{
			JNIEnv *mAudioEnv = Android_JNI_GetEnv();
			JNIEnv *env = Android_JNI_GetEnv();

			if (audioBuffer16Bit) {
			(mAudioEnv)->ReleaseShortArrayElements(mAudioEnv, (jshortArray)audioBuffer, (jshort )audioBufferPinned, JNI_COMMIT);
			(*mAudioEnv)->CallStaticVoidMethod(mAudioEnv, mActivityClass, midAudioWriteShortBuffer, (jshortArray)audioBuffer);
			} else {
			(mAudioEnv)->ReleaseByteArrayElements(mAudioEnv, (jbyteArray)audioBuffer, (jbyte )audioBufferPinned, JNI_COMMIT);
			(*mAudioEnv)->CallStaticVoidMethod(mAudioEnv, mActivityClass, midAudioWriteByteBuffer, (jbyteArray)audioBuffer);
			switch (audioBufferFormat) {
			case ENCODING_PCM_8BIT:
			(env)->ReleaseByteArrayElements(env, (jbyteArray)audioBuffer, (jbyte )audioBufferPinned, JNI_COMMIT);
			(*env)->CallStaticVoidMethod(env, mAudioManagerClass, midAudioWriteByteBuffer, (jbyteArray)audioBuffer);
			break;
			case ENCODING_PCM_16BIT:
			(env)->ReleaseShortArrayElements(env, (jshortArray)audioBuffer, (jshort )audioBufferPinned, JNI_COMMIT);
			(*env)->CallStaticVoidMethod(env, mAudioManagerClass, midAudioWriteShortBuffer, (jshortArray)audioBuffer);
			break;
			case ENCODING_PCM_FLOAT:
			(env)->ReleaseFloatArrayElements(env, (jfloatArray)audioBuffer, (jfloat )audioBufferPinned, JNI_COMMIT);
			(*env)->CallStaticVoidMethod(env, mAudioManagerClass, midAudioWriteFloatBuffer, (jfloatArray)audioBuffer);
			break;
			default:
			__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: unhandled audio buffer format");
			break;
			}

			/* JNI_COMMIT means the changes are committed to the VM but the buffer remains pinned */
			}

			void Android_JNI_CloseAudioDevice()
			int Android_JNI_CaptureAudioBuffer(void *buffer, int buflen)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			jboolean isCopy = JNI_FALSE;
			jint br = -1;

			switch (captureBufferFormat) {
			case ENCODING_PCM_8BIT:
			SDL_assert((*env)->GetArrayLength(env, (jshortArray)captureBuffer) == buflen);
			br = (*env)->CallStaticIntMethod(env, mAudioManagerClass, midCaptureReadByteBuffer, (jbyteArray)captureBuffer, JNI_TRUE);
			if (br > 0) {
			jbyte ptr = (env)->GetByteArrayElements(env, (jbyteArray)captureBuffer, &isCopy);
			SDL_memcpy(buffer, ptr, br);
			(*env)->ReleaseByteArrayElements(env, (jbyteArray)captureBuffer, ptr, JNI_ABORT);
			}
			break;
			case ENCODING_PCM_16BIT:
			SDL_assert((*env)->GetArrayLength(env, (jshortArray)captureBuffer) == (buflen / sizeof(Sint16)));
			br = (*env)->CallStaticIntMethod(env, mAudioManagerClass, midCaptureReadShortBuffer, (jshortArray)captureBuffer, JNI_TRUE);
			if (br > 0) {
			jshort ptr = (env)->GetShortArrayElements(env, (jshortArray)captureBuffer, &isCopy);
			br *= sizeof(Sint16);
			SDL_memcpy(buffer, ptr, br);
			(*env)->ReleaseShortArrayElements(env, (jshortArray)captureBuffer, ptr, JNI_ABORT);
			}
			break;
			case ENCODING_PCM_FLOAT:
			SDL_assert((*env)->GetArrayLength(env, (jfloatArray)captureBuffer) == (buflen / sizeof(float)));
			br = (*env)->CallStaticIntMethod(env, mAudioManagerClass, midCaptureReadFloatBuffer, (jfloatArray)captureBuffer, JNI_TRUE);
			if (br > 0) {
			jfloat ptr = (env)->GetFloatArrayElements(env, (jfloatArray)captureBuffer, &isCopy);
			br *= sizeof(float);
			SDL_memcpy(buffer, ptr, br);
			(*env)->ReleaseFloatArrayElements(env, (jfloatArray)captureBuffer, ptr, JNI_ABORT);
			}
			break;
			default:
			__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: unhandled capture buffer format");
			break;
			}
			return br;
			}

			void Android_JNI_FlushCapturedAudio(void)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			#if 0 /* !!! FIXME: this needs API 23, or it'll do blocking reads and never end. */
			switch (captureBufferFormat) {
			case ENCODING_PCM_8BIT:
			{
			const jint len = (*env)->GetArrayLength(env, (jbyteArray)captureBuffer);
			while ((env)->CallStaticIntMethod(env, mActivityClass, midCaptureReadByteBuffer, (jbyteArray)captureBuffer, JNI_FALSE) == len) { / spin */ }
			}
			break;
			case ENCODING_PCM_16BIT:
			{
			const jint len = (*env)->GetArrayLength(env, (jshortArray)captureBuffer);
			while ((env)->CallStaticIntMethod(env, mActivityClass, midCaptureReadShortBuffer, (jshortArray)captureBuffer, JNI_FALSE) == len) { / spin */ }
			}
			break;
			case ENCODING_PCM_FLOAT:
			{
			const jint len = (*env)->GetArrayLength(env, (jfloatArray)captureBuffer);
			while ((env)->CallStaticIntMethod(env, mActivityClass, midCaptureReadFloatBuffer, (jfloatArray)captureBuffer, JNI_FALSE) == len) { / spin */ }
			}
			break;
			default:
			__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: flushing unhandled capture buffer format");
			break;
			}
			#else
			switch (captureBufferFormat) {
			case ENCODING_PCM_8BIT:
			(*env)->CallStaticIntMethod(env, mAudioManagerClass, midCaptureReadByteBuffer, (jbyteArray)captureBuffer, JNI_FALSE);
			break;
			case ENCODING_PCM_16BIT:
			(*env)->CallStaticIntMethod(env, mAudioManagerClass, midCaptureReadShortBuffer, (jshortArray)captureBuffer, JNI_FALSE);
			break;
			case ENCODING_PCM_FLOAT:
			(*env)->CallStaticIntMethod(env, mAudioManagerClass, midCaptureReadFloatBuffer, (jfloatArray)captureBuffer, JNI_FALSE);
			break;
			default:
			__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: flushing unhandled capture buffer format");
			break;
			}
			#endif
			}

			void Android_JNI_CloseAudioDevice(const int iscapture)
			{
			JNIEnv *env = Android_JNI_GetEnv();

			(*env)->CallStaticVoidMethod(env, mActivityClass, midAudioQuit);

			if (audioBuffer) {
			(*env)->DeleteGlobalRef(env, audioBuffer);
			audioBuffer = NULL;
			audioBufferPinned = NULL;
			if (iscapture) {
			(*env)->CallStaticVoidMethod(env, mAudioManagerClass, midCaptureClose);
			if (captureBuffer) {
			(*env)->DeleteGlobalRef(env, captureBuffer);
			captureBuffer = NULL;
			}
			} else {
			(*env)->CallStaticVoidMethod(env, mAudioManagerClass, midAudioClose);
			if (audioBuffer) {
			(*env)->DeleteGlobalRef(env, audioBuffer);
			audioBuffer = NULL;
			audioBufferPinned = NULL;
			}
			}
			}

			void Android_JNI_AudioSetThreadPriority(int iscapture, int device_id)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			(*env)->CallStaticVoidMethod(env, mAudioManagerClass, midAudioSetThreadPriority, iscapture, device_id);
			}

			/* Test for an exception and call SDL_SetError with its detail if one occurs */
			/* If the parameter silent is truthy then SDL_SetError() will not be called. */
			static bool Android_JNI_ExceptionOccurred(bool silent)
			static SDL_bool Android_JNI_ExceptionOccurred(SDL_bool silent)
			{
			SDL_assert(LocalReferenceHolder_IsActive());
			JNIEnv *mEnv = Android_JNI_GetEnv();
			JNIEnv *env = Android_JNI_GetEnv();
			jthrowable exception;

			jthrowable exception = (*mEnv)->ExceptionOccurred(mEnv);
			/* Detect mismatch LocalReferenceHolder_Init/Cleanup */
			SDL_assert(SDL_AtomicGet(&s_active) > 0);

			exception = (*env)->ExceptionOccurred(env);
			if (exception != NULL) {
			jmethodID mid;

			/* Until this happens most JNI operations have undefined behaviour */
			(*mEnv)->ExceptionClear(mEnv);
			(*env)->ExceptionClear(env);

			if (!silent) {
			jclass exceptionClass = (*mEnv)->GetObjectClass(mEnv, exception);
			jclass classClass = (*mEnv)->FindClass(mEnv, "java/lang/Class");
			jclass exceptionClass = (*env)->GetObjectClass(env, exception);
			jclass classClass = (*env)->FindClass(env, "java/lang/Class");
			jstring exceptionName;
			const char *exceptionNameUTF8;
			jstring exceptionMessage;

			mid = (*mEnv)->GetMethodID(mEnv, classClass, "getName", "()Ljava/lang/String;");
			jstring exceptionName = (jstring)(*mEnv)->CallObjectMethod(mEnv, exceptionClass, mid);
			const char* exceptionNameUTF8 = (*mEnv)->GetStringUTFChars(mEnv, exceptionName, 0);
			mid = (*env)->GetMethodID(env, classClass, "getName", "()Ljava/lang/String;");
			exceptionName = (jstring)(*env)->CallObjectMethod(env, exceptionClass, mid);
			exceptionNameUTF8 = (*env)->GetStringUTFChars(env, exceptionName, 0);

			mid = (*mEnv)->GetMethodID(mEnv, exceptionClass, "getMessage", "()Ljava/lang/String;");
			jstring exceptionMessage = (jstring)(*mEnv)->CallObjectMethod(mEnv, exception, mid);
			mid = (*env)->GetMethodID(env, exceptionClass, "getMessage", "()Ljava/lang/String;");
			exceptionMessage = (jstring)(*env)->CallObjectMethod(env, exception, mid);

			if (exceptionMessage != NULL) {
			const char* exceptionMessageUTF8 = (*mEnv)->GetStringUTFChars(mEnv, exceptionMessage, 0);
			const char exceptionMessageUTF8 = (env)->GetStringUTFChars(env, exceptionMessage, 0);
			SDL_SetError("%s: %s", exceptionNameUTF8, exceptionMessageUTF8);
			(*mEnv)->ReleaseStringUTFChars(mEnv, exceptionMessage, exceptionMessageUTF8);
			(*env)->ReleaseStringUTFChars(env, exceptionMessage, exceptionMessageUTF8);
			} else {
			SDL_SetError("%s", exceptionNameUTF8);
			}

			(*mEnv)->ReleaseStringUTFChars(mEnv, exceptionName, exceptionNameUTF8);
			(*env)->ReleaseStringUTFChars(env, exceptionName, exceptionNameUTF8);
			}

			return true;
			return SDL_TRUE;
			}

			return false;
			return SDL_FALSE;
			}

			static int Internal_Android_JNI_FileOpen(SDL_RWops* ctx)
			static int Internal_Android_JNI_FileOpen(SDL_RWops *ctx)
			{
			struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);

			@@ -695,8 +1814,8 @@
			jclass fdCls;
			jfieldID descriptor;

			JNIEnv *mEnv = Android_JNI_GetEnv();
			if (!LocalReferenceHolder_Init(&refs, mEnv)) {
			JNIEnv *env = Android_JNI_GetEnv();
			if (!LocalReferenceHolder_Init(&refs, env)) {
			goto failure;
			}

			@@ -704,48 +1823,45 @@
			ctx->hidden.androidio.position = 0;

			/* context = SDLActivity.getContext(); */
			mid = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
			"getContext","()Landroid/content/Context;");
			context = (*mEnv)->CallStaticObjectMethod(mEnv, mActivityClass, mid);

			context = (*env)->CallStaticObjectMethod(env, mActivityClass, midGetContext);

			/* assetManager = context.getAssets(); */
			mid = (mEnv)->GetMethodID(mEnv, (mEnv)->GetObjectClass(mEnv, context),
			mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, context),
			"getAssets", "()Landroid/content/res/AssetManager;");
			assetManager = (*mEnv)->CallObjectMethod(mEnv, context, mid);
			assetManager = (*env)->CallObjectMethod(env, context, mid);

			/* First let's try opening the file to obtain an AssetFileDescriptor.
			* This method reads the files directly from the APKs using standard *nix calls
			*/
			mid = (mEnv)->GetMethodID(mEnv, (mEnv)->GetObjectClass(mEnv, assetManager), "openFd", "(Ljava/lang/String;)Landroid/content/res/AssetFileDescriptor;");
			inputStream = (*mEnv)->CallObjectMethod(mEnv, assetManager, mid, fileNameJString);
			if (Android_JNI_ExceptionOccurred(true)) {
			mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, assetManager), "openFd", "(Ljava/lang/String;)Landroid/content/res/AssetFileDescriptor;");
			inputStream = (*env)->CallObjectMethod(env, assetManager, mid, fileNameJString);
			if (Android_JNI_ExceptionOccurred(SDL_TRUE)) {
			goto fallback;
			}

			mid = (mEnv)->GetMethodID(mEnv, (mEnv)->GetObjectClass(mEnv, inputStream), "getStartOffset", "()J");
			ctx->hidden.androidio.offset = (*mEnv)->CallLongMethod(mEnv, inputStream, mid);
			if (Android_JNI_ExceptionOccurred(true)) {
			mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, inputStream), "getStartOffset", "()J");
			ctx->hidden.androidio.offset = (long)(*env)->CallLongMethod(env, inputStream, mid);
			if (Android_JNI_ExceptionOccurred(SDL_TRUE)) {
			goto fallback;
			}

			mid = (mEnv)->GetMethodID(mEnv, (mEnv)->GetObjectClass(mEnv, inputStream), "getDeclaredLength", "()J");
			ctx->hidden.androidio.size = (*mEnv)->CallLongMethod(mEnv, inputStream, mid);
			if (Android_JNI_ExceptionOccurred(true)) {
			mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, inputStream), "getDeclaredLength", "()J");
			ctx->hidden.androidio.size = (long)(*env)->CallLongMethod(env, inputStream, mid);
			if (Android_JNI_ExceptionOccurred(SDL_TRUE)) {
			goto fallback;
			}

			mid = (mEnv)->GetMethodID(mEnv, (mEnv)->GetObjectClass(mEnv, inputStream), "getFileDescriptor", "()Ljava/io/FileDescriptor;");
			fd = (*mEnv)->CallObjectMethod(mEnv, inputStream, mid);
			fdCls = (*mEnv)->GetObjectClass(mEnv, fd);
			descriptor = (*mEnv)->GetFieldID(mEnv, fdCls, "descriptor", "I");
			ctx->hidden.androidio.fd = (*mEnv)->GetIntField(mEnv, fd, descriptor);
			ctx->hidden.androidio.assetFileDescriptorRef = (*mEnv)->NewGlobalRef(mEnv, inputStream);
			mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, inputStream), "getFileDescriptor", "()Ljava/io/FileDescriptor;");
			fd = (*env)->CallObjectMethod(env, inputStream, mid);
			fdCls = (*env)->GetObjectClass(env, fd);
			descriptor = (*env)->GetFieldID(env, fdCls, "descriptor", "I");
			ctx->hidden.androidio.fd = (*env)->GetIntField(env, fd, descriptor);
			ctx->hidden.androidio.assetFileDescriptorRef = (*env)->NewGlobalRef(env, inputStream);

			/* Seek to the correct offset in the file. */
			lseek(ctx->hidden.androidio.fd, (off_t)ctx->hidden.androidio.offset, SEEK_SET);

			if (false) {
			if (0) {
			fallback:
			/* Disabled log message because of spam on the Nexus 7 */
			/* __android_log_print(ANDROID_LOG_DEBUG, "SDL", "Falling back to legacy InputStream method for opening file"); */
			@@ -754,14 +1870,22 @@
			ctx->hidden.androidio.assetFileDescriptorRef = NULL;

			/* inputStream = assetManager.open(<filename>); */
			mid = (mEnv)->GetMethodID(mEnv, (mEnv)->GetObjectClass(mEnv, assetManager),
			mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, assetManager),
			"open", "(Ljava/lang/String;I)Ljava/io/InputStream;");
			inputStream = (mEnv)->CallObjectMethod(mEnv, assetManager, mid, fileNameJString, 1 / ACCESS_RANDOM */);
			if (Android_JNI_ExceptionOccurred(false)) {
			goto failure;
			inputStream = (env)->CallObjectMethod(env, assetManager, mid, fileNameJString, 1 / ACCESS_RANDOM */);
			if (Android_JNI_ExceptionOccurred(SDL_FALSE)) {
			/* Try fallback to APK expansion files */
			inputStream = (*env)->CallStaticObjectMethod(env, mActivityClass, midOpenAPKExpansionInputStream, fileNameJString);

			/* Exception is checked first because it always needs to be cleared.
			* If no exception occurred then the last SDL error message is kept.
			*/
			if (Android_JNI_ExceptionOccurred(SDL_FALSE) \|\| !inputStream) {
			goto failure;
			}
			}

			ctx->hidden.androidio.inputStreamRef = (*mEnv)->NewGlobalRef(mEnv, inputStream);
			ctx->hidden.androidio.inputStreamRef = (*env)->NewGlobalRef(env, inputStream);

			/* Despite all the visible documentation on [Asset]InputStream claiming
			* that the .available() method is not guaranteed to return the entire file
			@@ -769,68 +1893,69 @@
			* android/apis/content/ReadAsset.java imply that Android's
			* AssetInputStream.available() /will/ always return the total file size
			*/


			/* size = inputStream.available(); */
			mid = (mEnv)->GetMethodID(mEnv, (mEnv)->GetObjectClass(mEnv, inputStream),
			mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, inputStream),
			"available", "()I");
			ctx->hidden.androidio.size = (long)(*mEnv)->CallIntMethod(mEnv, inputStream, mid);
			if (Android_JNI_ExceptionOccurred(false)) {
			ctx->hidden.androidio.size = (long)(*env)->CallIntMethod(env, inputStream, mid);
			if (Android_JNI_ExceptionOccurred(SDL_FALSE)) {
			goto failure;
			}

			/* readableByteChannel = Channels.newChannel(inputStream); */
			channels = (*mEnv)->FindClass(mEnv, "java/nio/channels/Channels");
			mid = (*mEnv)->GetStaticMethodID(mEnv, channels,
			channels = (*env)->FindClass(env, "java/nio/channels/Channels");
			mid = (*env)->GetStaticMethodID(env, channels,
			"newChannel",
			"(Ljava/io/InputStream;)Ljava/nio/channels/ReadableByteChannel;");
			readableByteChannel = (*mEnv)->CallStaticObjectMethod(
			mEnv, channels, mid, inputStream);
			if (Android_JNI_ExceptionOccurred(false)) {
			readableByteChannel = (*env)->CallStaticObjectMethod(
			env, channels, mid, inputStream);
			if (Android_JNI_ExceptionOccurred(SDL_FALSE)) {
			goto failure;
			}

			ctx->hidden.androidio.readableByteChannelRef =
			(*mEnv)->NewGlobalRef(mEnv, readableByteChannel);
			(*env)->NewGlobalRef(env, readableByteChannel);

			/* Store .read id for reading purposes */
			mid = (mEnv)->GetMethodID(mEnv, (mEnv)->GetObjectClass(mEnv, readableByteChannel),
			mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, readableByteChannel),
			"read", "(Ljava/nio/ByteBuffer;)I");
			ctx->hidden.androidio.readMethod = mid;
			}

			if (false) {
			if (0) {
			failure:
			result = -1;

			(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.fileNameRef);
			(*env)->DeleteGlobalRef(env, (jobject)ctx->hidden.androidio.fileNameRef);

			if(ctx->hidden.androidio.inputStreamRef != NULL) {
			(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.inputStreamRef);
			(*env)->DeleteGlobalRef(env, (jobject)ctx->hidden.androidio.inputStreamRef);
			}

			if(ctx->hidden.androidio.readableByteChannelRef != NULL) {
			(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.readableByteChannelRef);
			(*env)->DeleteGlobalRef(env, (jobject)ctx->hidden.androidio.readableByteChannelRef);
			}

			if(ctx->hidden.androidio.assetFileDescriptorRef != NULL) {
			(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.assetFileDescriptorRef);
			(*env)->DeleteGlobalRef(env, (jobject)ctx->hidden.androidio.assetFileDescriptorRef);
			}

			}


			LocalReferenceHolder_Cleanup(&refs);
			return result;
			}

			int Android_JNI_FileOpen(SDL_RWops* ctx,
			const char* fileName, const char* mode)
			int Android_JNI_FileOpen(SDL_RWops *ctx,
			const char fileName, const char mode)
			{
			struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
			JNIEnv *mEnv = Android_JNI_GetEnv();
			JNIEnv *env = Android_JNI_GetEnv();
			int retval;
			jstring fileNameJString;

			if (!LocalReferenceHolder_Init(&refs, mEnv)) {
			LocalReferenceHolder_Cleanup(&refs);
			if (!LocalReferenceHolder_Init(&refs, env)) {
			LocalReferenceHolder_Cleanup(&refs);
			return -1;
			}

			@@ -839,8 +1964,8 @@
			return -1;
			}

			jstring fileNameJString = (*mEnv)->NewStringUTF(mEnv, fileName);
			ctx->hidden.androidio.fileNameRef = (*mEnv)->NewGlobalRef(mEnv, fileNameJString);
			fileNameJString = (*env)->NewStringUTF(env, fileName);
			ctx->hidden.androidio.fileNameRef = (*env)->NewGlobalRef(env, fileNameJString);
			ctx->hidden.androidio.inputStreamRef = NULL;
			ctx->hidden.androidio.readableByteChannelRef = NULL;
			ctx->hidden.androidio.readMethod = NULL;
			@@ -851,17 +1976,18 @@
			return retval;
			}

			size_t Android_JNI_FileRead(SDL_RWops* ctx, void* buffer,
			size_t Android_JNI_FileRead(SDL_RWops ctx, void buffer,
			size_t size, size_t maxnum)
			{
			struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);

			if (ctx->hidden.androidio.assetFileDescriptorRef) {
			size_t bytesMax = size * maxnum;
			size_t result;
			if (ctx->hidden.androidio.size != -1 /* UNKNOWN_LENGTH */ && ctx->hidden.androidio.position + bytesMax > ctx->hidden.androidio.size) {
			bytesMax = ctx->hidden.androidio.size - ctx->hidden.androidio.position;
			}
			size_t result = read(ctx->hidden.androidio.fd, buffer, bytesMax );
			result = read(ctx->hidden.androidio.fd, buffer, bytesMax );
			if (result > 0) {
			ctx->hidden.androidio.position += result;
			LocalReferenceHolder_Cleanup(&refs);
			@@ -873,26 +1999,30 @@
			jlong bytesRemaining = (jlong) (size * maxnum);
			jlong bytesMax = (jlong) (ctx->hidden.androidio.size - ctx->hidden.androidio.position);
			int bytesRead = 0;
			JNIEnv *env;
			jobject readableByteChannel;
			jmethodID readMethod;
			jobject byteBuffer;

			/* Don't read more bytes than those that remain in the file, otherwise we get an exception */
			if (bytesRemaining > bytesMax) bytesRemaining = bytesMax;

			JNIEnv *mEnv = Android_JNI_GetEnv();
			if (!LocalReferenceHolder_Init(&refs, mEnv)) {
			LocalReferenceHolder_Cleanup(&refs);
			env = Android_JNI_GetEnv();
			if (!LocalReferenceHolder_Init(&refs, env)) {
			LocalReferenceHolder_Cleanup(&refs);
			return 0;
			}

			jobject readableByteChannel = (jobject)ctx->hidden.androidio.readableByteChannelRef;
			jmethodID readMethod = (jmethodID)ctx->hidden.androidio.readMethod;
			jobject byteBuffer = (*mEnv)->NewDirectByteBuffer(mEnv, buffer, bytesRemaining);
			readableByteChannel = (jobject)ctx->hidden.androidio.readableByteChannelRef;
			readMethod = (jmethodID)ctx->hidden.androidio.readMethod;
			byteBuffer = (*env)->NewDirectByteBuffer(env, buffer, bytesRemaining);

			while (bytesRemaining > 0) {
			/* result = readableByteChannel.read(...); */
			int result = (*mEnv)->CallIntMethod(mEnv, readableByteChannel, readMethod, byteBuffer);
			int result = (*env)->CallIntMethod(env, readableByteChannel, readMethod, byteBuffer);

			if (Android_JNI_ExceptionOccurred(false)) {
			LocalReferenceHolder_Cleanup(&refs);
			if (Android_JNI_ExceptionOccurred(SDL_FALSE)) {
			LocalReferenceHolder_Cleanup(&refs);
			return 0;
			}

			@@ -904,42 +2034,42 @@
			bytesRead += result;
			ctx->hidden.androidio.position += result;
			}
			LocalReferenceHolder_Cleanup(&refs);
			LocalReferenceHolder_Cleanup(&refs);
			return bytesRead / size;
			}
			}

			size_t Android_JNI_FileWrite(SDL_RWops* ctx, const void* buffer,
			size_t Android_JNI_FileWrite(SDL_RWops ctx, const void buffer,
			size_t size, size_t num)
			{
			SDL_SetError("Cannot write to Android package filesystem");
			return 0;
			}

			static int Internal_Android_JNI_FileClose(SDL_RWops* ctx, bool release)
			static int Internal_Android_JNI_FileClose(SDL_RWops *ctx, SDL_bool release)
			{
			struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);

			int result = 0;
			JNIEnv *mEnv = Android_JNI_GetEnv();
			JNIEnv *env = Android_JNI_GetEnv();

			if (!LocalReferenceHolder_Init(&refs, mEnv)) {
			if (!LocalReferenceHolder_Init(&refs, env)) {
			LocalReferenceHolder_Cleanup(&refs);
			return SDL_SetError("Failed to allocate enough JVM local references");
			}

			if (ctx) {
			if (release) {
			(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.fileNameRef);
			(*env)->DeleteGlobalRef(env, (jobject)ctx->hidden.androidio.fileNameRef);
			}

			if (ctx->hidden.androidio.assetFileDescriptorRef) {
			jobject inputStream = (jobject)ctx->hidden.androidio.assetFileDescriptorRef;
			jmethodID mid = (mEnv)->GetMethodID(mEnv, (mEnv)->GetObjectClass(mEnv, inputStream),
			jmethodID mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, inputStream),
			"close", "()V");
			(*mEnv)->CallVoidMethod(mEnv, inputStream, mid);
			(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.assetFileDescriptorRef);
			if (Android_JNI_ExceptionOccurred(false)) {
			(*env)->CallVoidMethod(env, inputStream, mid);
			(*env)->DeleteGlobalRef(env, (jobject)ctx->hidden.androidio.assetFileDescriptorRef);
			if (Android_JNI_ExceptionOccurred(SDL_FALSE)) {
			result = -1;
			}
			}
			@@ -947,12 +2077,12 @@
			jobject inputStream = (jobject)ctx->hidden.androidio.inputStreamRef;

			/* inputStream.close(); */
			jmethodID mid = (mEnv)->GetMethodID(mEnv, (mEnv)->GetObjectClass(mEnv, inputStream),
			jmethodID mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, inputStream),
			"close", "()V");
			(*mEnv)->CallVoidMethod(mEnv, inputStream, mid);
			(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.inputStreamRef);
			(*mEnv)->DeleteGlobalRef(mEnv, (jobject)ctx->hidden.androidio.readableByteChannelRef);
			if (Android_JNI_ExceptionOccurred(false)) {
			(*env)->CallVoidMethod(env, inputStream, mid);
			(*env)->DeleteGlobalRef(env, (jobject)ctx->hidden.androidio.inputStreamRef);
			(*env)->DeleteGlobalRef(env, (jobject)ctx->hidden.androidio.readableByteChannelRef);
			if (Android_JNI_ExceptionOccurred(SDL_FALSE)) {
			result = -1;
			}
			}
			@@ -967,14 +2097,15 @@
			}


			Sint64 Android_JNI_FileSize(SDL_RWops* ctx)
			Sint64 Android_JNI_FileSize(SDL_RWops *ctx)
			{
			return ctx->hidden.androidio.size;
			}

			Sint64 Android_JNI_FileSeek(SDL_RWops* ctx, Sint64 offset, int whence)
			Sint64 Android_JNI_FileSeek(SDL_RWops *ctx, Sint64 offset, int whence)
			{
			if (ctx->hidden.androidio.assetFileDescriptorRef) {
			off_t ret;
			switch (whence) {
			case RW_SEEK_SET:
			if (ctx->hidden.androidio.size != -1 /* UNKNOWN_LENGTH */ && offset > ctx->hidden.androidio.size) offset = ctx->hidden.androidio.size;
			@@ -991,13 +2122,13 @@
			default:
			return SDL_SetError("Unknown value for 'whence'");
			}
			whence = SEEK_SET;

			off_t ret = lseek(ctx->hidden.androidio.fd, (off_t)offset, SEEK_SET);
			ret = lseek(ctx->hidden.androidio.fd, (off_t)offset, SEEK_SET);
			if (ret == -1) return -1;
			ctx->hidden.androidio.position = ret - ctx->hidden.androidio.offset;
			} else {
			Sint64 newPosition;
			Sint64 movement;

			switch (whence) {
			case RW_SEEK_SET:
			@@ -1021,17 +2152,18 @@
			newPosition = ctx->hidden.androidio.size;
			}

			Sint64 movement = newPosition - ctx->hidden.androidio.position;
			movement = newPosition - ctx->hidden.androidio.position;
			if (movement > 0) {
			unsigned char buffer[4096];

			/* The easy case where we're seeking forwards */
			while (movement > 0) {
			Sint64 amount = sizeof (buffer);
			size_t result;
			if (amount > movement) {
			amount = movement;
			}
			size_t result = Android_JNI_FileRead(ctx, buffer, 1, amount);
			result = Android_JNI_FileRead(ctx, buffer, 1, (size_t)amount);
			if (result <= 0) {
			/* Failed to read/skip the required amount, so fail */
			return -1;
			@@ -1043,7 +2175,7 @@
			} else if (movement < 0) {
			/* We can't seek backwards so we have to reopen the file and seek */
			/* forwards which obviously isn't very efficient */
			Internal_Android_JNI_FileClose(ctx, false);
			Internal_Android_JNI_FileClose(ctx, SDL_FALSE);
			Internal_Android_JNI_FileOpen(ctx);
			Android_JNI_FileSeek(ctx, newPosition, RW_SEEK_SET);
			}
			@@ -1053,162 +2185,109 @@

			}

			int Android_JNI_FileClose(SDL_RWops* ctx)
			int Android_JNI_FileClose(SDL_RWops *ctx)
			{
			return Internal_Android_JNI_FileClose(ctx, true);
			return Internal_Android_JNI_FileClose(ctx, SDL_TRUE);
			}

			/* returns a new global reference which needs to be released later */
			static jobject Android_JNI_GetSystemServiceObject(const char* name)
			int Android_JNI_SetClipboardText(const char *text)
			{
			struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
			JNIEnv* env = Android_JNI_GetEnv();
			jobject retval = NULL;

			if (!LocalReferenceHolder_Init(&refs, env)) {
			LocalReferenceHolder_Cleanup(&refs);
			return NULL;
			}

			jstring service = (*env)->NewStringUTF(env, name);

			jmethodID mid;

			mid = (*env)->GetStaticMethodID(env, mActivityClass, "getContext", "()Landroid/content/Context;");
			jobject context = (*env)->CallStaticObjectMethod(env, mActivityClass, mid);

			mid = (*env)->GetMethodID(env, mActivityClass, "getSystemServiceFromUiThread", "(Ljava/lang/String;)Ljava/lang/Object;");
			jobject manager = (*env)->CallObjectMethod(env, context, mid, service);

			(*env)->DeleteLocalRef(env, service);

			retval = manager ? (*env)->NewGlobalRef(env, manager) : NULL;
			LocalReferenceHolder_Cleanup(&refs);
			return retval;
			}

			#define SETUP_CLIPBOARD(error) \
			struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__); \
			JNIEnv* env = Android_JNI_GetEnv(); \
			if (!LocalReferenceHolder_Init(&refs, env)) { \
			LocalReferenceHolder_Cleanup(&refs); \
			return error; \
			} \
			jobject clipboard = Android_JNI_GetSystemServiceObject("clipboard"); \
			if (!clipboard) { \
			LocalReferenceHolder_Cleanup(&refs); \
			return error; \
			}

			#define CLEANUP_CLIPBOARD() \
			LocalReferenceHolder_Cleanup(&refs);

			int Android_JNI_SetClipboardText(const char* text)
			{
			SETUP_CLIPBOARD(-1)

			jmethodID mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, clipboard), "setText", "(Ljava/lang/CharSequence;)V");
			JNIEnv *env = Android_JNI_GetEnv();
			jstring string = (*env)->NewStringUTF(env, text);
			(*env)->CallVoidMethod(env, clipboard, mid, string);
			(*env)->DeleteGlobalRef(env, clipboard);
			(*env)->CallStaticVoidMethod(env, mActivityClass, midClipboardSetText, string);
			(*env)->DeleteLocalRef(env, string);

			CLEANUP_CLIPBOARD();

			return 0;
			}

			char* Android_JNI_GetClipboardText()
			char* Android_JNI_GetClipboardText(void)
			{
			SETUP_CLIPBOARD(SDL_strdup(""))
			JNIEnv *env = Android_JNI_GetEnv();
			char *text = NULL;
			jstring string;

			jmethodID mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, clipboard), "getText", "()Ljava/lang/CharSequence;");
			jobject sequence = (*env)->CallObjectMethod(env, clipboard, mid);
			(*env)->DeleteGlobalRef(env, clipboard);
			if (sequence) {
			mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, sequence), "toString", "()Ljava/lang/String;");
			jstring string = (jstring)((*env)->CallObjectMethod(env, sequence, mid));
			const char* utf = (*env)->GetStringUTFChars(env, string, 0);
			string = (*env)->CallStaticObjectMethod(env, mActivityClass, midClipboardGetText);
			if (string) {
			const char utf = (env)->GetStringUTFChars(env, string, 0);
			if (utf) {
			char* text = SDL_strdup(utf);
			text = SDL_strdup(utf);
			(*env)->ReleaseStringUTFChars(env, string, utf);

			CLEANUP_CLIPBOARD();

			return text;
			}
			(*env)->DeleteLocalRef(env, string);
			}

			CLEANUP_CLIPBOARD();

			return SDL_strdup("");
			return (text == NULL) ? SDL_strdup("") : text;
			}

			SDL_bool Android_JNI_HasClipboardText()
			SDL_bool Android_JNI_HasClipboardText(void)
			{
			SETUP_CLIPBOARD(SDL_FALSE)

			jmethodID mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, clipboard), "hasText", "()Z");
			jboolean has = (*env)->CallBooleanMethod(env, clipboard, mid);
			(*env)->DeleteGlobalRef(env, clipboard);

			CLEANUP_CLIPBOARD();

			return has ? SDL_TRUE : SDL_FALSE;
			JNIEnv *env = Android_JNI_GetEnv();
			jboolean retval = (*env)->CallStaticBooleanMethod(env, mActivityClass, midClipboardHasText);
			return (retval == JNI_TRUE) ? SDL_TRUE : SDL_FALSE;
			}


			/* returns 0 on success or -1 on error (others undefined then)
			* returns truthy or falsy value in plugged, charged and battery
			* returns the value in seconds and percent or -1 if not available
			*/
			int Android_JNI_GetPowerInfo(int* plugged, int* charged, int* battery, int* seconds, int* percent)
			int Android_JNI_GetPowerInfo(int plugged, int charged, int battery, int seconds, int *percent)
			{
			struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
			JNIEnv* env = Android_JNI_GetEnv();
			JNIEnv *env = Android_JNI_GetEnv();
			jmethodID mid;
			jobject context;
			jstring action;
			jclass cls;
			jobject filter;
			jobject intent;
			jstring iname;
			jmethodID imid;
			jstring bname;
			jmethodID bmid;
			if (!LocalReferenceHolder_Init(&refs, env)) {
			LocalReferenceHolder_Cleanup(&refs);
			return -1;
			}

			jmethodID mid;

			mid = (*env)->GetStaticMethodID(env, mActivityClass, "getContext", "()Landroid/content/Context;");
			jobject context = (*env)->CallStaticObjectMethod(env, mActivityClass, mid);
			/* context = SDLActivity.getContext(); */
			context = (*env)->CallStaticObjectMethod(env, mActivityClass, midGetContext);

			jstring action = (*env)->NewStringUTF(env, "android.intent.action.BATTERY_CHANGED");
			action = (*env)->NewStringUTF(env, "android.intent.action.BATTERY_CHANGED");

			jclass cls = (*env)->FindClass(env, "android/content/IntentFilter");
			cls = (*env)->FindClass(env, "android/content/IntentFilter");

			mid = (*env)->GetMethodID(env, cls, "<init>", "(Ljava/lang/String;)V");
			jobject filter = (*env)->NewObject(env, cls, mid, action);
			filter = (*env)->NewObject(env, cls, mid, action);

			(*env)->DeleteLocalRef(env, action);

			mid = (*env)->GetMethodID(env, mActivityClass, "registerReceiver", "(Landroid/content/BroadcastReceiver;Landroid/content/IntentFilter;)Landroid/content/Intent;");
			jobject intent = (*env)->CallObjectMethod(env, context, mid, NULL, filter);
			intent = (*env)->CallObjectMethod(env, context, mid, NULL, filter);

			(*env)->DeleteLocalRef(env, filter);

			cls = (*env)->GetObjectClass(env, intent);

			jstring iname;
			jmethodID imid = (*env)->GetMethodID(env, cls, "getIntExtra", "(Ljava/lang/String;I)I");
			imid = (*env)->GetMethodID(env, cls, "getIntExtra", "(Ljava/lang/String;I)I");

			/* Watch out for C89 scoping rules because of the macro */
			#define GET_INT_EXTRA(var, key) \
			int var; \
			iname = (*env)->NewStringUTF(env, key); \
			int var = (*env)->CallIntMethod(env, intent, imid, iname, -1); \
			(var) = (*env)->CallIntMethod(env, intent, imid, iname, -1); \
			(*env)->DeleteLocalRef(env, iname);

			jstring bname;
			jmethodID bmid = (*env)->GetMethodID(env, cls, "getBooleanExtra", "(Ljava/lang/String;Z)Z");
			bmid = (*env)->GetMethodID(env, cls, "getBooleanExtra", "(Ljava/lang/String;Z)Z");

			/* Watch out for C89 scoping rules because of the macro */
			#define GET_BOOL_EXTRA(var, key) \
			int var; \
			bname = (*env)->NewStringUTF(env, key); \
			int var = (*env)->CallBooleanMethod(env, intent, bmid, bname, JNI_FALSE); \
			(var) = (*env)->CallBooleanMethod(env, intent, bmid, bname, JNI_FALSE); \
			(*env)->DeleteLocalRef(env, bname);

			if (plugged) {
			/* Watch out for C89 scoping rules because of the macro */
			GET_INT_EXTRA(plug, "plugged") /* == BatteryManager.EXTRA_PLUGGED (API 5) */
			if (plug == -1) {
			LocalReferenceHolder_Cleanup(&refs);
			@@ -1220,6 +2299,7 @@
			}

			if (charged) {
			/* Watch out for C89 scoping rules because of the macro */
			GET_INT_EXTRA(status, "status") /* == BatteryManager.EXTRA_STATUS (API 5) */
			if (status == -1) {
			LocalReferenceHolder_Cleanup(&refs);
			@@ -1239,8 +2319,20 @@
			}

			if (percent) {
			GET_INT_EXTRA(level, "level") /* == BatteryManager.EXTRA_LEVEL (API 5) */
			GET_INT_EXTRA(scale, "scale") /* == BatteryManager.EXTRA_SCALE (API 5) */
			int level;
			int scale;

			/* Watch out for C89 scoping rules because of the macro */
			{
			GET_INT_EXTRA(level_temp, "level") /* == BatteryManager.EXTRA_LEVEL (API 5) */
			level = level_temp;
			}
			/* Watch out for C89 scoping rules because of the macro */
			{
			GET_INT_EXTRA(scale_temp, "scale") /* == BatteryManager.EXTRA_SCALE (API 5) */
			scale = scale_temp;
			}

			if ((level == -1) \|\| (scale == -1)) {
			LocalReferenceHolder_Cleanup(&refs);
			return -1;
			@@ -1254,76 +2346,170 @@
			return 0;
			}

			/* returns number of found touch devices as return value and ids in parameter ids */
			int Android_JNI_GetTouchDeviceIds(int **ids) {
			JNIEnv *env = Android_JNI_GetEnv();
			jint sources = 4098; /* == InputDevice.SOURCE_TOUCHSCREEN */
			jmethodID mid = (*env)->GetStaticMethodID(env, mActivityClass, "inputGetInputDeviceIds", "(I)[I");
			jintArray array = (jintArray) (*env)->CallStaticObjectMethod(env, mActivityClass, mid, sources);
			int number = 0;
			*ids = NULL;
			if (array) {
			number = (int) (*env)->GetArrayLength(env, array);
			if (0 < number) {
			jint* elements = (*env)->GetIntArrayElements(env, array, NULL);
			if (elements) {
			int i;
			ids = SDL_malloc(number sizeof (**ids));
			for (i = 0; i < number; ++i) { /* not assuming sizeof (jint) == sizeof (int) */
			(*ids)[i] = elements[i];
			}
			(*env)->ReleaseIntArrayElements(env, array, elements, JNI_ABORT);
			}
			}
			(*env)->DeleteLocalRef(env, array);
			}
			return number;
			/* Add all touch devices */
			void Android_JNI_InitTouch() {
			JNIEnv *env = Android_JNI_GetEnv();
			(*env)->CallStaticVoidMethod(env, mActivityClass, midInitTouch);
			}

			void Android_JNI_PollInputDevices()
			void Android_JNI_PollInputDevices(void)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			(*env)->CallStaticVoidMethod(env, mActivityClass, midPollInputDevices);
			(*env)->CallStaticVoidMethod(env, mControllerManagerClass, midPollInputDevices);
			}

			void Android_JNI_PollHapticDevices(void)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			(*env)->CallStaticVoidMethod(env, mControllerManagerClass, midPollHapticDevices);
			}

			void Android_JNI_HapticRun(int device_id, float intensity, int length)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			(*env)->CallStaticVoidMethod(env, mControllerManagerClass, midHapticRun, device_id, intensity, length);
			}

			void Android_JNI_HapticStop(int device_id)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			(*env)->CallStaticVoidMethod(env, mControllerManagerClass, midHapticStop, device_id);
			}

			/* See SDLActivity.java for constants. */
			#define COMMAND_SET_KEEP_SCREEN_ON 5

			/* sends message to be handled on the UI event dispatch thread */
			int Android_JNI_SendMessage(int command, int param)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			if (!env) {
			return -1;
			}
			jmethodID mid = (*env)->GetStaticMethodID(env, mActivityClass, "sendMessage", "(II)Z");
			if (!mid) {
			return -1;
			}
			jboolean success = (*env)->CallStaticBooleanMethod(env, mActivityClass, mid, command, param);
			jboolean success;
			success = (*env)->CallStaticBooleanMethod(env, mActivityClass, midSendMessage, command, param);
			return success ? 0 : -1;
			}

			void Android_JNI_SuspendScreenSaver(SDL_bool suspend)
			{
			Android_JNI_SendMessage(COMMAND_SET_KEEP_SCREEN_ON, (suspend == SDL_FALSE) ? 0 : 1);
			}

			void Android_JNI_ShowTextInput(SDL_Rect *inputRect)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			if (!env) {
			return;
			}

			jmethodID mid = (*env)->GetStaticMethodID(env, mActivityClass, "showTextInput", "(IIII)Z");
			if (!mid) {
			return;
			}
			(*env)->CallStaticBooleanMethod(env, mActivityClass, mid,
			(*env)->CallStaticBooleanMethod(env, mActivityClass, midShowTextInput,
			inputRect->x,
			inputRect->y,
			inputRect->w,
			inputRect->h );
			}

			void Android_JNI_HideTextInput()
			void Android_JNI_HideTextInput(void)
			{
			/* has to match Activity constant */
			const int COMMAND_TEXTEDIT_HIDE = 3;
			Android_JNI_SendMessage(COMMAND_TEXTEDIT_HIDE, 0);
			}

			SDL_bool Android_JNI_IsScreenKeyboardShown(void)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			jboolean is_shown = 0;
			is_shown = (*env)->CallStaticBooleanMethod(env, mActivityClass, midIsScreenKeyboardShown);
			return is_shown;
			}


			int Android_JNI_ShowMessageBox(const SDL_MessageBoxData messageboxdata, int buttonid)
			{
			JNIEnv *env;
			jclass clazz;
			jmethodID mid;
			jobject context;
			jstring title;
			jstring message;
			jintArray button_flags;
			jintArray button_ids;
			jobjectArray button_texts;
			jintArray colors;
			jobject text;
			jint temp;
			int i;

			env = Android_JNI_GetEnv();

			/* convert parameters */

			clazz = (*env)->FindClass(env, "java/lang/String");

			title = (*env)->NewStringUTF(env, messageboxdata->title);
			message = (*env)->NewStringUTF(env, messageboxdata->message);

			button_flags = (*env)->NewIntArray(env, messageboxdata->numbuttons);
			button_ids = (*env)->NewIntArray(env, messageboxdata->numbuttons);
			button_texts = (*env)->NewObjectArray(env, messageboxdata->numbuttons,
			clazz, NULL);
			for (i = 0; i < messageboxdata->numbuttons; ++i) {
			const SDL_MessageBoxButtonData *sdlButton;

			if (messageboxdata->flags & SDL_MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT) {
			sdlButton = &messageboxdata->buttons[messageboxdata->numbuttons - 1 - i];
			} else {
			sdlButton = &messageboxdata->buttons[i];
			}

			temp = sdlButton->flags;
			(*env)->SetIntArrayRegion(env, button_flags, i, 1, &temp);
			temp = sdlButton->buttonid;
			(*env)->SetIntArrayRegion(env, button_ids, i, 1, &temp);
			text = (*env)->NewStringUTF(env, sdlButton->text);
			(*env)->SetObjectArrayElement(env, button_texts, i, text);
			(*env)->DeleteLocalRef(env, text);
			}

			if (messageboxdata->colorScheme) {
			colors = (*env)->NewIntArray(env, SDL_MESSAGEBOX_COLOR_MAX);
			for (i = 0; i < SDL_MESSAGEBOX_COLOR_MAX; ++i) {
			temp = (0xFFU << 24) \|
			(messageboxdata->colorScheme->colors[i].r << 16) \|
			(messageboxdata->colorScheme->colors[i].g << 8) \|
			(messageboxdata->colorScheme->colors[i].b << 0);
			(*env)->SetIntArrayRegion(env, colors, i, 1, &temp);
			}
			} else {
			colors = NULL;
			}

			(*env)->DeleteLocalRef(env, clazz);

			/* context = SDLActivity.getContext(); */
			context = (*env)->CallStaticObjectMethod(env, mActivityClass, midGetContext);

			clazz = (*env)->GetObjectClass(env, context);

			mid = (*env)->GetMethodID(env, clazz,
			"messageboxShowMessageBox", "(ILjava/lang/String;Ljava/lang/String;[I[I[Ljava/lang/String;[I)I");
			buttonid = (env)->CallIntMethod(env, context, mid,
			messageboxdata->flags,
			title,
			message,
			button_flags,
			button_ids,
			button_texts,
			colors);

			(*env)->DeleteLocalRef(env, context);
			(*env)->DeleteLocalRef(env, clazz);

			/* delete parameters */

			(*env)->DeleteLocalRef(env, title);
			(*env)->DeleteLocalRef(env, message);
			(*env)->DeleteLocalRef(env, button_flags);
			(*env)->DeleteLocalRef(env, button_ids);
			(*env)->DeleteLocalRef(env, button_texts);
			(*env)->DeleteLocalRef(env, colors);

			return 0;
			}

			/*
			@@ -1333,18 +2519,14 @@
			//////////////////////////////////////////////////////////////////////////////
			*/

			void *SDL_AndroidGetJNIEnv()
			void *SDL_AndroidGetJNIEnv(void)
			{
			return Android_JNI_GetEnv();
			}



			void *SDL_AndroidGetActivity()
			void *SDL_AndroidGetActivity(void)
			{
			/* See SDL_system.h for caveats on using this function. */

			jmethodID mid;

			JNIEnv *env = Android_JNI_GetEnv();
			if (!env) {
			@@ -1352,12 +2534,52 @@
			}

			/* return SDLActivity.getContext(); */
			mid = (*env)->GetStaticMethodID(env, mActivityClass,
			"getContext","()Landroid/content/Context;");
			return (*env)->CallStaticObjectMethod(env, mActivityClass, mid);
			return (*env)->CallStaticObjectMethod(env, mActivityClass, midGetContext);
			}

			const char * SDL_AndroidGetInternalStoragePath()
			int SDL_GetAndroidSDKVersion(void)
			{
			static int sdk_version;
			if (!sdk_version) {
			char sdk[PROP_VALUE_MAX] = {0};
			if (__system_property_get("ro.build.version.sdk", sdk) != 0) {
			sdk_version = SDL_atoi(sdk);
			}
			}
			return sdk_version;
			}

			SDL_bool SDL_IsAndroidTablet(void)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			return (*env)->CallStaticBooleanMethod(env, mActivityClass, midIsTablet);
			}

			SDL_bool SDL_IsAndroidTV(void)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			return (*env)->CallStaticBooleanMethod(env, mActivityClass, midIsAndroidTV);
			}

			SDL_bool SDL_IsChromebook(void)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			return (*env)->CallStaticBooleanMethod(env, mActivityClass, midIsChromebook);
			}

			SDL_bool SDL_IsDeXMode(void)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			return (*env)->CallStaticBooleanMethod(env, mActivityClass, midIsDeXMode);
			}

			void SDL_AndroidBackButton(void)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			(*env)->CallStaticVoidMethod(env, mActivityClass, midManualBackButton);
			}

			const char * SDL_AndroidGetInternalStoragePath(void)
			{
			static char *s_AndroidInternalFilesPath = NULL;

			@@ -1376,9 +2598,12 @@
			}

			/* context = SDLActivity.getContext(); */
			mid = (*env)->GetStaticMethodID(env, mActivityClass,
			"getContext","()Landroid/content/Context;");
			context = (*env)->CallStaticObjectMethod(env, mActivityClass, mid);
			context = (*env)->CallStaticObjectMethod(env, mActivityClass, midGetContext);
			if (!context) {
			SDL_SetError("Couldn't get Android context!");
			LocalReferenceHolder_Cleanup(&refs);
			return NULL;
			}

			/* fileObj = context.getFilesDir(); */
			mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, context),
			@@ -1390,10 +2615,14 @@
			return NULL;
			}

			/* path = fileObject.getAbsolutePath(); */
			/* path = fileObject.getCanonicalPath(); */
			mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, fileObject),
			"getAbsolutePath", "()Ljava/lang/String;");
			"getCanonicalPath", "()Ljava/lang/String;");
			pathString = (jstring)(*env)->CallObjectMethod(env, fileObject, mid);
			if (Android_JNI_ExceptionOccurred(SDL_FALSE)) {
			LocalReferenceHolder_Cleanup(&refs);
			return NULL;
			}

			path = (*env)->GetStringUTFChars(env, pathString, NULL);
			s_AndroidInternalFilesPath = SDL_strdup(path);
			@@ -1404,7 +2633,7 @@
			return s_AndroidInternalFilesPath;
			}

			int SDL_AndroidGetExternalStorageState()
			int SDL_AndroidGetExternalStorageState(void)
			{
			struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);
			jmethodID mid;
			@@ -1443,7 +2672,7 @@
			return stateFlags;
			}

			const char * SDL_AndroidGetExternalStoragePath()
			const char * SDL_AndroidGetExternalStoragePath(void)
			{
			static char *s_AndroidExternalFilesPath = NULL;

			@@ -1462,9 +2691,7 @@
			}

			/* context = SDLActivity.getContext(); */
			mid = (*env)->GetStaticMethodID(env, mActivityClass,
			"getContext","()Landroid/content/Context;");
			context = (*env)->CallStaticObjectMethod(env, mActivityClass, mid);
			context = (*env)->CallStaticObjectMethod(env, mActivityClass, midGetContext);

			/* fileObj = context.getExternalFilesDir(); */
			mid = (env)->GetMethodID(env, (env)->GetObjectClass(env, context),
			@@ -1490,7 +2717,85 @@
			return s_AndroidExternalFilesPath;
			}

			void Android_JNI_GetManifestEnvironmentVariables(void)
			{
			if (!mActivityClass \|\| !midGetManifestEnvironmentVariables) {
			__android_log_print(ANDROID_LOG_WARN, "SDL", "Request to get environment variables before JNI is ready");
			return;
			}

			if (!bHasEnvironmentVariables) {
			JNIEnv *env = Android_JNI_GetEnv();
			SDL_bool ret = (*env)->CallStaticBooleanMethod(env, mActivityClass, midGetManifestEnvironmentVariables);
			if (ret) {
			bHasEnvironmentVariables = SDL_TRUE;
			}
			}
			}

			int Android_JNI_CreateCustomCursor(SDL_Surface *surface, int hot_x, int hot_y)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			int custom_cursor = 0;
			jintArray pixels;
			pixels = (env)->NewIntArray(env, surface->w surface->h);
			if (pixels) {
			(env)->SetIntArrayRegion(env, pixels, 0, surface->w surface->h, (int *)surface->pixels);
			custom_cursor = (*env)->CallStaticIntMethod(env, mActivityClass, midCreateCustomCursor, pixels, surface->w, surface->h, hot_x, hot_y);
			(*env)->DeleteLocalRef(env, pixels);
			} else {
			SDL_OutOfMemory();
			}
			return custom_cursor;
			}


			SDL_bool Android_JNI_SetCustomCursor(int cursorID)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			return (*env)->CallStaticBooleanMethod(env, mActivityClass, midSetCustomCursor, cursorID);
			}

			SDL_bool Android_JNI_SetSystemCursor(int cursorID)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			return (*env)->CallStaticBooleanMethod(env, mActivityClass, midSetSystemCursor, cursorID);
			}

			SDL_bool Android_JNI_SupportsRelativeMouse(void)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			return (*env)->CallStaticBooleanMethod(env, mActivityClass, midSupportsRelativeMouse);
			}

			SDL_bool Android_JNI_SetRelativeMouseEnabled(SDL_bool enabled)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			return (*env)->CallStaticBooleanMethod(env, mActivityClass, midSetRelativeMouseEnabled, (enabled == 1));
			}

			SDL_bool Android_JNI_RequestPermission(const char *permission)
			{
			JNIEnv *env = Android_JNI_GetEnv();
			const int requestCode = 1;

			/* Wait for any pending request on another thread */
			while (SDL_AtomicGet(&bPermissionRequestPending) == SDL_TRUE) {
			SDL_Delay(10);
			}
			SDL_AtomicSet(&bPermissionRequestPending, SDL_TRUE);

			jstring jpermission = (*env)->NewStringUTF(env, permission);
			(*env)->CallStaticVoidMethod(env, mActivityClass, midRequestPermission, jpermission, requestCode);
			(*env)->DeleteLocalRef(env, jpermission);

			/* Wait for the request to complete */
			while (SDL_AtomicGet(&bPermissionRequestPending) == SDL_TRUE) {
			SDL_Delay(10);
			}
			return bPermissionRequestResult;
			}

			#endif /* __ANDROID__ */

			/* vi: set ts=4 sw=4 expandtab: */