[mob][photos] Speed up face thumbnail generation by first showing generation based on thumbnail

mobile/apps/photos/lib/models/ml/face/person_face_source.dart

@@ -0,0 +1,16 @@
+import 'package:photos/models/file/file.dart';
+import 'package:photos/models/ml/face/face.dart';
+
+class PersonFaceSource {
+  final EnteFile file;
+  final Face face;
+  final int resolvedFileId;
+  final String? personName;
+
+  const PersonFaceSource({
+    required this.file,
+    required this.face,
+    required this.resolvedFileId,
+    this.personName,
+  });
+}

mobile/apps/photos/lib/models/search/search_constants.dart

@@ -1,6 +1,8 @@
 const kPersonParamID = 'person_id';
 const kPersonWidgetKey = 'person_widget_key';
 const kPersonPinned = 'person_pinned';
+const kPersonAvatarFaceID = 'person_avatar_face_id';
+const kPersonFaceSource = 'person_face_source';
 const kClusterParamId = 'cluster_id';
 const kFileID = 'file_id';
 const kContactEmail = 'contact_email';

mobile/apps/photos/lib/services/machine_learning/face_thumbnail_generator.dart

@@ -8,6 +8,18 @@ import "package:photos/utils/image_ml_util.dart";
 import "package:photos/utils/isolate/isolate_operations.dart";
 import "package:photos/utils/isolate/super_isolate.dart";
 
