π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
[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.dartnew file mode 100644index 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.dartnew file mode 100644index 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.dartnew file mode 100644index 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.dartnew file mode 100644index 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.dartnew file mode 100644index 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.dartnew file mode 100644index 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;+}