Convert FirestoreInternal to the new JNI framework

This converts all method invocations but does not necessarily convert all uses
of older APIs because those are still needed to support classes that have not
yet converted.

PiperOrigin-RevId: 333429091

Author: wilhuff

firestore/src/android/document_reference_android.cc

@@ -174,8 +174,10 @@ ListenerRegistration DocumentReferenceInternal::AddSnapshotListener(
       env.Call(obj_, kAddSnapshotListener, firestore_->user_callback_executor(),
                java_metadata, java_listener);
 
-  return firestore_->NewListenerRegistration(
-      env, listener, passing_listener_ownership, java_registration);
+  if (!env.ok() || !java_registration) return {};
+  return ListenerRegistration(new ListenerRegistrationInternal(
+      firestore_, listener, passing_listener_ownership,
+      java_registration.get()));
 }
 
 Class DocumentReferenceInternal::GetClass() { return Class(clazz); }

firestore/src/android/event_listener_android.cc

@@ -155,6 +155,12 @@ jobject EventListenerInternal::EventListenerToJavaEventListener(
   return result;
 }
 
+Local<Object> EventListenerInternal::Create(Env& env,
+                                            EventListener<void>* listener) {
+  return Local<Object>(env.get(),
+                       EventListenerToJavaRunnable(env.get(), listener));
+}
+
 /* static */
 jobject EventListenerInternal::EventListenerToJavaRunnable(
     JNIEnv* env, EventListener<void>* listener) {

firestore/src/android/event_listener_android.h

@@ -41,6 +41,9 @@ class EventListenerInternal {
       JNIEnv* env, FirestoreInternal* firestore,
       EventListener<QuerySnapshot>* listener);
 
+  static jni::Local<jni::Object> Create(jni::Env& env,
+                                        EventListener<void>* listener);
+
   static jobject EventListenerToJavaRunnable(JNIEnv* env,
                                              EventListener<void>* listener);
 

firestore/src/android/firestore_android.cc

@@ -13,12 +13,14 @@
 #include "app/src/cleanup_notifier.h"
 #include "app/src/future_manager.h"
 #include "app/src/include/firebase/app.h"
-#include "app/src/util_android.h"
-#include "firestore/src/android/listener_registration_android.h"
+#include "firestore/src/common/type_mapping.h"
 #include "firestore/src/include/firebase/firestore/collection_reference.h"
 #include "firestore/src/include/firebase/firestore/document_reference.h"
 #include "firestore/src/include/firebase/firestore/settings.h"
+#include "firestore/src/jni/env.h"
 #include "firestore/src/jni/jni_fwd.h"
+#include "firestore/src/jni/object.h"
+#include "firestore/src/jni/ownership.h"
 
 namespace firebase {
 namespace firestore {
@@ -29,31 +31,34 @@ class Transaction;
 class TransactionFunction;
 class WriteBatch;
 
+template <typename PublicType, typename InternalType, typename FnEnumType>
+class Promise;
+
 // Used for registering global callbacks. See
 // firebase::util::RegisterCallbackOnTask for context.
 extern const char kApiIdentifier[];
 
-// Each API of Firestore that returns a Future needs to define an enum
-// value here. For example, a Future-returning method Foo() relies on the enum
-// value kFoo. The enum values are used to identify and manage Future in the
-// Firestore Future manager.
-enum class FirestoreFn {
-  kEnableNetwork = 0,
-  kDisableNetwork,
-  kRunTransaction,
-  kTerminate,
-  kWaitForPendingWrites,
-  kClearPersistence,
-  kCount,  // Must be the last enum value.
-};
-
 // This is the Android implementation of Firestore. Cannot inherit WrapperFuture
 // as a valid FirestoreInternal is required to construct a WrapperFuture. So we
 // will implement the Future APIs on the fly.
 class FirestoreInternal {
  public:
   using ApiType = Firestore;
 
+  // Each API of Firestore that returns a Future needs to define an enum
+  // value here. For example, a Future-returning method Foo() relies on the enum
+  // value kFoo. The enum values are used to identify and manage Future in the
+  // Firestore Future manager.
+  enum class AsyncFn {
+    kEnableNetwork = 0,
+    kDisableNetwork,
+    kRunTransaction,
+    kTerminate,
+    kWaitForPendingWrites,
+    kClearPersistence,
+    kCount,  // Must be the last enum value.
+  };
+
   // Note: call `set_firestore_public` immediately after construction.
   explicit FirestoreInternal(App* app);
   ~FirestoreInternal();
@@ -120,18 +125,15 @@ class FirestoreInternal {
   void UnregisterListenerRegistration(
       ListenerRegistrationInternal* registration);
 
-  jni::Env GetEnv() const;
+  static jni::Env GetEnv();
 
-  CollectionReference NewCollectionReference(jni::Env& env,
-                                             const jni::Object& reference);
+  CollectionReference NewCollectionReference(
+      jni::Env& env, const jni::Object& reference) const;
   DocumentReference NewDocumentReference(jni::Env& env,
-                                         const jni::Object& reference);
+                                         const jni::Object& reference) const;
   DocumentSnapshot NewDocumentSnapshot(jni::Env& env,
-                                       const jni::Object& snapshot);
-  ListenerRegistration NewListenerRegistration(
-      jni::Env& env, EventListener<DocumentSnapshot>* listener,
-      bool passing_listener_ownership, const jni::Object& registration);
-  Query NewQuery(jni::Env& env, const jni::Object& query);
+                                       const jni::Object& snapshot) const;
+  Query NewQuery(jni::Env& env, const jni::Object& query) const;
 
   // The constructor explicit Foo(FooInternal*) is protected in public API.
   // But we want it to be public-usable in internal implementation code
@@ -159,7 +161,9 @@ class FirestoreInternal {
   Firestore* firestore_public() { return firestore_public_; }
   const Firestore* firestore_public() const { return firestore_public_; }
 
-  jobject user_callback_executor() const { return user_callback_executor_; }
+  const jni::Global<jni::Object>& user_callback_executor() const {
+    return user_callback_executor_;
+  }
 
   static void SetClientLanguage(const std::string& language_token);
 
@@ -170,25 +174,40 @@ class FirestoreInternal {
     return future_manager_.GetFutureApi(this);
   }
 
-  void ShutdownUserCallbackExecutor();
+  FirestoreInternal* mutable_this() const {
+    return const_cast<FirestoreInternal*>(this);
+  }
+
+  template <typename PublicT = void, typename InternalT = InternalType<PublicT>>
+  Future<PublicT> NewFuture(jni::Env& env, AsyncFn op,
+                            const jni::Object& task) const {
+    if (!env.ok()) return {};
+
+    FirestoreInternal* self = mutable_this();
+    Promise<PublicT, InternalT, AsyncFn> promise(self->ref_future(), self);
+    promise.RegisterForTask(env, op, task);
+    return promise.GetFuture();
+  }
+
+  void ShutdownUserCallbackExecutor(jni::Env& env);
 
   static bool Initialize(App* app);
   static void ReleaseClasses(App* app);
   static void Terminate(App* app);
 
   // Initialize classes loaded from embedded files.
-  static bool InitializeEmbeddedClasses(App* app);
+  static bool InitializeEmbeddedClasses(App* app, jni::Loader& loader);
 
   static Mutex init_mutex_;
   static int initialize_count_;
   static jni::Loader* loader_;
 
-  jobject user_callback_executor_;
+  jni::Global<jni::Object> user_callback_executor_;
 
   App* app_ = nullptr;
   Firestore* firestore_public_ = nullptr;
   // Java Firestore global ref.
-  jobject obj_;
+  jni::Global<jni::Object> obj_;
 
   Mutex listener_registration_mutex_;  // For registering listener-registrations
 #if defined(_STLPORT_VERSION)

firestore/src/android/firestore_android.h

@@ -25,7 +25,7 @@ namespace firestore {
  */
 class LambdaTransactionFunction
     : public TransactionFunction,
-      public Promise<void, void, FirestoreFn>::Completion<void> {
+      public Promise<void, void, FirestoreInternal::AsyncFn>::Completion<void> {
  public:
   LambdaTransactionFunction(
       std::function<Error(Transaction&, std::string&)> update)

firestore/src/android/lambda_transaction_function.h

@@ -9,6 +9,7 @@
 #include "firestore/src/android/field_value_android.h"
 #include "firestore/src/android/firestore_android.h"
 #include "firestore/src/android/lambda_event_listener.h"
+#include "firestore/src/android/listener_registration_android.h"
 #include "firestore/src/android/metadata_changes_android.h"
 #include "firestore/src/android/promise_android.h"
 #include "firestore/src/android/source_android.h"

firestore/src/android/query_android.cc

@@ -192,6 +192,12 @@ bool TransactionInternal::CheckAndClearJniExceptions() {
   return result;
 }
 
+Local<Object> TransactionInternal::Create(Env& env,
+                                          FirestoreInternal* firestore,
+                                          TransactionFunction* function) {
+  return Local<Object>(env.get(), ToJavaObject(env.get(), firestore, function));
+}
+
 /* static */
 jobject TransactionInternal::ToJavaObject(JNIEnv* env,
                                           FirestoreInternal* firestore,

firestore/src/android/transaction_android.cc

@@ -39,6 +39,10 @@ class TransactionInternal : public Wrapper {
   DocumentSnapshot Get(const DocumentReference& document, Error* error_code,
                        std::string* error_message);
 
+  static jni::Local<jni::Object> Create(jni::Env& env,
+                                        FirestoreInternal* firestore,
+                                        TransactionFunction* function);
+
   static jobject ToJavaObject(JNIEnv* env, FirestoreInternal* firestore,
                               TransactionFunction* function);
 

firestore/src/android/transaction_android.h

@@ -7,6 +7,7 @@
 #if defined(__ANDROID__)
 #include <jni.h>
 
+#include "app/src/util_android.h"
 #include "firestore/src/android/firestore_android.h"
 #elif defined(FIRESTORE_STUB_BUILD)
 #include "firestore/src/stub/firestore_stub.h"