From 03f8528315fa46c95991a34f3325d7b33ae5538c Mon Sep 17 00:00:00 2001
From: Edward Rudd <urkle@outoforder.cc>
Date: Sat, 02 May 2020 21:48:36 +0000
Subject: [PATCH] Update source to SDL2 2.0.12
---
source/src/core/android/SDL_android.c | 1402 +++++++++++++++++++++++++++++++++++++--------------------
1 files changed, 901 insertions(+), 501 deletions(-)
diff --git a/source/src/core/android/SDL_android.c b/source/src/core/android/SDL_android.c
index a56575e..9dd961d 100644
--- a/source/src/core/android/SDL_android.c
+++ b/source/src/core/android/SDL_android.c
@@ -1,6 +1,6 @@
/*
Simple DirectMedia Layer
- Copyright (C) 1997-2018 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,9 +21,11 @@
#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__
@@ -42,16 +44,11 @@
#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>
#include <dlfcn.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 (0)
-#define LOGE(...) do {} while (0)
-
#define SDL_JAVA_PREFIX org_libsdl_app
#define CONCAT1(prefix, class, function) CONCAT2(prefix, class, function)
@@ -68,141 +65,211 @@
/* Java class SDLActivity */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetupJNI)(
- JNIEnv* mEnv, jclass cls);
+ JNIEnv *env, jclass cls);
JNIEXPORT int JNICALL SDL_JAVA_INTERFACE(nativeRunMain)(
- JNIEnv* env, jclass cls,
+ JNIEnv *env, jclass cls,
jstring library, jstring function, jobject array);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeDropFile)(
- JNIEnv* env, jclass jcls,
+ JNIEnv *env, jclass jcls,
jstring filename);
-JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeResize)(
- JNIEnv* env, jclass jcls,
+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);
+ JNIEnv *env, jclass jcls);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceDestroyed)(
- JNIEnv* env, jclass jcls);
+ JNIEnv *env, jclass jcls);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyDown)(
- JNIEnv* env, jclass jcls,
+ JNIEnv *env, jclass jcls,
jint keycode);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyUp)(
- JNIEnv* env, jclass jcls,
+ 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);
+ JNIEnv *env, jclass jcls);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeTouch)(
- JNIEnv* env, jclass jcls,
+ 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,
+ 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,
+ JNIEnv *env, jclass jcls,
jfloat x, jfloat y, jfloat z);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeClipboardChanged)(
- JNIEnv* env, jclass jcls);
+ JNIEnv *env, jclass jcls);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeLowMemory)(
- JNIEnv* env, jclass cls);
+ 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);
+ JNIEnv *env, jclass cls);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativePause)(
- JNIEnv* env, jclass cls);
+ JNIEnv *env, jclass cls);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeResume)(
- JNIEnv* env, jclass cls);
+ 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,
+ JNIEnv *env, jclass cls,
jstring name);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetenv)(
- JNIEnv* env, jclass cls,
+ JNIEnv *env, jclass cls,
jstring name, jstring value);
-JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeEnvironmentVariablesSet)(
- JNIEnv* env, jclass cls);
-
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeOrientationChanged)(
- JNIEnv* env, jclass cls,
+ 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,
+ JNIEnv *env, jclass cls,
jstring text, jint newCursorPosition);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeGenerateScancodeForUnichar)(
- JNIEnv* env, jclass cls,
+ JNIEnv *env, jclass cls,
jchar chUnicode);
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeSetComposingText)(
- JNIEnv* env, jclass cls,
+ 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,
+ JNIEnv *env, jclass jcls,
jint device_id, jint keycode);
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativePadUp)(
- JNIEnv* env, jclass jcls,
+ JNIEnv *env, jclass jcls,
jint device_id, jint keycode);
JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativeJoy)(
- JNIEnv* env, jclass jcls,
+ JNIEnv *env, jclass jcls,
jint device_id, jint axis, jfloat value);
JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativeHat)(
- JNIEnv* env, jclass jcls,
+ 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,
+ 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,
+ JNIEnv *env, jclass jcls,
jint device_id);
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeAddHaptic)(
- JNIEnv* env, jclass jcls,
+ JNIEnv *env, jclass jcls,
jint device_id, jstring device_name);
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveHaptic)(
- JNIEnv* env, jclass jcls,
+ 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);
/*******************************************************************************
@@ -215,37 +282,42 @@
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 midGetNativeSurface;
-static jmethodID midSetActivityTitle;
-static jmethodID midSetWindowStyle;
-static jmethodID midSetOrientation;
+static jmethodID midClipboardGetText;
+static jmethodID midClipboardHasText;
+static jmethodID midClipboardSetText;
+static jmethodID midCreateCustomCursor;
static jmethodID midGetContext;
-static jmethodID midIsTablet;
+static jmethodID midGetDisplayDPI;
+static jmethodID midGetManifestEnvironmentVariables;
+static jmethodID midGetNativeSurface;
+static jmethodID midInitTouch;
static jmethodID midIsAndroidTV;
static jmethodID midIsChromebook;
static jmethodID midIsDeXMode;
-static jmethodID midManualBackButton;
-static jmethodID midInputGetInputDeviceIds;
-static jmethodID midSendMessage;
-static jmethodID midShowTextInput;
static jmethodID midIsScreenKeyboardShown;
-static jmethodID midClipboardSetText;
-static jmethodID midClipboardGetText;
-static jmethodID midClipboardHasText;
+static jmethodID midIsTablet;
+static jmethodID midManualBackButton;
+static jmethodID midMinimizeWindow;
static jmethodID midOpenAPKExpansionInputStream;
-static jmethodID midGetManifestEnvironmentVariables;
-static jmethodID midGetDisplayDPI;
-static jmethodID midCreateCustomCursor;
+static jmethodID midRequestPermission;
+static jmethodID midSendMessage;
+static jmethodID midSetActivityTitle;
static jmethodID midSetCustomCursor;
-static jmethodID midSetSystemCursor;
-static jmethodID midSupportsRelativeMouse;
+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;
@@ -261,6 +333,7 @@
static jmethodID midCaptureReadShortBuffer;
static jmethodID midCaptureReadFloatBuffer;
static jmethodID midCaptureClose;
+static jmethodID midAudioSetThreadPriority;
/* controller manager */
static jclass mControllerManagerClass;
@@ -271,160 +344,321 @@
static jmethodID midHapticRun;
static jmethodID midHapticStop;
-/* static fields */
-static jfieldID fidSeparateMouseAndTouch;
-
/* Accelerometer data storage */
+static SDL_DisplayOrientation displayOrientation;
static float fLastAccelerometer[3];
static SDL_bool bHasNewData;
-static SDL_bool bHasEnvironmentVariables = SDL_FALSE;
+static SDL_bool bHasEnvironmentVariables;
+
+static SDL_atomic_t bPermissionRequestPending;
+static SDL_bool bPermissionRequestResult;
/*******************************************************************************
Functions called by JNI
*******************************************************************************/
-/* Library init */
-JNIEXPORT jint JNICALL 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;
}
-void checkJNIReady()
+void checkJNIReady(void)
{
if (!mActivityClass || !mAudioManagerClass || !mControllerManagerClass) {
- // We aren't fully initialized, let's just return.
+ /* We aren't fully initialized, let's just return. */
return;
}
- SDL_SetMainReady();
+ SDL_SetMainReady();
}
/* Activity initialization -- called before SDL_main() to initialize JNI bindings */
-JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetupJNI)(JNIEnv* mEnv, jclass cls)
+JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetupJNI)(JNIEnv *env, jclass cls)
{
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativeSetupJNI()");
- Android_JNI_SetupThread();
+ /*
+ * 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();
- mActivityClass = (jclass)((*mEnv)->NewGlobalRef(mEnv, cls));
+ /* Save JNIEnv of SDLActivity */
+ Android_JNI_SetEnv(env);
- midGetNativeSurface = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "getNativeSurface","()Landroid/view/Surface;");
- midSetActivityTitle = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "setActivityTitle","(Ljava/lang/String;)Z");
- midSetWindowStyle = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "setWindowStyle","(Z)V");
- midSetOrientation = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "setOrientation","(IIZLjava/lang/String;)V");
- midGetContext = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "getContext","()Landroid/content/Context;");
- midIsTablet = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "isTablet", "()Z");
- midIsAndroidTV = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "isAndroidTV","()Z");
- midIsChromebook = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "isChromebook", "()Z");
- midIsDeXMode = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "isDeXMode", "()Z");
- midManualBackButton = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "manualBackButton", "()V");
- midInputGetInputDeviceIds = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "inputGetInputDeviceIds", "(I)[I");
- midSendMessage = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "sendMessage", "(II)Z");
- midShowTextInput = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "showTextInput", "(IIII)Z");
- midIsScreenKeyboardShown = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "isScreenKeyboardShown","()Z");
- midClipboardSetText = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "clipboardSetText", "(Ljava/lang/String;)V");
- midClipboardGetText = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "clipboardGetText", "()Ljava/lang/String;");
- midClipboardHasText = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "clipboardHasText", "()Z");
- midOpenAPKExpansionInputStream = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "openAPKExpansionInputStream", "(Ljava/lang/String;)Ljava/io/InputStream;");
-
- midGetManifestEnvironmentVariables = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,
- "getManifestEnvironmentVariables", "()Z");
-
- midGetDisplayDPI = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass, "getDisplayDPI", "()Landroid/util/DisplayMetrics;");
- midCreateCustomCursor = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass, "createCustomCursor", "([IIIII)I");
- midSetCustomCursor = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass, "setCustomCursor", "(I)Z");
- midSetSystemCursor = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass, "setSystemCursor", "(I)Z");
-
- midSupportsRelativeMouse = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass, "supportsRelativeMouse", "()Z");
- midSetRelativeMouseEnabled = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass, "setRelativeMouseEnabled", "(Z)Z");
-
-
- if (!midGetNativeSurface ||
- !midSetActivityTitle || !midSetWindowStyle || !midSetOrientation || !midGetContext || !midIsTablet || !midIsAndroidTV || !midInputGetInputDeviceIds ||
- !midSendMessage || !midShowTextInput || !midIsScreenKeyboardShown ||
- !midClipboardSetText || !midClipboardGetText || !midClipboardHasText ||
- !midOpenAPKExpansionInputStream || !midGetManifestEnvironmentVariables || !midGetDisplayDPI ||
- !midCreateCustomCursor || !midSetCustomCursor || !midSetSystemCursor || !midSupportsRelativeMouse || !midSetRelativeMouseEnabled ||
- !midIsChromebook || !midIsDeXMode || !midManualBackButton) {
- __android_log_print(ANDROID_LOG_WARN, "SDL", "Missing some Java callbacks, do you have the latest version of SDLActivity.java?");
+ if (mJavaVM == NULL) {
+ __android_log_print(ANDROID_LOG_ERROR, "SDL", "failed to found a JavaVM");
}
- fidSeparateMouseAndTouch = (*mEnv)->GetStaticFieldID(mEnv, mActivityClass, "mSeparateMouseAndTouch", "Z");
+ /* 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 (!fidSeparateMouseAndTouch) {
- __android_log_print(ANDROID_LOG_WARN, "SDL", "Missing some Java static fields, do you have the latest version of SDLActivity.java?");
+ 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* mEnv, jclass cls)
+JNIEXPORT void JNICALL SDL_JAVA_AUDIO_INTERFACE(nativeSetupJNI)(JNIEnv *env, jclass cls)
{
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "AUDIO nativeSetupJNI()");
- Android_JNI_SetupThread();
+ mAudioManagerClass = (jclass)((*env)->NewGlobalRef(env, cls));
- mAudioManagerClass = (jclass)((*mEnv)->NewGlobalRef(mEnv, cls));
-
- midAudioOpen = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
+ midAudioOpen = (*env)->GetStaticMethodID(env, mAudioManagerClass,
"audioOpen", "(IIII)[I");
- midAudioWriteByteBuffer = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
+ midAudioWriteByteBuffer = (*env)->GetStaticMethodID(env, mAudioManagerClass,
"audioWriteByteBuffer", "([B)V");
- midAudioWriteShortBuffer = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
+ midAudioWriteShortBuffer = (*env)->GetStaticMethodID(env, mAudioManagerClass,
"audioWriteShortBuffer", "([S)V");
- midAudioWriteFloatBuffer = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
+ midAudioWriteFloatBuffer = (*env)->GetStaticMethodID(env, mAudioManagerClass,
"audioWriteFloatBuffer", "([F)V");
- midAudioClose = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
+ midAudioClose = (*env)->GetStaticMethodID(env, mAudioManagerClass,
"audioClose", "()V");
- midCaptureOpen = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
+ midCaptureOpen = (*env)->GetStaticMethodID(env, mAudioManagerClass,
"captureOpen", "(IIII)[I");
- midCaptureReadByteBuffer = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
+ midCaptureReadByteBuffer = (*env)->GetStaticMethodID(env, mAudioManagerClass,
"captureReadByteBuffer", "([BZ)I");
- midCaptureReadShortBuffer = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
+ midCaptureReadShortBuffer = (*env)->GetStaticMethodID(env, mAudioManagerClass,
"captureReadShortBuffer", "([SZ)I");
- midCaptureReadFloatBuffer = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
+ midCaptureReadFloatBuffer = (*env)->GetStaticMethodID(env, mAudioManagerClass,
"captureReadFloatBuffer", "([FZ)I");
- midCaptureClose = (*mEnv)->GetStaticMethodID(mEnv, mAudioManagerClass,
+ 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) {
+ !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?");
}
@@ -432,21 +666,19 @@
}
/* Controller initialization -- called before SDL_main() to initialize JNI bindings */
-JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeSetupJNI)(JNIEnv* mEnv, jclass cls)
+JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeSetupJNI)(JNIEnv *env, jclass cls)
{
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "CONTROLLER nativeSetupJNI()");
- Android_JNI_SetupThread();
+ mControllerManagerClass = (jclass)((*env)->NewGlobalRef(env, cls));
- mControllerManagerClass = (jclass)((*mEnv)->NewGlobalRef(mEnv, cls));
-
- midPollInputDevices = (*mEnv)->GetStaticMethodID(mEnv, mControllerManagerClass,
+ midPollInputDevices = (*env)->GetStaticMethodID(env, mControllerManagerClass,
"pollInputDevices", "()V");
- midPollHapticDevices = (*mEnv)->GetStaticMethodID(mEnv, mControllerManagerClass,
+ midPollHapticDevices = (*env)->GetStaticMethodID(env, mControllerManagerClass,
"pollHapticDevices", "()V");
- midHapticRun = (*mEnv)->GetStaticMethodID(mEnv, mControllerManagerClass,
+ midHapticRun = (*env)->GetStaticMethodID(env, mControllerManagerClass,
"hapticRun", "(IFI)V");
- midHapticStop = (*mEnv)->GetStaticMethodID(mEnv, mControllerManagerClass,
+ midHapticStop = (*env)->GetStaticMethodID(env, mControllerManagerClass,
"hapticStop", "(I)V");
if (!midPollInputDevices || !midPollHapticDevices || !midHapticRun || !midHapticStop) {
@@ -460,7 +692,7 @@
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)
+JNIEXPORT int JNICALL SDL_JAVA_INTERFACE(nativeRunMain)(JNIEnv *env, jclass cls, jstring library, jstring function, jobject array)
{
int status = -1;
const char *library_file;
@@ -468,8 +700,22 @@
__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;
@@ -481,18 +727,19 @@
int argc;
int len;
char **argv;
+ SDL_bool isstack;
/* Prepare the arguments. */
len = (*env)->GetArrayLength(env, array);
- argv = SDL_stack_alloc(char*, 1 + len + 1);
+ 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;
+ const char *utf;
+ char *arg = NULL;
jstring string = (*env)->GetObjectArrayElement(env, array, i);
if (string) {
utf = (*env)->GetStringUTFChars(env, string, 0);
@@ -517,7 +764,7 @@
for (i = 0; i < argc; ++i) {
SDL_free(argv[i]);
}
- SDL_stack_free(argv);
+ 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);
@@ -531,6 +778,10 @@
}
(*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); */
@@ -539,7 +790,7 @@
/* Drop file */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeDropFile)(
- JNIEnv* env, jclass jcls,
+ JNIEnv *env, jclass jcls,
jstring filename)
{
const char *path = (*env)->GetStringUTFChars(env, filename, NULL);
@@ -548,26 +799,100 @@
SDL_SendDropComplete(NULL);
}
-/* Resize */
-JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeResize)(
- JNIEnv* env, jclass jcls,
+/* 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 */
+JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeResize)(
+ JNIEnv *env, jclass jcls)
+{
+ SDL_LockMutex(Android_ActivityMutex);
+
+ if (Android_Window)
+ {
+ Android_SendResize(Android_Window);
+ }
+
+ SDL_UnlockMutex(Android_ActivityMutex);
}
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeOrientationChanged)(
JNIEnv *env, jclass jcls,
jint orientation)
{
- SDL_VideoDisplay *display = SDL_GetDisplay(0);
- SDL_SendDisplayEvent(display, SDL_DISPLAYEVENT_ORIENTATION, 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,
+ JNIEnv *env, jclass jcls,
jint device_id, jint keycode)
{
return Android_OnPadDown(device_id, keycode);
@@ -575,7 +900,7 @@
/* Padup */
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativePadUp)(
- JNIEnv* env, jclass jcls,
+ JNIEnv *env, jclass jcls,
jint device_id, jint keycode)
{
return Android_OnPadUp(device_id, keycode);
@@ -583,7 +908,7 @@
/* Joy */
JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativeJoy)(
- JNIEnv* env, jclass jcls,
+ JNIEnv *env, jclass jcls,
jint device_id, jint axis, jfloat value)
{
Android_OnJoy(device_id, axis, value);
@@ -591,7 +916,7 @@
/* POV Hat */
JNIEXPORT void JNICALL SDL_JAVA_CONTROLLER_INTERFACE(onNativeHat)(
- JNIEnv* env, jclass jcls,
+ JNIEnv *env, jclass jcls,
jint device_id, jint hat_id, jint x, jint y)
{
Android_OnHat(device_id, hat_id, x, y);
@@ -599,7 +924,7 @@
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeAddJoystick)(
- JNIEnv* env, jclass jcls,
+ 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)
@@ -617,14 +942,14 @@
}
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveJoystick)(
- JNIEnv* env, jclass jcls,
+ JNIEnv *env, jclass jcls,
jint device_id)
{
return Android_RemoveJoystick(device_id);
}
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeAddHaptic)(
- JNIEnv* env, jclass jcls, jint device_id, jstring device_name)
+ JNIEnv *env, jclass jcls, jint device_id, jstring device_name)
{
int retval;
const char *name = (*env)->GetStringUTFChars(env, device_name, NULL);
@@ -637,68 +962,95 @@
}
JNIEXPORT jint JNICALL SDL_JAVA_CONTROLLER_INTERFACE(nativeRemoveHaptic)(
- JNIEnv* env, jclass jcls, jint device_id)
+ JNIEnv *env, jclass jcls, jint device_id)
{
return Android_RemoveHaptic(device_id);
}
-
-/* Surface Created */
-JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceChanged)(JNIEnv* env, jclass jcls)
+/* Called from surfaceCreated() */
+JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceCreated)(JNIEnv *env, jclass jcls)
{
- SDL_WindowData *data;
- SDL_VideoDevice *_this;
+ SDL_LockMutex(Android_ActivityMutex);
- if (Android_Window == NULL || Android_Window->driverdata == NULL ) {
- return;
- }
+ if (Android_Window)
+ {
+ SDL_WindowData *data = (SDL_WindowData *) Android_Window->driverdata;
- _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);
- }
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 */
-JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(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;
+ SDL_LockMutex(Android_ActivityMutex);
- if (Android_Window == NULL || Android_Window->driverdata == NULL ) {
- return;
+ 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 */
}
- _this = SDL_GetVideoDevice();
- data = (SDL_WindowData *) Android_Window->driverdata;
+ SDL_UnlockMutex(Android_ActivityMutex);
+}
- 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;
+/* Called from surfaceDestroyed() */
+JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeSurfaceDestroyed)(JNIEnv *env, jclass jcls)
+{
+ 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 */
}
- /* GL Context handling is done in the event loop because this function is run from the Java thread */
-
+ SDL_UnlockMutex(Android_ActivityMutex);
}
/* Keydown */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyDown)(
- JNIEnv* env, jclass jcls,
+ JNIEnv *env, jclass jcls,
jint keycode)
{
Android_OnKeyDown(keycode);
@@ -706,15 +1058,26 @@
/* Keyup */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyUp)(
- JNIEnv* env, jclass jcls,
+ 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 */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyboardFocusLost)(
- JNIEnv* env, jclass jcls)
+ JNIEnv *env, jclass jcls)
{
/* Calling SDL_StopTextInput will take care of hiding the keyboard and cleaning up the DummyText widget */
SDL_StopTextInput();
@@ -723,24 +1086,32 @@
/* Touch */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeTouch)(
- JNIEnv* env, jclass jcls,
+ 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,
+ JNIEnv *env, jclass jcls,
jint button, jint action, jfloat x, jfloat y, jboolean relative)
{
- Android_OnMouse(button, action, x, y, relative);
+ SDL_LockMutex(Android_ActivityMutex);
+
+ Android_OnMouse(Android_Window, button, action, x, y, relative);
+
+ SDL_UnlockMutex(Android_ActivityMutex);
}
/* Accelerometer */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeAccel)(
- JNIEnv* env, jclass jcls,
+ JNIEnv *env, jclass jcls,
jfloat x, jfloat y, jfloat z)
{
fLastAccelerometer[0] = x;
@@ -751,73 +1122,106 @@
/* Clipboard */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeClipboardChanged)(
- JNIEnv* env, jclass jcls)
+ JNIEnv *env, jclass jcls)
{
SDL_SendClipboardUpdate();
}
/* Low memory */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeLowMemory)(
- JNIEnv* env, jclass cls)
+ JNIEnv *env, jclass cls)
{
SDL_SendAppEvent(SDL_APP_LOWMEMORY);
}
-/* Quit */
-JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(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 */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativePause)(
- JNIEnv* env, jclass cls)
+ 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 */
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeResume)(
- JNIEnv* env, jclass cls)
+ JNIEnv *env, jclass cls)
{
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "nativeResume()");
+ /* 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);
+}
+
+JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeFocusChanged)(
+ JNIEnv *env, jclass cls, jboolean hasFocus)
+{
+ SDL_LockMutex(Android_ActivityMutex);
+
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);
+ __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,
+ JNIEnv *env, jclass cls,
jstring text, jint newCursorPosition)
{
const char *utftext = (*env)->GetStringUTFChars(env, text, NULL);
@@ -828,13 +1232,13 @@
}
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeGenerateScancodeForUnichar)(
- JNIEnv* env, jclass cls,
+ JNIEnv *env, jclass cls,
jchar chUnicode)
{
SDL_Scancode code = SDL_SCANCODE_UNKNOWN;
uint16_t mod = 0;
- // We do not care about bigger than 127.
+ /* We do not care about bigger than 127. */
if (chUnicode < 127) {
AndroidKeyInfo info = unicharToAndroidKeyInfoTable[chUnicode];
code = info.code;
@@ -856,9 +1260,8 @@
}
}
-
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE_INPUT_CONNECTION(nativeSetComposingText)(
- JNIEnv* env, jclass cls,
+ JNIEnv *env, jclass cls,
jstring text, jint newCursorPosition)
{
const char *utftext = (*env)->GetStringUTFChars(env, text, NULL);
@@ -869,7 +1272,7 @@
}
JNIEXPORT jstring JNICALL SDL_JAVA_INTERFACE(nativeGetHint)(
- JNIEnv* env, jclass cls,
+ JNIEnv *env, jclass cls,
jstring name)
{
const char *utfname = (*env)->GetStringUTFChars(env, name, NULL);
@@ -882,7 +1285,7 @@
}
JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeSetenv)(
- JNIEnv* env, jclass cls,
+ JNIEnv *env, jclass cls,
jstring name, jstring value)
{
const char *utfname = (*env)->GetStringUTFChars(env, name, NULL);
@@ -899,7 +1302,7 @@
Functions called by SDL into Java
*******************************************************************************/
-static int s_active = 0;
+static SDL_atomic_t s_active;
struct LocalReferenceHolder
{
JNIEnv *m_env;
@@ -924,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;
}
@@ -935,52 +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(void)
-{
- 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_SetSurfaceViewFormat(int format)
+{
+ 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)
{
- JNIEnv *mEnv = Android_JNI_GetEnv();
+ JNIEnv *env = Android_JNI_GetEnv();
- jstring jtitle = (jstring)((*mEnv)->NewStringUTF(mEnv, title));
- (*mEnv)->CallStaticBooleanMethod(mEnv, mActivityClass, midSetActivityTitle, jtitle);
- (*mEnv)->DeleteLocalRef(mEnv, jtitle);
+ jstring jtitle = (*env)->NewStringUTF(env, title);
+ (*env)->CallStaticBooleanMethod(env, mActivityClass, midSetActivityTitle, jtitle);
+ (*env)->DeleteLocalRef(env, jtitle);
}
void Android_JNI_SetWindowStyle(SDL_bool fullscreen)
{
- JNIEnv *mEnv = Android_JNI_GetEnv();
- (*mEnv)->CallStaticVoidMethod(mEnv, mActivityClass, midSetWindowStyle, fullscreen ? 1 : 0);
+ 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 *mEnv = Android_JNI_GetEnv();
+ JNIEnv *env = Android_JNI_GetEnv();
- jstring jhint = (jstring)((*mEnv)->NewStringUTF(mEnv, (hint ? hint : "")));
- (*mEnv)->CallStaticVoidMethod(mEnv, mActivityClass, midSetOrientation, w, h, (resizable? 1 : 0), jhint);
- (*mEnv)->DeleteLocalRef(mEnv, jhint);
+ 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])
@@ -999,81 +1431,24 @@
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 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 iscapture, SDL_AudioSpec *spec)
{
int audioformat;
- int numBufferFrames;
jobject jbufobj = NULL;
jobject result;
int *resultElements;
jboolean isCopy;
JNIEnv *env = Android_JNI_GetEnv();
-
- if (!env) {
- LOGE("callback_handler: failed to attach current thread");
- }
- Android_JNI_SetupThread();
switch (spec->format) {
case AUDIO_U8:
@@ -1172,7 +1547,6 @@
audioBufferFormat = audioformat;
audioBuffer = jbufobj;
}
- numBufferFrames = (*env)->GetArrayLength(env, (jarray)jbufobj);
if (!iscapture) {
isCopy = JNI_FALSE;
@@ -1192,6 +1566,11 @@
}
}
return 0;
+}
+
+SDL_DisplayOrientation Android_JNI_GetDisplayOrientation(void)
+{
+ return displayOrientation;
}
int Android_JNI_GetDisplayDPI(float *ddpi, float *xdpi, float *ydpi)
@@ -1233,20 +1612,20 @@
void Android_JNI_WriteAudioBuffer(void)
{
- JNIEnv *mAudioEnv = Android_JNI_GetEnv();
+ JNIEnv *env = Android_JNI_GetEnv();
switch (audioBufferFormat) {
case ENCODING_PCM_8BIT:
- (*mAudioEnv)->ReleaseByteArrayElements(mAudioEnv, (jbyteArray)audioBuffer, (jbyte *)audioBufferPinned, JNI_COMMIT);
- (*mAudioEnv)->CallStaticVoidMethod(mAudioEnv, mAudioManagerClass, midAudioWriteByteBuffer, (jbyteArray)audioBuffer);
+ (*env)->ReleaseByteArrayElements(env, (jbyteArray)audioBuffer, (jbyte *)audioBufferPinned, JNI_COMMIT);
+ (*env)->CallStaticVoidMethod(env, mAudioManagerClass, midAudioWriteByteBuffer, (jbyteArray)audioBuffer);
break;
case ENCODING_PCM_16BIT:
- (*mAudioEnv)->ReleaseShortArrayElements(mAudioEnv, (jshortArray)audioBuffer, (jshort *)audioBufferPinned, JNI_COMMIT);
- (*mAudioEnv)->CallStaticVoidMethod(mAudioEnv, mAudioManagerClass, midAudioWriteShortBuffer, (jshortArray)audioBuffer);
+ (*env)->ReleaseShortArrayElements(env, (jshortArray)audioBuffer, (jshort *)audioBufferPinned, JNI_COMMIT);
+ (*env)->CallStaticVoidMethod(env, mAudioManagerClass, midAudioWriteShortBuffer, (jshortArray)audioBuffer);
break;
case ENCODING_PCM_FLOAT:
- (*mAudioEnv)->ReleaseFloatArrayElements(mAudioEnv, (jfloatArray)audioBuffer, (jfloat *)audioBufferPinned, JNI_COMMIT);
- (*mAudioEnv)->CallStaticVoidMethod(mAudioEnv, mAudioManagerClass, midAudioWriteFloatBuffer, (jfloatArray)audioBuffer);
+ (*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");
@@ -1260,7 +1639,7 @@
{
JNIEnv *env = Android_JNI_GetEnv();
jboolean isCopy = JNI_FALSE;
- jint br;
+ jint br = -1;
switch (captureBufferFormat) {
case ENCODING_PCM_8BIT:
@@ -1269,7 +1648,7 @@
if (br > 0) {
jbyte *ptr = (*env)->GetByteArrayElements(env, (jbyteArray)captureBuffer, &isCopy);
SDL_memcpy(buffer, ptr, br);
- (*env)->ReleaseByteArrayElements(env, (jbyteArray)captureBuffer, (jbyte *)ptr, JNI_ABORT);
+ (*env)->ReleaseByteArrayElements(env, (jbyteArray)captureBuffer, ptr, JNI_ABORT);
}
break;
case ENCODING_PCM_16BIT:
@@ -1279,7 +1658,7 @@
jshort *ptr = (*env)->GetShortArrayElements(env, (jshortArray)captureBuffer, &isCopy);
br *= sizeof(Sint16);
SDL_memcpy(buffer, ptr, br);
- (*env)->ReleaseShortArrayElements(env, (jshortArray)captureBuffer, (jshort *)ptr, JNI_ABORT);
+ (*env)->ReleaseShortArrayElements(env, (jshortArray)captureBuffer, ptr, JNI_ABORT);
}
break;
case ENCODING_PCM_FLOAT:
@@ -1289,7 +1668,7 @@
jfloat *ptr = (*env)->GetFloatArrayElements(env, (jfloatArray)captureBuffer, &isCopy);
br *= sizeof(float);
SDL_memcpy(buffer, ptr, br);
- (*env)->ReleaseFloatArrayElements(env, (jfloatArray)captureBuffer, (jfloat *)ptr, JNI_ABORT);
+ (*env)->ReleaseFloatArrayElements(env, (jfloatArray)captureBuffer, ptr, JNI_ABORT);
}
break;
default:
@@ -1364,45 +1743,52 @@
}
}
+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 SDL_bool Android_JNI_ExceptionOccurred(SDL_bool silent)
{
- JNIEnv *mEnv = Android_JNI_GetEnv();
+ JNIEnv *env = Android_JNI_GetEnv();
jthrowable exception;
- SDL_assert(LocalReferenceHolder_IsActive());
+ /* Detect mismatch LocalReferenceHolder_Init/Cleanup */
+ SDL_assert(SDL_AtomicGet(&s_active) > 0);
- exception = (*mEnv)->ExceptionOccurred(mEnv);
+ 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;
+ const char *exceptionNameUTF8;
jstring exceptionMessage;
- mid = (*mEnv)->GetMethodID(mEnv, classClass, "getName", "()Ljava/lang/String;");
- exceptionName = (jstring)(*mEnv)->CallObjectMethod(mEnv, exceptionClass, mid);
- 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;");
- 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 SDL_TRUE;
@@ -1411,7 +1797,7 @@
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__);
@@ -1428,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;
}
@@ -1437,40 +1823,40 @@
ctx->hidden.androidio.position = 0;
/* context = SDLActivity.getContext(); */
- context = (*mEnv)->CallStaticObjectMethod(mEnv, mActivityClass, midGetContext);
+ 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);
+ 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);
+ 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);
+ 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);
@@ -1484,12 +1870,12 @@
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 */);
+ inputStream = (*env)->CallObjectMethod(env, assetManager, mid, fileNameJString, 1 /* ACCESS_RANDOM */);
if (Android_JNI_ExceptionOccurred(SDL_FALSE)) {
/* Try fallback to APK expansion files */
- inputStream = (*mEnv)->CallStaticObjectMethod(mEnv, mActivityClass, midOpenAPKExpansionInputStream, fileNameJString);
+ 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.
@@ -1499,7 +1885,7 @@
}
}
- 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
@@ -1509,29 +1895,29 @@
*/
/* 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);
+ 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);
+ 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;
}
@@ -1540,18 +1926,18 @@
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);
}
}
@@ -1560,15 +1946,15 @@
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)) {
+ if (!LocalReferenceHolder_Init(&refs, env)) {
LocalReferenceHolder_Cleanup(&refs);
return -1;
}
@@ -1578,8 +1964,8 @@
return -1;
}
- 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;
@@ -1590,7 +1976,7 @@
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__);
@@ -1613,7 +1999,7 @@
jlong bytesRemaining = (jlong) (size * maxnum);
jlong bytesMax = (jlong) (ctx->hidden.androidio.size - ctx->hidden.androidio.position);
int bytesRead = 0;
- JNIEnv *mEnv;
+ JNIEnv *env;
jobject readableByteChannel;
jmethodID readMethod;
jobject byteBuffer;
@@ -1621,19 +2007,19 @@
/* Don't read more bytes than those that remain in the file, otherwise we get an exception */
if (bytesRemaining > bytesMax) bytesRemaining = bytesMax;
- mEnv = Android_JNI_GetEnv();
- if (!LocalReferenceHolder_Init(&refs, mEnv)) {
+ env = Android_JNI_GetEnv();
+ if (!LocalReferenceHolder_Init(&refs, env)) {
LocalReferenceHolder_Cleanup(&refs);
return 0;
}
readableByteChannel = (jobject)ctx->hidden.androidio.readableByteChannelRef;
readMethod = (jmethodID)ctx->hidden.androidio.readMethod;
- byteBuffer = (*mEnv)->NewDirectByteBuffer(mEnv, buffer, bytesRemaining);
+ 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(SDL_FALSE)) {
LocalReferenceHolder_Cleanup(&refs);
@@ -1653,36 +2039,36 @@
}
}
-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, SDL_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);
+ (*env)->CallVoidMethod(env, inputStream, mid);
+ (*env)->DeleteGlobalRef(env, (jobject)ctx->hidden.androidio.assetFileDescriptorRef);
if (Android_JNI_ExceptionOccurred(SDL_FALSE)) {
result = -1;
}
@@ -1691,11 +2077,11 @@
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);
+ (*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;
}
@@ -1711,12 +2097,12 @@
}
-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;
@@ -1736,7 +2122,6 @@
default:
return SDL_SetError("Unknown value for 'whence'");
}
- whence = SEEK_SET;
ret = lseek(ctx->hidden.androidio.fd, (off_t)offset, SEEK_SET);
if (ret == -1) return -1;
@@ -1778,7 +2163,7 @@
if (amount > movement) {
amount = movement;
}
- 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;
@@ -1800,14 +2185,14 @@
}
-int Android_JNI_FileClose(SDL_RWops* ctx)
+int Android_JNI_FileClose(SDL_RWops *ctx)
{
return Internal_Android_JNI_FileClose(ctx, SDL_TRUE);
}
-int Android_JNI_SetClipboardText(const char* text)
+int Android_JNI_SetClipboardText(const char *text)
{
- JNIEnv* env = Android_JNI_GetEnv();
+ JNIEnv *env = Android_JNI_GetEnv();
jstring string = (*env)->NewStringUTF(env, text);
(*env)->CallStaticVoidMethod(env, mActivityClass, midClipboardSetText, string);
(*env)->DeleteLocalRef(env, string);
@@ -1816,26 +2201,26 @@
char* Android_JNI_GetClipboardText(void)
{
- JNIEnv* env = Android_JNI_GetEnv();
- char* text = NULL;
+ JNIEnv *env = Android_JNI_GetEnv();
+ char *text = NULL;
jstring string;
-
+
string = (*env)->CallStaticObjectMethod(env, mActivityClass, midClipboardGetText);
if (string) {
- const char* utf = (*env)->GetStringUTFChars(env, string, 0);
+ const char *utf = (*env)->GetStringUTFChars(env, string, 0);
if (utf) {
text = SDL_strdup(utf);
(*env)->ReleaseStringUTFChars(env, string, utf);
}
(*env)->DeleteLocalRef(env, string);
}
-
+
return (text == NULL) ? SDL_strdup("") : text;
}
SDL_bool Android_JNI_HasClipboardText(void)
{
- JNIEnv* env = Android_JNI_GetEnv();
+ JNIEnv *env = Android_JNI_GetEnv();
jboolean retval = (*env)->CallStaticBooleanMethod(env, mActivityClass, midClipboardHasText);
return (retval == JNI_TRUE) ? SDL_TRUE : SDL_FALSE;
}
@@ -1844,10 +2229,10 @@
* 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;
@@ -1889,7 +2274,7 @@
#define GET_INT_EXTRA(var, key) \
int var; \
iname = (*env)->NewStringUTF(env, key); \
- var = (*env)->CallIntMethod(env, intent, imid, iname, -1); \
+ (var) = (*env)->CallIntMethod(env, intent, imid, iname, -1); \
(*env)->DeleteLocalRef(env, iname);
bmid = (*env)->GetMethodID(env, cls, "getBooleanExtra", "(Ljava/lang/String;Z)Z");
@@ -1898,7 +2283,7 @@
#define GET_BOOL_EXTRA(var, key) \
int var; \
bname = (*env)->NewStringUTF(env, key); \
- var = (*env)->CallBooleanMethod(env, intent, bmid, bname, JNI_FALSE); \
+ (var) = (*env)->CallBooleanMethod(env, intent, bmid, bname, JNI_FALSE); \
(*env)->DeleteLocalRef(env, bname);
if (plugged) {
@@ -1961,36 +2346,10 @@
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 */
- jintArray array = (jintArray) (*env)->CallStaticObjectMethod(env, mActivityClass, midInputGetInputDeviceIds, 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;
-}
-
-/* sets the mSeparateMouseAndTouch field */
-void Android_JNI_SetSeparateMouseAndTouch(SDL_bool new_value)
-{
- JNIEnv *env = Android_JNI_GetEnv();
- (*env)->SetStaticBooleanField(env, mActivityClass, fidSeparateMouseAndTouch, new_value ? JNI_TRUE : JNI_FALSE);
+/* Add all touch devices */
+void Android_JNI_InitTouch() {
+ JNIEnv *env = Android_JNI_GetEnv();
+ (*env)->CallStaticVoidMethod(env, mActivityClass, midInitTouch);
}
void Android_JNI_PollInputDevices(void)
@@ -2051,11 +2410,11 @@
Android_JNI_SendMessage(COMMAND_TEXTEDIT_HIDE, 0);
}
-SDL_bool Android_JNI_IsScreenKeyboardShown()
+SDL_bool Android_JNI_IsScreenKeyboardShown(void)
{
- JNIEnv *mEnv = Android_JNI_GetEnv();
+ JNIEnv *env = Android_JNI_GetEnv();
jboolean is_shown = 0;
- is_shown = (*mEnv)->CallStaticBooleanMethod(mEnv, mActivityClass, midIsScreenKeyboardShown);
+ is_shown = (*env)->CallStaticBooleanMethod(env, mActivityClass, midIsScreenKeyboardShown);
return is_shown;
}
@@ -2090,11 +2449,19 @@
button_texts = (*env)->NewObjectArray(env, messageboxdata->numbuttons,
clazz, NULL);
for (i = 0; i < messageboxdata->numbuttons; ++i) {
- temp = messageboxdata->buttons[i].flags;
+ 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 = messageboxdata->buttons[i].buttonid;
+ temp = sdlButton->buttonid;
(*env)->SetIntArrayRegion(env, button_ids, i, 1, &temp);
- text = (*env)->NewStringUTF(env, messageboxdata->buttons[i].text);
+ text = (*env)->NewStringUTF(env, sdlButton->text);
(*env)->SetObjectArrayElement(env, button_texts, i, text);
(*env)->DeleteLocalRef(env, text);
}
@@ -2102,7 +2469,7 @@
if (messageboxdata->colorScheme) {
colors = (*env)->NewIntArray(env, SDL_MESSAGEBOX_COLOR_MAX);
for (i = 0; i < SDL_MESSAGEBOX_COLOR_MAX; ++i) {
- temp = (0xFF << 24) |
+ temp = (0xFFU << 24) |
(messageboxdata->colorScheme->colors[i].r << 16) |
(messageboxdata->colorScheme->colors[i].g << 8) |
(messageboxdata->colorScheme->colors[i].b << 0);
@@ -2170,6 +2537,18 @@
return (*env)->CallStaticObjectMethod(env, mActivityClass, midGetContext);
}
+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();
@@ -2197,7 +2576,7 @@
void SDL_AndroidBackButton(void)
{
JNIEnv *env = Android_JNI_GetEnv();
- return (*env)->CallStaticVoidMethod(env, mActivityClass, midManualBackButton);
+ (*env)->CallStaticVoidMethod(env, mActivityClass, midManualBackButton);
}
const char * SDL_AndroidGetInternalStoragePath(void)
@@ -2356,14 +2735,14 @@
int Android_JNI_CreateCustomCursor(SDL_Surface *surface, int hot_x, int hot_y)
{
- JNIEnv *mEnv = Android_JNI_GetEnv();
+ JNIEnv *env = Android_JNI_GetEnv();
int custom_cursor = 0;
jintArray pixels;
- pixels = (*mEnv)->NewIntArray(mEnv, surface->w * surface->h);
+ pixels = (*env)->NewIntArray(env, surface->w * surface->h);
if (pixels) {
- (*mEnv)->SetIntArrayRegion(mEnv, pixels, 0, surface->w * surface->h, (int *)surface->pixels);
- custom_cursor = (*mEnv)->CallStaticIntMethod(mEnv, mActivityClass, midCreateCustomCursor, pixels, surface->w, surface->h, hot_x, hot_y);
- (*mEnv)->DeleteLocalRef(mEnv, 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();
}
@@ -2373,28 +2752,49 @@
SDL_bool Android_JNI_SetCustomCursor(int cursorID)
{
- JNIEnv *mEnv = Android_JNI_GetEnv();
- return (*mEnv)->CallStaticBooleanMethod(mEnv, mActivityClass, midSetCustomCursor, cursorID);
+ JNIEnv *env = Android_JNI_GetEnv();
+ return (*env)->CallStaticBooleanMethod(env, mActivityClass, midSetCustomCursor, cursorID);
}
SDL_bool Android_JNI_SetSystemCursor(int cursorID)
{
- JNIEnv *mEnv = Android_JNI_GetEnv();
- return (*mEnv)->CallStaticBooleanMethod(mEnv, mActivityClass, midSetSystemCursor, cursorID);
+ JNIEnv *env = Android_JNI_GetEnv();
+ return (*env)->CallStaticBooleanMethod(env, mActivityClass, midSetSystemCursor, cursorID);
}
-SDL_bool Android_JNI_SupportsRelativeMouse()
+SDL_bool Android_JNI_SupportsRelativeMouse(void)
{
- JNIEnv *mEnv = Android_JNI_GetEnv();
- return (*mEnv)->CallStaticBooleanMethod(mEnv, mActivityClass, midSupportsRelativeMouse);
+ JNIEnv *env = Android_JNI_GetEnv();
+ return (*env)->CallStaticBooleanMethod(env, mActivityClass, midSupportsRelativeMouse);
}
SDL_bool Android_JNI_SetRelativeMouseEnabled(SDL_bool enabled)
{
- JNIEnv *mEnv = Android_JNI_GetEnv();
- return (*mEnv)->CallStaticBooleanMethod(mEnv, mActivityClass, midSetRelativeMouseEnabled, (enabled == 1));
+ 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__ */
--
Gitblit v1.9.3