[[ ExternalsApiV5 ]] Merged in Monte's instanceOf based approach to Send/Post parameters.

runrevmark · runrevmark · commit 64b9206068db · 2013-08-08T09:56:08.000+01:00
[[ ExternalsApiV5 ]] Added simple Send/Post test to android test external.
[[ ExternalsApiV5 ]] Changed signature of LC.Object.Send/Post to use variadic parameters (Object...).
diff --git a/lcidlc/src/InterfaceGenerate.cpp b/lcidlc/src/InterfaceGenerate.cpp
@@ -1631,8 +1631,8 @@ static bool InterfaceGenerateExports(InterfaceRef self, CoderRef p_coder)
 		{ "ObjectRetain", "void", "jlong object", "object" },
 		{ "ObjectRelease", "void", "jlong object", "object" },
 		{ "ObjectExists", "jboolean", "jlong object", "object" },
-		{ "ObjectSend", "void", "jlong object, jobject message, jobject signature, jobject arguments", "object, message, signature, arguments" },
-		{ "ObjectPost", "void", "jlong object, jobject message, jobject signature, jobject arguments", "object, message, signature, arguments" },
+		{ "ObjectSend", "void", "jlong object, jobject message, jobjectArray arguments", "object, message, arguments" },
+		{ "ObjectPost", "void", "jlong object, jobject message, jobjectArray arguments", "object, message, arguments" },
 		{ "ContextMe", "jlong", nil, nil },
 		{ "ContextTarget", "jlong", nil, nil },
 		{ "RunOnSystemThread", "void", "jobject runnable", "runnable" },
diff --git a/lcidlc/src/Support.java b/lcidlc/src/Support.java
@@ -171,10 +171,16 @@ public boolean Exists()
 			
 		//////////
 		
-		public void Post(String p_message, String p_signature, java.lang.Object[] p_arguments)
+		public void Send(String p_message, java.lang.Object... p_arguments)
 		{
 			Check();
-			__ObjectPost(m_pointer, p_message, p_signature, p_arguments);
+			__ObjectSend(m_pointer, p_message, p_arguments);
+		}
+		
+		public void Post(String p_message, java.lang.Object... p_arguments)
+		{
+			Check();
+			__ObjectPost(m_pointer, p_message, p_arguments);
 		}
 		
 		//////////
@@ -328,8 +334,8 @@ private static EngineApi getEngineApi()
 	private static native void __ObjectRetain(long object);
 	private static native void __ObjectRelease(long object);
 	private static native boolean __ObjectExists(long object);
-	private static native void __ObjectSend(long object, String message, String signature, java.lang.Object[] arguments);
-	private static native void __ObjectPost(long object, String message, String signature, java.lang.Object[] arguments);
+	private static native void __ObjectSend(long object, String message, java.lang.Object[] arguments);
+	private static native void __ObjectPost(long object, String message, java.lang.Object[] arguments);
 	/*private static native java.lang.Object __ObjectGet(long object, int options, String property, String key);
 	private static native void __ObjectSet(long object, int options, String property, String key);*/
 	
diff --git a/lcidlc/src/Support.mm b/lcidlc/src/Support.mm
@@ -3114,7 +3114,182 @@ static jboolean java_lcapi_ObjectExists(JNIEnv *env, jlong object)
 	return t_exists;
 }
 	
