Moved JObjectReference out of util_android.{cc,h}

smiles · a-maurice · commit 78a90d6d35d6 · 2019-09-10T18:17:44.000-07:00
PiperOrigin-RevId: 266024720
diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt
@@ -85,6 +85,7 @@ build_flatbuffers("${CMAKE_CURRENT_LIST_DIR}/google_services.fbs"
 set(log_common_SRCS
     src/log.cc)
 set(log_android_SRCS
+    src/jobject_reference.cc
     src/log_android.cc
     src/log_android_callback.cc
     src/util_android.cc)
diff --git a/app/src/app_android.cc b/app/src/app_android.cc
@@ -24,6 +24,7 @@
 #include "app/src/google_play_services/availability_android.h"
 #include "app/src/include/firebase/app.h"
 #include "app/src/include/firebase/version.h"
+#include "app/src/jobject_reference.h"
 #include "app/src/log.h"
 #include "app/src/util.h"
 #include "app/src/util_android.h"
diff --git a/app/src/jobject_reference.cc b/app/src/jobject_reference.cc
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "app/src/jobject_reference.h"
+
+#include <jni.h>
+
+#include "app/src/assert.h"
+// util_android.h is included for GetThreadsafeJNIEnv()
+#include "app/src/util_android.h"
+
+namespace FIREBASE_NAMESPACE {
+namespace internal {
+
+JObjectReference::JObjectReference() : java_vm_(nullptr), object_(nullptr) {}
+
+JObjectReference::JObjectReference(JNIEnv* env)
+    : java_vm_(GetJavaVM(env)), object_(nullptr) {}
+
+JObjectReference::JObjectReference(JNIEnv* env, jobject object) {
+  Initialize(GetJavaVM(env), env, object);
+}
+
+JObjectReference::JObjectReference(const JObjectReference& reference) {
+  Initialize(reference.java_vm_, reference.GetJNIEnv(), reference.object());
+}
+
+#ifdef FIREBASE_USE_MOVE_OPERATORS
+JObjectReference::JObjectReference(JObjectReference&& reference) {
+  operator=(std::move(reference));
+}
+#endif  // FIREBASE_USE_MOVE_OPERATORS
+
+JObjectReference::~JObjectReference() { Set(nullptr); }
+
+JObjectReference& JObjectReference::operator=(
+    const JObjectReference& reference) {
+  Set(reference.GetJNIEnv(), reference.object_);
+  return *this;
+}
+
+#ifdef FIREBASE_USE_MOVE_OPERATORS
+JObjectReference& JObjectReference::operator=(JObjectReference&& reference) {
+  java_vm_ = reference.java_vm_;
+  object_ = reference.object_;
+  reference.java_vm_ = nullptr;
+  reference.object_ = nullptr;
+  return *this;
+}
+#endif  // FIREBASE_USE_MOVE_OPERATORS
+
+void JObjectReference::Set(jobject jobject_reference) {
+  JNIEnv* env = GetJNIEnv();
+  if (env && object_) env->DeleteGlobalRef(object_);
+  object_ = nullptr;
+  Initialize(java_vm_, env, jobject_reference);
+}
+
+void JObjectReference::Set(JNIEnv* env, jobject jobject_reference) {
+  if (env && object_) env->DeleteGlobalRef(object_);
+  object_ = nullptr;
+  Initialize(GetJavaVM(env), env, jobject_reference);
+}
+
+JNIEnv* JObjectReference::GetJNIEnv() const {
+  return java_vm_ ? util::GetThreadsafeJNIEnv(java_vm_) : nullptr;
+}
+
+jobject JObjectReference::GetLocalRef() const {
+  JNIEnv* env = GetJNIEnv();
+  return object_ && env ? env->NewLocalRef(object_) : nullptr;
+}
+
+JObjectReference JObjectReference::FromLocalReference(JNIEnv* env,
+                                                      jobject local_reference) {
+  JObjectReference jobject_reference = JObjectReference(env, local_reference);
+  if (local_reference) env->DeleteLocalRef(local_reference);
+  return jobject_reference;
+}
+
+void JObjectReference::Initialize(JavaVM* jvm, JNIEnv* env,
+                                  jobject jobject_reference) {
+  FIREBASE_DEV_ASSERT(env || !jobject_reference);
+  java_vm_ = jvm;
+  object_ = nullptr;
+  if (jobject_reference) object_ = env->NewGlobalRef(jobject_reference);
+}
+
+JavaVM* JObjectReference::GetJavaVM(JNIEnv* env) {
+  JavaVM* jvm;
+  jint result = env->GetJavaVM(&jvm);
+  assert(result == JNI_OK);
+  return jvm;
+}
+
+}  // namespace internal
+}  // namespace FIREBASE_NAMESPACE
diff --git a/app/src/jobject_reference.h b/app/src/jobject_reference.h
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef FIREBASE_APP_CLIENT_CPP_SRC_JOBJECT_REFERENCE_H_
+#define FIREBASE_APP_CLIENT_CPP_SRC_JOBJECT_REFERENCE_H_
+
+#include <jni.h>
+
+#include "app/src/include/firebase/internal/common.h"
+
+#if !defined(FIREBASE_NAMESPACE)
+#define FIREBASE_NAMESPACE firebase
+#endif
+
+namespace FIREBASE_NAMESPACE {
+namespace internal {
+
+// Creates an alias of internal::JObjectReference named classname.
+// This is useful when defining the implementation of a forward declared class
+// using JObjectReference.
+#define JOBJECT_REFERENCE(classname)                                          \
+  class classname : public FIREBASE_NAMESPACE::internal::JObjectReference {   \
+   public:                                                                    \
+     explicit classname(JNIEnv *env) :                                        \
+         FIREBASE_NAMESPACE::internal::JObjectReference(env) {}               \
+     explicit classname(                                                      \
+         const FIREBASE_NAMESPACE::internal::JObjectReference& obj) :         \
+         FIREBASE_NAMESPACE::internal::JObjectReference(obj) {}               \
+     explicit classname(                                                      \
+           FIREBASE_NAMESPACE::internal::JObjectReference&& obj) :            \
+         FIREBASE_NAMESPACE::internal::JObjectReference(obj) {}               \
+     classname(JNIEnv *env, jobject obj) :                                    \
+         FIREBASE_NAMESPACE::internal::JObjectReference(env, obj) {}          \
+     classname& operator=(                                                    \
+         const FIREBASE_NAMESPACE::internal::JObjectReference& rhs) {         \
+       FIREBASE_NAMESPACE::internal::JObjectReference::operator=(rhs);        \
+       return *this;                                                          \
+     }                                                                        \
+     classname& operator=(                                                    \
+           FIREBASE_NAMESPACE::internal::JObjectReference&& rhs) {            \
+       FIREBASE_NAMESPACE::internal::JObjectReference::operator=(rhs);        \
+       return *this;                                                          \
+     }                                                                        \
+  }
+
+// Creates and holds a global reference to a Java object.
+class JObjectReference {
+ public:
+  JObjectReference();
+  explicit JObjectReference(JNIEnv* env);
+  // Create a reference to a java object.
+  JObjectReference(JNIEnv* env, jobject object);
+  // Copy
+  JObjectReference(const JObjectReference& reference);
+  // Move
+#ifdef FIREBASE_USE_MOVE_OPERATORS
+  JObjectReference(JObjectReference&& reference);
+#endif  // FIREBASE_USE_MOVE_OPERATORS
+  // Delete the reference to the java object.
+  ~JObjectReference();
+  // Copy this reference.
+  JObjectReference& operator=(const JObjectReference& reference);
+  // Move this reference.
+#ifdef FIREBASE_USE_MOVE_OPERATORS
+  JObjectReference& operator=(JObjectReference&& reference);
+#endif  // FIREBASE_USE_MOVE_OPERATORS
+
+  // Add a global reference to the specified object, removing the reference
+  // to the object currently referenced by this class.  If jobject_reference
+  // is null, the existing reference is removed.
+  void Set(jobject jobject_reference);
+
+  void Set(JNIEnv* env, jobject jobject_reference);
+
+  // Get a JNIEnv from the JavaVM associated with this class.
+  JNIEnv* GetJNIEnv() const;
+
+  // Get the JavaVM associated with this class.
+  JavaVM* java_vm() const { return java_vm_; }
+
+  // Get the global reference to the Java object without incrementing the
+  // reference count.
+  jobject object() const { return object_; }
+
+  // Get a local reference to the object. The returned reference must be
+  // deleted after use with DeleteLocalRef().
+  jobject GetLocalRef() const;
+
+  // Same as object()
+  jobject operator*() const { return object(); }
+
+  // Convert a local reference to a JObjectReference, deleting the local
+  // reference.
+  static JObjectReference FromLocalReference(JNIEnv* env,
+                                             jobject local_reference);
+
+ private:
+  // Initialize this instance by adding a reference to the specified Java
+  // object.
+  void Initialize(JavaVM* jvm, JNIEnv* env, jobject jobject_reference);
+  // Get JavaVM from a JNIEnv.
+  static JavaVM* GetJavaVM(JNIEnv* env);
+
+ private:
+  JavaVM* java_vm_;
+  jobject object_;
+};
+
+}  // namespace internal
+}  // namespace FIREBASE_NAMESPACE
+
+#endif  // FIREBASE_APP_CLIENT_CPP_SRC_JOBJECT_REFERENCE_H_
diff --git a/app/src/util_android.cc b/app/src/util_android.cc
@@ -1295,78 +1295,6 @@ JNIEXPORT void JNICALL JniResultCallback_nativeOnResult(
               status_message_c.c_str(), user_callback_data);
 }
 
