extern "C" const char * orxAndroid_GetInternalStoragePath()
{
if (!sstAndroid.zAndroidInternalFilesPath)
{
jmethodID mid;
jobject fileObject;
jstring pathString;
const char *path;
jobject jActivity;
JNIEnv *env = Android_JNI_GetEnv();
mid = env->GetMethodID(env->GetObjectClass(sstAndroid.mActivity), "getFilesDir", "()Ljava/io/File;");
fileObject = env->CallObjectMethod(sstAndroid.mActivity, mid);
if (!fileObject)
{
LOGE("Couldn't get internal directory");
return NULL;
}
// path = fileObject.getAbsolutePath();
mid = env->GetMethodID(env->GetObjectClass(fileObject), "getAbsolutePath", "()Ljava/lang/String;");
pathString = (jstring)env->CallObjectMethod(fileObject, mid);
env->DeleteLocalRef(fileObject);
path = env->GetStringUTFChars(pathString, NULL);
sstAndroid.zAndroidInternalFilesPath = strdup(path);
env->ReleaseStringUTFChars(pathString, path);
env->DeleteLocalRef(pathString);
}
return sstAndroid.zAndroidInternalFilesPath;
}
extern DECLSPEC void Android_JNI_StateCallback(void* context, m64p_core_param paramChanged, int newValue)
{
/*----ParamChanged-----------------
* --------NewValue--------
* M64CORE_EMU_STATE 1
* M64EMU_STOPPED 1
* M64EMU_RUNNING 2
* M64EMU_PAUSED 3
* M64CORE_VIDEO_MODE 2
* M64CORE_SAVESTATE_SLOT 3
* M64CORE_SPEED_FACTOR 4
* M64CORE_SPEED_LIMITER 5
* M64CORE_VIDEO_SIZE 6
* M64CORE_AUDIO_VOLUME 7
* M64CORE_AUDIO_MUTE 8
* M64CORE_INPUT_GAMESHARK 9
* M64CORE_STATE_LOADCOMPLETE 10
* (successful) 1
* (unsuccessful) 0
* M64CORE_STATE_SAVECOMPLETE 11
* (successful) 1
* (unsuccessful) 0
*/
JNIEnv *env = Android_JNI_GetEnv();
env->CallStaticVoidMethod(mActivityClass, midStateCallback, (int) paramChanged, newValue);
}
static int Android_JNI_FileClose(SDL_RWops* ctx, bool release)
{
LocalReferenceHolder refs(__FUNCTION__);
int result = 0;
JNIEnv *mEnv = Android_JNI_GetEnv();
if (!refs.init(mEnv)) {
SDL_SetError("Failed to allocate enough JVM local references");
return -1;
}
if (ctx) {
if (release) {
mEnv->DeleteGlobalRef((jobject)ctx->hidden.androidio.fileNameRef);
}
jobject inputStream = (jobject)ctx->hidden.androidio.inputStreamRef;
// inputStream.close();
jmethodID mid = mEnv->GetMethodID(mEnv->GetObjectClass(inputStream),
"close", "()V");
mEnv->CallVoidMethod(inputStream, mid);
mEnv->DeleteGlobalRef((jobject)ctx->hidden.androidio.inputStreamRef);
mEnv->DeleteGlobalRef((jobject)ctx->hidden.androidio.readableByteChannelRef);
if (Android_JNI_ExceptionOccurred()) {
result = -1;
}
if (release) {
SDL_FreeRW(ctx);
}
}
return result;
}
extern "C" SDL_bool Android_JNI_CreateContext(int majorVersion, int minorVersion,
int red, int green, int blue, int alpha,
int buffer, int depth, int stencil,
int buffers, int samples)
{
JNIEnv *env = Android_JNI_GetEnv();
jint attribs[] = {
EGL_RED_SIZE, red,
EGL_GREEN_SIZE, green,
EGL_BLUE_SIZE, blue,
EGL_ALPHA_SIZE, alpha,
EGL_BUFFER_SIZE, buffer,
EGL_DEPTH_SIZE, depth,
EGL_STENCIL_SIZE, stencil,
EGL_SAMPLE_BUFFERS, buffers,
EGL_SAMPLES, samples,
EGL_RENDERABLE_TYPE, (majorVersion == 1 ? EGL_OPENGL_ES_BIT : EGL_OPENGL_ES2_BIT),
EGL_NONE
};
int len = SDL_arraysize(attribs);
jintArray array;
array = env->NewIntArray(len);
env->SetIntArrayRegion(array, 0, len, attribs);
jboolean success = env->CallStaticBooleanMethod(mActivityClass, midCreateGLContext, majorVersion, minorVersion, array);
env->DeleteLocalRef(array);
return success ? SDL_TRUE : SDL_FALSE;
}
// This function is based on
// (1) convert surface to Java BitMap object
// (2) call Java PrintHelper to do print job.
const char *SurfacePrint(SDL_Surface *surface)
{
JNIEnv *mEnv = Android_JNI_GetEnv();
jclass mBitmapClass = (*mEnv)->FindClass(mEnv, "android/graphics/Bitmap");
jmethodID mCreateMethod = (*mEnv)->GetStaticMethodID(mEnv, mBitmapClass, "createBitmap", "([IIILandroid/graphics/Bitmap$Config;)Landroid/graphics/Bitmap;");
jintArray mSurfaceArray = (*mEnv)->NewIntArray(mEnv, surface->w * surface->h);
(*mEnv)->SetIntArrayRegion(mEnv,mSurfaceArray, 0, surface->w * surface->h, surface->pixels);
jclass mConfigClass = (*mEnv)->FindClass(mEnv, "android/graphics/Bitmap$Config");
jfieldID mConfigField = (*mEnv)->GetStaticFieldID(mEnv, mConfigClass , "ARGB_8888", "Landroid/graphics/Bitmap$Config;");
jobject mConfig = (*mEnv)->GetStaticObjectField(mEnv, mConfigClass, mConfigField);
jobject mBitMap = (*mEnv)->CallStaticObjectMethod(mEnv, mBitmapClass, mCreateMethod, mSurfaceArray, surface->w, surface->h, mConfig);
jobject mContext = (jobject)SDL_AndroidGetActivity();
jclass mPrintClass = (*mEnv)->FindClass(mEnv, "android/support/v4/print/PrintHelper");
// sometimes android v4 support library may be not ready
if (mPrintClass == NULL)
return "There is no android v4 support library.";
jmethodID mInitMethod = (*mEnv)->GetMethodID(mEnv, mPrintClass, "<init>", "(Landroid/content/Context;)V");
jobject mPrint = (*mEnv)->NewObject(mEnv, mPrintClass, mInitMethod, mContext);
jmethodID mPrintMethod = (*mEnv)->GetMethodID(mEnv, mPrintClass, "printBitmap", "(Ljava/lang/String;Landroid/graphics/Bitmap;)V");
jstring mString = (*mEnv)->NewStringUTF(mEnv, "TuxPaint");
(*mEnv)->CallVoidMethod(mEnv, mPrint, mPrintMethod, mString, mBitMap);
// clean up
(*mEnv)->DeleteLocalRef(mEnv, mSurfaceArray);
(*mEnv)->DeleteLocalRef(mEnv, mConfig);
(*mEnv)->DeleteLocalRef(mEnv, mPrint);
(*mEnv)->DeleteLocalRef(mEnv, mString);
return NULL;
}
extern "C" void orxAndroid_JNI_GetDeviceIds(orxS32 deviceIds[4])
{
JNIEnv *env = Android_JNI_GetEnv();
jintArray retval = (jintArray) env->CallObjectMethod(sstAndroid.mActivity, sstAndroid.midGetDeviceIds);
env->GetIntArrayRegion(retval, 0, 4, (jint*) &deviceIds[0]);
env->DeleteLocalRef(retval);
}
void setCurrLyric(char* lyric)
{
JNIEnv* theGoodEnv = Android_JNI_GetEnv();
jbyteArray byteArr = (*theGoodEnv)->NewByteArray(theGoodEnv, 300);
(*theGoodEnv)->SetByteArrayRegion(theGoodEnv, byteArr , 0, 300, (jbyte *)lyric);
(*theGoodEnv)->CallStaticVoidMethod(theGoodEnv, pushClazz, pushLyricId, byteArr, 300);
(*theGoodEnv)->DeleteLocalRef(theGoodEnv, byteArr);
}
void flushIt()
{
JNIEnv* theGoodEnv = Android_JNI_GetEnv();
//jclass clazz = (*theGoodEnv)->FindClass(theGoodEnv, "com/xperia64/timidityae/JNIHandler");
//jmethodID buffit = (*theGoodEnv)->GetStaticMethodID(theGoodEnv, pushClazz, "flushIt", "()V");
(*theGoodEnv)->CallStaticIntMethod(theGoodEnv, pushClazz, flushId);
//(*theGoodEnv)->DeleteLocalRef(theGoodEnv, clazz);
}
void controller(int aa)
{
JNIEnv* theGoodEnv = Android_JNI_GetEnv();
//jclass clazz = (*theGoodEnv)->FindClass(theGoodEnv, "com/xperia64/timidityae/JNIHandler");
//jclass cls = (*envelope)->GetObjectClass(envelope, mine);
//jmethodID buffit = (*theGoodEnv)->GetStaticMethodID(theGoodEnv, clazz, "controlMe", "(I)V");
(*theGoodEnv)->CallStaticVoidMethod(theGoodEnv, pushClazz, controlId, aa);
//(*theGoodEnv)->DeleteLocalRef(theGoodEnv, clazz);
}
int getBuffer()
{
JNIEnv* theGoodEnv = Android_JNI_GetEnv();
//jclass clazz = (*theGoodEnv)->FindClass(theGoodEnv, "com/xperia64/timidityae/JNIHandler");
//jmethodID buffit = (*theGoodEnv)->GetStaticMethodID(theGoodEnv, clazz, "bufferSize", "()I");
int r = (int)(*theGoodEnv)->CallStaticIntMethod(theGoodEnv, pushClazz, buffId);
//(*theGoodEnv)->DeleteLocalRef(theGoodEnv, clazz);
return r;
}
extern "C" SDL_bool Android_JNI_CreateContext(int majorVersion, int minorVersion)
{
JNIEnv *mEnv = Android_JNI_GetEnv();
if (mEnv->CallStaticBooleanMethod(mActivityClass, midCreateGLContext, majorVersion, minorVersion)) {
return SDL_TRUE;
} else {
return SDL_FALSE;
}
}
void JavaBridge::EmulationStopped(void)
{
JNIEnv *env = Android_JNI_GetEnv();
if (g_Activity != NULL && env != NULL)
{
jmethodID midEmulationStopped = env->GetStaticMethodID(m_NotifierClass, "EmulationStopped", "(Landroid/app/Activity;)V");
env->CallStaticVoidMethod(m_NotifierClass, midEmulationStopped, g_Activity);
}
}
void JavaBridge::RecentRomsUpdated(void)
{
JNIEnv *env = Android_JNI_GetEnv();
if (env)
{
jmethodID midRRecentRomsUpdated = env->GetStaticMethodID(m_GalleryActivityClass, "RecentRomsUpdated", "()V");
env->CallStaticVoidMethod(m_GalleryActivityClass, midRRecentRomsUpdated);
}
}
void JavaBridge::RomListReset(void)
{
JNIEnv *env = Android_JNI_GetEnv();
if (env)
{
jmethodID midRomListReset = env->GetStaticMethodID(m_GalleryActivityClass, "RomListReset", "()V");
env->CallStaticVoidMethod(m_GalleryActivityClass, midRomListReset);
}
}
extern "C" int Android_JNI_OpenAudioDevice(int sampleRate, int is16Bit, int channelCount, int desiredBufferFrames)
{
int audioBufferFrames;
int status;
JNIEnv *env = Android_JNI_GetEnv();
if (!env) {
LOGE("callback_handler: failed to attach current thread");
}
Android_JNI_SetupThread();
__android_log_print(ANDROID_LOG_VERBOSE, "SDL", "SDL audio: opening device");
audioBuffer16Bit = is16Bit;
audioBufferStereo = channelCount > 1;
env->CallStaticObjectMethod(mActivityClass, midAudioInit, sampleRate, audioBuffer16Bit, audioBufferStereo, desiredBufferFrames);
/* 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(desiredBufferFrames * (audioBufferStereo ? 2 : 1));
if (audioBufferLocal) {
audioBuffer = env->NewGlobalRef(audioBufferLocal);
env->DeleteLocalRef(audioBufferLocal);
}
}
else {
jbyteArray audioBufferLocal = env->NewByteArray(desiredBufferFrames * (audioBufferStereo ? 2 : 1));
if (audioBufferLocal) {
audioBuffer = env->NewGlobalRef(audioBufferLocal);
env->DeleteLocalRef(audioBufferLocal);
}
}
if (audioBuffer == NULL) {
__android_log_print(ANDROID_LOG_WARN, "SDL", "SDL audio: could not allocate an audio buffer!");
return 0;
}
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;
}
void JavaBridge::SwapWindow()
{
JNIEnv *env = Android_JNI_GetEnv();
if (g_GLThread != NULL && env != NULL)
{
jclass GLThreadClass = env->GetObjectClass(g_GLThread);
jmethodID midSwapBuffers = env->GetMethodID(GLThreadClass, "SwapBuffers", "()V");
env->CallVoidMethod(g_GLThread, midSwapBuffers);
env->DeleteLocalRef(GLThreadClass);
}
}
static void
SeparateEventsHintWatcher(void *userdata, const char *name,
const char *oldValue, const char *newValue)
{
jclass mActivityClass = Android_JNI_GetActivityClass();
JNIEnv *env = Android_JNI_GetEnv();
jfieldID fid = (*env)->GetStaticFieldID(env, mActivityClass, "mSeparateMouseAndTouch", "Z");
separate_mouse_and_touch = (newValue && (SDL_strcmp(newValue, "1") == 0));
(*env)->SetStaticBooleanField(env, mActivityClass, fid, separate_mouse_and_touch ? JNI_TRUE : JNI_FALSE);
}
void JavaBridge::DisplayMessage2(const char * Message)
{
JNIEnv *env = Android_JNI_GetEnv();
if (env)
{
jstring j_Message = env->NewStringUTF(Message);
jmethodID midshowMessage2 = env->GetStaticMethodID(m_NotifierClass, "showMessage2", "(Landroid/app/Activity;Ljava/lang/String;)V");
env->CallStaticVoidMethod(m_NotifierClass, midshowMessage2,g_Activity,j_Message);
env->DeleteLocalRef(j_Message);
}
}
extern "C" void Android_JNI_SetActivityTitle(const char *title)
{
jmethodID mid;
JNIEnv *mEnv = Android_JNI_GetEnv();
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);
}
}
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;
}
extern "C" void Android_JNI_CloseAudioDevice()
{
JNIEnv *env = Android_JNI_GetEnv();
env->CallStaticVoidMethod(mActivityClass, midAudioQuit);
if (audioBuffer) {
env->DeleteGlobalRef(audioBuffer);
audioBuffer = NULL;
audioBufferPinned = NULL;
}
}
void scoreloop_submit_score(unsigned int scoreMode, unsigned int scoreValue)
{
JNIEnv* env = Android_JNI_GetEnv();
if (!env)
{
return;
}
jclass mActivityClass = (*env)->FindClass(env, "com/moonlite/tuxracer/GameActivity");
jmethodID mid = (*env)->GetStaticMethodID(env, mActivityClass, "submitScore", "(II)Z");
if (!mid)
{
return;
}
if (!(*env)->CallStaticBooleanMethod(env, mActivityClass, mid, (int)scoreMode, (int)scoreValue))
{
jstring j_title=(*env)->NewStringUTF(env, ALIAS_PROMPT_TITLE);
jstring j_message=(*env)->NewStringUTF(env, ALIAS_PROMPT_MESSAGE);
if (!getparam_should_prompt_alias())
{
return;
}
stored_score_mode=(int)scoreMode;
stored_score_value=(int)scoreValue;
env = Android_JNI_GetEnv();
if (!env)
{
return;
}
mActivityClass = (*env)->FindClass(env, "com/moonlite/tuxracer/GameActivity");
mid = (*env)->GetStaticMethodID(env, mActivityClass, "promptForAlias", "(II)V");
if (!mid)
{
return;
}
(*env)->CallStaticVoidMethod(env, mActivityClass, mid, (int)scoreMode, (int)scoreValue);
(*env)->DeleteLocalRef(env, j_title);
(*env)->DeleteLocalRef(env, j_message);
}
return;
}
extern "C" size_t Android_JNI_FileRead(SDL_RWops* ctx, void* buffer,
size_t size, size_t maxnum)
{
LocalReferenceHolder refs(__FUNCTION__);
if (ctx->hidden.androidio.assetFileDescriptorRef) {
size_t bytesMax = size * maxnum;
if (ctx->hidden.androidio.size != -1 /*UNKNOWN_LENGTH*/ && ctx->hidden.androidio.position + bytesMax > ctx->hidden.androidio.size) {
bytesMax = ctx->hidden.androidio.size - ctx->hidden.androidio.position;
}
size_t result = read(ctx->hidden.androidio.fd, buffer, bytesMax );
if (result > 0) {
ctx->hidden.androidio.position += result;
return result / size;
}
return 0;
} else {
jlong bytesRemaining = (jlong) (size * maxnum);
jlong bytesMax = (jlong) (ctx->hidden.androidio.size - ctx->hidden.androidio.position);
int bytesRead = 0;
/* Don't read more bytes than those that remain in the file, otherwise we get an exception */
if (bytesRemaining > bytesMax) bytesRemaining = bytesMax;
JNIEnv *mEnv = Android_JNI_GetEnv();
if (!refs.init(mEnv)) {
return -1;
}
jobject readableByteChannel = (jobject)ctx->hidden.androidio.readableByteChannelRef;
jmethodID readMethod = (jmethodID)ctx->hidden.androidio.readMethod;
jobject byteBuffer = mEnv->NewDirectByteBuffer(buffer, bytesRemaining);
while (bytesRemaining > 0) {
// result = readableByteChannel.read(...);
int result = mEnv->CallIntMethod(readableByteChannel, readMethod, byteBuffer);
if (Android_JNI_ExceptionOccurred()) {
return 0;
}
if (result < 0) {
break;
}
bytesRemaining -= result;
bytesRead += result;
ctx->hidden.androidio.position += result;
}
return bytesRead / size;
}
}
void JavaBridge::GfxThreadInit()
{
WriteTrace(TraceUserInterface, TraceDebug, "Start");
JNIEnv *env = Android_JNI_GetEnv();
if (g_GLThread != NULL && env != NULL)
{
jclass GLThreadClass = env->GetObjectClass(g_GLThread);
jmethodID midThreadStarting = env->GetMethodID(GLThreadClass, "ThreadStarting", "()V");
env->CallVoidMethod(g_GLThread, midThreadStarting);
env->DeleteLocalRef(GLThreadClass);
}
WriteTrace(TraceUserInterface, TraceDebug, "Done");
}
// sends message to be handled on the UI event dispatch thread
extern "C" int Android_JNI_SendMessage(int command, int param)
{
JNIEnv *env = Android_JNI_GetEnv();
if (!env) {
return -1;
}
jmethodID mid = env->GetStaticMethodID(mActivityClass, "sendMessage", "(II)V");
if (!mid) {
return -1;
}
env->CallStaticVoidMethod(mActivityClass, mid, command, param);
return 0;
}
int nativePush(char* buf, int nframes)
{
//jclass clazz = (*theGoodEnv)->FindClass(theGoodEnv, "com/xperia64/timidityae/JNIHandler");
JNIEnv* theGoodEnv = Android_JNI_GetEnv();
//jmethodID buffit = (*theGoodEnv)->GetStaticMethodID(theGoodEnv, clazz, "buffit", "([BI)V");
jbyteArray byteArr = (*theGoodEnv)->NewByteArray(theGoodEnv, nframes);
(*theGoodEnv)->SetByteArrayRegion(theGoodEnv, byteArr , 0, nframes, (jbyte *)buf);
(*theGoodEnv)->CallStaticVoidMethod(theGoodEnv, pushClazz, pushBuffit, byteArr, nframes);
(*theGoodEnv)->DeleteLocalRef(theGoodEnv, byteArr);
//(*theGoodEnv)->DeleteLocalRef(theGoodEnv, clazz);
return 0;
}
void orxAndroid_JNI_SetupThread(void) {
/* 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)
*/
JNIEnv *env = Android_JNI_GetEnv();
pthread_setspecific(mThreadKey, (void*) env);
}
// Since Print work is based on Java PrintHelper class, which may not be supported on some old versions
int IsPrinterAvailable( void )
{
JNIEnv *mEnv = Android_JNI_GetEnv();
jclass mPrintHelperClass = (*mEnv)->FindClass(mEnv, "android/support/v4/print/PrintHelper");
if (mPrintHelperClass == NULL)
return 0;
jmethodID mSupportMethod = (*mEnv)->GetStaticMethodID(mEnv, mPrintHelperClass, "systemSupportsPrint", "()Z");
jboolean support = (*mEnv)->CallStaticBooleanMethod(mEnv, mPrintHelperClass, mSupportMethod);
return support ? 1 : 0;
}
extern "C" void Android_JNI_WriteAudioBuffer()
{
JNIEnv *mAudioEnv = Android_JNI_GetEnv();
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 */
}
void GameCpuRunning(void * /*NotUsed*/)
{
WriteTrace(TraceUserInterface, TraceDebug, "Start");
bool Running = g_Settings->LoadBool(GameRunning_CPU_Running);
WriteTrace(TraceUserInterface, TraceDebug, Running ? "Game Started" : "Game Stopped");
if (Running)
{
stdstr FileLoc = g_Settings->LoadStringVal(Game_File);
if (FileLoc.length() > 0)
{
AddRecentRom(FileLoc.c_str());
}
g_System->RefreshGameSettings();
}
else
{
JNIEnv *env = Android_JNI_GetEnv();
if (env != NULL)
{
if (g_JavaBridge)
{
WriteTrace(TraceUserInterface, TraceDebug, "Notify java emulation stopped");
g_JavaBridge->EmulationStopped();
}
else
{
WriteTrace(TraceUserInterface, TraceError, "No Java bridge");
}
// call in to java that emulation done
WriteTrace(TraceUserInterface, TraceDebug, "clean up global activity");
env->DeleteGlobalRef(g_Activity);
g_Activity = NULL;
WriteTrace(TraceUserInterface, TraceDebug, "clean up global gl thread");
if (g_JavaBridge)
{
g_JavaBridge->GfxThreadDone();
}
env->DeleteGlobalRef(g_GLThread);
g_GLThread = NULL;
}
else
{
WriteTrace(TraceUserInterface, TraceError, "Failed to get java environment");
}
}
WriteTrace(TraceUserInterface, TraceDebug, "Done");
}
