feat(firestore): support for PersistentCacheIndexManager for firestore instances for managing cache indexes. (#13070)

* feat(firestore): initial setup for `PersistentCacheIndexManager`

* chore: fix melos format script

* fix(firestore): update pigeon API for new cache manager methods

* feat: update method handlers for cache manager

* feat(firestore): persistence cache manager implementation for ios + android

* feat(firestore): cache manager index implementation for web

* refactor: use only one method for native to save duplication

* chore: format

* refactor(firestore): method channel use single method for persistence manager

* chore: update method channel name

* fix(web: remove firestore instance from invocation

* fix: add break statements to ios switch statement

* chore: add license header

* chore: fix analyser issues

* fix(apple): revert back to `index` to fix

* tests(firestore): `PersistentCacheIndexManager`

* chore: make delegate private

* chore: remove obsolete code

* refactor: return null if persistence is not enabled

* chore: fix test scoping

* fix: settings on firestore web was always creating new Settings object

* tests: test every scenario for `PersistenceCacheIndexManager`

* chore: fix analyse

Author: russellwheatley

melos.yaml

@@ -229,7 +229,7 @@ scripts:
       melos exec -- "flutter pub run pigeon --input ./pigeons/messages.dart" && \
       melos run generate:pigeon:macos --no-select && \
       melos run generate:pigeon:android --no-select && \
-      melos run format --no-select
+      melos run format-ci --no-select
     packageFilters:
       fileExists: 'pigeons/messages.dart'
     description: Generate the pigeon messages for all the supported packages.

packages/cloud_firestore/cloud_firestore/android/src/main/java/io/flutter/plugins/firebase/firestore/FlutterFirebaseFirestorePlugin.java

@@ -9,6 +9,7 @@
 import static com.google.firebase.firestore.AggregateField.sum;
 
 import android.app.Activity;
+import android.util.Log;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import com.google.android.gms.tasks.Task;
@@ -24,6 +25,7 @@
 import com.google.firebase.firestore.FirebaseFirestore;
 import com.google.firebase.firestore.FirebaseFirestoreSettings;
 import com.google.firebase.firestore.MemoryCacheSettings;
+import com.google.firebase.firestore.PersistentCacheIndexManager;
 import com.google.firebase.firestore.PersistentCacheSettings;
 import com.google.firebase.firestore.Query;
 import com.google.firebase.firestore.QuerySnapshot;
@@ -64,7 +66,7 @@ public class FlutterFirebaseFirestorePlugin
         GeneratedAndroidFirebaseFirestore.FirebaseFirestoreHostApi {
   protected static final HashMap<FirebaseFirestore, FlutterFirebaseFirestoreExtension>
       firestoreInstanceCache = new HashMap<>();
-
+  public static final String TAG = "FlutterFirestorePlugin";
   public static final String DEFAULT_ERROR_CODE = "firebase_firestore";
 
   private static final String METHOD_CHANNEL_NAME = "plugins.flutter.io/firebase_firestore";
@@ -473,6 +475,35 @@ public void setIndexConfiguration(
         });
   }
 
+  @Override
+  public void persistenceCacheIndexManagerRequest(
+      @NonNull GeneratedAndroidFirebaseFirestore.FirestorePigeonFirebaseApp app,
+      @NonNull GeneratedAndroidFirebaseFirestore.PersistenceCacheIndexManagerRequest request,
+      @NonNull GeneratedAndroidFirebaseFirestore.Result<Void> result) {
+    cachedThreadPool.execute(
+        () -> {
+          PersistentCacheIndexManager indexManager =
+              getFirestoreFromPigeon(app).getPersistentCacheIndexManager();
+          if (indexManager != null) {
+            switch (request) {
+              case ENABLE_INDEX_AUTO_CREATION:
+                indexManager.enableIndexAutoCreation();
+                break;
+              case DISABLE_INDEX_AUTO_CREATION:
+                indexManager.disableIndexAutoCreation();
+                break;
+              case DELETE_ALL_INDEXES:
+                indexManager.deleteAllIndexes();
+                break;
+            }
+          } else {
+            Log.d(TAG, "`PersistentCacheIndexManager` is not available.");
+          }
+
+          result.success(null);
+        });
+  }
+
   @Override
   public void setLoggingEnabled(
       @NonNull Boolean loggingEnabled,

packages/cloud_firestore/cloud_firestore/android/src/main/java/io/flutter/plugins/firebase/firestore/GeneratedAndroidFirebaseFirestore.java

@@ -166,6 +166,22 @@ private AggregateSource(final int index) {
     }
   }
 
+  /**
+   * [PersistenceCacheIndexManagerRequest] represents the request types for the persistence cache
+   * index manager.
+   */
+  public enum PersistenceCacheIndexManagerRequest {
+    ENABLE_INDEX_AUTO_CREATION(0),
+    DISABLE_INDEX_AUTO_CREATION(1),
+    DELETE_ALL_INDEXES(2);
+
+    final int index;
+
+    private PersistenceCacheIndexManagerRequest(final int index) {
+      this.index = index;
+    }
+  }
+
   public enum PigeonTransactionResult {
     SUCCESS(0),
     FAILURE(1);
@@ -1815,6 +1831,11 @@ void documentReferenceSnapshot(
         @NonNull ListenSource source,
         @NonNull Result<String> result);
 
+    void persistenceCacheIndexManagerRequest(
+        @NonNull FirestorePigeonFirebaseApp app,
+        @NonNull PersistenceCacheIndexManagerRequest request,
+        @NonNull Result<Void> result);
+
     /** The codec used by FirebaseFirestoreHostApi. */
     static @NonNull MessageCodec<Object> getCodec() {
       return FirebaseFirestoreHostApiCodec.INSTANCE;
@@ -2570,6 +2591,39 @@ public void error(Throwable error) {
           channel.setMessageHandler(null);
         }
       }
+      {
+        BasicMessageChannel<Object> channel =
+            new BasicMessageChannel<>(
+                binaryMessenger,
+                "dev.flutter.pigeon.cloud_firestore_platform_interface.FirebaseFirestoreHostApi.persistenceCacheIndexManagerRequest",
+                getCodec());
+        if (api != null) {
+          channel.setMessageHandler(
+              (message, reply) -> {
+                ArrayList<Object> wrapped = new ArrayList<Object>();
+                ArrayList<Object> args = (ArrayList<Object>) message;
+                FirestorePigeonFirebaseApp appArg = (FirestorePigeonFirebaseApp) args.get(0);
+                PersistenceCacheIndexManagerRequest requestArg =
+                    PersistenceCacheIndexManagerRequest.values()[(int) args.get(1)];
+                Result<Void> resultCallback =
+                    new Result<Void>() {
+                      public void success(Void result) {
+                        wrapped.add(0, null);
+                        reply.reply(wrapped);
+                      }
+
+                      public void error(Throwable error) {
+                        ArrayList<Object> wrappedError = wrapError(error);
+                        reply.reply(wrappedError);
+                      }
+                    };
+
+                api.persistenceCacheIndexManagerRequest(appArg, requestArg, resultCallback);
+              });
+        } else {
+          channel.setMessageHandler(null);
+        }
+      }
     }
   }
 }

