Added macro to generate aliases of JObjectReference.

It can be useful to forward declare a platform specific handle class e.g
UserInternal and then define the class in terms of JObjectReference.

For example...

class UserInternal;

class User {
 protected:
   UserInternal *internal;
};

In Android specific code UserInternal can be declared using
JOBJECT_REFERENCE(UserInternal);

This removes the need to cast from void* to the platform specific type.

PiperOrigin-RevId: 264715554

Author: smiles

app/src/util_android.cc

@@ -29,6 +29,7 @@
 #include <map>
 #include <string>
 #include <vector>
+#include <utility>
 
 #include "app/app_resources.h"
 #include "app/src/app_common.h"
@@ -1295,16 +1296,22 @@ JNIEXPORT void JNICALL JniResultCallback_nativeOnResult(
 }
 
 JObjectReference::JObjectReference(JNIEnv* env)
-    : jvm_(GetJavaVM(env)), object_(nullptr) {}
+    : java_vm_(GetJavaVM(env)), object_(nullptr) {}
 
 JObjectReference::JObjectReference(JNIEnv* env, jobject object) {
   Initialize(GetJavaVM(env), env, object);
 }
 
 JObjectReference::JObjectReference(const JObjectReference& reference) {
-  Initialize(reference.jvm_, reference.GetJNIEnv(), reference.object());
+  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=(
@@ -1313,17 +1320,30 @@ JObjectReference& JObjectReference::operator=(
   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(jvm_, env, jobject_reference);
+  Initialize(java_vm_, env, jobject_reference);
 }
 
 JNIEnv* JObjectReference::GetJNIEnv() const {
-  return GetThreadsafeJNIEnv(jvm_);
+  return GetThreadsafeJNIEnv(java_vm_);
+}
+
+jobject JObjectReference::GetLocalRef() const {
+  JNIEnv* env = GetJNIEnv();
+  return object_ ? env->NewLocalRef(object_) : nullptr;
 }
 
 JObjectReference JObjectReference::FromLocalReference(JNIEnv* env,
@@ -1335,7 +1355,7 @@ JObjectReference JObjectReference::FromLocalReference(JNIEnv* env,
 
 void JObjectReference::Initialize(JavaVM* jvm, JNIEnv* env,
                                   jobject jobject_reference) {
-  jvm_ = jvm;
+  java_vm_ = jvm;
   object_ = nullptr;
   if (jobject_reference) object_ = env->NewGlobalRef(jobject_reference);
 }

app/src/util_android.h

@@ -732,10 +732,18 @@ class JObjectReference {
   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
@@ -745,10 +753,20 @@ class JObjectReference {
   // 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,
@@ -762,10 +780,34 @@ class JObjectReference {
   static JavaVM* GetJavaVM(JNIEnv* env);
 
  private:
-  JavaVM* jvm_;
+  JavaVM* java_vm_;
   jobject object_;
 };
 
+// Creates an alias of util::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::util::JObjectReference {           \
+   public:                                                              \
+     explicit classname(JNIEnv *env) :                                  \
+         firebase::util::JObjectReference(env) {}                       \
+     explicit classname(const firebase::util::JObjectReference& obj) :  \
+         firebase::util::JObjectReference(obj) {}                       \
+     explicit classname(firebase::util::JObjectReference&& obj) :       \
+         firebase::util::JObjectReference(obj) {}                       \
+     classname(JNIEnv *env, jobject obj) :                              \
+         util::JObjectReference(env, obj) {}                            \
+     classname& operator=(const util::JObjectReference& rhs) {          \
+       util::JObjectReference::operator=(rhs);                          \
+       return *this;                                                    \
+     }                                                                  \
+     classname& operator=(util::JObjectReference&& rhs) {               \
+       util::JObjectReference::operator=(rhs);                          \
+       return *this;                                                    \
+     }                                                                  \
+  }
+
 // Holds a reference to a Java thread that will execute a C++ method.
 //
 // To support cancelation (i.e. using ReleaseExecuteCancelLock() and