-static void java_lcapi_ObjectSend(JNIEnv *env, jlong object, jobject message, jobject signature, jobject arguments)
+static LCError java_lcapi_LCCreateArguments(JNIEnv *env, jobjectArray arguments, MCVariableRef*& r_argv, uint32_t& r_argc)
+{
+    LCError t_error;
+    t_error = kLCErrorNone;
+    
+    uint32_t t_argc;
+    t_argc = env->GetArrayLength(arguments);
+    
+    MCVariableRef *t_argv;
+    
+    if (t_error == kLCErrorNone)
+    {
+        t_argv = nil;
+        t_argv = (MCVariableRef *)calloc(t_argc, sizeof(MCVariableRef));
+        if (t_argv == nil)
+            return kLCErrorOutOfMemory;
+    }
+    
+    // Get all the classes we want to support
+    
+    jclass t_class_String;
+    
+    if (t_error == kLCErrorNone)
+    {
+        t_class_String = nil;
+        t_class_String = env->FindClass("java/lang/String");
+        if (t_class_String == nil)
+            t_error = kLCErrorFailed;
+    }
+
+    jclass t_class_Boolean;
+    
+    if (t_error == kLCErrorNone)
+    {
+        t_class_Boolean = nil;
+        t_class_Boolean = env->FindClass("java/lang/Boolean");
+        if (t_class_Boolean == nil)
+            t_error = kLCErrorFailed;
+    }
+    
+    jclass t_class_Integer;
+    
+    if (t_error == kLCErrorNone)
+    {
+        t_class_Integer = nil;
+        t_class_Integer = env->FindClass("java/lang/Integer");
+        if (t_class_Integer == nil)
+            t_error = kLCErrorFailed;
+    }
+    
+    jclass t_class_Double;
+    
+    if (t_error == kLCErrorNone)
+    {
+        t_class_Double = nil;
+        t_class_Double = env->FindClass("java/lang/Double");
+        if (t_class_Double == nil)
+            t_error = kLCErrorFailed;
+    }
+    
+    jclass t_class_ByteBuffer;
+    
+    if (t_error == kLCErrorNone)
+    {
+        t_class_ByteBuffer = nil;
+        t_class_ByteBuffer = env->FindClass("java/nio/ByteBuffer");
+        if (t_class_ByteBuffer == nil)
+            t_error = kLCErrorFailed;
+    }
+    
+    // Get all the required methods so we don't need to get them multiple times
+    
+    jmethodID t_mid_Boolean_booleanValue;
+    
+    if (t_error == kLCErrorNone)
+    {
+        t_mid_Boolean_booleanValue = nil;
+        t_mid_Boolean_booleanValue = env->GetMethodID(t_class_Boolean, "booleanValue", "()Z");
+        if (t_mid_Boolean_booleanValue == nil)
+            t_error = kLCErrorFailed;
+    }
+    
+    jmethodID t_mid_Integer_integerValue;
+    
+    if (t_error == kLCErrorNone)
+    {
+        t_mid_Integer_integerValue = nil;
+        t_mid_Integer_integerValue = env->GetMethodID(t_class_Integer, "intValue", "()I");
+        if (t_mid_Integer_integerValue == nil)
+            t_error = kLCErrorFailed;
+    }
+    
+    jmethodID t_mid_Double_doubleValue;
+    
+    if (t_error == kLCErrorNone)
+    {
+        t_mid_Double_doubleValue = nil;
+        t_mid_Double_doubleValue = env->GetMethodID(t_class_Double, "doubleValue", "()D");
+        if (t_mid_Double_doubleValue == nil)
+            t_error = kLCErrorFailed;
+    }
+    
+    jmethodID t_mid_ByteBuffer_array;
+    
+    if (t_error == kLCErrorNone)
+    {
+        t_mid_ByteBuffer_array = nil;
+        t_mid_ByteBuffer_array = env->GetMethodID(t_class_ByteBuffer, "array", "()[B");
+        if (t_mid_ByteBuffer_array == nil)
+            t_error = kLCErrorFailed;
+    }
+    
+    for (uint32_t i = 0; i < t_argc; i++)
+    {
+        t_error = (LCError)MCVariableCreate(&t_argv[i]);
+		if (t_error != kLCErrorNone)
+			break;
+		
+        jobject t_param;
+        if (t_error == kLCErrorNone)
+        {
+            t_param = nil;
+            t_param = env->GetObjectArrayElement(arguments,i);
+            if (t_param == nil)
+                t_error = kLCErrorFailed;
+        }
+                
+        if (t_error == kLCErrorNone)
+        {
+            // Compare to classes we know we can use
+            if (env->IsInstanceOf(t_param, t_class_String) == JNI_TRUE)
+            {
+				char *t_cstring;
+                t_error = java_to__cstring(env, t_param, t_cstring);
+                if (t_error == kLCErrorNone)
+                {
+                    t_error = (LCError)MCVariableStore(t_argv[i], kMCOptionAsCString, &t_cstring);
+                    free(t_cstring);
+                }
+            }
+            if (env->IsInstanceOf(t_param, t_class_Boolean) == JNI_TRUE)
+            {
+                bool t_boolean = (bool) env -> CallBooleanMethod(t_param,t_mid_Boolean_booleanValue);
+                t_error = (LCError)MCVariableStore(t_argv[i], kMCOptionAsBoolean, &t_boolean);
+            }
+            if (env->IsInstanceOf(t_param, t_class_Integer) == JNI_TRUE)
+            {
+                int t_integer = (int) env -> CallIntMethod(t_param,t_mid_Integer_integerValue);
+                t_error = (LCError)MCVariableStore(t_argv[i], kMCOptionAsInteger, &t_integer);
+            }
+            if (env->IsInstanceOf(t_param, t_class_Double) == JNI_TRUE)
+            {
+                double t_double = (double) env -> CallDoubleMethod(t_param,t_mid_Double_doubleValue);
+                t_error = (LCError)MCVariableStore(t_argv[i], kMCOptionAsReal, &t_double);
+            }
+            if (env->IsInstanceOf(t_param, t_class_ByteBuffer) == JNI_TRUE)
+            {
+                //jobject t_byte_array = env -> CallObjectMethod(t_param,t_mid_ByteBuffer_array);
+                //LCBytes t_bytes = java_to__cdata(env, t_byte_array);
+                //t_error = (LCError)MCVariableStore(t_argv[i], kMCOptionAsString, &t_bytes);
+            }
+		}
+	}
+    
+    if (t_error == kLCErrorNone)
+    {
+        r_argv = t_argv;
+        r_argc = t_argc;
+    }
+    else
+        LCArgumentsDestroy(t_argv, t_argc);
+
+    return t_error;
+}
+
+static void java_lcapi_ObjectSend(JNIEnv *env, jlong object, jobject message, jobjectArray arguments)
 {
 	LCError t_error;
 	t_error = kLCErrorNone;
@@ -3123,37 +3298,130 @@ static void java_lcapi_ObjectSend(JNIEnv *env, jlong object, jobject message, jo
 	t_message_cstring = nil;
 	if (t_error == kLCErrorNone)
 		t_error = java_to__cstring(env, message, t_message_cstring);
-	
-	// TODO handle signature / arguments
+
+	MCVariableRef *t_argv;
+	uint32_t t_argc;
+	t_argv = nil;
+	t_argc = 0;
+	if (t_error == kLCErrorNone)
+		t_error = java_lcapi_LCCreateArguments(env, arguments, t_argv, t_argc);
 	
 	if (t_error == kLCErrorNone)
-		t_error = LCObjectSend((LCObjectRef)object, t_message_cstring, "");
+	{
+		MCDispatchStatus t_status;
+		t_error = (LCError)s_interface -> object_dispatch((MCObjectRef)object, kMCDispatchTypeCommand, t_message_cstring, t_argv, t_argc, &t_status);
+		if (t_error == kLCErrorNone)
+		{
+			switch(t_status)
+			{
+				case kMCDispatchStatusError:
+					t_error = kLCErrorFailed;
+					break;
+				case kMCDispatchStatusExit:
+					t_error = kLCErrorExited;
+					break;
+				case kMCDispatchStatusAbort:
+					t_error = kLCErrorAborted;
+					break;
+				default:
+					break;
+			}
+		}
+	}
 	
+	LCArgumentsDestroy(t_argv, t_argc);
+
 	free(t_message_cstring);
 	
 	if (t_error != kLCErrorNone)
 	{
 		java_lcapi__throw(env, t_error);
 		return;
-	}	
+	}
 }
 
