GitHub Viewer
#include "java.h"
#include
#ifdef WIN32
#else
#include
#endif
#include "javaObject.h"
#include "javaScope.h"
#include "methodCallBaton.h"
#include "node_NodeDynamicProxyClass.h"
#include
std::string nativeBindingLocation;
long v8ThreadId;
/*static*/ v8::Persistent Java::s_ct;
void my_sleep(int dur) {
#ifdef WIN32
Sleep(dur);
#else
usleep(dur);
#endif
}
long my_getThreadId() {
#ifdef WIN32
return (long)GetCurrentThreadId();
#else
return (long)pthread_self();
#endif
}
/*static*/ void Java::Init(v8::Handle target) {
v8::HandleScope scope;
v8ThreadId = my_getThreadId();
v8::Local t = v8::FunctionTemplate::New(New);
s_ct = v8::Persistent::New(t);
s_ct->InstanceTemplate()->SetInternalFieldCount(1);
s_ct->SetClassName(v8::String::NewSymbol("Java"));
NODE_SET_PROTOTYPE_METHOD(s_ct, "getClassLoader", getClassLoader);
NODE_SET_PROTOTYPE_METHOD(s_ct, "newInstance", newInstance);
NODE_SET_PROTOTYPE_METHOD(s_ct, "newInstanceSync", newInstanceSync);
NODE_SET_PROTOTYPE_METHOD(s_ct, "newProxy", newProxy);
NODE_SET_PROTOTYPE_METHOD(s_ct, "callStaticMethod", callStaticMethod);
NODE_SET_PROTOTYPE_METHOD(s_ct, "callStaticMethodSync", callStaticMethodSync);
NODE_SET_PROTOTYPE_METHOD(s_ct, "findClassSync", findClassSync);
NODE_SET_PROTOTYPE_METHOD(s_ct, "newArray", newArray);
NODE_SET_PROTOTYPE_METHOD(s_ct, "newByte", newByte);
NODE_SET_PROTOTYPE_METHOD(s_ct, "getStaticFieldValue", getStaticFieldValue);
NODE_SET_PROTOTYPE_METHOD(s_ct, "setStaticFieldValue", setStaticFieldValue);
target->Set(v8::String::NewSymbol("Java"), s_ct->GetFunction());
}
/*static*/ v8::Handle Java::New(const v8::Arguments& args) {
v8::HandleScope scope;
Java *self = new Java();
self->Wrap(args.This());
self->handle_->Set(v8::String::New("classpath"), v8::Array::New());
self->handle_->Set(v8::String::New("options"), v8::Array::New());
self->handle_->Set(v8::String::New("nativeBindingLocation"), v8::String::New("Not Set"));
return args.This();
}
Java::Java() {
this->m_jvm = NULL;
this->m_env = NULL;
}
Java::~Java() {
}
v8::Handle Java::ensureJvm() {
if(!m_jvm) {
return createJVM(&this->m_jvm, &this->m_env);
}
return v8::Undefined();
}
v8::Handle Java::createJVM(JavaVM** jvm, JNIEnv** env) {
JavaVM* jvmTemp;
JavaVMInitArgs args;
// setup classpath
std::ostringstream classPath;
classPath Get(v8::String::New("classpath"));
if(!classPathValue->IsArray()) {
return ThrowException(v8::Exception::TypeError(v8::String::New("Classpath must be an array")));
}
v8::Local classPathArray = v8::Array::Cast(*classPathValue);
for(uint32_t i=0; iLength(); i++) {
if(i != 0) {
#ifdef WIN32
classPath IsString()) {
return ThrowException(v8::Exception::TypeError(v8::String::New("Classpath must only contain strings")));
}
v8::Local arrayItem = arrayItemValue->ToString();
v8::String::AsciiValue arrayItemStr(arrayItem);
classPath Get(v8::String::New("nativeBindingLocation"));
v8::String::AsciiValue nativeBindingLocationStr(v8NativeBindingLocation);
nativeBindingLocation = *nativeBindingLocationStr;
// get other options
v8::Local optionsValue = handle_->Get(v8::String::New("options"));
if(!optionsValue->IsArray()) {
return ThrowException(v8::Exception::TypeError(v8::String::New("options must be an array")));
}
v8::Local optionsArray = v8::Array::Cast(*optionsValue);
// create vm options
int vmOptionsCount = optionsArray->Length() + 1;
JavaVMOption* vmOptions = new JavaVMOption[vmOptionsCount];
//printf("classPath: %s\n", classPath.str().c_str());
vmOptions[0].optionString = strdup(classPath.str().c_str());
for(uint32_t i=0; iLength(); i++) {
v8::Local arrayItemValue = optionsArray->Get(i);
if(!arrayItemValue->IsString()) {
return ThrowException(v8::Exception::TypeError(v8::String::New("options must only contain strings")));
}
v8::Local arrayItem = arrayItemValue->ToString();
v8::String::AsciiValue arrayItemStr(arrayItem);
vmOptions[i+1].optionString = strdup(*arrayItemStr);
}
JNI_GetDefaultJavaVMInitArgs(&args);
args.version = JNI_VERSION_1_6;
args.ignoreUnrecognized = false;
args.options = vmOptions;
args.nOptions = vmOptionsCount;
JNI_CreateJavaVM(&jvmTemp, (void **)env, &args);
*jvm = jvmTemp;
m_classLoader = getSystemClassLoader(*env);
return v8::Undefined();
}
/*static*/ v8::Handle Java::getClassLoader(const v8::Arguments& args) {
v8::HandleScope scope;
Java* self = node::ObjectWrap::Unwrap(args.This());
v8::Handle ensureJvmResults = self->ensureJvm();
if(!ensureJvmResults->IsUndefined()) {
return ensureJvmResults;
}
JNIEnv* env = self->getJavaEnv();
JavaScope javaScope(env);
jclass classClazz = env->FindClass("java/lang/ClassLoader");
jmethodID class_getClassLoader = env->GetStaticMethodID(classClazz, "getSystemClassLoader", "()Ljava/lang/ClassLoader;");
jobject classLoader = env->CallStaticObjectMethod(classClazz, class_getClassLoader);
jobject result = env->NewGlobalRef(classLoader);
return scope.Close(javaToV8(self, env, result));
}
/*static*/ v8::Handle Java::newInstance(const v8::Arguments& args) {
v8::HandleScope scope;
Java* self = node::ObjectWrap::Unwrap(args.This());
v8::Handle ensureJvmResults = self->ensureJvm();
if(!ensureJvmResults->IsUndefined()) {
return ensureJvmResults;
}
JNIEnv* env = self->getJavaEnv();
JavaScope javaScope(env);
int argsStart = 0;
int argsEnd = args.Length();
// arguments
ARGS_FRONT_CLASSNAME();
ARGS_BACK_CALLBACK();
// find class
jclass clazz = javaFindClass(env, className);
if(clazz == NULL) {
EXCEPTION_CALL_CALLBACK("Could not find class " run();
END_CALLBACK_FUNCTION("\"Constructor for class '"