Skip to content

armgit / ente

Public Imported from GitHub
0

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

Load memory music from manifest

ashilkn89be0d0fa520
diff --git a/mobile/apps/photos/lib/main.dart b/mobile/apps/photos/lib/main.dart
index 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.d
import "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.dart
index 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.dart
index 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 {
@override
Future<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;
+ }
}
@override
diff --git a/mobile/apps/photos/lib/services/memories/memory_music_service.dart b/mobile/apps/photos/lib/services/memories/memory_music_service.dart
new file mode 100644
index 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.dart
deleted file mode 100644
index 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.dart
index 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.dart
index 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.dart
index 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;
@override
void 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);
}
@override
void didChangeAppLifecycleState(AppLifecycleState state) {
- unawaited(_controller.setAppActive(state == AppLifecycleState.resumed));
+ _isAppActive = state == AppLifecycleState.resumed;
+ final controller = _controller;
+ if (controller != null) {
+ unawaited(controller.setAppActive(_isAppActive));
+ }
}
@override
void 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.dart
index 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.dart
index 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.dart
new file mode 100644
index 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.dart
new file mode 100644
index 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;
+}