/*

Simple DirectMedia Layer

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages

arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it

freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not

claim that you wrote the original software. If you use this software

in a product, an acknowledgment in the product documentation would be

appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be

misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

*/

#include "../../SDL_internal.h"

#include "SDL_stdinc.h"

#include "SDL_assert.h"

#include "SDL_hints.h"

#include "SDL_log.h"

#ifdef __ANDROID__

#include "SDL_system.h"

#include "SDL_android.h"

#include <EGL/egl.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 <android/log.h>

#include <pthread.h>

#include <sys/types.h>

#include <unistd.h>

/* #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)

#define CONCAT2(prefix, class, function) Java_ ## prefix ## _ ## class ## _ ## function

#define SDL_JAVA_INTERFACE(function) CONCAT1(SDL_JAVA_PREFIX, SDLActivity, function)

#define SDL_JAVA_INTERFACE_INPUT_CONNECTION(function) CONCAT1(SDL_JAVA_PREFIX, SDLInputConnection, function)

/* Java class SDLActivity */

JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeDropFile)(

JNIEnv* env, jclass jcls,

jstring filename);

JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeResize)(

JNIEnv* env, jclass jcls,

jint width, jint height, jint format, jfloat rate);

JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(onNativePadDown)(

JNIEnv* env, jclass jcls,

jint device_id, jint keycode);

JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(onNativePadUp)(

JNIEnv* env, jclass jcls,

jint device_id, jint keycode);

JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeJoy)(

JNIEnv* env, jclass jcls,

jint device_id, jint axis, jfloat value);

JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeHat)(

JNIEnv* env, jclass jcls,

jint device_id, jint hat_id, jint x, jint y);

JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(nativeAddJoystick)(

JNIEnv* env, jclass jcls,

jint nbuttons, jint naxes, jint nhats, jint nballs);

JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(nativeRemoveJoystick)(

JNIEnv* env, jclass jcls,

jint device_id);

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 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);

JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeAccel)(

JNIEnv* env, jclass jcls,

jfloat x, jfloat y, jfloat z);

JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(nativeLowMemory)(

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 jstring JNICALL SDL_JAVA_INTERFACE(nativeGetHint)(

JNIEnv* env, jclass cls,

jstring name);

/* 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(nativeSetComposingText)(

JNIEnv* env, jclass cls,

jstring text, jint newCursorPosition);

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

/* #define DEBUG_JNI */

static void Android_JNI_ThreadDestroyed(void*);

/*******************************************************************************

This file links the Java side of Android with libsdl

*******************************************************************************/

#include <jni.h>

/*******************************************************************************

Globals

*******************************************************************************/

static pthread_key_t mThreadKey;

static JavaVM* mJavaVM;

/* Main activity */

static jclass mActivityClass;

/* method signatures */

static jmethodID midGetNativeSurface;

static jmethodID midAudioWriteShortBuffer;

static jmethodID midAudioWriteByteBuffer;

static jmethodID midAudioClose;

static jmethodID midCaptureOpen;

static jmethodID midCaptureReadShortBuffer;

static jmethodID midCaptureReadByteBuffer;

static jmethodID midCaptureClose;

static jmethodID midPollHapticDevices;

static jmethodID midHapticRun;

static jmethodID midSetActivityTitle;

static jmethodID midSetOrientation;

static jmethodID midGetContext;

static jmethodID midInputGetInputDeviceIds;

static jmethodID midSendMessage;

static jmethodID midShowTextInput;

static jmethodID midIsScreenKeyboardShown;

static jmethodID midGetSystemServiceFromUiThread;

/* static fields */

static jfieldID fidSeparateMouseAndTouch;

/* Accelerometer data storage */

static float fLastAccelerometer[3];

static SDL_bool bHasNewData;

/*******************************************************************************

Functions called by JNI

*******************************************************************************/

/* Library init */

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)

{

JNIEnv *env;

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;

}

/*

* 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();

return JNI_VERSION_1_4;

}

/* Called before SDL_main() to initialize JNI bindings */

JNIEXPORT void JNICALL SDL_Android_Init(JNIEnv* mEnv, jclass cls)

