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.

#ifdef __ANDROID__

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

static JavaVM* mJavaVM;

static bool bHasNewData;

    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;

    }

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

    bHasNewData = false;

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

    fLastAccelerometer[2] = z;

    bHasNewData = true;

// Pause

extern "C" void Java_org_libsdl_app_SDLActivity_nativePause(

                                    JNIEnv* env, jclass cls)

{

    if (Android_Window) {

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

        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(

extern "C" SDL_bool Android_JNI_GetAccelerometerValues(float values[3])

    SDL_bool retval = SDL_FALSE;

    if (bHasNewData) {

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

            values[i] = fLastAccelerometer[i];

        }

        bHasNewData = false;

        retval = SDL_TRUE;

    return retval;

    int status;

    JNIEnv *env;

    static bool isAttached = false;    

    status = mJavaVM->GetEnv((void **) &env, JNI_VERSION_1_4);

    if(status < 0) {

        LOGE("callback_handler: failed to get JNI environment, assuming native thread");

        status = mJavaVM->AttachCurrentThread(&env, NULL);

        if(status < 0) {

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

            return 0;

        }

        isAttached = true;

    }

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

    audioBuffer = env->NewGlobalRef(audioBuffer);

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

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

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

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

    if (isAttached) {

        mJavaVM->DetachCurrentThread();

    }

    int status;

    JNIEnv *env;

    static bool isAttached = false;    

    status = mJavaVM->GetEnv((void **) &env, JNI_VERSION_1_4);

    if(status < 0) {

        LOGE("callback_handler: failed to get JNI environment, assuming native thread");

        status = mJavaVM->AttachCurrentThread(&env, NULL);

        if(status < 0) {

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

            return;

        }

        isAttached = true;

    }

    env->CallStaticVoidMethod(mActivityClass, midAudioQuit); 

        env->DeleteGlobalRef(audioBuffer);

    if (isAttached) {

        mJavaVM->DetachCurrentThread();

    }

}

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

static bool Android_JNI_ExceptionOccurred()

{

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

            mEnv->DeleteLocalRef(exceptionMessage);

        } else {

            SDL_SetError("%s", exceptionNameUTF8);

        }

        mEnv->ReleaseStringUTFChars(exceptionName, exceptionNameUTF8);

        mEnv->DeleteLocalRef(exceptionName);

        mEnv->DeleteLocalRef(classClass);

        mEnv->DeleteLocalRef(exceptionClass);

        mEnv->DeleteLocalRef(exception);

        return true;

    }

    return false;

}

static int Android_JNI_FileOpen(SDL_RWops* ctx)

{

    int result = 0;

    jmethodID mid;

    jobject context;

    jobject assetManager;

    jobject inputStream;

    jclass channels;

    jobject readableByteChannel;

    jstring fileNameJString;

    bool allocatedLocalFrame = false;

    if (mEnv->PushLocalFrame(16) < 0) {

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

        goto failure;

    } else {

        allocatedLocalFrame = true;

    }

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

    // context = SDLActivity.getContext();

    mid = mEnv->GetStaticMethodID(mActivityClass,

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

    context = mEnv->CallStaticObjectMethod(mActivityClass, mid);

    // assetManager = context.getAssets();

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

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

    assetManager = mEnv->CallObjectMethod(context, mid);

    // inputStream = assetManager.open(<filename>);

    mid = mEnv->GetMethodID(mEnv->GetObjectClass(assetManager),

            "open", "(Ljava/lang/String;)Ljava/io/InputStream;");

    inputStream = mEnv->CallObjectMethod(assetManager, mid, fileNameJString);

    if (Android_JNI_ExceptionOccurred()) {

        goto failure;

    }

    ctx->hidden.androidio.inputStream = inputStream;

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

    // Despite all the visible documentation on [Asset]InputStream claiming

    // that the .available() method is not guaranteed to return the entire file

    // size, comments in <sdk>/samples/<ver>/ApiDemos/src/com/example/ ...

    // android/apis/content/ReadAsset.java imply that Android's

    // AssetInputStream.available() /will/ always return the total file size

    // size = inputStream.available();

    mid = mEnv->GetMethodID(mEnv->GetObjectClass(inputStream),

            "available", "()I");

    ctx->hidden.androidio.size = mEnv->CallIntMethod(inputStream, mid);

    if (Android_JNI_ExceptionOccurred()) {

        goto failure;

    }

    // readableByteChannel = Channels.newChannel(inputStream);

    channels = mEnv->FindClass("java/nio/channels/Channels");

    mid = mEnv->GetStaticMethodID(channels,

            "newChannel",

            "(Ljava/io/InputStream;)Ljava/nio/channels/ReadableByteChannel;");

    readableByteChannel = mEnv->CallStaticObjectMethod(

            channels, mid, inputStream);

    if (Android_JNI_ExceptionOccurred()) {

        goto failure;

    }

    ctx->hidden.androidio.readableByteChannel = readableByteChannel;

    ctx->hidden.androidio.readableByteChannelRef =

        mEnv->NewGlobalRef(readableByteChannel);

    // Store .read id for reading purposes

    mid = mEnv->GetMethodID(mEnv->GetObjectClass(readableByteChannel),

            "read", "(Ljava/nio/ByteBuffer;)I");

    ctx->hidden.androidio.readMethod = mid;

    ctx->hidden.androidio.position = 0;

    if (false) {

failure:

        result = -1;

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

        if(ctx->hidden.androidio.inputStreamRef != NULL) {

            mEnv->DeleteGlobalRef((jobject)ctx->hidden.androidio.inputStreamRef);

        }

    }

    if (allocatedLocalFrame) {

        mEnv->PopLocalFrame(NULL);

    }

    return result;

extern "C" int Android_JNI_FileOpen(SDL_RWops* ctx,

        const char* fileName, const char*)

{

    if (!ctx) {

        return -1;

    }

    jstring fileNameJString = mEnv->NewStringUTF(fileName);

    ctx->hidden.androidio.fileName = fileNameJString;

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

    ctx->hidden.androidio.inputStreamRef = NULL;

    mEnv->DeleteLocalRef(fileNameJString);

    return Android_JNI_FileOpen(ctx);

}