Programs/system_java.c - brltty - Git at Google

 /*
  * BRLTTY - A background process providing access to the console screen (when in
  *          text mode) for a blind person using a refreshable braille display.
  *
  * Copyright (C) 1995-2023 by The BRLTTY Developers.
  *
  * BRLTTY comes with ABSOLUTELY NO WARRANTY.
  *
  * This is free software, placed under the terms of the
  * GNU Lesser General Public License, as published by the Free Software
  * Foundation; either version 2.1 of the License, or (at your option) any
  * later version. Please see the file LICENSE-LGPL for details.
  *
  * Web Page: http://brltty.app/
  *
  * This software is maintained by Dave Mielke <dave@mielke.cc>.
  */

 #include "prologue.h"

 #include <string.h>

 #include "log.h"
 #include "thread.h"
 #include "system.h"
 #include "system_java.h"

 static JavaVM *javaVirtualMachine = NULL;

 JNIEXPORT jint
 JNI_OnLoad (JavaVM *vm, void *reserved) {
   javaVirtualMachine = vm;
   return JAVA_JNI_VERSION;
 }

 JNIEXPORT void
 JNI_OnUnload (JavaVM *vm, void *reserved) {
   javaVirtualMachine = NULL;
 }

 JavaVM *
 getJavaInvocationInterface (void) {
   return javaVirtualMachine;
 }

 typedef struct {
   JavaVM *virtualMachine;
   JNIEnv *nativeInterface;
   char *threadName;
 } ThreadSpecificData;

 static THREAD_SPECIFIC_DATA_NEW(tsdJavaNativeThread) {
   ThreadSpecificData *tsd;

   if ((tsd = malloc(sizeof(*tsd)))) {
     memset(tsd, 0, sizeof(*tsd));
     return tsd;
   } else {
     logMallocError();
   }

   return NULL;
 }

 static THREAD_SPECIFIC_DATA_DESTROY(tsdJavaNativeThread) {
   ThreadSpecificData *tsd = data;

   {
     JavaVM *vm = tsd->virtualMachine;
     (*vm)->DetachCurrentThread(vm);
   }

   logMessage(LOG_DEBUG, "thread detached from Java VM: %s", tsd->threadName);
   free(tsd->threadName);
   free(tsd);
 }

 THREAD_SPECIFIC_DATA_CONTROL(tsdJavaNativeThread);

 static char *
 getJavaThreadName (JNIEnv *env) {
   char *name = NULL;
   static jclass Thread_class = NULL;

   if (findJavaClass(env, &Thread_class, JAVA_OBJ_THREAD)) {
     static jmethodID Thread_currentThread = 0;

     if (findJavaStaticMethod(env, &Thread_currentThread, Thread_class, "currentThread",
                              JAVA_SIG_METHOD(JAVA_SIG_THREAD,
                                             ))) {
       jobject thread = (*env)->CallStaticObjectMethod(env, Thread_class, Thread_currentThread);

       if (!clearJavaException(env, 1)) {
         static jmethodID Thread_getName = 0;

         if (findJavaInstanceMethod(env, &Thread_getName, Thread_class, "getName",
                                    JAVA_SIG_METHOD(JAVA_SIG_STRING,
                                                   ))) {
           jstring jName = (*env)->CallObjectMethod(env, thread, Thread_getName);

           if (!clearJavaException(env, 1)) {
             jboolean isCopy;
             const char *cName = (*env)->GetStringUTFChars(env, jName, &isCopy);

             if (!(name = strdup(cName))) {
               logMallocError();
             }

             (*env)->ReleaseStringUTFChars(env, jName, cName);
             (*env)->DeleteLocalRef(env, jName);
           }
         }

         (*env)->DeleteLocalRef(env, thread);
       }
     }
   }

   return name;
 }

 JNIEnv *
 getJavaNativeInterface (void) {
   JavaVM *vm = getJavaInvocationInterface();

 #ifdef __ANDROID__
   JNIEnv *env = NULL;
 #else /* __ANDROID__ */
   void *env = NULL;
 #endif /* __ANDROID__ */

   if (vm) {
     jint result = (*vm)->GetEnv(vm, (void **)&env, JAVA_JNI_VERSION);

     if (result != JNI_OK) {
       if (result == JNI_EDETACHED) {
         JavaVMAttachArgs args = {
           .version = JAVA_JNI_VERSION,
           .name = NULL,
           .group = NULL
         };

         if ((result = (*vm)->AttachCurrentThread(vm, &env, &args)) < 0) {
           logMessage(LOG_WARNING, "Java AttachCurrentThread error: %d", result);
         } else {
           ThreadSpecificData *tsd = getThreadSpecificData(&tsdJavaNativeThread);
           tsd->virtualMachine = vm;
           tsd->nativeInterface = env;
           tsd->threadName = getJavaThreadName(env);

           logMessage(LOG_DEBUG, "thread attached to Java VM: %s", tsd->threadName);
         }
       } else {
         logMessage(LOG_WARNING, "Java GetEnv error: %d", result);
       }
     }
   }

   return env;
 }

 int
 clearJavaException (JNIEnv *env, int describe) {
   int exceptionOccurred = (*env)->ExceptionCheck(env);

   if (exceptionOccurred) {
     if (describe) (*env)->ExceptionDescribe(env);
     (*env)->ExceptionClear(env);
   }

   return exceptionOccurred;
 }

 static jobject javaClassLoaderInstance = NULL;
 static jclass javaClassLoaderClass = NULL;
 static jmethodID loadClassMethod = 0;

 int
 setJavaClassLoader (JNIEnv *env, jobject instance) {
   if (instance) {
     javaClassLoaderInstance = (*env)->NewGlobalRef(env, instance);

     if (javaClassLoaderInstance) {
       jclass class = (*env)->GetObjectClass(env, instance);

       if (class) {
         javaClassLoaderClass = (*env)->NewGlobalRef(env, class);

         (*env)->DeleteLocalRef(env, class);
         class = NULL;

         if (javaClassLoaderClass) {
           jmethodID method = (*env)->GetMethodID(env, javaClassLoaderClass, "loadClass",
                                                  JAVA_SIG_METHOD(JAVA_SIG_CLASS,
                                                                  JAVA_SIG_STRING // className
                                                                 ));

           if (method) {
             loadClassMethod = method;
             return 1;
           }

           (*env)->DeleteGlobalRef(env, javaClassLoaderClass);
         }
       }

       (*env)->DeleteGlobalRef(env, javaClassLoaderInstance);
     }
   }

   javaClassLoaderInstance = NULL;
   javaClassLoaderClass = NULL;
   loadClassMethod = 0;
   return 0;
 }

 static jclass
 loadJavaClass (JNIEnv *env, const char *path) {
   size_t size = strlen(path) + 1;
   char cName[size];

   jclass class = NULL;
   jobject jName;

   {
     const char *p = path;
     char *n = cName;
     char c;

     do {
       c = *p++;
       if (c == '/') c = '.';
       *n++ = c;
     } while (c);
   }

   if ((jName = (*env)->NewStringUTF(env, cName))) {
     jclass result = (*env)->CallObjectMethod(env, javaClassLoaderInstance, loadClassMethod, jName);

     if (clearJavaException(env, 1)) {
       (*env)->DeleteLocalRef(env, result);
     } else {
       class = result;
     }

     (*env)->DeleteLocalRef(env, jName);
   } else {
     logMallocError();
   }

   return class;
 }

 int
 findJavaClass (JNIEnv *env, jclass *class, const char *path) {
   if (*class) return 1;

   {
     jclass localReference = loadClassMethod?
                               loadJavaClass(env, path):
                               (*env)->FindClass(env, path);

     if (localReference) {
       jclass globalReference = (*env)->NewGlobalRef(env, localReference);

       (*env)->DeleteLocalRef(env, localReference);
       localReference = NULL;

       if (globalReference) {
         logMessage(LOG_DEBUG, "java class found: %s", path);
         *class = globalReference;
         return 1;
       } else {
         logMallocError();
         clearJavaException(env, 0);
       }
     } else {
       logMessage(LOG_ERR, "java class not found: %s", path);
       clearJavaException(env, 1);
     }
   }

   return 0;
 }

 int
 findJavaInstanceMethod (
   JNIEnv *env, jmethodID *method,
   jclass class, const char *name, const char *signature
 ) {
   if (!*method) {
     if (!(*method = (*env)->GetMethodID(env, class, name, signature))) {
       logMessage(LOG_ERR, "java instance method not found: %s: %s", name, signature);
       clearJavaException(env, 0);
       return 0;
     }

     logMessage(LOG_DEBUG, "java instance method found: %s: %s", name, signature);
   }

   return 1;
 }

 int
 findJavaStaticMethod (
   JNIEnv *env, jmethodID *method,
   jclass class, const char *name, const char *signature
 ) {
   if (!*method) {
     if (!(*method = (*env)->GetStaticMethodID(env, class, name, signature))) {
       logMessage(LOG_ERR, "java static method not found: %s: %s", name, signature);
       clearJavaException(env, 0);
       return 0;
     }

     logMessage(LOG_DEBUG, "java static method found: %s: %s", name, signature);
   }

   return 1;
 }

 int
 findJavaConstructor (
   JNIEnv *env, jmethodID *constructor,
   jclass class, const char *signature
 ) {
   return findJavaInstanceMethod(env, constructor, class, JAVA_CONSTRUCTOR_NAME, signature);
 }

 int
 findJavaInstanceField (
   JNIEnv *env, jfieldID *field,
   jclass class, const char *name, const char *signature
 ) {
   if (!*field) {
     if (!(*field = (*env)->GetFieldID(env, class, name, signature))) {
       logMessage(LOG_ERR, "java instance field not found: %s: %s", name, signature);
       clearJavaException(env, 0);
       return 0;
     }

     logMessage(LOG_DEBUG, "java instance field found: %s: %s", name, signature);
   }

   return 1;
 }

 int
 findJavaStaticField (
   JNIEnv *env, jfieldID *field,
   jclass class, const char *name, const char *signature
 ) {
   if (!*field) {
     if (!(*field = (*env)->GetStaticFieldID(env, class, name, signature))) {
       logMessage(LOG_ERR, "java static field not found: %s: %s", name, signature);
       clearJavaException(env, 0);
       return 0;
     }

     logMessage(LOG_DEBUG, "java static field found: %s: %s", name, signature);
   }

   return 1;
 }

 char *
 getJavaLocaleName (void) {
   char *name = NULL;
   JNIEnv *env;

   if ((env = getJavaNativeInterface())) {
     jclass Locale_class = NULL;

     if (findJavaClass(env, &Locale_class, JAVA_OBJ_LOCALE)) {
       jmethodID Locale_getDefault = 0;

       if (findJavaStaticMethod(env, &Locale_getDefault, Locale_class, "getDefault",
                                JAVA_SIG_METHOD(JAVA_SIG_LOCALE,
                                               ))) {
         jobject locale = (*env)->CallStaticObjectMethod(env, Locale_class, Locale_getDefault);

         if (!clearJavaException(env, 1)) {
           jmethodID Locale_toString = 0;

           if (findJavaInstanceMethod(env, &Locale_toString, Locale_class, "toString",
                                      JAVA_SIG_METHOD(JAVA_SIG_STRING,
                                                     ))) {
             jstring jName = (*env)->CallObjectMethod(env, locale, Locale_toString);

             if (!clearJavaException(env, 1)) {
               jboolean isCopy;
               const char *cName = (*env)->GetStringUTFChars(env, jName, &isCopy);

               if (!(name = strdup(cName))) {
                 logMallocError();
               }

               (*env)->ReleaseStringUTFChars(env, jName, cName);
               (*env)->DeleteLocalRef(env, jName);
             }
           }

           (*env)->DeleteLocalRef(env, locale);
         }
       }
     }
   }

   return name;
 }

 #if defined(__ANDROID__)
 #include <locale.h>
 #include "messages.h"

 static void
 initializeAndroidEnvironment (JNIEnv *env) {
   {
     static jclass class = NULL;

     if (findJavaClass(env, &class, JAVA_OBJ_BRLTTY("BrailleApplication"))) {
       static jmethodID method = 0;

       if (findJavaStaticMethod(env, &method, class, "getCurrentLocale",
                                JAVA_SIG_METHOD(JAVA_SIG_STRING,
                                               ))) {
         jstring jLocale = (*env)->CallStaticObjectMethod(env, class, method);

         if (!clearJavaException(env, 1)) {
           if (jLocale) {
             jboolean isCopy;
             const char *cLocale = (*env)->GetStringUTFChars(env, jLocale, &isCopy);

             if (cLocale) {
               if (setMessagesLocale(cLocale)) {
               }

               (*env)->ReleaseStringUTFChars(env, jLocale, cLocale);
             }

             (*env)->DeleteLocalRef(env, jLocale);
           }
         }
       }
     }
   }
 }
 #endif /* platform-speciofic initialization */

 void
 initializeSystemObject (void) {
 #if defined(__ANDROID__)
   initializeAndroidEnvironment(getJavaNativeInterface());
 #endif /* platform-speciofic initialization */
 }
	/*
	* BRLTTY - A background process providing access to the console screen (when in
	* text mode) for a blind person using a refreshable braille display.
	*
	* Copyright (C) 1995-2023 by The BRLTTY Developers.
	*
	* BRLTTY comes with ABSOLUTELY NO WARRANTY.
	*
	* This is free software, placed under the terms of the
	* GNU Lesser General Public License, as published by the Free Software
	* Foundation; either version 2.1 of the License, or (at your option) any
	* later version. Please see the file LICENSE-LGPL for details.
	*
	* Web Page: http://brltty.app/
	*
	* This software is maintained by Dave Mielke <dave@mielke.cc>.
	*/

	#include "prologue.h"

	#include <string.h>

	#include "log.h"
	#include "thread.h"
	#include "system.h"
	#include "system_java.h"

	static JavaVM *javaVirtualMachine = NULL;

	JNIEXPORT jint
	JNI_OnLoad (JavaVM vm, void reserved) {
	javaVirtualMachine = vm;
	return JAVA_JNI_VERSION;
	}

	JNIEXPORT void
	JNI_OnUnload (JavaVM vm, void reserved) {
	javaVirtualMachine = NULL;
	}

	JavaVM *
	getJavaInvocationInterface (void) {
	return javaVirtualMachine;
	}

	typedef struct {
	JavaVM *virtualMachine;
	JNIEnv *nativeInterface;
	char *threadName;
	} ThreadSpecificData;

	static THREAD_SPECIFIC_DATA_NEW(tsdJavaNativeThread) {
	ThreadSpecificData *tsd;

	if ((tsd = malloc(sizeof(*tsd)))) {
	memset(tsd, 0, sizeof(*tsd));
	return tsd;
	} else {
	logMallocError();
	}

	return NULL;
	}

	static THREAD_SPECIFIC_DATA_DESTROY(tsdJavaNativeThread) {
	ThreadSpecificData *tsd = data;

	{
	JavaVM *vm = tsd->virtualMachine;
	(*vm)->DetachCurrentThread(vm);
	}

	logMessage(LOG_DEBUG, "thread detached from Java VM: %s", tsd->threadName);
	free(tsd->threadName);
	free(tsd);
	}

	THREAD_SPECIFIC_DATA_CONTROL(tsdJavaNativeThread);

	static char *
	getJavaThreadName (JNIEnv *env) {
	char *name = NULL;
	static jclass Thread_class = NULL;

	if (findJavaClass(env, &Thread_class, JAVA_OBJ_THREAD)) {
	static jmethodID Thread_currentThread = 0;

	if (findJavaStaticMethod(env, &Thread_currentThread, Thread_class, "currentThread",
	JAVA_SIG_METHOD(JAVA_SIG_THREAD,
	))) {
	jobject thread = (*env)->CallStaticObjectMethod(env, Thread_class, Thread_currentThread);

	if (!clearJavaException(env, 1)) {
	static jmethodID Thread_getName = 0;

	if (findJavaInstanceMethod(env, &Thread_getName, Thread_class, "getName",
	JAVA_SIG_METHOD(JAVA_SIG_STRING,
	))) {
	jstring jName = (*env)->CallObjectMethod(env, thread, Thread_getName);

	if (!clearJavaException(env, 1)) {
	jboolean isCopy;
	const char cName = (env)->GetStringUTFChars(env, jName, &isCopy);

	if (!(name = strdup(cName))) {
	logMallocError();
	}

	(*env)->ReleaseStringUTFChars(env, jName, cName);
	(*env)->DeleteLocalRef(env, jName);
	}
	}

	(*env)->DeleteLocalRef(env, thread);
	}
	}
	}

	return name;
	}

	JNIEnv *
	getJavaNativeInterface (void) {
	JavaVM *vm = getJavaInvocationInterface();

	#ifdef __ANDROID__
	JNIEnv *env = NULL;
	#else /* __ANDROID__ */
	void *env = NULL;
	#endif /* __ANDROID__ */

	if (vm) {
	jint result = (vm)->GetEnv(vm, (void *)&env, JAVA_JNI_VERSION);

	if (result != JNI_OK) {
	if (result == JNI_EDETACHED) {
	JavaVMAttachArgs args = {
	.version = JAVA_JNI_VERSION,
	.name = NULL,
	.group = NULL
	};

	if ((result = (*vm)->AttachCurrentThread(vm, &env, &args)) < 0) {
	logMessage(LOG_WARNING, "Java AttachCurrentThread error: %d", result);
	} else {
	ThreadSpecificData *tsd = getThreadSpecificData(&tsdJavaNativeThread);
	tsd->virtualMachine = vm;
	tsd->nativeInterface = env;
	tsd->threadName = getJavaThreadName(env);

	logMessage(LOG_DEBUG, "thread attached to Java VM: %s", tsd->threadName);
	}
	} else {
	logMessage(LOG_WARNING, "Java GetEnv error: %d", result);
	}
	}
	}

	return env;
	}

	int
	clearJavaException (JNIEnv *env, int describe) {
	int exceptionOccurred = (*env)->ExceptionCheck(env);

	if (exceptionOccurred) {
	if (describe) (*env)->ExceptionDescribe(env);
	(*env)->ExceptionClear(env);
	}

	return exceptionOccurred;
	}

	static jobject javaClassLoaderInstance = NULL;
	static jclass javaClassLoaderClass = NULL;
	static jmethodID loadClassMethod = 0;

	int
	setJavaClassLoader (JNIEnv *env, jobject instance) {
	if (instance) {
	javaClassLoaderInstance = (*env)->NewGlobalRef(env, instance);

	if (javaClassLoaderInstance) {
	jclass class = (*env)->GetObjectClass(env, instance);

	if (class) {
	javaClassLoaderClass = (*env)->NewGlobalRef(env, class);

	(*env)->DeleteLocalRef(env, class);
	class = NULL;

	if (javaClassLoaderClass) {
	jmethodID method = (*env)->GetMethodID(env, javaClassLoaderClass, "loadClass",
	JAVA_SIG_METHOD(JAVA_SIG_CLASS,
	JAVA_SIG_STRING // className
	));

	if (method) {
	loadClassMethod = method;
	return 1;
	}

	(*env)->DeleteGlobalRef(env, javaClassLoaderClass);
	}
	}

	(*env)->DeleteGlobalRef(env, javaClassLoaderInstance);
	}
	}

	javaClassLoaderInstance = NULL;
	javaClassLoaderClass = NULL;
	loadClassMethod = 0;
	return 0;
	}

	static jclass
	loadJavaClass (JNIEnv env, const char path) {
	size_t size = strlen(path) + 1;
	char cName[size];

	jclass class = NULL;
	jobject jName;

	{
	const char *p = path;
	char *n = cName;
	char c;

	do {
	c = *p++;
	if (c == '/') c = '.';
	*n++ = c;
	} while (c);
	}

	if ((jName = (*env)->NewStringUTF(env, cName))) {
	jclass result = (*env)->CallObjectMethod(env, javaClassLoaderInstance, loadClassMethod, jName);

	if (clearJavaException(env, 1)) {
	(*env)->DeleteLocalRef(env, result);
	} else {
	class = result;
	}

	(*env)->DeleteLocalRef(env, jName);
	} else {
	logMallocError();
	}

	return class;
	}

	int
	findJavaClass (JNIEnv env, jclass class, const char *path) {
	if (*class) return 1;

	{
	jclass localReference = loadClassMethod?
	loadJavaClass(env, path):
	(*env)->FindClass(env, path);

	if (localReference) {
	jclass globalReference = (*env)->NewGlobalRef(env, localReference);

	(*env)->DeleteLocalRef(env, localReference);
	localReference = NULL;

	if (globalReference) {
	logMessage(LOG_DEBUG, "java class found: %s", path);
	*class = globalReference;
	return 1;
	} else {
	logMallocError();
	clearJavaException(env, 0);
	}
	} else {
	logMessage(LOG_ERR, "java class not found: %s", path);
	clearJavaException(env, 1);
	}
	}

	return 0;
	}

	int
	findJavaInstanceMethod (
	JNIEnv env, jmethodID method,
	jclass class, const char name, const char signature
	) {
	if (!*method) {
	if (!(method = (env)->GetMethodID(env, class, name, signature))) {
	logMessage(LOG_ERR, "java instance method not found: %s: %s", name, signature);
	clearJavaException(env, 0);
	return 0;
	}

	logMessage(LOG_DEBUG, "java instance method found: %s: %s", name, signature);
	}

	return 1;
	}

	int
	findJavaStaticMethod (
	JNIEnv env, jmethodID method,
	jclass class, const char name, const char signature
	) {
	if (!*method) {
	if (!(method = (env)->GetStaticMethodID(env, class, name, signature))) {
	logMessage(LOG_ERR, "java static method not found: %s: %s", name, signature);
	clearJavaException(env, 0);
	return 0;
	}

	logMessage(LOG_DEBUG, "java static method found: %s: %s", name, signature);
	}

	return 1;
	}

	int
	findJavaConstructor (
	JNIEnv env, jmethodID constructor,
	jclass class, const char *signature
	) {
	return findJavaInstanceMethod(env, constructor, class, JAVA_CONSTRUCTOR_NAME, signature);
	}

	int
	findJavaInstanceField (
	JNIEnv env, jfieldID field,
	jclass class, const char name, const char signature
	) {
	if (!*field) {
	if (!(field = (env)->GetFieldID(env, class, name, signature))) {
	logMessage(LOG_ERR, "java instance field not found: %s: %s", name, signature);
	clearJavaException(env, 0);
	return 0;
	}

	logMessage(LOG_DEBUG, "java instance field found: %s: %s", name, signature);
	}

	return 1;
	}

	int
	findJavaStaticField (
	JNIEnv env, jfieldID field,
	jclass class, const char name, const char signature
	) {
	if (!*field) {
	if (!(field = (env)->GetStaticFieldID(env, class, name, signature))) {
	logMessage(LOG_ERR, "java static field not found: %s: %s", name, signature);
	clearJavaException(env, 0);
	return 0;
	}

	logMessage(LOG_DEBUG, "java static field found: %s: %s", name, signature);
	}

	return 1;
	}

	char *
	getJavaLocaleName (void) {
	char *name = NULL;
	JNIEnv *env;

	if ((env = getJavaNativeInterface())) {
	jclass Locale_class = NULL;

	if (findJavaClass(env, &Locale_class, JAVA_OBJ_LOCALE)) {
	jmethodID Locale_getDefault = 0;

	if (findJavaStaticMethod(env, &Locale_getDefault, Locale_class, "getDefault",
	JAVA_SIG_METHOD(JAVA_SIG_LOCALE,
	))) {
	jobject locale = (*env)->CallStaticObjectMethod(env, Locale_class, Locale_getDefault);

	if (!clearJavaException(env, 1)) {
	jmethodID Locale_toString = 0;

	if (findJavaInstanceMethod(env, &Locale_toString, Locale_class, "toString",
	JAVA_SIG_METHOD(JAVA_SIG_STRING,
	))) {
	jstring jName = (*env)->CallObjectMethod(env, locale, Locale_toString);

	if (!clearJavaException(env, 1)) {
	jboolean isCopy;
	const char cName = (env)->GetStringUTFChars(env, jName, &isCopy);

	if (!(name = strdup(cName))) {
	logMallocError();
	}

	(*env)->ReleaseStringUTFChars(env, jName, cName);
	(*env)->DeleteLocalRef(env, jName);
	}
	}

	(*env)->DeleteLocalRef(env, locale);
	}
	}
	}
	}

	return name;
	}

	#if defined(__ANDROID__)
	#include <locale.h>
	#include "messages.h"

	static void
	initializeAndroidEnvironment (JNIEnv *env) {
	{
	static jclass class = NULL;

	if (findJavaClass(env, &class, JAVA_OBJ_BRLTTY("BrailleApplication"))) {
	static jmethodID method = 0;

	if (findJavaStaticMethod(env, &method, class, "getCurrentLocale",
	JAVA_SIG_METHOD(JAVA_SIG_STRING,
	))) {
	jstring jLocale = (*env)->CallStaticObjectMethod(env, class, method);

	if (!clearJavaException(env, 1)) {
	if (jLocale) {
	jboolean isCopy;
	const char cLocale = (env)->GetStringUTFChars(env, jLocale, &isCopy);

	if (cLocale) {
	if (setMessagesLocale(cLocale)) {
	}

	(*env)->ReleaseStringUTFChars(env, jLocale, cLocale);
	}

	(*env)->DeleteLocalRef(env, jLocale);
	}
	}
	}
	}
	}
	}
	#endif /* platform-speciofic initialization */

	void
	initializeSystemObject (void) {
	#if defined(__ANDROID__)
	initializeAndroidEnvironment(getJavaNativeInterface());
	#endif /* platform-speciofic initialization */
	}