{

__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;");

midAudioOpen = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

"audioOpen", "(IZZI)I");

midAudioWriteShortBuffer = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

"audioWriteShortBuffer", "([S)V");

midAudioWriteByteBuffer = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

"audioWriteByteBuffer", "([B)V");

midAudioClose = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

"audioClose", "()V");

midCaptureOpen = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

"captureOpen", "(IZZI)I");

midCaptureReadShortBuffer = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

"captureReadShortBuffer", "([SZ)I");

midCaptureReadByteBuffer = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

"captureReadByteBuffer", "([BZ)I");

midCaptureClose = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

"captureClose", "()V");

midPollInputDevices = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

"pollInputDevices", "()V");

midPollHapticDevices = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

"pollHapticDevices", "()V");

midHapticRun = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

"hapticRun", "(II)V");

midSetActivityTitle = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

"setActivityTitle","(Ljava/lang/String;)Z");

midSetOrientation = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

"setOrientation","(IIZLjava/lang/String;)V");

midGetContext = (*mEnv)->GetStaticMethodID(mEnv, mActivityClass,

"getContext","()Landroid/content/Context;");

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");

midGetSystemServiceFromUiThread = (*mEnv)->GetMethodID(mEnv, mActivityClass,

"getSystemServiceFromUiThread", "(Ljava/lang/String;)Ljava/lang/Object;");

bHasNewData = SDL_FALSE;

!midPollInputDevices || !midPollHapticDevices || !midHapticRun ||

!midSetActivityTitle || !midSetOrientation || !midGetContext || !midInputGetInputDeviceIds ||

!midSendMessage || !midShowTextInput || !midIsScreenKeyboardShown || !midGetSystemServiceFromUiThread) {

__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL: Couldn't locate Java callbacks, check that they're named and typed correctly");

}

fidSeparateMouseAndTouch = (*mEnv)->GetStaticFieldID(mEnv, mActivityClass, "mSeparateMouseAndTouch", "Z");

if (!fidSeparateMouseAndTouch) {

__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL: Couldn't locate Java static fields, check that they're named and typed correctly");

}

__android_log_print(ANDROID_LOG_INFO, "SDL", "SDL_Android_Init() finished!");

}

/* Drop file */

JNIEnv* env, jclass jcls,

jstring filename)

{

const char *path = (*env)->GetStringUTFChars(env, filename, NULL);

}

/* Resize */

JNIEnv* env, jclass jcls,

jint width, jint height, jint format, jfloat rate)

{

Android_SetScreenResolution(width, height, format, rate);

}

/* Paddown */

JNIEnv* env, jclass jcls,

jint device_id, jint keycode)

{

return Android_OnPadDown(device_id, keycode);

}

/* Padup */

JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(onNativePadUp)(

JNIEnv* env, jclass jcls,

jint device_id, jint keycode)

{

return Android_OnPadUp(device_id, keycode);

}

/* Joy */

JNIEnv* env, jclass jcls,

jint device_id, jint axis, jfloat value)

{

Android_OnJoy(device_id, axis, value);

}

/* POV Hat */

JNIEnv* env, jclass jcls,

jint device_id, jint hat_id, jint x, jint y)

{

Android_OnHat(device_id, hat_id, x, y);

}

JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(nativeAddJoystick)(

JNIEnv* env, jclass jcls,

{

int retval;

const char *name = (*env)->GetStringUTFChars(env, device_name, NULL);

retval = Android_AddJoystick(device_id, name, (SDL_bool) is_accelerometer, nbuttons, naxes, nhats, nballs);

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

return retval;

}

JNIEXPORT jint JNICALL SDL_JAVA_INTERFACE(nativeRemoveJoystick)(

JNIEnv* env, jclass jcls,

jint device_id)

{

return Android_RemoveJoystick(device_id);

}

JNIEXPORT jint JNICALL Java_org_libsdl_app_SDLActivity_nativeAddHaptic(

JNIEnv* env, jclass jcls, jint device_id, jstring device_name)

{

int retval;

const char *name = (*env)->GetStringUTFChars(env, device_name, NULL);

retval = Android_AddHaptic(device_id, name);

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

return retval;

}

JNIEXPORT jint JNICALL Java_org_libsdl_app_SDLActivity_nativeRemoveHaptic(

JNIEnv* env, jclass jcls, jint device_id)

{

return Android_RemoveHaptic(device_id);

}

/* Surface Created */

{

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 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);

}

}

