Merge 50d729f8a0 into 0ec9f3535b

lib/collections/fake.dart

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

lib/extensions/track.dart

@@ -4,9 +4,7 @@ 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(
@@ -70,16 +68,7 @@ extension TrackExtensions on Track {
 }
 
 extension TrackSimpleExtensions on TrackSimple {
-  Future<Track> asTrack(AlbumSimple album, ref) async {
+  Track asTrack(AlbumSimple album) {
-    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;
@@ -100,9 +89,6 @@ extension TrackSimpleExtensions on TrackSimple {
     track.uri = uri;
     return track;
   }
-      rethrow;
-    }
-  }
 }
 
 extension TracksToMediaExtension on Iterable<Track> {

lib/modules/album/album_card.dart

@@ -54,8 +54,7 @@ class AlbumCard extends HookConsumerWidget {
 
     Future<List<Track>> fetchAllTrack() async {
       if (album.tracks != null && album.tracks!.isNotEmpty) {
-        return Future.wait(
+        return album.tracks!.map((track) => track.asTrack(album)).toList();
-            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 List<Track> items = await Future.wait(tracks.items?.map((e) => e.asTrack(arg, ref)).toList() ?? []);
+    final items = tracks.items?.map((e) => e.asTrack(arg)).toList() ?? [];
 
     return (
       items: items,

lib/services/sourced_track/sources/youtube.dart

@@ -236,28 +236,28 @@ class YoutubeSourcedTrack extends SourcedTrack {
         .toList();
   }
 
-  static Future<List<YoutubeVideoInfo>> fetchFromIsrc({
+  static Future<List<SiblingType>> fetchSiblings({
     required Track track,
-    required Provider provider,
     required Ref ref,
   }) async {
-    final matchingResults = <YoutubeVideoInfo>[];
+    List<SiblingType> siblings = [];
+
     final isrc = track.externalIds?.isrc;
     if (isrc != null && isrc.isNotEmpty) {
-      final isrcResults = await ref
+      final isrcResults =
-          .read(provider)
+          await ref.read(youtubeEngineProvider).searchVideos(isrc.toString());
-          .searchVideos(isrc.toString());
       if (isrcResults.isNotEmpty) {
-        for (final videoInfo in isrcResults.map(YoutubeVideoInfo.fromVideo).toList()) {
+        final rankedResults = rankResults(
-          final titleWords =
+            isrcResults.map(YoutubeVideoInfo.fromVideo).toList(), track);
-              videoInfo.title
+        final matchingResults = <YoutubeVideoInfo>[];
+        for (final video in rankedResults) {
+          final titleWords = video.title
               .toLowerCase()
               .replaceAll(RegExp(r'[^a-zA-Z0-9\s]+'), '')
               .split(RegExp(r'\s+'))
               .where((item) => item.isNotEmpty)
               .toList();
-          final nameLower =
+          final nameLower = track.name!
-              track.name!
               .toLowerCase()
               .replaceAll(RegExp(r'[^a-zA-Z0-9\s]+'), '')
               .split(RegExp(r'\s+'))
@@ -266,34 +266,39 @@ class YoutubeSourcedTrack extends SourcedTrack {
           final matchCount =
               titleWords.where((word) => nameLower.contains(word)).length;
           if (matchCount > nameLower.length / 2) {
-            matchingResults.add(videoInfo);
+            matchingResults.add(video);
+          }
+        }
+        if (matchingResults.isNotEmpty) {
+          final matchingSiblings =
+              await Future.wait(matchingResults.map((matchingResult) async {
+            try {
+              return await toSiblingType(0, matchingResult, ref);
+            } on VideoUnplayableException catch (e, stack) {
+              // Ignore this error and continue with the search
+              AppLogger.reportError(e, stack);
+              return null;
+            }
+          }));
+          siblings.addAll(matchingSiblings.whereType<SiblingType>());
         }
       }
     }
-    }
-    return matchingResults;
-  }
-
-  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) {
       try {
-        videoResults.add(
+        siblings.add(await toSiblingType(
+          0,
           YoutubeVideoInfo.fromVideo(
-            await ref
+            await ref.read(youtubeEngineProvider).getVideo(
-                .read(youtubeEngineProvider)
+                  Uri.parse(ytLink!.url!).queryParameters["v"]!,
-                .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);
@@ -302,33 +307,33 @@ class YoutubeSourcedTrack extends SourcedTrack {
 
     final query = SourcedTrack.getSearchTerm(track);
 
-    final searchResults = await ref
+    final searchResults =
-        .read(youtubeEngineProvider)
+        await ref.read(youtubeEngineProvider).searchVideos(query);
-        .searchVideos(query);
 
     if (ServiceUtils.onlyContainsEnglish(query)) {
-      videoResults.addAll(
+      siblings.addAll(await Future.wait(searchResults
-          searchResults.map(YoutubeVideoInfo.fromVideo).toList(),
+          .map(YoutubeVideoInfo.fromVideo)
-      );
+          .mapIndexed((index, info) => toSiblingType(index, info, ref))));
     } else {
-      videoResults.addAll(rankResults(
+      final rankedSiblings = rankResults(
         searchResults.map(YoutubeVideoInfo.fromVideo).toList(),
         track,
+      );
+      siblings.addAll(await Future.wait(
+        rankedSiblings
+            .mapIndexed((index, info) => toSiblingType(index, info, ref)),
       ));
     }
 
     final seenIds = <String>{};
-    int index = 0;
+    // Deduplicate siblings by info.id, keeping the first occurrence
-    return await Future.wait(
+    return await Future.wait(siblings.map((sibling) async {
-      videoResults.map((videoResult) async {
+      if (!seenIds.contains(sibling.info.id)) {
-        // Deduplicate results
+        seenIds.add(sibling.info.id);
-        if (!seenIds.contains(videoResult.id)) {
+        return sibling;
-          seenIds.add(videoResult.id);
-          return await toSiblingType(index++, videoResult, ref);
       }
       return null;
-      }),
+    })).then((s) => s.whereType<SiblingType>().toList());
-    ).then((s) => s.whereType<SiblingType>().toList());
   }
 
   @override