packages/cloud_firestore/cloud_firestore/example/integration_test/instance_e2e.dart

@@ -6,6 +6,7 @@ import 'dart:async';
 import 'dart:convert';
 
 import 'package:cloud_firestore/cloud_firestore.dart';
+import 'package:firebase_core/firebase_core.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter_test/flutter_test.dart';
 
@@ -312,6 +313,121 @@ void runInstanceTests() {
           {'some': 'data'},
         );
       });
+      testWidgets(
+        '`PersistenceCacheIndexManager` with default persistence settings for each platform',
+        (widgetTester) async {
+          if (defaultTargetPlatform == TargetPlatform.windows) {
+            try {
+              // Windows does not have `PersistenceCacheIndexManager` support
+              FirebaseFirestore.instance.persistentCacheIndexManager();
+            } catch (e) {
+              expect(e, isInstanceOf<UnimplementedError>());
+            }
+          } else {
+            if (kIsWeb) {
+              // persistence is disabled by default on web
+              final firestore = FirebaseFirestore.instanceFor(
+                app: Firebase.app(),
+                // Use different firestore instance to test behavior
+                databaseId: 'default-web',
+              );
+              PersistentCacheIndexManager? indexManager =
+                  firestore.persistentCacheIndexManager();
+              expect(indexManager, isNull);
+            } else {
+              final firestore = FirebaseFirestore.instanceFor(
+                app: Firebase.app(),
+                // Use different firestore instance to test behavior
+                databaseId: 'default-other-platform-test',
+              );
+              // macOS, android, iOS have persistence enabled by default
+              PersistentCacheIndexManager? indexManager =
+                  firestore.persistentCacheIndexManager();
+              await indexManager!.enableIndexAutoCreation();
+              await indexManager.disableIndexAutoCreation();
+              await indexManager.deleteAllIndexes();
+            }
+          }
+        },
+      );
+
+      testWidgets(
+        '`PersistenceCacheIndexManager` with persistence enabled for each platform',
+        (widgetTester) async {
+          if (kIsWeb) {
+            final firestore = FirebaseFirestore.instanceFor(
+              app: Firebase.app(),
+              databaseId: 'web-enabled',
+            );
+            // persistence is disabled by default so we enable it
+            firestore.settings = const Settings(persistenceEnabled: true);
+
+            PersistentCacheIndexManager? indexManager =
+                firestore.persistentCacheIndexManager();
+
+            await indexManager!.enableIndexAutoCreation();
+            await indexManager.disableIndexAutoCreation();
+            await indexManager.deleteAllIndexes();
+
+            final firestore2 = FirebaseFirestore.instanceFor(
+              app: Firebase.app(),
+              databaseId: 'web-disabled-2',
+            );
+
+            // Now try using `enablePersistence()`, web only API
+            await firestore2.enablePersistence();
+
+            PersistentCacheIndexManager? indexManager2 =
+                firestore2.persistentCacheIndexManager();
+
+            await indexManager2!.enableIndexAutoCreation();
+            await indexManager2.disableIndexAutoCreation();
+            await indexManager2.deleteAllIndexes();
+          } else {
+            final firestore = FirebaseFirestore.instanceFor(
+              app: Firebase.app(),
+              databaseId: 'other-platform-enabled',
+            );
+            firestore.settings = const Settings(persistenceEnabled: true);
+            PersistentCacheIndexManager? indexManager =
+                firestore.persistentCacheIndexManager();
+            await indexManager!.enableIndexAutoCreation();
+            await indexManager.disableIndexAutoCreation();
+            await indexManager.deleteAllIndexes();
+          }
+        },
+        skip: defaultTargetPlatform == TargetPlatform.windows,
+      );
+
+      testWidgets(
+        '`PersistenceCacheIndexManager` with persistence disabled for each platform',
+        (widgetTester) async {
+          if (kIsWeb) {
+            final firestore = FirebaseFirestore.instanceFor(
+              app: Firebase.app(),
+              databaseId: 'web-disabled-1',
+            );
+            // persistence is disabled by default so we enable it
+            firestore.settings = const Settings(persistenceEnabled: false);
+
+            PersistentCacheIndexManager? indexManager =
+                firestore.persistentCacheIndexManager();
+
+            expect(indexManager, isNull);
+          } else {
+            final firestore = FirebaseFirestore.instanceFor(
+              app: Firebase.app(),
+              databaseId: 'other-platform-disabled',
+            );
+            // macOS, android, iOS have persistence enabled by default so we disable it
+            firestore.settings = const Settings(persistenceEnabled: false);
+            PersistentCacheIndexManager? indexManager =
+                firestore.persistentCacheIndexManager();
+            expect(indexManager, isNull);
+          }
+        },
+        skip: defaultTargetPlatform == TargetPlatform.windows,
+      );
     },
   );
 }