/* Surface Destroyed */

{

/* 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 */

}

/* Keydown */

JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyDown)(

JNIEnv* env, jclass jcls,

jint keycode)

{

Android_OnKeyDown(keycode);

}

/* Keyup */

JNIEXPORT void JNICALL SDL_JAVA_INTERFACE(onNativeKeyUp)(

JNIEnv* env, jclass jcls,

jint keycode)

{

Android_OnKeyUp(keycode);

}

/* Keyboard Focus Lost */

JNIEnv* env, jclass jcls)

{

/* Calling SDL_StopTextInput will take care of hiding the keyboard and cleaning up the DummyText widget */

SDL_StopTextInput();

}

/* Touch */

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);

}

/* Mouse */

JNIEnv* env, jclass jcls,

jint button, jint action, jfloat x, jfloat y)

{

Android_OnMouse(button, action, x, y);

}

/* Accelerometer */

JNIEnv* env, jclass jcls,

jfloat x, jfloat y, jfloat z)

{

fLastAccelerometer[0] = x;

fLastAccelerometer[1] = y;

fLastAccelerometer[2] = z;

bHasNewData = SDL_TRUE;

}

/* Low memory */

JNIEnv* env, jclass cls)

{

SDL_SendAppEvent(SDL_APP_LOWMEMORY);

}

/* Quit */

JNIEnv* env, jclass cls)

{

/* Discard previous events. The user should have handled state storage

* in SDL_APP_WILLENTERBACKGROUND. After nativeQuit() 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);

/* 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);

}

/* Pause */

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);

}

}

/* Resume */

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);

}

}

JNIEnv* env, jclass cls,

jstring text, jint newCursorPosition)

{

const char *utftext = (*env)->GetStringUTFChars(env, text, NULL);

SDL_SendKeyboardText(utftext);

(*env)->ReleaseStringUTFChars(env, text, utftext);

}

JNIEnv* env, jclass cls,

jstring text, jint newCursorPosition)

{

const char *utftext = (*env)->GetStringUTFChars(env, text, NULL);

SDL_SendEditingText(utftext, 0, 0);

(*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;

}

/*******************************************************************************

Functions called by SDL into Java

*******************************************************************************/

static int s_active = 0;

struct LocalReferenceHolder

{

JNIEnv *m_env;

const char *m_func;

};

static struct LocalReferenceHolder LocalReferenceHolder_Setup(const char *func)

{

struct LocalReferenceHolder refholder;

refholder.m_env = NULL;

refholder.m_func = func;

#ifdef DEBUG_JNI

SDL_Log("Entering function %s", func);

#endif

return refholder;

}

static SDL_bool LocalReferenceHolder_Init(struct LocalReferenceHolder *refholder, JNIEnv *env)

{

const int capacity = 16;

if ((*env)->PushLocalFrame(env, capacity) < 0) {

SDL_SetError("Failed to allocate enough JVM local references");

return SDL_FALSE;

}

++s_active;

refholder->m_env = env;

return SDL_TRUE;

}

static void LocalReferenceHolder_Cleanup(struct LocalReferenceHolder *refholder)

{

#ifdef DEBUG_JNI

SDL_Log("Leaving function %s", refholder->m_func);

#endif

if (refholder->m_env) {

JNIEnv* env = refholder->m_env;

(*env)->PopLocalFrame(env, NULL);

--s_active;

}

}

static SDL_bool LocalReferenceHolder_IsActive(void)

{

return s_active > 0;

}

ANativeWindow* Android_JNI_GetNativeWindow(void)

{

ANativeWindow* anw;

jobject s;

JNIEnv *env = Android_JNI_GetEnv();

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

anw = ANativeWindow_fromSurface(env, s);

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

return anw;

}

void Android_JNI_SetActivityTitle(const char *title)

{

JNIEnv *mEnv = Android_JNI_GetEnv();

jstring jtitle = (jstring)((*mEnv)->NewStringUTF(mEnv, title));

(*mEnv)->CallStaticBooleanMethod(mEnv, mActivityClass, midSetActivityTitle, jtitle);

(*mEnv)->DeleteLocalRef(mEnv, jtitle);

}

void Android_JNI_SetOrientation(int w, int h, int resizable, const char *hint)

{

JNIEnv *mEnv = 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);

}

