/*

  Simple DirectMedia Layer

  Copyright (C) 1997-2012 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

  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_config.h"

#include "SDL_stdinc.h"

#include "SDL_assert.h"

#ifdef __ANDROID__

#include "SDL_android.h"

extern "C" {

#include "../../events/SDL_events_c.h"

#include "../../video/android/SDL_androidkeyboard.h"

#include "../../video/android/SDL_androidtouch.h"

#include "../../video/android/SDL_androidvideo.h"

#include <android/log.h>

#define LOG_TAG "SDL_android"

//#define LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)

//#define LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)

#define LOGI(...) do {} while (false)

#define LOGE(...) do {} while (false)

/* Implemented in audio/android/SDL_androidaudio.c */

extern void Android_RunAudioThread();

} // C

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

 This file links the Java side of Android with libsdl

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

#include <jni.h>

#include <android/log.h>

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

                               Globals

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

static JavaVM* mJavaVM;

// Main activity

static jclass mActivityClass;

// method signatures

static jmethodID midCreateGLContext;

static jmethodID midFlipBuffers;

static jmethodID midAudioInit;

static jmethodID midAudioWriteShortBuffer;

static jmethodID midAudioWriteByteBuffer;

static jmethodID midAudioQuit;

// Accelerometer data storage

static float fLastAccelerometer[3];

static bool bHasNewData;

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

                 Functions called by JNI

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

// Library init

extern "C" jint JNI_OnLoad(JavaVM* vm, void* reserved)

{

    JNIEnv *env;

    mJavaVM = vm;

    LOGI("JNI_OnLoad called");

    if (mJavaVM->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {

        LOGE("Failed to get the environment using GetEnv()");

        return -1;

    }

    return JNI_VERSION_1_4;

}

// Called before SDL_main() to initialize JNI bindings

{

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

    midCreateGLContext = mEnv->GetStaticMethodID(mActivityClass,

                                "createGLContext","(II)Z");

    midFlipBuffers = mEnv->GetStaticMethodID(mActivityClass,

                                "flipBuffers","()V");

    midAudioInit = mEnv->GetStaticMethodID(mActivityClass, 

                                "audioInit", "(IZZI)Ljava/lang/Object;");

    midAudioWriteShortBuffer = mEnv->GetStaticMethodID(mActivityClass,

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

    midAudioWriteByteBuffer = mEnv->GetStaticMethodID(mActivityClass,

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

    midAudioQuit = mEnv->GetStaticMethodID(mActivityClass,

                                "audioQuit", "()V");

    bHasNewData = false;

    if(!midCreateGLContext || !midFlipBuffers || !midAudioInit ||

       !midAudioWriteShortBuffer || !midAudioWriteByteBuffer || !midAudioQuit) {

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

    }

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

}

// Resize

extern "C" void Java_org_libsdl_app_SDLActivity_onNativeResize(

                                    JNIEnv* env, jclass jcls,

                                    jint width, jint height, jint format)

{

    Android_SetScreenResolution(width, height, format);

}

// Keydown

extern "C" void Java_org_libsdl_app_SDLActivity_onNativeKeyDown(

                                    JNIEnv* env, jclass jcls, jint keycode)

{

    Android_OnKeyDown(keycode);

}

// Keyup

extern "C" void Java_org_libsdl_app_SDLActivity_onNativeKeyUp(

                                    JNIEnv* env, jclass jcls, jint keycode)

{

    Android_OnKeyUp(keycode);

}

// Touch

extern "C" void Java_org_libsdl_app_SDLActivity_onNativeTouch(

                                    JNIEnv* env, jclass jcls,

                                    jint touch_device_id_in, jint pointer_finger_id_in,

                                    jint action, jfloat x, jfloat y, jfloat p)

{

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

}

// Accelerometer

extern "C" void Java_org_libsdl_app_SDLActivity_onNativeAccel(

                                    JNIEnv* env, jclass jcls,

                                    jfloat x, jfloat y, jfloat z)

{

    fLastAccelerometer[0] = x;

    fLastAccelerometer[1] = y;

    fLastAccelerometer[2] = z;

    bHasNewData = true;

}

// Quit

extern "C" void Java_org_libsdl_app_SDLActivity_nativeQuit(

                                    JNIEnv* env, jclass cls)

{    

    // Inject a SDL_QUIT event

    SDL_SendQuit();

}

// Pause

extern "C" void Java_org_libsdl_app_SDLActivity_nativePause(

                                    JNIEnv* env, jclass cls)

{

    if (Android_Window) {

        /* Signal the pause semaphore so the event loop knows to pause and (optionally) block itself */

        if (!SDL_SemValue(Android_PauseSem)) SDL_SemPost(Android_PauseSem);

        SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_FOCUS_LOST, 0, 0);

        SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_MINIMIZED, 0, 0);

    }

}

// Resume

extern "C" void Java_org_libsdl_app_SDLActivity_nativeResume(

                                    JNIEnv* env, jclass cls)

{

    if (Android_Window) {

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

        SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_FOCUS_GAINED, 0, 0);

        SDL_SendWindowEvent(Android_Window, SDL_WINDOWEVENT_RESTORED, 0, 0);

    }

}

extern "C" void Java_org_libsdl_app_SDLActivity_nativeRunAudioThread(

                                    JNIEnv* env, jclass cls)

{

    /* This is the audio thread, with a different environment */

    Android_RunAudioThread();

}

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

             Functions called by SDL into Java

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

class LocalReferenceHolder

{

private:

    static int s_active;

public:

    static bool IsActive() {

        return s_active > 0;

    }

public:

