Revert "Update Java8 Optional handling in JniReferences (#30071)" (#30769)
This reverts commit 4e438d69c63d259dafdc3fc3bb1748d7de27e044.
diff --git a/src/lib/support/JniReferences.cpp b/src/lib/support/JniReferences.cpp
index b6919f8..f07837a 100644
--- a/src/lib/support/JniReferences.cpp
+++ b/src/lib/support/JniReferences.cpp
@@ -21,7 +21,6 @@
#include <lib/support/CodeUtils.h>
#include <lib/support/JniReferences.h>
#include <lib/support/JniTypeWrappers.h>
-#include <string>
namespace chip {
@@ -36,7 +35,7 @@
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 @@
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 @@
{
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 @@
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 @@
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 @@
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;");
+ ofMethod = env->GetStaticMethodID(optionalCls, "ofNullable", "(Ljava/lang/Object;)Lj$/util/Optional;");
+ env->ExceptionClear();
}
- else
- {
- ofMethod = env->GetStaticMethodID(mOptionalClass, "ofNullable", "(Ljava/lang/Object;)Lj$/util/Optional;");
- }
+
VerifyOrReturnError(ofMethod != nullptr, CHIP_JNI_ERROR_METHOD_NOT_FOUND);
-
- outOptional = env->CallStaticObjectMethod(mOptionalClass, ofMethod, objectToWrap);
+ outOptional = env->CallStaticObjectMethod(optionalCls, ofMethod, objectToWrap);
VerifyOrReturnError(!env->ExceptionCheck(), CHIP_JNI_ERROR_EXCEPTION_THROWN);
@@ -287,12 +252,13 @@
CHIP_ERROR JniReferences::GetOptionalValue(jobject optionalObj, jobject & optionalValue)
{
- 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 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 @@
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 4abef99..9a0fea5 100644
--- a/src/lib/support/JniReferences.h
+++ b/src/lib/support/JniReferences.h
@@ -190,12 +190,8 @@
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
