persistentCacheIndexManager

public @NullablePersistentCacheIndexManager persistentCacheIndexManager

addSnapshotsInSyncListener

public @NonNullListenerRegistration addSnapshotsInSyncListener(@NonNullRunnable runnable)

Attaches a listener for a snapshots-in-sync event. The snapshots-in-sync event indicates that all listeners affected by a given change have fired, even if a single server-generated change affects multiple listeners.

NOTE: The snapshots-in-sync event only indicates that listeners are in sync with each other, but does not relate to whether those snapshots are in sync with the server. Use SnapshotMetadata in the individual listeners to determine if a snapshot is from the cache or the server.

addSnapshotsInSyncListener

public @NonNullListenerRegistration addSnapshotsInSyncListener(
    @NonNullActivity activity,
    @NonNullRunnable runnable
)

Attaches a listener for a snapshots-in-sync event. The snapshots-in-sync event indicates that all listeners affected by a given change have fired, even if a single server-generated change affects multiple listeners.

NOTE: The snapshots-in-sync event only indicates that listeners are in sync with each other, but does not relate to whether those snapshots are in sync with the server. Use SnapshotMetadata in the individual listeners to determine if a snapshot is from the cache or the server.

addSnapshotsInSyncListener

public @NonNullListenerRegistration addSnapshotsInSyncListener(
    @NonNullExecutor executor,
    @NonNullRunnable runnable
)

Attaches a listener for a snapshots-in-sync event. The snapshots-in-sync event indicates that all listeners affected by a given change have fired, even if a single server-generated change affects multiple listeners.

NOTE: The snapshots-in-sync event only indicates that listeners are in sync with each other, but does not relate to whether those snapshots are in sync with the server. Use SnapshotMetadata in the individual listeners to determine if a snapshot is from the cache or the server.

batch

public @NonNullWriteBatch batch()

Creates a write batch, used for performing multiple writes as a single atomic operation.

The maximum number of writes allowed in a single batch is 500, but note that each usage ofserverTimestamp,arrayUnion,arrayRemove, orincrement inside a transaction counts as an additional write.

clearPersistence

public @NonNullTask<Void> clearPersistence()

Clears the persistent storage, including pending writes and cached documents.

Must be called while theFirebaseFirestore instance is not started (after the app is shutdown or when the app is first initialized). On startup, this method must be called before other methods (other thansetFirestoreSettings). If theFirebaseFirestore instance is still running, theTask will fail with an error code ofFAILED_PRECONDITION.

Note:clearPersistence() is primarily intended to help write reliable tests that use Cloud Firestore. It uses an efficient mechanism for dropping existing data but does not attempt to securely overwrite or otherwise make cached data unrecoverable. For applications that are sensitive to the disclosure of cached data in between user sessions, we strongly recommend not enabling persistence at all.

collection

public @NonNullCollectionReference collection(@NonNullString collectionPath)

Gets aCollectionReference instance that refers to the collection at the specified path within the database.

collectionGroup

public @NonNullQuery collectionGroup(@NonNullString collectionId)

Creates and returns a newQuery that includes all documents in the database that are contained in a collection or subcollection with the givencollectionId.

disableNetwork

public @NonNullTask<Void> disableNetwork()

Disables network access for this instance. While the network is disabled, any snapshot listeners orget() calls will return results from cache, and any write operations will be queued until network usage is re-enabled via a call toenableNetwork.

document

public @NonNullDocumentReference document(@NonNullString documentPath)

Gets a `DocumentReference` instance that refers to the document at the specified path within the database.

enableNetwork

public @NonNullTask<Void> enableNetwork()

Re-enables network usage for this instance after a prior call todisableNetwork.

getApp

public @NonNullFirebaseApp getApp()

Returns the FirebaseApp instance to which thisFirebaseFirestore belongs.

getFirestoreSettings

public @NonNullFirebaseFirestoreSettings getFirestoreSettings()

Returns the settings used by thisFirebaseFirestore object.

getInstance

public static @NonNullFirebaseFirestore getInstance()

Returns the defaultFirebaseFirestore instance for the defaultFirebaseApp.

Returns the same instance for all invocations. If no instance exists, initializes a new instance.

TheFirebaseFirestore instance.

getInstance

public static @NonNullFirebaseFirestore getInstance(@NonNullFirebaseApp app)

Returns the defaultFirebaseFirestore instance for the providedFirebaseApp.

For a givenFirebaseApp, invocation always returns the same instance. If no instance exists, initializes a new instance.

TheFirebaseFirestore instance.

getInstance

public static @NonNullFirebaseFirestore getInstance(@NonNullString database)

Returns theFirebaseFirestore instance for the defaultFirebaseApp.

Returns the same instance for all invocations given the same database parameter. If no instance exists, initializes a new instance.

TheFirebaseFirestore instance.

getInstance

