Format code (#3217)

This commit is contained in:
minggo
2021-01-13 14:49:32 +08:00
committed by GitHub
parent 0386bed212
commit 826babfa64
257 changed files with 25430 additions and 30471 deletions
@@ -32,21 +32,19 @@
#include <string>
#ifdef LOG_TAG
#undef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "JavaScriptJavaBridge"
#ifndef ORG_JAVABRIDGE_CLASS_NAME
#define ORG_JAVABRIDGE_CLASS_NAME com_cocos_lib_CocosJavascriptJavaBridge
#define ORG_JAVABRIDGE_CLASS_NAME com_cocos_lib_CocosJavascriptJavaBridge
#endif
#define JNI_JSJAVABRIDGE(FUNC) JNI_METHOD1(ORG_JAVABRIDGE_CLASS_NAME,FUNC)
#define JNI_JSJAVABRIDGE(FUNC) JNI_METHOD1(ORG_JAVABRIDGE_CLASS_NAME, FUNC)
extern "C" {
JNIEXPORT jint JNICALL JNI_JSJAVABRIDGE(evalString)
(JNIEnv *env, jclass cls, jstring value)
{
JNIEXPORT jint JNICALL JNI_JSJAVABRIDGE(evalString)(JNIEnv *env, jclass cls, jstring value) {
if (!se::ScriptEngine::getInstance()->isValid()) {
CC_LOG_DEBUG("ScriptEngine has not been initialized");
return 0;
@@ -55,8 +53,7 @@ JNIEXPORT jint JNICALL JNI_JSJAVABRIDGE(evalString)
se::AutoHandleScope hs;
bool strFlag = false;
std::string strValue = cc::StringUtils::getStringUTFCharsJNI(env, value, &strFlag);
if (!strFlag)
{
if (!strFlag) {
CC_LOG_DEBUG("JavaScriptJavaBridge_evalString error, invalid string code");
return 0;
}
@@ -75,11 +72,9 @@ JNIEXPORT jint JNICALL JNI_JSJAVABRIDGE(evalString)
#define JSJ_ERR_VM_FAILURE (-6)
#define JSJ_ERR_CLASS_NOT_FOUND (-7)
class JavaScriptJavaBridge
{
class JavaScriptJavaBridge {
public:
enum class ValueType: char
{
enum class ValueType : char {
INVALID,
VOID,
INTEGER,
@@ -93,33 +88,30 @@ public:
typedef std::vector<ValueType> ValueTypes;
typedef union
{
int intValue;
long longValue;
float floatValue;
int boolValue;
typedef union {
int intValue;
long longValue;
float floatValue;
int boolValue;
std::string *stringValue;
} ReturnValue;
class CallInfo
{
class CallInfo {
public:
CallInfo(const char *className, const char *methodName, const char *methodSig)
: m_valid(false)
, m_error(JSJ_ERR_OK)
, m_className(className)
, m_methodName(methodName)
, m_methodSig(methodSig)
, m_returnType(ValueType::VOID)
, m_argumentsCount(0)
, m_retjstring(NULL)
, m_env(NULL)
, m_classID(NULL)
, m_methodID(NULL)
{
: m_valid(false),
m_error(JSJ_ERR_OK),
m_className(className),
m_methodName(methodName),
m_methodSig(methodSig),
m_returnType(ValueType::VOID),
m_argumentsCount(0),
m_retjstring(NULL),
m_env(NULL),
m_classID(NULL),
m_methodID(NULL) {
memset(&m_ret, 0, sizeof(m_ret));
m_valid = validateMethodSig() && getMethodInfo();
m_valid = validateMethodSig() && getMethodInfo();
}
~CallInfo();
@@ -139,60 +131,55 @@ public:
return m_argumentsType.at(index);
}
int getArgumentsCount(){
int getArgumentsCount() {
return m_argumentsCount;
}
ValueType getReturnValueType(){
ValueType getReturnValueType() {
return m_returnType;
}
ReturnValue getReturnValue(){
ReturnValue getReturnValue() {
return m_ret;
}
bool execute();
bool executeWithArgs(jvalue *args);
private:
bool m_valid;
int m_error;
bool m_valid;
int m_error;
std::string m_className;
std::string m_methodName;
std::string m_methodSig;
int m_argumentsCount;
ValueTypes m_argumentsType;
ValueType m_returnType;
std::string m_className;
std::string m_methodName;
std::string m_methodSig;
int m_argumentsCount;
ValueTypes m_argumentsType;
ValueType m_returnType;
ReturnValue m_ret;
jstring m_retjstring;
jstring m_retjstring;
JNIEnv *m_env;
jclass m_classID;
jmethodID m_methodID;
JNIEnv *m_env;
jclass m_classID;
jmethodID m_methodID;
bool validateMethodSig();
bool getMethodInfo();
ValueType checkType(const std::string& sig, size_t *pos);
ValueType checkType(const std::string &sig, size_t *pos);
};
static bool convertReturnValue(ReturnValue retValue, ValueType type, se::Value* ret);
static bool convertReturnValue(ReturnValue retValue, ValueType type, se::Value *ret);
};
JavaScriptJavaBridge::CallInfo::~CallInfo()
{
if (m_returnType == ValueType::STRING && m_ret.stringValue)
{
JavaScriptJavaBridge::CallInfo::~CallInfo() {
if (m_returnType == ValueType::STRING && m_ret.stringValue) {
delete m_ret.stringValue;
}
}
bool JavaScriptJavaBridge::CallInfo::execute()
{
switch (m_returnType)
{
bool JavaScriptJavaBridge::CallInfo::execute() {
switch (m_returnType) {
case JavaScriptJavaBridge::ValueType::VOID:
m_env->CallStaticVoidMethod(m_classID, m_methodID);
break;
@@ -213,15 +200,12 @@ bool JavaScriptJavaBridge::CallInfo::execute()
m_ret.boolValue = m_env->CallStaticBooleanMethod(m_classID, m_methodID);
break;
case JavaScriptJavaBridge::ValueType::STRING:
{
case JavaScriptJavaBridge::ValueType::STRING: {
m_retjstring = (jstring)m_env->CallStaticObjectMethod(m_classID, m_methodID);
if (m_retjstring)
{
if (m_retjstring) {
std::string strValue = cc::StringUtils::getStringUTFCharsJNI(m_env, m_retjstring);
m_ret.stringValue = new std::string(strValue);
}
else
} else
m_ret.stringValue = nullptr;
break;
@@ -233,8 +217,7 @@ bool JavaScriptJavaBridge::CallInfo::execute()
return false;
}
if (m_env->ExceptionCheck() == JNI_TRUE)
{
if (m_env->ExceptionCheck() == JNI_TRUE) {
m_env->ExceptionDescribe();
m_env->ExceptionClear();
m_error = JSJ_ERR_EXCEPTION_OCCURRED;
@@ -244,11 +227,8 @@ bool JavaScriptJavaBridge::CallInfo::execute()
return true;
}
bool JavaScriptJavaBridge::CallInfo::executeWithArgs(jvalue *args)
{
switch (m_returnType)
{
bool JavaScriptJavaBridge::CallInfo::executeWithArgs(jvalue *args) {
switch (m_returnType) {
case JavaScriptJavaBridge::ValueType::VOID:
m_env->CallStaticVoidMethodA(m_classID, m_methodID, args);
break;
@@ -269,8 +249,7 @@ bool JavaScriptJavaBridge::CallInfo::executeWithArgs(jvalue *args)
m_ret.boolValue = m_env->CallStaticBooleanMethodA(m_classID, m_methodID, args);
break;
case JavaScriptJavaBridge::ValueType::STRING:
{
case JavaScriptJavaBridge::ValueType::STRING: {
m_retjstring = (jstring)m_env->CallStaticObjectMethodA(m_classID, m_methodID, args);
std::string strValue = cc::StringUtils::getStringUTFCharsJNI(m_env, m_retjstring);
m_ret.stringValue = new std::string(strValue);
@@ -283,8 +262,7 @@ bool JavaScriptJavaBridge::CallInfo::executeWithArgs(jvalue *args)
return false;
}
if (m_env->ExceptionCheck() == JNI_TRUE)
{
if (m_env->ExceptionCheck() == JNI_TRUE) {
m_env->ExceptionDescribe();
m_env->ExceptionClear();
m_error = JSJ_ERR_EXCEPTION_OCCURRED;
@@ -294,8 +272,7 @@ bool JavaScriptJavaBridge::CallInfo::executeWithArgs(jvalue *args)
return true;
}
bool JavaScriptJavaBridge::CallInfo::validateMethodSig()
{
bool JavaScriptJavaBridge::CallInfo::validateMethodSig() {
size_t len = m_methodSig.length();
if (len < 3 || m_methodSig[0] != '(') // min sig is "()V"
{
@@ -304,8 +281,7 @@ bool JavaScriptJavaBridge::CallInfo::validateMethodSig()
}
size_t pos = 1;
while (pos < len && m_methodSig[pos] != ')')
{
while (pos < len && m_methodSig[pos] != ')') {
JavaScriptJavaBridge::ValueType type = checkType(m_methodSig, &pos);
if (type == ValueType::INVALID) return false;
@@ -314,8 +290,7 @@ bool JavaScriptJavaBridge::CallInfo::validateMethodSig()
pos++;
}
if (pos >= len || m_methodSig[pos] != ')')
{
if (pos >= len || m_methodSig[pos] != ')') {
m_error = JSJ_ERR_INVALID_SIGNATURES;
return false;
}
@@ -325,10 +300,8 @@ bool JavaScriptJavaBridge::CallInfo::validateMethodSig()
return true;
}
JavaScriptJavaBridge::ValueType JavaScriptJavaBridge::CallInfo::checkType(const std::string& sig, size_t *pos)
{
switch (sig[*pos])
{
JavaScriptJavaBridge::ValueType JavaScriptJavaBridge::CallInfo::checkType(const std::string &sig, size_t *pos) {
switch (sig[*pos]) {
case 'I':
return JavaScriptJavaBridge::ValueType::INTEGER;
case 'J':
@@ -341,25 +314,19 @@ JavaScriptJavaBridge::ValueType JavaScriptJavaBridge::CallInfo::checkType(const
return JavaScriptJavaBridge::ValueType::VOID;
case 'L':
size_t pos2 = sig.find_first_of(';', *pos + 1);
if (pos2 == std::string::npos)
{
if (pos2 == std::string::npos) {
m_error = JSJ_ERR_INVALID_SIGNATURES;
return ValueType::INVALID;
}
const std::string t = sig.substr(*pos, pos2 - *pos + 1);
if (t.compare("Ljava/lang/String;") == 0)
{
if (t.compare("Ljava/lang/String;") == 0) {
*pos = pos2;
return ValueType::STRING;
}
else if (t.compare("Ljava/util/Vector;") == 0)
{
} else if (t.compare("Ljava/util/Vector;") == 0) {
*pos = pos2;
return ValueType::VECTOR;
}
else
{
} else {
m_error = JSJ_ERR_TYPE_NOT_SUPPORT;
return ValueType::INVALID;
}
@@ -369,37 +336,34 @@ JavaScriptJavaBridge::ValueType JavaScriptJavaBridge::CallInfo::checkType(const
return ValueType::INVALID;
}
bool JavaScriptJavaBridge::CallInfo::getMethodInfo()
{
bool JavaScriptJavaBridge::CallInfo::getMethodInfo() {
m_methodID = 0;
m_env = 0;
JavaVM* jvm = cc::JniHelper::getJavaVM();
jint ret = jvm->GetEnv((void**)&m_env, JNI_VERSION_1_4);
JavaVM *jvm = cc::JniHelper::getJavaVM();
jint ret = jvm->GetEnv((void **)&m_env, JNI_VERSION_1_4);
switch (ret) {
case JNI_OK:
break;
case JNI_EDETACHED :
if (jvm->AttachCurrentThread(&m_env, NULL) < 0)
{
case JNI_EDETACHED:
if (jvm->AttachCurrentThread(&m_env, NULL) < 0) {
SE_LOGD("%s", "Failed to get the environment using AttachCurrentThread()");
m_error = JSJ_ERR_VM_THREAD_DETACHED;
return false;
}
break;
case JNI_EVERSION :
default :
case JNI_EVERSION:
default:
SE_LOGD("%s", "Failed to get the environment using GetEnv()");
m_error = JSJ_ERR_VM_FAILURE;
return false;
}
jstring _jstrClassName = m_env->NewStringUTF(m_className.c_str());
m_classID = (jclass) m_env->CallObjectMethod(cc::JniHelper::classloader,
cc::JniHelper::loadclassMethod_methodID,
_jstrClassName);
m_classID = (jclass)m_env->CallObjectMethod(cc::JniHelper::classloader,
cc::JniHelper::loadclassMethod_methodID,
_jstrClassName);
if (NULL == m_classID) {
SE_LOGD("Classloader failed to find class of %s", m_className.c_str());
@@ -411,13 +375,12 @@ bool JavaScriptJavaBridge::CallInfo::getMethodInfo()
m_env->DeleteLocalRef(_jstrClassName);
m_methodID = m_env->GetStaticMethodID(m_classID, m_methodName.c_str(), m_methodSig.c_str());
if (!m_methodID)
{
if (!m_methodID) {
m_env->ExceptionClear();
SE_LOGD("Failed to find method id of %s.%s %s",
m_className.c_str(),
m_methodName.c_str(),
m_methodSig.c_str());
m_className.c_str(),
m_methodName.c_str(),
m_methodSig.c_str());
m_error = JSJ_ERR_METHOD_NOT_FOUND;
return false;
}
@@ -425,11 +388,9 @@ bool JavaScriptJavaBridge::CallInfo::getMethodInfo()
return true;
}
bool JavaScriptJavaBridge::convertReturnValue(ReturnValue retValue, ValueType type, se::Value* ret)
{
bool JavaScriptJavaBridge::convertReturnValue(ReturnValue retValue, ValueType type, se::Value *ret) {
assert(ret != nullptr);
switch (type)
{
switch (type) {
case JavaScriptJavaBridge::ValueType::INTEGER:
ret->setInt32(retValue.intValue);
break;
@@ -456,31 +417,27 @@ bool JavaScriptJavaBridge::convertReturnValue(ReturnValue retValue, ValueType ty
return true;
}
se::Class* __jsb_JavaScriptJavaBridge_class = nullptr;
se::Class *__jsb_JavaScriptJavaBridge_class = nullptr;
static bool JavaScriptJavaBridge_finalize(se::State& s)
{
JavaScriptJavaBridge* cobj = (JavaScriptJavaBridge*)s.nativeThisObject();
static bool JavaScriptJavaBridge_finalize(se::State &s) {
JavaScriptJavaBridge *cobj = (JavaScriptJavaBridge *)s.nativeThisObject();
delete cobj;
return true;
}
SE_BIND_FINALIZE_FUNC(JavaScriptJavaBridge_finalize)
static bool JavaScriptJavaBridge_constructor(se::State& s)
{
JavaScriptJavaBridge* cobj = new (std::nothrow) JavaScriptJavaBridge();
static bool JavaScriptJavaBridge_constructor(se::State &s) {
JavaScriptJavaBridge *cobj = new (std::nothrow) JavaScriptJavaBridge();
s.thisObject()->setPrivateData(cobj);
return true;
}
SE_BIND_CTOR(JavaScriptJavaBridge_constructor, __jsb_JavaScriptJavaBridge_class, JavaScriptJavaBridge_finalize)
static bool JavaScriptJavaBridge_callStaticMethod(se::State& s)
{
const auto& args = s.args();
static bool JavaScriptJavaBridge_callStaticMethod(se::State &s) {
const auto &args = s.args();
int argc = (int)args.size();
if (argc == 3)
{
if (argc == 3) {
bool ok = false;
std::string clsName, methodName, methodSig;
ok = seval_to_std_string(args[0], &clsName);
@@ -493,12 +450,10 @@ static bool JavaScriptJavaBridge_callStaticMethod(se::State& s)
SE_PRECONDITION2(ok, false, "Converting method signature failed!");
JavaScriptJavaBridge::CallInfo call(clsName.c_str(), methodName.c_str(), methodSig.c_str());
if (call.isValid())
{
if (call.isValid()) {
ok = call.execute();
int errorCode = call.getErrorCode();
if (!ok || errorCode < 0)
{
if (!ok || errorCode < 0) {
SE_REPORT_ERROR("call result code: %d", call.getErrorCode());
return false;
}
@@ -507,9 +462,7 @@ static bool JavaScriptJavaBridge_callStaticMethod(se::State& s)
}
SE_REPORT_ERROR("JavaScriptJavaBridge::CallInfo isn't valid!");
return false;
}
else if (argc > 3)
{
} else if (argc > 3) {
bool ok = false;
std::string clsName, methodName, methodSig;
ok = seval_to_std_string(args[0], &clsName);
@@ -522,49 +475,40 @@ static bool JavaScriptJavaBridge_callStaticMethod(se::State& s)
SE_PRECONDITION2(ok, false, "Converting method signature failed!");
JavaScriptJavaBridge::CallInfo call(clsName.c_str(), methodName.c_str(), methodSig.c_str());
if (call.isValid() && call.getArgumentsCount() == (argc - 3))
{
if (call.isValid() && call.getArgumentsCount() == (argc - 3)) {
int count = argc - 3;
jvalue* jargs = new jvalue[count];
jvalue *jargs = new jvalue[count];
std::vector<jobject> toReleaseObjects;
for (int i = 0; i < count; ++i)
{
for (int i = 0; i < count; ++i) {
int index = i + 3;
switch (call.argumentTypeAtIndex(i))
{
case JavaScriptJavaBridge::ValueType::INTEGER:
{
switch (call.argumentTypeAtIndex(i)) {
case JavaScriptJavaBridge::ValueType::INTEGER: {
int integer = 0;
seval_to_int32(args[index], &integer);
jargs[i].i = integer;
break;
}
case JavaScriptJavaBridge::ValueType::LONG:
{
case JavaScriptJavaBridge::ValueType::LONG: {
long longVal = 0L;
seval_to_long(args[index], &longVal);
jargs[i].j = longVal;
break;
}
case JavaScriptJavaBridge::ValueType::FLOAT:
{
case JavaScriptJavaBridge::ValueType::FLOAT: {
float floatNumber = 0.0f;
seval_to_float(args[index], &floatNumber);
jargs[i].f = floatNumber;
break;
}
case JavaScriptJavaBridge::ValueType::BOOLEAN:
{
case JavaScriptJavaBridge::ValueType::BOOLEAN: {
jargs[i].z = args[index].isBoolean() && args[index].toBoolean() ? JNI_TRUE : JNI_FALSE;
break;
}
case JavaScriptJavaBridge::ValueType::STRING:
{
case JavaScriptJavaBridge::ValueType::STRING: {
const auto &arg = args[index];
if (arg.isNull() || arg.isUndefined())
jargs[i].l = nullptr;
else
{
else {
std::string str;
seval_to_std_string(args[index], &str);
jargs[i].l = call.getEnv()->NewStringUTF(str.c_str());
@@ -579,15 +523,13 @@ static bool JavaScriptJavaBridge_callStaticMethod(se::State& s)
}
}
ok = call.executeWithArgs(jargs);
for (const auto& obj : toReleaseObjects)
{
for (const auto &obj : toReleaseObjects) {
call.getEnv()->DeleteLocalRef(obj);
}
if (jargs)
delete[] jargs;
int errorCode = call.getErrorCode();
if (!ok || errorCode < 0)
{
if (!ok || errorCode < 0) {
SE_REPORT_ERROR("js_JSJavaBridge : call result code: %d", errorCode);
return false;
}
@@ -603,9 +545,8 @@ static bool JavaScriptJavaBridge_callStaticMethod(se::State& s)
}
SE_BIND_FUNC(JavaScriptJavaBridge_callStaticMethod)
bool register_javascript_java_bridge(se::Object* obj)
{
se::Class* cls = se::Class::create("JavascriptJavaBridge", obj, nullptr, _SE(JavaScriptJavaBridge_constructor));
bool register_javascript_java_bridge(se::Object *obj) {
se::Class *cls = se::Class::create("JavascriptJavaBridge", obj, nullptr, _SE(JavaScriptJavaBridge_constructor));
cls->defineFinalizeFunction(_SE(JavaScriptJavaBridge_finalize));
cls->defineFunction("callStaticMethod", _SE(JavaScriptJavaBridge_callStaticMethod));
@@ -617,4 +558,3 @@ bool register_javascript_java_bridge(se::Object* obj)
return true;
}