kitty/spotube
1
0
Fork 0
mirror of https://github.com/KRTirtho/spotube.git synced 2025-09-13 07:55:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

feat: add ISRC track search for YouTube (#2594)

Browse Source 
* Add ISRC track search for YouTube

* Do not probe Song.Link when ISRC results are valid, fix rate limit
This commit is contained in:
Seungmin Kim 2025-03-28 22:10:54 +09:00 committed by GitHub
parent 0ec9f3535b
commit 2c4cc94985
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 110 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lib/collections/fake.dart
View File

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

57
lib/extensions/track.dart
View File

@ -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;
}
}
}

2
lib/modules/album/album_card.dart
View File

@ -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();

2
lib/provider/spotify/album/tracks.dart
View File

@ -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,

96
lib/services/sourced_track/sources/youtube.dart
View File

@ -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