    LocalReferenceHolder() : m_env(NULL) { }

    ~LocalReferenceHolder() {

        if (m_env) {

            m_env->PopLocalFrame(NULL);

            --s_active;

        }

    }

    bool init(JNIEnv *env, jint capacity = 16) {

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

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

            return false;

        }

        ++s_active;

        m_env = env;

        return true;

    }

protected:

    JNIEnv *m_env;

};

int LocalReferenceHolder::s_active;

extern "C" SDL_bool Android_JNI_CreateContext(int majorVersion, int minorVersion)

{

    if (mEnv->CallStaticBooleanMethod(mActivityClass, midCreateGLContext, majorVersion, minorVersion)) {

        return SDL_TRUE;

    } else {

        return SDL_FALSE;

    }

}

extern "C" void Android_JNI_SwapWindow()

{

    mEnv->CallStaticVoidMethod(mActivityClass, midFlipBuffers); 

}

extern "C" void Android_JNI_SetActivityTitle(const char *title)

{

    jmethodID mid;

    mid = mEnv->GetStaticMethodID(mActivityClass,"setActivityTitle","(Ljava/lang/String;)V");

    if (mid) {

        jstring jtitle = reinterpret_cast<jstring>(mEnv->NewStringUTF(title));

        mEnv->CallStaticVoidMethod(mActivityClass, mid, jtitle);

        mEnv->DeleteLocalRef(jtitle);

    }

}

extern "C" 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 = false;

        retval = SDL_TRUE;

    }

    return retval;

}

//

// Audio support

//

static jboolean audioBuffer16Bit = JNI_FALSE;

static jboolean audioBufferStereo = JNI_FALSE;

static jobject audioBuffer = NULL;

static void* audioBufferPinned = NULL;

extern "C" int Android_JNI_OpenAudioDevice(int sampleRate, int is16Bit, int channelCount, int desiredBufferFrames)

{

    int audioBufferFrames;

    int status;

    }

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

    audioBuffer16Bit = is16Bit;

    audioBufferStereo = channelCount > 1;

    audioBuffer = env->CallStaticObjectMethod(mActivityClass, midAudioInit, sampleRate, audioBuffer16Bit, audioBufferStereo, desiredBufferFrames);

    if (audioBuffer == NULL) {

        __android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: didn't get back a good audio buffer!");

        return 0;

    }

    audioBuffer = env->NewGlobalRef(audioBuffer);

    jboolean isCopy = JNI_FALSE;

    if (audioBuffer16Bit) {

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

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

    } else {

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

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

    }

    if (audioBufferStereo) {

        audioBufferFrames /= 2;

    }

    return audioBufferFrames;

}

extern "C" void * Android_JNI_GetAudioBuffer()

{

    return audioBufferPinned;

}

extern "C" void Android_JNI_WriteAudioBuffer()

{

    if (audioBuffer16Bit) {

        mAudioEnv->ReleaseShortArrayElements((jshortArray)audioBuffer, (jshort *)audioBufferPinned, JNI_COMMIT);

        mAudioEnv->CallStaticVoidMethod(mActivityClass, midAudioWriteShortBuffer, (jshortArray)audioBuffer);

    } else {

        mAudioEnv->ReleaseByteArrayElements((jbyteArray)audioBuffer, (jbyte *)audioBufferPinned, JNI_COMMIT);

        mAudioEnv->CallStaticVoidMethod(mActivityClass, midAudioWriteByteBuffer, (jbyteArray)audioBuffer);

    }

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

}

extern "C" void Android_JNI_CloseAudioDevice()

{

    int status;

    env->CallStaticVoidMethod(mActivityClass, midAudioQuit); 

    if (audioBuffer) {

        env->DeleteGlobalRef(audioBuffer);

        audioBuffer = NULL;

        audioBufferPinned = NULL;

    }

}

// Test for an exception and call SDL_SetError with its detail if one occurs

static bool Android_JNI_ExceptionOccurred()

{

    SDL_assert(LocalReferenceHolder::IsActive());

    jthrowable exception = mEnv->ExceptionOccurred();

    if (exception != NULL) {

        jmethodID mid;

        // Until this happens most JNI operations have undefined behaviour

        mEnv->ExceptionClear();

        jclass exceptionClass = mEnv->GetObjectClass(exception);

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

        mid = mEnv->GetMethodID(classClass, "getName", "()Ljava/lang/String;");

        jstring exceptionName = (jstring)mEnv->CallObjectMethod(exceptionClass, mid);

        const char* exceptionNameUTF8 = mEnv->GetStringUTFChars(exceptionName, 0);

        mid = mEnv->GetMethodID(exceptionClass, "getMessage", "()Ljava/lang/String;");

        jstring exceptionMessage = (jstring)mEnv->CallObjectMethod(exception, mid);

        if (exceptionMessage != NULL) {

            const char* exceptionMessageUTF8 = mEnv->GetStringUTFChars(

                    exceptionMessage, 0);

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

            mEnv->ReleaseStringUTFChars(exceptionMessage, exceptionMessageUTF8);

        } else {

            SDL_SetError("%s", exceptionNameUTF8);

        }

        mEnv->ReleaseStringUTFChars(exceptionName, exceptionNameUTF8);

        return true;

    }

    return false;

}

static int Android_JNI_FileOpen(SDL_RWops* ctx)

{

    LocalReferenceHolder refs;

    int result = 0;

    jmethodID mid;

    jobject context;

    jobject assetManager;

    jobject inputStream;

    jclass channels;

    jobject readableByteChannel;

    jstring fileNameJString;

    if (!refs.init(mEnv)) {

        goto failure;