Firestore COUNT API (#1174)

* Firestore COUNT API

* Exempt from go/allstar check (#1173)

* Token-changed listeners for iOS AppCheck (#1172)

* [macOS sandbox mode] Application group name mangling for semaphores (#1167)

When macOS Sandbox mode is enabled, macOS requires that semaphores have a name that is prefixed by the App's Group Name. If the semaphore's name doesn't match this convention then its creation fails.

Unfortunately there's no official way for the SDK to query the app's group name at runtime, so we can't automatically mangle the semaphore names.

Instead I've updated the SDK to use an Info.plist property named FBAppGroupEntitlementName on macOS. If that property is present then the SDK will use it's value to prefix the semaphore names.

As an additional issue, the SDK attempted to detect semaphore creation errors by comparing the semaphore handle to nil. But in the case of macOS, a semaphore creation error returns SEM_FAILED which is 0xFFFFFFFFFFFFFFFF, not nil. And on Linux, sem_init returns -1. I've updated the corresponding platform implementations to detect the correct  values for these errors.

* Setup Desktop test workflow that detects C++ SDK breakage caused by iOS SDK changes (#1162)

* [Bugfx] Fix Nightly Test Report template (#1181)

* Reduce number of RewardedAd loads on iOS in CI (#1180)

The GMA backend doesn't whitelist iOS devices running in CI which means number of ads that can be served to iOS in CI is restricted. This is true even when using the prescribed Demo Ad Unit Id.

This PR reduces the number of ads we load on iOS in an attempt to minimize the chance of encountering NoFillErrors and push our CI to green.

* Firestore COUNT implementation (WIP)

* Firestore COUNT implementation (WIP)

* Fix linting

* Fix linting

* Fix linking

* Cleanup

* Fix release notes

* Format

* Fixes from review

* Formatting

* Responding to PR comments.

* Add Hash

* Add Hash

* Fix copyright year

* Rename

* Format

* Rename

* Fixup constructor/assignment parameter naming.

* Format

---------

Co-authored-by: chkuang-g <[email protected]>
Co-authored-by: Matthew Hyndman <[email protected]>
Co-authored-by: DellaBitta <[email protected]>
Co-authored-by: Mou Sun <[email protected]>

Author: 5 people

app/CMakeLists.txt

@@ -522,6 +522,9 @@ if (IOS)
     ${FIREBASE_SOURCE_DIR}/dynamic_links/src/include/firebase/dynamic_links/components.h)
   set(firestore_HDRS
     ${FIREBASE_SOURCE_DIR}/firestore/src/include/firebase/firestore.h
+    ${FIREBASE_SOURCE_DIR}/firestore/src/include/firebase/firestore/aggregate_query.h
+    ${FIREBASE_SOURCE_DIR}/firestore/src/include/firebase/firestore/aggregate_query_snapshot.h
+    ${FIREBASE_SOURCE_DIR}/firestore/src/include/firebase/firestore/aggregate_source.h
     ${FIREBASE_SOURCE_DIR}/firestore/src/include/firebase/firestore/collection_reference.h
     ${FIREBASE_SOURCE_DIR}/firestore/src/include/firebase/firestore/document_change.h
     ${FIREBASE_SOURCE_DIR}/firestore/src/include/firebase/firestore/document_reference.h

firestore/CMakeLists.txt

@@ -20,6 +20,8 @@ else()
 endif()
 
 set(common_SRCS
+    src/common/aggregate_query.cc
+    src/common/aggregate_query_snapshot.cc
     src/common/cleanup.h
     src/common/collection_reference.cc
     src/common/compiler_info.cc
@@ -185,6 +187,10 @@ set(android_SRCS
 
 # Sources that apply to all non-Android platforms.
 set(main_SRCS
+    src/main/aggregate_query_main.cc
+    src/main/aggregate_query_main.h
+    src/main/aggregate_query_snapshot_main.cc
+    src/main/aggregate_query_snapshot_main.h
     src/main/collection_reference_main.cc
     src/main/collection_reference_main.h
     src/main/converter_main.h

firestore/CONTRIBUTING.md

@@ -19,7 +19,7 @@ a Python3 installation.
 
 # Architecture
 
-It is easier to work this Firestore CPP SDK by keeping a high level archetecture in mind:
+It is easier to work this Firestore CPP SDK by keeping a high level architecture in mind:
 
 ![architecture.png](architecture.png)
 

firestore/src/common/aggregate_query.cc

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2023 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 "firestore/src/include/firebase/firestore/aggregate_query.h"
+#include "firestore/src/common/cleanup.h"
+#include "firestore/src/common/futures.h"
+#include "firestore/src/common/util.h"
+#include "firestore/src/include/firebase/firestore/aggregate_query_snapshot.h"
+
+#if defined(__ANDROID__)
+// TODO(tomandersen) #include "firestore/src/android/aggregate_query_android.h"
+#else
+#include "firestore/src/main/aggregate_query_main.h"
+#endif  // defined(__ANDROID__)
+
+namespace firebase {
+namespace firestore {
+
+using CleanupFnAggregateQuery = CleanupFn<AggregateQuery>;
+
+AggregateQuery::AggregateQuery() {}
+
+AggregateQuery::AggregateQuery(const AggregateQuery& other) {
+  if (other.internal_) {
+    internal_ = new AggregateQueryInternal(*other.internal_);
+  }
+  CleanupFnAggregateQuery::Register(this, internal_);
+}
+
+AggregateQuery::AggregateQuery(AggregateQuery&& other) {
+  CleanupFnAggregateQuery::Unregister(&other, other.internal_);
+  std::swap(internal_, other.internal_);
+  CleanupFnAggregateQuery::Register(this, internal_);
+}
+
+AggregateQuery::AggregateQuery(AggregateQueryInternal* internal)
+    : internal_(internal) {
+  SIMPLE_HARD_ASSERT(internal != nullptr);
+  CleanupFnAggregateQuery::Register(this, internal_);
+}
+
+AggregateQuery::~AggregateQuery() {
+  CleanupFnAggregateQuery::Unregister(this, internal_);
+  delete internal_;
+  internal_ = nullptr;
+}
+
+AggregateQuery& AggregateQuery::operator=(const AggregateQuery& other) {
+  if (this == &other) {
+    return *this;
+  }
+
+  CleanupFnAggregateQuery::Unregister(this, internal_);
+  delete internal_;
+  if (other.internal_) {
+    internal_ = new AggregateQueryInternal(*other.internal_);
+  } else {
+    internal_ = nullptr;
+  }
+  CleanupFnAggregateQuery::Register(this, internal_);
+  return *this;
+}
+
+AggregateQuery& AggregateQuery::operator=(AggregateQuery&& other) {
+  if (this == &other) {
+    return *this;
+  }
+
+  CleanupFnAggregateQuery::Unregister(&other, other.internal_);
+  CleanupFnAggregateQuery::Unregister(this, internal_);
+  delete internal_;
+  internal_ = other.internal_;
+  other.internal_ = nullptr;
+  CleanupFnAggregateQuery::Register(this, internal_);
+  return *this;
+}
+
+Query AggregateQuery::query() const {
+  if (!internal_) return {};
+  return internal_->query();
+}
+
+Future<AggregateQuerySnapshot> AggregateQuery::Get(
+    AggregateSource aggregate_source) const {
+  if (!internal_) return FailedFuture<AggregateQuerySnapshot>();
+  return internal_->Get(aggregate_source);
+}
+
+size_t AggregateQuery::Hash() const {
+  if (!internal_) return {};
+  return internal_->Hash();
+}
+
+bool operator==(const AggregateQuery& lhs, const AggregateQuery& rhs) {
+  return EqualityCompare(lhs.internal_, rhs.internal_);
+}
+
+}  // namespace firestore
+}  // namespace firebase

firestore/src/common/aggregate_query_snapshot.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2023 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 "firestore/src/include/firebase/firestore/aggregate_query_snapshot.h"
+
+#include "firestore/src/common/cleanup.h"
+#include "firestore/src/common/util.h"
+#include "firestore/src/include/firebase/firestore/aggregate_query.h"
+
+#if defined(__ANDROID__)
+// TODO(tomandersen) #include
+// "firestore/src/android/aggregate_query_snapshot_android.h"
+#else
+#include "firestore/src/main/aggregate_query_snapshot_main.h"
+#endif  // defined(__ANDROID__)
+
+namespace firebase {
+namespace firestore {
+
+using CleanupFnAggregateQuerySnapshot = CleanupFn<AggregateQuerySnapshot>;
+
+AggregateQuerySnapshot::AggregateQuerySnapshot() {}
+
+AggregateQuerySnapshot::AggregateQuerySnapshot(
+    const AggregateQuerySnapshot& other) {
+  if (other.internal_) {
+    internal_ = new AggregateQuerySnapshotInternal(*other.internal_);
+  }
+  CleanupFnAggregateQuerySnapshot::Register(this, internal_);
+}
+
+AggregateQuerySnapshot::AggregateQuerySnapshot(AggregateQuerySnapshot&& other) {
+  CleanupFnAggregateQuerySnapshot::Unregister(&other, other.internal_);
+  std::swap(internal_, other.internal_);
+  CleanupFnAggregateQuerySnapshot::Register(this, internal_);
+}
+
+AggregateQuerySnapshot::AggregateQuerySnapshot(
+    AggregateQuerySnapshotInternal* internal)
+    : internal_(internal) {
+  SIMPLE_HARD_ASSERT(internal != nullptr);
+  CleanupFnAggregateQuerySnapshot::Register(this, internal_);
+}
+
+AggregateQuerySnapshot::~AggregateQuerySnapshot() {
+  CleanupFnAggregateQuerySnapshot::Unregister(this, internal_);
+  delete internal_;
+  internal_ = nullptr;
+}
+
+AggregateQuerySnapshot& AggregateQuerySnapshot::operator=(
+    const AggregateQuerySnapshot& other) {
+  if (this == &other) {
+    return *this;
+  }
+
+  CleanupFnAggregateQuerySnapshot::Unregister(this, internal_);
+  delete internal_;
+  if (other.internal_) {
+    internal_ = new AggregateQuerySnapshotInternal(*other.internal_);
+  } else {
+    internal_ = nullptr;
+  }
+  CleanupFnAggregateQuerySnapshot::Register(this, internal_);
+  return *this;
+}
+
+AggregateQuerySnapshot& AggregateQuerySnapshot::operator=(
+    AggregateQuerySnapshot&& other) {
+  if (this == &other) {
+    return *this;
+  }
+
+  CleanupFnAggregateQuerySnapshot::Unregister(&other, other.internal_);
+  CleanupFnAggregateQuerySnapshot::Unregister(this, internal_);
+  delete internal_;
+  internal_ = other.internal_;
+  other.internal_ = nullptr;
+  CleanupFnAggregateQuerySnapshot::Register(this, internal_);
+  return *this;
+}
+
+AggregateQuery AggregateQuerySnapshot::query() const {
+  if (!internal_) return {};
+  return internal_->query();
+}
+
+int64_t AggregateQuerySnapshot::count() const {
+  if (!internal_) return 0;
+  return internal_->count();
+}
+
+bool operator==(const AggregateQuerySnapshot& lhs,
+                const AggregateQuerySnapshot& rhs) {
+  return EqualityCompare(lhs.internal_, rhs.internal_);
+}
+
+size_t AggregateQuerySnapshot::Hash() const {
+  if (!internal_) return {};
+  return internal_->Hash();
+}
+
+}  // namespace firestore
+}  // namespace firebase

firestore/src/common/query.cc

@@ -23,6 +23,7 @@
 #include "firestore/src/common/futures.h"
 #include "firestore/src/common/hard_assert_common.h"
 #include "firestore/src/common/util.h"
+#include "firestore/src/include/firebase/firestore/aggregate_query.h"
 #include "firestore/src/include/firebase/firestore/document_snapshot.h"
 #include "firestore/src/include/firebase/firestore/field_path.h"
 #include "firestore/src/include/firebase/firestore/field_value.h"
@@ -106,6 +107,11 @@ Firestore* Query::firestore() {
   return internal_->firestore();
 }
 
+AggregateQuery Query::Count() const {
+  if (!internal_) return {};
+  return internal_->Count();
+}
+
 Query Query::WhereEqualTo(const std::string& field,
                           const FieldValue& value) const {
   return WhereEqualTo(FieldPath::FromDotSeparatedString(field), value);

firestore/src/common/type_mapping.h

@@ -22,6 +22,10 @@
 namespace firebase {
 namespace firestore {
 
+class AggregateQuery;
+class AggregateQueryInternal;
+class AggregateQuerySnapshot;
+class AggregateQuerySnapshotInternal;
 class CollectionReference;
 class CollectionReferenceInternal;
 class DocumentChange;
@@ -54,6 +58,14 @@ class WriteBatchInternal;
 template <typename T>
 struct InternalTypeMap {};
 
+template <>
+struct InternalTypeMap<AggregateQuery> {
+  using type = AggregateQueryInternal;
+};
+template <>
+struct InternalTypeMap<AggregateQuerySnapshot> {
+  using type = AggregateQuerySnapshotInternal;
+};
 template <>
 struct InternalTypeMap<CollectionReference> {
   using type = CollectionReferenceInternal;

firestore/src/include/firebase/firestore.h

@@ -27,6 +27,9 @@
 #include "firebase/log.h"
 // Include *all* the public headers to make sure including just "firestore.h" is
 // sufficient for users.
+#include "firebase/firestore/aggregate_query.h"
+#include "firebase/firestore/aggregate_query_snapshot.h"
+#include "firebase/firestore/aggregate_source.h"
 #include "firebase/firestore/collection_reference.h"
 #include "firebase/firestore/document_change.h"
 #include "firebase/firestore/document_reference.h"