Merge remote-tracking branch 'origin/master' into ghm

Author: a-maurice

CMakeLists.txt

@@ -45,6 +45,9 @@ option(FIREBASE_INCLUDE_FIRESTORE
 option(FIREBASE_INCLUDE_FUNCTIONS
        "Include the Cloud Functions for Firebase library."
        ${FIREBASE_INCLUDE_LIBRARY_DEFAULT})
+option(FIREBASE_INCLUDE_INSTALLATIONS
+       "Include the Firebase Installations library."
+       ${FIREBASE_INCLUDE_LIBRARY_DEFAULT})
 option(FIREBASE_INCLUDE_INSTANCE_ID
        "Include the Firebase Instance ID library."
        ${FIREBASE_INCLUDE_LIBRARY_DEFAULT})
@@ -428,6 +431,9 @@ endif()
 if (FIREBASE_INCLUDE_FUNCTIONS)
   add_subdirectory(functions)
 endif()
+if (FIREBASE_INCLUDE_INSTALLATIONS)
+  add_subdirectory(installations)
+endif()
 if (FIREBASE_INCLUDE_INSTANCE_ID)
   add_subdirectory(instance_id)
 endif()

firestore/src/android/document_snapshot_android.cc

@@ -85,6 +85,13 @@ MapFieldValue DocumentSnapshotInternal::GetData(
   Env env = GetEnv();
   Local<Object> java_stb = ServerTimestampBehaviorInternal::Create(env, stb);
   Local<Object> java_data = env.Call(obj_, kGetData, java_stb);
+
+  if (!java_data) {
+    // If the document doesn't exist, Android returns a null Map. In C++, the
+    // map is returned by value, so translate this case to an empty map.
+    return MapFieldValue();
+  }
+
   return FieldValueInternal(java_data).map_value();
 }
 

firestore/src/android/firestore_android.cc

@@ -25,7 +25,7 @@
 #include "firestore/src/android/lambda_transaction_function.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/promise_factory_android.h"
 #include "firestore/src/android/query_android.h"
 #include "firestore/src/android/query_snapshot_android.h"
 #include "firestore/src/android/server_timestamp_behavior_android.h"
@@ -213,7 +213,7 @@ FirestoreInternal::FirestoreInternal(App* app) {
   FIREBASE_ASSERT(java_user_callback_executor.get() != nullptr);
   user_callback_executor_ = java_user_callback_executor;
 
-  future_manager_.AllocFutureApi(this, static_cast<int>(AsyncFn::kCount));
+  promises_ = MakeUnique<PromiseFactory<AsyncFn>>(this);
 }
 
 /* static */
@@ -314,7 +314,7 @@ FirestoreInternal::~FirestoreInternal() {
   Env env = GetEnv();
   ShutdownUserCallbackExecutor(env);
 
-  future_manager_.ReleaseFutureApi(this);
+  promises_.reset(nullptr);
 
   java_firestores_->Remove(env, obj_);
 
@@ -378,13 +378,11 @@ Future<void> FirestoreInternal::RunTransaction(TransactionFunction* update,
 #if defined(FIREBASE_USE_STD_FUNCTION) || defined(DOXYGEN)
   auto* completion =
       static_cast<LambdaTransactionFunction*>(is_lambda ? update : nullptr);
-  Promise<void, void, AsyncFn> promise(ref_future(), this, completion);
+  return promises_->NewFuture<void>(env, AsyncFn::kRunTransaction, task,
+                                    completion);
 #else  // defined(FIREBASE_USE_STD_FUNCTION) || defined(DOXYGEN)
-  Promise<void, void, AsyncFn> promise(ref_future(), this);
+  return promises_->NewFuture<void>(env, AsyncFn::kRunTransaction, task);
 #endif  // defined(FIREBASE_USE_STD_FUNCTION) || defined(DOXYGEN)
-
-  promise.RegisterForTask(env, AsyncFn::kRunTransaction, task);
-  return promise.GetFuture();
 }
 
 #if defined(FIREBASE_USE_STD_FUNCTION) || defined(DOXYGEN)
@@ -398,31 +396,31 @@ Future<void> FirestoreInternal::RunTransaction(
 Future<void> FirestoreInternal::DisableNetwork() {
   Env env = GetEnv();
   Local<Object> task = env.Call(obj_, kDisableNetwork);
-  return NewFuture(env, AsyncFn::kDisableNetwork, task);
+  return promises_->NewFuture<void>(env, AsyncFn::kDisableNetwork, task);
 }
 
 Future<void> FirestoreInternal::EnableNetwork() {
   Env env = GetEnv();
   Local<Object> task = env.Call(obj_, kEnableNetwork);
-  return NewFuture(env, AsyncFn::kEnableNetwork, task);
+  return promises_->NewFuture<void>(env, AsyncFn::kEnableNetwork, task);
 }
 
 Future<void> FirestoreInternal::Terminate() {
   Env env = GetEnv();
   Local<Object> task = env.Call(obj_, kTerminate);
-  return NewFuture(env, AsyncFn::kTerminate, task);
+  return promises_->NewFuture<void>(env, AsyncFn::kTerminate, task);
 }
 
 Future<void> FirestoreInternal::WaitForPendingWrites() {
   Env env = GetEnv();
   Local<Object> task = env.Call(obj_, kWaitForPendingWrites);
-  return NewFuture(env, AsyncFn::kWaitForPendingWrites, task);
+  return promises_->NewFuture<void>(env, AsyncFn::kWaitForPendingWrites, task);
 }
 
 Future<void> FirestoreInternal::ClearPersistence() {
   Env env = GetEnv();
   Local<Object> task = env.Call(obj_, kClearPersistence);
-  return NewFuture(env, AsyncFn::kClearPersistence, task);
+  return promises_->NewFuture<void>(env, AsyncFn::kClearPersistence, task);
 }
 
 ListenerRegistration FirestoreInternal::AddSnapshotsInSyncListener(

firestore/src/android/firestore_android.h

@@ -8,6 +8,7 @@
 #include <functional>
 #endif
 
+#include "app/memory/unique_ptr.h"
 #include "app/src/cleanup_notifier.h"
 #include "app/src/future_manager.h"
 #include "app/src/include/firebase/app.h"
@@ -29,8 +30,8 @@ class Transaction;
 class TransactionFunction;
 class WriteBatch;
 
-template <typename PublicType, typename InternalType, typename FnEnumType>
-class Promise;
+template <typename EnumT>
+class PromiseFactory;
 
 // Used for registering global callbacks. See
 // firebase::util::RegisterCallbackOnTask for context.
@@ -154,27 +155,12 @@ class FirestoreInternal {
   static void SetClientLanguage(const std::string& language_token);
 
  private:
-  // Gets the reference-counted Future implementation of this instance, which
-  // can be used to create a Future.
-  ReferenceCountedFutureImpl* ref_future() {
-    return future_manager_.GetFutureApi(this);
-  }
+  friend class FirestoreIntegrationTest;
 
   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);
@@ -211,6 +197,7 @@ class FirestoreInternal {
 #endif  //  defined(_STLPORT_VERSION)
 
   FutureManager future_manager_;
+  UniquePtr<PromiseFactory<AsyncFn>> promises_;
 
   CleanupNotifier cleanup_;
 };

firestore/src/android/lambda_transaction_function.h

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

firestore/src/android/promise_android.h

@@ -17,6 +17,9 @@
 namespace firebase {
 namespace firestore {
 
+template <typename EnumT>
+class PromiseFactory;
+
 // This class simplifies the implementation of Future APIs for Android wrappers.
 // PublicType is the public type, say Foo, and InternalType is FooInternal.
 // FnEnumType is an enum class that defines a set of APIs returning a Future.
@@ -29,25 +32,20 @@ namespace firestore {
 // and FnEnumType is CollectionReferenceFn.
 template <typename PublicType, typename InternalType, typename FnEnumType>
 class Promise {
+  friend class PromiseFactory<FnEnumType>;
+
  public:
   // One can add a completion to execute right after the Future is resolved.
   // The Games's Future library does not support chaining-up of completions yet.
   // So we add the interface here to allow executing code after Future is
   // resolved.
-  template <typename PublicT>
   class Completion {
    public:
     virtual ~Completion() = default;
     virtual void CompleteWith(Error error_code, const char* error_message,
-                              PublicT* result) = 0;
+                              PublicType* result) = 0;
   };
 
-  Promise(ReferenceCountedFutureImpl* impl, FirestoreInternal* firestore,
-          Completion<PublicType>* completion = nullptr)
-      : completer_(MakeUnique<Completer<PublicType, InternalType>>(
-            impl, firestore, completion)),
-        impl_(impl) {}
-
   ~Promise() {}
 
   Promise(const Promise&) = delete;
@@ -56,10 +54,6 @@ class Promise {
   Promise(Promise&& other) = default;
   Promise& operator=(Promise&& other) = default;
 
-  void RegisterForTask(FnEnumType op, const jni::Object& task) {
-    return RegisterForTask(op, task.get());
-  }
-
   void RegisterForTask(jni::Env& env, FnEnumType op, const jni::Object& task) {
     handle_ = completer_->Alloc(static_cast<int>(op));
 
@@ -73,11 +67,19 @@ class Promise {
   Future<PublicType> GetFuture() { return MakeFuture(impl_, handle_); }
 
  private:
+  // The constructor is intentionally private.
+  // Create instances with `PromiseFactory`.
+  Promise(ReferenceCountedFutureImpl* impl, FirestoreInternal* firestore,
+          Completion* completion)
+      : completer_(MakeUnique<Completer<PublicType, InternalType>>(
+            impl, firestore, completion)),
+        impl_(impl) {}
+
   template <typename PublicT>
   class CompleterBase {
    public:
     CompleterBase(ReferenceCountedFutureImpl* impl,
-                  FirestoreInternal* firestore, Completion<PublicT>* completion)
+                  FirestoreInternal* firestore, Completion* completion)
         : impl_{impl}, firestore_{firestore}, completion_(completion) {}
 
     virtual ~CompleterBase() = default;
@@ -131,7 +133,7 @@ class Promise {
     SafeFutureHandle<PublicT> handle_;
     ReferenceCountedFutureImpl* impl_;    // not owning
     FirestoreInternal* firestore_;        // not owning
-    Completion<PublicType>* completion_;  // not owning
+    Completion* completion_;              // not owning
   };
 
   // Partial specialization of a nested class is allowed. So adding the no-op
@@ -143,7 +145,8 @@ class Promise {
     using CompleterBase<PublicT>::CompleterBase;
 
     void SucceedWithResult(jni::Env& env, const jni::Object& result) override {
-      auto future_result = MakePublic<PublicT>(env, this->firestore_, result);
+      auto future_result =
+          MakePublic<PublicT, InternalT>(env, this->firestore_, result);
 
       this->impl_->CompleteWithResult(this->handle_, Error::kErrorOk,
                                       /*error_msg=*/"", future_result);

firestore/src/android/promise_factory_android.h

@@ -36,15 +36,21 @@ class PromiseFactory {
   // This can be used to implement APIs that return Futures of some public type.
   // Use MakePromise<void, void>() to create a Future<void>.
   template <typename PublicT, typename InternalT = InternalType<PublicT>>
-  Promise<PublicT, InternalT, EnumT> MakePromise() {
-    return Promise<PublicT, InternalT, EnumT>{future_api(), firestore_};
+  Promise<PublicT, InternalT, EnumT> MakePromise(
+      typename Promise<PublicT, InternalT, EnumT>::Completion* completion =
+          nullptr) {
+    return Promise<PublicT, InternalT, EnumT>{future_api(), firestore_,
+                                              completion};
   }
 
   template <typename PublicT, typename InternalT = InternalType<PublicT>>
-  Future<PublicT> NewFuture(jni::Env& env, EnumT op, const jni::Object& task) {
+  Future<PublicT> NewFuture(
+      jni::Env& env, EnumT op, const jni::Object& task,
+      typename Promise<PublicT, InternalT, EnumT>::Completion* completion =
+          nullptr) {
     if (!env.ok()) return {};
 
-    auto promise = MakePromise<PublicT, InternalT>();
+    auto promise = MakePromise<PublicT, InternalT>(completion);
     promise.RegisterForTask(env, op, task);
     return promise.GetFuture();
   }

firestore/src/tests/android/cancellation_token_source.cc

@@ -0,0 +1,40 @@
+#include "firestore/src/tests/android/cancellation_token_source.h"
+
+#include "firestore/src/jni/env.h"
+#include "firestore/src/jni/loader.h"
+
+namespace firebase {
+namespace firestore {
+namespace {
+
+using jni::Constructor;
+using jni::Env;
+using jni::Local;
+using jni::Method;
+using jni::Object;
+
+constexpr char kClassName[] =
+    PROGUARD_KEEP_CLASS "com/google/android/gms/tasks/CancellationTokenSource";
+Constructor<CancellationTokenSource> kConstructor("()V");
+Method<Object> kGetToken("getToken",
+                         "()Lcom/google/android/gms/tasks/CancellationToken;");
+Method<void> kCancel("cancel", "()V");
+
+}  // namespace
+
+void CancellationTokenSource::Initialize(jni::Loader& loader) {
+  loader.LoadClass(kClassName, kConstructor, kGetToken, kCancel);
+}
+
+Local<CancellationTokenSource> CancellationTokenSource::Create(Env& env) {
+  return env.New(kConstructor);
+}
+
+Local<Object> CancellationTokenSource::GetToken(Env& env) {
+  return env.Call(*this, kGetToken);
+}
+
+void CancellationTokenSource::Cancel(Env& env) { env.Call(*this, kCancel); }
+
+}  // namespace firestore
+}  // namespace firebase

firestore/src/tests/android/cancellation_token_source.h

@@ -0,0 +1,34 @@
+#ifndef FIREBASE_FIRESTORE_CLIENT_CPP_SRC_TESTS_ANDROID_CANCELLATION_TOKEN_SOURCE_H_
+#define FIREBASE_FIRESTORE_CLIENT_CPP_SRC_TESTS_ANDROID_CANCELLATION_TOKEN_SOURCE_H_
+
+#include "firestore/src/jni/jni_fwd.h"
+#include "firestore/src/jni/object.h"
+
+namespace firebase {
+namespace firestore {
+
+/** A C++ proxy for a Java `CancellationTokenSource` from the Tasks API. */
+class CancellationTokenSource : public jni::Object {
+ public:
+  using jni::Object::Object;
+
+  static void Initialize(jni::Loader& loader);
+
+  /** Creates a C++ proxy for a Java `CancellationTokenSource` object. */
+  static jni::Local<CancellationTokenSource> Create(jni::Env& env);
+
+  /**
+   * Invokes `getToken()` on the wrapped Java `CancellationTokenSource` object.
+   */
+  jni::Local<Object> GetToken(jni::Env& env);
+
+  /**
+   * Invokes `cancel()` on the wrapped Java `CancellationTokenSource` object.
+   */
+  void Cancel(jni::Env& env);
+};
+
+}  // namespace firestore
+}  // namespace firebase
+
+#endif  // FIREBASE_FIRESTORE_CLIENT_CPP_SRC_TESTS_ANDROID_CANCELLATION_TOKEN_SOURCE_H_