Throw error in subsequent function calls after the client is shutdown (#375)

Author: Brian Chen

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

@@ -953,4 +953,11 @@ public void testCanDisableAndEnableNetworking() {
     waitFor(firestore.disableNetwork());
     waitFor(firestore.enableNetwork());
   }
+
+  @Test
+  public void testClientCallsAfterShutdownFails() {
+    FirebaseFirestore firestore = testFirestore();
+    waitFor(firestore.shutdown());
+    expectError(() -> waitFor(firestore.disableNetwork()), "The client has already been shutdown");
+  }
 }

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

@@ -333,11 +333,9 @@ public Task<Void> runBatch(@NonNull WriteBatch.Function batchFunction) {
 
   @VisibleForTesting
   Task<Void> shutdown() {
-    if (client == null) {
-      return Tasks.forResult(null);
-    } else {
-      return client.shutdown();
-    }
+    // The client must be initialized to ensure that all subsequent API usage throws an exception.
+    this.ensureClientConfigured();
+    return client.shutdown();
   }
 
   @VisibleForTesting

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

@@ -75,6 +75,7 @@ public final class FirestoreClient implements RemoteStore.RemoteStoreCallback {
   private RemoteStore remoteStore;
   private SyncEngine syncEngine;
   private EventManager eventManager;
+  private boolean isShutdown = false;
 
   // LRU-related
   @Nullable private LruGarbageCollector.Scheduler lruScheduler;
@@ -125,15 +126,20 @@ public FirestoreClient(
   }
 
   public Task<Void> disableNetwork() {
+    this.verifyNotShutdown();
     return asyncQueue.enqueue(() -> remoteStore.disableNetwork());
   }
 
   public Task<Void> enableNetwork() {
+    this.verifyNotShutdown();
     return asyncQueue.enqueue(() -> remoteStore.enableNetwork());
   }
 
   /** Shuts down this client, cancels all writes / listeners, and releases all resources. */
   public Task<Void> shutdown() {
+    if (this.isShutdown) {
+      return Tasks.forResult(null);
+    }
     credentialsProvider.removeChangeListener();
     return asyncQueue.enqueue(
         () -> {
@@ -142,23 +148,27 @@ public Task<Void> shutdown() {
           if (lruScheduler != null) {
             lruScheduler.stop();
           }
+          this.isShutdown = true;
         });
   }
 
   /** Starts listening to a query. */
   public QueryListener listen(
       Query query, ListenOptions options, EventListener<ViewSnapshot> listener) {
+    this.verifyNotShutdown();
     QueryListener queryListener = new QueryListener(query, options, listener);
     asyncQueue.enqueueAndForget(() -> eventManager.addQueryListener(queryListener));
     return queryListener;
   }
 
   /** Stops listening to a query previously listened to. */
   public void stopListening(QueryListener listener) {
+    this.verifyNotShutdown();
     asyncQueue.enqueueAndForget(() -> eventManager.removeQueryListener(listener));
   }
 
   public Task<Document> getDocumentFromLocalCache(DocumentKey docKey) {
+    this.verifyNotShutdown();
     return asyncQueue
         .enqueue(() -> localStore.readDocument(docKey))
         .continueWith(
@@ -180,6 +190,7 @@ public Task<Document> getDocumentFromLocalCache(DocumentKey docKey) {
   }
 
   public Task<ViewSnapshot> getDocumentsFromLocalCache(Query query) {
+    this.verifyNotShutdown();
     return asyncQueue.enqueue(
         () -> {
           ImmutableSortedMap<DocumentKey, Document> docs = localStore.executeQuery(query);
@@ -196,6 +207,7 @@ public Task<ViewSnapshot> getDocumentsFromLocalCache(Query query) {
 
   /** Writes mutations. The returned task will be notified when it's written to the backend. */
   public Task<Void> write(final List<Mutation> mutations) {
+    this.verifyNotShutdown();
     final TaskCompletionSource<Void> source = new TaskCompletionSource<>();
     asyncQueue.enqueueAndForget(() -> syncEngine.writeMutations(mutations, source));
     return source.getTask();
@@ -204,6 +216,7 @@ public Task<Void> write(final List<Mutation> mutations) {
   /** Tries to execute the transaction in updateFunction up to retries times. */
   public <TResult> Task<TResult> transaction(
       Function<Transaction, Task<TResult>> updateFunction, int retries) {
+    this.verifyNotShutdown();
     return AsyncQueue.callTask(
         asyncQueue.getExecutor(),
         () -> syncEngine.transaction(asyncQueue, updateFunction, retries));
@@ -255,6 +268,12 @@ private void initialize(Context context, User user, boolean usePersistence, long
     remoteStore.start();
   }
 
+  private void verifyNotShutdown() {
+    if (this.isShutdown) {
+      throw new IllegalArgumentException("The client has already been shutdown");
+    }
+  }
+
   @Override
   public void handleRemoteEvent(RemoteEvent remoteEvent) {
     syncEngine.handleRemoteEvent(remoteEvent);