diff --git a/android/app/src/main/kotlin/com/zarz/mornye/MainActivity.kt b/android/app/src/main/kotlin/com/zarz/mornye/MainActivity.kt index 03c2b7fe9..061cd322b 100644 --- a/android/app/src/main/kotlin/com/zarz/mornye/MainActivity.kt +++ b/android/app/src/main/kotlin/com/zarz/mornye/MainActivity.kt @@ -123,6 +123,7 @@ class MainActivity: FlutterFragmentActivity() { "writeSafSidecarLrc", "writeSafSidecar", "readSafSidecar", + "findSafSibling", "downloadCoverToFile", "extractCoverToFile", "rewriteSplitArtistTags", @@ -562,6 +563,7 @@ class MainActivity: FlutterFragmentActivity() { "writeSafSidecarLrc" -> handleWriteSafSidecarLrc(call, result) "writeSafSidecar" -> handleWriteSafSidecar(call, result) "readSafSidecar" -> handleReadSafSidecar(call, result) + "findSafSibling" -> handleFindSafSibling(call, result) "downloadCoverToFile" -> handleDownloadCoverToFile(call, result) "extractCoverToFile" -> handleExtractCoverToFile(call, result) "reEnrichFile" -> handleReEnrichFile(call, result) diff --git a/android/app/src/main/kotlin/com/zarz/mornye/MainActivitySafCalls.kt b/android/app/src/main/kotlin/com/zarz/mornye/MainActivitySafCalls.kt index 32f6eda3b..acab4e0d0 100644 --- a/android/app/src/main/kotlin/com/zarz/mornye/MainActivitySafCalls.kt +++ b/android/app/src/main/kotlin/com/zarz/mornye/MainActivitySafCalls.kt @@ -422,6 +422,20 @@ internal suspend fun MainActivity.handleReadSafSidecar(call: MethodCall, result: result.success(content) } +internal suspend fun MainActivity.handleFindSafSibling(call: MethodCall, result: MethodChannel.Result) { + val safUri = call.argument("saf_uri") ?: "" + val name = call.argument("name") ?: "" + val sibling = withContext(Dispatchers.IO) { + // A plain file name: never a path into another folder. + if (name.isBlank() || name.contains('/') || name.startsWith('.')) { + null + } else { + findSafSibling(Uri.parse(safUri), name) + } + } + result.success(sibling) +} + internal suspend fun MainActivity.handleGetSafFileModTimes(call: MethodCall, result: MethodChannel.Result) { val uris = call.argument("uris") ?: "[]" val response = withContext(Dispatchers.IO) { diff --git a/android/app/src/main/kotlin/com/zarz/mornye/MainActivitySafIo.kt b/android/app/src/main/kotlin/com/zarz/mornye/MainActivitySafIo.kt index 4290ba204..fce639b75 100644 --- a/android/app/src/main/kotlin/com/zarz/mornye/MainActivitySafIo.kt +++ b/android/app/src/main/kotlin/com/zarz/mornye/MainActivitySafIo.kt @@ -529,6 +529,26 @@ internal fun Context.readSafSidecar( } } +/** + * The file named [name] in the folder of a SAF audio document, such as an + * album's "cover.mp4", as its uri, size and modification time, or null when + * the folder has none. + */ +internal fun Context.findSafSibling(audioUri: Uri, name: String): Map? { + return try { + val parent = safParentDir(audioUri) ?: return null + val sibling = findSafChild(this, parent, name)?.takeIf { it.isFile } ?: return null + mapOf( + "uri" to sibling.uri.toString(), + "size" to sibling.length(), + "modified" to sibling.lastModified(), + ) + } catch (e: Exception) { + android.util.Log.w("Mornye", "Sibling lookup failed: ${e.message}") + null + } +} + internal fun Context.runPostProcessingSafV2( coreBackend: CoreBackend, fileUriStr: String, diff --git a/lib/l10n/arb/app_en.arb b/lib/l10n/arb/app_en.arb index 2b4bce4e7..6620cd3e2 100644 --- a/lib/l10n/arb/app_en.arb +++ b/lib/l10n/arb/app_en.arb @@ -528,6 +528,14 @@ "@downloadSingleFilenameFormatDescription": { "description": "Subtitle description for single filename format setting" }, + "downloadSaveMotionArtwork": "Save Animated Covers", + "@downloadSaveMotionArtwork": { + "description": "Files setting that copies an album's animated cover video into the album's download folder" + }, + "downloadSaveMotionArtworkSubtitle": "Adds the album's animated cover to its folder as cover.mp4, for albums that have their own folder", + "@downloadSaveMotionArtworkSubtitle": { + "description": "Subtitle of the Save Animated Covers switch. Keep 'cover.mp4' as is: it is a file name" + }, "downloadFolderOrganization": "Folder Organization", "@downloadFolderOrganization": { "description": "Title of the folder organization picker bottom sheet" diff --git a/lib/models/settings.dart b/lib/models/settings.dart index 5fa914ed8..9c04c4ebb 100644 --- a/lib/models/settings.dart +++ b/lib/models/settings.dart @@ -216,6 +216,9 @@ class AppSettings { final String lyricsMode; final bool keepScreenOnLyrics; final bool motionArtworkEnabled; + + /// Copy a download's animated cover into its album folder as `cover.mp4`. + final bool saveMotionArtworkFile; final bool listeningStatisticsEnabled; final bool autoConvertDownloads; // Re-download a Hi-Res request at LOSSLESS when the file measures as fake. @@ -402,6 +405,7 @@ class AppSettings { this.lyricsMode = 'embed', this.keepScreenOnLyrics = true, this.motionArtworkEnabled = true, + this.saveMotionArtworkFile = false, this.listeningStatisticsEnabled = true, this.autoConvertDownloads = false, this.redownloadFakeHiRes = false, @@ -563,6 +567,7 @@ class AppSettings { String? lyricsMode, bool? keepScreenOnLyrics, bool? motionArtworkEnabled, + bool? saveMotionArtworkFile, bool? listeningStatisticsEnabled, bool? autoConvertDownloads, bool? redownloadFakeHiRes, @@ -725,6 +730,8 @@ class AppSettings { lyricsMode: lyricsMode ?? this.lyricsMode, keepScreenOnLyrics: keepScreenOnLyrics ?? this.keepScreenOnLyrics, motionArtworkEnabled: motionArtworkEnabled ?? this.motionArtworkEnabled, + saveMotionArtworkFile: + saveMotionArtworkFile ?? this.saveMotionArtworkFile, listeningStatisticsEnabled: listeningStatisticsEnabled ?? this.listeningStatisticsEnabled, autoConvertDownloads: autoConvertDownloads ?? this.autoConvertDownloads, diff --git a/lib/models/settings.g.dart b/lib/models/settings.g.dart index 529f78bc0..a7870bcaf 100644 --- a/lib/models/settings.g.dart +++ b/lib/models/settings.g.dart @@ -136,6 +136,7 @@ AppSettings _$AppSettingsFromJson(Map json) => AppSettings( lyricsMode: json['lyricsMode'] as String? ?? 'embed', keepScreenOnLyrics: json['keepScreenOnLyrics'] as bool? ?? true, motionArtworkEnabled: json['motionArtworkEnabled'] as bool? ?? true, + saveMotionArtworkFile: json['saveMotionArtworkFile'] as bool? ?? false, listeningStatisticsEnabled: json['listeningStatisticsEnabled'] as bool? ?? true, autoConvertDownloads: json['autoConvertDownloads'] as bool? ?? false, @@ -290,6 +291,7 @@ Map _$AppSettingsToJson( 'lyricsMode': instance.lyricsMode, 'keepScreenOnLyrics': instance.keepScreenOnLyrics, 'motionArtworkEnabled': instance.motionArtworkEnabled, + 'saveMotionArtworkFile': instance.saveMotionArtworkFile, 'listeningStatisticsEnabled': instance.listeningStatisticsEnabled, 'autoConvertDownloads': instance.autoConvertDownloads, 'redownloadFakeHiRes': instance.redownloadFakeHiRes, diff --git a/lib/providers/download_queue_provider.dart b/lib/providers/download_queue_provider.dart index 8135a186d..dae58e2e0 100644 --- a/lib/providers/download_queue_provider.dart +++ b/lib/providers/download_queue_provider.dart @@ -1000,6 +1000,22 @@ class DownloadQueueNotifier extends Notifier { playlistName: playlistName, ); + @visibleForTesting + Future holdsAlbumFilesFor( + DownloadItem item, + AppSettings settings, { + required String filePath, + String? relativeDir, + String quality = 'LOSSLESS', + }) => _holdsAlbumFiles( + item.track, + item, + settings, + quality, + filePath: filePath, + relativeDir: relativeDir, + ); + DownloadItem? _findItemById(String id) { return state.lookup.byItemId[id]; } diff --git a/lib/providers/download_queue_provider_finalization.dart b/lib/providers/download_queue_provider_finalization.dart index 393b3ce8c..f71952fbc 100644 --- a/lib/providers/download_queue_provider_finalization.dart +++ b/lib/providers/download_queue_provider_finalization.dart @@ -48,12 +48,22 @@ extension _DownloadQueueFinalization on DownloadQueueNotifier { info: _log.i, ); + /// Saves the album's animated cover for the player and, when the settings + /// ask, as `cover.mp4` beside [filePath] in the album's own folder: an + /// Android document there needs [treeUri] and [relativeDir]. The folder + /// was planned from [folderTrack], when it differs from [track]. Future _saveDownloadedMotionArtwork( Ref ref, DownloadItem item, Track track, - Map result, - ) async { + Map result, { + required AppSettings settings, + required String quality, + String? filePath, + String? treeUri, + String? relativeDir, + Track? folderTrack, + }) async { // Store independently of history preferences and the selected UI theme. // A later switch to Mornye must still work without network access. try { @@ -84,6 +94,30 @@ extension _DownloadQueueFinalization on DownloadQueueNotifier { if (artwork != null && ref.mounted) { ref.invalidate(playerMotionArtworkProvider(album)); } + if (artwork == null || + filePath == null || + !settings.saveMotionArtworkFile || + !ref.mounted || + !await _holdsAlbumFiles( + folderTrack ?? track, + item, + settings, + quality, + filePath: filePath, + relativeDir: relativeDir, + ) || + !ref.mounted) { + return; + } + final saved = await ref + .read(motionArtworkFolderProvider) + .save( + File.fromUri(Uri.parse(artwork.source)), + song: filePath, + treeUri: treeUri, + relativeDir: relativeDir, + ); + if (saved) _log.i('Animated cover saved to the album folder'); } catch (error) { _log.w('Optional motion artwork was not saved: ${error.runtimeType}'); } diff --git a/lib/providers/download_queue_provider_native_worker.dart b/lib/providers/download_queue_provider_native_worker.dart index ff7752438..0401db6a5 100644 --- a/lib/providers/download_queue_provider_native_worker.dart +++ b/lib/providers/download_queue_provider_native_worker.dart @@ -1257,7 +1257,17 @@ extension _DownloadQueueNativeWorker on DownloadQueueNotifier { if (result.nativeFinalized) { final nativeFinalizedFilePath = filePath; - await _saveDownloadedMotionArtwork(ref, item, item.track, result); + await _saveDownloadedMotionArtwork( + ref, + item, + item.track, + result, + settings: settings, + quality: context.quality, + filePath: nativeFinalizedFilePath, + treeUri: context.storageMode == 'saf' ? context.downloadTreeUri : null, + relativeDir: context.safRelativeDir, + ); await persistBeforePublishingDownloadCompletion( persist: () async { if (!settings.saveDownloadHistory) return; @@ -1521,7 +1531,18 @@ extension _DownloadQueueNativeWorker on DownloadQueueNotifier { lowerFilePath.endsWith('.ogg'); final completedFilePath = filePath; - await _saveDownloadedMotionArtwork(ref, item, trackToDownload, result); + await _saveDownloadedMotionArtwork( + ref, + item, + trackToDownload, + result, + settings: settings, + quality: context.quality, + filePath: completedFilePath, + treeUri: context.storageMode == 'saf' ? context.downloadTreeUri : null, + relativeDir: context.safRelativeDir, + folderTrack: item.track, + ); final lyricsAvailability = await _resolveFinalLyricsAvailability( filePath: completedFilePath, externalLrcWritten: externalLrcWritten, diff --git a/lib/providers/download_queue_provider_paths.dart b/lib/providers/download_queue_provider_paths.dart index a03f869e6..d852f3161 100644 --- a/lib/providers/download_queue_provider_paths.dart +++ b/lib/providers/download_queue_provider_paths.dart @@ -453,6 +453,89 @@ extension _DownloadQueuePaths on DownloadQueueNotifier { }; } + /// The folder, as relative parts, when downloads of [track] go to a folder + /// of their album alone, so files that belong to the whole album can sit + /// beside them. Planned again with a marker for the album name: a folder + /// that holds an album names it in its last part and nowhere else differs. + Future?> _albumFolderParts( + Track track, + DownloadItem item, + AppSettings settings, + String quality, + ) async { + if (track.albumName.trim().isEmpty) return null; + const marker = 'mornyealbumfolder'; + Future> folder(Track value) async => _buildRelativeOutputDir( + value, + settings, + customFolderPath: await _resolveCustomFolderPath( + value, + item, + settings, + quality, + ), + playlistName: item.playlistName, + ).split('/').where((part) => part.isNotEmpty).toList(); + final markedTrack = track.copyWith(albumName: marker); + // An album named like "Singles" counts as a single: renaming it must + // not move it out of the shared Singles folder. + if (settings.separateSingles && + _shouldTreatAsSingleRelease(track) != + _shouldTreatAsSingleRelease(markedTrack)) { + return null; + } + final planned = await folder(track); + final marked = await folder(markedTrack); + bool named(String part) => part.toLowerCase().contains(marker); + // A playlist folder or a shared Singles folder names no album. + if (marked.isEmpty || planned.length != marked.length) return null; + if (!named(marked.last)) return null; + for (var i = 0; i < marked.length; i++) { + if (!named(marked[i]) && marked[i] != planned[i]) return null; + } + return planned; + } + + /// Whether the song of [track] saved at [filePath], or as a document in + /// [relativeDir], sits in a folder of its album alone, and not in one an + /// earlier copy of it was kept in. + Future _holdsAlbumFiles( + Track track, + DownloadItem item, + AppSettings settings, + String quality, { + required String filePath, + String? relativeDir, + }) async { + final parts = await _albumFolderParts(track, item, settings, quality); + return parts != null && _isInAlbumFolder(filePath, relativeDir, parts); + } + + bool _isInAlbumFolder( + String filePath, + String? relativeDir, + List parts, + ) { + final List folder; + if (isContentUri(filePath)) { + folder = (relativeDir ?? '').split('/'); + } else if (filePath.startsWith('network://')) { + final segments = Uri.tryParse(filePath)?.pathSegments ?? const []; + folder = segments.isEmpty + ? const [] + : segments.sublist(0, segments.length - 1); + } else { + folder = p.split(p.dirname(filePath)); + } + final named = folder.where((part) => part.isNotEmpty).toList(); + if (named.length < parts.length) return false; + final tail = named.sublist(named.length - parts.length); + for (var i = 0; i < parts.length; i++) { + if (tail[i] != parts[i]) return false; + } + return true; + } + String _joinRelativePath(String prefix, String suffix) { if (prefix.isEmpty) return suffix; if (suffix.isEmpty) return prefix; diff --git a/lib/providers/download_queue_provider_single_item.dart b/lib/providers/download_queue_provider_single_item.dart index 22ecc5a16..d7ca02ea9 100644 --- a/lib/providers/download_queue_provider_single_item.dart +++ b/lib/providers/download_queue_provider_single_item.dart @@ -1682,6 +1682,11 @@ class _DownloadRun { item, trackToDownload, result, + settings: settings, + quality: quality, + filePath: historyFilePath, + treeUri: effectiveSafMode ? settings.downloadTreeUri : null, + relativeDir: effectiveSafMode ? effectiveOutputDir : null, ); onStageCompleted?.call('optional motion artwork'); await persistBeforePublishingDownloadCompletion( diff --git a/lib/providers/player_motion_artwork_provider.dart b/lib/providers/player_motion_artwork_provider.dart index 0a719add3..d68b09678 100644 --- a/lib/providers/player_motion_artwork_provider.dart +++ b/lib/providers/player_motion_artwork_provider.dart @@ -1,5 +1,6 @@ import 'package:flutter_riverpod/flutter_riverpod.dart'; import 'package:mornye/providers/settings_provider.dart'; +import 'package:mornye/services/motion_artwork_folder.dart'; import 'package:mornye/services/motion_artwork_store.dart'; import 'package:mornye/utils/logger.dart'; import 'package:mornye/utils/string_utils.dart'; @@ -8,6 +9,12 @@ typedef PlayerArtworkAlbum = ({String album, String artist}); final motionArtworkStoreProvider = Provider((ref) => MotionArtworkStore()); +final motionArtworkFolderProvider = Provider((ref) => MotionArtworkFolder()); + +/// An album and the song, or one of its songs, whose folder may hold the +/// album's `cover.mp4`. +typedef PlayerArtworkSong = ({String album, String artist, String source}); + /// Player and local album pages read artwork saved by downloads or re-enrich. /// Opening either must never search extensions or download more artwork. final playerMotionArtworkProvider = FutureProvider.autoDispose @@ -21,6 +28,26 @@ final playerMotionArtworkProvider = FutureProvider.autoDispose return ref.watch(motionArtworkStoreProvider).find(album); }); +/// The artwork for a song: a `cover.mp4` in its folder first, since that +/// one belongs to exactly this album and is the user's own file, then the +/// artwork saved for the album. +final songMotionArtworkProvider = FutureProvider.autoDispose + .family((ref, song) async { + if (!ref.watch(settingsProvider.select((s) => s.motionArtworkEnabled))) { + return null; + } + final (beside, saved) = await ( + ref.watch(motionArtworkFolderProvider).find(song.source), + ref.watch( + playerMotionArtworkProvider(( + album: song.album, + artist: song.artist, + )).future, + ), + ).wait; + return beside ?? saved; + }); + /// Optional video is kept outside audio tags, after the metadata write succeeds. Future saveReEnrichedMotionArtwork( ProviderContainer container, { diff --git a/lib/providers/settings_provider.dart b/lib/providers/settings_provider.dart index 7ed21487c..11e033cf4 100644 --- a/lib/providers/settings_provider.dart +++ b/lib/providers/settings_provider.dart @@ -778,6 +778,9 @@ class SettingsNotifier extends Notifier { void setMotionArtworkEnabled(bool enabled) => _commit(state.copyWith(motionArtworkEnabled: enabled)); + void setSaveMotionArtworkFile(bool enabled) => + _commit(state.copyWith(saveMotionArtworkFile: enabled)); + void setListeningStatisticsEnabled(bool enabled) => _commit(state.copyWith(listeningStatisticsEnabled: enabled)); diff --git a/lib/screens/downloaded_album_screen.dart b/lib/screens/downloaded_album_screen.dart index 46e8544e5..0cf2f7176 100644 --- a/lib/screens/downloaded_album_screen.dart +++ b/lib/screens/downloaded_album_screen.dart @@ -377,11 +377,12 @@ class _DownloadedAlbumScreenState extends ConsumerState final motion = context.isMornye && !MediaQuery.disableAnimationsOf(context) ? ref .watch( - playerMotionArtworkProvider(( + songMotionArtworkProvider(( album: widget.albumName, artist: tracks.isEmpty ? widget.artistName : tracks.first.artistName, + source: tracks.firstOrNull?.filePath ?? '', )), ) .value diff --git a/lib/screens/local_album_screen.dart b/lib/screens/local_album_screen.dart index 647ff08e8..a34941076 100644 --- a/lib/screens/local_album_screen.dart +++ b/lib/screens/local_album_screen.dart @@ -368,11 +368,12 @@ class _LocalAlbumScreenState extends ConsumerState final motion = context.isMornye && !MediaQuery.disableAnimationsOf(context) ? ref .watch( - playerMotionArtworkProvider(( + songMotionArtworkProvider(( album: widget.albumName, artist: _sortedTracksCache.firstOrNull?.artistName ?? widget.artistName, + source: _sortedTracksCache.firstOrNull?.filePath ?? '', )), ) .value diff --git a/lib/screens/now_playing_screen.dart b/lib/screens/now_playing_screen.dart index 9ce76beec..06b46c3b9 100644 --- a/lib/screens/now_playing_screen.dart +++ b/lib/screens/now_playing_screen.dart @@ -353,9 +353,10 @@ class _NowPlayingScreenState extends ConsumerState { ref.watch(settingsProvider.select((s) => s.motionArtworkEnabled)) && !MediaQuery.disableAnimationsOf(context) ? ref.watch( - playerMotionArtworkProvider(( + songMotionArtworkProvider(( album: mediaItem.album ?? '', artist: mediaItem.artist ?? '', + source: source, )), ) : null; diff --git a/lib/screens/settings/cache_management_page.dart b/lib/screens/settings/cache_management_page.dart index b45d92f13..1d46d7169 100644 --- a/lib/screens/settings/cache_management_page.dart +++ b/lib/screens/settings/cache_management_page.dart @@ -154,7 +154,9 @@ class _CacheManagementPageState extends ConsumerState { } Future _clearMotionArtwork() async { + // Copies of folder covers live in the same directory. await ref.read(motionArtworkStoreProvider).clear(); + ref.read(motionArtworkFolderProvider).forget(); if (mounted) ref.invalidate(playerMotionArtworkProvider); } diff --git a/lib/screens/settings/files_settings_page.dart b/lib/screens/settings/files_settings_page.dart index 8ce23d533..008390f38 100644 --- a/lib/screens/settings/files_settings_page.dart +++ b/lib/screens/settings/files_settings_page.dart @@ -220,6 +220,15 @@ class _FilesSettingsPageState extends ConsumerState { description: context.l10n.downloadSingleFilenameFormatDescription, ), + ), + SettingsSwitchItem( + icon: Icons.motion_photos_on_outlined, + title: context.l10n.downloadSaveMotionArtwork, + subtitle: context.l10n.downloadSaveMotionArtworkSubtitle, + value: settings.saveMotionArtworkFile, + onChanged: ref + .read(settingsProvider.notifier) + .setSaveMotionArtworkFile, showDivider: false, ), ], diff --git a/lib/services/motion_artwork_folder.dart b/lib/services/motion_artwork_folder.dart new file mode 100644 index 000000000..8107ca903 --- /dev/null +++ b/lib/services/motion_artwork_folder.dart @@ -0,0 +1,289 @@ +import 'dart:async'; +import 'dart:convert'; +import 'dart:io'; + +import 'package:crypto/crypto.dart'; +import 'package:path/path.dart' as p; +import 'package:mornye/services/motion_artwork_store.dart'; +import 'package:mornye/services/network_storage_service.dart'; +import 'package:mornye/services/platform_bridge.dart'; +import 'package:mornye/utils/file_access.dart'; +import 'package:mornye/utils/logger.dart'; + +/// The name an album's animated cover has in the album's folder. +const motionArtworkFileName = 'cover.mp4'; +const _maxBytes = 64 << 20; + +typedef MotionArtworkDocument = ({String uri, int size, int modified}); + +/// An album's animated cover kept as `cover.mp4` in the album's own folder, +/// where file managers and other players find it. Downloads write it there +/// when the settings ask; the player shows one it finds beside a song. +class MotionArtworkFolder { + MotionArtworkFolder({ + Future Function()? directory, + Future Function(String song, String name)? sibling, + Future Function(String uri)? copyDocument, + Future Function( + String treeUri, + String relativeDir, + String name, + String path, + )? + createDocument, + Future Function(String target, File file)? upload, + bool? documents, + }) : _directory = directory ?? MotionArtworkStore.defaultDirectory, + _sibling = sibling ?? PlatformBridge.findSafSibling, + _copyDocument = copyDocument ?? PlatformBridge.copyContentUriToTemp, + _createDocument = createDocument ?? _createSafDocument, + _upload = upload ?? _uploadToNetwork, + _documents = documents ?? Platform.isAndroid; + + final Future Function() _directory; + final Future Function(String song, String name) + _sibling; + final Future Function(String uri) _copyDocument; + final Future Function( + String treeUri, + String relativeDir, + String name, + String path, + ) + _createDocument; + final Future Function(String target, File file) _upload; + final bool _documents; + final _saving = >{}; + final _done = {}; + final _copying = >{}; + + /// Android document lookups by song, so moving between songs does not ask + /// the provider again; a cover added later shows within minutes. + final _found = )>{}; + static const _foundFor = Duration(minutes: 5); + static final _log = AppLogger('MotionArtworkFolder'); + + /// Forgets document lookups, after their copies were cleared. + void forget() => _found.clear(); + + /// Saves [video] as the `cover.mp4` of the folder holding [song]: a local + /// path, an Android document in [treeUri]/[relativeDir], or a network + /// song. A cover already there stays. True when one was written. + Future save( + File video, { + required String song, + String? treeUri, + String? relativeDir, + }) { + final String folder; + final Future Function() write; + if (song.startsWith('network://')) { + final uri = Uri.tryParse(song); + if (uri == null || uri.host.isEmpty) return Future.value(false); + final parent = p.posix.dirname(uri.pathSegments.join('/')); + folder = NetworkStorageService.source( + uri.host, + parent == '.' + ? motionArtworkFileName + : '$parent/$motionArtworkFileName', + ); + write = () => _upload(folder, video); + } else if (isContentUri(song)) { + if (treeUri == null || treeUri.isEmpty || relativeDir == null) { + return Future.value(false); + } + folder = '$treeUri\n$relativeDir'; + write = () => _createDocument( + treeUri, + relativeDir, + motionArtworkFileName, + video.path, + ); + } else { + final path = _localPath(song); + if (path == null) return Future.value(false); + folder = p.dirname(path); + write = () => _copyLocal(video, folder); + } + // Songs of one album finish together: the first writes, the rest wait + // for it, and later ones in this session do not look again. + if (_done.contains(folder)) return Future.value(false); + final pending = _saving[folder]; + if (pending != null) return pending.then((_) => false); + final saving = () async { + try { + if (!await video.exists() || await video.length() == 0) return false; + final written = await write(); + if (_done.length >= 256) _done.clear(); + _done.add(folder); + return written; + } catch (error) { + _log.w('Animated cover was not saved to the folder: $error'); + return false; + } + }(); + _saving[folder] = saving; + return saving.whenComplete(() => _saving.remove(folder)); + } + + Future _copyLocal(File video, String folder) async { + final target = File(p.join(folder, motionArtworkFileName)); + if (await target.exists()) return false; + final staged = File('${target.path}.partial'); + try { + await video.copy(staged.path); + if (await target.exists()) return false; + await staged.rename(target.path); + return true; + } finally { + if (await staged.exists()) await deleteFileQuietly(staged); + } + } + + /// The `cover.mp4` in [song]'s folder as a local file the player can show, + /// or null when there is none. Android documents are copied into the app + /// once, since the video player only opens files. + Future find(String song) async { + if (song.isEmpty || song.startsWith('network://')) return null; + if (isContentUri(song)) { + if (!_documents) return null; + final now = DateTime.now(); + final found = _found[song]; + if (found != null && now.difference(found.$1) < _foundFor) { + return found.$2; + } + if (_found.length >= 64) _found.clear(); + final lookup = _findDocument(song); + _found[song] = (now, lookup); + return lookup; + } + final path = _localPath(song); + if (path == null) return null; + try { + final file = File(p.join(p.dirname(path), motionArtworkFileName)); + if (!await file.exists()) return null; + final length = await file.length(); + if (length == 0 || length > _maxBytes) return null; + return MotionArtwork(file.uri.toString()); + } catch (_) { + return null; + } + } + + Future _findDocument(String song) async { + try { + final document = await _sibling(song, motionArtworkFileName); + if (document == null || document.size <= 0 || document.size > _maxBytes) { + return null; + } + // Songs of one album share a cover: copy it once. + final pending = _copying[document.uri]; + if (pending != null) return await pending; + final copying = _copyIn(document); + _copying[document.uri] = copying; + try { + return await copying; + } finally { + _copying.remove(document.uri); + } + } catch (error) { + _log.w('Could not read the folder animated cover: $error'); + return null; + } + } + + Future _copyIn(MotionArtworkDocument document) async { + File? staged; + try { + final root = Directory(p.join((await _directory()).path, 'folder')); + final key = sha256.convert(utf8.encode(document.uri)).toString(); + final file = File(p.join(root.path, '$key.mp4')); + final info = File(p.join(root.path, '$key.json')); + final stamp = jsonEncode({ + 'size': document.size, + 'modified': document.modified, + }); + if (await file.exists() && + await info.exists() && + await info.readAsString() == stamp) { + return MotionArtwork(file.uri.toString()); + } + final copied = await _copyDocument(document.uri); + if (copied == null) return null; + await root.create(recursive: true); + staged = File(p.join(root.path, '$key.partial.mp4')); + final source = File(copied); + try { + await source.rename(staged.path); + } on FileSystemException { + await source.copy(staged.path); + await deleteFileQuietly(source); + } + if (await staged.length() != document.size) return null; + await staged.rename(file.path); + await info.writeAsString(stamp, flush: true); + return MotionArtwork(file.uri.toString()); + } catch (error) { + _log.w('Could not read the folder animated cover: $error'); + return null; + } finally { + if (staged != null && await staged.exists()) { + await deleteFileQuietly(staged); + } + } + } + + static String? _localPath(String song) { + if (song.isEmpty || + isContentUri(song) || + const {'http', 'https'}.contains(Uri.tryParse(song)?.scheme)) { + return null; + } + final uri = Uri.tryParse(song); + final path = uri?.scheme == 'file' ? uri!.toFilePath() : song; + final real = isCueVirtualPath(path) ? stripCueTrackSuffix(path) : path; + return p.isAbsolute(real) ? real : null; + } + + static Future _createSafDocument( + String treeUri, + String relativeDir, + String name, + String path, + ) async { + final result = await PlatformBridge.createSafFileIfAbsentFromPath( + treeUri: treeUri, + relativeDir: relativeDir, + fileName: name, + mimeType: 'video/mp4', + srcPath: path, + ); + final uri = (result['uri'] as String? ?? '').trim(); + return uri.isNotEmpty && result['already_exists'] != true; + } + + static Future _uploadToNetwork(String target, File file) async { + final storage = NetworkStorageService.instance; + final uri = Uri.parse(target); + final path = networkPath(uri.pathSegments.join('/')); + final slash = path.lastIndexOf('/'); + final parent = slash < 0 ? '' : path.substring(0, slash + 1); + // Looking by name first: an upload over an existing file would download + // it to compare, and a different one is the user's to keep. + final entries = await storage.list( + await storage.connection(uri.host), + parent, + ); + if (entries.any((e) => e.name.toLowerCase() == motionArtworkFileName)) { + return false; + } + await storage.publishUpload( + target, + file, + 'motion-cover:$target', + checkpoint: () {}, + progress: (_, _) {}, + ); + return true; + } +} diff --git a/lib/services/platform_bridge.dart b/lib/services/platform_bridge.dart index 3aef911c8..73ac42290 100644 --- a/lib/services/platform_bridge.dart +++ b/lib/services/platform_bridge.dart @@ -1702,6 +1702,23 @@ class PlatformBridge { 'extension': extension, }); + /// The file named [name] in the folder of the SAF document [safUri], or + /// null when the folder has none. + static Future<({String uri, int size, int modified})?> findSafSibling( + String safUri, + String name, + ) async { + final result = await _channel.invokeMethod>( + 'findSafSibling', + {'saf_uri': safUri, 'name': name}, + ); + final uri = result?['uri']; + final size = result?['size']; + final modified = result?['modified']; + if (uri is! String || size is! int || modified is! int) return null; + return (uri: uri, size: size, modified: modified); + } + static Future startDownloadService({ String trackName = '', String artistName = '', diff --git a/lib/utils/settings_search_catalog.dart b/lib/utils/settings_search_catalog.dart index 30154f84c..cca7edc5a 100644 --- a/lib/utils/settings_search_catalog.dart +++ b/lib/utils/settings_search_catalog.dart @@ -665,6 +665,12 @@ class SettingsSearchCatalog { title: l10n.downloadSingleFilenameFormat, keywords: const ['single naming', 'file template'], ), + SettingsSearchEntry( + icon: Icons.motion_photos_on_outlined, + title: l10n.downloadSaveMotionArtwork, + subtitle: l10n.downloadSaveMotionArtworkSubtitle, + keywords: const ['cover.mp4', 'motion cover', 'video', 'animation'], + ), SettingsSearchEntry( icon: Icons.library_music_outlined, title: l10n.downloadSeparateSinglesFolder, diff --git a/lib/widgets/mini_player.dart b/lib/widgets/mini_player.dart index 5c53f6c4a..026b6d7bb 100644 --- a/lib/widgets/mini_player.dart +++ b/lib/widgets/mini_player.dart @@ -231,9 +231,10 @@ class _MiniPlayerBodyState extends ConsumerState<_MiniPlayerBody> { !MediaQuery.disableAnimationsOf(context)) { final artwork = ref .watch( - playerMotionArtworkProvider(( + songMotionArtworkProvider(( album: mediaItem.album ?? '', artist: mediaItem.artist ?? '', + source: mediaItem.extras?['source']?.toString() ?? '', )), ) .value; diff --git a/test/motion_artwork_folder_test.dart b/test/motion_artwork_folder_test.dart new file mode 100644 index 000000000..99877af49 --- /dev/null +++ b/test/motion_artwork_folder_test.dart @@ -0,0 +1,442 @@ +import 'dart:convert'; +import 'dart:io'; + +import 'package:flutter/services.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:mornye/models/download_item.dart'; +import 'package:mornye/models/settings.dart'; +import 'package:mornye/models/track.dart'; +import 'package:mornye/providers/download_queue_provider.dart'; +import 'package:mornye/providers/player_motion_artwork_provider.dart'; +import 'package:mornye/providers/settings_provider.dart'; +import 'package:mornye/services/motion_artwork_folder.dart'; +import 'package:mornye/services/motion_artwork_store.dart'; +import 'package:mornye/services/network_storage_service.dart'; +import 'package:path/path.dart' as p; +import 'package:shared_preferences/shared_preferences.dart'; + +const _album = Track( + id: 'album', + name: 'Song', + artistName: 'Artist', + albumName: 'Album', + duration: 180, + albumType: 'album', + totalTracks: 10, +); + +const _single = Track( + id: 'single', + name: 'Song', + artistName: 'Artist', + albumName: 'Song', + duration: 180, + albumType: 'single', + totalTracks: 1, +); + +DownloadItem _item(Track track, {String? playlist}) => DownloadItem( + id: track.id, + track: track, + service: 'example', + playlistName: playlist, + createdAt: DateTime(2026), +); + +void main() { + TestWidgetsFlutterBinding.ensureInitialized(); + + group('album folder rule', () { + final queue = DownloadQueueNotifier(); + + Future holds( + AppSettings settings, { + Track track = _album, + String? playlist, + String? path, + }) { + final planned = queue.relativeOutputDirFor( + track, + settings, + playlistName: playlist, + ); + return queue.holdsAlbumFilesFor( + _item(track, playlist: playlist), + settings, + filePath: path ?? p.join('/music', planned, 'Song.flac'), + ); + } + + test('album folders hold album files', () async { + for (final structure in ['artist_album', 'album_only', 'year_album']) { + expect( + await holds( + AppSettings( + folderOrganization: 'album', + albumFolderStructure: structure, + separateSingles: false, + ), + ), + isTrue, + reason: structure, + ); + } + expect( + await holds( + const AppSettings( + folderOrganization: 'artist_album', + separateSingles: false, + ), + ), + isTrue, + ); + // Albums kept apart from singles still get a folder each. + expect( + await holds( + const AppSettings( + folderOrganization: 'none', + separateSingles: true, + albumFolderStructure: 'artist_album_singles', + ), + ), + isTrue, + ); + }); + + test('shared folders never get an album file', () async { + for (final organization in ['none', 'artist']) { + expect( + await holds( + AppSettings( + folderOrganization: organization, + separateSingles: false, + ), + ), + isFalse, + reason: organization, + ); + } + expect( + await holds( + const AppSettings( + folderOrganization: 'playlist', + separateSingles: false, + ), + playlist: 'Road Trip', + ), + isFalse, + ); + // Every single shares one Singles folder. + expect( + await holds( + const AppSettings( + folderOrganization: 'none', + separateSingles: true, + albumFolderStructure: 'artist_album_singles', + ), + track: _single, + ), + isFalse, + ); + // A release named like the Singles folder is still a single there. + expect( + await holds( + const AppSettings( + folderOrganization: 'none', + separateSingles: true, + albumFolderStructure: 'artist_album_singles', + ), + track: Track( + id: 'named', + name: 'Song', + artistName: 'Artist', + albumName: 'Singles', + duration: 180, + totalTracks: 2, + ), + ), + isFalse, + ); + expect( + await queue.holdsAlbumFilesFor( + _item(_album.copyWith(albumName: ' ')), + const AppSettings( + folderOrganization: 'album', + separateSingles: false, + ), + filePath: '/music/Artist/Song.flac', + ), + isFalse, + ); + }); + + test('the song must be in the planned folder', () async { + const settings = AppSettings( + folderOrganization: 'album', + albumFolderStructure: 'artist_album', + separateSingles: false, + ); + final planned = queue.relativeOutputDirFor(_album, settings); + // An earlier copy kept in an older flat layout. + expect(await holds(settings, path: '/music/Song.flac'), isFalse); + expect( + await queue.holdsAlbumFilesFor( + _item(_album), + settings, + filePath: 'content://tree/document/song', + relativeDir: planned, + ), + isTrue, + ); + expect( + await queue.holdsAlbumFilesFor( + _item(_album), + settings, + filePath: 'content://tree/document/song', + relativeDir: 'Other', + ), + isFalse, + ); + expect( + await queue.holdsAlbumFilesFor( + _item(_album), + settings, + filePath: NetworkStorageService.source( + 'nas', + 'Music/$planned/Song.flac', + ), + ), + isTrue, + ); + }); + + test('custom folders hold an album when its name ends them', () async { + const backend = MethodChannel('com.zarz.mornye/backend'); + final messenger = + TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger; + messenger.setMockMethodCallHandler(backend, (call) async { + if (call.method != 'buildFilename') return null; + final args = call.arguments as Map; + final metadata = jsonDecode(args['metadata'] as String) as Map; + return (args['template'] as String) + .replaceAll('{album}', '${metadata['album']}') + .replaceAll('{artist}', '${metadata['artist']}'); + }); + addTearDown(() => messenger.setMockMethodCallHandler(backend, null)); + + Future custom(String template) async { + final settings = AppSettings( + folderOrganization: 'custom', + folderPathTemplate: template, + separateSingles: false, + ); + final item = _item(_album); + final folder = template + .replaceAll('{album}', 'Album') + .replaceAll('{artist}', 'Artist'); + return queue.holdsAlbumFilesFor( + item, + settings, + filePath: '/music/$folder/Song.flac', + ); + } + + expect(await custom('{artist}/{album}'), isTrue); + expect(await custom('{album}/{artist}'), isFalse); + expect(await custom('{artist}'), isFalse); + }); + }); + + group('MotionArtworkFolder', () { + late Directory root; + late File video; + + setUp(() async { + root = await Directory.systemTemp.createTemp('motion-folder-'); + video = File(p.join(root.path, 'stored.mp4')) + ..writeAsBytesSync([1, 2, 3]); + }); + tearDown(() => root.delete(recursive: true)); + + test('writes cover.mp4 beside a local song once', () async { + final album = Directory(p.join(root.path, 'Artist', 'Album')) + ..createSync(recursive: true); + final folder = MotionArtworkFolder(directory: () async => root); + final saves = await Future.wait([ + folder.save(video, song: p.join(album.path, '01.flac')), + folder.save(video, song: p.join(album.path, '02.flac')), + ]); + expect(saves.where((saved) => saved), hasLength(1)); + final cover = File(p.join(album.path, motionArtworkFileName)); + expect(cover.readAsBytesSync(), [1, 2, 3]); + expect(album.listSync().map((e) => p.basename(e.path)), [ + motionArtworkFileName, + ]); + expect( + await folder.save(video, song: p.join(album.path, '03.flac')), + isFalse, + ); + }); + + test('keeps a cover the user already has', () async { + final album = Directory(p.join(root.path, 'Album'))..createSync(); + final cover = File(p.join(album.path, motionArtworkFileName)) + ..writeAsBytesSync([9]); + final folder = MotionArtworkFolder(directory: () async => root); + expect( + await folder.save(video, song: p.join(album.path, '01.flac')), + isFalse, + ); + expect(cover.readAsBytesSync(), [9]); + }); + + test('documents and network songs go through their storage', () async { + final created = []; + final uploads = []; + final folder = MotionArtworkFolder( + directory: () async => root, + createDocument: (treeUri, relativeDir, name, path) async { + created.add('$treeUri|$relativeDir|$name|${p.basename(path)}'); + return true; + }, + upload: (target, file) async { + uploads.add(target); + return true; + }, + ); + expect( + await folder.save(video, song: 'content://tree/document/song'), + isFalse, + ); + expect( + await folder.save( + video, + song: 'content://tree/document/song', + treeUri: 'content://tree', + relativeDir: 'Artist/Album', + ), + isTrue, + ); + expect(created, ['content://tree|Artist/Album|cover.mp4|stored.mp4']); + final song = NetworkStorageService.source('nas', 'Music/Album/01.flac'); + expect(await folder.save(video, song: song), isTrue); + expect(uploads, [ + NetworkStorageService.source('nas', 'Music/Album/cover.mp4'), + ]); + }); + + test('finds cover.mp4 beside a local song', () async { + final album = Directory(p.join(root.path, 'Album'))..createSync(); + final song = p.join(album.path, '01.flac'); + final folder = MotionArtworkFolder(directory: () async => root); + expect(await folder.find(song), isNull); + final cover = File(p.join(album.path, motionArtworkFileName)) + ..writeAsBytesSync([4, 5]); + expect((await folder.find(song))?.source, cover.uri.toString()); + expect( + (await folder.find(Uri.file(song).toString()))?.source, + cover.uri.toString(), + ); + expect( + await folder.find(NetworkStorageService.source('nas', 'a/b.flac')), + isNull, + ); + }); + + test('copies a document cover in once per version', () async { + var modified = 1; + var copies = 0; + final folder = MotionArtworkFolder( + directory: () async => root, + documents: true, + sibling: (song, name) async { + expect(name, motionArtworkFileName); + return ( + uri: 'content://tree/document/cover', + size: 2, + modified: modified, + ); + }, + copyDocument: (uri) async { + copies++; + final temp = File(p.join(root.path, 'temp-$copies.mp4')); + await temp.writeAsBytes([7, copies]); + return temp.path; + }, + ); + final first = await Future.wait([ + folder.find('content://tree/document/song-1'), + folder.find('content://tree/document/song-2'), + ]); + expect(copies, 1); + expect(first[0]?.source, first[1]?.source); + final copy = File.fromUri(Uri.parse(first[0]!.source)); + expect(p.isWithin(root.path, copy.path), isTrue); + expect(copy.readAsBytesSync(), [7, 1]); + + // Another song of the album reuses the copy. + await folder.find('content://tree/document/song-3'); + expect(copies, 1); + + // A replaced cover is copied again once lookups expire. + modified = 2; + folder.forget(); + await folder.find('content://tree/document/song-1'); + expect(copies, 2); + expect(copy.readAsBytesSync(), [7, 2]); + }); + + test('documents are not read off Android', () async { + var asked = false; + final folder = MotionArtworkFolder( + directory: () async => root, + documents: false, + sibling: (_, _) async { + asked = true; + return null; + }, + ); + expect(await folder.find('content://tree/document/song'), isNull); + expect(asked, isFalse); + }); + }); + + group('songMotionArtworkProvider', () { + setUp(() => SharedPreferences.setMockInitialValues({})); + + test('prefers the folder cover over the saved one', () async { + final root = await Directory.systemTemp.createTemp('motion-song-'); + addTearDown(() => root.delete(recursive: true)); + final album = Directory(p.join(root.path, 'Album'))..createSync(); + final song = p.join(album.path, '01.flac'); + const saved = MotionArtwork('file:///saved.mp4', aspectRatio: 1); + final container = ProviderContainer( + overrides: [ + motionArtworkFolderProvider.overrideWithValue( + MotionArtworkFolder(directory: () async => root), + ), + playerMotionArtworkProvider.overrideWith((ref, album) async => saved), + ], + ); + addTearDown(container.dispose); + Future read(String source) => container.read( + songMotionArtworkProvider(( + album: 'Album', + artist: 'Artist', + source: source, + )).future, + ); + + expect((await read(song))?.source, saved.source); + final cover = File(p.join(album.path, motionArtworkFileName)) + ..writeAsBytesSync([1]); + container.invalidate(songMotionArtworkProvider); + expect((await read(song))?.source, cover.uri.toString()); + expect((await read(''))?.source, saved.source); + + container.read(settingsProvider.notifier).setMotionArtworkEnabled(false); + expect(await read(song), isNull); + }); + }); +}