Merge branch 'master' of github.com:nearinfinity/node-java

joeferner · joeferner · commit b6fdecf6ef3b · 2013-04-11T13:58:04.000-04:00
diff --git a/README.md b/README.md
@@ -60,13 +60,27 @@ var byteArray = java.newArray(
     .map(function(c) { return java.newByte(str.charCodeAt(c)); });
 ```
 
+### Using java.lang.Long and long
+
+JavaScript only supports 32-bit integers. Because of this java longs must be treated specially.
+When getting a long result the value may be truncated. If you need the original value there is
+a property off of the result called "longValue" which contains the un-truncated value as a string.
+If you are calling a method that takes a long you must create it using [java.newInstance](#javaNewInstance).
+
+```javascript
+var javaLong = java.newInstanceSync("java.lang.Long", 5);
+console.log('Possibly truncated long value: ' + javaLong);
+console.log('Original long value (as a string): ' + javaLong.longValue);
+java.callStaticMethodSync("Test", "staticMethodThatTakesALong", javaLong);
+```
+
 # Release Notes
 
 ### v0.2.0
 
-* java.lang.Long and long primitives are no longer auto converted to JavaScript numbers due to the lack of 
-  precision \([See Issue #37](https://github.com/nearinfinity/node-java/issues/37)\) and 
-  lack of autoboxing support from Apache Commons Lang MethodUtils#getMatchingAccessibleMethod \([See Issue #40](https://github.com/nearinfinity/node-java/issues/40)\).
+* java.lang.Long and long primitives are handled better. See
+  \([Issue #37](https://github.com/nearinfinity/node-java/issues/37)\) and
+  \([Issue #40](https://github.com/nearinfinity/node-java/issues/40)\).
 
 # Index
 
diff --git a/binding.gyp b/binding.gyp
@@ -4,6 +4,12 @@
     'conditions': [
       ['target_arch=="ia32"', {
         'arch%': "i386"
+      }],
+      ['OS=="win"', {
+        'javahome%': "<!(echo %JAVA_HOME%)"
+      }],
+      ['OS=="linux" or OS=="mac"', {
+        'javahome%': "<!(echo $JAVA_HOME)"
       }]
     ]
   },
@@ -19,7 +25,7 @@
         "src/utils.cpp"
       ],
       "include_dirs": [
-        "$(JAVA_HOME)/include",
+        "<(javahome)/include",
       ],
       'conditions': [
         ['OS=="win"',
@@ -28,20 +34,20 @@
               {
                 'action_name': 'verifyDeps',
                 'inputs': [
-                  '$(JAVA_HOME)/lib/jvm.lib',
-                  '$(JAVA_HOME)/include/jni.h',
-                  '$(JAVA_HOME)/include/win32/jni_md.h'
+                  '<(javahome)/lib/jvm.lib',
+                  '<(javahome)/include/jni.h',
+                  '<(javahome)/include/win32/jni_md.h'
                 ],
                 'outputs': ['./build/depsVerified'],
                 'action': ['python', 'touch.py'],
                 'message': 'Verify Deps'
               }
             ],
             "include_dirs": [
-              "$(JAVA_HOME)/include/win32",
+              "<(javahome)/include/win32",
             ],
             "libraries": [
-              "-l$(JAVA_HOME)/lib/jvm.lib"
+              "-l<(javahome)/lib/jvm.lib"
             ]
           }
         ],
@@ -51,21 +57,21 @@
               {
                 'action_name': 'verifyDeps',
                 'inputs': [
-                  '$(JAVA_HOME)/jre/lib/<(arch)/server/libjvm.so',
-                  '$(JAVA_HOME)/include/jni.h',
-                  '$(JAVA_HOME)/include/linux/jni_md.h'
+                  '<(javahome)/jre/lib/<(arch)/server/libjvm.so',
+                  '<(javahome)/include/jni.h',
+                  '<(javahome)/include/linux/jni_md.h'
                 ],
                 'outputs': ['./build/depsVerified'],
                 'action': [],
                 'message': 'Verify Deps'
               }
             ],
             "include_dirs": [
-              "$(JAVA_HOME)/include/linux",
+              "<(javahome)/include/linux",
             ],
             "libraries": [
-              "-L$(JAVA_HOME)/jre/lib/<(arch)/server/",
-              "-Wl,-rpath,$(JAVA_HOME)/jre/lib/<(arch)/server/",
+              "-L<(javahome)/jre/lib/<(arch)/server/",
+              "-Wl,-rpath,<(javahome)/jre/lib/<(arch)/server/",
               "-ljvm"
             ]
           }
diff --git a/package.json b/package.json
@@ -7,7 +7,7 @@
     "jvm",
     "bridge"
   ],
-  "version": "0.2.0",
+  "version": "0.2.2",
   "engines": {
     "node": ">=0.6.0"
   },
diff --git a/src/java.cpp b/src/java.cpp
@@ -9,6 +9,7 @@
 #include "javaScope.h"
 #include "methodCallBaton.h"
 #include "node_NodeDynamicProxyClass.h"
+#include <node_version.h>
 #include <sstream>
 
 std::string nativeBindingLocation;
@@ -650,7 +651,11 @@ v8::Handle<v8::Value> Java::createJVM(JavaVM** jvm, JNIEnv** env) {
 void EIO_CallJs(uv_work_t* req) {
 }
 
+#if NODE_MINOR_VERSION >= 10
+void EIO_AfterCallJs(uv_work_t* req, int status) {
+#else
 void EIO_AfterCallJs(uv_work_t* req) {
+#endif
   DynamicProxyData* dynamicProxyData = static_cast<DynamicProxyData*>(req->data);
   if(!dynamicProxyDataVerify(dynamicProxyData)) {
     return;
@@ -726,7 +731,11 @@ JNIEXPORT jobject JNICALL Java_node_NodeDynamicProxyClass_callJs(JNIEnv *env, jo
   uv_work_t* req = new uv_work_t();
   req->data = dynamicProxyData;
   if(myThreadId == v8ThreadId) {
+#if NODE_MINOR_VERSION >= 10
+    EIO_AfterCallJs(req, 0);
+#else
     EIO_AfterCallJs(req);
+#endif
   } else {
     uv_queue_work(uv_default_loop(), req, EIO_CallJs, EIO_AfterCallJs);
 
diff --git a/src/javaObject.cpp b/src/javaObject.cpp
@@ -73,7 +73,7 @@
 
   v8::Local<v8::Function> ctor = persistentFuncTemplate->GetFunction();
   v8::Local<v8::Object> javaObjectObj = ctor->NewInstance();
-  javaObjectObj->SetHiddenValue(v8::String::New("__isJavaObject"), v8::Boolean::New(true));
+  javaObjectObj->SetHiddenValue(v8::String::New(V8_HIDDEN_MARKER_JAVA_OBJECT), v8::Boolean::New(true));
   JavaObject *self = new JavaObject(java, obj);
   self->Wrap(javaObjectObj);
 
diff --git a/src/methodCallBaton.cpp b/src/methodCallBaton.cpp
@@ -50,7 +50,11 @@ v8::Handle<v8::Value> MethodCallBaton::runSync() {
   javaDetachCurrentThread(self->m_java->getJvm());
 }
 
+#if NODE_MINOR_VERSION >= 10
+/*static*/ void MethodCallBaton::EIO_AfterMethodCall(uv_work_t* req, int status) {
+#else
 /*static*/ void MethodCallBaton::EIO_AfterMethodCall(uv_work_t* req) {
+#endif
   MethodCallBaton* self = static_cast<MethodCallBaton*>(req->data);
   JNIEnv *env = self->m_java->getJavaEnv();
   self->after(env);
@@ -78,7 +82,6 @@ v8::Handle<v8::Value> MethodCallBaton::resultsToV8(JNIEnv *env) {
 
   if(m_error) {
     v8::Handle<v8::Value> err = javaExceptionToV8(env, m_error, m_errorString);
-    env->DeleteGlobalRef(m_error);
     return scope.Close(err);
   }
 
@@ -92,9 +95,8 @@ void NewInstanceBaton::execute(JNIEnv *env) {
   //printf("invoke: %s\n", javaMethodCallToString(env, m_method, constructor_newInstance, m_args).c_str());
 
   jobject result = env->CallObjectMethod(m_method, constructor_newInstance, m_args);
-  jthrowable err = env->ExceptionOccurred();
-  if(err) {
-    m_error = (jthrowable)env->NewGlobalRef(err);
+  if(env->ExceptionCheck()) {
+    m_error = env->ExceptionOccurred();
     m_errorString = "Error creating class";
     env->ExceptionClear();
     return;
@@ -117,9 +119,8 @@ void StaticMethodCallBaton::execute(JNIEnv *env) {
 
   jobject result = env->CallObjectMethod(m_method, method_invoke, NULL, m_args);
 
-  jthrowable err = env->ExceptionOccurred();
-  if(err) {
-    m_error = (jthrowable)env->NewGlobalRef(err);
+  if(env->ExceptionCheck()) {
+    m_error = env->ExceptionOccurred();
     m_errorString = "Error running static method";
     env->ExceptionClear();
     return;
@@ -142,9 +143,8 @@ void InstanceMethodCallBaton::execute(JNIEnv *env) {
 
   jobject result = env->CallObjectMethod(m_method, method_invoke, m_javaObject->getObject(), m_args);
 
-  jthrowable err = env->ExceptionOccurred();
-  if(err) {
-    m_error = (jthrowable)env->NewGlobalRef(err);
+  if(env->ExceptionCheck()) {
+    m_error = env->ExceptionOccurred();
     m_errorString = "Error running instance method";
     env->ExceptionClear();
     return;
diff --git a/src/methodCallBaton.h b/src/methodCallBaton.h
@@ -5,6 +5,7 @@
 #include "utils.h"
 #include <v8.h>
 #include <node.h>
+#include <node_version.h>
 #include <jni.h>
 #include <list>
 
@@ -17,7 +18,11 @@ class MethodCallBaton {
   virtual ~MethodCallBaton();
 
   static void EIO_MethodCall(uv_work_t* req);
+#if NODE_MINOR_VERSION >= 10
+  static void EIO_AfterMethodCall(uv_work_t* req, int status);
+#else
   static void EIO_AfterMethodCall(uv_work_t* req);
+#endif
   void run();
   v8::Handle<v8::Value> runSync();
 
diff --git a/src/utils.cpp b/src/utils.cpp
@@ -8,6 +8,9 @@
 
 #define MODIFIER_STATIC 9
 
+jobject v8ToJava_javaObject(JNIEnv* env, v8::Local<v8::Object> obj);
+jobject v8ToJava_javaLong(JNIEnv* env, v8::Local<v8::Object> obj);
+
 void javaReflectionGetMethods(JNIEnv *env, jclass clazz, std::list<jobject>* methods, bool includeStatic) {
   jclass clazzclazz = env->FindClass("java/lang/Class");
   jmethodID clazz_getMethods = env->GetMethodID(clazzclazz, "getMethods", "()[Ljava/lang/reflect/Method;");
@@ -267,55 +270,15 @@ jobject v8ToJava(JNIEnv* env, v8::Local<v8::Value> arg) {
 
   if(arg->IsObject()) {
     v8::Local<v8::Object> obj = v8::Object::Cast(*arg);
-    v8::Local<v8::Value> isJavaObject = obj->GetHiddenValue(v8::String::New("__isJavaObject"));
+
+    v8::Local<v8::Value> isJavaObject = obj->GetHiddenValue(v8::String::New(V8_HIDDEN_MARKER_JAVA_OBJECT));
     if(!isJavaObject.IsEmpty() && isJavaObject->IsBoolean()) {
-      JavaObject* javaObject = node::ObjectWrap::Unwrap<JavaObject>(obj);
-      jobject jobj = javaObject->getObject();
-
-      jclass nodeDynamicProxyClass = env->FindClass("node/NodeDynamicProxyClass");
-      if(env->IsInstanceOf(jobj, nodeDynamicProxyClass)) {
-        jfieldID ptrField = env->GetFieldID(nodeDynamicProxyClass, "ptr", "J");
-        DynamicProxyData* proxyData = (DynamicProxyData*)(long)env->GetLongField(jobj, ptrField);
-        if(!dynamicProxyDataVerify(proxyData)) {
-          return NULL;
-        }
-
-        jclass dynamicInterface = javaFindClass(env, proxyData->interfaceName);
-        if(dynamicInterface == NULL) {
-          printf("Could not find interface %s\n", proxyData->interfaceName.c_str());
-          return NULL;
-        }
-        jclass classClazz = env->FindClass("java/lang/Class");
-        jobjectArray classArray = env->NewObjectArray(1, classClazz, NULL);
-        env->SetObjectArrayElement(classArray, 0, dynamicInterface);
-
-        jmethodID class_getClassLoader = env->GetMethodID(classClazz, "getClassLoader", "()Ljava/lang/ClassLoader;");
-        jobject classLoader = env->CallObjectMethod(dynamicInterface, class_getClassLoader);
-        if(classLoader == NULL) {
-          jclass objectClazz = env->FindClass("java/lang/Object");
-          jmethodID object_getClass = env->GetMethodID(objectClazz, "getClass", "()Ljava/lang/Class;");
-          jobject jobjClass = env->CallObjectMethod(jobj, object_getClass);
-          classLoader = env->CallObjectMethod(jobjClass, class_getClassLoader);
-        }
-
-        jclass proxyClass = env->FindClass("java/lang/reflect/Proxy");
-        jmethodID proxy_newProxyInstance = env->GetStaticMethodID(proxyClass, "newProxyInstance", "(Ljava/lang/ClassLoader;[Ljava/lang/Class;Ljava/lang/reflect/InvocationHandler;)Ljava/lang/Object;");
-        if(classLoader == NULL) {
-          printf("Could not get classloader for Proxy\n");
-          return NULL;
-        }
-        if(classArray == NULL) {
-          printf("Could not create class array for Proxy\n");
-          return NULL;
-        }
-        if(jobj == NULL) {
-          printf("Not a valid object to wrap\n");
-          return NULL;
-        }
-        jobj = env->CallStaticObjectMethod(proxyClass, proxy_newProxyInstance, classLoader, classArray, jobj);
-      }
+      return v8ToJava_javaObject(env, obj);
+    }
 
-      return jobj;
+    v8::Local<v8::Value> isJavaLong = obj->GetHiddenValue(v8::String::New(V8_HIDDEN_MARKER_JAVA_LONG));
+    if(!isJavaLong.IsEmpty() && isJavaLong->IsBoolean()) {
+      return v8ToJava_javaLong(env, obj);
     }
   }
 
@@ -325,6 +288,64 @@ jobject v8ToJava(JNIEnv* env, v8::Local<v8::Value> arg) {
   return NULL;
 }
 
+jobject v8ToJava_javaObject(JNIEnv* env, v8::Local<v8::Object> obj) {
+  JavaObject* javaObject = node::ObjectWrap::Unwrap<JavaObject>(obj);
+  jobject jobj = javaObject->getObject();
+
+  jclass nodeDynamicProxyClass = env->FindClass("node/NodeDynamicProxyClass");
+  if(env->IsInstanceOf(jobj, nodeDynamicProxyClass)) {
+    jfieldID ptrField = env->GetFieldID(nodeDynamicProxyClass, "ptr", "J");
+    DynamicProxyData* proxyData = (DynamicProxyData*)(long)env->GetLongField(jobj, ptrField);
+    if(!dynamicProxyDataVerify(proxyData)) {
+      return NULL;
+    }
+
+    jclass dynamicInterface = javaFindClass(env, proxyData->interfaceName);
+    if(dynamicInterface == NULL) {
+      printf("Could not find interface %s\n", proxyData->interfaceName.c_str());
+      return NULL;
+    }
+    jclass classClazz = env->FindClass("java/lang/Class");
+    jobjectArray classArray = env->NewObjectArray(1, classClazz, NULL);
+    env->SetObjectArrayElement(classArray, 0, dynamicInterface);
+
+    jmethodID class_getClassLoader = env->GetMethodID(classClazz, "getClassLoader", "()Ljava/lang/ClassLoader;");
+    jobject classLoader = env->CallObjectMethod(dynamicInterface, class_getClassLoader);
+    if(classLoader == NULL) {
+      jclass objectClazz = env->FindClass("java/lang/Object");
+      jmethodID object_getClass = env->GetMethodID(objectClazz, "getClass", "()Ljava/lang/Class;");
+      jobject jobjClass = env->CallObjectMethod(jobj, object_getClass);
+      classLoader = env->CallObjectMethod(jobjClass, class_getClassLoader);
+    }
+
+    jclass proxyClass = env->FindClass("java/lang/reflect/Proxy");
+    jmethodID proxy_newProxyInstance = env->GetStaticMethodID(proxyClass, "newProxyInstance", "(Ljava/lang/ClassLoader;[Ljava/lang/Class;Ljava/lang/reflect/InvocationHandler;)Ljava/lang/Object;");
+    if(classLoader == NULL) {
+      printf("Could not get classloader for Proxy\n");
+      return NULL;
+    }
+    if(classArray == NULL) {
+      printf("Could not create class array for Proxy\n");
+      return NULL;
+    }
+    if(jobj == NULL) {
+      printf("Not a valid object to wrap\n");
+      return NULL;
+    }
+    jobj = env->CallStaticObjectMethod(proxyClass, proxy_newProxyInstance, classLoader, classArray, jobj);
+  }
+
+  return jobj;
+}
+
+jobject v8ToJava_javaLong(JNIEnv* env, v8::Local<v8::Object> obj) {
+  jobject longValue = v8ToJava(env, obj->Get(v8::String::New("longValue")));
+  jclass longClazz = env->FindClass("java/lang/Long");
+  jmethodID long_constructor = env->GetMethodID(longClazz, "<init>", "(Ljava/lang/String;)V");
+  jobject jobj = env->NewObject(longClazz, long_constructor, longValue);
+  return jobj;
+}
+
 jobjectArray v8ToJava(JNIEnv* env, const v8::Arguments& args, int start, int end) {
   jclass clazz = env->FindClass("java/lang/Object");
   jobjectArray results = env->NewObjectArray(end-start, clazz, NULL);
@@ -509,14 +530,18 @@ v8::Handle<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj) {
         jbyte result = env->CallByteMethod(obj, byte_byteValue);
         return scope.Close(v8::Number::New(result));
       }
-// Removed to support long return types and long parameters.
-//    case TYPE_LONG:
-//      {
-//        jclass longClazz = env->FindClass("java/lang/Long");
-//        jmethodID long_longValue = env->GetMethodID(longClazz, "longValue", "()J");
-//        jlong result = env->CallLongMethod(obj, long_longValue);
-//        return scope.Close(v8::Number::New(result));
-//      }
+    case TYPE_LONG:
+      {
+        jclass longClazz = env->FindClass("java/lang/Long");
+        jmethodID long_longValue = env->GetMethodID(longClazz, "longValue", "()J");
+        jlong result = env->CallLongMethod(obj, long_longValue);
+        std::string strValue = javaObjectToString(env, obj);
+        v8::Local<v8::Value> v8Result = v8::NumberObject::New(result);
+        v8::NumberObject* v8ResultNumberObject = v8::NumberObject::Cast(*v8Result);
+        v8ResultNumberObject->Set(v8::String::New("longValue"), v8::String::New(strValue.c_str()));
+        v8ResultNumberObject->SetHiddenValue(v8::String::New(V8_HIDDEN_MARKER_JAVA_LONG), v8::Boolean::New(true));
+        return scope.Close(v8Result);
+      }
     case TYPE_INT:
       {
         jclass integerClazz = env->FindClass("java/lang/Integer");
diff --git a/src/utils.h b/src/utils.h
diff --git a/test/java-callStaticMethod-test.js b/test/java-callStaticMethod-test.js
