Merge branch 'master' into firebase-kotlin-format

Author: mrober

firebase-appdistribution/firebase-appdistribution.gradle

@@ -52,7 +52,7 @@ dependencies {
     implementation 'com.google.firebase:firebase-common:20.3.1'
     testImplementation project(path: ':firebase-appdistribution')
     testImplementation project(':integ-testing')
-    runtimeOnly 'com.google.firebase:firebase-installations:17.1.2'
+    runtimeOnly 'com.google.firebase:firebase-installations:17.1.3'
 
     implementation libs.javax.inject
     vendor (libs.dagger.dagger) {

firebase-config/src/main/java/com/google/firebase/remoteconfig/ConfigUpdate.java

@@ -18,10 +18,7 @@
 import com.google.auto.value.AutoValue;
 import java.util.Set;
 
-/**
- * Information about the updated config passed to the {@code onUpdate} callback of {@link
- * ConfigUpdateListener}.
- */
+/** Information about the updated config passed to {@link ConfigUpdateListener#onUpdate}. */
 @AutoValue
 public abstract class ConfigUpdate {
   @NonNull

firebase-config/src/main/java/com/google/firebase/remoteconfig/ConfigUpdateListener.java

@@ -18,21 +18,23 @@
 import javax.annotation.Nonnull;
 
 /**
- * Event listener interface for real-time RC updates. Implement {@code ConfigUpdateListner} to call
- * {@link com.google.firebase.remoteconfig.FirebaseRemoteConfig#addOnConfigUpdateListener}.
+ * Event listener interface for real-time Remote Config updates. Implement {@link
+ * ConfigUpdateListener} to call {@link
+ * com.google.firebase.remoteconfig.FirebaseRemoteConfig#addOnConfigUpdateListener}.
  */
 public interface ConfigUpdateListener {
   /**
-   * Callback for when a new config has been automatically fetched from the backend and has changed
-   * from the activated config.
+   * Callback for when a new config version has been automatically fetched from the backend and has
+   * changed from the activated config.
    *
-   * @param configUpdate A {@link ConfigUpdate} with information about the updated config, including
-   *     the set of updated parameters.
+   * @param configUpdate A {@link ConfigUpdate} with information about the updated config version,
+   *     including the set of updated parameters.
    */
   void onUpdate(@NonNull ConfigUpdate configUpdate);
 
   /**
-   * Callback for when an error occurs while listening or fetching a config update.
+   * Callback for when an error occurs while listening for updates or fetching the latest version of
+   * the config.
    *
    * @param error A {@link FirebaseRemoteConfigException} with information about the error.
    */

firebase-config/src/main/java/com/google/firebase/remoteconfig/FirebaseRemoteConfig.java

@@ -549,21 +549,21 @@ public Task<Void> reset() {
   }
 
   /**
-   * Start listening for real-time config updates from the Remote Config backend and automatically
-   * fetch updates from the RC backend when they are available.
+   * Starts listening for real-time config updates from the Remote Config backend and automatically
+   * fetches updates from the RC backend when they are available.
    *
    * <p>If a connection to the Remote Config backend is not already open, calling this method will
    * open it. Multiple listeners can be added by calling this method again, but subsequent calls
    * re-use the same connection to the backend.
    *
    * <p>Note: Real-time Remote Config requires the Firebase Remote Config Realtime API. See the <a
-   * href="https://firebase.google.com/docs/remote-config/get-started">Remote Config Get Started
-   * </a> guide to enable the API.
+   * href="https://firebase.google.com/docs/remote-config/get-started#add-real-time-listener">Remote
+   * Config Get Started </a> guide to enable the API.
    *
    * @param configUpdateListener A {@link ConfigUpdateListener} that can be used to respond to
    *     config updates when they're fetched.
-   * @return A {@link ConfigUpdateListenerRegistration} that allows the user to remove the added
-   *     {@code configUpdateListener} and close the connection when there are no more listeners.
+   * @return A {@link ConfigUpdateListenerRegistration} that allows you to remove the added {@code
+   *     configUpdateListener} and close the connection when there are no more listeners.
    */
   @NonNull
   public ConfigUpdateListenerRegistration addOnConfigUpdateListener(

firebase-config/src/main/java/com/google/firebase/remoteconfig/FirebaseRemoteConfigClientException.java

@@ -45,7 +45,7 @@ public FirebaseRemoteConfigClientException(@NonNull String detailMessage, @NonNu
 
   /**
    * Creates a Firebase Remote Config client exception with the given message, exception cause, and
-   * FirebaseRemoteConfigException code.
+   * {@code FirebaseRemoteConfigException} code.
    */
   public FirebaseRemoteConfigClientException(
       @NonNull String detailMessage, @Nullable Throwable cause, @NonNull Code code) {

firebase-config/src/main/java/com/google/firebase/remoteconfig/FirebaseRemoteConfigServerException.java

@@ -45,8 +45,8 @@ public FirebaseRemoteConfigServerException(
   }
 
   /**
-   * Creates a Firebase Remote Config server exception with the given message and
-   * FirebaseRemoteConfigException code.
+   * Creates a Firebase Remote Config server exception with the given message and {@code
+   * FirebaseRemoteConfigException} code.
    */
   public FirebaseRemoteConfigServerException(@NonNull String detailMessage, @Nonnull Code code) {
     super(detailMessage, code);
@@ -55,7 +55,7 @@ public FirebaseRemoteConfigServerException(@NonNull String detailMessage, @Nonnu
 
   /**
    * Creates a Firebase Remote Config server exception with the HTTP status code, given message, and
-   * FirebaseRemoteConfigException code.
+   * {@code FirebaseRemoteConfigException} code.
    */
   public FirebaseRemoteConfigServerException(
       int httpStatusCode, @NonNull String detailMessage, @Nonnull Code code) {
@@ -65,7 +65,7 @@ public FirebaseRemoteConfigServerException(
 
   /**
    * Creates a Firebase Remote Config server exception with the given message, exception cause, and
-   * FirebaseRemoteConfigException code.
+   * {@code FirebaseRemoteConfigException} code.
    */
   public FirebaseRemoteConfigServerException(
       @NonNull String detailMessage, @Nullable Throwable cause, @NonNull Code code) {
@@ -75,7 +75,7 @@ public FirebaseRemoteConfigServerException(
 
   /**
    * Creates a Firebase Remote Config server exception with the HTTP status code, given message,
-   * exception cause, and FirebaseRemoteConfigException code.
+   * exception cause, and {@code FirebaseRemoteConfigException} code.
    */
   public FirebaseRemoteConfigServerException(
       int httpStatusCode,

firebase-crashlytics-ndk/firebase-crashlytics-ndk.gradle

@@ -18,7 +18,10 @@ plugins {
 }
 
 firebaseLibrary {
-    testLab.enabled = true
+    testLab {
+        enabled = true
+        device 'model=panther,version=33' // Pixel7
+    }
     publishJavadoc = false
 }
 

firebase-crashlytics/CHANGELOG.md

@@ -1,9 +1,7 @@
 # Unreleased
+* [changed] Added support for reporting GWP-ASan crashes on supported API levels.(#4721)
 * [changed] Improved crash reporting reliability for crashes that occur early in the app's
-  lifecycle.
-* [changed] Add improved support capturing build ids for Native ANRs on older
-  Android versions.
-
+  lifecycle.(#4608, #4786)
 
 # 18.3.5
 * [fixed] Updated `firebase-common` to its latest version (v20.3.0) to fix an

firebase-crashlytics/firebase-crashlytics.gradle

@@ -68,7 +68,7 @@ dependencies {
     implementation project(':transport:transport-runtime')
     implementation project(':transport:transport-backend-cct')
     implementation 'com.google.firebase:firebase-installations-interop:17.1.0'
-    runtimeOnly project(':firebase-installations')
+    runtimeOnly 'com.google.firebase:firebase-installations:17.1.3'
     implementation 'com.google.firebase:firebase-measurement-connector:18.0.2'
     implementation "com.google.android.gms:play-services-tasks:18.0.1"
 

firebase-firestore/src/androidTest/java/com/google/firebase/firestore/QueryTest.java

@@ -37,6 +37,7 @@
 import com.google.android.gms.tasks.Task;
 import com.google.common.collect.Lists;
 import com.google.firebase.firestore.Query.Direction;
+import com.google.firebase.firestore.remote.ExistenceFilterMismatchListener;
 import com.google.firebase.firestore.testutil.EventAccumulator;
 import com.google.firebase.firestore.testutil.IntegrationTestUtil;
 import java.util.ArrayList;
@@ -1053,6 +1054,7 @@ public void resumingAQueryShouldUseExistenceFilterToDetectDeletes() throws Excep
         createdDocuments.add(documentSnapshot.getReference());
       }
     }
+    assertWithMessage("createdDocuments").that(createdDocuments).hasSize(100);
 
     // Delete 50 of the 100 documents. Do this in a transaction, rather than
     // DocumentReference.delete(), to avoid affecting the local cache.
@@ -1069,13 +1071,33 @@ public void resumingAQueryShouldUseExistenceFilterToDetectDeletes() throws Excep
                   }
                   return null;
                 }));
+    assertWithMessage("deletedDocumentIds").that(deletedDocumentIds).hasSize(50);
 
     // Wait for 10 seconds, during which Watch will stop tracking the query and will send an
     // existence filter rather than "delete" events when the query is resumed.
     Thread.sleep(10000);
 
-    // Resume the query and save the resulting snapshot for verification.
-    QuerySnapshot snapshot2 = waitFor(collection.get());
+    // Resume the query and save the resulting snapshot for verification. Use some internal testing
+    // hooks to "capture" the existence filter mismatches to verify them.
+    ExistenceFilterMismatchListener existenceFilterMismatchListener =
+        new ExistenceFilterMismatchListener();
+    QuerySnapshot snapshot2;
+    ExistenceFilterMismatchListener.ExistenceFilterMismatchInfo existenceFilterMismatchInfo;
+    try {
+      existenceFilterMismatchListener.startListening();
+      snapshot2 = waitFor(collection.get());
+      // TODO(b/270731363): Remove the "if" condition below once the Firestore Emulator is fixed
+      //  to send an existence filter.
+      if (isRunningAgainstEmulator()) {
+        existenceFilterMismatchInfo = null;
+      } else {
+        existenceFilterMismatchInfo =
+            existenceFilterMismatchListener.getOrWaitForExistenceFilterMismatch(
+                /*timeoutMillis=*/ 5000);
+      }
+    } finally {
+      existenceFilterMismatchListener.stopListening();
+    }
 
     // Verify that the snapshot from the resumed query contains the expected documents; that is,
     // that it contains the 50 documents that were _not_ deleted.
@@ -1098,6 +1120,26 @@ public void resumingAQueryShouldUseExistenceFilterToDetectDeletes() throws Excep
           .that(actualDocumentIds)
           .containsExactlyElementsIn(expectedDocumentIds);
     }
+
+    // Skip the verification of the existence filter mismatch when testing against the Firestore
+    // emulator because the Firestore emulator fails to to send an existence filter at all.
+    // TODO(b/270731363): Enable the verification of the existence filter mismatch once the
+    // Firestore emulator is fixed to send an existence filter.
+    if (isRunningAgainstEmulator()) {
+      return;
+    }
+
+    // Verify that Watch sent an existence filter with the correct counts when the query was
+    // resumed.
+    assertWithMessage("Watch should have sent an existence filter")
+        .that(existenceFilterMismatchInfo)
+        .isNotNull();
+    assertWithMessage("localCacheCount")
+        .that(existenceFilterMismatchInfo.localCacheCount())
+        .isEqualTo(100);
+    assertWithMessage("existenceFilterCount")
+        .that(existenceFilterMismatchInfo.existenceFilterCount())
+        .isEqualTo(50);
   }
 
   @Test

firebase-firestore/src/androidTest/java/com/google/firebase/firestore/remote/ExistenceFilterMismatchListener.java

@@ -0,0 +1,150 @@
+// 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.
+
+package com.google.firebase.firestore.remote;
+
+import android.os.SystemClock;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.firebase.firestore.ListenerRegistration;
+import java.util.ArrayList;
+
+/**
+ * Provides a mechanism for tests to listen for existence filter mismatches in the Watch "listen"
+ * stream.
+ */
+public final class ExistenceFilterMismatchListener {
+
+  private TestingHooksExistenceFilterMismatchListenerImpl listener;
+  private ListenerRegistration listenerRegistration;
+
+  /**
+   * Starts listening for existence filter mismatches.
+   *
+   * @throws IllegalStateException if this object is already started.
+   * @see #stopListening
+   */
+  public synchronized void startListening() {
+    if (listener != null) {
+      throw new IllegalStateException("already registered");
+    }
+    listener = new TestingHooksExistenceFilterMismatchListenerImpl();
+    listenerRegistration = TestingHooks.getInstance().addExistenceFilterMismatchListener(listener);
+  }
+
+  /**
+   * Stops listening for existence filter mismatches.
+   *
+   * <p>If listening has not been started then this method does nothing.
+   *
+   * @see #startListening
+   */
+  public synchronized void stopListening() {
+    if (listenerRegistration != null) {
+      listenerRegistration.remove();
+    }
+    listenerRegistration = null;
+    listener = null;
+  }
+
+  /**
+   * Returns the oldest existence filter mismatch observed, waiting if none has yet been observed.
+   *
+   * <p>The oldest existence filter mismatch observed since the most recent successful invocation of
+   * {@link #startListening} will be returned. A subsequent invocation of this method will return
+   * the second-oldest existence filter mismatch observed, and so on. An invocation of {@link
+   * #stopListening} followed by another invocation of {@link #startListening} will discard any
+   * existence filter mismatches that occurred while previously started and will start observing
+   * afresh.
+   *
+   * @param timeoutMillis the maximum amount of time, in milliseconds, to wait for an existence
+   *     filter mismatch to occur.
+   * @return information about the existence filter mismatch that occurred.
+   * @throws InterruptedException if waiting is interrupted.
+   * @throws IllegalStateException if this object has not been started by {@link #startListening}.
+   * @throws IllegalArgumentException if the given timeout is less than or equal to zero.
+   */
+  @Nullable
+  public ExistenceFilterMismatchInfo getOrWaitForExistenceFilterMismatch(long timeoutMillis)
+      throws InterruptedException {
+    if (timeoutMillis <= 0) {
+      throw new IllegalArgumentException("invalid timeout: " + timeoutMillis);
+    }
+
+    TestingHooksExistenceFilterMismatchListenerImpl registeredListener;
+    synchronized (this) {
+      registeredListener = listener;
+    }
+
+    if (registeredListener == null) {
+      throw new IllegalStateException(
+          "must be registered before waiting for an existence filter mismatch");
+    }
+
+    return registeredListener.getOrWaitForExistenceFilterMismatch(timeoutMillis);
+  }
+
+  private static final class TestingHooksExistenceFilterMismatchListenerImpl
+      implements TestingHooks.ExistenceFilterMismatchListener {
+
+    private final ArrayList<ExistenceFilterMismatchInfo> existenceFilterMismatches =
+        new ArrayList<>();
+
+    @Override
+    public synchronized void onExistenceFilterMismatch(
+        @NonNull TestingHooks.ExistenceFilterMismatchInfo info) {
+      existenceFilterMismatches.add(new ExistenceFilterMismatchInfo(info));
+      notifyAll();
+    }
+
+    @Nullable
+    synchronized ExistenceFilterMismatchInfo getOrWaitForExistenceFilterMismatch(long timeoutMillis)
+        throws InterruptedException {
+      if (timeoutMillis <= 0) {
+        throw new IllegalArgumentException("invalid timeout: " + timeoutMillis);
+      }
+
+      long endTimeMillis = SystemClock.uptimeMillis() + timeoutMillis;
+      while (true) {
+        if (existenceFilterMismatches.size() > 0) {
+          return existenceFilterMismatches.remove(0);
+        }
+        long currentWaitMillis = endTimeMillis - SystemClock.uptimeMillis();
+        if (currentWaitMillis <= 0) {
+          return null;
+        }
+
+        wait(currentWaitMillis);
+      }
+    }
+  }
+
+  /** @see TestingHooks.ExistenceFilterMismatchInfo */
+  public static final class ExistenceFilterMismatchInfo {
+
+    private final TestingHooks.ExistenceFilterMismatchInfo info;
+
+    ExistenceFilterMismatchInfo(@NonNull TestingHooks.ExistenceFilterMismatchInfo info) {
+      this.info = info;
+    }
+
+    public int localCacheCount() {
+      return info.localCacheCount();
+    }
+
+    public int existenceFilterCount() {
+      return info.existenceFilterCount();
+    }
+  }
+}