diff options
Diffstat (limited to 'platform/android/java_class_wrapper.cpp')
| -rw-r--r-- | platform/android/java_class_wrapper.cpp | 755 |
1 files changed, 352 insertions, 403 deletions
diff --git a/platform/android/java_class_wrapper.cpp b/platform/android/java_class_wrapper.cpp index 2923ef6a91..eb208f0ee0 100644 --- a/platform/android/java_class_wrapper.cpp +++ b/platform/android/java_class_wrapper.cpp @@ -29,56 +29,55 @@ #include "java_class_wrapper.h" #include "thread_jandroid.h" +bool JavaClass::_call_method(JavaObject *p_instance, const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error, Variant &ret) { -bool JavaClass::_call_method(JavaObject* p_instance,const StringName& p_method,const Variant** p_args,int p_argcount,Variant::CallError &r_error,Variant& ret) { - - Map<StringName,List<MethodInfo> >::Element *M=methods.find(p_method); + Map<StringName, List<MethodInfo> >::Element *M = methods.find(p_method); if (!M) return false; JNIEnv *env = ThreadAndroid::get_env(); - MethodInfo *method=NULL; - for (List<MethodInfo>::Element *E=M->get().front();E;E=E->next()) { + MethodInfo *method = NULL; + for (List<MethodInfo>::Element *E = M->get().front(); E; E = E->next()) { if (!p_instance && !E->get()._static) { - r_error.error=Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL; + r_error.error = Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL; continue; } int pc = E->get().param_types.size(); - if (pc>p_argcount) { + if (pc > p_argcount) { - r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS; - r_error.argument=pc; + r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS; + r_error.argument = pc; continue; } - if (pc<p_argcount) { + if (pc < p_argcount) { - r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS; - r_error.argument=pc; + r_error.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS; + r_error.argument = pc; continue; } - uint32_t *ptypes=E->get().param_types.ptr(); - bool valid=true; + uint32_t *ptypes = E->get().param_types.ptr(); + bool valid = true; - for(int i=0;i<pc;i++) { + for (int i = 0; i < pc; i++) { - Variant::Type arg_expected=Variant::NIL; - switch(ptypes[i]) { + Variant::Type arg_expected = Variant::NIL; + switch (ptypes[i]) { case ARG_TYPE_VOID: { //bug? } break; case ARG_TYPE_BOOLEAN: { - if (p_args[i]->get_type()!=Variant::BOOL) - arg_expected=Variant::BOOL; + if (p_args[i]->get_type() != Variant::BOOL) + arg_expected = Variant::BOOL; } break; - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_BYTE: - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_CHAR: - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_SHORT: - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_INT: - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_LONG: + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_BYTE: + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_CHAR: + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_SHORT: + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_INT: + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_LONG: case ARG_TYPE_BYTE: case ARG_TYPE_CHAR: case ARG_TYPE_SHORT: @@ -86,127 +85,119 @@ bool JavaClass::_call_method(JavaObject* p_instance,const StringName& p_method,c case ARG_TYPE_LONG: { if (!p_args[i]->is_num()) - arg_expected=Variant::INT; + arg_expected = Variant::INT; } break; - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_FLOAT: - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_DOUBLE: + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_FLOAT: + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_DOUBLE: case ARG_TYPE_FLOAT: case ARG_TYPE_DOUBLE: { if (!p_args[i]->is_num()) - arg_expected=Variant::REAL; + arg_expected = Variant::REAL; } break; case ARG_TYPE_STRING: { - if (p_args[i]->get_type()!=Variant::STRING) - arg_expected=Variant::STRING; + if (p_args[i]->get_type() != Variant::STRING) + arg_expected = Variant::STRING; } break; case ARG_TYPE_CLASS: { - if (p_args[i]->get_type()!=Variant::OBJECT) - arg_expected=Variant::OBJECT; + if (p_args[i]->get_type() != Variant::OBJECT) + arg_expected = Variant::OBJECT; else { Ref<Reference> ref = *p_args[i]; if (!ref.is_null()) { - if (ref->cast_to<JavaObject>() ) { + if (ref->cast_to<JavaObject>()) { - Ref<JavaObject> jo=ref; + Ref<JavaObject> jo = ref; //could be faster jclass c = env->FindClass(E->get().param_sigs[i].operator String().utf8().get_data()); - if (!c || !env->IsInstanceOf(jo->instance,c)) { + if (!c || !env->IsInstanceOf(jo->instance, c)) { - arg_expected=Variant::OBJECT; + arg_expected = Variant::OBJECT; } else { //ok } } else { - arg_expected=Variant::OBJECT; + arg_expected = Variant::OBJECT; } - } } } break; default: { - if (p_args[i]->get_type()!=Variant::ARRAY) - arg_expected=Variant::ARRAY; + if (p_args[i]->get_type() != Variant::ARRAY) + arg_expected = Variant::ARRAY; } break; - } - if (arg_expected!=Variant::NIL) { - r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; - r_error.argument=i; - r_error.expected=arg_expected; - valid=false; + if (arg_expected != Variant::NIL) { + r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; + r_error.argument = i; + r_error.expected = arg_expected; + valid = false; break; - } - } if (!valid) continue; - - method=&E->get(); + method = &E->get(); break; - } if (!method) return true; //no version convinces + r_error.error = Variant::CallError::CALL_OK; - - r_error.error=Variant::CallError::CALL_OK; - - jvalue *argv=NULL; + jvalue *argv = NULL; if (method->param_types.size()) { - argv=(jvalue*)alloca( sizeof(jvalue)*method->param_types.size() ); + argv = (jvalue *)alloca(sizeof(jvalue) * method->param_types.size()); } List<jobject> to_free; - for(int i=0;i<method->param_types.size();i++) { + for (int i = 0; i < method->param_types.size(); i++) { - switch(method->param_types[i]) { - case ARG_TYPE_VOID: { + switch (method->param_types[i]) { + case ARG_TYPE_VOID: { //can't happen - argv[i].l=NULL; //I hope this works + argv[i].l = NULL; //I hope this works } break; case ARG_TYPE_BOOLEAN: { - argv[i].z=*p_args[i]; + argv[i].z = *p_args[i]; } break; case ARG_TYPE_BYTE: { - argv[i].b=*p_args[i]; + argv[i].b = *p_args[i]; } break; case ARG_TYPE_CHAR: { - argv[i].c=*p_args[i]; + argv[i].c = *p_args[i]; } break; case ARG_TYPE_SHORT: { - argv[i].s=*p_args[i]; + argv[i].s = *p_args[i]; } break; case ARG_TYPE_INT: { - argv[i].i=*p_args[i]; + argv[i].i = *p_args[i]; } break; case ARG_TYPE_LONG: { - argv[i].j=*p_args[i]; + argv[i].j = *p_args[i]; } break; case ARG_TYPE_FLOAT: { - argv[i].f=*p_args[i]; + argv[i].f = *p_args[i]; } break; case ARG_TYPE_DOUBLE: { - argv[i].d=*p_args[i]; + argv[i].d = *p_args[i]; } break; - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_BOOLEAN: { + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_BOOLEAN: { jclass bclass = env->FindClass("java/lang/Boolean"); jmethodID ctor = env->GetMethodID(bclass, "<init>", "(Z)V"); jvalue val; @@ -215,7 +206,7 @@ bool JavaClass::_call_method(JavaObject* p_instance,const StringName& p_method,c argv[i].l = obj; to_free.push_back(obj); } break; - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_BYTE: { + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_BYTE: { jclass bclass = env->FindClass("java/lang/Byte"); jmethodID ctor = env->GetMethodID(bclass, "<init>", "(B)V"); jvalue val; @@ -224,7 +215,7 @@ bool JavaClass::_call_method(JavaObject* p_instance,const StringName& p_method,c argv[i].l = obj; to_free.push_back(obj); } break; - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_CHAR: { + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_CHAR: { jclass bclass = env->FindClass("java/lang/Character"); jmethodID ctor = env->GetMethodID(bclass, "<init>", "(C)V"); jvalue val; @@ -233,7 +224,7 @@ bool JavaClass::_call_method(JavaObject* p_instance,const StringName& p_method,c argv[i].l = obj; to_free.push_back(obj); } break; - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_SHORT: { + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_SHORT: { jclass bclass = env->FindClass("java/lang/Short"); jmethodID ctor = env->GetMethodID(bclass, "<init>", "(S)V"); jvalue val; @@ -242,7 +233,7 @@ bool JavaClass::_call_method(JavaObject* p_instance,const StringName& p_method,c argv[i].l = obj; to_free.push_back(obj); } break; - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_INT: { + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_INT: { jclass bclass = env->FindClass("java/lang/Integer"); jmethodID ctor = env->GetMethodID(bclass, "<init>", "(I)V"); jvalue val; @@ -251,7 +242,7 @@ bool JavaClass::_call_method(JavaObject* p_instance,const StringName& p_method,c argv[i].l = obj; to_free.push_back(obj); } break; - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_LONG: { + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_LONG: { jclass bclass = env->FindClass("java/lang/Long"); jmethodID ctor = env->GetMethodID(bclass, "<init>", "(J)V"); jvalue val; @@ -260,7 +251,7 @@ bool JavaClass::_call_method(JavaObject* p_instance,const StringName& p_method,c argv[i].l = obj; to_free.push_back(obj); } break; - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_FLOAT: { + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_FLOAT: { jclass bclass = env->FindClass("java/lang/Float"); jmethodID ctor = env->GetMethodID(bclass, "<init>", "(F)V"); jvalue val; @@ -269,7 +260,7 @@ bool JavaClass::_call_method(JavaObject* p_instance,const StringName& p_method,c argv[i].l = obj; to_free.push_back(obj); } break; - case ARG_NUMBER_CLASS_BIT|ARG_TYPE_DOUBLE: { + case ARG_NUMBER_CLASS_BIT | ARG_TYPE_DOUBLE: { jclass bclass = env->FindClass("java/lang/Double"); jmethodID ctor = env->GetMethodID(bclass, "<init>", "(D)V"); jvalue val; @@ -281,217 +272,214 @@ bool JavaClass::_call_method(JavaObject* p_instance,const StringName& p_method,c case ARG_TYPE_STRING: { String s = *p_args[i]; jstring jStr = env->NewStringUTF(s.utf8().get_data()); - argv[i].l=jStr; + argv[i].l = jStr; to_free.push_back(jStr); } break; case ARG_TYPE_CLASS: { - Ref<JavaObject> jo=*p_args[i]; + Ref<JavaObject> jo = *p_args[i]; if (jo.is_valid()) { - argv[i].l=jo->instance; + argv[i].l = jo->instance; } else { - argv[i].l=NULL; //I hope this works + argv[i].l = NULL; //I hope this works } } break; - case ARG_ARRAY_BIT|ARG_TYPE_BOOLEAN: { + case ARG_ARRAY_BIT | ARG_TYPE_BOOLEAN: { Array arr = *p_args[i]; jbooleanArray a = env->NewBooleanArray(arr.size()); - for(int j=0;j<arr.size();j++) { + for (int j = 0; j < arr.size(); j++) { jboolean val = arr[j]; - env->SetBooleanArrayRegion(a,j,1,&val); + env->SetBooleanArrayRegion(a, j, 1, &val); } - argv[i].l=a; + argv[i].l = a; to_free.push_back(a); } break; - case ARG_ARRAY_BIT|ARG_TYPE_BYTE: { + case ARG_ARRAY_BIT | ARG_TYPE_BYTE: { Array arr = *p_args[i]; jbyteArray a = env->NewByteArray(arr.size()); - for(int j=0;j<arr.size();j++) { + for (int j = 0; j < arr.size(); j++) { jbyte val = arr[j]; - env->SetByteArrayRegion(a,j,1,&val); + env->SetByteArrayRegion(a, j, 1, &val); } - argv[i].l=a; + argv[i].l = a; to_free.push_back(a); - } break; - case ARG_ARRAY_BIT|ARG_TYPE_CHAR: { + case ARG_ARRAY_BIT | ARG_TYPE_CHAR: { Array arr = *p_args[i]; jcharArray a = env->NewCharArray(arr.size()); - for(int j=0;j<arr.size();j++) { + for (int j = 0; j < arr.size(); j++) { jchar val = arr[j]; - env->SetCharArrayRegion(a,j,1,&val); + env->SetCharArrayRegion(a, j, 1, &val); } - argv[i].l=a; + argv[i].l = a; to_free.push_back(a); } break; - case ARG_ARRAY_BIT|ARG_TYPE_SHORT: { + case ARG_ARRAY_BIT | ARG_TYPE_SHORT: { Array arr = *p_args[i]; jshortArray a = env->NewShortArray(arr.size()); - for(int j=0;j<arr.size();j++) { + for (int j = 0; j < arr.size(); j++) { jshort val = arr[j]; - env->SetShortArrayRegion(a,j,1,&val); + env->SetShortArrayRegion(a, j, 1, &val); } - argv[i].l=a; + argv[i].l = a; to_free.push_back(a); } break; - case ARG_ARRAY_BIT|ARG_TYPE_INT: { + case ARG_ARRAY_BIT | ARG_TYPE_INT: { Array arr = *p_args[i]; jintArray a = env->NewIntArray(arr.size()); - for(int j=0;j<arr.size();j++) { + for (int j = 0; j < arr.size(); j++) { jint val = arr[j]; - env->SetIntArrayRegion(a,j,1,&val); + env->SetIntArrayRegion(a, j, 1, &val); } - argv[i].l=a; + argv[i].l = a; to_free.push_back(a); } break; - case ARG_ARRAY_BIT|ARG_TYPE_LONG: { + case ARG_ARRAY_BIT | ARG_TYPE_LONG: { Array arr = *p_args[i]; jlongArray a = env->NewLongArray(arr.size()); - for(int j=0;j<arr.size();j++) { + for (int j = 0; j < arr.size(); j++) { jlong val = arr[j]; - env->SetLongArrayRegion(a,j,1,&val); + env->SetLongArrayRegion(a, j, 1, &val); } - argv[i].l=a; + argv[i].l = a; to_free.push_back(a); } break; - case ARG_ARRAY_BIT|ARG_TYPE_FLOAT: { + case ARG_ARRAY_BIT | ARG_TYPE_FLOAT: { Array arr = *p_args[i]; jfloatArray a = env->NewFloatArray(arr.size()); - for(int j=0;j<arr.size();j++) { + for (int j = 0; j < arr.size(); j++) { jfloat val = arr[j]; - env->SetFloatArrayRegion(a,j,1,&val); + env->SetFloatArrayRegion(a, j, 1, &val); } - argv[i].l=a; + argv[i].l = a; to_free.push_back(a); - } break; - case ARG_ARRAY_BIT|ARG_TYPE_DOUBLE: { + case ARG_ARRAY_BIT | ARG_TYPE_DOUBLE: { Array arr = *p_args[i]; jdoubleArray a = env->NewDoubleArray(arr.size()); - for(int j=0;j<arr.size();j++) { + for (int j = 0; j < arr.size(); j++) { jdouble val = arr[j]; - env->SetDoubleArrayRegion(a,j,1,&val); + env->SetDoubleArrayRegion(a, j, 1, &val); } - argv[i].l=a; + argv[i].l = a; to_free.push_back(a); } break; - case ARG_ARRAY_BIT|ARG_TYPE_STRING: { + case ARG_ARRAY_BIT | ARG_TYPE_STRING: { Array arr = *p_args[i]; - jobjectArray a = env->NewObjectArray(arr.size(),env->FindClass("java/lang/String"),NULL); - for(int j=0;j<arr.size();j++) { + jobjectArray a = env->NewObjectArray(arr.size(), env->FindClass("java/lang/String"), NULL); + for (int j = 0; j < arr.size(); j++) { String s = arr[j]; jstring jStr = env->NewStringUTF(s.utf8().get_data()); - env->SetObjectArrayElement(a,j,jStr); + env->SetObjectArrayElement(a, j, jStr); to_free.push_back(jStr); } - argv[i].l=a; + argv[i].l = a; to_free.push_back(a); } break; - case ARG_ARRAY_BIT|ARG_TYPE_CLASS: { + case ARG_ARRAY_BIT | ARG_TYPE_CLASS: { - argv[i].l=NULL; + argv[i].l = NULL; } break; } } - r_error.error=Variant::CallError::CALL_OK; - bool success=true; - - switch(method->return_type) { + r_error.error = Variant::CallError::CALL_OK; + bool success = true; + switch (method->return_type) { case ARG_TYPE_VOID: { if (method->_static) { - env->CallStaticVoidMethodA(_class,method->method,argv); + env->CallStaticVoidMethodA(_class, method->method, argv); } else { - env->CallVoidMethodA(p_instance->instance,method->method,argv); + env->CallVoidMethodA(p_instance->instance, method->method, argv); } - ret=Variant(); + ret = Variant(); } break; case ARG_TYPE_BOOLEAN: { if (method->_static) { - ret=env->CallStaticBooleanMethodA(_class,method->method,argv); + ret = env->CallStaticBooleanMethodA(_class, method->method, argv); } else { - ret=env->CallBooleanMethodA(p_instance->instance,method->method,argv); + ret = env->CallBooleanMethodA(p_instance->instance, method->method, argv); } } break; case ARG_TYPE_BYTE: { if (method->_static) { - ret=env->CallStaticByteMethodA(_class,method->method,argv); + ret = env->CallStaticByteMethodA(_class, method->method, argv); } else { - ret=env->CallByteMethodA(p_instance->instance,method->method,argv); + ret = env->CallByteMethodA(p_instance->instance, method->method, argv); } } break; case ARG_TYPE_CHAR: { if (method->_static) { - ret=env->CallStaticCharMethodA(_class,method->method,argv); + ret = env->CallStaticCharMethodA(_class, method->method, argv); } else { - ret=env->CallCharMethodA(p_instance->instance,method->method,argv); + ret = env->CallCharMethodA(p_instance->instance, method->method, argv); } } break; case ARG_TYPE_SHORT: { if (method->_static) { - ret=env->CallStaticShortMethodA(_class,method->method,argv); + ret = env->CallStaticShortMethodA(_class, method->method, argv); } else { - ret=env->CallShortMethodA(p_instance->instance,method->method,argv); + ret = env->CallShortMethodA(p_instance->instance, method->method, argv); } } break; case ARG_TYPE_INT: { if (method->_static) { - ret=env->CallStaticIntMethodA(_class,method->method,argv); + ret = env->CallStaticIntMethodA(_class, method->method, argv); } else { - ret=env->CallIntMethodA(p_instance->instance,method->method,argv); + ret = env->CallIntMethodA(p_instance->instance, method->method, argv); } } break; case ARG_TYPE_LONG: { if (method->_static) { - ret=env->CallStaticLongMethodA(_class,method->method,argv); + ret = env->CallStaticLongMethodA(_class, method->method, argv); } else { - ret=env->CallLongMethodA(p_instance->instance,method->method,argv); + ret = env->CallLongMethodA(p_instance->instance, method->method, argv); } } break; case ARG_TYPE_FLOAT: { if (method->_static) { - ret=env->CallStaticFloatMethodA(_class,method->method,argv); + ret = env->CallStaticFloatMethodA(_class, method->method, argv); } else { - ret=env->CallFloatMethodA(p_instance->instance,method->method,argv); + ret = env->CallFloatMethodA(p_instance->instance, method->method, argv); } } break; case ARG_TYPE_DOUBLE: { if (method->_static) { - ret=env->CallStaticDoubleMethodA(_class,method->method,argv); + ret = env->CallStaticDoubleMethodA(_class, method->method, argv); } else { - ret=env->CallDoubleMethodA(p_instance->instance,method->method,argv); + ret = env->CallDoubleMethodA(p_instance->instance, method->method, argv); } } break; @@ -499,375 +487,366 @@ bool JavaClass::_call_method(JavaObject* p_instance,const StringName& p_method,c jobject obj; if (method->_static) { - obj=env->CallStaticObjectMethodA(_class,method->method,argv); + obj = env->CallStaticObjectMethodA(_class, method->method, argv); } else { - obj=env->CallObjectMethodA(p_instance->instance,method->method,argv); + obj = env->CallObjectMethodA(p_instance->instance, method->method, argv); } if (!obj) { - ret=Variant(); + ret = Variant(); } else { - if (!_convert_object_to_variant(env, obj, ret,method->return_type)) { - ret=Variant(); - r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD; - success=false; + if (!_convert_object_to_variant(env, obj, ret, method->return_type)) { + ret = Variant(); + r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD; + success = false; } env->DeleteLocalRef(obj); } } break; - } - for(List<jobject>::Element *E=to_free.front();E;E=E->next()) { + for (List<jobject>::Element *E = to_free.front(); E; E = E->next()) { env->DeleteLocalRef(E->get()); } return success; } -Variant JavaClass::call(const StringName& p_method,const Variant** p_args,int p_argcount,Variant::CallError &r_error) { +Variant JavaClass::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) { Variant ret; - bool found = _call_method(NULL,p_method,p_args,p_argcount,r_error,ret); + bool found = _call_method(NULL, p_method, p_args, p_argcount, r_error, ret); if (found) { return ret; } - return Reference::call(p_method,p_args,p_argcount,r_error); + return Reference::call(p_method, p_args, p_argcount, r_error); } JavaClass::JavaClass() { - } ///////////////////// -Variant JavaObject::call(const StringName& p_method,const Variant** p_args,int p_argcount,Variant::CallError &r_error){ +Variant JavaObject::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) { return Variant(); } -JavaObject::JavaObject(const Ref<JavaClass>& p_base,jobject *p_instance) { - +JavaObject::JavaObject(const Ref<JavaClass> &p_base, jobject *p_instance) { } -JavaObject::~JavaObject(){ - +JavaObject::~JavaObject() { } - //////////////////// void JavaClassWrapper::_bind_methods() { - ClassDB::bind_method(D_METHOD("wrap:JavaClass","name"),&JavaClassWrapper::wrap); + ClassDB::bind_method(D_METHOD("wrap:JavaClass", "name"), &JavaClassWrapper::wrap); } - -bool JavaClassWrapper::_get_type_sig(JNIEnv *env,jobject obj,uint32_t& sig,String&strsig) { +bool JavaClassWrapper::_get_type_sig(JNIEnv *env, jobject obj, uint32_t &sig, String &strsig) { jstring name2 = (jstring)env->CallObjectMethod(obj, Class_getName); - String str_type = env->GetStringUTFChars( name2, NULL ); - print_line("name: "+str_type); + String str_type = env->GetStringUTFChars(name2, NULL); + print_line("name: " + str_type); env->DeleteLocalRef(name2); - uint32_t t=0; + uint32_t t = 0; if (str_type.begins_with("[")) { - t=JavaClass::ARG_ARRAY_BIT; - strsig="["; - str_type=str_type.substr(1,str_type.length()-1); + t = JavaClass::ARG_ARRAY_BIT; + strsig = "["; + str_type = str_type.substr(1, str_type.length() - 1); if (str_type.begins_with("[")) { - print_line("Nested arrays not supported for type: "+str_type); + print_line("Nested arrays not supported for type: " + str_type); return false; } if (str_type.begins_with("L")) { - str_type=str_type.substr(1,str_type.length()-2); //ok it's a class + str_type = str_type.substr(1, str_type.length() - 2); //ok it's a class } } - if (str_type=="void" || str_type=="V") { - t|=JavaClass::ARG_TYPE_VOID; - strsig+="V"; - } else if (str_type=="boolean" || str_type=="Z") { - t|=JavaClass::ARG_TYPE_BOOLEAN; - strsig+="Z"; - } else if (str_type=="byte" || str_type=="B") { - t|=JavaClass::ARG_TYPE_BYTE; - strsig+="B"; - } else if (str_type=="char" || str_type=="C") { - t|=JavaClass::ARG_TYPE_CHAR; - strsig+="C"; - } else if (str_type=="short" || str_type=="S") { - t|=JavaClass::ARG_TYPE_SHORT; - strsig+="S"; - } else if (str_type=="int" || str_type=="I") { - t|=JavaClass::ARG_TYPE_INT; - strsig+="I"; - } else if (str_type=="long" || str_type=="J") { - t|=JavaClass::ARG_TYPE_LONG; - strsig+="J"; - } else if (str_type=="float" || str_type=="F") { - t|=JavaClass::ARG_TYPE_FLOAT; - strsig+="F"; - } else if (str_type=="double" || str_type=="D") { - t|=JavaClass::ARG_TYPE_DOUBLE; - strsig+="D"; - } else if (str_type=="java.lang.String") { - t|=JavaClass::ARG_TYPE_STRING; - strsig+="Ljava/lang/String;"; - } else if (str_type=="java.lang.Boolean") { - t|=JavaClass::ARG_TYPE_BOOLEAN|JavaClass::ARG_NUMBER_CLASS_BIT; - strsig+="Ljava/lang/Boolean;"; - } else if (str_type=="java.lang.Byte") { - t|=JavaClass::ARG_TYPE_BYTE|JavaClass::ARG_NUMBER_CLASS_BIT; - strsig+="Ljava/lang/Byte;"; - } else if (str_type=="java.lang.Character") { - t|=JavaClass::ARG_TYPE_CHAR|JavaClass::ARG_NUMBER_CLASS_BIT; - strsig+="Ljava/lang/Character;"; - } else if (str_type=="java.lang.Short") { - t|=JavaClass::ARG_TYPE_SHORT|JavaClass::ARG_NUMBER_CLASS_BIT; - strsig+="Ljava/lang/Short;"; - } else if (str_type=="java.lang.Integer") { - t|=JavaClass::ARG_TYPE_INT|JavaClass::ARG_NUMBER_CLASS_BIT; - strsig+="Ljava/lang/Integer;"; - } else if (str_type=="java.lang.Long") { - t|=JavaClass::ARG_TYPE_LONG|JavaClass::ARG_NUMBER_CLASS_BIT; - strsig+="Ljava/lang/Long;"; - } else if (str_type=="java.lang.Float") { - t|=JavaClass::ARG_TYPE_FLOAT|JavaClass::ARG_NUMBER_CLASS_BIT; - strsig+="Ljava/lang/Float;"; - } else if (str_type=="java.lang.Double") { - t|=JavaClass::ARG_TYPE_DOUBLE|JavaClass::ARG_NUMBER_CLASS_BIT; - strsig+="Ljava/lang/Double;"; + if (str_type == "void" || str_type == "V") { + t |= JavaClass::ARG_TYPE_VOID; + strsig += "V"; + } else if (str_type == "boolean" || str_type == "Z") { + t |= JavaClass::ARG_TYPE_BOOLEAN; + strsig += "Z"; + } else if (str_type == "byte" || str_type == "B") { + t |= JavaClass::ARG_TYPE_BYTE; + strsig += "B"; + } else if (str_type == "char" || str_type == "C") { + t |= JavaClass::ARG_TYPE_CHAR; + strsig += "C"; + } else if (str_type == "short" || str_type == "S") { + t |= JavaClass::ARG_TYPE_SHORT; + strsig += "S"; + } else if (str_type == "int" || str_type == "I") { + t |= JavaClass::ARG_TYPE_INT; + strsig += "I"; + } else if (str_type == "long" || str_type == "J") { + t |= JavaClass::ARG_TYPE_LONG; + strsig += "J"; + } else if (str_type == "float" || str_type == "F") { + t |= JavaClass::ARG_TYPE_FLOAT; + strsig += "F"; + } else if (str_type == "double" || str_type == "D") { + t |= JavaClass::ARG_TYPE_DOUBLE; + strsig += "D"; + } else if (str_type == "java.lang.String") { + t |= JavaClass::ARG_TYPE_STRING; + strsig += "Ljava/lang/String;"; + } else if (str_type == "java.lang.Boolean") { + t |= JavaClass::ARG_TYPE_BOOLEAN | JavaClass::ARG_NUMBER_CLASS_BIT; + strsig += "Ljava/lang/Boolean;"; + } else if (str_type == "java.lang.Byte") { + t |= JavaClass::ARG_TYPE_BYTE | JavaClass::ARG_NUMBER_CLASS_BIT; + strsig += "Ljava/lang/Byte;"; + } else if (str_type == "java.lang.Character") { + t |= JavaClass::ARG_TYPE_CHAR | JavaClass::ARG_NUMBER_CLASS_BIT; + strsig += "Ljava/lang/Character;"; + } else if (str_type == "java.lang.Short") { + t |= JavaClass::ARG_TYPE_SHORT | JavaClass::ARG_NUMBER_CLASS_BIT; + strsig += "Ljava/lang/Short;"; + } else if (str_type == "java.lang.Integer") { + t |= JavaClass::ARG_TYPE_INT | JavaClass::ARG_NUMBER_CLASS_BIT; + strsig += "Ljava/lang/Integer;"; + } else if (str_type == "java.lang.Long") { + t |= JavaClass::ARG_TYPE_LONG | JavaClass::ARG_NUMBER_CLASS_BIT; + strsig += "Ljava/lang/Long;"; + } else if (str_type == "java.lang.Float") { + t |= JavaClass::ARG_TYPE_FLOAT | JavaClass::ARG_NUMBER_CLASS_BIT; + strsig += "Ljava/lang/Float;"; + } else if (str_type == "java.lang.Double") { + t |= JavaClass::ARG_TYPE_DOUBLE | JavaClass::ARG_NUMBER_CLASS_BIT; + strsig += "Ljava/lang/Double;"; } else { //a class likely - strsig+="L"+str_type.replace(".","/")+";"; - t|=JavaClass::ARG_TYPE_CLASS; + strsig += "L" + str_type.replace(".", "/") + ";"; + t |= JavaClass::ARG_TYPE_CLASS; } - sig=t; - + sig = t; return true; - } -bool JavaClass::_convert_object_to_variant(JNIEnv * env, jobject obj, Variant& var,uint32_t p_sig) { +bool JavaClass::_convert_object_to_variant(JNIEnv *env, jobject obj, Variant &var, uint32_t p_sig) { if (!obj) { - var=Variant(); //seems null is just null... + var = Variant(); //seems null is just null... return true; } - - switch(p_sig) { + switch (p_sig) { case ARG_TYPE_VOID: { return Variant(); } break; - case ARG_TYPE_BOOLEAN|ARG_NUMBER_CLASS_BIT: { + case ARG_TYPE_BOOLEAN | ARG_NUMBER_CLASS_BIT: { var = env->CallBooleanMethod(obj, JavaClassWrapper::singleton->Boolean_booleanValue); return true; } break; - case ARG_TYPE_BYTE|ARG_NUMBER_CLASS_BIT: { + case ARG_TYPE_BYTE | ARG_NUMBER_CLASS_BIT: { var = env->CallByteMethod(obj, JavaClassWrapper::singleton->Byte_byteValue); return true; } break; - case ARG_TYPE_CHAR|ARG_NUMBER_CLASS_BIT: { + case ARG_TYPE_CHAR | ARG_NUMBER_CLASS_BIT: { var = env->CallCharMethod(obj, JavaClassWrapper::singleton->Character_characterValue); return true; } break; - case ARG_TYPE_SHORT|ARG_NUMBER_CLASS_BIT: { + case ARG_TYPE_SHORT | ARG_NUMBER_CLASS_BIT: { var = env->CallShortMethod(obj, JavaClassWrapper::singleton->Short_shortValue); return true; } break; - case ARG_TYPE_INT|ARG_NUMBER_CLASS_BIT: { + case ARG_TYPE_INT | ARG_NUMBER_CLASS_BIT: { var = env->CallIntMethod(obj, JavaClassWrapper::singleton->Integer_integerValue); return true; } break; - case ARG_TYPE_LONG|ARG_NUMBER_CLASS_BIT: { + case ARG_TYPE_LONG | ARG_NUMBER_CLASS_BIT: { var = env->CallLongMethod(obj, JavaClassWrapper::singleton->Long_longValue); return true; } break; - case ARG_TYPE_FLOAT|ARG_NUMBER_CLASS_BIT: { + case ARG_TYPE_FLOAT | ARG_NUMBER_CLASS_BIT: { var = env->CallFloatMethod(obj, JavaClassWrapper::singleton->Float_floatValue); return true; } break; - case ARG_TYPE_DOUBLE|ARG_NUMBER_CLASS_BIT: { + case ARG_TYPE_DOUBLE | ARG_NUMBER_CLASS_BIT: { var = env->CallDoubleMethod(obj, JavaClassWrapper::singleton->Double_doubleValue); return true; } break; case ARG_TYPE_STRING: { - var = String::utf8(env->GetStringUTFChars( (jstring)obj, NULL )); + var = String::utf8(env->GetStringUTFChars((jstring)obj, NULL)); return true; } break; case ARG_TYPE_CLASS: { return false; } break; - case ARG_ARRAY_BIT|ARG_TYPE_VOID: { + case ARG_ARRAY_BIT | ARG_TYPE_VOID: { var = Array(); // ? return true; } break; - case ARG_ARRAY_BIT|ARG_TYPE_BOOLEAN: { + case ARG_ARRAY_BIT | ARG_TYPE_BOOLEAN: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jboolean val; - env->GetBooleanArrayRegion((jbooleanArray)arr,0,1,&val); + env->GetBooleanArrayRegion((jbooleanArray)arr, 0, 1, &val); ret.push_back(val); } - var=ret; + var = ret; return true; } break; - case ARG_ARRAY_BIT|ARG_TYPE_BYTE: { + case ARG_ARRAY_BIT | ARG_TYPE_BYTE: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jbyte val; - env->GetByteArrayRegion((jbyteArray)arr,0,1,&val); + env->GetByteArrayRegion((jbyteArray)arr, 0, 1, &val); ret.push_back(val); } - var=ret; + var = ret; return true; } break; - case ARG_ARRAY_BIT|ARG_TYPE_CHAR: { + case ARG_ARRAY_BIT | ARG_TYPE_CHAR: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jchar val; - env->GetCharArrayRegion((jcharArray)arr,0,1,&val); + env->GetCharArrayRegion((jcharArray)arr, 0, 1, &val); ret.push_back(val); } - var=ret; + var = ret; return true; } break; - case ARG_ARRAY_BIT|ARG_TYPE_SHORT: { + case ARG_ARRAY_BIT | ARG_TYPE_SHORT: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jshort val; - env->GetShortArrayRegion((jshortArray)arr,0,1,&val); + env->GetShortArrayRegion((jshortArray)arr, 0, 1, &val); ret.push_back(val); } - var=ret; + var = ret; return true; } break; - case ARG_ARRAY_BIT|ARG_TYPE_INT: { + case ARG_ARRAY_BIT | ARG_TYPE_INT: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jint val; - env->GetIntArrayRegion((jintArray)arr,0,1,&val); + env->GetIntArrayRegion((jintArray)arr, 0, 1, &val); ret.push_back(val); } - var=ret; + var = ret; return true; } break; - case ARG_ARRAY_BIT|ARG_TYPE_LONG: { + case ARG_ARRAY_BIT | ARG_TYPE_LONG: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jlong val; - env->GetLongArrayRegion((jlongArray)arr,0,1,&val); + env->GetLongArrayRegion((jlongArray)arr, 0, 1, &val); ret.push_back(val); } - var=ret; + var = ret; return true; } break; - case ARG_ARRAY_BIT|ARG_TYPE_FLOAT: { + case ARG_ARRAY_BIT | ARG_TYPE_FLOAT: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jfloat val; - env->GetFloatArrayRegion((jfloatArray)arr,0,1,&val); + env->GetFloatArrayRegion((jfloatArray)arr, 0, 1, &val); ret.push_back(val); } - var=ret; + var = ret; return true; } break; - case ARG_ARRAY_BIT|ARG_TYPE_DOUBLE: { + case ARG_ARRAY_BIT | ARG_TYPE_DOUBLE: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jdouble val; - env->GetDoubleArrayRegion((jdoubleArray)arr,0,1,&val); + env->GetDoubleArrayRegion((jdoubleArray)arr, 0, 1, &val); ret.push_back(val); } - var=ret; + var = ret; return true; } break; - case ARG_NUMBER_CLASS_BIT|ARG_ARRAY_BIT|ARG_TYPE_BOOLEAN: { + case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_BOOLEAN: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jobject o = env->GetObjectArrayElement(arr, i); if (!o) @@ -875,23 +854,22 @@ bool JavaClass::_convert_object_to_variant(JNIEnv * env, jobject obj, Variant& v else { bool val = env->CallBooleanMethod(o, JavaClassWrapper::singleton->Boolean_booleanValue); ret.push_back(val); - } env->DeleteLocalRef(o); } - var=ret; + var = ret; return true; } break; - case ARG_NUMBER_CLASS_BIT|ARG_ARRAY_BIT|ARG_TYPE_BYTE: { + case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_BYTE: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jobject o = env->GetObjectArrayElement(arr, i); if (!o) @@ -899,22 +877,21 @@ bool JavaClass::_convert_object_to_variant(JNIEnv * env, jobject obj, Variant& v else { int val = env->CallByteMethod(o, JavaClassWrapper::singleton->Byte_byteValue); ret.push_back(val); - } env->DeleteLocalRef(o); } - var=ret; + var = ret; return true; } break; - case ARG_NUMBER_CLASS_BIT|ARG_ARRAY_BIT|ARG_TYPE_CHAR: { + case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_CHAR: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jobject o = env->GetObjectArrayElement(arr, i); if (!o) @@ -922,22 +899,21 @@ bool JavaClass::_convert_object_to_variant(JNIEnv * env, jobject obj, Variant& v else { int val = env->CallCharMethod(o, JavaClassWrapper::singleton->Character_characterValue); ret.push_back(val); - } env->DeleteLocalRef(o); } - var=ret; + var = ret; return true; } break; - case ARG_NUMBER_CLASS_BIT|ARG_ARRAY_BIT|ARG_TYPE_SHORT: { + case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_SHORT: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jobject o = env->GetObjectArrayElement(arr, i); if (!o) @@ -945,22 +921,21 @@ bool JavaClass::_convert_object_to_variant(JNIEnv * env, jobject obj, Variant& v else { int val = env->CallShortMethod(o, JavaClassWrapper::singleton->Short_shortValue); ret.push_back(val); - } env->DeleteLocalRef(o); } - var=ret; + var = ret; return true; } break; - case ARG_NUMBER_CLASS_BIT|ARG_ARRAY_BIT|ARG_TYPE_INT: { + case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_INT: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jobject o = env->GetObjectArrayElement(arr, i); if (!o) @@ -968,22 +943,21 @@ bool JavaClass::_convert_object_to_variant(JNIEnv * env, jobject obj, Variant& v else { int val = env->CallIntMethod(o, JavaClassWrapper::singleton->Integer_integerValue); ret.push_back(val); - } env->DeleteLocalRef(o); } - var=ret; + var = ret; return true; } break; - case ARG_NUMBER_CLASS_BIT|ARG_ARRAY_BIT|ARG_TYPE_LONG: { + case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_LONG: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jobject o = env->GetObjectArrayElement(arr, i); if (!o) @@ -991,22 +965,21 @@ bool JavaClass::_convert_object_to_variant(JNIEnv * env, jobject obj, Variant& v else { int64_t val = env->CallLongMethod(o, JavaClassWrapper::singleton->Long_longValue); ret.push_back(val); - } env->DeleteLocalRef(o); } - var=ret; + var = ret; return true; } break; - case ARG_NUMBER_CLASS_BIT|ARG_ARRAY_BIT|ARG_TYPE_FLOAT: { + case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_FLOAT: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jobject o = env->GetObjectArrayElement(arr, i); if (!o) @@ -1014,21 +987,20 @@ bool JavaClass::_convert_object_to_variant(JNIEnv * env, jobject obj, Variant& v else { float val = env->CallFloatMethod(o, JavaClassWrapper::singleton->Float_floatValue); ret.push_back(val); - } env->DeleteLocalRef(o); } - var=ret; + var = ret; return true; } break; - case ARG_NUMBER_CLASS_BIT|ARG_ARRAY_BIT|ARG_TYPE_DOUBLE: { + case ARG_NUMBER_CLASS_BIT | ARG_ARRAY_BIT | ARG_TYPE_DOUBLE: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jobject o = env->GetObjectArrayElement(arr, i); if (!o) @@ -1036,58 +1008,53 @@ bool JavaClass::_convert_object_to_variant(JNIEnv * env, jobject obj, Variant& v else { double val = env->CallDoubleMethod(o, JavaClassWrapper::singleton->Double_doubleValue); ret.push_back(val); - } env->DeleteLocalRef(o); } - var=ret; + var = ret; return true; } break; - case ARG_ARRAY_BIT|ARG_TYPE_STRING: { + case ARG_ARRAY_BIT | ARG_TYPE_STRING: { Array ret; jobjectArray arr = (jobjectArray)obj; int count = env->GetArrayLength(arr); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jobject o = env->GetObjectArrayElement(arr, i); if (!o) ret.push_back(Variant()); else { - String val = String::utf8(env->GetStringUTFChars( (jstring)o, NULL )); + String val = String::utf8(env->GetStringUTFChars((jstring)o, NULL)); ret.push_back(val); - } env->DeleteLocalRef(o); } - var=ret; + var = ret; return true; } break; - case ARG_ARRAY_BIT|ARG_TYPE_CLASS: { + case ARG_ARRAY_BIT | ARG_TYPE_CLASS: { } break; } return false; - } - -Ref<JavaClass> JavaClassWrapper::wrap(const String& p_class) { +Ref<JavaClass> JavaClassWrapper::wrap(const String &p_class) { if (class_cache.has(p_class)) return class_cache[p_class]; - JNIEnv *env = ThreadAndroid::get_env(); jclass bclass = env->FindClass(p_class.utf8().get_data()); - ERR_FAIL_COND_V(!bclass,Ref<JavaClass>()); + ERR_FAIL_COND_V(!bclass, Ref<JavaClass>()); //jmethodID getDeclaredMethods = env->GetMethodID(bclass,"getDeclaredMethods", "()[Ljava/lang/reflect/Method;"); @@ -1095,130 +1062,121 @@ Ref<JavaClass> JavaClassWrapper::wrap(const String& p_class) { jobjectArray methods = (jobjectArray)env->CallObjectMethod(bclass, getDeclaredMethods); - ERR_FAIL_COND_V(!methods,Ref<JavaClass>()); + ERR_FAIL_COND_V(!methods, Ref<JavaClass>()); - - Ref<JavaClass> java_class = memnew( JavaClass ); + Ref<JavaClass> java_class = memnew(JavaClass); int count = env->GetArrayLength(methods); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jobject obj = env->GetObjectArrayElement(methods, i); ERR_CONTINUE(!obj); - jstring name = (jstring)env->CallObjectMethod(obj, getName); - String str_method = env->GetStringUTFChars( name, NULL ); + String str_method = env->GetStringUTFChars(name, NULL); env->DeleteLocalRef(name); Vector<String> params; - jint mods = env->CallIntMethod(obj,getModifiers); + jint mods = env->CallIntMethod(obj, getModifiers); - if (!(mods&0x0001)) { + if (!(mods & 0x0001)) { env->DeleteLocalRef(obj); continue; //not public bye } - - jobjectArray param_types = (jobjectArray)env->CallObjectMethod(obj, getParameterTypes); - int count2=env->GetArrayLength(param_types); + int count2 = env->GetArrayLength(param_types); if (!java_class->methods.has(str_method)) { - java_class->methods[str_method]=List<JavaClass::MethodInfo>(); + java_class->methods[str_method] = List<JavaClass::MethodInfo>(); } JavaClass::MethodInfo mi; - mi._static = (mods&0x8)!=0; - bool valid=true; - String signature="("; + mi._static = (mods & 0x8) != 0; + bool valid = true; + String signature = "("; - for(int j=0;j<count2;j++) { + for (int j = 0; j < count2; j++) { jobject obj2 = env->GetObjectArrayElement(param_types, j); String strsig; - uint32_t sig=0; - if (!_get_type_sig(env,obj2,sig,strsig)) { - valid=false; + uint32_t sig = 0; + if (!_get_type_sig(env, obj2, sig, strsig)) { + valid = false; env->DeleteLocalRef(obj2); break; } - signature+=strsig; + signature += strsig; mi.param_types.push_back(sig); mi.param_sigs.push_back(strsig); env->DeleteLocalRef(obj2); - } if (!valid) { - print_line("Method Can't be bound (unsupported arguments): "+p_class+"::"+str_method); + print_line("Method Can't be bound (unsupported arguments): " + p_class + "::" + str_method); env->DeleteLocalRef(obj); env->DeleteLocalRef(param_types); continue; } - signature+=")"; + signature += ")"; jobject return_type = (jobject)env->CallObjectMethod(obj, 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): "+p_class+"::"+str_method); + 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; + signature += strsig; + mi.return_type = sig; - print_line("METHOD: "+str_method+" SIG: "+signature+" static: "+itos(mi._static)); + print_line("METHOD: " + str_method + " SIG: " + signature + " static: " + itos(mi._static)); - bool discard=false; + bool discard = false; - for(List<JavaClass::MethodInfo>::Element *E=java_class->methods[str_method].front();E;E=E->next()) { + for (List<JavaClass::MethodInfo>::Element *E = java_class->methods[str_method].front(); E; E = E->next()) { - float new_likeliness=0; - float existing_likeliness=0; + float new_likeliness = 0; + float existing_likeliness = 0; - if (E->get().param_types.size()!=mi.param_types.size()) + if (E->get().param_types.size() != mi.param_types.size()) continue; - bool valid=true; - for(int j=0;j<E->get().param_types.size();j++) { + bool valid = true; + for (int j = 0; j < E->get().param_types.size(); j++) { Variant::Type _new; float new_l; Variant::Type existing; float existing_l; - JavaClass::_convert_to_variant_type(E->get().param_types[j],existing,existing_l); - JavaClass::_convert_to_variant_type(mi.param_types[j],_new,new_l); - if (_new!=existing) { - valid=false; + JavaClass::_convert_to_variant_type(E->get().param_types[j], existing, existing_l); + JavaClass::_convert_to_variant_type(mi.param_types[j], _new, new_l); + if (_new != existing) { + valid = false; break; } - new_likeliness+=new_l; - existing_likeliness=existing_l; - + new_likeliness += new_l; + existing_likeliness = existing_l; } if (!valid) continue; - if (new_likeliness>existing_likeliness) { + if (new_likeliness > existing_likeliness) { java_class->methods[str_method].erase(E); print_line("replace old"); break; } else { - discard=true; + discard = true; print_line("old is better"); } - - } if (!discard) { @@ -1236,12 +1194,8 @@ Ref<JavaClass> JavaClassWrapper::wrap(const String& p_class) { env->DeleteLocalRef(param_types); env->DeleteLocalRef(return_type); - - - //args[i] = _jobject_to_variant(env, obj); //print_line("\targ"+itos(i)+": "+Variant::get_type_name(args[i].get_type())); - }; env->DeleteLocalRef(methods); @@ -1250,33 +1204,32 @@ Ref<JavaClass> JavaClassWrapper::wrap(const String& p_class) { count = env->GetArrayLength(fields); - for (int i=0; i<count; i++) { + for (int i = 0; i < count; i++) { jobject obj = env->GetObjectArrayElement(fields, i); ERR_CONTINUE(!obj); jstring name = (jstring)env->CallObjectMethod(obj, Field_getName); - String str_field = env->GetStringUTFChars( name, NULL ); + String str_field = env->GetStringUTFChars(name, NULL); env->DeleteLocalRef(name); - print_line("FIELD: "+str_field); - int mods = env->CallIntMethod(obj,Field_getModifiers); - if ((mods&0x8) && (mods&0x10) && (mods&0x1)) { //static final public! + print_line("FIELD: " + str_field); + int mods = env->CallIntMethod(obj, Field_getModifiers); + if ((mods & 0x8) && (mods & 0x10) && (mods & 0x1)) { //static final public! - jobject objc = env->CallObjectMethod(obj, Field_get,NULL); + jobject objc = env->CallObjectMethod(obj, Field_get, NULL); if (objc) { - uint32_t sig; String strsig; jclass cl = env->GetObjectClass(objc); - if (JavaClassWrapper::_get_type_sig(env,cl,sig,strsig)) { + if (JavaClassWrapper::_get_type_sig(env, cl, sig, strsig)) { - if ((sig&JavaClass::ARG_TYPE_MASK)<=JavaClass::ARG_TYPE_STRING) { + if ((sig & JavaClass::ARG_TYPE_MASK) <= JavaClass::ARG_TYPE_STRING) { Variant value; - if (JavaClass::_convert_object_to_variant(env,objc,value,sig)) { + if (JavaClass::_convert_object_to_variant(env, objc, value, sig)) { - java_class->constant_map[str_field]=value; + java_class->constant_map[str_field] = value; } } } @@ -1284,49 +1237,46 @@ Ref<JavaClass> JavaClassWrapper::wrap(const String& p_class) { env->DeleteLocalRef(cl); } - env->DeleteLocalRef(objc); - } env->DeleteLocalRef(obj); } env->DeleteLocalRef(fields); - return Ref<JavaClass>(); } -JavaClassWrapper *JavaClassWrapper::singleton=NULL; +JavaClassWrapper *JavaClassWrapper::singleton = NULL; JavaClassWrapper::JavaClassWrapper(jobject p_activity) { - singleton=this; + singleton = this; JNIEnv *env = ThreadAndroid::get_env(); jclass activityClass = env->FindClass("org/godotengine/godot/Godot"); - jmethodID getClassLoader = env->GetMethodID(activityClass,"getClassLoader", "()Ljava/lang/ClassLoader;"); + jmethodID getClassLoader = env->GetMethodID(activityClass, "getClassLoader", "()Ljava/lang/ClassLoader;"); classLoader = env->CallObjectMethod(p_activity, getClassLoader); - classLoader=(jclass)env->NewGlobalRef(classLoader); + classLoader = (jclass)env->NewGlobalRef(classLoader); jclass classLoaderClass = env->FindClass("java/lang/ClassLoader"); findClass = env->GetMethodID(classLoaderClass, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;"); 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_getName = env->GetMethodID(bclass,"getName", "()Ljava/lang/String;"); + getDeclaredMethods = env->GetMethodID(bclass, "getDeclaredMethods", "()[Ljava/lang/reflect/Method;"); + getFields = env->GetMethodID(bclass, "getFields", "()[Ljava/lang/reflect/Field;"); + Class_getName = env->GetMethodID(bclass, "getName", "()Ljava/lang/String;"); // 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"); + 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"); /// bclass = env->FindClass("java/lang/reflect/Field"); - Field_getName = env->GetMethodID(bclass,"getName", "()Ljava/lang/String;"); - Field_getModifiers = env->GetMethodID(bclass,"getModifiers", "()I"); - Field_get = env->GetMethodID(bclass,"get", "(Ljava/lang/Object;)Ljava/lang/Object;"); + Field_getName = env->GetMethodID(bclass, "getName", "()Ljava/lang/String;"); + Field_getModifiers = env->GetMethodID(bclass, "getModifiers", "()I"); + Field_get = env->GetMethodID(bclass, "get", "(Ljava/lang/Object;)Ljava/lang/Object;"); // each bclass = env->FindClass("java/lang/Boolean"); Boolean_booleanValue = env->GetMethodID(bclass, "booleanValue", "()Z"); @@ -1351,5 +1301,4 @@ JavaClassWrapper::JavaClassWrapper(jobject p_activity) { bclass = env->FindClass("java/lang/Double"); Double_doubleValue = env->GetMethodID(bclass, "doubleValue", "()D"); - } |