JNIUtility.cpp   [plain text]

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

    jniError = getJavaVM()->AttachCurrentThread(&u.dummy, 0);

    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;
    else
        type = JavaTypeObject;

    return type;
}

const char* signatureFromJavaType(JavaType type)
{
    switch (type) {
    case JavaTypeVoid:
        return "V";

    case JavaTypeArray:
        return "[";

    case JavaTypeObject:
        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:
                    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:
        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)