-JObjectReference::JObjectReference(JNIEnv* env)
-    : java_vm_(GetJavaVM(env)), object_(nullptr) {}
-
-JObjectReference::JObjectReference(JNIEnv* env, jobject object) {
-  Initialize(GetJavaVM(env), env, object);
-}
-
-JObjectReference::JObjectReference(const JObjectReference& reference) {
-  Initialize(reference.java_vm_, reference.GetJNIEnv(), reference.object());
-}
-
-#ifdef FIREBASE_USE_MOVE_OPERATORS
-JObjectReference::JObjectReference(JObjectReference&& reference) {
-  operator=(std::move(reference));
-}
-#endif  // FIREBASE_USE_MOVE_OPERATORS
-
-JObjectReference::~JObjectReference() { Set(nullptr); }
-
-JObjectReference& JObjectReference::operator=(
-    const JObjectReference& reference) {
-  Set(reference.object_);
-  return *this;
-}
-
-#ifdef FIREBASE_USE_MOVE_OPERATORS
-JObjectReference& JObjectReference::operator=(JObjectReference&& reference) {
-  java_vm_ = reference.java_vm_;
-  object_ = reference.object_;
-  return *this;
-}
-#endif  // FIREBASE_USE_MOVE_OPERATORS
-
-void JObjectReference::Set(jobject jobject_reference) {
-  JNIEnv* env = GetJNIEnv();
-  if (object_) {
-    env->DeleteGlobalRef(object_);
-    object_ = nullptr;
-  }
-  Initialize(java_vm_, env, jobject_reference);
-}
-
-JNIEnv* JObjectReference::GetJNIEnv() const {
-  return GetThreadsafeJNIEnv(java_vm_);
-}
-
-jobject JObjectReference::GetLocalRef() const {
-  JNIEnv* env = GetJNIEnv();
-  return object_ ? env->NewLocalRef(object_) : nullptr;
-}
-
-JObjectReference JObjectReference::FromLocalReference(JNIEnv* env,
-                                                      jobject local_reference) {
-  JObjectReference jobject_reference = JObjectReference(env, local_reference);
-  if (local_reference) env->DeleteLocalRef(local_reference);
-  return jobject_reference;
-}
-
-void JObjectReference::Initialize(JavaVM* jvm, JNIEnv* env,
-                                  jobject jobject_reference) {
-  java_vm_ = jvm;
-  object_ = nullptr;
-  if (jobject_reference) object_ = env->NewGlobalRef(jobject_reference);
-}
-
-JavaVM* JObjectReference::GetJavaVM(JNIEnv* env) {
-  JavaVM* jvm;
-  jint result = env->GetJavaVM(&jvm);
-  assert(result == JNI_OK);
-  return jvm;
-}
-
 // Call a C++ function pointer, passing in a given data pointer. This is called
 // by the CppThreadDispatcher Java class, which uses the Java long type to
 // contain C++ pointers.
diff --git a/app/src/util_android.h b/app/src/util_android.h