-static void java_lcapi_ObjectPost(JNIEnv *env, jlong object, jobject message, jobject signature, jobject arguments)
+struct java_lcapi_LCObjectPost_context
 {
-	LCError t_error;
-	t_error = kLCErrorNone;
+    MCObjectRef object;
+    char *message;
+    MCVariableRef *argv;
+	uint32_t argc;
+    LCError result;
+};
+
+static void java_lcapi_ObjectPost_perform(void *p_context)
+{
+    java_lcapi_LCObjectPost_context *context;
+	context = (java_lcapi_LCObjectPost_context *)p_context;
+    
+    LCError t_error;
+    t_error = kLCErrorNone;
 	
+	struct LCObjectPostV_event *t_event;
+	t_event = nil;
+	if (t_error == kLCErrorNone)
+	{
+		t_event = (LCObjectPostV_event *)calloc(1, sizeof(LCObjectPostV_event));
+		if (t_event == nil)
+			t_error = kLCErrorOutOfMemory;
+	}
+	
+	if (t_error == kLCErrorNone)
+		t_error = (LCError)s_interface -> object_retain(context -> object);
+	
+	if (t_error == kLCErrorNone)
+	{
+		t_event -> object = context -> object;
+		t_event -> message = context -> message;
+		t_event -> argv = context -> argv;
+		t_event -> argc = context -> argc;
+		t_error = (LCError)s_interface -> engine_run_on_main_thread((void *)LCObjectPostV_dispatch, t_event, kMCRunOnMainThreadPost | kMCRunOnMainThreadRequired | kMCRunOnMainThreadSafe | kMCRunOnMainThreadDeferred);
+	}
+    
+	if (t_error != kLCErrorNone)
+	{
+		if (t_event -> object != nil)
+			s_interface -> object_release(t_event -> object);
+		free(t_event -> message);
+		LCArgumentsDestroy(context -> argv, context -> argc);
+		free(t_event);
+	}
+
+    context -> result = (LCError)t_error;
+}
+
+static void java_lcapi_ObjectPost(JNIEnv *env, jlong object, jobject message, jobjectArray arguments)
+{
+	LCError t_error;
+    t_error = kLCErrorNone;
+    
+	// The cstring will be given to the perform method.
 	char *t_message_cstring;
 	t_message_cstring = nil;
 	if (t_error == kLCErrorNone)
 		t_error = java_to__cstring(env, message, t_message_cstring);
-	
-	// TODO handle signature / arguments
-	
+
+	// Create the arguments array here to make sure we don't get JNI thread problems.
+	// (this could be called from any thread, and we want to avoid having to make 
+	//  globalref's to the arguments array). The arguments array will be freed
+	// by the perform method (to stop threading problems engine-side).
+	MCVariableRef *t_argv;
+	uint32_t t_argc;
+	t_argv = nil;
+	t_argc = 0;
 	if (t_error == kLCErrorNone)
-		t_error = LCObjectPost((LCObjectRef)object, t_message_cstring, "");
+        t_error = java_lcapi_LCCreateArguments(env, arguments, t_argv, t_argc);
 	
-	free(t_message_cstring);
+    struct java_lcapi_LCObjectPost_context t_context;
+    t_context . object = (MCObjectRef)object;
+	t_context . message = t_message_cstring;
+	t_context . argv = t_argv;
+	t_context . argc = t_argc;
+	if (t_error == kLCErrorNone)
+		t_error = (LCError)s_interface -> engine_run_on_main_thread((void *)java_lcapi_ObjectPost_perform, &t_context, kMCRunOnMainThreadSend | kMCRunOnMainThreadOptional | kMCRunOnMainThreadUnsafe | kMCRunOnMainThreadImmediate);
+    
+    if (t_error == kLCErrorNone)
+        t_error = t_context . result;
 	
 	if (t_error != kLCErrorNone)
 	{
diff --git a/revtestexternal/revtestexternal.lcidl b/revtestexternal/revtestexternal.lcidl
@@ -54,4 +54,6 @@ tail command revTestExternalAndroidButtonDestroy
 
 function revTestExternalRunActivity return c-string
 
-command revTestExternalRunOnSystemThread
+command revTestExternalRunOnSystemThread
+
+command revTestExternalObjectPostAndSend
diff --git a/revtestexternal/revtestexternal.livecode b/revtestexternal/revtestexternal.livecode
diff --git a/revtestexternal/src/revtestexternal.java b/revtestexternal/src/revtestexternal.java
