/*
* Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "JNIUtility.h"
#if ENABLE(JAVA_BRIDGE)
#include <dlfcn.h>
namespace JSC {
namespace Bindings {
static jint KJSGetCreatedJavaVMs(JavaVM** vmBuf, jsize bufLen, jsize* nVMs)
{
static void* javaVMFramework = 0;
if (!javaVMFramework)
javaVMFramework = dlopen("/System/Library/Frameworks/JavaVM.framework/JavaVM", RTLD_LAZY);
if (!javaVMFramework)
return JNI_ERR;
typedef jint(*FunctionPointerType)(JavaVM**, jsize, jsize*);
static FunctionPointerType functionPointer = 0;
if (!functionPointer)
functionPointer = reinterpret_cast<FunctionPointerType>(dlsym(javaVMFramework, "JNI_GetCreatedJavaVMs"));
if (!functionPointer)
return JNI_ERR;
return functionPointer(vmBuf, bufLen, nVMs);
}
static JavaVM* jvm = 0;
// Provide the ability for an outside component to specify the JavaVM to use
// If the jvm value is set, the getJavaVM function below will just return.
// In getJNIEnv(), if AttachCurrentThread is called to a VM that is already
// attached, the result is a no-op.
void setJavaVM(JavaVM* javaVM)
{
jvm = javaVM;
}
JavaVM* getJavaVM()
{
if (jvm)
return jvm;
JavaVM* jvmArray[1];
jsize bufLen = 1;
jsize nJVMs = 0;
jint jniError = 0;
// Assumes JVM is already running ..., one per process
jniError = KJSGetCreatedJavaVMs(jvmArray, bufLen, &nJVMs);
if (jniError == JNI_OK && nJVMs > 0)
jvm = jvmArray[0];
else
LOG_ERROR("JNI_GetCreatedJavaVMs failed, returned %ld", static_cast<long>(jniError));
return jvm;
}
JNIEnv* getJNIEnv()
{
union {
JNIEnv* env;
void* dummy;
} u;
jint jniError = 0;
#if OS(ANDROID)
jniError = getJavaVM()->AttachCurrentThread(&u.env, 0);
#else
jniError = getJavaVM()->AttachCurrentThread(&u.dummy, 0);
#endif
if (jniError == JNI_OK)
return u.env;
LOG_ERROR("AttachCurrentThread failed, returned %ld", static_cast<long>(jniError));
return 0;
}
jmethodID getMethodID(jobject obj, const char* name, const char* sig)
{
JNIEnv* env = getJNIEnv();
jmethodID mid = 0;
if (env) {
jclass cls = env->GetObjectClass(obj);
if (cls) {
mid = env->GetMethodID(cls, name, sig);
if (!mid) {
env->ExceptionClear();
mid = env->GetStaticMethodID(cls, name, sig);
if (!mid)
env->ExceptionClear();
}
}
env->DeleteLocalRef(cls);
}
return mid;
}
const char* getCharactersFromJString(jstring aJString)
{
return getCharactersFromJStringInEnv(getJNIEnv(), aJString);
}
void releaseCharactersForJString(jstring aJString, const char* s)
{
releaseCharactersForJStringInEnv(getJNIEnv(), aJString, s);
}
const char* getCharactersFromJStringInEnv(JNIEnv* env, jstring aJString)
{
jboolean isCopy;
const char* s = env->GetStringUTFChars(aJString, &isCopy);
if (!s) {
env->ExceptionDescribe();
env->ExceptionClear();
fprintf(stderr, "\n");
}
return s;
}
void releaseCharactersForJStringInEnv(JNIEnv* env, jstring aJString, const char* s)
{
env->ReleaseStringUTFChars(aJString, s);
}
const jchar* getUCharactersFromJStringInEnv(JNIEnv* env, jstring aJString)
{
jboolean isCopy;
const jchar* s = env->GetStringChars(aJString, &isCopy);
if (!s) {
env->ExceptionDescribe();
env->ExceptionClear();
fprintf(stderr, "\n");
}
return s;
}
void releaseUCharactersForJStringInEnv(JNIEnv* env, jstring aJString, const jchar* s)
{
env->ReleaseStringChars(aJString, s);
}
JavaType javaTypeFromClassName(const char* name)
{
JavaType type;
if (!strcmp("byte", name))
type = JavaTypeByte;
else if (!strcmp("short", name))
type = JavaTypeShort;
else if (!strcmp("int", name))
type = JavaTypeInt;
else if (!strcmp("long", name))
type = JavaTypeLong;
else if (!strcmp("float", name))
type = JavaTypeFloat;
else if (!strcmp("double", name))
type = JavaTypeDouble;
else if (!strcmp("char", name))
type = JavaTypeChar;
else if (!strcmp("boolean", name))
type = JavaTypeBoolean;
else if (!strcmp("void", name))
type = JavaTypeVoid;
else if ('[' == name[0])
type = JavaTypeArray;
#if USE(V8)
else if (!strcmp("java.lang.String", name))
type = JavaTypeString;
#endif
else
type = JavaTypeObject;
return type;
}
const char* signatureFromJavaType(JavaType type)
{
switch (type) {
case JavaTypeVoid:
return "V";
case JavaTypeArray:
return "[";
case JavaTypeObject:
#if USE(V8)
case JavaTypeString:
#endif
return "L";
case JavaTypeBoolean:
return "Z";
case JavaTypeByte:
return "B";
case JavaTypeChar:
return "C";
case JavaTypeShort:
return "S";
case JavaTypeInt:
return "I";
case JavaTypeLong:
return "J";
case JavaTypeFloat:
return "F";
case JavaTypeDouble:
return "D";
case JavaTypeInvalid:
default:
break;
}
return "";
}
JavaType javaTypeFromPrimitiveType(char type)
{
switch (type) {
case 'V':
return JavaTypeVoid;
case 'L':
return JavaTypeObject;
case '[':
return JavaTypeArray;
case 'Z':
return JavaTypeBoolean;
case 'B':
return JavaTypeByte;
case 'C':
return JavaTypeChar;
case 'S':
return JavaTypeShort;
case 'I':
return JavaTypeInt;
case 'J':
return JavaTypeLong;
case 'F':
return JavaTypeFloat;
case 'D':
return JavaTypeDouble;
default:
break;
}
return JavaTypeInvalid;
}
jvalue getJNIField(jobject obj, JavaType type, const char* name, const char* signature)
{
JavaVM* jvm = getJavaVM();
JNIEnv* env = getJNIEnv();
jvalue result;
memset(&result, 0, sizeof(jvalue));
if (obj && jvm && env) {
jclass cls = env->GetObjectClass(obj);
if (cls) {
jfieldID field = env->GetFieldID(cls, name, signature);
if (field) {
switch (type) {
case JavaTypeArray:
case JavaTypeObject:
#if USE(V8)
case JavaTypeString:
#endif
result.l = env->functions->GetObjectField(env, obj, field);
break;
case JavaTypeBoolean:
result.z = env->functions->GetBooleanField(env, obj, field);
break;
case JavaTypeByte:
result.b = env->functions->GetByteField(env, obj, field);
break;
case JavaTypeChar:
result.c = env->functions->GetCharField(env, obj, field);
break;
case JavaTypeShort:
result.s = env->functions->GetShortField(env, obj, field);
break;
case JavaTypeInt:
result.i = env->functions->GetIntField(env, obj, field);
break;
case JavaTypeLong:
result.j = env->functions->GetLongField(env, obj, field);
break;
case JavaTypeFloat:
result.f = env->functions->GetFloatField(env, obj, field);
break;
case JavaTypeDouble:
result.d = env->functions->GetDoubleField(env, obj, field);
break;
default:
LOG_ERROR("Invalid field type (%d)", static_cast<int>(type));
}
} else {
LOG_ERROR("Could not find field: %s", name);
env->ExceptionDescribe();
env->ExceptionClear();
fprintf(stderr, "\n");
}
env->DeleteLocalRef(cls);
} else
LOG_ERROR("Could not find class for object");
}
return result;
}
jvalue callJNIMethod(jobject object, JavaType returnType, const char* name, const char* signature, jvalue* args)
{
jmethodID methodId = getMethodID(object, name, signature);
jvalue result;
switch (returnType) {
case JavaTypeVoid:
callJNIMethodIDA<void>(object, methodId, args);
break;
case JavaTypeObject:
#if USE(V8)
case JavaTypeString:
#endif
result.l = callJNIMethodIDA<jobject>(object, methodId, args);
break;
case JavaTypeBoolean:
result.z = callJNIMethodIDA<jboolean>(object, methodId, args);
break;
case JavaTypeByte:
result.b = callJNIMethodIDA<jbyte>(object, methodId, args);
break;
case JavaTypeChar:
result.c = callJNIMethodIDA<jchar>(object, methodId, args);
break;
case JavaTypeShort:
result.s = callJNIMethodIDA<jshort>(object, methodId, args);
break;
case JavaTypeInt:
result.i = callJNIMethodIDA<jint>(object, methodId, args);
break;
case JavaTypeLong:
result.j = callJNIMethodIDA<jlong>(object, methodId, args);
break;
case JavaTypeFloat:
result.f = callJNIMethodIDA<jfloat>(object, methodId, args);
break;
case JavaTypeDouble:
result.d = callJNIMethodIDA<jdouble>(object, methodId, args);
break;
default:
break;
}
return result;
}
} // namespace Bindings
} // namespace JSC
#endif // ENABLE(JAVA_BRIDGE)