SDL_bool Android_JNI_GetAccelerometerValues(float values[3])

{

int i;

SDL_bool retval = SDL_FALSE;

if (bHasNewData) {

for (i = 0; i < 3; ++i) {

values[i] = fLastAccelerometer[i];

}

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 jobject audioBuffer = NULL;

static void* audioBufferPinned = NULL;

static jboolean captureBuffer16Bit = JNI_FALSE;

static jobject captureBuffer = NULL;

{

jboolean audioBufferStereo;

int audioBufferFrames;

JNIEnv *env = Android_JNI_GetEnv();

if (!env) {

LOGE("callback_handler: failed to attach current thread");

}

Android_JNI_SetupThread();

audioBufferStereo = channelCount > 1;

if (iscapture) {

__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "SDL audio: opening device for capture");

captureBuffer16Bit = is16Bit;

if ((*env)->CallStaticIntMethod(env, mActivityClass, midCaptureOpen, sampleRate, audioBuffer16Bit, audioBufferStereo, desiredBufferFrames) != 0) {

/* Error during audio initialization */

__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: error on AudioRecord initialization!");

return 0;

}

} else {

__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "SDL audio: opening device for output");

audioBuffer16Bit = is16Bit;

if ((*env)->CallStaticIntMethod(env, mActivityClass, midAudioOpen, sampleRate, audioBuffer16Bit, audioBufferStereo, desiredBufferFrames) != 0) {

/* Error during audio initialization */

__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: error on AudioTrack initialization!");

return 0;

}

}

/* 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) {

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

}

}

else {

jbyteArray audioBufferLocal = (*env)->NewByteArray(env, desiredBufferFrames * (audioBufferStereo ? 2 : 1));

if (audioBufferLocal) {

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

}

}

__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: could not allocate an audio buffer!");

return 0;

}

if (iscapture) {

captureBuffer = jbufobj;

} else {

audioBuffer = jbufobj;

}

if (is16Bit) {

if (!iscapture) {

audioBufferPinned = (*env)->GetShortArrayElements(env, (jshortArray)audioBuffer, &isCopy);

}

audioBufferFrames = (*env)->GetArrayLength(env, (jshortArray)audioBuffer);

} else {

if (!iscapture) {

audioBufferPinned = (*env)->GetByteArrayElements(env, (jbyteArray)audioBuffer, &isCopy);

}

audioBufferFrames = (*env)->GetArrayLength(env, (jbyteArray)audioBuffer);

}

if (audioBufferStereo) {

audioBufferFrames /= 2;

}

return audioBufferFrames;

}

void * Android_JNI_GetAudioBuffer(void)

{

return audioBufferPinned;

}

void Android_JNI_WriteAudioBuffer(void)

{

JNIEnv *mAudioEnv = 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);

}

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

}

int Android_JNI_CaptureAudioBuffer(void *buffer, int buflen)

{

JNIEnv *env = Android_JNI_GetEnv();

jboolean isCopy = JNI_FALSE;

jint br;

if (captureBuffer16Bit) {

SDL_assert((*env)->GetArrayLength(env, (jshortArray)captureBuffer) == (buflen / 2));

br = (*env)->CallStaticIntMethod(env, mActivityClass, midCaptureReadShortBuffer, (jshortArray)captureBuffer, JNI_TRUE);

if (br > 0) {

jshort *ptr = (*env)->GetShortArrayElements(env, (jshortArray)captureBuffer, &isCopy);

br *= 2;

SDL_memcpy(buffer, ptr, br);

(*env)->ReleaseShortArrayElements(env, (jshortArray)captureBuffer, (jshort *)ptr, JNI_ABORT);

}

} else {

SDL_assert((*env)->GetArrayLength(env, (jshortArray)captureBuffer) == buflen);

br = (*env)->CallStaticIntMethod(env, mActivityClass, 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, (jbyte *)ptr, JNI_ABORT);

}

}

return (int) br;

}

void Android_JNI_FlushCapturedAudio(void)

{

JNIEnv *env = Android_JNI_GetEnv();

if (captureBuffer16Bit) {

const jint len = (*env)->GetArrayLength(env, (jshortArray)captureBuffer);

while ((*env)->CallStaticIntMethod(env, mActivityClass, midCaptureReadShortBuffer, (jshortArray)captureBuffer, JNI_FALSE) == len) { /* spin */ }

} else {

const jint len = (*env)->GetArrayLength(env, (jbyteArray)captureBuffer);

while ((*env)->CallStaticIntMethod(env, mActivityClass, midCaptureReadByteBuffer, (jbyteArray)captureBuffer, JNI_FALSE) == len) { /* spin */ }

}

