From 682926883d563dfd25dc72608c111ce99f776d3f Mon Sep 17 00:00:00 2001 From: Yufeng Wang Date: Fri, 1 Dec 2023 12:38:11 -0800 Subject: [PATCH] Revert "Update Java8 Optional handling in JniReferences (#30071)" (#30769) This reverts commit 4e438d69c63d259dafdc3fc3bb1748d7de27e044. --- src/lib/support/JniReferences.cpp | 108 ++++++++++-------------------- src/lib/support/JniReferences.h | 4 -- 2 files changed, 37 insertions(+), 75 deletions(-) diff --git a/src/lib/support/JniReferences.cpp b/src/lib/support/JniReferences.cpp index b6919f8c076b4a..f07837ade467bd 100644 --- a/src/lib/support/JniReferences.cpp +++ b/src/lib/support/JniReferences.cpp @@ -21,7 +21,6 @@ #include #include #include -#include namespace chip { @@ -36,7 +35,7 @@ void JniReferences::SetJavaVm(JavaVM * jvm, const char * clsType) JNIEnv * env = GetEnvForCurrentThread(); // Any chip.devicecontroller.* class will work here - just need something to call getClassLoader() on. jclass chipClass = env->FindClass(clsType); - VerifyOrReturn(chipClass != nullptr, ChipLogError(Support, "clsType can not be found")); + VerifyOrReturn(chipClass != nullptr, ChipLogError(Support, "clsType can not found")); jclass classClass = env->FindClass("java/lang/Class"); jclass classLoaderClass = env->FindClass("java/lang/ClassLoader"); @@ -48,36 +47,6 @@ void JniReferences::SetJavaVm(JavaVM * jvm, const char * clsType) chip::JniReferences::GetInstance().GetClassRef(env, "java/util/List", mListClass); chip::JniReferences::GetInstance().GetClassRef(env, "java/util/ArrayList", mArrayListClass); chip::JniReferences::GetInstance().GetClassRef(env, "java/util/HashMap", mHashMapClass); - - // Determine if the Java code has proper Java 8 support or not. - // The class and method chosen here are arbitrary, all we care about is - // looking up any method that has an Optional parameter. - jclass controllerParamsClass = env->FindClass("chip/devicecontroller/ControllerParams"); - VerifyOrReturn(controllerParamsClass != nullptr, ChipLogError(Support, "controllerParamsClass is nullptr")); - - jmethodID getCountryCodeMethod = env->GetMethodID(controllerParamsClass, "getCountryCode", "()Ljava/util/Optional;"); - if (getCountryCodeMethod == nullptr) - { - // GetMethodID will have thrown an exception previously if it returned nullptr. - env->ExceptionClear(); - VerifyOrReturn(env->GetMethodID(controllerParamsClass, "getCountryCode", "()Lj$/util/Optional;") != nullptr, - ChipLogError(Support, "Method getCountryCode can not be found")); - use_java8_optional = false; - } - else - { - use_java8_optional = true; - } - - if (use_java8_optional) - { - chip::JniReferences::GetInstance().GetClassRef(env, "java/util/Optional", mOptionalClass); - } - else - { - chip::JniReferences::GetInstance().GetClassRef(env, "j$/util/Optional", mOptionalClass); - } - VerifyOrReturn(mOptionalClass != nullptr, ChipLogError(Support, "mOptionalClass is nullptr")); } JNIEnv * JniReferences::GetEnvForCurrentThread() @@ -121,11 +90,11 @@ CHIP_ERROR JniReferences::GetLocalClassRef(JNIEnv * env, const char * clsType, j { jclass cls = nullptr; - // Try `j$/util/Optional` when enabling Java8. Check whether mOptionalClass - // is null because this method is used to originally set mOptionalClass. - if (mOptionalClass != nullptr && (strcmp(clsType, "java/util/Optional") == 0 || strcmp(clsType, "j$/util/Optional") == 0)) + // Try `j$/util/Optional` when enabling Java8. + if (strcmp(clsType, "java/util/Optional") == 0) { - cls = mOptionalClass; + cls = env->FindClass("j$/util/Optional"); + env->ExceptionClear(); } if (cls == nullptr) @@ -160,18 +129,6 @@ CHIP_ERROR JniReferences::N2J_ByteArray(JNIEnv * env, const uint8_t * inArray, j return err; } -static std::string StrReplaceAll(const std::string & source, const std::string & from, const std::string & to) -{ - std::string newString = source; - size_t pos = 0; - while ((pos = newString.find(from, pos)) != std::string::npos) - { - newString.replace(pos, from.length(), to); - pos += to.length(); - } - return newString; -} - CHIP_ERROR JniReferences::FindMethod(JNIEnv * env, jobject object, const char * methodName, const char * methodSignature, jmethodID * methodId) { @@ -189,14 +146,21 @@ CHIP_ERROR JniReferences::FindMethod(JNIEnv * env, jobject object, const char * return CHIP_NO_ERROR; } - std::string method_signature = methodSignature; - if (!use_java8_optional) + // Try `j$` when enabling Java8. + std::string methodSignature_java8_str(methodSignature); + size_t pos = methodSignature_java8_str.find("java/util/Optional"); + if (pos != std::string::npos) { - method_signature = StrReplaceAll(method_signature, "java/util/Optional", "j$/util/Optional"); + // Replace all "java/util/Optional" with "j$/util/Optional". + while (pos != std::string::npos) + { + methodSignature_java8_str.replace(pos, strlen("java/util/Optional"), "j$/util/Optional"); + pos = methodSignature_java8_str.find("java/util/Optional"); + } + *methodId = env->GetMethodID(javaClass, methodName, methodSignature_java8_str.c_str()); + env->ExceptionClear(); } - *methodId = env->GetMethodID(javaClass, methodName, method_signature.data()); - VerifyOrReturnError(*methodId != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND); return CHIP_NO_ERROR; @@ -262,23 +226,24 @@ void JniReferences::ThrowError(JNIEnv * env, jclass exceptionCls, CHIP_ERROR err CHIP_ERROR JniReferences::CreateOptional(jobject objectToWrap, jobject & outOptional) { - VerifyOrReturnError(mOptionalClass != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND); + JNIEnv * env = GetEnvForCurrentThread(); + jclass optionalCls; + chip::JniReferences::GetInstance().GetClassRef(env, "java/util/Optional", optionalCls); + VerifyOrReturnError(optionalCls != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND); + chip::JniClass jniClass(optionalCls); - JNIEnv * const env = GetEnvForCurrentThread(); - VerifyOrReturnError(env != nullptr, CHIP_JNI_ERROR_NO_ENV); + jmethodID ofMethod = env->GetStaticMethodID(optionalCls, "ofNullable", "(Ljava/lang/Object;)Ljava/util/Optional;"); + env->ExceptionClear(); - jmethodID ofMethod = nullptr; - if (use_java8_optional) + // Try `Lj$/util/Optional;` when enabling Java8. + if (ofMethod == nullptr) { - ofMethod = env->GetStaticMethodID(mOptionalClass, "ofNullable", "(Ljava/lang/Object;)Ljava/util/Optional;"); - } - else - { - ofMethod = env->GetStaticMethodID(mOptionalClass, "ofNullable", "(Ljava/lang/Object;)Lj$/util/Optional;"); + ofMethod = env->GetStaticMethodID(optionalCls, "ofNullable", "(Ljava/lang/Object;)Lj$/util/Optional;"); + env->ExceptionClear(); } - VerifyOrReturnError(ofMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND); - outOptional = env->CallStaticObjectMethod(mOptionalClass, ofMethod, objectToWrap); + VerifyOrReturnError(ofMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND); + outOptional = env->CallStaticObjectMethod(optionalCls, ofMethod, objectToWrap); VerifyOrReturnError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN); @@ -287,12 +252,13 @@ CHIP_ERROR JniReferences::CreateOptional(jobject objectToWrap, jobject & outOpti CHIP_ERROR JniReferences::GetOptionalValue(jobject optionalObj, jobject & optionalValue) { - VerifyOrReturnError(mOptionalClass != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND); - - JNIEnv * const env = GetEnvForCurrentThread(); - VerifyOrReturnError(env != nullptr, CHIP_JNI_ERROR_NO_ENV); + JNIEnv * env = GetEnvForCurrentThread(); + jclass optionalCls; + chip::JniReferences::GetInstance().GetClassRef(env, "java/util/Optional", optionalCls); + VerifyOrReturnError(optionalCls != nullptr, CHIP_JNI_ERROR_TYPE_NOT_FOUND); + chip::JniClass jniClass(optionalCls); - jmethodID isPresentMethod = env->GetMethodID(mOptionalClass, "isPresent", "()Z"); + jmethodID isPresentMethod = env->GetMethodID(optionalCls, "isPresent", "()Z"); VerifyOrReturnError(isPresentMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND); jboolean isPresent = optionalObj && env->CallBooleanMethod(optionalObj, isPresentMethod); @@ -302,7 +268,7 @@ CHIP_ERROR JniReferences::GetOptionalValue(jobject optionalObj, jobject & option return CHIP_NO_ERROR; } - jmethodID getMethod = env->GetMethodID(mOptionalClass, "get", "()Ljava/lang/Object;"); + jmethodID getMethod = env->GetMethodID(optionalCls, "get", "()Ljava/lang/Object;"); VerifyOrReturnError(getMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND); optionalValue = env->CallObjectMethod(optionalObj, getMethod); return CHIP_NO_ERROR; diff --git a/src/lib/support/JniReferences.h b/src/lib/support/JniReferences.h index 4abef990822b0c..9a0fea52019040 100644 --- a/src/lib/support/JniReferences.h +++ b/src/lib/support/JniReferences.h @@ -190,12 +190,8 @@ class JniReferences jobject mClassLoader = nullptr; jmethodID mFindClassMethod = nullptr; - // These are global refs and therefore safe to persist. jclass mHashMapClass = nullptr; jclass mListClass = nullptr; jclass mArrayListClass = nullptr; - jclass mOptionalClass = nullptr; - - bool use_java8_optional = false; }; } // namespace chip