packages/cloud_firestore/cloud_firestore/ios/Classes/FLTFirebaseFirestorePlugin.m

@@ -6,6 +6,7 @@
 #import <firebase_core/FLTFirebasePluginRegistry.h>
 
 #import <TargetConditionals.h>
+#import "FirebaseFirestoreInternal/FIRPersistentCacheIndexManager.h"
 #import "Private/FLTDocumentSnapshotStreamHandler.h"
 #import "Private/FLTFirebaseFirestoreReader.h"
 #import "Private/FLTFirebaseFirestoreUtils.h"
@@ -566,6 +567,31 @@ - (void)setIndexConfigurationApp:(nonnull FirestorePigeonFirebaseApp *)app
                                 }];
 }
 
+- (void)persistenceCacheIndexManagerRequestApp:(FirestorePigeonFirebaseApp *)app
+                                       request:(PersistenceCacheIndexManagerRequest)request
+                                    completion:(void (^)(FlutterError *_Nullable))completion {
+  FIRPersistentCacheIndexManager *persistentCacheIndexManager =
+      [self getFIRFirestoreFromAppNameFromPigeon:app].persistentCacheIndexManager;
+
+  if (persistentCacheIndexManager) {
+    switch (request) {
+      case PersistenceCacheIndexManagerRequestEnableIndexAutoCreation:
+        [persistentCacheIndexManager enableIndexAutoCreation];
+        break;
+      case PersistenceCacheIndexManagerRequestDisableIndexAutoCreation:
+        [persistentCacheIndexManager disableIndexAutoCreation];
+        break;
+      case PersistenceCacheIndexManagerRequestDeleteAllIndexes:
+        [persistentCacheIndexManager deleteAllIndexes];
+        break;
+    }
+  } else {
+    // Put because `persistentCacheIndexManager` is a nullable property
+    NSLog(@"FLTFirebaseFirestore: `PersistentCacheIndexManager` is not available.");
+  }
+  completion(nil);
+}
+
 - (void)setLoggingEnabledLoggingEnabled:(nonnull NSNumber *)loggingEnabled
                              completion:(nonnull void (^)(FlutterError *_Nullable))completion {
   [FIRFirestore enableLogging:[loggingEnabled boolValue]];

packages/cloud_firestore/cloud_firestore/ios/Classes/FirestoreMessages.g.m

@@ -77,6 +77,18 @@ - (instancetype)initWithValue:(AggregateSource)value {
 }
 @end
 
+/// [PersistenceCacheIndexManagerRequest] represents the request types for the persistence cache
+/// index manager.
+@implementation PersistenceCacheIndexManagerRequestBox
+- (instancetype)initWithValue:(PersistenceCacheIndexManagerRequest)value {
+  self = [super init];
+  if (self) {
+    _value = value;
+  }
+  return self;
+}
+@end
+
 @implementation PigeonTransactionResultBox
 - (instancetype)initWithValue:(PigeonTransactionResult)value {
   self = [super init];
@@ -1340,4 +1352,31 @@ void FirebaseFirestoreHostApiSetup(id<FlutterBinaryMessenger> binaryMessenger,
       [channel setMessageHandler:nil];
     }
   }
+  {
+    FlutterBasicMessageChannel *channel = [[FlutterBasicMessageChannel alloc]
+           initWithName:@"dev.flutter.pigeon.cloud_firestore_platform_interface."
+                        @"FirebaseFirestoreHostApi.persistenceCacheIndexManagerRequest"
+        binaryMessenger:binaryMessenger
+                  codec:FirebaseFirestoreHostApiGetCodec()];
+    if (api) {
+      NSCAssert([api respondsToSelector:@selector
+                     (persistenceCacheIndexManagerRequestApp:request:completion:)],
+                @"FirebaseFirestoreHostApi api (%@) doesn't respond to "
+                @"@selector(persistenceCacheIndexManagerRequestApp:request:completion:)",
+                api);
+      [channel setMessageHandler:^(id _Nullable message, FlutterReply callback) {
+        NSArray *args = message;
+        FirestorePigeonFirebaseApp *arg_app = GetNullableObjectAtIndex(args, 0);
+        PersistenceCacheIndexManagerRequest arg_request =
+            [GetNullableObjectAtIndex(args, 1) integerValue];
+        [api persistenceCacheIndexManagerRequestApp:arg_app
+                                            request:arg_request
+                                         completion:^(FlutterError *_Nullable error) {
+                                           callback(wrapResult(nil, error));
+                                         }];
+      }];
+    } else {
+      [channel setMessageHandler:nil];
+    }
+  }
 }

