π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
Load memory music from manifest
ashilkn89be0d0fa520
diff --git a/mobile/apps/photos/lib/main.dart b/mobile/apps/photos/lib/main.dartindex 3fde99bae9..0c7eb4c473 100644--- a/mobile/apps/photos/lib/main.dart+++ b/mobile/apps/photos/lib/main.dart@@ -49,14 +49,13 @@ import "package:photos/services/machine_learning/face_ml/person/person_service.dimport "package:photos/services/machine_learning/ml_run_control.dart";import 'package:photos/services/machine_learning/ml_service.dart';import 'package:photos/services/machine_learning/semantic_search/semantic_search_service.dart';-import "package:photos/services/memories/memory_music_tracks.dart";+import "package:photos/services/memories/memory_music_service.dart";import 'package:photos/services/memory_lane/memory_lane_service.dart';import 'package:photos/services/memory_share_service.dart';import "package:photos/services/notification_service.dart";import "package:photos/services/photos_contacts_service.dart";import "package:photos/services/process_activity.dart";import 'package:photos/services/push_service.dart';-import "package:photos/services/remote_assets_service.dart";import 'package:photos/services/search_service.dart';import 'package:photos/services/social_notification_coordinator.dart';import 'package:photos/services/sync/local_sync_service.dart';@@ -187,7 +186,7 @@ Future<void> _runInForeground(unawaited(SemanticSearchService.instance.init());unawaited(MemoryLaneService.instance.init());if (flagService.internalUser) {- unawaited(_downloadMemoryMusicTracks());+ unawaited(MemoryMusicService.instance.prepare());}unawaited(Future.delayed(@@ -200,25 +199,6 @@ Future<void> _runInForeground(});}-Future<void> _downloadMemoryMusicTracks() async {- await Future.wait(- memoryMusicTracks.map((track) async {- try {- await RemoteAssetsService.instance.getAsset(- track.url,- cacheFileName: track.cacheFileName,- );- } catch (error, stackTrace) {- _logger.warning(- "Failed to download memory music track ${track.id}",- error,- stackTrace,- );- }- }),- );-}-Future<void> _warmPickerFilesDb() async {final tlog = TimeLogger();try {diff --git a/mobile/apps/photos/lib/models/memories/memory_music_track.dart b/mobile/apps/photos/lib/models/memories/memory_music_track.dartindex 9c943a3646..70f0c371f8 100644--- a/mobile/apps/photos/lib/models/memories/memory_music_track.dart+++ b/mobile/apps/photos/lib/models/memories/memory_music_track.dart@@ -1,14 +1,12 @@class MemoryMusicTrack {final String id;final String url;- final String cacheFileName;final String? title;final String? artist;const MemoryMusicTrack({required this.id,required this.url,- required this.cacheFileName,this.title,this.artist,});diff --git a/mobile/apps/photos/lib/services/memories/just_audio_memory_music_player.dart b/mobile/apps/photos/lib/services/memories/just_audio_memory_music_player.dartindex 8ce30f76c7..1960f7ea78 100644--- a/mobile/apps/photos/lib/services/memories/just_audio_memory_music_player.dart+++ b/mobile/apps/photos/lib/services/memories/just_audio_memory_music_player.dart@@ -5,6 +5,7 @@ import "package:just_audio/just_audio.dart";import "package:logging/logging.dart";import "package:photos/models/memories/memory_music_track.dart";import "package:photos/services/memories/memory_music_player.dart";+import "package:photos/services/memories/memory_music_service.dart";import "package:photos/services/remote_assets_service.dart";class JustAudioMemoryMusicPlayer implements MemoryMusicPlayer {@@ -28,11 +29,28 @@ class JustAudioMemoryMusicPlayer implements MemoryMusicPlayer {@overrideFuture<void> load(MemoryMusicTrack track) async {+ final cacheFileName = memoryMusicCacheFileName(track.url);final file = await RemoteAssetsService.instance.getAsset(track.url,- cacheFileName: track.cacheFileName,+ cacheFileName: cacheFileName,);- await _player.setFilePath(file.path, preload: true);+ try {+ await _player.setFilePath(file.path, preload: true);+ } on PlayerException {+ try {+ await RemoteAssetsService.instance.deleteAsset(+ track.url,+ cacheFileName: cacheFileName,+ );+ } catch (error, stackTrace) {+ _logger.warning(+ "Failed to invalidate memory music track ${track.id}",+ error,+ stackTrace,+ );+ }+ rethrow;+ }}@overridediff --git a/mobile/apps/photos/lib/services/memories/memory_music_service.dart b/mobile/apps/photos/lib/services/memories/memory_music_service.dartnew file mode 100644index 0000000000..3ebfeb24be--- /dev/null+++ b/mobile/apps/photos/lib/services/memories/memory_music_service.dart@@ -0,0 +1,230 @@+import "dart:async";+import "dart:convert";++import "package:crypto/crypto.dart";+import "package:logging/logging.dart";+import "package:photos/models/memories/memory_music_track.dart";+import "package:photos/service_locator.dart";+import "package:photos/services/remote_assets_service.dart";+import "package:shared_preferences/shared_preferences.dart";++const _manifestURL = "https://music.ente.com/tracks.json";+const _manifestPreferenceKey = "memory_music_manifest";++String memoryMusicCacheFileName(String url) =>+ "memory-music-${sha256.convert(utf8.encode(url))}.mp3";++class MemoryMusicService {+ static final _logger = Logger("MemoryMusicService");+ static MemoryMusicService? _instance;++ final SharedPreferences _preferences;+ final Future<Object?> Function() _fetchManifest;+ final Future<void> Function(String url) _cacheAsset;+ final Future<void> Function(String url) _deleteAsset;++ List<MemoryMusicTrack>? _tracks;+ Future<List<MemoryMusicTrack>>? _preparation;+ bool _manifestRefreshed = false;++ MemoryMusicService({+ required SharedPreferences preferences,+ required Future<Object?> Function() fetchManifest,+ required Future<void> Function(String url) cacheAsset,+ required Future<void> Function(String url) deleteAsset,+ }) : _preferences = preferences,+ _fetchManifest = fetchManifest,+ _cacheAsset = cacheAsset,+ _deleteAsset = deleteAsset;++ static MemoryMusicService get instance => _instance ??= MemoryMusicService(+ preferences: ServiceLocator.instance.prefs,+ fetchManifest: () async {+ final response = await ServiceLocator.instance.nonEnteDio.get<Object?>(+ _manifestURL,+ );+ return response.data;+ },+ cacheAsset: (url) async {+ await RemoteAssetsService.instance.getAsset(+ url,+ cacheFileName: memoryMusicCacheFileName(url),+ );+ },+ deleteAsset: (url) => RemoteAssetsService.instance.deleteAsset(+ url,+ cacheFileName: memoryMusicCacheFileName(url),+ ),+ );++ Future<List<MemoryMusicTrack>> prepare() {+ final preparation = _preparation;+ if (preparation != null) return preparation;++ late final Future<List<MemoryMusicTrack>> nextPreparation;+ nextPreparation = _prepare().whenComplete(() {+ if (identical(_preparation, nextPreparation)) _preparation = null;+ });+ _preparation = nextPreparation;+ return nextPreparation;+ }++ Future<List<MemoryMusicTrack>> _prepare() async {+ _tracks ??= _readCachedManifest();+ if (!_manifestRefreshed) await _refreshManifest();+ return _availableTracks(_tracks!);+ }++ List<MemoryMusicTrack> _readCachedManifest() {+ final manifest = _preferences.getString(_manifestPreferenceKey);+ if (manifest == null) return const [];+ try {+ return _parseManifest(jsonDecode(manifest));+ } catch (error, stackTrace) {+ _logger.warning(+ "Ignoring invalid cached memory music manifest",+ error,+ stackTrace,+ );+ return const [];+ }+ }++ Future<void> _refreshManifest() async {+ try {+ final manifest = await _fetchManifest();+ final tracks = _parseManifest(manifest);+ final previousTracks = _tracks!;+ _tracks = tracks;+ _manifestRefreshed = true;+ await _persistAndCleanUp(manifest, previousTracks, tracks);+ } catch (error, stackTrace) {+ _logger.warning(+ "Failed to refresh memory music manifest",+ error,+ stackTrace,+ );+ }+ }++ Future<void> _persistAndCleanUp(+ Object? manifest,+ List<MemoryMusicTrack> previousTracks,+ List<MemoryMusicTrack> tracks,+ ) async {+ try {+ final saved = await _preferences.setString(+ _manifestPreferenceKey,+ jsonEncode(manifest),+ );+ if (!saved) {+ _logger.warning("Failed to cache memory music manifest");+ return;+ }+ } catch (error, stackTrace) {+ _logger.warning(+ "Failed to cache memory music manifest",+ error,+ stackTrace,+ );+ return;+ }++ final currentURLs = tracks.map((track) => track.url).toSet();+ final removedURLs = previousTracks+ .map((track) => track.url)+ .toSet()+ .difference(currentURLs);+ await Future.wait(removedURLs.map(_deleteRemovedAsset));+ }++ Future<void> _deleteRemovedAsset(String url) async {+ try {+ await _deleteAsset(url);+ } catch (error, stackTrace) {+ _logger.warning(+ "Failed to delete removed memory music asset $url",+ error,+ stackTrace,+ );+ }+ }++ Future<List<MemoryMusicTrack>> _availableTracks(+ List<MemoryMusicTrack> tracks,+ ) async {+ final availableURLs = <String>{};+ await Future.wait(+ tracks.map((track) => track.url).toSet().map((url) async {+ try {+ await _cacheAsset(url);+ availableURLs.add(url);+ } catch (error, stackTrace) {+ _logger.warning(+ "Failed to cache memory music asset $url",+ error,+ stackTrace,+ );+ }+ }),+ );+ return tracks+ .where((track) => availableURLs.contains(track.url))+ .toList(growable: false);+ }++ List<MemoryMusicTrack> _parseManifest(Object? manifest) {+ if (manifest is! Map<String, dynamic>) {+ throw const FormatException("Memory music manifest must be an object");+ }+ final entries = manifest["tracks"];+ if (entries is! List) {+ throw const FormatException("Memory music manifest needs tracks");+ }++ final ids = <String>{};+ final tracks = <MemoryMusicTrack>[];+ for (final entry in entries) {+ if (entry is! Map<String, dynamic>) {+ throw const FormatException("Memory music track must be an object");+ }+ final id = entry["id"];+ final url = entry["url"];+ final title = entry["title"];+ final artist = entry["artist"];+ if (id is! String || id.trim().isEmpty) {+ throw const FormatException("Memory music track needs an ID");+ }+ if (!ids.add(id)) {+ throw FormatException("Duplicate memory music track ID: $id");+ }+ if (url is! String || !_isValidTrackURL(url)) {+ throw FormatException("Invalid memory music track URL for $id");+ }+ if (title != null && title is! String) {+ throw FormatException("Invalid memory music track title for $id");+ }+ if (artist != null && artist is! String) {+ throw FormatException("Invalid memory music track artist for $id");+ }+ tracks.add(+ MemoryMusicTrack(+ id: id,+ url: url,+ title: title as String?,+ artist: artist as String?,+ ),+ );+ }+ tracks.sort((a, b) => a.id.compareTo(b.id));+ return tracks;+ }++ bool _isValidTrackURL(String value) {+ final url = Uri.tryParse(value);+ return url != null &&+ url.scheme == "https" &&+ url.host.isNotEmpty &&+ url.path.toLowerCase().endsWith(".mp3");+ }+}diff --git a/mobile/apps/photos/lib/services/memories/memory_music_tracks.dart b/mobile/apps/photos/lib/services/memories/memory_music_tracks.dartdeleted file mode 100644index a6a4e280d6..0000000000--- a/mobile/apps/photos/lib/services/memories/memory_music_tracks.dart+++ /dev/null@@ -1,17 +0,0 @@-import "package:photos/models/memories/memory_music_track.dart";--const memoryMusicTracks = <MemoryMusicTrack>[- MemoryMusicTrack(- id: "then",- url: "https://music.ente.com/then.mp3",- cacheFileName: "memory-music-then.mp3",- title: "Then",- artist: "Vishnu Mohandas",- ),- MemoryMusicTrack(- id: "sunday",- url: "https://music.ente.com/sunday.mp3",- cacheFileName: "memory-music-sunday.mp3",- title: "Sunday",- ),-];diff --git a/mobile/apps/photos/lib/services/remote_assets_service.dart b/mobile/apps/photos/lib/services/remote_assets_service.dartindex a0438828df..195b46d623 100644--- a/mobile/apps/photos/lib/services/remote_assets_service.dart+++ b/mobile/apps/photos/lib/services/remote_assets_service.dart@@ -53,6 +53,16 @@ class RemoteAssetsService {});}+ Future<void> deleteAsset(String remotePath, {String? cacheFileName}) {+ return _lockFor(remotePath).synchronized(() async {+ final localPath = await _getLocalPath(+ remotePath,+ cacheFileName: cacheFileName,+ );+ await _deleteAssetArtifacts(localPath);+ });+ }+Future<String> getAssetPath(String remotePath, {bool refetch = false,diff --git a/mobile/apps/photos/lib/ui/home/memories/full_screen_memory.dart b/mobile/apps/photos/lib/ui/home/memories/full_screen_memory.dartindex 1c8ec64d05..a7de5231d6 100644--- a/mobile/apps/photos/lib/ui/home/memories/full_screen_memory.dart+++ b/mobile/apps/photos/lib/ui/home/memories/full_screen_memory.dart@@ -357,6 +357,7 @@ class _FullScreenMemoryState extends State<FullScreenMemory> {// invalidates the prior delayed forward.Object? _kenBurnsStartToken;bool _isViewerPaused = false;+ bool _isMusicViewerActionPaused = false;bool _isPlaybackPaused = false;bool get _isAnimationPaused =>!widget.isActive || _isViewerPaused || _isPlaybackPaused;@@ -422,13 +423,10 @@ class _FullScreenMemoryState extends State<FullScreenMemory> {void didChangeDependencies() {super.didChangeDependencies();final memoryData = FullScreenMemoryData.of(context);- final previousMemoryData = _memoryData;_memoryData = memoryData;final nextNotifier = memoryData?.indexNotifier;if (identical(nextNotifier, _itemIndexNotifier)) {- if (!identical(previousMemoryData, memoryData)) {- _activateCurrentItemMusic();- }+ _activateCurrentItemMusic();return;}_itemIndexNotifier?.removeListener(_activateCurrentItemMusic);@@ -467,6 +465,7 @@ class _FullScreenMemoryState extends State<FullScreenMemory> {final file = inheritedData.memories[index].file;final controller = MemoryMusicScope.maybeOf(context, listen: false);if (controller == null) return;+ unawaited(controller.setViewerActionPaused(_isMusicViewerActionPaused));unawaited(controller.activateMemory(widget.memoryID,@@ -676,6 +675,7 @@ class _FullScreenMemoryState extends State<FullScreenMemory> {void _pauseViewer() {if (!mounted) return;+ _isMusicViewerActionPaused = true;final controller = MemoryMusicScope.maybeOf(context, listen: false);if (controller != null) {unawaited(controller.setViewerActionPaused(true));@@ -686,6 +686,7 @@ class _FullScreenMemoryState extends State<FullScreenMemory> {void _resumeViewer() {if (!mounted) return;+ _isMusicViewerActionPaused = false;Bus.instance.fire(ResumeVideoEvent());_toggleAnimation(pause: false);final controller = MemoryMusicScope.maybeOf(context, listen: false);diff --git a/mobile/apps/photos/lib/ui/home/memories/memory_music_session.dart b/mobile/apps/photos/lib/ui/home/memories/memory_music_session.dartindex 809efbee76..7149ced285 100644--- a/mobile/apps/photos/lib/ui/home/memories/memory_music_session.dart+++ b/mobile/apps/photos/lib/ui/home/memories/memory_music_session.dart@@ -5,7 +5,7 @@ import "package:photos/service_locator.dart";import "package:photos/services/memories/just_audio_memory_music_player.dart";import "package:photos/services/memories/memory_music_controller.dart";import "package:photos/services/memories/memory_music_selector.dart";-import "package:photos/services/memories/memory_music_tracks.dart";+import "package:photos/services/memories/memory_music_service.dart";class MemoryMusicSession extends StatefulWidget {final List<String> memoryIDs;@@ -23,34 +23,50 @@ class MemoryMusicSession extends StatefulWidget {class _MemoryMusicSessionState extends State<MemoryMusicSession>with WidgetsBindingObserver {- late final MemoryMusicController _controller;+ MemoryMusicController? _controller;+ bool _isAppActive = true;@overridevoid initState() {super.initState();WidgetsBinding.instance.addObserver(this);+ final lifecycleState = WidgetsBinding.instance.lifecycleState;+ _isAppActive =+ lifecycleState == null || lifecycleState == AppLifecycleState.resumed;+ unawaited(_initialize());+ }++ Future<void> _initialize() async {+ final tracks = await MemoryMusicService.instance.prepare();+ if (!mounted || tracks.isEmpty) return;final assignments = assignMemoryMusicTracks(memoryIDs: widget.memoryIDs,- tracks: memoryMusicTracks,+ tracks: tracks,);- _controller = MemoryMusicController(+ final controller = MemoryMusicController(assignments: assignments,initiallyMuted: localSettings.isMemoriesAudioMuted(),persistMuted: localSettings.setMemoriesAudioMuted,player: JustAudioMemoryMusicPlayer(),- tracks: memoryMusicTracks,+ tracks: tracks,);+ if (!_isAppActive) unawaited(controller.setAppActive(false));+ setState(() => _controller = controller);}@overridevoid didChangeAppLifecycleState(AppLifecycleState state) {- unawaited(_controller.setAppActive(state == AppLifecycleState.resumed));+ _isAppActive = state == AppLifecycleState.resumed;+ final controller = _controller;+ if (controller != null) {+ unawaited(controller.setAppActive(_isAppActive));+ }}@overridevoid dispose() {WidgetsBinding.instance.removeObserver(this);- _controller.dispose();+ _controller?.dispose();super.dispose();}@@ -62,7 +78,7 @@ class _MemoryMusicSessionState extends State<MemoryMusicSession>class MemoryMusicScope extends InheritedNotifier<MemoryMusicController> {const MemoryMusicScope({- required MemoryMusicController controller,+ required MemoryMusicController? controller,required super.child,super.key,}) : super(notifier: controller);diff --git a/mobile/apps/photos/test/services/memories/memory_music_controller_test.dart b/mobile/apps/photos/test/services/memories/memory_music_controller_test.dartindex 3dff5b9d91..a034758b81 100644--- a/mobile/apps/photos/test/services/memories/memory_music_controller_test.dart+++ b/mobile/apps/photos/test/services/memories/memory_music_controller_test.dart@@ -9,12 +9,10 @@ void main() {const track1 = MemoryMusicTrack(id: "track-1",url: "https://example.com/track-1.mp3",- cacheFileName: "track-1.mp3",);const track2 = MemoryMusicTrack(id: "track-2",url: "https://example.com/track-2.mp3",- cacheFileName: "track-2.mp3",);late _FakeMemoryMusicPlayer player;late List<bool> persistedMuteValues;@@ -136,13 +134,12 @@ void main() {});test("music resumes only after every pause reason clears", () async {- await controller.activateMemory("memory-1", currentItemIsVideo: false);-await controller.setAppActive(false);- expect(player.playing, isFalse);expect(player.pausedImmediately, isTrue);-await controller.setViewerActionPaused(true);+ await controller.activateMemory("memory-1", currentItemIsVideo: false);+ expect(player.playing, isFalse);+await controller.setAppActive(true);expect(player.playing, isFalse);diff --git a/mobile/apps/photos/test/services/memories/memory_music_selector_test.dart b/mobile/apps/photos/test/services/memories/memory_music_selector_test.dartindex 34f3a98235..abe1d9ff18 100644--- a/mobile/apps/photos/test/services/memories/memory_music_selector_test.dart+++ b/mobile/apps/photos/test/services/memories/memory_music_selector_test.dart@@ -4,16 +4,8 @@ import "package:photos/services/memories/memory_music_selector.dart";void main() {const tracks = <MemoryMusicTrack>[- MemoryMusicTrack(- id: "track-1",- url: "https://example.com/track-1.mp3",- cacheFileName: "track-1.mp3",- ),- MemoryMusicTrack(- id: "track-2",- url: "https://example.com/track-2.mp3",- cacheFileName: "track-2.mp3",- ),+ MemoryMusicTrack(id: "track-1", url: "https://example.com/track-1.mp3"),+ MemoryMusicTrack(id: "track-2", url: "https://example.com/track-2.mp3"),];const memoryIDs = <String>["memory-a", "memory-b", "memory-c", "memory-d"];@@ -35,11 +27,7 @@ void main() {final assignments = assignMemoryMusicTracks(memoryIDs: memoryIDs,tracks: const <MemoryMusicTrack>[- MemoryMusicTrack(- id: "track-1",- url: "https://example.com/track-1.mp3",- cacheFileName: "track-1.mp3",- ),+ MemoryMusicTrack(id: "track-1", url: "https://example.com/track-1.mp3"),],);diff --git a/mobile/apps/photos/test/services/memories/memory_music_service_test.dart b/mobile/apps/photos/test/services/memories/memory_music_service_test.dartnew file mode 100644index 0000000000..11dad05178--- /dev/null+++ b/mobile/apps/photos/test/services/memories/memory_music_service_test.dart@@ -0,0 +1,271 @@+import "dart:async";+import "dart:convert";++import "package:flutter_test/flutter_test.dart";+import "package:photos/services/memories/memory_music_service.dart";+import "package:shared_preferences/shared_preferences.dart";++const _manifestPreferenceKey = "memory_music_manifest";+const _cachedURL = "https://music.ente.com/cached.mp3";+const _newURL = "https://music.ente.com/new.mp3";+const _sharedURL = "https://music.ente.com/shared.mp3";++void main() {+ late SharedPreferences preferences;++ setUp(() async {+ SharedPreferences.setMockInitialValues({});+ preferences = await SharedPreferences.getInstance();+ });++ test("sorts a valid manifest and caches each URL once", () async {+ final manifest = _manifest([+ _track("z-track", _sharedURL, title: "Zed"),+ _track("a-track", _sharedURL, artist: "Artist"),+ _track("middle-track", _newURL),+ ]);+ final cachedURLs = <String>[];+ final service = _service(+ preferences,+ fetchManifest: () async => manifest,+ cacheAsset: (url) async => cachedURLs.add(url),+ );++ final tracks = await service.prepare();++ expect(tracks.map((track) => track.id), [+ "a-track",+ "middle-track",+ "z-track",+ ]);+ expect(tracks.first.artist, "Artist");+ expect(tracks.last.title, "Zed");+ expect(cachedURLs, unorderedEquals([_sharedURL, _newURL]));+ expect(cachedURLs.where((url) => url == _sharedURL), hasLength(1));+ expect(+ jsonDecode(preferences.getString(_manifestPreferenceKey)!),+ manifest,+ );+ });++ test("uses a cached manifest after failure and retries refresh", () async {+ final cachedManifest = _manifest([_track("cached", _cachedURL)]);+ final refreshedManifest = _manifest([_track("new", _newURL)]);+ final cachedManifestJSON = jsonEncode(cachedManifest);+ await preferences.setString(_manifestPreferenceKey, cachedManifestJSON);+ var fetchCalls = 0;+ final deletedURLs = <String>[];+ final service = _service(+ preferences,+ fetchManifest: () async {+ fetchCalls++;+ if (fetchCalls == 1) throw StateError("offline");+ return refreshedManifest;+ },+ deleteAsset: (url) async => deletedURLs.add(url),+ );++ final fallbackTracks = await service.prepare();++ expect(fallbackTracks.map((track) => track.id), ["cached"]);+ expect(preferences.getString(_manifestPreferenceKey), cachedManifestJSON);+ expect(deletedURLs, isEmpty);++ final refreshedTracks = await service.prepare();++ expect(refreshedTracks.map((track) => track.id), ["new"]);+ expect(fetchCalls, 2);+ expect(deletedURLs, [_cachedURL]);+ expect(+ jsonDecode(preferences.getString(_manifestPreferenceKey)!),+ refreshedManifest,+ );+ });++ for (final invalidManifest in <(String, Object?)>[+ (+ "invalid entry",+ _manifest([+ <String, dynamic>{"id": "broken", "url": 42},+ ]),+ ),+ (+ "duplicate IDs",+ _manifest([+ _track("duplicate", "https://music.ente.com/first.mp3"),+ _track("duplicate", "https://music.ente.com/second.mp3"),+ ]),+ ),+ ]) {+ test("${invalidManifest.$1} preserves the cached manifest", () async {+ final cachedManifest = _manifest([_track("cached", _cachedURL)]);+ final cachedManifestJSON = jsonEncode(cachedManifest);+ await preferences.setString(_manifestPreferenceKey, cachedManifestJSON);+ final deletedURLs = <String>[];+ final service = _service(+ preferences,+ fetchManifest: () async => invalidManifest.$2,+ deleteAsset: (url) async => deletedURLs.add(url),+ );++ final tracks = await service.prepare();++ expect(tracks.map((track) => track.id), ["cached"]);+ expect(preferences.getString(_manifestPreferenceKey), cachedManifestJSON);+ expect(deletedURLs, isEmpty);+ });+ }++ test("an empty manifest removes each previously referenced URL", () async {+ await preferences.setString(+ _manifestPreferenceKey,+ jsonEncode(+ _manifest([+ _track("cached-a", _cachedURL),+ _track("cached-b", _cachedURL),+ _track("shared", _sharedURL),+ ]),+ ),+ );+ final cachedURLs = <String>[];+ final deletedURLs = <String>[];+ final emptyManifest = _manifest([]);+ final service = _service(+ preferences,+ fetchManifest: () async => emptyManifest,+ cacheAsset: (url) async => cachedURLs.add(url),+ deleteAsset: (url) async => deletedURLs.add(url),+ );++ final tracks = await service.prepare();++ expect(tracks, isEmpty);+ expect(cachedURLs, isEmpty);+ expect(deletedURLs, unorderedEquals([_cachedURL, _sharedURL]));+ expect(deletedURLs.where((url) => url == _cachedURL), hasLength(1));+ expect(+ jsonDecode(preferences.getString(_manifestPreferenceKey)!),+ emptyManifest,+ );+ });++ test("removes only URLs no longer shared by the new manifest", () async {+ await preferences.setString(+ _manifestPreferenceKey,+ jsonEncode(+ _manifest([+ _track("removed", _cachedURL),+ _track("old-shared-id", _sharedURL),+ ]),+ ),+ );+ final cachedURLs = <String>[];+ final deletedURLs = <String>[];+ final service = _service(+ preferences,+ fetchManifest: () async => _manifest([+ _track("new-shared-id", _sharedURL),+ _track("new", _newURL),+ ]),+ cacheAsset: (url) async => cachedURLs.add(url),+ deleteAsset: (url) async => deletedURLs.add(url),+ );++ final tracks = await service.prepare();++ expect(tracks.map((track) => track.id), ["new", "new-shared-id"]);+ expect(cachedURLs, unorderedEquals([_newURL, _sharedURL]));+ expect(deletedURLs, [_cachedURL]);+ });++ test(+ "filters an audio failure and retries it without refetching the manifest",+ () async {+ const firstURL = "https://music.ente.com/first.mp3";+ const secondURL = "https://music.ente.com/second.mp3";+ var fetchCalls = 0;+ final cacheAttempts = <String, int>{};+ final service = _service(+ preferences,+ fetchManifest: () async {+ fetchCalls++;+ return _manifest([+ _track("first", firstURL),+ _track("second", secondURL),+ ]);+ },+ cacheAsset: (url) async {+ final attempt = (cacheAttempts[url] ?? 0) + 1;+ cacheAttempts[url] = attempt;+ if (url == firstURL && attempt == 1) {+ throw StateError("download failed");+ }+ },+ );++ final firstTracks = await service.prepare();+ final retriedTracks = await service.prepare();++ expect(firstTracks.map((track) => track.id), ["second"]);+ expect(retriedTracks.map((track) => track.id), ["first", "second"]);+ expect(fetchCalls, 1);+ expect(cacheAttempts, <String, int>{firstURL: 2, secondURL: 2});+ },+ );++ test("concurrent preparation shares one manifest fetch", () async {+ final fetchStarted = Completer<void>();+ final finishFetch = Completer<void>();+ var fetchCalls = 0;+ var cacheCalls = 0;+ final service = _service(+ preferences,+ fetchManifest: () async {+ fetchCalls++;+ fetchStarted.complete();+ await finishFetch.future;+ return _manifest([_track("track", _newURL)]);+ },+ cacheAsset: (_) async => cacheCalls++,+ );++ final firstPreparation = service.prepare();+ await fetchStarted.future;+ final secondPreparation = service.prepare();++ expect(identical(firstPreparation, secondPreparation), isTrue);+ expect(fetchCalls, 1);++ finishFetch.complete();+ final results = await Future.wait([firstPreparation, secondPreparation]);++ expect(results[0].map((track) => track.id), ["track"]);+ expect(results[1].map((track) => track.id), ["track"]);+ expect(cacheCalls, 1);+ });+}++MemoryMusicService _service(+ SharedPreferences preferences, {+ required Future<Object?> Function() fetchManifest,+ Future<void> Function(String url)? cacheAsset,+ Future<void> Function(String url)? deleteAsset,+}) {+ return MemoryMusicService(+ preferences: preferences,+ fetchManifest: fetchManifest,+ cacheAsset: cacheAsset ?? (_) async {},+ deleteAsset: deleteAsset ?? (_) async {},+ );+}++Map<String, dynamic> _manifest(List<Map<String, dynamic>> tracks) => {+ "tracks": tracks,+};++Map<String, dynamic> _track(+ String id,+ Object url, {+ String? title,+ String? artist,+}) => {"id": id, "url": url, "title": ?title, "artist": ?artist};diff --git a/mobile/apps/photos/test/services/remote_assets_service_test.dart b/mobile/apps/photos/test/services/remote_assets_service_test.dartnew file mode 100644index 0000000000..ba6d455c7a--- /dev/null+++ b/mobile/apps/photos/test/services/remote_assets_service_test.dart@@ -0,0 +1,89 @@+import "dart:io";++import "package:flutter_test/flutter_test.dart";+import "package:path/path.dart" as p;+import "package:path_provider_platform_interface/path_provider_platform_interface.dart";+import "package:photos/services/remote_assets_service.dart";++void main() {+ TestWidgetsFlutterBinding.ensureInitialized();++ late Directory tempDirectory;+ late PathProviderPlatform previousPathProvider;++ setUp(() async {+ previousPathProvider = PathProviderPlatform.instance;+ tempDirectory = await Directory.systemTemp.createTemp(+ "remote_assets_service_test_",+ );+ PathProviderPlatform.instance = _FakePathProvider(tempDirectory.path);+ });++ tearDown(() async {+ PathProviderPlatform.instance = previousPathProvider;+ await tempDirectory.delete(recursive: true);+ });++ test("deleteAsset removes every custom-named cache artifact", () async {+ const cacheFileName = "memory-music-track.mp3";+ final localPath = p.join(tempDirectory.path, "assets", cacheFileName);+ final artifacts = await _createAssetArtifacts(localPath);+ final unrelatedFile = File(+ p.join(tempDirectory.path, "assets", "unrelated.mp3"),+ );+ await unrelatedFile.writeAsString("unrelated");++ await RemoteAssetsService.instance.deleteAsset(+ "https://music.ente.com/track.mp3",+ cacheFileName: cacheFileName,+ );++ for (final artifact in artifacts) {+ expect(await artifact.exists(), isFalse);+ }+ expect(await unrelatedFile.exists(), isTrue);++ await RemoteAssetsService.instance.deleteAsset(+ "https://music.ente.com/track.mp3",+ cacheFileName: cacheFileName,+ );+ });++ test("deleteAsset retains the existing default cache-name mapping", () async {+ const remotePath = "https://models.ente.com/model.onnx";+ final localPath = p.join(+ tempDirectory.path,+ "assets",+ "models_ente_com_model_onnx",+ );+ final artifacts = await _createAssetArtifacts(localPath);++ await RemoteAssetsService.instance.deleteAsset(remotePath);++ for (final artifact in artifacts) {+ expect(await artifact.exists(), isFalse);+ }+ });+}++Future<List<File>> _createAssetArtifacts(String localPath) async {+ final artifacts = <File>[+ File(localPath),+ File("$localPath.temp"),+ File("$localPath.temp.resume.json"),+ ];+ for (final artifact in artifacts) {+ await artifact.create(recursive: true);+ await artifact.writeAsString("asset");+ }+ return artifacts;+}++class _FakePathProvider extends PathProviderPlatform {+ _FakePathProvider(this.applicationSupportPath);++ final String applicationSupportPath;++ @override+ Future<String?> getApplicationSupportPath() async => applicationSupportPath;+}