+class FaceThumbnailGenerationResult {
+  final List<Uint8List> thumbnails;
+  final int sourceWidth;
+  final int sourceHeight;
+
+  const FaceThumbnailGenerationResult({
+    required this.thumbnails,
+    required this.sourceWidth,
+    required this.sourceHeight,
+  });
+}
+
 @pragma('vm:entry-point')
 class FaceThumbnailGenerator extends SuperIsolate {
   @override
@@ -64,6 +76,66 @@ class FaceThumbnailGenerator extends SuperIsolate {
       return compressedFaces;
     } catch (e, s) {
       _logger.severe("Failed to generate face thumbnails", e, s);
+      rethrow;
+    }
+  }
+
+  Future<FaceThumbnailGenerationResult>
+      generateFaceThumbnailsWithSourceDimensions(
+    String imagePath,
+    List<FaceBox> faceBoxes,
+  ) async {
+    if (!flagService.progressivePersonFaceThumbnailsEnabled) {
+      final thumbnails = await generateFaceThumbnails(imagePath, faceBoxes);
+      return FaceThumbnailGenerationResult(
+        thumbnails: thumbnails,
+        sourceWidth: 0,
+        sourceHeight: 0,
+      );
+    }
+
+    try {
+      final useRustForFaceThumbnails = flagService.useRustForFaceThumbnails;
+      _logger.info(
+        "Generating face thumbnails for ${faceBoxes.length} face boxes in $imagePath",
+      );
+      final List<Map<String, dynamic>> faceBoxesJson =
+          faceBoxes.map((box) => box.toJson()).toList();
+      final Map<String, dynamic> rawResult = await runInIsolate(
+        IsolateOperation.generateFaceThumbnailsWithSourceDimensions,
+        {
+          'imagePath': imagePath,
+          'faceBoxesList': faceBoxesJson,
+          'useRustForFaceThumbnails': useRustForFaceThumbnails,
+        },
+      ).then((value) => Map<String, dynamic>.from(value));
+      final List<Uint8List> faces =
+          (rawResult['thumbnails'] as List<dynamic>).cast<Uint8List>();
+      final int sourceWidth = rawResult['sourceWidth'] as int? ?? 0;
+      final int sourceHeight = rawResult['sourceHeight'] as int? ?? 0;
+      _logger.info(
+        "Generated face thumbnails with source dimensions ${sourceWidth}x$sourceHeight",
+      );
+      if (useRustForFaceThumbnails) {
+        // Rust path already emits compressed JPEG bytes.
+        return FaceThumbnailGenerationResult(
+          thumbnails: faces,
+          sourceWidth: sourceWidth,
+          sourceHeight: sourceHeight,
+        );
+      }
+      final compressedFaces =
+          await compressFaceThumbnails({'listPngBytes': faces});
+      _logger.fine(
+        "Compressed face thumbnails from sizes ${faces.map((e) => e.length / 1024).toList()} to ${compressedFaces.map((e) => e.length / 1024).toList()} kilobytes",
+      );
+      return FaceThumbnailGenerationResult(
+        thumbnails: compressedFaces,
+        sourceWidth: sourceWidth,
+        sourceHeight: sourceHeight,
+      );
+    } catch (e, s) {
+      _logger.severe("Failed to generate face thumbnails", e, s);
 
       rethrow;
     }

mobile/apps/photos/lib/services/search_service.dart

@@ -32,6 +32,7 @@ import "package:photos/models/memories/memories_cache.dart";
 import "package:photos/models/memories/memory.dart";
 import "package:photos/models/memories/smart_memory.dart";
 import "package:photos/models/ml/face/person.dart";
+import "package:photos/models/ml/face/person_face_source.dart";
 import 'package:photos/models/search/album_search_result.dart';
 import 'package:photos/models/search/device_album_search_result.dart';
 import 'package:photos/models/search/generic_search_result.dart';
@@ -66,11 +67,13 @@ import "package:photos/utils/file_util.dart";
 import "package:photos/utils/people_sort_util.dart";
 
 class SearchService {
+  static const int _initialFaceSourcePrefetchCount = 24;
   Future<List<EnteFile>>? _cachedFilesFuture;
   Future<List<EnteFile>>? _cachedFilesForSearch;
   Future<List<EnteFile>>? _cachedFilesForHierarchicalSearch;
   Future<List<EnteFile>>? _cachedFilesForGenericGallery;
   Future<List<EnteFile>>? _cachedHiddenFilesFuture;
+  final Set<String> _faceSourcePrefetchInFlight = {};
   final _logger = Logger((SearchService).toString());
   final _collectionService = CollectionsService.instance;
   static const _maximumResultsLimit = 20;
@@ -197,6 +200,127 @@ class SearchService {
     unawaited(memoriesCacheService.clearMemoriesCache());
   }
 
+  Future<void> _enrichInitialFaceSources(
+    List<GenericSearchResult> results,
+  ) async {
+    await prefetchFaceSourcesInWindow(
+      results,
+      startIndex: 0,
+      count: _initialFaceSourcePrefetchCount,
+    );
+  }
+
+  Future<void> prefetchFaceSourcesInWindow(
+    List<GenericSearchResult> results, {
+    required int startIndex,
+    int count = _initialFaceSourcePrefetchCount,
+    int leadingBuffer = 0,
+  }) async {
+    if (results.isEmpty || count <= 0) {
+      return;
+    }
+    final safeStart = max(0, startIndex - leadingBuffer);
+    final safeEnd = min(results.length, safeStart + count);
+    if (safeStart >= safeEnd) {
+      return;
+    }
+    await Future.wait(
+      results.sublist(safeStart, safeEnd).map(_prefetchFaceSourceIfNeeded),
+    );
+  }
+
+  Future<void> _prefetchFaceSourceIfNeeded(
+    GenericSearchResult result,
+  ) async {
+    if (result.params[kPersonFaceSource] != null) {
+      return;
+    }
+    final prefetchKey = _faceSourcePrefetchKey(result);
+    if (prefetchKey == null || !_faceSourcePrefetchInFlight.add(prefetchKey)) {
+      return;
+    }
+    try {
+      final source = await _tryBuildInitialPersonFaceSource(result);
+      if (source != null) {
+        result.params[kPersonFaceSource] = source;
+      }
+    } catch (e, s) {
+      _logger.fine(
+        "Failed to prefetch initial face source for ${result.params[kPersonParamID] ?? result.params[kClusterParamId]}",
+        e,
+        s,
+      );
+    } finally {
+      _faceSourcePrefetchInFlight.remove(prefetchKey);
+    }
+  }
+
+  String? _faceSourcePrefetchKey(GenericSearchResult result) {
+    final personID = result.params[kPersonParamID] as String?;
+    if (personID != null && personID.isNotEmpty) {
+      return "person:$personID";
+    }
+    final clusterID = result.params[kClusterParamId] as String?;
+    if (clusterID != null && clusterID.isNotEmpty) {
+      return "cluster:$clusterID";
+    }
+    return null;
+  }
+
+  Future<PersonFaceSource?> _tryBuildInitialPersonFaceSource(
+    GenericSearchResult result,
+  ) async {
+    final personID = result.params[kPersonParamID] as String?;
+    final clusterID = result.params[kClusterParamId] as String?;
+    final avatarFaceID = result.params[kPersonAvatarFaceID] as String?;
+    final previewFile = result.previewThumbnail();
+    final previewFileID = previewFile?.uploadedFileID;
+    if (previewFile == null || previewFileID == null) {
+      return null;
+    }
+
+    final hasPersonSeed = personID != null &&
+        personID.isNotEmpty &&
+        avatarFaceID != null &&
+        avatarFaceID.isNotEmpty;
+    final hasClusterSeed = clusterID != null && clusterID.isNotEmpty;
+    if (!hasPersonSeed && !hasClusterSeed) {
+      return null;
+    }
+
+    final face = await mlDataDB.getCoverFaceForPerson(
+      recentFileID: previewFileID,
+      personID: hasPersonSeed ? personID : null,
+      avatarFaceId: hasPersonSeed ? avatarFaceID : null,
+      clusterID: hasClusterSeed ? clusterID : null,
+    );
+    if (face == null) {
+      return null;
+    }
+
+    EnteFile sourceFile = previewFile;
+    if (face.fileID != previewFileID) {
+      EnteFile? faceFile;
+      for (final file in result.resultFiles()) {
+        if (file.uploadedFileID == face.fileID) {
+          faceFile = file;
+          break;
+        }
+      }
+      if (faceFile == null) {
+        return null;
+      }
+      sourceFile = faceFile;
+    }
+
+    return PersonFaceSource(
+      file: sourceFile,
+      face: face,
+      resolvedFileId: face.fileID,
+      personName: result.name(),
+    );
+  }
+
   // getFilteredCollectionsWithThumbnail removes deleted or archived or
   // collections which don't have a file from search result
   Future<List<AlbumSearchResult>> getCollectionSearchResults(
@@ -1083,6 +1207,7 @@ class SearchService {
             params: {
               kPersonWidgetKey: p.data.avatarFaceID ?? p.hashCode.toString(),
               kPersonParamID: personID,
+              kPersonAvatarFaceID: p.data.avatarFaceID,
               kFileID: files.first.uploadedFileID,
               kPersonPinned: p.data.isPinned,
             },
@@ -1100,6 +1225,7 @@ class SearchService {
                       kPersonWidgetKey:
                           p.data.avatarFaceID ?? p.hashCode.toString(),
                       kPersonParamID: personID,
+                      kPersonAvatarFaceID: p.data.avatarFaceID,
                       kPersonPinned: p.data.isPinned,
                       kFileID: files.first.uploadedFileID,
                     },
@@ -1206,6 +1332,7 @@ class SearchService {
           photosSortAscending: localSettings.peoplePhotosSortAscending,
         ),
       );
+      await _enrichInitialFaceSources(facesResult);
       if (limit != null) {
         return facesResult.sublist(0, min(limit, facesResult.length));
       } else {