packages/cloud_firestore/cloud_firestore/ios/Classes/Public/FirestoreMessages.g.h

@@ -109,6 +109,20 @@ typedef NS_ENUM(NSUInteger, AggregateSource) {
 - (instancetype)initWithValue:(AggregateSource)value;
 @end
 
+/// [PersistenceCacheIndexManagerRequest] represents the request types for the persistence cache
+/// index manager.
+typedef NS_ENUM(NSUInteger, PersistenceCacheIndexManagerRequest) {
+  PersistenceCacheIndexManagerRequestEnableIndexAutoCreation = 0,
+  PersistenceCacheIndexManagerRequestDisableIndexAutoCreation = 1,
+  PersistenceCacheIndexManagerRequestDeleteAllIndexes = 2,
+};
+
+/// Wrapper for PersistenceCacheIndexManagerRequest to allow for nullability.
+@interface PersistenceCacheIndexManagerRequestBox : NSObject
+@property(nonatomic, assign) PersistenceCacheIndexManagerRequest value;
+- (instancetype)initWithValue:(PersistenceCacheIndexManagerRequest)value;
+@end
+
 typedef NS_ENUM(NSUInteger, PigeonTransactionResult) {
   PigeonTransactionResultSuccess = 0,
   PigeonTransactionResultFailure = 1,
@@ -399,6 +413,9 @@ NSObject<FlutterMessageCodec> *FirebaseFirestoreHostApiGetCodec(void);
                               source:(ListenSource)source
                           completion:
                               (void (^)(NSString *_Nullable, FlutterError *_Nullable))completion;
+- (void)persistenceCacheIndexManagerRequestApp:(FirestorePigeonFirebaseApp *)app
+                                       request:(PersistenceCacheIndexManagerRequest)request
+                                    completion:(void (^)(FlutterError *_Nullable))completion;
 @end
 
 extern void FirebaseFirestoreHostApiSetup(id<FlutterBinaryMessenger> binaryMessenger,