diff --git a/lib/screens/track_metadata_edit_autofill.dart b/lib/screens/track_metadata_edit_autofill.dart index 02fcc70ae..13c4e2188 100644 --- a/lib/screens/track_metadata_edit_autofill.dart +++ b/lib/screens/track_metadata_edit_autofill.dart @@ -223,6 +223,15 @@ extension _EditMetadataSheetAutoFill on _EditMetadataSheetState { final usesAutomaticProvider = selectedProviderId == null || selectedProviderId.isEmpty; final needsTrackLookup = fields.any((key) => key != 'lyrics'); + final lyricsExtensionId = + configuredProviderId == null || + !MetadataAutofillService.lyricsOnly(fields) + ? null + : _autofill + .lyricsProviders(extensionState) + .where((extension) => extension.id == configuredProviderId) + .firstOrNull + ?.id; Map? best; final queryParts = []; @@ -313,6 +322,7 @@ extension _EditMetadataSheetAutoFill on _EditMetadataSheetState { durationMs: widget.durationMs, syncLyricsSettings: settingsNotifier.syncLyricsSettingsToBackend, isCurrent: isCurrent, + lyricsExtensionId: lyricsExtensionId, ); if (!mounted || !isCurrent() || result == null) return; final availableValues = result.values; @@ -462,7 +472,10 @@ extension _EditMetadataSheetAutoFill on _EditMetadataSheetState { Consumer( builder: (context, ref, _) { final extensionState = ref.watch(extensionProvider); - final providers = _autofill.orderedProviders(extensionState); + final providers = + MetadataAutofillService.lyricsOnly(_form.autoFillFields) + ? _autofill.lyricsProviders(extensionState) + : _autofill.orderedProviders(extensionState); final selectedProviderIsAvailable = providers.any( (extension) => extension.id == _selectedMetadataProviderId, ); diff --git a/lib/services/metadata_autofill_service.dart b/lib/services/metadata_autofill_service.dart index 40ac76dd5..fba2070b5 100644 --- a/lib/services/metadata_autofill_service.dart +++ b/lib/services/metadata_autofill_service.dart @@ -122,6 +122,7 @@ class MetadataAutofillService { required int durationMs, required Future Function() syncLyricsSettings, required bool Function() isCurrent, + String? lyricsExtensionId, }) async { if (!isCurrent()) return null; final title = currentValues['title']?.trim() ?? ''; @@ -236,12 +237,22 @@ class MetadataAutofillService { if (lyricsTitle.isNotEmpty && lyricsArtist.isNotEmpty) { try { - final lyricsResult = await PlatformBridge.getLyricsLRCWithSource( - rawSpotifyId ?? '', - lyricsTitle, - lyricsArtist, - durationMs: durationMs, - ); + // A chosen lyrics extension answers alone; otherwise every enabled + // provider is asked in the order of the lyrics settings. + final lyricsResult = lyricsExtensionId == null + ? await PlatformBridge.getLyricsLRCWithSource( + rawSpotifyId ?? '', + lyricsTitle, + lyricsArtist, + durationMs: durationMs, + ) + : await PlatformBridge.getLyricsFromProvider( + 'extension:${lyricsExtensionId.toLowerCase()}', + trackName: lyricsTitle, + artistName: lyricsArtist, + spotifyId: rawSpotifyId ?? '', + durationMs: durationMs, + ); final lyricsText = lyricsResult['lyrics']?.toString().trim() ?? ''; final lyricsSource = lyricsResult['source']?.toString().trim() ?? ''; if (lyricsSource.isNotEmpty) lyricsSourceName = lyricsSource; @@ -279,11 +290,29 @@ class MetadataAutofillService { : null, sourceId: providerId?.isNotEmpty == true ? providerId! - : selectedBest?['provider_id']?.toString().trim() ?? '', + : selectedBest?['provider_id']?.toString().trim() ?? + lyricsExtensionId ?? + '', lyricsSource: selectedBest == null ? lyricsSourceName : null, ); } + /// Whether lyrics are the only thing [fields] asks for. The source choice + /// then lists [lyricsProviders], since a metadata source has no say in + /// where lyrics come from. + static bool lyricsOnly(Set fields) => + fields.length == 1 && fields.contains('lyrics'); + + /// The enabled extensions that provide lyrics, by name. + List lyricsProviders(ExtensionState state) => + [ + for (final extension in state.extensions) + if (extension.enabled && extension.hasLyricsProvider) extension, + ]..sort( + (a, b) => + a.displayName.toLowerCase().compareTo(b.displayName.toLowerCase()), + ); + List orderedProviders(ExtensionState state) { final providersById = { for (final extension in state.extensions) diff --git a/test/metadata_autofill_service_test.dart b/test/metadata_autofill_service_test.dart index c933aef41..809655d09 100644 --- a/test/metadata_autofill_service_test.dart +++ b/test/metadata_autofill_service_test.dart @@ -212,4 +212,60 @@ void main() { expect(result.values.containsKey('lyrics'), !instrumental); }); } + + test('a chosen lyrics extension is the only provider asked', () async { + const channel = MethodChannel('com.zarz.mornye/backend'); + final messenger = + TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger; + messenger.setMockMethodCallHandler(channel, (call) async { + expect(call.method, 'getLyricsFromProvider'); + expect((call.arguments as Map)['provider'], 'extension:example.lyrics'); + return jsonEncode({'lyrics': '[00:01.00]Lyric'}); + }); + addTearDown(() => messenger.setMockMethodCallHandler(channel, null)); + final result = await service.enrich( + null, + currentValues: const {'title': 'Song', 'artist': 'Artist'}, + fields: {'lyrics'}, + providerId: null, + sourceTrackId: null, + durationMs: 180000, + syncLyricsSettings: () async {}, + isCurrent: () => true, + lyricsExtensionId: 'Example.Lyrics', + ); + expect(result!.values['lyrics'], '[00:01.00]Lyric'); + expect(result.sourceId, 'Example.Lyrics'); + }); + + test('the source choice for lyrics alone lists lyrics extensions only', () { + Extension extension(String id, {bool lyrics = false, bool on = true}) => + Extension( + id: id, + name: id, + displayName: id, + version: '1.0.0', + description: '', + enabled: on, + status: 'loaded', + hasMetadataProvider: !lyrics, + hasLyricsProvider: lyrics, + ); + final state = ExtensionState( + extensions: [ + extension('metadata'), + extension('words-b', lyrics: true), + extension('words-a', lyrics: true), + extension('words-off', lyrics: true, on: false), + ], + ); + expect(MetadataAutofillService.lyricsOnly({'lyrics'}), isTrue); + expect(MetadataAutofillService.lyricsOnly({'lyrics', 'cover'}), isFalse); + expect(MetadataAutofillService.lyricsOnly({'cover'}), isFalse); + expect(service.lyricsProviders(state).map((e) => e.id), [ + 'words-a', + 'words-b', + ]); + expect(service.orderedProviders(state).map((e) => e.id), ['metadata']); + }); }