From 78883a52c64adbab56aaa363138a9f661a67d48e Mon Sep 17 00:00:00 2001 From: David Snopek Date: Tue, 20 Aug 2024 16:53:57 -0500 Subject: [PATCH] Fix `JavaClassWrapper` so it actually works --- doc/classes/JavaClass.xml | 26 +- doc/classes/JavaClassWrapper.xml | 9 + doc/classes/JavaObject.xml | 21 ++ platform/android/api/api.cpp | 30 +++ platform/android/api/java_class_wrapper.h | 49 +++- platform/android/api/jni_singleton.h | 5 + platform/android/java_class_wrapper.cpp | 293 ++++++++++++++++++---- platform/android/jni_utils.cpp | 22 +- platform/android/jni_utils.h | 2 +- 9 files changed, 397 insertions(+), 60 deletions(-) create mode 100644 doc/classes/JavaObject.xml diff --git a/doc/classes/JavaClass.xml b/doc/classes/JavaClass.xml index ecfcaa87815..9a6c30df10e 100644 --- a/doc/classes/JavaClass.xml +++ b/doc/classes/JavaClass.xml @@ -1,13 +1,33 @@ - Represents an object from the Java Native Interface. + Represents a class from the Java Native Interface. - Represents an object from the Java Native Interface. It is returned from [method JavaClassWrapper.wrap]. - [b]Note:[/b] This class only works on Android. For any other build, this class does nothing. + Represents a class from the Java Native Interface. It is returned from [method JavaClassWrapper.wrap]. + [b]Note:[/b] This class only works on Android. On any other platform, this class does nothing. [b]Note:[/b] This class is not to be confused with [JavaScriptObject]. + + + + + Returns the Java class name. + + + + + + Returns the object's Java methods and their signatures as an [Array] of dictionaries, in the same format as [method Object.get_method_list]. + + + + + + Returns a [JavaClass] representing the Java parent class of this class. + + + diff --git a/doc/classes/JavaClassWrapper.xml b/doc/classes/JavaClassWrapper.xml index 01c3392b049..b43e149e9fe 100644 --- a/doc/classes/JavaClassWrapper.xml +++ b/doc/classes/JavaClassWrapper.xml @@ -6,6 +6,15 @@ The JavaClassWrapper singleton provides a way for the Godot application to send and receive data through the [url=https://developer.android.com/training/articles/perf-jni]Java Native Interface[/url] (JNI). [b]Note:[/b] This singleton is only available in Android builds. + [codeblock] + var LocalDateTime = JavaClassWrapper.wrap("java.time.LocalDateTime") + var DateTimeFormatter = JavaClassWrapper.wrap("java.time.format.DateTimeFormatter") + + var datetime = LocalDateTime.now() + var formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss") + + print(datetime.format(formatter)) + [/codeblock] diff --git a/doc/classes/JavaObject.xml b/doc/classes/JavaObject.xml new file mode 100644 index 00000000000..f38070e7d9d --- /dev/null +++ b/doc/classes/JavaObject.xml @@ -0,0 +1,21 @@ + + + + Represents an object from the Java Native Interface. + + + Represents an object from the Java Native Interface. It can be returned from Java methods called on [JavaClass] or other [JavaObject]s. See [JavaClassWrapper] for an example. + [b]Note:[/b] This class only works on Android. On any other platform, this class does nothing. + [b]Note:[/b] This class is not to be confused with [JavaScriptObject]. + + + + + + + + Returns the [JavaClass] that this object is an instance of. + + + + diff --git a/platform/android/api/api.cpp b/platform/android/api/api.cpp index 60c369951c9..6920f801e52 100644 --- a/platform/android/api/api.cpp +++ b/platform/android/api/api.cpp @@ -49,6 +49,7 @@ void register_android_api() { #endif GDREGISTER_CLASS(JavaClass); + GDREGISTER_CLASS(JavaObject); GDREGISTER_CLASS(JavaClassWrapper); Engine::get_singleton()->add_singleton(Engine::Singleton("JavaClassWrapper", JavaClassWrapper::get_singleton())); } @@ -59,6 +60,16 @@ void unregister_android_api() { #endif } +void JavaClass::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_java_class_name"), &JavaClass::get_java_class_name); + ClassDB::bind_method(D_METHOD("get_java_method_list"), &JavaClass::get_java_method_list); + ClassDB::bind_method(D_METHOD("get_java_parent_class"), &JavaClass::get_java_parent_class); +} + +void JavaObject::_bind_methods() { + ClassDB::bind_method(D_METHOD("get_java_class"), &JavaObject::get_java_class); +} + void JavaClassWrapper::_bind_methods() { ClassDB::bind_method(D_METHOD("wrap", "name"), &JavaClassWrapper::wrap); } @@ -69,13 +80,32 @@ Variant JavaClass::callp(const StringName &, const Variant **, int, Callable::Ca return Variant(); } +String JavaClass::get_java_class_name() const { + return ""; +} + +TypedArray JavaClass::get_java_method_list() const { + return TypedArray(); +} + +Ref JavaClass::get_java_parent_class() const { + return Ref(); +} + JavaClass::JavaClass() { } +JavaClass::~JavaClass() { +} + Variant JavaObject::callp(const StringName &, const Variant **, int, Callable::CallError &) { return Variant(); } +Ref JavaObject::get_java_class() const { + return Ref(); +} + JavaClassWrapper *JavaClassWrapper::singleton = nullptr; Ref JavaClassWrapper::wrap(const String &) { diff --git a/platform/android/api/java_class_wrapper.h b/platform/android/api/java_class_wrapper.h index e21a331ab9d..52df1644be8 100644 --- a/platform/android/api/java_class_wrapper.h +++ b/platform/android/api/java_class_wrapper.h @@ -32,6 +32,7 @@ #define JAVA_CLASS_WRAPPER_H #include "core/object/ref_counted.h" +#include "core/variant/typed_array.h" #ifdef ANDROID_ENABLED #include @@ -67,6 +68,7 @@ class JavaClass : public RefCounted { struct MethodInfo { bool _static = false; + bool _constructor = false; Vector param_types; Vector param_sigs; uint32_t return_type = 0; @@ -174,14 +176,29 @@ class JavaClass : public RefCounted { bool _call_method(JavaObject *p_instance, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error, Variant &ret); friend class JavaClassWrapper; + friend class JavaObject; + String java_class_name; + String java_constructor_name; HashMap> methods; jclass _class; #endif +protected: + static void _bind_methods(); + public: virtual Variant callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override; + String get_java_class_name() const; + TypedArray get_java_method_list() const; + Ref get_java_parent_class() const; + +#ifdef ANDROID_ENABLED + virtual String to_string() override; +#endif + JavaClass(); + ~JavaClass(); }; class JavaObject : public RefCounted { @@ -191,14 +208,24 @@ class JavaObject : public RefCounted { Ref base_class; friend class JavaClass; - jobject instance; + jobject instance = nullptr; #endif +protected: + static void _bind_methods(); + public: virtual Variant callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override; + Ref get_java_class() const; + #ifdef ANDROID_ENABLED - JavaObject(const Ref &p_base, jobject *p_instance); + virtual String to_string() override; + + jobject get_instance() { return instance; } + + JavaObject(); + JavaObject(const Ref &p_base, jobject p_instance); ~JavaObject(); #endif }; @@ -209,13 +236,17 @@ class JavaClassWrapper : public Object { #ifdef ANDROID_ENABLED RBMap> class_cache; friend class JavaClass; - jmethodID getDeclaredMethods; - jmethodID getFields; - jmethodID getParameterTypes; - jmethodID getReturnType; - jmethodID getModifiers; - jmethodID getName; + jmethodID Class_getDeclaredConstructors; + jmethodID Class_getDeclaredMethods; + jmethodID Class_getFields; jmethodID Class_getName; + jmethodID Class_getSuperclass; + jmethodID Constructor_getParameterTypes; + jmethodID Constructor_getModifiers; + jmethodID Method_getParameterTypes; + jmethodID Method_getReturnType; + jmethodID Method_getModifiers; + jmethodID Method_getName; jmethodID Field_getName; jmethodID Field_getModifiers; jmethodID Field_get; @@ -242,6 +273,8 @@ public: Ref wrap(const String &p_class); #ifdef ANDROID_ENABLED + Ref wrap_jclass(jclass p_class); + JavaClassWrapper(jobject p_activity = nullptr); #else JavaClassWrapper(); diff --git a/platform/android/api/jni_singleton.h b/platform/android/api/jni_singleton.h index 087fd1bacec..06afc4eb782 100644 --- a/platform/android/api/jni_singleton.h +++ b/platform/android/api/jni_singleton.h @@ -180,6 +180,11 @@ public: env->DeleteLocalRef(obj); } break; + case Variant::OBJECT: { + jobject obj = env->CallObjectMethodA(instance, E->get().method, v); + ret = _jobject_to_variant(env, obj); + env->DeleteLocalRef(obj); + } break; default: { env->PopLocalFrame(nullptr); ERR_FAIL_V(Variant()); diff --git a/platform/android/java_class_wrapper.cpp b/platform/android/java_class_wrapper.cpp index a309a6ab740..f8553ca3978 100644 --- a/platform/android/java_class_wrapper.cpp +++ b/platform/android/java_class_wrapper.cpp @@ -44,7 +44,7 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method, MethodInfo *method = nullptr; for (MethodInfo &E : M->value) { - if (!p_instance && !E._static) { + if (!p_instance && !E._static && !E._constructor) { r_error.error = Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL; continue; } @@ -102,15 +102,19 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method, } } break; case ARG_TYPE_CLASS: { - if (p_args[i]->get_type() != Variant::OBJECT) { + if (p_args[i]->get_type() != Variant::OBJECT && p_args[i]->get_type() != Variant::NIL) { arg_expected = Variant::OBJECT; } else { Ref ref = *p_args[i]; - if (!ref.is_null()) { + if (ref.is_valid()) { if (Object::cast_to(ref.ptr())) { Ref jo = ref; //could be faster - jclass c = env->FindClass(E.param_sigs[i].operator String().utf8().get_data()); + String cn = E.param_sigs[i].operator String(); + if (cn.begins_with("L") && cn.ends_with(";")) { + cn = cn.substr(1, cn.length() - 2); + } + jclass c = env->FindClass(cn.utf8().get_data()); if (!c || !env->IsInstanceOf(jo->instance, c)) { arg_expected = Variant::OBJECT; } else { @@ -458,7 +462,9 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method, } break; default: { jobject obj; - if (method->_static) { + if (method->_constructor) { + obj = env->NewObject(_class, method->method, argv); + } else if (method->_static) { obj = env->CallStaticObjectMethodA(_class, method->method, argv); } else { obj = env->CallObjectMethodA(p_instance->instance, method->method, argv); @@ -487,7 +493,9 @@ bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method, Variant JavaClass::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) { Variant ret; - bool found = _call_method(nullptr, p_method, p_args, p_argcount, r_error, ret); + + String method = (p_method == java_constructor_name) ? "" : p_method; + bool found = _call_method(nullptr, method, p_args, p_argcount, r_error, ret); if (found) { return ret; } @@ -495,19 +503,156 @@ Variant JavaClass::callp(const StringName &p_method, const Variant **p_args, int return RefCounted::callp(p_method, p_args, p_argcount, r_error); } +String JavaClass::get_java_class_name() const { + return java_class_name; +} + +TypedArray JavaClass::get_java_method_list() const { + TypedArray method_list; + + for (const KeyValue> &item : methods) { + for (const MethodInfo &mi : item.value) { + Dictionary method; + + method["name"] = mi._constructor ? java_constructor_name : String(item.key); + method["id"] = (uint64_t)mi.method; + method["default_args"] = Array(); + method["flags"] = METHOD_FLAGS_DEFAULT & (mi._static || mi._constructor ? METHOD_FLAG_STATIC : METHOD_FLAG_NORMAL); + + { + Array a; + + for (uint32_t argtype : mi.param_types) { + Dictionary d; + + Variant::Type t = Variant::NIL; + float likelihood = 0.0; + _convert_to_variant_type(argtype, t, likelihood); + d["type"] = t; + if (t == Variant::OBJECT) { + d["hint"] = PROPERTY_HINT_RESOURCE_TYPE; + d["hint_string"] = "JavaObject"; + } else { + d["hint"] = 0; + d["hint_string"] = ""; + } + + a.push_back(d); + } + + method["args"] = a; + } + + { + Dictionary d; + + if (mi._constructor) { + d["type"] = Variant::OBJECT; + d["hint"] = PROPERTY_HINT_RESOURCE_TYPE; + d["hint_string"] = "JavaObject"; + } else { + Variant::Type t = Variant::NIL; + float likelihood = 0.0; + _convert_to_variant_type(mi.return_type, t, likelihood); + d["type"] = t; + if (t == Variant::OBJECT) { + d["hint"] = PROPERTY_HINT_RESOURCE_TYPE; + d["hint_string"] = "JavaObject"; + } else { + d["hint"] = 0; + d["hint_string"] = ""; + } + } + + method["return_type"] = d; + } + + method_list.push_back(method); + } + } + + return method_list; +} + +Ref JavaClass::get_java_parent_class() const { + ERR_FAIL_NULL_V(_class, Ref()); + + JNIEnv *env = get_jni_env(); + ERR_FAIL_NULL_V(env, Ref()); + + jclass superclass = (jclass)env->CallObjectMethod(_class, JavaClassWrapper::singleton->Class_getSuperclass); + if (!superclass) { + return Ref(); + } + + Ref ret = JavaClassWrapper::singleton->wrap_jclass(superclass); + env->DeleteLocalRef(superclass); + return ret; +} + +String JavaClass::to_string() { + return ""; +} + JavaClass::JavaClass() { } +JavaClass::~JavaClass() { + if (_class) { + JNIEnv *env = get_jni_env(); + ERR_FAIL_NULL(env); + + env->DeleteGlobalRef(_class); + } +} + ///////////////////// Variant JavaObject::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) { - return Variant(); + if (instance) { + Ref c = base_class; + while (c.is_valid()) { + Variant ret; + bool found = c->_call_method(this, p_method, p_args, p_argcount, r_error, ret); + if (found) { + return ret; + } + c = c->get_java_parent_class(); + } + } + + return RefCounted::callp(p_method, p_args, p_argcount, r_error); } -JavaObject::JavaObject(const Ref &p_base, jobject *p_instance) { +Ref JavaObject::get_java_class() const { + return base_class; +} + +String JavaObject::to_string() { + if (base_class.is_valid() && instance) { + return "java_class_name + " \"" + (String)call("toString") + "\">"; + } + return RefCounted::to_string(); +} + +JavaObject::JavaObject() { +} + +JavaObject::JavaObject(const Ref &p_base, jobject p_instance) { + JNIEnv *env = get_jni_env(); + ERR_FAIL_NULL(env); + + base_class = p_base; + instance = env->NewGlobalRef(p_instance); } JavaObject::~JavaObject() { + if (instance) { + JNIEnv *env = get_jni_env(); + ERR_FAIL_NULL(env); + + env->DeleteGlobalRef(instance); + } } //////////////////// @@ -649,6 +794,16 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va return true; } break; case ARG_TYPE_CLASS: { + jclass java_class = env->GetObjectClass(obj); + Ref java_class_wrapped = JavaClassWrapper::singleton->wrap_jclass(java_class); + env->DeleteLocalRef(java_class); + + if (java_class_wrapped.is_valid()) { + Ref ret = Ref(memnew(JavaObject(java_class_wrapped, obj))); + var = ret; + return true; + } + return false; } break; case ARG_ARRAY_BIT | ARG_TYPE_VOID: { @@ -966,43 +1121,67 @@ bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &va } Ref JavaClassWrapper::wrap(const String &p_class) { - if (class_cache.has(p_class)) { - return class_cache[p_class]; + String class_name_dots = p_class.replace("/", "."); + if (class_cache.has(class_name_dots)) { + return class_cache[class_name_dots]; } JNIEnv *env = get_jni_env(); ERR_FAIL_NULL_V(env, Ref()); - jclass bclass = env->FindClass(p_class.utf8().get_data()); + jclass bclass = env->FindClass(class_name_dots.replace(".", "/").utf8().get_data()); ERR_FAIL_NULL_V(bclass, Ref()); - jobjectArray methods = (jobjectArray)env->CallObjectMethod(bclass, getDeclaredMethods); + jobjectArray constructors = (jobjectArray)env->CallObjectMethod(bclass, Class_getDeclaredConstructors); + ERR_FAIL_NULL_V(constructors, Ref()); + jobjectArray methods = (jobjectArray)env->CallObjectMethod(bclass, Class_getDeclaredMethods); ERR_FAIL_NULL_V(methods, Ref()); Ref java_class = memnew(JavaClass); + java_class->java_class_name = class_name_dots; + Vector class_name_parts = class_name_dots.split("."); + java_class->java_constructor_name = class_name_parts[class_name_parts.size() - 1]; + java_class->_class = (jclass)env->NewGlobalRef(bclass); + class_cache[class_name_dots] = java_class; - int count = env->GetArrayLength(methods); + LocalVector methods_and_constructors; + int constructor_count = env->GetArrayLength(constructors); + int method_count = env->GetArrayLength(methods); + methods_and_constructors.resize(method_count + constructor_count); + for (int i = 0; i < constructor_count; i++) { + methods_and_constructors[i] = env->GetObjectArrayElement(constructors, i); + } + for (int i = 0; i < method_count; i++) { + methods_and_constructors[constructor_count + i] = env->GetObjectArrayElement(methods, i); + } - for (int i = 0; i < count; i++) { - jobject obj = env->GetObjectArrayElement(methods, i); + for (int i = 0; i < (int)methods_and_constructors.size(); i++) { + jobject obj = methods_and_constructors[i]; ERR_CONTINUE(!obj); - jstring name = (jstring)env->CallObjectMethod(obj, getName); - String str_method = jstring_to_string(name, env); - env->DeleteLocalRef(name); + bool is_constructor = i < constructor_count; + + String str_method; + if (is_constructor) { + str_method = ""; + } else { + jstring name = (jstring)env->CallObjectMethod(obj, Method_getName); + str_method = jstring_to_string(name, env); + env->DeleteLocalRef(name); + } Vector params; - jint mods = env->CallIntMethod(obj, getModifiers); + jint mods = env->CallIntMethod(obj, is_constructor ? Constructor_getModifiers : Method_getModifiers); if (!(mods & 0x0001)) { env->DeleteLocalRef(obj); continue; //not public bye } - jobjectArray param_types = (jobjectArray)env->CallObjectMethod(obj, getParameterTypes); - int count2 = env->GetArrayLength(param_types); + jobjectArray param_types = (jobjectArray)env->CallObjectMethod(obj, is_constructor ? Constructor_getParameterTypes : Method_getParameterTypes); + int count = env->GetArrayLength(param_types); if (!java_class->methods.has(str_method)) { java_class->methods[str_method] = List(); @@ -1010,10 +1189,11 @@ Ref JavaClassWrapper::wrap(const String &p_class) { JavaClass::MethodInfo mi; mi._static = (mods & 0x8) != 0; + mi._constructor = is_constructor; bool valid = true; String signature = "("; - for (int j = 0; j < count2; j++) { + for (int j = 0; j < count; j++) { jobject obj2 = env->GetObjectArrayElement(param_types, j); String strsig; uint32_t sig = 0; @@ -1029,7 +1209,7 @@ Ref JavaClassWrapper::wrap(const String &p_class) { } if (!valid) { - print_line("Method can't be bound (unsupported arguments): " + p_class + "::" + str_method); + print_line("Method can't be bound (unsupported arguments): " + class_name_dots + "::" + str_method); env->DeleteLocalRef(obj); env->DeleteLocalRef(param_types); continue; @@ -1037,21 +1217,28 @@ Ref JavaClassWrapper::wrap(const String &p_class) { signature += ")"; - jobject return_type = (jobject)env->CallObjectMethod(obj, getReturnType); + if (is_constructor) { + signature += "V"; + mi.return_type = JavaClass::ARG_TYPE_CLASS; + } else { + jobject return_type = (jobject)env->CallObjectMethod(obj, Method_getReturnType); + + String strsig; + uint32_t sig = 0; + if (!_get_type_sig(env, return_type, sig, strsig)) { + print_line("Method can't be bound (unsupported return type): " + class_name_dots + "::" + str_method); + env->DeleteLocalRef(obj); + env->DeleteLocalRef(param_types); + env->DeleteLocalRef(return_type); + continue; + } + + signature += strsig; + mi.return_type = sig; - String strsig; - uint32_t sig = 0; - if (!_get_type_sig(env, return_type, sig, strsig)) { - print_line("Method can't be bound (unsupported return type): " + p_class + "::" + str_method); - env->DeleteLocalRef(obj); - env->DeleteLocalRef(param_types); env->DeleteLocalRef(return_type); - continue; } - signature += strsig; - mi.return_type = sig; - bool discard = false; for (List::Element *E = java_class->methods[str_method].front(); E; E = E->next()) { @@ -1103,14 +1290,14 @@ Ref JavaClassWrapper::wrap(const String &p_class) { env->DeleteLocalRef(obj); env->DeleteLocalRef(param_types); - env->DeleteLocalRef(return_type); } + env->DeleteLocalRef(constructors); env->DeleteLocalRef(methods); - jobjectArray fields = (jobjectArray)env->CallObjectMethod(bclass, getFields); + jobjectArray fields = (jobjectArray)env->CallObjectMethod(bclass, Class_getFields); - count = env->GetArrayLength(fields); + int count = env->GetArrayLength(fields); for (int i = 0; i < count; i++) { jobject obj = env->GetObjectArrayElement(fields, i); @@ -1146,7 +1333,18 @@ Ref JavaClassWrapper::wrap(const String &p_class) { env->DeleteLocalRef(fields); - return Ref(); + return java_class; +} + +Ref JavaClassWrapper::wrap_jclass(jclass p_class) { + JNIEnv *env = get_jni_env(); + ERR_FAIL_NULL_V(env, Ref()); + + jstring class_name = (jstring)env->CallObjectMethod(p_class, Class_getName); + String class_name_string = jstring_to_string(class_name, env); + env->DeleteLocalRef(class_name); + + return wrap(class_name_string); } JavaClassWrapper *JavaClassWrapper::singleton = nullptr; @@ -1158,16 +1356,23 @@ JavaClassWrapper::JavaClassWrapper(jobject p_activity) { ERR_FAIL_NULL(env); jclass bclass = env->FindClass("java/lang/Class"); - getDeclaredMethods = env->GetMethodID(bclass, "getDeclaredMethods", "()[Ljava/lang/reflect/Method;"); - getFields = env->GetMethodID(bclass, "getFields", "()[Ljava/lang/reflect/Field;"); + Class_getDeclaredConstructors = env->GetMethodID(bclass, "getDeclaredConstructors", "()[Ljava/lang/reflect/Constructor;"); + Class_getDeclaredMethods = env->GetMethodID(bclass, "getDeclaredMethods", "()[Ljava/lang/reflect/Method;"); + Class_getFields = env->GetMethodID(bclass, "getFields", "()[Ljava/lang/reflect/Field;"); Class_getName = env->GetMethodID(bclass, "getName", "()Ljava/lang/String;"); + Class_getSuperclass = env->GetMethodID(bclass, "getSuperclass", "()Ljava/lang/Class;"); + env->DeleteLocalRef(bclass); + + bclass = env->FindClass("java/lang/reflect/Constructor"); + Constructor_getParameterTypes = env->GetMethodID(bclass, "getParameterTypes", "()[Ljava/lang/Class;"); + Constructor_getModifiers = env->GetMethodID(bclass, "getModifiers", "()I"); env->DeleteLocalRef(bclass); bclass = env->FindClass("java/lang/reflect/Method"); - getParameterTypes = env->GetMethodID(bclass, "getParameterTypes", "()[Ljava/lang/Class;"); - getReturnType = env->GetMethodID(bclass, "getReturnType", "()Ljava/lang/Class;"); - getName = env->GetMethodID(bclass, "getName", "()Ljava/lang/String;"); - getModifiers = env->GetMethodID(bclass, "getModifiers", "()I"); + Method_getParameterTypes = env->GetMethodID(bclass, "getParameterTypes", "()[Ljava/lang/Class;"); + Method_getReturnType = env->GetMethodID(bclass, "getReturnType", "()Ljava/lang/Class;"); + Method_getName = env->GetMethodID(bclass, "getName", "()Ljava/lang/String;"); + Method_getModifiers = env->GetMethodID(bclass, "getModifiers", "()I"); env->DeleteLocalRef(bclass); bclass = env->FindClass("java/lang/reflect/Field"); diff --git a/platform/android/jni_utils.cpp b/platform/android/jni_utils.cpp index fc97d6eca44..4c17d03c602 100644 --- a/platform/android/jni_utils.cpp +++ b/platform/android/jni_utils.cpp @@ -30,6 +30,8 @@ #include "jni_utils.h" +#include "api/java_class_wrapper.h" + jvalret _variant_to_jvalue(JNIEnv *env, Variant::Type p_type, const Variant *p_arg, bool force_jobject) { jvalret v; @@ -185,6 +187,16 @@ jvalret _variant_to_jvalue(JNIEnv *env, Variant::Type p_type, const Variant *p_a v.obj = arr; } break; + case Variant::OBJECT: { + Ref generic_object = *p_arg; + if (generic_object.is_valid()) { + jobject obj = env->NewLocalRef(generic_object->get_instance()); + v.val.l = obj; + v.obj = obj; + } else { + v.val.i = 0; + } + } break; default: { v.val.i = 0; @@ -358,9 +370,11 @@ Variant _jobject_to_variant(JNIEnv *env, jobject obj) { return ret; } + Ref generic_object(memnew(JavaObject(JavaClassWrapper::get_singleton()->wrap(name), obj))); + env->DeleteLocalRef(c); - return Variant(); + return generic_object; } Variant::Type get_jni_type(const String &p_type) { @@ -395,10 +409,10 @@ Variant::Type get_jni_type(const String &p_type) { idx++; } - return Variant::NIL; + return Variant::OBJECT; } -const char *get_jni_sig(const String &p_type) { +String get_jni_sig(const String &p_type) { static struct { const char *name; const char *sig; @@ -430,5 +444,5 @@ const char *get_jni_sig(const String &p_type) { idx++; } - return "Ljava/lang/Object;"; + return "L" + p_type.replace(".", "/") + ";"; } diff --git a/platform/android/jni_utils.h b/platform/android/jni_utils.h index c608f9ebaa2..631acd1cef5 100644 --- a/platform/android/jni_utils.h +++ b/platform/android/jni_utils.h @@ -52,6 +52,6 @@ Variant _jobject_to_variant(JNIEnv *env, jobject obj); Variant::Type get_jni_type(const String &p_type); -const char *get_jni_sig(const String &p_type); +String get_jni_sig(const String &p_type); #endif // JNI_UTILS_H