mirror of
https://github.com/godotengine/godot.git
synced 2025-10-19 16:03:29 +00:00
Fix JavaClassWrapper so it actually works
This commit is contained in:
David Snopek
parent
a5830f6eb9
commit
78883a52c6
9 changed files with 397 additions and 60 deletions
|
|
@ -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<RefCounted> ref = *p_args[i];
|
||||
if (!ref.is_null()) {
|
||||
if (ref.is_valid()) {
|
||||
if (Object::cast_to<JavaObject>(ref.ptr())) {
|
||||
Ref<JavaObject> 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) ? "<init>" : 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<Dictionary> JavaClass::get_java_method_list() const {
|
||||
TypedArray<Dictionary> method_list;
|
||||
|
||||
for (const KeyValue<StringName, List<MethodInfo>> &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> JavaClass::get_java_parent_class() const {
|
||||
ERR_FAIL_NULL_V(_class, Ref<JavaClass>());
|
||||
|
||||
JNIEnv *env = get_jni_env();
|
||||
ERR_FAIL_NULL_V(env, Ref<JavaClass>());
|
||||
|
||||
jclass superclass = (jclass)env->CallObjectMethod(_class, JavaClassWrapper::singleton->Class_getSuperclass);
|
||||
if (!superclass) {
|
||||
return Ref<JavaClass>();
|
||||
}
|
||||
|
||||
Ref<JavaClass> ret = JavaClassWrapper::singleton->wrap_jclass(superclass);
|
||||
env->DeleteLocalRef(superclass);
|
||||
return ret;
|
||||
}
|
||||
|
||||
String JavaClass::to_string() {
|
||||
return "<JavaClass:" + java_class_name + ">";
|
||||
}
|
||||
|
||||
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<JavaClass> 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<JavaClass> &p_base, jobject *p_instance) {
|
||||
Ref<JavaClass> JavaObject::get_java_class() const {
|
||||
return base_class;
|
||||
}
|
||||
|
||||
String JavaObject::to_string() {
|
||||
if (base_class.is_valid() && instance) {
|
||||
return "<JavaObject:" + base_class->java_class_name + " \"" + (String)call("toString") + "\">";
|
||||
}
|
||||
return RefCounted::to_string();
|
||||
}
|
||||
|
||||
JavaObject::JavaObject() {
|
||||
}
|
||||
|
||||
JavaObject::JavaObject(const Ref<JavaClass> &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<JavaClass> java_class_wrapped = JavaClassWrapper::singleton->wrap_jclass(java_class);
|
||||
env->DeleteLocalRef(java_class);
|
||||
|
||||
if (java_class_wrapped.is_valid()) {
|
||||
Ref<JavaObject> ret = Ref<JavaObject>(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<JavaClass> 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<JavaClass>());
|
||||
|
||||
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<JavaClass>());
|
||||
|
||||
jobjectArray methods = (jobjectArray)env->CallObjectMethod(bclass, getDeclaredMethods);
|
||||
jobjectArray constructors = (jobjectArray)env->CallObjectMethod(bclass, Class_getDeclaredConstructors);
|
||||
ERR_FAIL_NULL_V(constructors, Ref<JavaClass>());
|
||||
|
||||
jobjectArray methods = (jobjectArray)env->CallObjectMethod(bclass, Class_getDeclaredMethods);
|
||||
ERR_FAIL_NULL_V(methods, Ref<JavaClass>());
|
||||
|
||||
Ref<JavaClass> java_class = memnew(JavaClass);
|
||||
java_class->java_class_name = class_name_dots;
|
||||
Vector<String> 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<jobject> 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 = "<init>";
|
||||
} else {
|
||||
jstring name = (jstring)env->CallObjectMethod(obj, Method_getName);
|
||||
str_method = jstring_to_string(name, env);
|
||||
env->DeleteLocalRef(name);
|
||||
}
|
||||
|
||||
Vector<String> 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<JavaClass::MethodInfo>();
|
||||
|
|
@ -1010,10 +1189,11 @@ Ref<JavaClass> 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<JavaClass> 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<JavaClass> 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<JavaClass::MethodInfo>::Element *E = java_class->methods[str_method].front(); E; E = E->next()) {
|
||||
|
|
@ -1103,14 +1290,14 @@ Ref<JavaClass> 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<JavaClass> JavaClassWrapper::wrap(const String &p_class) {
|
|||
|
||||
env->DeleteLocalRef(fields);
|
||||
|
||||
return Ref<JavaClass>();
|
||||
return java_class;
|
||||
}
|
||||
|
||||
Ref<JavaClass> JavaClassWrapper::wrap_jclass(jclass p_class) {
|
||||
JNIEnv *env = get_jni_env();
|
||||
ERR_FAIL_NULL_V(env, Ref<JavaClass>());
|
||||
|
||||
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");
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue