Merge 77ef0b5f05 into 0ec9f3535b

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(
@@ -68,7 +70,16 @@ extension TrackExtensions on Track {
 }
 
 extension TrackSimpleExtensions on TrackSimple {
-  Track asTrack(AlbumSimple album) {
+  Future<Track> asTrack(AlbumSimple album, ref) async {
+    try {
+      final spotify = ref.read(spotifyProvider);
+      return await spotify.invoke((api) => api.tracks.get(id!));
+    } catch (e, stack) {
+      if ((e is AuthorizationException && e.error != 'invalid_token') ||
+          e is SpotifyException) {
+        // Ignore this error and create the Track locally
+        AppLogger.reportError(e, stack);
+
         Track track = Track();
         track.name = name;
         track.album = album;	
@@ -89,6 +100,9 @@ extension TrackSimpleExtensions on TrackSimple {
         track.uri = uri;	
         return track;
       }
+      rethrow;
+    }
+  }
 }
 
 extension TracksToMediaExtension on Iterable<Track> {

lib/modules/album/album_card.dart

@@ -54,7 +54,8 @@ 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 Future.wait(
+            album.tracks!.map((track) => track.asTrack(album, ref)).toList());
       }
       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 List<Track> items = await Future.wait(tracks.items?.map((e) => e.asTrack(arg, ref)).toList() ?? []);
 
     return (
       items: items,

lib/services/sourced_track/sources/youtube.dart

@@ -236,29 +236,42 @@ 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());
+      isrcResults.addAll(await searchedVideos
+          .map<YoutubeVideoInfo>(YoutubeVideoInfo.fromVideo)
+          .toList());
+    }
+    return isrcResults;
+  }
+
   static Future<List<SiblingType>> fetchSiblings({
     required Track track,
     required Ref ref,
   }) async {
+    final videoResults = <YoutubeVideoInfo>[];
+
+    videoResults.addAll(await fetchFromIsrc(
+        track: track, provider: youtubeEngineProvider, ref: ref));
+
     final links = await SongLinkService.links(track.id!);
     final ytLink = links.firstWhereOrNull((link) => link.platform == "youtube");
 
-    if (ytLink?.url != null
+    if (ytLink?.url != null) {
-        // allows to fetch siblings more results for already sourced track
-        &&
-        track is! SourcedTrack) {
       try {
-        return [
+        videoResults.add(YoutubeVideoInfo.fromVideo(
-          await toSiblingType(
+          await ref
-            0,
+              .read(youtubeEngineProvider)
-            YoutubeVideoInfo.fromVideo(
+              .getVideo(Uri.parse(ytLink!.url!).queryParameters["v"]!),
-              await ref.read(youtubeEngineProvider).getVideo(
+        ));
-                    Uri.parse(ytLink!.url!).queryParameters["v"]!,
-                  ),
-            ),
-            ref,
-          )
-        ];
       } on VideoUnplayableException catch (e, stack) {
         // Ignore this error and continue with the search
         AppLogger.reportError(e, stack);
@@ -271,20 +284,28 @@ class YoutubeSourcedTrack extends SourcedTrack {
         await ref.read(youtubeEngineProvider).searchVideos(query);
 
     if (ServiceUtils.onlyContainsEnglish(query)) {
-      return await Future.wait(searchResults
+      videoResults.addAll(
-          .map(YoutubeVideoInfo.fromVideo)
+        searchResults.map(YoutubeVideoInfo.fromVideo).toList(),
-          .mapIndexed((index, info) => toSiblingType(index, info, ref)));
+      );
-    }
+    } else {
-
+      videoResults.addAll(rankResults(
-    final rankedSiblings = rankResults(
         searchResults.map(YoutubeVideoInfo.fromVideo).toList(),
         track,
-    );
+      ));
+    }
 
+    final seenIds = <String>{};
+    int index = 0;
     return await Future.wait(
-      rankedSiblings
+      videoResults.map((videoResult) async {
-          .mapIndexed((index, info) => toSiblingType(index, info, ref)),
+        // 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