Add initial Env with minimal support for Strings

PiperOrigin-RevId: 321475293

Author: wilhuff

firestore/src/jni/env.cc

@@ -0,0 +1,43 @@
+#include "firestore/src/jni/env.h"
+
+namespace firebase {
+namespace firestore {
+namespace jni {
+
+Local<String> Env::NewStringUtf(const char* bytes) {
+  if (!ok()) return {};
+
+  jstring result = env_->NewStringUTF(bytes);
+  RecordException();
+  return Local<String>(env_, result);
+}
+
+std::string Env::GetStringUtfRegion(jstring string, size_t start, size_t len) {
+  if (!ok()) return "";
+
+  // Copy directly into the std::string buffer. This is guaranteed to work as
+  // of C++11, and also happens to work with STLPort.
+  std::string result;
+  result.resize(len);
+
+  env_->GetStringUTFRegion(string, ToJni(start), ToJni(len), &result[0]);
+  RecordException();
+
+  // Ensure that if there was an exception, the contents of the buffer are
+  // disregarded.
+  if (!ok()) return "";
+  return result;
+}
+
+void Env::RecordException() {
+  if (last_exception_ || !env_->ExceptionCheck()) return;
+
+  env_->ExceptionDescribe();
+
+  last_exception_ = env_->ExceptionOccurred();
+  env_->ExceptionClear();
+}
+
+}  // namespace jni
+}  // namespace firestore
+}  // namespace firebase

firestore/src/jni/env.h

@@ -0,0 +1,87 @@
+#ifndef FIREBASE_FIRESTORE_CLIENT_CPP_SRC_JNI_ENV_H_
+#define FIREBASE_FIRESTORE_CLIENT_CPP_SRC_JNI_ENV_H_
+
+#include <jni.h>
+
+#include <string>
+
+#include "firestore/src/jni/object.h"
+#include "firestore/src/jni/ownership.h"
+#include "firestore/src/jni/string.h"
+#include "firestore/src/jni/traits.h"
+
+namespace firebase {
+namespace firestore {
+namespace jni {
+
+/**
+ * A wrapper around a JNIEnv pointer that makes dealing with JNI simpler in C++,
+ * by:
+ *
+ *   * Automatically converting arguments of C++ types to their JNI equivalents;
+ *   * handling C++ strings naturally;
+ *   * wrapping JNI references in `Local` RAII wrappers automatically; and
+ *   * simplifying error handling related to JNI calls (see below).
+ *
+ * Normally JNI requires that each call be followed by an explicit check to see
+ * if an exception happened. This is tedious and clutters the code. Instead,
+ * `Env` automatically checks for a JNI exception and short circuits any further
+ * calls. This means that JNI-intensive code can be written straightforwardly
+ * with a single, final check for errors. Exceptions can still be handled
+ * inline if required.
+ */
+class Env {
+ public:
+  Env() : env_(GetEnv()) {}
+
+  explicit Env(JNIEnv* env) : env_(env) {}
+
+  /** Returns true if the Env has not encountered an exception. */
+  bool ok() const { return last_exception_ == nullptr; }
+
+  /** Returns the underlying JNIEnv pointer. */
+  JNIEnv* get() const { return env_; }
+
+  // MARK: String Operations
+
+  /**
+   * Creates a new proxy for a Java String from a sequences of modified UTF-8
+   * bytes.
+   */
+  Local<String> NewStringUtf(const char* bytes);
+  Local<String> NewStringUtf(const std::string& bytes) {
+    return NewStringUtf(bytes.c_str());
+  }
+
+  /** Returns the length of the string in modified UTF-8 bytes. */
+  size_t GetStringUtfLength(jstring string) {
+    jsize result = env_->GetStringUTFLength(string);
+    RecordException();
+    return static_cast<size_t>(result);
+  }
+  size_t GetStringUtfLength(const String& string) {
+    return GetStringUtfLength(string.get());
+  }
+
+  /**
+   * Copies the contents of a region of a Java string to a C++ string. The
+   * resulting string has a modified UTF-8 encoding.
+   */
+  std::string GetStringUtfRegion(jstring string, size_t start, size_t len);
+  std::string GetStringUtfRegion(const String& string, size_t start,
+                                 size_t len) {
+    return GetStringUtfRegion(string.get(), start, len);
+  }
+
+ private:
+  void RecordException();
+
+  JNIEnv* env_ = nullptr;
+  jthrowable last_exception_ = nullptr;
+};
+
+}  // namespace jni
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // FIREBASE_FIRESTORE_CLIENT_CPP_SRC_JNI_ENV_H_

firestore/src/jni/jni_fwd.h

@@ -10,6 +10,8 @@ namespace jni {
  */
 JNIEnv* GetEnv();
 
+class Env;
+
 // Reference types
 template <typename T>
 class Local;
@@ -19,6 +21,7 @@ template <typename T>
 class NonOwning;
 
 class Object;
+class String;
 
 }  // namespace jni
 }  // namespace firestore

firestore/src/jni/object.cc

@@ -1,6 +1,7 @@
 #include "firestore/src/jni/object.h"
 
 #include "app/src/util_android.h"
+#include "firestore/src/jni/env.h"
 
 namespace firebase {
 namespace firestore {
@@ -10,6 +11,8 @@ std::string Object::ToString(JNIEnv* env) const {
   return util::JniObjectToString(env, object_);
 }
 
+std::string Object::ToString(Env& env) const { return ToString(env.get()); }
+
 }  // namespace jni
 }  // namespace firestore
 }  // namespace firebase

