setupDataCacheX function

Implementation

Future<void> setupDataCacheX({
  String? boxName,
  Duration? cleanupFrequency,
  CacheAdapterType adapterType = CacheAdapterType.hive,
  bool enableEncryption = false,
  String? encryptionKey,
  EncryptionOptions? encryptionOptions,
  Map<Type, TypeAdapter<CacheItem>>? customAdapters,
  Map<Type, DataSerializer>? customSerializers,
}) async {
  // Register TypeAdapterRegistry
  getIt.registerSingleton<TypeAdapterRegistry>(TypeAdapterRegistry());

  // Initialize Hive
  if (adapterType == CacheAdapterType.hive) {
    await Hive.initFlutter();
  }

  // Register default adapters
  final typeAdapterRegistry = getIt<TypeAdapterRegistry>();

  // Register custom adapters
  if (customAdapters != null) {
    customAdapters.forEach((type, adapter) {
      typeAdapterRegistry.registerAdapter(adapter);
      if (adapterType == CacheAdapterType.hive) {
        Hive.registerAdapter(adapter);
      }
    });
  }

  // Register default cache item adapters
  // First register the value adapters
  final stringAdapter = JsonTypeAdapter<String>(
      serializer: JsonDataSerializer<String>(), typeId: 1);
  typeAdapterRegistry.registerAdapter<String>(stringAdapter, typeId: 1);

  // Then create and register the cache item adapters
  final stringCacheItemAdapter =
      _CacheItemAdapter<String>(typeId: 1, valueAdapter: stringAdapter);
  typeAdapterRegistry.registerAdapter<String>(
    stringAdapter,
    typeId: 1,
    cacheItemAdapter: stringCacheItemAdapter,
  );

  if (adapterType == CacheAdapterType.hive) {
    Hive.registerAdapter(stringCacheItemAdapter);
  }
  // Register int adapter
  final intAdapter =
      JsonTypeAdapter<int>(serializer: JsonDataSerializer<int>(), typeId: 2);
  typeAdapterRegistry.registerAdapter<int>(intAdapter, typeId: 2);

  // Then create and register the cache item adapter
  final intCacheItemAdapter =
      _CacheItemAdapter<int>(typeId: 2, valueAdapter: intAdapter);
  typeAdapterRegistry.registerAdapter<int>(
    intAdapter,
    typeId: 2,
    cacheItemAdapter: intCacheItemAdapter,
  );

  if (adapterType == CacheAdapterType.hive) {
    Hive.registerAdapter(intCacheItemAdapter);
  }
  // Register double adapter
  final doubleAdapter = JsonTypeAdapter<double>(
      serializer: JsonDataSerializer<double>(), typeId: 3);
  typeAdapterRegistry.registerAdapter<double>(doubleAdapter, typeId: 3);

  // Then create and register the cache item adapter
  final doubleCacheItemAdapter =
      _CacheItemAdapter<double>(typeId: 3, valueAdapter: doubleAdapter);
  typeAdapterRegistry.registerAdapter<double>(
    doubleAdapter,
    typeId: 3,
    cacheItemAdapter: doubleCacheItemAdapter,
  );

  if (adapterType == CacheAdapterType.hive) {
    Hive.registerAdapter(doubleCacheItemAdapter);
  }
  // Register bool adapter
  final boolAdapter =
      JsonTypeAdapter<bool>(serializer: JsonDataSerializer<bool>(), typeId: 4);
  typeAdapterRegistry.registerAdapter<bool>(boolAdapter, typeId: 4);

  // Then create and register the cache item adapter
  final boolCacheItemAdapter =
      _CacheItemAdapter<bool>(typeId: 4, valueAdapter: boolAdapter);
  typeAdapterRegistry.registerAdapter<bool>(
    boolAdapter,
    typeId: 4,
    cacheItemAdapter: boolCacheItemAdapter,
  );

  if (adapterType == CacheAdapterType.hive) {
    Hive.registerAdapter(boolCacheItemAdapter);
  }
  // Register List<String> adapter
  final listStringAdapter = JsonTypeAdapter<List<String>>(
      serializer: JsonDataSerializer<List<String>>(), typeId: 5);
  typeAdapterRegistry.registerAdapter<List<String>>(listStringAdapter,
      typeId: 5);

  // Then create and register the cache item adapter
  final listStringCacheItemAdapter = _CacheItemAdapter<List<String>>(
      typeId: 5, valueAdapter: listStringAdapter);
  typeAdapterRegistry.registerAdapter<List<String>>(
    listStringAdapter,
    typeId: 5,
    cacheItemAdapter: listStringCacheItemAdapter,
  );

  if (adapterType == CacheAdapterType.hive) {
    Hive.registerAdapter(listStringCacheItemAdapter);
  }
  // Register Map<String, dynamic> adapter
  final mapAdapter = JsonTypeAdapter<Map<String, dynamic>>(
      serializer: JsonDataSerializer<Map<String, dynamic>>(), typeId: 6);
  typeAdapterRegistry.registerAdapter<Map<String, dynamic>>(mapAdapter,
      typeId: 6);

  // Then create and register the cache item adapter
  final mapCacheItemAdapter = _CacheItemAdapter<Map<String, dynamic>>(
      typeId: 6, valueAdapter: mapAdapter);
  typeAdapterRegistry.registerAdapter<Map<String, dynamic>>(
    mapAdapter,
    typeId: 6,
    cacheItemAdapter: mapCacheItemAdapter,
  );

  if (adapterType == CacheAdapterType.hive) {
    Hive.registerAdapter(mapCacheItemAdapter);
  }

  // Register custom serializers or default if none provided
  if (customSerializers == null || customSerializers.isEmpty) {
    typeAdapterRegistry
        .registerSerializer<String>(JsonDataSerializer<String>());
    typeAdapterRegistry.registerSerializer<int>(JsonDataSerializer<int>());
    typeAdapterRegistry
        .registerSerializer<double>(JsonDataSerializer<double>());
    typeAdapterRegistry.registerSerializer<bool>(JsonDataSerializer<bool>());
    typeAdapterRegistry
        .registerSerializer<List<String>>(JsonDataSerializer<List<String>>());
    typeAdapterRegistry.registerSerializer<Map<String, dynamic>>(
        JsonDataSerializer<Map<String, dynamic>>());
  } else {
    customSerializers.forEach((type, serializer) {
      typeAdapterRegistry.registerSerializer(serializer);
    });
  }

  // Register CacheAdapter
  CacheAdapter cacheAdapter;
  switch (adapterType) {
    case CacheAdapterType.hive:
      if (!getIt.isRegistered<HiveAdapter>()) {
        final hiveAdapter = HiveAdapter(
          typeAdapterRegistry,
          boxName: boxName,
          enableEncryption: enableEncryption,
          encryptionKey: encryptionKey,
          encryptionOptions: encryptionOptions,
        );
        // Initialize the adapter by opening the Hive box
        await hiveAdapter.init();
        getIt.registerSingleton<HiveAdapter>(hiveAdapter);
        cacheAdapter = hiveAdapter;
      } else {
        cacheAdapter = getIt<HiveAdapter>();
        // Ensure the adapter is initialized
        if (cacheAdapter is HiveAdapter) {
          await (cacheAdapter).init();
        }
      }
      break;
    case CacheAdapterType.memory:
      if (!getIt.isRegistered<MemoryAdapter>()) {
        final memoryAdapter = MemoryAdapter(
          enableEncryption: enableEncryption,
          encryptionKey: encryptionKey,
          encryptionOptions: encryptionOptions,
        );
        getIt.registerSingleton<MemoryAdapter>(memoryAdapter);
        cacheAdapter = memoryAdapter;
      } else {
        cacheAdapter = getIt<MemoryAdapter>();
      }
      break;
    case CacheAdapterType.sqlite:
      if (!getIt.isRegistered<SqliteAdapter>()) {
        final sqliteAdapter = SqliteAdapter(
          boxName: boxName,
          enableEncryption: enableEncryption,
          encryptionKey: encryptionKey,
          encryptionOptions: encryptionOptions,
        );
        getIt.registerSingleton<SqliteAdapter>(sqliteAdapter);
        cacheAdapter = sqliteAdapter;
      } else {
        cacheAdapter = getIt<SqliteAdapter>();
      }
      break;
    case CacheAdapterType.sharedPreferences:
      if (!getIt.isRegistered<SharedPreferencesAdapter>()) {
        final sharedPreferencesAdapter = SharedPreferencesAdapter(
          boxName: boxName,
          enableEncryption: enableEncryption,
          encryptionKey: encryptionKey,
          encryptionOptions: encryptionOptions,
        );
        getIt.registerSingleton<SharedPreferencesAdapter>(
            sharedPreferencesAdapter);
        cacheAdapter = sharedPreferencesAdapter;
      } else {
        cacheAdapter = getIt<SharedPreferencesAdapter>();
      }
      break;
  }

  // Register DataCacheX
  getIt.registerSingleton<DataCacheX>(DataCacheX(cacheAdapter));

  // Initialize background cleanup
  BackgroundCleanup.initializeBackgroundCleanup(
    adapter: cacheAdapter,
    frequency: cleanupFrequency,
  );
}