Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

[mob][photos] Load device media and bound picker selection

r4khul165360f678df
diff --git a/mobile/apps/photos/lib/ui/device_picker/device_media_library.dart b/mobile/apps/photos/lib/ui/device_picker/device_media_library.dart
new file mode 100644
index 0000000000..8722ddbb4d
--- /dev/null
+++ b/mobile/apps/photos/lib/ui/device_picker/device_media_library.dart
@@ -0,0 +1,62 @@
+import "package:photo_manager/photo_manager.dart";
+import "package:photos/db/files_db.dart";
+import "package:photos/models/file/extensions/file_props.dart";
+import "package:photos/models/file/file.dart";
+import "package:photos/service_locator.dart";
+
+abstract interface class DeviceMediaLibrary {
+ Future<PermissionState> permission({required bool request});
+ Future<List<AssetPathEntity>> albums();
+ Future<List<AssetEntity>> read(
+ AssetPathEntity album, {
+ required int start,
+ required int end,
+ });
+ Future<AssetEntity?> resolve(String id);
+ Future<Map<String, EnteFile>> files(List<String> localIDs);
+ Future<int> count(AssetPathEntity album);
+}
+
+class PhotoManagerDeviceLibrary implements DeviceMediaLibrary {
+ @override
+ Future<PermissionState> permission({required bool request}) => request
+ ? permissionService.requestPhotoMangerPermissions()
+ : permissionService.getPermissionState();
+
+ @override
+ Future<List<AssetPathEntity>> albums() => PhotoManager.getAssetPathList(
+ type: RequestType.common,
+ filterOption: FilterOptionGroup(
+ imageOption: const FilterOption(
+ sizeConstraint: SizeConstraint(ignoreSize: true),
+ ),
+ orders: [const OrderOption(type: OrderOptionType.createDate)],
+ ),
+ );
+
+ @override
+ Future<List<AssetEntity>> read(
+ AssetPathEntity album, {
+ required int start,
+ required int end,
+ }) => album.getAssetListRange(start: start, end: end);
+
+ @override
+ Future<Map<String, EnteFile>> files(List<String> localIDs) async {
+ if (localIDs.isEmpty) return {};
+ final files = await FilesDB.instance.getLocalFiles(localIDs);
+ final byID = <String, EnteFile>{};
+ for (final file in files.where((file) => file.isOwner)) {
+ if (byID[file.localID]?.isUploaded != true) {
+ byID[file.localID!] = file;
+ }
+ }
+ return byID;
+ }
+
+ @override
+ Future<int> count(AssetPathEntity album) => album.assetCountAsync;
+
+ @override
+ Future<AssetEntity?> resolve(String id) => AssetEntity.fromId(id);
+}
diff --git a/mobile/apps/photos/lib/ui/device_picker/device_picker_controller.dart b/mobile/apps/photos/lib/ui/device_picker/device_picker_controller.dart
new file mode 100644
index 0000000000..6819f64356
--- /dev/null
+++ b/mobile/apps/photos/lib/ui/device_picker/device_picker_controller.dart
@@ -0,0 +1,244 @@
+import "dart:math" as math;
+
+import "package:flutter/foundation.dart";
+import "package:logging/logging.dart";
+import "package:photo_manager/photo_manager.dart";
+import "package:photos/core/constants.dart";
+import "package:photos/ui/device_picker/device_media_library.dart";
+
+class DevicePickerController extends ChangeNotifier {
+ DevicePickerController({required this.library});
+
+ final DeviceMediaLibrary library;
+ final selectionChanges = ChangeNotifier();
+ final _mediaIDs = <String>{};
+ List<AssetEntity>? _selectionSnapshot;
+ static const batchSize = 96;
+ final _log = Logger("DevicePicker");
+ final _chosen = <String, AssetEntity>{};
+ final _loadedCounts = <String, int>{};
+ List<AssetPathEntity> albums = [];
+ List<AssetEntity> media = [];
+ AssetPathEntity? album;
+ PermissionState permission = PermissionState.notDetermined;
+ bool refreshing = false;
+ bool loadingMore = false;
+ bool hasMore = false;
+ bool confirming = false;
+ Object? error;
+ int removedSelections = 0;
+ int _revision = 0;
+ int _nextOffset = 0;
+ bool _closed = false;
+
+ List<AssetEntity> get selection =>
+ _selectionSnapshot ??= List.unmodifiable(_chosen.values);
+ int get selectionCount => _chosen.length;
+ bool get hasAccess => permission.hasAccess;
+
+ void replaceSelection(Iterable<AssetEntity> items) {
+ if (confirming) return;
+ final next = <String, AssetEntity>{};
+ for (final item in items) {
+ if (next.length >= maxPickAssetLimit) break;
+ next[item.id] = item;
+ }
+ if (mapEquals(_chosen, next)) return;
+ _chosen
+ ..clear()
+ ..addAll(next);
+ _selectionChanged();
+ }
+
+ void _selectionChanged() {
+ _selectionSnapshot = null;
+ selectionChanges.notifyListeners();
+ }
+
+ void clearSelection() {
+ if (confirming) return;
+ _chosen.clear();
+ _selectionChanged();
+ }
+
+ Future<void> refresh({bool requestPermission = false}) async {
+ final revision = ++_revision;
+ refreshing = true;
+ loadingMore = false;
+ error = null;
+ notifyListeners();
+ try {
+ final access = await library.permission(request: requestPermission);
+ if (!_isCurrent(revision)) return;
+ permission = access;
+ if (!access.hasAccess) {
+ removedSelections += _chosen.length;
+ _chosen.clear();
+ _selectionChanged();
+ albums = [];
+ album = null;
+ media = [];
+ _mediaIDs.clear();
+ hasMore = false;
+ return;
+ }
+ final folders = await library.albums();
+ if (!_isCurrent(revision)) return;
+ final previousID = album?.id;
+ albums = folders;
+ album =
+ folders.where((item) => item.id == previousID).firstOrNull ??
+ folders.where((item) => item.isAll).firstOrNull ??
+ folders.firstOrNull;
+ final length = album?.id == previousID
+ ? math.max(batchSize, _nextOffset)
+ : batchSize;
+ final items = album == null
+ ? <AssetEntity>[]
+ : await library.read(album!, start: 0, end: length);
+ if (!_isCurrent(revision)) return;
+ media = _unique(items);
+ _mediaIDs
+ ..clear()
+ ..addAll(media.map((item) => item.id));
+ _nextOffset = items.length;
+ hasMore = album != null && items.length == length;
+ final selected = await _resolveSelection();
+ if (!_isCurrent(revision)) return;
+ _replaceSelection(selected.items, selected.checked);
+ } catch (exception, stack) {
+ if (_isCurrent(revision)) {
+ error = exception;
+ _log.warning("Could not refresh device media", exception, stack);
+ }
+ } finally {
+ if (_isCurrent(revision)) {
+ refreshing = false;
+ notifyListeners();
+ }
+ }
+ }
+
+ Future<void> openAlbum(AssetPathEntity target) async {
+ if (target.id == album?.id) return;
+ final revision = ++_revision;
+ if (album != null) _loadedCounts[album!.id] = _nextOffset;
+ album = target;
+ media = [];
+ _mediaIDs.clear();
+ _nextOffset = 0;
+ hasMore = true;
+ refreshing = false;
+ loadingMore = false;
+ error = null;
+ notifyListeners();
+ await _readNext(
+ revision,
+ count: math.max(batchSize, _loadedCounts[target.id] ?? 0),
+ );
+ }
+
+ Future<void> loadMore() async {
+ if (refreshing || loadingMore || !hasMore || album == null) return;
+ await _readNext(_revision);
+ }
+
+ Future<void> _readNext(int revision, {int count = batchSize}) async {
+ loadingMore = true;
+ error = null;
+ if (media.isEmpty) notifyListeners();
+ try {
+ final items = await library.read(
+ album!,
+ start: _nextOffset,
+ end: _nextOffset + count,
+ );
+ if (!_isCurrent(revision)) return;
+ media.addAll(items.where((item) => _mediaIDs.add(item.id)));
+ _nextOffset += items.length;
+ hasMore = items.length == count;
+ } catch (exception, stack) {
+ if (_isCurrent(revision)) {
+ error = exception;
+ _log.warning("Could not load device media", exception, stack);
+ }
+ } finally {
+ if (_isCurrent(revision)) {
+ loadingMore = false;
+ notifyListeners();
+ }
+ }
+ }
+
+ Future<List<AssetEntity>?> confirm() async {
+ if (confirming || refreshing || _chosen.isEmpty) {
+ return null;
+ }
+ confirming = true;
+ final revision = _revision;
+ notifyListeners();
+ try {
+ final resolved = await _resolveSelection();
+ if (!_isCurrent(revision)) return null;
+ final items = resolved.items;
+ final previousCount = _chosen.length;
+ _replaceSelection(items, resolved.checked);
+ if (items.length != previousCount) return null;
+ return selection;
+ } catch (exception, stack) {
+ if (_isCurrent(revision)) {
+ _log.warning("Could not confirm device media", exception, stack);
+ rethrow;
+ }
+ return null;
+ } finally {
+ if (!_closed) {
+ confirming = false;
+ notifyListeners();
+ }
+ }
+ }
+
+ Future<({List<AssetEntity> items, Set<String> checked})>
+ _resolveSelection() async {
+ final revision = _revision;
+ final ids = _chosen.keys.toList();
+ final resolved = <AssetEntity>[];
+ for (var offset = 0; offset < ids.length; offset += 8) {
+ final batch = await Future.wait(
+ ids.skip(offset).take(8).map(library.resolve),
+ );
+ if (!_isCurrent(revision)) break;
+ resolved.addAll(batch.whereType<AssetEntity>());
+ }
+ return (items: resolved, checked: ids.toSet());
+ }
+
+ void _replaceSelection(List<AssetEntity> items, Set<String> checked) {
+ final byID = {for (final item in items) item.id: item};
+ final missing = checked
+ .where((id) => _chosen.containsKey(id) && !byID.containsKey(id))
+ .toList();
+ removedSelections += missing.length;
+ for (final id in missing) {
+ _chosen.remove(id);
+ }
+ for (final item in items) {
+ if (_chosen.containsKey(item.id)) _chosen[item.id] = item;
+ }
+ _selectionChanged();
+ }
+
+ List<AssetEntity> _unique(List<AssetEntity> items) =>
+ {for (final item in items) item.id: item}.values.toList();
+
+ bool _isCurrent(int revision) => !_closed && revision == _revision;
+
+ @override
+ void dispose() {
+ _closed = true;
+ ++_revision;
+ selectionChanges.dispose();
+ super.dispose();
+ }
+}
diff --git a/mobile/apps/photos/lib/ui/device_picker/device_picker_selection.dart b/mobile/apps/photos/lib/ui/device_picker/device_picker_selection.dart
new file mode 100644
index 0000000000..a14c80e7c9
--- /dev/null
+++ b/mobile/apps/photos/lib/ui/device_picker/device_picker_selection.dart
@@ -0,0 +1,42 @@
+import "package:photos/core/constants.dart";
+import "package:photos/models/file/dummy_file.dart";
+import "package:photos/models/file/file.dart";
+import "package:photos/models/selected_files.dart";
+
+class DevicePickerSelectedFiles extends SelectedFiles {
+ bool locked = false;
+
+ @override
+ bool isFileSelected(EnteFile file) => files.contains(file);
+
+ @override
+ void toggleSelection(EnteFile file) {
+ if (locked || file is DummyFile) return;
+ if (isFileSelected(file)) {
+ unSelectAll({file});
+ } else {
+ selectAll({file});
+ }
+ }
+
+ @override
+ void selectAll(Set<EnteFile> filesToSelect) {
+ if (locked) return;
+ final remaining = maxPickAssetLimit - files.length;
+ final additions = filesToSelect
+ .where((file) => file is! DummyFile && !files.contains(file))
+ .take(remaining)
+ .toSet();
+ if (additions.isNotEmpty) super.selectAll(additions);
+ }
+
+ @override
+ void unSelectAll(Set<EnteFile> filesToUnselect, {bool skipNotify = false}) {
+ if (!locked) super.unSelectAll(filesToUnselect, skipNotify: skipNotify);
+ }
+
+ @override
+ void clearAll({bool fireEvent = true}) {
+ if (!locked) super.clearAll(fireEvent: false);
+ }
+}
diff --git a/mobile/apps/photos/test/ui/device_picker/device_picker_controller_test.dart b/mobile/apps/photos/test/ui/device_picker/device_picker_controller_test.dart
new file mode 100644
index 0000000000..50813938ef
--- /dev/null
+++ b/mobile/apps/photos/test/ui/device_picker/device_picker_controller_test.dart
@@ -0,0 +1,153 @@
+import "dart:async";
+
+import "package:flutter_test/flutter_test.dart";
+import "package:photo_manager/photo_manager.dart";
+import "package:photos/ui/device_picker/device_picker_controller.dart";
+
+import "device_picker_test_helpers.dart";
+
+void main() {
+ late FakeDeviceLibrary library;
+ late DevicePickerController model;
+
+ setUp(() {
+ library = FakeDeviceLibrary();
+ model = DevicePickerController(library: library);
+ });
+ tearDown(() => model.dispose());
+
+ test(
+ 'selection stops at 50 and confirmation resolves in bounded batches',
+ () async {
+ library.items = List.generate(80, (i) => media('$i'));
+ await model.refresh();
+ var running = 0;
+ var peak = 0;
+ library.resolveOverride = (id) async {
+ running++;
+ if (running > peak) peak = running;
+ await Future<void>.delayed(Duration.zero);
+ running--;
+ return library.items[int.parse(id)];
+ };
+ model.replaceSelection(library.items);
+ expect(model.selectionCount, 50);
+ model.replaceSelection([
+ ...model.selection.where((item) => item.id != '10'),
+ library.items[50],
+ ]);
+ expect(model.selectionCount, 50);
+ final confirmed = await model.confirm();
+ expect(confirmed, model.selection);
+ expect(identical(confirmed!.first, library.items.first), isTrue);
+ expect(peak, lessThanOrEqualTo(8));
+ },
+ );
+
+ test(
+ 'leaving during a large confirmation cancels the remaining batches',
+ () async {
+ library.items = List.generate(100, (i) => media('$i'));
+ final controller = DevicePickerController(library: library);
+ await controller.refresh();
+ controller.replaceSelection(library.items);
+ final pending = Completer<AssetEntity?>();
+ var requests = 0;
+ library.resolveOverride = (_) {
+ requests++;
+ return pending.future;
+ };
+ final confirmation = controller.confirm();
+ controller.dispose();
+ pending.complete(null);
+ expect(await confirmation, isNull);
+ expect(requests, 8);
+ },
+ );
+
+ test('late page from the old album cannot replace the new album', () async {
+ library.items = List.generate(100, (index) => media('$index'));
+ await model.refresh();
+ model.replaceSelection([library.items.first]);
+ final pending = Completer<List<AssetEntity>>();
+ library.readOverride = (album, start, end) {
+ if (album.id == 'recent' && start > 0) return pending.future;
+ return Future.value([media('new-album')]);
+ };
+ final oldPage = model.loadMore();
+ await model.openAlbum(library.folders.last);
+ pending.complete([media('old-album')]);
+ await oldPage;
+ expect(model.media.single.id, 'new-album');
+ expect(model.loadingMore, isFalse);
+ expect(model.selection, [library.items.first]);
+ });
+
+ test('a failed page can be retried without losing selection', () async {
+ library.items = List.generate(100, (index) => media('$index'));
+ await model.refresh();
+ model.replaceSelection([library.items.first]);
+ library.readOverride = (_, _, _) => Future.error(StateError('offline'));
+ await model.loadMore();
+ expect(model.error, isNotNull);
+ expect(model.media.length, 96);
+ library.readOverride = null;
+ await model.loadMore();
+ expect(model.error, isNull);
+ expect(model.media.length, 100);
+ expect(model.selection.single.id, '0');
+ });
+
+ test(
+ 'confirmation removes unavailable selections and requires review',
+ () async {
+ await model.refresh();
+ model.replaceSelection(library.items.take(2));
+ library.unavailable.add(library.items.first.id);
+ expect(await model.confirm(), isNull);
+ expect(model.removedSelections, 1);
+ expect(model.selection.single.id, library.items[1].id);
+ expect(await model.confirm(), [library.items[1]]);
+ },
+ );
+
+ test('permission revocation clears cached media and selection', () async {
+ await model.refresh();
+ model.replaceSelection([library.items.first]);
+ library.access = PermissionState.denied;
+ await model.refresh();
+ expect(model.hasAccess, isFalse);
+ expect(model.media, isEmpty);
+ expect(model.selection, isEmpty);
+ expect(await model.confirm(), isNull);
+ });
+
+ test('failed confirmation keeps selection available for retry', () async {
+ await model.refresh();
+ model.replaceSelection([library.items.first]);
+ library.resolveOverride = (_) => Future.error(StateError('Unavailable'));
+ await expectLater(model.confirm(), throwsStateError);
+ expect(model.confirming, isFalse);
+ expect(model.error, isNull);
+ expect(model.selection, [library.items.first]);
+ library.resolveOverride = null;
+ expect(await model.confirm(), [library.items.first]);
+ });
+
+ test(
+ 'selection made during refresh is not mistaken for a missing asset',
+ () async {
+ await model.refresh();
+ model.replaceSelection([library.items.first]);
+ final pending = Completer<AssetEntity?>();
+ library.resolveOverride = (_) => pending.future;
+ final refresh = model.refresh();
+ await Future<void>.delayed(Duration.zero);
+ model.replaceSelection([...model.selection, library.items[1]]);
+ pending.complete(library.items.first);
+ await refresh;
+ expect(model.selection.length, 2);
+ expect(model.removedSelections, 0);
+ },
+ );
+}
diff --git a/mobile/apps/photos/test/ui/device_picker/device_picker_selection_test.dart b/mobile/apps/photos/test/ui/device_picker/device_picker_selection_test.dart
new file mode 100644
index 0000000000..b2c07827be
--- /dev/null
+++ b/mobile/apps/photos/test/ui/device_picker/device_picker_selection_test.dart
@@ -0,0 +1,80 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:photos/core/event_bus.dart';
+import 'package:photos/events/clear_selections_event.dart';
+import 'package:photos/models/file/dummy_file.dart';
+import 'package:photos/models/file/file.dart';
+import 'package:photos/ui/device_picker/device_picker_selection.dart';
+import 'package:photos/ui/viewer/gallery/swipe_to_select_helper.dart';
+
+void main() {
+ TestWidgetsFlutterBinding.ensureInitialized();
+
+ test('local assets toggle by identity without database IDs', () {
+ final selection = DevicePickerSelectedFiles();
+ addTearDown(selection.dispose);
+ selection.toggleSelection(EnteFile()..localID = 'photo');
+ expect(selection.isFileSelected(EnteFile()..localID = 'photo'), isTrue);
+ expect(selection.isFileSelected(EnteFile()..localID = 'other'), isFalse);
+ selection.toggleSelection(EnteFile()..localID = 'photo');
+ expect(selection.files, isEmpty);
+ final group = {EnteFile()..localID = 'a', EnteFile()..localID = 'b'};
+ selection.toggleGroupSelection(group);
+ expect(selection.files, group);
+ selection.toggleGroupSelection(group);
+ expect(selection.files, isEmpty);
+ });
+
+ test('shared swipe selection respects the cap and can deselect', () {
+ final selection = DevicePickerSelectedFiles();
+ final files = List.generate(70, (i) => EnteFile()..localID = '$i');
+ final swipe = SwipeToSelectHelper(
+ allFiles: files,
+ selectedFiles: selection,
+ );
+ addTearDown(() {
+ swipe.dispose();
+ selection.dispose();
+ });
+ swipe.startSelection(files.first);
+ swipe.updateSelection(files.last);
+ expect(selection.files.length, 50);
+ swipe.updateSelection(files[24]);
+ expect(selection.files.length, 25);
+ swipe.endSelection();
+ swipe.startSelection(files.first);
+ swipe.updateSelection(files[24]);
+ swipe.endSelection();
+ expect(selection.files, isEmpty);
+ selection.selectAll({DummyFile(groupID: 'day', index: 0), ...files});
+ expect(selection.files.length, 50);
+ expect(selection.files.any((file) => file is DummyFile), isFalse);
+ });
+
+ test(
+ 'confirmation locks gestures and clearing stays inside the picker',
+ () async {
+ final selection = DevicePickerSelectedFiles();
+ var globalClears = 0;
+ final subscription = Bus.instance.on<ClearSelectionsEvent>().listen((_) {
+ globalClears++;
+ });
+ addTearDown(() async {
+ await subscription.cancel();
+ selection.dispose();
+ });
+ final file = EnteFile()..localID = 'photo';
+ selection.toggleSelection(file);
+ selection.locked = true;
+ selection.toggleSelection(file);
+ selection.selectAll({EnteFile()..localID = 'other'});
+ selection.unSelectAll({file});
+ selection.clearAll();
+ expect(selection.files, {file});
+ selection.locked = false;
+ selection.clearAll();
+ await Future<void>.delayed(Duration.zero);
+ expect(selection.files, isEmpty);
+ expect(globalClears, 0);
+ },
+ );
+}
diff --git a/mobile/apps/photos/test/ui/device_picker/device_picker_test_helpers.dart b/mobile/apps/photos/test/ui/device_picker/device_picker_test_helpers.dart
new file mode 100644
index 0000000000..aeb17f0ace
--- /dev/null
+++ b/mobile/apps/photos/test/ui/device_picker/device_picker_test_helpers.dart
@@ -0,0 +1,58 @@
+import "package:photo_manager/photo_manager.dart";
+import "package:photos/models/file/file.dart";
+import "package:photos/ui/device_picker/device_media_library.dart";
+
+AssetEntity media(String id) => AssetEntity(
+ id: id,
+ typeInt: 1,
+ width: 1200,
+ height: 800,
+ title: '$id.jpg',
+ createDateSecond: 1700000000,
+);
+
+class FakeDeviceLibrary implements DeviceMediaLibrary {
+ PermissionState access = PermissionState.authorized;
+ final folders = [
+ AssetPathEntity(id: 'recent', name: 'Recent', isAll: true),
+ AssetPathEntity(id: 'camera', name: 'Camera'),
+ ];
+ List<AssetEntity> items = List.generate(3, (index) => media('$index'));
+ final unavailable = <String>{};
+ final knownFiles = <String, EnteFile>{};
+ final fileLookupBatches = <List<String>>[];
+ Object? fileLookupError;
+ Future<List<AssetEntity>> Function(AssetPathEntity, int, int)? readOverride;
+ Future<AssetEntity?> Function(String)? resolveOverride;
+
+ @override
+ Future<PermissionState> permission({required bool request}) async => access;
+ @override
+ Future<List<AssetPathEntity>> albums() async => folders;
+ @override
+ Future<List<AssetEntity>> read(
+ AssetPathEntity album, {
+ required int start,
+ required int end,
+ }) async => readOverride != null
+ ? readOverride!(album, start, end)
+ : items.skip(start).take(end - start).toList();
+ @override
+ Future<Map<String, EnteFile>> files(List<String> localIDs) async {
+ if (fileLookupError != null) throw fileLookupError!;
+ fileLookupBatches.add(localIDs);
+ return {
+ for (final id in localIDs)
+ if (knownFiles.containsKey(id)) id: knownFiles[id]!,
+ };
+ }
+
+ @override
+ Future<int> count(AssetPathEntity album) async => items.length;
+ @override
+ Future<AssetEntity?> resolve(String id) async => resolveOverride != null
+ ? resolveOverride!(id)
+ : unavailable.contains(id)
+ ? null
+ : items.where((item) => item.id == id).firstOrNull;
+}