platform clients

mobile/lib/infrastructure/loaders/image_request.dart

@@ -1,15 +1,16 @@
 import 'dart:async';
 import 'dart:ffi';
-import 'dart:io';
 import 'dart:ui' as ui;
 
+import 'package:cronet_http/cronet_http.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:ffi/ffi.dart';
+import 'package:http/http.dart' as http;
 import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
-import 'package:immich_mobile/providers/image/cache/remote_image_cache_manager.dart';
+import 'package:immich_mobile/presentation/widgets/timeline/constants.dart';
 import 'package:immich_mobile/providers/infrastructure/platform.provider.dart';
-import 'package:logging/logging.dart';
+import 'package:immich_mobile/infrastructure/repositories/network.repository.dart';
 
 part 'local_image_request.dart';
 part 'thumbhash_image_request.dart';

mobile/lib/infrastructure/loaders/remote_image_request.dart

@@ -1,14 +1,18 @@
 part of 'image_request.dart';
 
 class RemoteImageRequest extends ImageRequest {
-  static final log = Logger('RemoteImageRequest');
-  static final client = HttpClient()..maxConnectionsPerHost = 16;
-  final RemoteCacheManager? cacheManager;
+  static final _client = const NetworkRepository().getHttpClient(
+    directoryName: 'thumbnails',
+    diskCapacity: kThumbnailDiskCacheSize,
+    memoryCapacity: 0,
+    maxConnections: 16,
+    cacheMode: CacheMode.disk,
+  );
   final String uri;
   final Map<String, String> headers;
-  HttpClientRequest? _request;
+  final abortTrigger = Completer<void>();
 
-  RemoteImageRequest({required this.uri, required this.headers, this.cacheManager});
+  RemoteImageRequest({required this.uri, required this.headers});
 
   @override
   Future<ImageInfo?> load(ImageDecoderCallback decode, {double scale = 1.0}) async {
@@ -16,15 +20,8 @@ class RemoteImageRequest extends ImageRequest {
       return null;
     }
 
-    // TODO: the cache manager makes everything sequential with its DB calls and its operations cannot be cancelled,
-    //  so it ends up being a bottleneck.  We only prefer fetching from it when it can skip the DB call.
-    final cachedFileImage = await _loadCachedFile(uri, decode, scale, inMemoryOnly: true);
-    if (cachedFileImage != null) {
-      return cachedFileImage;
-    }
-
     try {
-      final buffer = await _downloadImage(uri);
+      final buffer = await _downloadImage();
       if (buffer == null) {
         return null;
       }
@@ -35,57 +32,37 @@ class RemoteImageRequest extends ImageRequest {
         return null;
       }
 
-      final cachedFileImage = await _loadCachedFile(uri, decode, scale, inMemoryOnly: false);
-      if (cachedFileImage != null) {
-        return cachedFileImage;
-      }
-
       rethrow;
-    } finally {
-      _request = null;
     }
   }
 
-  Future<ImmutableBuffer?> _downloadImage(String url) async {
+  Future<ImmutableBuffer?> _downloadImage() async {
     if (_isCancelled) {
       return null;
     }
 
-    final request = _request = await client.getUrl(Uri.parse(url));
-    if (_isCancelled) {
-      request.abort();
-      return _request = null;
-    }
-
-    for (final entry in headers.entries) {
-      request.headers.set(entry.key, entry.value);
-    }
-    final response = await request.close();
+    final req = http.AbortableRequest('get', Uri.parse(uri), abortTrigger: abortTrigger.future);
+    req.headers.addAll(headers);
+    final res = await _client.send(req);
     if (_isCancelled) {
+      _onCancelled();
       return null;
     }
 
-    final cacheManager = this.cacheManager;
-    final streamController = StreamController<List<int>>(sync: true);
-    final Stream<List<int>> stream;
-    cacheManager?.putStreamedFile(url, streamController.stream);
-    stream = response.map((chunk) {
+    final stream = res.stream.map((chunk) {
       if (_isCancelled) {
         throw StateError('Cancelled request');
       }
-      if (cacheManager != null) {
-        streamController.add(chunk);
-      }
       return chunk;
     });
 
     try {
-      final Uint8List bytes = await _downloadBytes(stream, response.contentLength);
-      streamController.close();
+      final Uint8List bytes = await _downloadBytes(stream, res.contentLength ?? -1);
+      if (_isCancelled) {
+        return null;
+      }
       return await ImmutableBuffer.fromUint8List(bytes);
     } catch (e) {
-      streamController.addError(e);
-      streamController.close();
       if (_isCancelled) {
         return null;
       }
@@ -122,40 +99,6 @@ class RemoteImageRequest extends ImageRequest {
     return bytes;
   }
 
-  Future<ImageInfo?> _loadCachedFile(
-    String url,
-    ImageDecoderCallback decode,
-    double scale, {
-    required bool inMemoryOnly,
-  }) async {
-    final cacheManager = this.cacheManager;
-    if (_isCancelled || cacheManager == null) {
-      return null;
-    }
-
-    final file = await (inMemoryOnly ? cacheManager.getFileFromMemory(url) : cacheManager.getFileFromCache(url));
-    if (_isCancelled || file == null) {
-      return null;
-    }
-
-    try {
-      final buffer = await ImmutableBuffer.fromFilePath(file.file.path);
-      return await _decodeBuffer(buffer, decode, scale);
-    } catch (e) {
-      log.severe('Failed to decode cached image', e);
-      _evictFile(url);
-      return null;
-    }
-  }
-
-  Future<void> _evictFile(String url) async {
-    try {
-      await cacheManager?.removeFile(url);
-    } catch (e) {
-      log.severe('Failed to remove cached image', e);
-    }
-  }
-
   Future<ImageInfo?> _decodeBuffer(ImmutableBuffer buffer, ImageDecoderCallback decode, scale) async {
     if (_isCancelled) {
       buffer.dispose();
@@ -173,7 +116,6 @@ class RemoteImageRequest extends ImageRequest {
 
   @override
   void _onCancelled() {
-    _request?.abort();
-    _request = null;
+    abortTrigger.complete();
   }
 }

mobile/lib/infrastructure/repositories/network.repository.dart

@@ -0,0 +1,40 @@
+import 'dart:io';
+
+import 'package:cronet_http/cronet_http.dart';
+import 'package:cupertino_http/cupertino_http.dart';
+import 'package:http/http.dart' as http;
+import 'package:path_provider/path_provider.dart';
+
+class NetworkRepository {
+  static late Directory _cachePath;
+
+  static Future<void> init() async {
+    _cachePath = await getTemporaryDirectory();
+  }
+
+  const NetworkRepository();
+
+  http.Client getHttpClient({
+    required String directoryName,
+    required int diskCapacity,
+    required int memoryCapacity,
+    required int maxConnections,
+    required CacheMode cacheMode,
+  }) {
+    final directory = Directory('${_cachePath.path}/$directoryName');
+    directory.createSync(recursive: true);
+    if (Platform.isAndroid) {
+      final engine = CronetEngine.build(cacheMode: cacheMode, cacheMaxSize: diskCapacity, storagePath: directory.path);
+      return CronetClient.fromCronetEngine(engine, closeEngine: true);
+    }
+
+    final config = URLSessionConfiguration.defaultSessionConfiguration()
+      ..httpMaximumConnectionsPerHost = maxConnections
+      ..cache = URLCache.withCapacity(
+        diskCapacity: diskCapacity,
+        memoryCapacity: memoryCapacity,
+        directory: directory.uri,
+      );
+    return CupertinoClient.fromSessionConfiguration(config);
+  }
+}