GitHub Viewer
#include "javaObject.h"
#include "java.h"
#include "javaScope.h"
#include "utils.h"
#include
#include
/*static*/ std::map JavaObject::sFunctionTemplates;
/*static*/ void JavaObject::Init(v8::Handle target) {
}
/*static*/ v8::Local JavaObject::New(Java *java, jobject obj) {
v8::HandleScope scope;
JNIEnv *env = java->getJavaEnv();
JavaScope javaScope(env);
jclass objClazz = env->GetObjectClass(obj);
jclass classClazz = env->FindClass("java/lang/Class");
jmethodID class_getName = env->GetMethodID(classClazz, "getName", "()Ljava/lang/String;");
jobject classNameJava = env->CallObjectMethod(objClazz, class_getName);
assert(!env->ExceptionCheck());
std::string className = javaObjectToString(env, classNameJava);
std::replace(className.begin(), className.end(), '.', '_');
std::replace(className.begin(), className.end(), '$', '_');
std::replace(className.begin(), className.end(), '[', 'a');
className = "nodeJava_" + className;
v8::Persistent persistentFuncTemplate;
if(sFunctionTemplates.find(className) != sFunctionTemplates.end()) {
//printf("existing className: %s\n", className.c_str());
persistentFuncTemplate = sFunctionTemplates[className];
} else {
//printf("create className: %s\n", className.c_str());
v8::Local funcTemplate = v8::FunctionTemplate::New();
funcTemplate->InstanceTemplate()->SetInternalFieldCount(1);
funcTemplate->SetClassName(v8::String::NewSymbol(className.c_str()));
std::list methods;
javaReflectionGetMethods(env, objClazz, &methods, false);
jclass methodClazz = env->FindClass("java/lang/reflect/Method");
jmethodID method_getName = env->GetMethodID(methodClazz, "getName", "()Ljava/lang/String;");
for(std::list::iterator it = methods.begin(); it != methods.end(); ++it) {
jstring methodNameJava = (jstring)env->CallObjectMethod(*it, method_getName);
assert(!env->ExceptionCheck());
std::string methodNameStr = javaToString(env, methodNameJava);
v8::Handle methodName = v8::String::New(methodNameStr.c_str());
v8::Local methodCallTemplate = v8::FunctionTemplate::New(methodCall, methodName);
funcTemplate->PrototypeTemplate()->Set(methodName, methodCallTemplate->GetFunction());
v8::Handle methodNameSync = v8::String::New((methodNameStr + "Sync").c_str());
v8::Local methodCallSyncTemplate = v8::FunctionTemplate::New(methodCallSync, methodName);
funcTemplate->PrototypeTemplate()->Set(methodNameSync, methodCallSyncTemplate->GetFunction());
}
std::list fields;
javaReflectionGetFields(env, objClazz, &fields);
jclass fieldClazz = env->FindClass("java/lang/reflect/Field");
jmethodID field_getName = env->GetMethodID(fieldClazz, "getName", "()Ljava/lang/String;");
for(std::list::iterator it = fields.begin(); it != fields.end(); ++it) {
jstring fieldNameJava = (jstring)env->CallObjectMethod(*it, field_getName);
assert(!env->ExceptionCheck());
std::string fieldNameStr = javaToString(env, fieldNameJava);
v8::Handle fieldName = v8::String::New(fieldNameStr.c_str());
funcTemplate->InstanceTemplate()->SetAccessor(fieldName, fieldGetter, fieldSetter);
}
sFunctionTemplates[className] = persistentFuncTemplate = v8::Persistent::New(funcTemplate);
}
v8::Local ctor = persistentFuncTemplate->GetFunction();
v8::Local javaObjectObj = ctor->NewInstance();
javaObjectObj->SetHiddenValue(v8::String::New(V8_HIDDEN_MARKER_JAVA_OBJECT), v8::Boolean::New(true));
JavaObject *self = new JavaObject(java, obj);
self->Wrap(javaObjectObj);
return scope.Close(javaObjectObj);
}
JavaObject::JavaObject(Java *java, jobject obj) {
m_java = java;
JNIEnv *env = m_java->getJavaEnv();
m_obj = env->NewGlobalRef(obj);
m_class = (jclass)env->NewGlobalRef(env->GetObjectClass(obj));
}
JavaObject::~JavaObject() {
JNIEnv *env = m_java->getJavaEnv();
jclass nodeDynamicProxyClass = env->FindClass("node/NodeDynamicProxyClass");
if(env->IsInstanceOf(m_obj, nodeDynamicProxyClass)) {
jfieldID ptrField = env->GetFieldID(nodeDynamicProxyClass, "ptr", "J");
DynamicProxyData* proxyData = (DynamicProxyData*)(long)env->GetLongField(m_obj, ptrField);
if(dynamicProxyDataVerify(proxyData)) {
delete proxyData;
}
}
env->DeleteGlobalRef(m_obj);
env->DeleteGlobalRef(m_class);
}
/*static*/ v8::Handle JavaObject::methodCall(const v8::Arguments& args) {
v8::HandleScope scope;
JavaObject* self = node::ObjectWrap::Unwrap(args.This());
JNIEnv *env = self->m_java->getJavaEnv();
JavaScope javaScope(env);
v8::String::AsciiValue methodName(args.Data());
std::string methodNameStr = *methodName;
int argsStart = 0;
int argsEnd = args.Length();
// arguments
ARGS_BACK_CALLBACK();
if(!callbackProvided && methodNameStr == "toString") {
return methodCallSync(args);
}
jobjectArray methodArgs = v8ToJava(env, args, argsStart, argsEnd);
jobject method = javaFindMethod(env, self->m_class, methodNameStr, methodArgs);
if(method == NULL) {
std::string msg = methodNotFoundToString(env, self->m_class, methodNameStr, false, args, argsStart, argsEnd);
EXCEPTION_CALL_CALLBACK(self->m_java, msg);
return v8::Undefined();
}
// run
InstanceMethodCallBaton* baton = new InstanceMethodCallBaton(self->m_java, self, method, methodArgs, callback);
baton->run();
END_CALLBACK_FUNCTION("\"Method '"