firestore/src/jni/object.h

@@ -9,6 +9,8 @@ namespace firebase {
 namespace firestore {
 namespace jni {
 
+class Env;
+
 /**
  * A wrapper for a JNI `jobject` that adds additional behavior.
  *
@@ -31,6 +33,7 @@ class Object {
    * on it.
    */
   std::string ToString(JNIEnv* env) const;
+  std::string ToString(Env& env) const;
 
  protected:
   jobject object_ = nullptr;

firestore/src/jni/string.cc

@@ -0,0 +1,17 @@
+#include "firestore/src/jni/string.h"
+
+#include "firestore/src/jni/env.h"
+
+namespace firebase {
+namespace firestore {
+namespace jni {
+
+std::string String::ToString(Env& env) const {
+  jstring str = get();
+  size_t len = env.GetStringUtfLength(str);
+  return env.GetStringUtfRegion(str, 0, len);
+}
+
+}  // namespace jni
+}  // namespace firestore
+}  // namespace firebase

firestore/src/jni/string.h

@@ -0,0 +1,33 @@
+#ifndef FIREBASE_FIRESTORE_CLIENT_CPP_SRC_JNI_STRING_H_
+#define FIREBASE_FIRESTORE_CLIENT_CPP_SRC_JNI_STRING_H_
+
+#include "firestore/src/jni/object.h"
+
+namespace firebase {
+namespace firestore {
+namespace jni {
+
+/**
+ * A wrapper for a JNI `jstring` that adds additional behavior. This is a proxy
+ * for a Java String in the JVM.
+ *
+ * `String` merely holds values with `jstring` type, see `Local` and `Global`
+ * template subclasses for reference-type-aware wrappers that automatically
+ * manage the lifetime of JNI objects.
+ */
+class String : public Object {
+ public:
+  String() = default;
+  explicit String(jstring string) : Object(string) {}
+
+  jstring get() const override { return static_cast<jstring>(object_); }
+
+  /** Converts this Java String to a C++ string. */
+  std::string ToString(Env& env) const;
+};
+
+}  // namespace jni
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // FIREBASE_FIRESTORE_CLIENT_CPP_SRC_JNI_STRING_H_

firestore/src/jni/traits.h

@@ -48,8 +48,10 @@ 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<jstring> { using type = jstring; };
 
 template <> struct JniTypeMap<Object> { using type = jobject; };
+template <> struct JniTypeMap<String> { using type = jstring; };
 
 template <typename T>
 using JniType = typename JniTypeMap<decay_t<T>>::type;

firestore/src/tests/jni/env_test.cc

@@ -0,0 +1,54 @@
+#include "firestore/src/jni/env.h"
+
+#include "firestore/src/tests/firestore_integration_test.h"
+#include "gtest/gtest.h"
+
+namespace firebase {
+namespace firestore {
+namespace jni {
+
+class EnvTest : public FirestoreIntegrationTest {
+ public:
+  EnvTest() : env_(GetEnv()) {}
+
+ protected:
+  Env env_;
+};
+
+#if __cpp_exceptions
+TEST_F(EnvTest, ToolchainSupportsThrowingFromDestructors) {
+  class ThrowsInDestructor {
+   public:
+    ~ThrowsInDestructor() noexcept(false) { throw std::exception(); }
+  };
+
+  try {
+    { ThrowsInDestructor obj; }
+    FAIL() << "Should have thrown";
+  } catch (const std::exception& e) {
+    SUCCEED() << "Caught exception";
+  }
+}
+#endif  // __cpp_exceptions
+
+TEST_F(EnvTest, GetStringUtfLength) {
+  Local<String> str = env_.NewStringUtf("Foo");
+  size_t len = env_.GetStringUtfLength(str);
+  EXPECT_EQ(3, len);
+}
+
+TEST_F(EnvTest, GetStringUtfRegion) {
+  Local<String> str = env_.NewStringUtf("Foo");
+  std::string result = env_.GetStringUtfRegion(str, 1, 2);
+  EXPECT_EQ("oo", result);
+}
+
+TEST_F(EnvTest, ToString) {
+  Local<String> str = env_.NewStringUtf("Foo");
+  std::string result = str.ToString(env_);
+  EXPECT_EQ("Foo", result);
+}
+
+}  // namespace jni
+}  // namespace firestore
+}  // namespace firebase