Merge ff252d6b14 into 2c4cc94985

* Add ISRC track search for YouTube

* Do not probe Song.Link when ISRC results are valid, fix rate limit

lib/collections/fake.dart

@@ -94,6 +94,7 @@ abstract class FakeData {
     ..trackNumber = 1
     ..type = "type"
     ..uri = "uri"
+    ..externalIds = externalIds
     ..isPlayable = true
     ..explicit = false
     ..linkedFrom = trackLink;

lib/extensions/track.dart

@@ -4,7 +4,9 @@ import 'dart:typed_data';
 import 'package:metadata_god/metadata_god.dart';
 import 'package:path/path.dart';
 import 'package:spotify/spotify.dart';
+import 'package:spotube/provider/spotify/spotify.dart';
 import 'package:spotube/services/audio_player/audio_player.dart';
+import 'package:spotube/services/logger/logger.dart';
 
 extension TrackExtensions on Track {
   Track fromFile(
@@ -67,27 +69,40 @@ extension TrackExtensions on Track {
   }
 }
 
-extension TrackSimpleExtensions on TrackSimple {
-  Track asTrack(AlbumSimple album) {
-    Track track = Track();
-    track.name = name;
-    track.album = album;
-    track.artists = artists;
-    track.availableMarkets = availableMarkets;
-    track.discNumber = discNumber;
-    track.durationMs = durationMs;
-    track.explicit = explicit;
-    track.externalUrls = externalUrls;
-    track.href = href;
-    track.id = id;
-    track.isPlayable = isPlayable;
-    track.linkedFrom = linkedFrom;
-    track.name = name;
-    track.previewUrl = previewUrl;
-    track.trackNumber = trackNumber;
-    track.type = type;
-    track.uri = uri;
-    return track;
+extension IterableTrackSimpleExtensions on Iterable<TrackSimple> {
+  Future<List<Track>> asTracks(AlbumSimple album, ref) async {
+    try {
+      final spotify = ref.read(spotifyProvider);
+      final tracks = await spotify.invoke(
+        (api) => api.tracks.list(map((trackSimple) => trackSimple.id!).toList()));
+      return tracks.toList();
+    } catch (e, stack) {
+      // Ignore errors and create the track locally
+      AppLogger.reportError(e, stack);
+
+      List<Track> tracks = [];
+      for (final trackSimple in this) {
+        Track track = Track();
+        track.album = album;
+        track.name = trackSimple.name;
+        track.artists = trackSimple.artists;
+        track.availableMarkets = trackSimple.availableMarkets;
+        track.discNumber = trackSimple.discNumber;
+        track.durationMs = trackSimple.durationMs;
+        track.explicit = trackSimple.explicit;
+        track.externalUrls = trackSimple.externalUrls;
+        track.href = trackSimple.href;
+        track.id = trackSimple.id;
+        track.isPlayable = trackSimple.isPlayable;
+        track.linkedFrom = trackSimple.linkedFrom;
+        track.previewUrl = trackSimple.previewUrl;
+        track.trackNumber = trackSimple.trackNumber;
+        track.type = trackSimple.type;
+        track.uri = trackSimple.uri;
+        tracks.add(track);
+      }
+      return tracks;
+    }
   }
 }
 

lib/l10n/app_it.arb

@@ -137,16 +137,16 @@
   "pre_download_play_description": "Anzi che effettuare lo stream dell'audio, scarica invece i byte e li riproduce (raccomandato per gli utenti con banda più alta)",
   "skip_non_music": "Salta i segmenti non di musica (SponsorBlock)",
   "blacklist_description": "Tracce e artisti in blacklist",
-  "wait_for_download_to_finish": "Prego attendere che lo scaricamento corrente finisca",
+  "wait_for_download_to_finish": "Prego attendere che il download corrente finisca",
   "desktop": "Desktop",
   "close_behavior": "Comportamento Chiusura",
   "close": "Chiudi",
   "minimize_to_tray": "Minimizza in tray",
   "show_tray_icon": "Mostra icona in tray di sistema",
-  "about": "A proposito di",
+  "about": "Informazioni su",
   "u_love_spotube": "Sappiamo che ami Spotube",
   "check_for_updates": "Controlla aggiornamenti",
-  "about_spotube": "A proposito di Spotube",
+  "about_spotube": "Informazioni su Spotube",
   "blacklist": "Blacklist",
   "please_sponsor": "Per favore sponsorizza/dona",
   "spotube_description": "Spotube, un client spotify gratis per tutti, multipiattaforma e leggero",
@@ -187,7 +187,7 @@
   "generate_playlist": "Genera Playlist",
   "track_exists": "La traccia {track} esiste già",
   "replace_downloaded_tracks": "Sostituisci tutte le tracce scaricate",
-  "skip_download_tracks": "Salta lo scaricamento di tutte le tracce scaricate",
+  "skip_download_tracks": "Salta il download di tutte le tracce scaricate",
   "do_you_want_to_replace": "Vuoi sovrascrivere la traccia esistente??",
   "replace": "Sovrascrivi",
   "skip": "Salta",
@@ -256,7 +256,7 @@
   "querying_info": "Richiesta informazioni...",
   "piped_api_down": "Le Piped API non funzionano",
   "piped_down_error_instructions": "L'istanza di Piped {pipedInstance} è correntemente offline\n\nCambia istanza o cambia 'Tipo API' alle API ufficiali YouTube\n\nAssicurati di riavviare l'app dopo il cambio",
-  "you_are_offline": "Sei correntemente offline",
+  "you_are_offline": "Al momento sei offline",
   "connection_restored": "Connessione ad internet ripristinata",
   "use_system_title_bar": "Usa la barra del titolo di sistema",
   "crunching_results": "Elaborazione risultati...",
@@ -267,15 +267,15 @@
   "change_cover": "Cambia copertina",
   "add_cover": "Aggiungi copertina",
   "restore_defaults": "Ripristina default",
-  "download_music_codec": "Codec musicale scaricamento",
-  "streaming_music_codec": "Codec musicale streaming",
-  "login_with_lastfm": "Accesso a Last.fm",
-  "connect": "Connetti",
-  "disconnect_lastfm": "Disconnetti Last.fm",
+  "download_music_codec": "Codec download musica",
+  "streaming_music_codec": "Codec streaming musica",
+  "login_with_lastfm": "Accedi con Last.fm",
+  "connect": "Connettiti",
+  "disconnect_lastfm": "Disconnettiti da Last.fm",
   "disconnect": "Disconnetti",
   "username": "Nome utente",
   "password": "Password",
-  "login": "Accesso",
+  "login": "Accedi",
   "login_with_your_lastfm": "Accedi con il tuo account Last.fm",
   "scrobble_to_lastfm": "Invia a Last.fm",
   "audio_source": "Fonte audio",
@@ -299,7 +299,7 @@
   "song_link": "Link della Canzone",
   "skip_this_nonsense": "Salta questa sciocchezza",
   "freedom_of_music": "“Libertà della Musica”",
-  "freedom_of_music_palm": "“Libertà della Musica nel palmo della tua mano”",
+  "freedom_of_music_palm": "“Libertà della Musica nelle tue mani”",
   "get_started": "Cominciamo",
   "youtube_source_description": "Consigliato e funziona meglio.",
   "piped_source_description": "Ti senti libero? Come YouTube ma molto più gratuito.",

lib/modules/album/album_card.dart

@@ -54,7 +54,7 @@ class AlbumCard extends HookConsumerWidget {
 
     Future<List<Track>> fetchAllTrack() async {
       if (album.tracks != null && album.tracks!.isNotEmpty) {
-        return album.tracks!.map((track) => track.asTrack(album)).toList();
+        return album.tracks!.asTracks(album, ref);
       }
       await ref.read(albumTracksProvider(album).future);
       return ref.read(albumTracksProvider(album).notifier).fetchAll();

lib/provider/spotify/album/tracks.dart

@@ -33,7 +33,7 @@ class AlbumTracksNotifier extends AutoDisposeFamilyPaginatedAsyncNotifier<Track,
     final tracks = await spotify.invoke(
       (api) => api.albums.tracks(arg.id!).getPage(limit, offset),
     );
-    final items = tracks.items?.map((e) => e.asTrack(arg)).toList() ?? [];
+    final items = await tracks.items!.asTracks(arg, ref);
 
     return (
       items: items,

lib/services/sourced_track/sources/youtube.dart

@@ -236,29 +236,67 @@ class YoutubeSourcedTrack extends SourcedTrack {
         .toList();
   }
 
+  static Future<List<YoutubeVideoInfo>> fetchFromIsrc({
+    required Track track,
+    required Provider provider,
+    required Ref ref,
+  }) async {
+    final isrcResults = <YoutubeVideoInfo>[];
+    final isrc = track.externalIds?.isrc;
+    if (isrc != null && isrc.isNotEmpty) {
+      final searchedVideos = await ref
+          .read(provider)
+          .searchVideos(isrc.toString());
+      if (searchedVideos.isNotEmpty) {
+        isrcResults.addAll(searchedVideos
+            .map<YoutubeVideoInfo>(YoutubeVideoInfo.fromVideo)
+            .map((YoutubeVideoInfo videoInfo) {
+              final ytWords =
+                  videoInfo.title
+                      .toLowerCase()
+                      .replaceAll(RegExp(r'[^a-zA-Z0-9\s]+'), '')
+                      .split(RegExp(r'\s+'))
+                      .where((item) => item.isNotEmpty);
+              final spWords =
+                  track.name!
+                      .toLowerCase()
+                      .replaceAll(RegExp(r'\((.*)\)'), '')
+                      .replaceAll(RegExp(r'[^a-zA-Z0-9\s]+'), '')
+                      .split(RegExp(r'\s+'))
+                      .where((item) => item.isNotEmpty);
+              // Word match to filter out unrelated results
+              final matchCount =
+                  ytWords.where((word) => spWords.contains(word)).length;
+              if (matchCount > spWords.length ~/ 2) {
+                return videoInfo;
+              }
+              return null;
+            }
+        ).whereType<YoutubeVideoInfo>().toList());
+      }
+    }
+    return isrcResults;
+  }
+
   static Future<List<SiblingType>> fetchSiblings({
     required Track track,
     required Ref ref,
   }) async {
+    final videoResults = <YoutubeVideoInfo>[];
+
+    final isrcResults = await fetchFromIsrc(track: track, provider: youtubeEngineProvider, ref: ref);
+    videoResults.addAll(isrcResults);
+
     final links = await SongLinkService.links(track.id!);
     final ytLink = links.firstWhereOrNull((link) => link.platform == "youtube");
 
-    if (ytLink?.url != null
-        // allows to fetch siblings more results for already sourced track
-        &&
-        track is! SourcedTrack) {
+    if (isrcResults.isEmpty && ytLink?.url != null) {
       try {
-        return [
-          await toSiblingType(
-            0,
+        videoResults.add(
             YoutubeVideoInfo.fromVideo(
-              await ref.read(youtubeEngineProvider).getVideo(
-                    Uri.parse(ytLink!.url!).queryParameters["v"]!,
-                  ),
-            ),
-            ref,
-          )
-        ];
+                await ref.read(youtubeEngineProvider)
+                    .getVideo(Uri.parse(ytLink!.url!).queryParameters["v"]!)
+        ));
       } on VideoUnplayableException catch (e, stack) {
         // Ignore this error and continue with the search
         AppLogger.reportError(e, stack);
@@ -271,20 +309,28 @@ class YoutubeSourcedTrack extends SourcedTrack {
         await ref.read(youtubeEngineProvider).searchVideos(query);
 
     if (ServiceUtils.onlyContainsEnglish(query)) {
-      return await Future.wait(searchResults
-          .map(YoutubeVideoInfo.fromVideo)
-          .mapIndexed((index, info) => toSiblingType(index, info, ref)));
+      videoResults.addAll(
+          searchResults.map(YoutubeVideoInfo.fromVideo).toList()
+      );
+    } else {
+      videoResults.addAll(rankResults(
+          searchResults.map(YoutubeVideoInfo.fromVideo).toList(),
+          track,
+      ));
     }
 
-    final rankedSiblings = rankResults(
-      searchResults.map(YoutubeVideoInfo.fromVideo).toList(),
-      track,
-    );
-
+    final seenIds = <String>{};
+    int index = 0;
     return await Future.wait(
-      rankedSiblings
-          .mapIndexed((index, info) => toSiblingType(index, info, ref)),
-    );
+      videoResults.map((videoResult) async {
+        // Deduplicate results
+        if (!seenIds.contains(videoResult.id)) {
+          seenIds.add(videoResult.id);
+          return await toSiblingType(index++, videoResult, ref);
+        }
+        return null;
+      }),
+    ).then((s) => s.whereType<SiblingType>().toList());
   }
 
   @override