Merge remote-tracking branch 'origin/master' into rc-realtime-dev

Author: qdpham13

firebase-appdistribution-api/ktx/api.txt

@@ -3,6 +3,13 @@ package com.google.firebase.appdistribution.ktx {
 
   public final class FirebaseAppDistributionKt {
     ctor public FirebaseAppDistributionKt();
+    method @NonNull public static operator com.google.firebase.appdistribution.BinaryType component1(@NonNull com.google.firebase.appdistribution.AppDistributionRelease);
+    method public static operator long component1(@NonNull com.google.firebase.appdistribution.UpdateProgress);
+    method @NonNull public static operator String component2(@NonNull com.google.firebase.appdistribution.AppDistributionRelease);
+    method public static operator long component2(@NonNull com.google.firebase.appdistribution.UpdateProgress);
+    method public static operator long component3(@NonNull com.google.firebase.appdistribution.AppDistributionRelease);
+    method @NonNull public static operator com.google.firebase.appdistribution.UpdateStatus component3(@NonNull com.google.firebase.appdistribution.UpdateProgress);
+    method @Nullable public static operator String component4(@NonNull com.google.firebase.appdistribution.AppDistributionRelease);
     method @NonNull public static com.google.firebase.appdistribution.FirebaseAppDistribution getAppDistribution(@NonNull com.google.firebase.ktx.Firebase);
   }
 

firebase-appdistribution-api/ktx/src/androidTest/kotlin/com/google/firebase/app/distribution/ktx/FirebaseAppDistributionTests.kt

@@ -19,7 +19,11 @@ import androidx.test.internal.runner.junit4.AndroidJUnit4ClassRunner
 import com.google.common.truth.Truth.assertThat
 import com.google.firebase.FirebaseApp
 import com.google.firebase.FirebaseOptions
+import com.google.firebase.appdistribution.AppDistributionRelease
+import com.google.firebase.appdistribution.BinaryType
 import com.google.firebase.appdistribution.FirebaseAppDistribution
+import com.google.firebase.appdistribution.UpdateProgress
+import com.google.firebase.appdistribution.UpdateStatus
 import com.google.firebase.ktx.Firebase
 import com.google.firebase.ktx.app
 import com.google.firebase.ktx.initialize
@@ -70,6 +74,43 @@ class FirebaseAppDistributionTests : BaseTestCase() {
     fun appDistribution_default_callsDefaultGetInstance() {
         assertThat(Firebase.appDistribution).isSameInstanceAs(FirebaseAppDistribution.getInstance())
     }
+
+    @Test
+    fun appDistributionReleaseDestructuringDeclarationsWork() {
+        val mockAppDistributionRelease = object : AppDistributionRelease {
+            override fun getDisplayVersion(): String = "1.0.0"
+
+            override fun getVersionCode(): Long = 1L
+
+            override fun getReleaseNotes(): String = "Changelog..."
+
+            override fun getBinaryType(): BinaryType = BinaryType.AAB
+        }
+
+        val (type, displayVersion, versionCode, notes) = mockAppDistributionRelease
+
+        assertThat(type).isEqualTo(mockAppDistributionRelease.binaryType)
+        assertThat(displayVersion).isEqualTo(mockAppDistributionRelease.displayVersion)
+        assertThat(versionCode).isEqualTo(mockAppDistributionRelease.versionCode)
+        assertThat(notes).isEqualTo(mockAppDistributionRelease.releaseNotes)
+    }
+
+    @Test
+    fun updateProgressDestructuringDeclarationsWork() {
+        val mockUpdateProgress = object : UpdateProgress {
+            override fun getApkBytesDownloaded(): Long = 1200L
+
+            override fun getApkFileTotalBytes(): Long = 9000L
+
+            override fun getUpdateStatus(): UpdateStatus = UpdateStatus.DOWNLOADING
+        }
+
+        val (downloaded, total, status) = mockUpdateProgress
+
+        assertThat(downloaded).isEqualTo(mockUpdateProgress.apkBytesDownloaded)
+        assertThat(total).isEqualTo(mockUpdateProgress.apkFileTotalBytes)
+        assertThat(status).isEqualTo(mockUpdateProgress.updateStatus)
+    }
 }
 
 internal const val LIBRARY_NAME: String = "fire-appdistribution-ktx"

firebase-appdistribution-api/ktx/src/main/kotlin/com/google/firebase/appdistribution/ktx/FirebaseAppDistribution.kt

@@ -17,7 +17,9 @@ package com.google.firebase.appdistribution.ktx
 import androidx.annotation.Keep
 import com.google.firebase.BuildConfig
 import com.google.firebase.FirebaseApp
+import com.google.firebase.appdistribution.AppDistributionRelease
 import com.google.firebase.appdistribution.FirebaseAppDistribution
+import com.google.firebase.appdistribution.UpdateProgress
 import com.google.firebase.components.Component
 import com.google.firebase.components.ComponentRegistrar
 import com.google.firebase.ktx.Firebase
@@ -27,6 +29,55 @@ import com.google.firebase.platforminfo.LibraryVersionComponent
 val Firebase.appDistribution: FirebaseAppDistribution
     get() = FirebaseAppDistribution.getInstance()
 
+/**
+ * Destructuring declaration for [AppDistributionRelease] to provide binaryType.
+ *
+ * @return the binaryType of the [AppDistributionRelease]
+ */
+operator fun AppDistributionRelease.component1() = binaryType
+
+/**
+ * Destructuring declaration for [AppDistributionRelease] to provide displayVersion.
+ *
+ * @return the displayVersion of the [AppDistributionRelease]
+ */
+operator fun AppDistributionRelease.component2() = displayVersion
+
+/**
+ * Destructuring declaration for [AppDistributionRelease] to provide versionCode.
+ *
+ * @return the versionCode of the [AppDistributionRelease]
+ */
+operator fun AppDistributionRelease.component3() = versionCode
+
+/**
+ * Destructuring declaration for [AppDistributionRelease] to provide releaseNotes.
+ *
+ * @return the releaseNotes of the [AppDistributionRelease]
+ */
+operator fun AppDistributionRelease.component4() = releaseNotes
+
+/**
+ * Destructuring declaration for [UpdateProgress] to provide apkBytesDownloaded.
+ *
+ * @return the apkBytesDownloaded of the [UpdateProgress]
+ */
+operator fun UpdateProgress.component1() = apkBytesDownloaded
+
+/**
+ * Destructuring declaration for [UpdateProgress] to provide apkFileTotalBytes.
+ *
+ * @return the apkFileTotalBytes of the [UpdateProgress]
+ */
+operator fun UpdateProgress.component2() = apkFileTotalBytes
+
+/**
+ * Destructuring declaration for [UpdateProgress] to provide updateStatus.
+ *
+ * @return the updateStatus of the [UpdateProgress]
+ */
+operator fun UpdateProgress.component3() = updateStatus
+
 internal const val LIBRARY_NAME: String = "fire-appdistribution-ktx"
 
 /** @suppress */

firebase-firestore/src/main/java/com/google/firebase/firestore/Query.java

@@ -14,6 +14,7 @@
 
 package com.google.firebase.firestore;
 
+import static com.google.firebase.firestore.core.Query.LimitType.LIMIT_TO_LAST;
 import static com.google.firebase.firestore.util.Assert.fail;
 import static com.google.firebase.firestore.util.Assert.hardAssert;
 import static com.google.firebase.firestore.util.Preconditions.checkNotNull;
@@ -1216,7 +1217,7 @@ private ListenerRegistration addSnapshotListenerInternal(
   }
 
   private void validateHasExplicitOrderByForLimitToLast() {
-    if (query.hasLimitToLast() && query.getExplicitOrderBy().isEmpty()) {
+    if (query.getLimitType().equals(LIMIT_TO_LAST) && query.getExplicitOrderBy().isEmpty()) {
       throw new IllegalStateException(
           "limitToLast() queries require specifying at least one orderBy() clause");
     }

firebase-firestore/src/main/java/com/google/firebase/firestore/core/Query.java

@@ -147,34 +147,16 @@ public List<Filter> getFilters() {
     return filters;
   }
 
-  /**
-   * The maximum number of results to return. If there is no limit on the query, then this will
-   * cause an assertion failure.
-   */
-  public long getLimitToFirst() {
-    hardAssert(hasLimitToFirst(), "Called getLimitToFirst when no limit was set");
-    return limit;
-  }
-
-  public boolean hasLimitToFirst() {
-    return limitType == LimitType.LIMIT_TO_FIRST && limit != Target.NO_LIMIT;
-  }
-
-  /**
-   * The maximum number of last-matching results to return. If there is no limit on the query, then
-   * this will cause an assertion failure.
-   */
-  public long getLimitToLast() {
-    hardAssert(hasLimitToLast(), "Called getLimitToLast when no limit was set");
+  /** The maximum number of results to return or {@link Target#NO_LIMIT} if there is no limit. */
+  public long getLimit() {
     return limit;
   }
 
-  public boolean hasLimitToLast() {
-    return limitType == LimitType.LIMIT_TO_LAST && limit != Target.NO_LIMIT;
+  public boolean hasLimit() {
+    return limit != Target.NO_LIMIT;
   }
 
   public LimitType getLimitType() {
-    hardAssert(hasLimitToLast() || hasLimitToFirst(), "Called getLimitType when no limit was set");
     return limitType;
   }
 

firebase-firestore/src/main/java/com/google/firebase/firestore/core/View.java

@@ -14,6 +14,8 @@
 
 package com.google.firebase.firestore.core;
 
+import static com.google.firebase.firestore.core.Query.LimitType.LIMIT_TO_FIRST;
+import static com.google.firebase.firestore.core.Query.LimitType.LIMIT_TO_LAST;
 import static com.google.firebase.firestore.util.Assert.hardAssert;
 import static com.google.firebase.firestore.util.Util.compareIntegers;
 
@@ -147,11 +149,11 @@ public DocumentChanges computeDocChanges(
     // Note that this should never get used in a refill (when previousChanges is set), because there
     // will only be adds -- no deletes or updates.
     Document lastDocInLimit =
-        (query.hasLimitToFirst() && oldDocumentSet.size() == query.getLimitToFirst())
+        (query.getLimitType().equals(LIMIT_TO_FIRST) && oldDocumentSet.size() == query.getLimit())
             ? oldDocumentSet.getLastDocument()
             : null;
     Document firstDocInLimit =
-        (query.hasLimitToLast() && oldDocumentSet.size() == query.getLimitToLast())
+        (query.getLimitType().equals(LIMIT_TO_LAST) && oldDocumentSet.size() == query.getLimit())
             ? oldDocumentSet.getFirstDocument()
             : null;
 
@@ -222,11 +224,10 @@ public DocumentChanges computeDocChanges(
     }
 
     // Drop documents out to meet limitToFirst/limitToLast requirement.
-    if (query.hasLimitToFirst() || query.hasLimitToLast()) {
-      long limit = query.hasLimitToFirst() ? query.getLimitToFirst() : query.getLimitToLast();
-      for (long i = newDocumentSet.size() - limit; i > 0; --i) {
+    if (query.hasLimit()) {
+      for (long i = newDocumentSet.size() - query.getLimit(); i > 0; --i) {
         Document oldDoc =
-            query.hasLimitToFirst()
+            query.getLimitType().equals(LIMIT_TO_FIRST)
                 ? newDocumentSet.getLastDocument()
                 : newDocumentSet.getFirstDocument();
         newDocumentSet = newDocumentSet.remove(oldDoc.getKey());

firebase-firestore/src/main/java/com/google/firebase/firestore/local/QueryEngine.java

@@ -15,7 +15,6 @@
 package com.google.firebase.firestore.local;
 
 import static com.google.firebase.firestore.util.Assert.hardAssert;
-import static com.google.firebase.firestore.util.Util.values;
 
 import com.google.firebase.database.collection.ImmutableSortedMap;
 import com.google.firebase.database.collection.ImmutableSortedSet;
@@ -117,15 +116,14 @@ public ImmutableSortedMap<DocumentKey, Document> getDocumentsMatchingQuery(
       return null;
     }
 
-    if (indexType.equals(IndexType.PARTIAL)) {
+    if (query.hasLimit() && indexType.equals(IndexType.PARTIAL)) {
       // We cannot apply a limit for targets that are served using a partial index.
       // If a partial index will be used to serve the target, the query may return a superset of
       // documents that match the target (e.g. if the index doesn't include all the target's
       // filters), or may return the correct set of documents in the wrong order (e.g. if the index
       // doesn't include a segment for one of the orderBys). Therefore a limit should not be applied
       // in such cases.
-      query = query.limitToFirst(Target.NO_LIMIT);
-      target = query.toTarget();
+      return performQueryUsingIndex(query.limitToFirst(Target.NO_LIMIT));
     }
 
     List<DocumentKey> keys = indexManager.getDocumentsMatchingTarget(target);
@@ -136,12 +134,15 @@ public ImmutableSortedMap<DocumentKey, Document> getDocumentsMatchingQuery(
     IndexOffset offset = indexManager.getMinOffset(target);
 
     ImmutableSortedSet<Document> previousResults = applyQuery(query, indexedDocuments);
-    if ((query.hasLimitToFirst() || query.hasLimitToLast())
-        && needsRefill(query.getLimitType(), keys.size(), previousResults, offset.getReadTime())) {
-      return null;
+    if (needsRefill(query, keys.size(), previousResults, offset.getReadTime())) {
+      // A limit query whose boundaries change due to local edits can be re-run against the cache
+      // by excluding the limit. This ensures that all documents that match the query's filters are
+      // included in the result set. The SDK can then apply the limit once all local edits are
+      // incorporated.
+      return performQueryUsingIndex(query.limitToFirst(Target.NO_LIMIT));
     }
 
-    return appendRemainingResults(values(indexedDocuments), query, offset);
+    return appendRemainingResults(previousResults, query, offset);
   }
 
   /**
@@ -167,12 +168,7 @@ && needsRefill(query.getLimitType(), keys.size(), previousResults, offset.getRea
         localDocumentsView.getDocuments(remoteKeys);
     ImmutableSortedSet<Document> previousResults = applyQuery(query, documents);
 
-    if ((query.hasLimitToFirst() || query.hasLimitToLast())
-        && needsRefill(
-            query.getLimitType(),
-            remoteKeys.size(),
-            previousResults,
-            lastLimboFreeSnapshotVersion)) {
+    if (needsRefill(query, remoteKeys.size(), previousResults, lastLimboFreeSnapshotVersion)) {
       return null;
     }
 
@@ -211,7 +207,7 @@ private ImmutableSortedSet<Document> applyQuery(
    * Determines if a limit query needs to be refilled from cache, making it ineligible for
    * index-free execution.
    *
-   * @param limitType The type of limit query for refill calculation.
+   * @param query The query.
    * @param expectedDocumentCount The number of documents keys that matched the query at the last
    *     snapshot.
    * @param sortedPreviousResults The documents that match the query based on the previous result,
@@ -221,12 +217,17 @@ private ImmutableSortedSet<Document> applyQuery(
    *     synchronized.
    */
   private boolean needsRefill(
-      Query.LimitType limitType,
+      Query query,
       int expectedDocumentCount,
       ImmutableSortedSet<Document> sortedPreviousResults,
       SnapshotVersion limboFreeSnapshotVersion) {
-    // The query needs to be refilled if a previously matching document no longer matches.
+    if (!query.hasLimit()) {
+      // Queries without limits do not need to be refilled.
+      return false;
+    }
+
     if (expectedDocumentCount != sortedPreviousResults.size()) {
+      // The query needs to be refilled if a previously matching document no longer matches.
       return true;
     }
 
@@ -237,7 +238,7 @@ private boolean needsRefill(
     // did not change and documents from cache will continue to be "rejected" by this boundary.
     // Therefore, we can ignore any modifications that don't affect the last document.
     Document documentAtLimitEdge =
-        limitType == Query.LimitType.LIMIT_TO_FIRST
+        query.getLimitType() == Query.LimitType.LIMIT_TO_FIRST
             ? sortedPreviousResults.getMaxEntry()
             : sortedPreviousResults.getMinEntry();
     if (documentAtLimitEdge == null) {

firebase-firestore/src/test/java/com/google/firebase/firestore/bundle/BundleSerializerTest.java

@@ -712,30 +712,26 @@ private void assertDecodesNamedQuery(String json, Query query) throws JSONExcept
             + json
             + ",\n"
             + "    limitType: '"
-            + (query.hasLimitToLast() ? "LAST" : "FIRST")
+            + (query.getLimitType().equals(Query.LimitType.LIMIT_TO_LAST) ? "LAST" : "FIRST")
             + "'\n"
             + "   },\n"
             + " readTime: '2020-01-01T00:00:01.000000001Z'\n"
             + "}";
     NamedQuery actualNamedQuery = serializer.decodeNamedQuery(new JSONObject(queryJson));
 
-    long limit =
-        query.hasLimitToFirst()
-            ? query.getLimitToFirst()
-            : (query.hasLimitToLast() ? query.getLimitToLast() : Target.NO_LIMIT);
     Target target =
         new Target(
             query.getPath(),
             query.getCollectionGroup(),
             query.getFilters(),
             query.getExplicitOrderBy(),
-            limit,
+            query.getLimit(),
             query.getStartAt(),
             query.getEndAt());
     BundledQuery bundledQuery =
         new BundledQuery(
             target,
-            query.hasLimitToLast()
+            query.getLimitType().equals(Query.LimitType.LIMIT_TO_LAST)
                 ? Query.LimitType.LIMIT_TO_LAST
                 : Query.LimitType.LIMIT_TO_FIRST);
     NamedQuery expectedNamedQuery =

firebase-firestore/src/test/java/com/google/firebase/firestore/local/SQLiteLocalStoreTest.java

@@ -213,7 +213,7 @@ public void testUsesPartiallyIndexedOverlaysWhenAvailable() {
   }
 
   @Test
-  public void testDoesNotUseIndexForLimitQueryWhenIndexIsOutdated() {
+  public void testDoesNotUseLimitWhenIndexIsOutdated() {
     FieldIndex index =
         fieldIndex("coll", 0, FieldIndex.INITIAL_STATE, "count", FieldIndex.Segment.Kind.ASCENDING);
     configureFieldIndexes(singletonList(index));
@@ -234,10 +234,10 @@ public void testDoesNotUseIndexForLimitQueryWhenIndexIsOutdated() {
     writeMutation(deleteMutation("coll/b"));
 
     executeQuery(query);
-    // The query engine first reads the documents by key and then discards the results, which means
-    // that we read both by key and by collection.
-    assertRemoteDocumentsRead(/* byKey= */ 2, /* byCollection= */ 3);
-    assertOverlaysRead(/* byKey= */ 2, /* byCollection= */ 1);
+
+    // The query engine first reads the documents by key and then re-runs the query without limit.
+    assertRemoteDocumentsRead(/* byKey= */ 5, /* byCollection= */ 0);
+    assertOverlaysRead(/* byKey= */ 5, /* byCollection= */ 1);
     assertQueryReturned("coll/a", "coll/c");
   }