if (captureBuffer16Bit) {

(*env)->CallStaticIntMethod(env, mActivityClass, midCaptureReadShortBuffer, (jshortArray)captureBuffer, JNI_FALSE);

} else {

(*env)->CallStaticIntMethod(env, mActivityClass, midCaptureReadByteBuffer, (jbyteArray)captureBuffer, JNI_FALSE);

}

void Android_JNI_CloseAudioDevice(const int iscapture)

{

JNIEnv *env = Android_JNI_GetEnv();

if (iscapture) {

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

if (captureBuffer) {

(*env)->DeleteGlobalRef(env, captureBuffer);

captureBuffer = NULL;

}

} else {

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

if (audioBuffer) {

(*env)->DeleteGlobalRef(env, audioBuffer);

audioBuffer = NULL;

audioBufferPinned = NULL;

}

}

}

/* 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();

jthrowable exception;

SDL_assert(LocalReferenceHolder_IsActive());

if (exception != NULL) {

jmethodID mid;

/* Until this happens most JNI operations have undefined behaviour */

(*mEnv)->ExceptionClear(mEnv);

if (!silent) {

jclass exceptionClass = (*mEnv)->GetObjectClass(mEnv, exception);

jclass classClass = (*mEnv)->FindClass(mEnv, "java/lang/Class");

jstring exceptionName;

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 = (*mEnv)->GetMethodID(mEnv, exceptionClass, "getMessage", "()Ljava/lang/String;");

if (exceptionMessage != NULL) {

const char* exceptionMessageUTF8 = (*mEnv)->GetStringUTFChars(mEnv, exceptionMessage, 0);

SDL_SetError("%s: %s", exceptionNameUTF8, exceptionMessageUTF8);

(*mEnv)->ReleaseStringUTFChars(mEnv, exceptionMessage, exceptionMessageUTF8);

} else {

SDL_SetError("%s", exceptionNameUTF8);

}

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

}

return SDL_TRUE;

}

return SDL_FALSE;

}

static int Internal_Android_JNI_FileOpen(SDL_RWops* ctx)

{

struct LocalReferenceHolder refs = LocalReferenceHolder_Setup(__FUNCTION__);

int result = 0;

jmethodID mid;

jobject context;

jobject assetManager;

jobject inputStream;

jclass channels;

jobject readableByteChannel;

jstring fileNameJString;

jobject fd;

jclass fdCls;

jfieldID descriptor;

JNIEnv *mEnv = Android_JNI_GetEnv();

if (!LocalReferenceHolder_Init(&refs, mEnv)) {

goto failure;

}

fileNameJString = (jstring)ctx->hidden.androidio.fileNameRef;

ctx->hidden.androidio.position = 0;

/* context = SDLActivity.getContext(); */

/* assetManager = context.getAssets(); */

mid = (*mEnv)->GetMethodID(mEnv, (*mEnv)->GetObjectClass(mEnv, context),

"getAssets", "()Landroid/content/res/AssetManager;");

assetManager = (*mEnv)->CallObjectMethod(mEnv, 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