store javascript object in java

joeferner · joeferner · commit 732d26dc3606 · 2015-09-28T09:57:31.000-04:00
diff --git a/src-java/node/NodeObject.java b/src-java/node/NodeObject.java
@@ -0,0 +1,18 @@
+package node;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Array;
+import java.util.Arrays;
+
+public class NodeObject {
+     private final long handle;
+
+     public NodeObject(long handle) {
+          this.handle = handle;
+     }
+     
+     public long getHandle() {
+          return this.handle;
+     }
+}
diff --git a/src/utils.cpp b/src/utils.cpp
@@ -10,6 +10,7 @@
 
 jobject v8ToJava_javaObject(JNIEnv* env, v8::Local<v8::Object> obj);
 jobject v8ToJava_javaLong(JNIEnv* env, v8::Local<v8::Object> obj);
+jobject v8ToJava_v8Object(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");
@@ -362,14 +363,26 @@ jobject v8ToJava(JNIEnv* env, v8::Local<v8::Value> arg) {
     if(!isJavaLong.IsEmpty() && isJavaLong->IsBoolean()) {
       return v8ToJava_javaLong(env, obj);
     }
+    
+    return v8ToJava_v8Object(env, obj);
   }
 
   // TODO: handle other arg types. Don't print here, see instanceof-test#non-java object
-  // v8::String::AsciiValue typeStr(arg);
+  // v8::String::Utf8Value typeStr(arg);
   // printf("v8ToJava: Unhandled type: %s\n", *typeStr);
   return NULL;
 }
 
+jobject v8ToJava_v8Object(JNIEnv* env, v8::Local<v8::Object> obj) {
+  Nan::Persistent<v8::Object>* p = new Nan::Persistent<v8::Object>();
+  p->Reset(obj);
+
+  jclass nodeObjectClass = env->FindClass("node/NodeObject");
+  jmethodID nodeObject_constructor = env->GetMethodID(nodeObjectClass, "<init>", "(J)V");
+  jobject jobj = env->NewObject(nodeObjectClass, nodeObject_constructor, (long) p);
+  return jobj;
+}
+
 jobject v8ToJava_javaObject(JNIEnv* env, v8::Local<v8::Object> obj) {
   JavaObject* javaObject = Nan::ObjectWrap::Unwrap<JavaObject>(obj);
   return javaObject->getObject();
@@ -644,11 +657,18 @@ v8::Local<v8::Value> javaToV8(Java* java, JNIEnv* env, jobject obj, DynamicProxy
       }
     case TYPE_STRING:
       return Nan::New<v8::String>(javaObjectToString(env, obj).c_str()).ToLocalChecked();
-    case TYPE_OBJECT:
+    case TYPE_OBJECT: {
       if (dynamicProxyData != NULL) {
         return JavaProxyObject::New(java, obj, dynamicProxyData);
       }
+      jclass nodeObjectClass = env->FindClass("node/NodeObject");
+      if (env->IsSameObject(nodeObjectClass, objClazz)) {
+	jmethodID nodeObjectClass_getHandle = env->GetMethodID(nodeObjectClass, "getHandle", "()J");
+	Nan::Persistent<v8::Object>* p = (Nan::Persistent<v8::Object>*) env->CallLongMethod(obj, nodeObjectClass_getHandle);
+	return Nan::New(*p);
+      }
       return JavaObject::New(java, obj);
+    }
     default:
       printf("javaToV8: unhandled type: 0x%03x\n", resultType);
       return JavaObject::New(java, obj);
diff --git a/test/Test.java b/test/Test.java
@@ -5,6 +5,7 @@ public class Test {
   public static int staticFieldInt = 42;
   public static double staticFieldDouble = 42.5;
   public static Test[] staticArrayObjects = null;
+  public static Object staticFieldObject = null;
 
   public Test() {}
   public Test(Integer i) { this.i = i; }
@@ -42,6 +43,9 @@ public Test() {}
   public static int staticMethodAmbiguous(Double a) { return 1; }
   public static int staticMethodAmbiguous(Integer a) { return 2; }
 
+  public static void staticMethodSetObject(Object obj) { staticFieldObject = obj; }
+  public static Object staticMethodGetObject() { return staticFieldObject; }
+  
   public int methodAmbiguous(Double a) { return 1; }
   public int methodAmbiguous(Integer a) { return 2; }
 
diff --git a/test/java-callStaticMethod-test.js b/test/java-callStaticMethod-test.js
@@ -288,5 +288,21 @@ exports['Java - Call Static Method'] = nodeunit.testCase({
       test.ifError(err);
       test.done();
     });
+  },
+  
+  "Call static method with javascript objects": function(test) {
+    var Test = java.import("Test");
+    var obj = Test.staticMethodGetObjectSync();
+    test.equal(obj, null);
+    
+    obj = function() { return 42; };
+    Test.staticMethodSetObjectSync(obj);
+    
+    obj = Test.staticMethodGetObjectSync();
+    test.notEqual(obj, null);
+    console.log('zzzzzzzzzzzzzzzzzzzzzzzz', obj);
+    test.equal(obj(), 42);
+    
+    test.done();
   }
 });