public static @NonNullFirebaseFirestore getInstance(@NonNullFirebaseApp app, @NonNullString database)

Returns theFirebaseFirestore instance for the providedFirebaseApp.

Returns the same instance for all invocations given the sameFirebaseApp and database parameter. If no instance exists, initializes a new instance.

TheFirebaseFirestore instance.

getNamedQuery

public @NonNullTask<Query> getNamedQuery(@NonNullString name)

Reads a FirestoreQuery from local cache, identified by the given name.

The named queries are packaged into bundles on the server side (along with resulting documents) and loaded to local cache usingloadBundle. Once in local cache, you can use this method to extract a query by name.

getPersistentCacheIndexManager

public @NullablePersistentCacheIndexManager getPersistentCacheIndexManager()

Gets thePersistentCacheIndexManager instance used by thisFirebaseFirestore object.

This is not the same as Cloud Firestore Indexes. Persistent cache indexes are optional indexes that only exist within the SDK to assist in local query execution.

loadBundle

public @NonNullLoadBundleTask loadBundle(@NonNull byte[] bundleData)

Loads a Firestore bundle into the local cache.

loadBundle

public @NonNullLoadBundleTask loadBundle(@NonNullByteBuffer bundleData)

Loads a Firestore bundle into the local cache.

loadBundle

public @NonNullLoadBundleTask loadBundle(@NonNullInputStream bundleData)

Loads a Firestore bundle into the local cache.

runBatch

public @NonNullTask<Void> runBatch(@NonNullWriteBatch.Function batchFunction)

Executes a batchFunction on a newly createdWriteBatch and then commits all of the writes made by the batchFunction as a single atomic unit.

runTransaction

public @NonNullTask<TResult> <TResult>runTransaction(
    @NonNullTransaction.Function<TResult> updateFunction
)

Executes the givenupdateFunction and then attempts to commit the changes applied within the transaction. If any document read within the transaction has changed, the updateFunction will be retried. If it fails to commit after 5 attempts (the default failure limit), the transaction will fail. To have a different number of retries, use therunTransaction method instead.

runTransaction

public @NonNullTask<TResult> <TResult>runTransaction(
    @NonNullTransactionOptions options,
    @NonNullTransaction.Function<TResult> updateFunction
)

Executes the givenupdateFunction and then attempts to commit the changes applied within the transaction. If any document read within the transaction has changed, the updateFunction will be retried. If it fails to commit after the maxmimum number of attempts specified in transactionOptions, the transaction will fail.

setFirestoreSettings

public void setFirestoreSettings(@NonNullFirebaseFirestoreSettings settings)

Sets any custom settings used to configure thisFirebaseFirestore object. This method can only be called before calling any other methods on this object.

setIndexConfiguration

@PreviewApi
public @NonNullTask<Void> setIndexConfiguration(@NonNullString json)

Instead of creating cache indexes manually, consider usingenableIndexAutoCreation to let the SDK decide whether to create cache indexes for queries running locally.

Configures indexing for local query execution. Any previous index configuration is overridden. The Task resolves once the index configuration has been persisted.

The index entries themselves are created asynchronously. You can continue to use queries that require indexing even if the indices are not yet available. Query execution will automatically start using the index once the index entries have been written.

The method accepts the JSON format exported by the Firebase CLI (`firebase firestore:indexes`). If the JSON format is invalid, this method throws an exception.

setLoggingEnabled

public static void setLoggingEnabled(boolean loggingEnabled)

Globally enables / disables Cloud Firestore logging for the SDK.

terminate

public @NonNullTask<Void> terminate()

Terminates thisFirebaseFirestore instance.

After callingterminate() only theclearPersistence method may be used. Any other method will throw anIllegalStateException.

To restart after termination, simply create a new instance ofFirebaseFirestore withgetInstance orgetInstance.

terminate() does not cancel any pending writes and any tasks that are awaiting a response from the server will not be resolved. The next time you start this instance, it will resume attempting to send these writes to the server.

Note: Under normal circumstances, callingterminate() is not required. This method is useful only when you want to force this instance to release all of its resources or in combination with clearPersistence to ensure that all local state is destroyed between test runs.

useEmulator

public void useEmulator(@NonNullString host, int port)

Modifies this FirebaseDatabase instance to communicate with the Cloud Firestore emulator.

Note: Call this method before using the instance to do any database operations.

waitForPendingWrites

public @NonNullTask<Void> waitForPendingWrites()

Waits until all currently pending writes for the active user have been acknowledged by the backend.

The returned Task completes immediately if there are no outstanding writes. Otherwise, the Task waits for all previously issued writes (including those written in a previous app session), but it does not wait for writes that were added after the method is called. If you wish to wait for additional writes, you have to callwaitForPendingWrites() again.

Any outstandingwaitForPendingWrites() Tasks are cancelled during user changes.