Add JNI Object wrapper and type conversion traits

This is the first in a series of commits that aims to convert our JNI usage to
a more modern approach while still remaining STLPort compatible.

PiperOrigin-RevId: 321059370

Author: wilhuff

app/src/include/firebase/internal/type_traits.h

@@ -85,6 +85,9 @@ struct is_lvalue_reference<T&> {
 template <typename T>
 using decay = FIREBASE_TYPE_TRAITS_NS::decay<T>;
 
+template <typename T>
+using decay_t = typename decay<T>::type;
+
 template <bool value, typename T = void>
 using enable_if = FIREBASE_TYPE_TRAITS_NS::enable_if<value, T>;
 
@@ -100,6 +103,9 @@ using is_same = FIREBASE_TYPE_TRAITS_NS::is_same<T, U>;
 template <typename T, T value>
 using integral_constant = FIREBASE_TYPE_TRAITS_NS::integral_constant<T, value>;
 
+using true_type = FIREBASE_TYPE_TRAITS_NS::true_type;
+using false_type = FIREBASE_TYPE_TRAITS_NS::false_type;
+
 #undef FIREBASE_TYPE_TRAITS_NS
 
 // `is_char<T>::value` is true iff `T` is a character type (including `wchar_t`

firestore/src/jni/object.cc

@@ -0,0 +1,15 @@
+#include "firestore/src/jni/object.h"
+
+#include "app/src/util_android.h"
+
+namespace firebase {
+namespace firestore {
+namespace jni {
+
+std::string Object::ToString(JNIEnv* env) const {
+  return util::JniObjectToString(env, object_);
+}
+
+}  // namespace jni
+}  // namespace firestore
+}  // namespace firebase

firestore/src/jni/object.h

@@ -0,0 +1,51 @@
+#ifndef FIREBASE_FIRESTORE_CLIENT_CPP_SRC_JNI_OBJECT_H_
+#define FIREBASE_FIRESTORE_CLIENT_CPP_SRC_JNI_OBJECT_H_
+
+#include <jni.h>
+
+#include <string>
+
+namespace firebase {
+namespace firestore {
+namespace jni {
+
+/**
+ * A wrapper for a JNI `jobject` that adds additional behavior.
+ *
+ * `Object` merely holds values with `jobject` types, see `Local` and `Global`
+ * template subclasses for reference-type-aware wrappers that automatically
+ * manage the lifetime of JNI objects.
+ */
+class Object {
+ public:
+  Object() = default;
+  explicit Object(jobject object) : object_(object) {}
+  virtual ~Object() = default;
+
+  explicit operator bool() const { return object_ != nullptr; }
+
+  virtual jobject get() const { return object_; }
+
+  /**
+   * Converts this object to a C++ String by calling the Java `toString` method
+   * on it.
+   */
+  std::string ToString(JNIEnv* env) const;
+
+ protected:
+  jobject object_ = nullptr;
+};
+
+inline bool operator==(const Object& lhs, const Object& rhs) {
+  return lhs.get() == rhs.get();
+}
+
+inline bool operator!=(const Object& lhs, const Object& rhs) {
+  return !(lhs == rhs);
+}
+
+}  // namespace jni
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // FIREBASE_FIRESTORE_CLIENT_CPP_SRC_JNI_OBJECT_H_

firestore/src/jni/traits.h

@@ -0,0 +1,97 @@
+#ifndef FIREBASE_FIRESTORE_CLIENT_CPP_SRC_JNI_TRAITS_H_
+#define FIREBASE_FIRESTORE_CLIENT_CPP_SRC_JNI_TRAITS_H_
+
+#include <jni.h>
+
+#include "app/src/include/firebase/internal/type_traits.h"
+
+namespace firebase {
+namespace firestore {
+namespace jni {
+
+class Object;
+
+// clang-format off
+
+// MARK: Primitive and Reference Type traits
+
+template <typename T> struct IsPrimitive : public false_type {};
+template <> struct IsPrimitive<jboolean> : public true_type {};
+template <> struct IsPrimitive<jbyte> : public true_type {};
+template <> struct IsPrimitive<jchar> : public true_type {};
+template <> struct IsPrimitive<jshort> : public true_type {};
+template <> struct IsPrimitive<jint> : public true_type {};
+template <> struct IsPrimitive<jlong> : public true_type {};
+template <> struct IsPrimitive<jfloat> : public true_type {};
+template <> struct IsPrimitive<jdouble> : public true_type {};
+
+template <typename T> struct IsReference : public false_type {};
+template <> struct IsReference<jclass> : public true_type {};
+template <> struct IsReference<jobject> : public true_type {};
+template <> struct IsReference<jstring> : public true_type {};
+template <> struct IsReference<jthrowable> : public true_type {};
+template <> struct IsReference<jbyteArray> : public true_type {};
+template <> struct IsReference<jobjectArray> : public true_type {};
+
+
+// MARK: Type mapping
+
+// A compile-time map from C++ types to their JNI equivalents.
+template <typename T> struct JniTypeMap {};
+template <> struct JniTypeMap<bool> { using type = jboolean; };
+template <> struct JniTypeMap<uint8_t> { using type = jbyte; };
+template <> struct JniTypeMap<uint16_t> { using type = jchar; };
+template <> struct JniTypeMap<int16_t> { using type = jshort; };
+template <> struct JniTypeMap<int32_t> { using type = jint; };
+template <> struct JniTypeMap<int64_t> { using type = jlong; };
+template <> struct JniTypeMap<float> { using type = jfloat; };
+template <> struct JniTypeMap<double> { using type = jdouble; };
+template <> struct JniTypeMap<size_t> { using type = jsize; };
+
+template <> struct JniTypeMap<jobject> { using type = jobject; };
+
+template <> struct JniTypeMap<Object> { using type = jobject; };
+
+template <typename T>
+using JniType = typename JniTypeMap<decay_t<T>>::type;
+
+// clang-format on
+
+// MARK: Enable If Helpers
+
+template <typename T, typename R = T>
+using EnableForPrimitive =
+    typename enable_if<IsPrimitive<JniType<T>>::value, R>::type;
+
+template <typename T, typename R = T>
+using EnableForReference =
+    typename enable_if<IsReference<JniType<T>>::value, R>::type;
+
+// MARK: Type converters
+
+// Converts C++ primitives to their equivalent JNI primitive types by casting.
+template <typename T>
+EnableForPrimitive<T, JniType<T>> ToJni(const T& value) {
+  return static_cast<JniType<T>>(value);
+}
+
+// Converts JNI wrapper reference types (like `const Object&`) and any ownership
+// wrappers of those types to their underlying `jobject`-derived reference.
+template <typename T>
+EnableForReference<T, JniType<T>> ToJni(const T& value) {
+  return value.get();
+}
+template <typename T, typename J = typename T::jni_type>
+J ToJni(const T& value) {
+  return value.get();
+}
+
+// Preexisting JNI types can be passed directly. This makes incremental
+// migration possible. Ideally this could eventually be removed.
+inline jobject ToJni(jobject value) { return value; }
+
+}  // namespace jni
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // FIREBASE_FIRESTORE_CLIENT_CPP_SRC_JNI_TRAITS_H_

firestore/src/tests/jni/object_test.cc

@@ -0,0 +1,31 @@
+#include "firestore/src/jni/object.h"
+
+#include <jni.h>
+
+#include "firestore/src/tests/firestore_integration_test.h"
+#include "gtest/gtest.h"
+
+namespace firebase {
+namespace firestore {
+namespace jni {
+
+class ObjectTest : public FirestoreIntegrationTest {
+ public:
+  ObjectTest() : env_(app()->GetJNIEnv()) {}
+
+ protected:
+  JNIEnv* env_ = nullptr;
+};
+
+TEST_F(ObjectTest, ToString) {
+  jclass string_class = env_->FindClass("java/lang/String");
+  Object wrapper(string_class);
+
+  // java.lang.Class defines its toString output as having this form.
+  EXPECT_EQ("class java.lang.String", wrapper.ToString(env_));
+  env_->DeleteLocalRef(string_class);
+}
+
+}  // namespace jni
+}  // namespace firestore
+}  // namespace firebase

firestore/src/tests/jni/traits_test.cc

@@ -0,0 +1,73 @@
+#include "firestore/src/jni/traits.h"
+
+#include <jni.h>
+
+#include <limits>
+
+#include "firestore/src/jni/object.h"
+#include "firestore/src/tests/firestore_integration_test.h"
+#include "gtest/gtest.h"
+
+namespace firebase {
+namespace firestore {
+namespace jni {
+
+using testing::StaticAssertTypeEq;
+
+using TraitsTest = FirestoreIntegrationTest;
+
+template <typename C, typename J>
+void ExpectConvertsPrimitive() {
+  static_assert(sizeof(C) >= sizeof(J),
+                "Java types should never be bigger than C++ equivalents");
+
+  // Some C++ types (notably size_t) have a size that is not fixed. Use the
+  // maximum value supported by the Java type for testing.
+  C cpp_value = static_cast<C>(std::numeric_limits<J>::max());
+  J jni_value = ToJni(cpp_value);
+  EXPECT_EQ(jni_value, static_cast<J>(cpp_value));
+}
+
+TEST_F(TraitsTest, ConvertsPrimitives) {
+  ExpectConvertsPrimitive<bool, jboolean>();
+  ExpectConvertsPrimitive<uint8_t, jbyte>();
+  ExpectConvertsPrimitive<uint16_t, jchar>();
+  ExpectConvertsPrimitive<int16_t, jshort>();
+  ExpectConvertsPrimitive<int32_t, jint>();
+  ExpectConvertsPrimitive<int64_t, jlong>();
+  ExpectConvertsPrimitive<float, jfloat>();
+  ExpectConvertsPrimitive<double, jdouble>();
+  ExpectConvertsPrimitive<size_t, jsize>();
+}
+
+TEST_F(TraitsTest, ConvertsObjects) {
+  Object cpp_value;
+  jobject jni_value = ToJni(cpp_value);
+  EXPECT_EQ(jni_value, nullptr);
+
+  jobject jobject_value = nullptr;
+  jni_value = ToJni(jobject_value);
+  EXPECT_EQ(jni_value, nullptr);
+
+  jni_value = ToJni(nullptr);
+  EXPECT_EQ(jni_value, nullptr);
+}
+
+// Conversion implicitly tests type mapping. Additionally test variations of
+// types that should be equivalent.
+TEST_F(TraitsTest, DecaysBeforeMappingTypes) {
+  StaticAssertTypeEq<JniType<int32_t>, jint>();
+  StaticAssertTypeEq<JniType<const int32_t>, jint>();
+
+  StaticAssertTypeEq<JniType<jobject>, jobject>();
+  StaticAssertTypeEq<JniType<const jobject>, jobject>();
+
+  StaticAssertTypeEq<JniType<Object>, jobject>();
+  StaticAssertTypeEq<JniType<const Object>, jobject>();
+  StaticAssertTypeEq<JniType<const Object&>, jobject>();
+  StaticAssertTypeEq<JniType<Object&&>, jobject>();
+}
+
+}  // namespace jni
+}  // namespace firestore
+}  // namespace firebase