CachedNetworkImageのcache読み込みを23倍高速化する方法

class JsonCacheManager extends CacheManager with ImageCacheManager {
  static const key = 'libCachedImageData';

  static final DefaultCacheManager _instance = DefaultCacheManager._();
  factory DefaultCacheManager() {
    return _instance;
  }

  JsonCacheManager._()
      : super(
          Config(
            key,
            repo: JsonCacheInfoRepository(),
          ),
        );
}

CachedNetworkImage(
  imageUrl: url,
  cacheManager: JsonCacheManager(),
);

import 'package:clock/clock.dart';
import 'package:flutter_cache_manager/flutter_cache_manager.dart';
// ignore: implementation_imports
import 'package:flutter_cache_manager/src/storage/cache_info_repositories/helper_methods.dart';
// ignore: implementation_imports
import 'package:flutter_cache_manager/src/storage/cache_object.dart';
import 'package:isar/isar.dart';
import 'package:path_provider/path_provider.dart';

import './image_cache_object.dart';

class IsarCacheInfoRepository extends CacheInfoRepository
    with CacheInfoRepositoryHelperMethods {
  Isar? box;
  @override
  Future<bool> open() async {
    if (!shouldOpenOnNewConnection()) {
      return openCompleter!.future;
    }
    final dir = await getApplicationDocumentsDirectory();
    box = await Isar.open([ImageCacheObjectSchema], directory: dir.path);
    return opened();
  }

  @override
  Future<CacheObject?> get(String key) async {
    try {
      final id = ImageCacheObject.fastHash(key);
      final cache = await box!.imageCacheObjects.get(id);
      if (cache == null) {
        return null;
      }
      return CacheObject.fromMap(cache.toJson());
    } on Exception catch (e) {
      print(e);
    }
    return null;
  }

  @override
  Future<List<CacheObject>> getAllObjects() async {
    final allCache =
        await box!.collection<ImageCacheObject>().where().findAll();
    return allCache.map((e) => CacheObject.fromMap(e.toJson())).toList();
  }

  @override
  Future<CacheObject> insert(
    CacheObject cacheObject, {
    bool setTouchedToNow = true,
  }) async {
    await box!.writeTxn(() async {
      await box!.imageCacheObjects.put(
        ImageCacheObject.fromCacheObject(
          cacheObject,
          setTouchedToNow: setTouchedToNow,
        ),
      );
    });
    return cacheObject;
  }

  @override
  Future<int> update(
    CacheObject cacheObject, {
    bool setTouchedToNow = true,
  }) async {
    await box!.writeTxn(() async {
      await box!.imageCacheObjects.put(
        ImageCacheObject.fromCacheObject(cacheObject,
            setTouchedToNow: setTouchedToNow),
      );
    });
    return 1;
  }

  @override
  Future updateOrInsert(CacheObject cacheObject) {
    return cacheObject.id == null ? insert(cacheObject) : update(cacheObject);
  }

  @override
  Future<List<CacheObject>> getObjectsOverCapacity(int capacity) async {
    final allSorted = await getAllObjects()
      ..sort((c1, c2) => c1.touched!.compareTo(c2.touched!));
    if (allSorted.length <= capacity) {
      return [];
    }
    return allSorted.getRange(0, allSorted.length - capacity).toList();
  }

  @override
  Future<bool> close() async {
    if (!shouldClose()) {
      return false;
    }
    await box!.close();
    return true;
  }

  @override
  Future<int> delete(int id) async {
    await box!.writeTxn(() async {
      await box!.imageCacheObjects.delete(id);
    });
    return 1;
  }

  @override
  Future<int> deleteAll(Iterable<int> ids) async {
    var deleted = 0;
    for (final id in ids) {
      deleted += await delete(id);
    }
    return deleted;
  }

  @override
  Future<void> deleteDataFile() {
    return box!.clear();
  }

  @override
  Future<bool> exists() {
    return box!.imageCacheObjects
        .where()
        .findAll()
        .then((value) => value.isNotEmpty);
  }

  @override
  Future<List<CacheObject>> getOldObjects(Duration maxAge) async {
    final then = clock.now().subtract(maxAge);

    final imageCache =
        await box!.imageCacheObjects.filter().touchedLessThan(then).findAll();
    return imageCache.map((e) => CacheObject.fromMap(e.toJson())).toList();
  }
}

  /// FNV-1a 64bit hash algorithm optimized for Dart Strings
  static int fastHash(String string) {
    // ignore: avoid_js_rounded_ints
    var hash = 0xcbf29ce484222325;

    var i = 0;
    while (i < string.length) {
      final codeUnit = string.codeUnitAt(i++);
      hash ^= codeUnit >> 8;
      hash *= 0x100000001b3;
      hash ^= codeUnit & 0xFF;
      hash *= 0x100000001b3;
    }

    return hash;
  }

import 'package:clock/clock.dart';
// ignore: implementation_imports
import 'package:flutter_cache_manager/src/storage/cache_object.dart';
import 'package:isar/isar.dart';

part 'image_cache_object.g.dart';

@collection
class ImageCacheObject {
  ImageCacheObject({
    required this.id,
    required this.url,
    required this.key,
    required this.relativePath,
    required this.validTill,
    this.eTag,
    this.length,
    this.touched,
  });
  factory ImageCacheObject.fromCacheObject(
    CacheObject cache, {
    bool setTouchedToNow = true,
  }) {
    return ImageCacheObject(
      id: cache.key,
      url: cache.url,
      key: cache.key,
      relativePath: cache.relativePath,
      validTill: cache.validTill,
      touched: setTouchedToNow ? clock.now() : cache.touched ?? clock.now(),
    );
  }

  /// Internal ID used to represent this cache object
  String? id;
  Id get isarId => fastHash(id!);

  /// The URL that was used to download the file
  String url;

  /// The key used to identify the object in the cache.
  ///
  /// This key is optional and will default to [url] if not specified
  String key;

  /// Where the cached file is stored
  String relativePath;

  /// When this cached item becomes invalid
  DateTime validTill;

  /// eTag provided by the server for cache expiry
  String? eTag;

  /// The length of the cached file
  int? length;

  /// When the file is last used
  DateTime? touched;

  /// FNV-1a 64bit hash algorithm optimized for Dart Strings
  /// https://isar.dev/recipes/string_ids.html
  static int fastHash(String string) {
    // ignore: avoid_js_rounded_ints
    var hash = 0xcbf29ce484222325;

    var i = 0;
    while (i < string.length) {
      final codeUnit = string.codeUnitAt(i++);
      hash ^= codeUnit >> 8;
      hash *= 0x100000001b3;
      hash ^= codeUnit & 0xFF;
      hash *= 0x100000001b3;
    }

    return hash;
  }

  Map<String, dynamic> toJson() {
    return {
      CacheObject.columnId: isarId,
      CacheObject.columnUrl: url,
      CacheObject.columnKey: id,
      CacheObject.columnPath: relativePath,
      CacheObject.columnValidTill: validTill.millisecondsSinceEpoch,
      if (eTag != null) CacheObject.columnETag: eTag,
      if (length != null) CacheObject.columnLength: length,
      if (touched != null)
        CacheObject.columnTouched: touched!.millisecondsSinceEpoch,
    };
  }
}