Goatworks/GroovyBox
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

✨ Improvement on remote track metadata

Browse Source
This commit is contained in:
LittleSheep
2025-12-19 23:51:02 +08:00
parent 2f1130b424
commit cb4cca2917
7 changed files with 300 additions and 190 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
lib/logic/audio_handler.dart
View File

@@ -3,7 +3,8 @@ import 'package:hooks_riverpod/hooks_riverpod.dart';
import 'package:media_kit/media_kit.dart' as media_kit;
import 'package:groovybox/data/db.dart';
import 'package:groovybox/providers/theme_provider.dart';
import 'package:groovybox/logic/metadata_service.dart';
import 'package:groovybox/providers/remote_provider.dart';
import 'package:groovybox/providers/db_provider.dart';
class AudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
final media_kit.Player _player;
@@ -51,12 +52,26 @@ class AudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
if (_container == null) return;
try {
// Get metadata for the current track to access artBytes
final metadataService = _container!.read(metadataServiceProvider);
final metadata = await metadataService.getMetadata(mediaItem.id);
// For remote tracks, get metadata from database
final urlResolver = _container!.read(remoteUrlResolverProvider);
if (urlResolver.isProtocolUrl(mediaItem.id)) {
final database = _container!.read(databaseProvider);
final track = await (database.select(
database.tracks,
)..where((t) => t.path.equals(mediaItem.id))).getSingleOrNull();
if (track != null && track.artUri != null) {
// Fetch album art bytes for remote tracks
// TODO: Implement remote album art fetching for theme
}
} else {
// For local tracks, use existing metadata service
// TODO: Get metadata service working
}
// Reset to default for now
final seedColorNotifier = _container!.read(seedColorProvider.notifier);
seedColorNotifier.updateFromAlbumArtBytes(metadata.artBytes);
seedColorNotifier.resetToDefault();
} catch (e) {
// If metadata retrieval fails, reset to default color
final seedColorNotifier = _container!.read(seedColorProvider.notifier);
@@ -134,10 +149,38 @@ class AudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
}
Future<void> _updatePlaylist() async {
if (_container == null) {
// Fallback if container not set
final medias = _queue.map((item) => media_kit.Media(item.id)).toList();
if (medias.isNotEmpty) {
await _player.open(media_kit.Playlist(medias, index: _queueIndex));
}
return;
}
final urlResolver = _container!.read(remoteUrlResolverProvider);
final medias = <media_kit.Media>[];
for (final item in _queue) {
String uri = item.id;
// Check if this is a protocol URL that needs resolution
if (urlResolver.isProtocolUrl(item.id)) {
final resolvedUrl = await urlResolver.resolveUrl(item.id);
if (resolvedUrl != null) {
uri = resolvedUrl;
} else {
// If resolution fails, skip this track or use original URL
continue;
}
}
medias.add(media_kit.Media(uri));
}
if (medias.isNotEmpty) {
await _player.open(media_kit.Playlist(medias, index: _queueIndex));
}
}
void _broadcastPlaybackState() {

47
lib/logic/metadata_service.dart
View File

@@ -1,9 +1,10 @@
import 'dart:io';
import 'dart:typed_data';
import 'package:flutter/foundation.dart';
import 'package:flutter_media_metadata/flutter_media_metadata.dart';
import 'package:http/http.dart' as http;
import 'package:riverpod_annotation/riverpod_annotation.dart';
part 'metadata_service.g.dart';
import 'package:groovybox/providers/remote_provider.dart';
import 'package:groovybox/providers/db_provider.dart';
class TrackMetadata {
final String? title;
@@ -43,6 +44,42 @@ MetadataService metadataService(Ref ref) {
}
@riverpod
Future<TrackMetadata> trackMetadata(Ref ref, String path) {
return ref.watch(metadataServiceProvider).getMetadata(path);
Future<TrackMetadata> trackMetadata(Ref ref, String path) async {
// Check if this is a remote track (protocol URL)
final urlResolver = ref.watch(remoteUrlResolverProvider);
if (urlResolver.isProtocolUrl(path)) {
// For remote tracks, get metadata from database
final database = ref.watch(databaseProvider);
final track = await (database.select(
database.tracks,
)..where((t) => t.path.equals(path))).getSingleOrNull();
if (track != null) {
// For remote tracks, try to fetch album art from the stored URL
Uint8List? artBytes;
if (track.artUri != null) {
try {
final response = await http.get(Uri.parse(track.artUri!));
if (response.statusCode == 200) {
artBytes = response.bodyBytes;
}
} catch (e) {
// Ignore art fetching errors - album art is not critical
debugPrint('Failed to fetch album art from ${track.artUri}: $e');
}
}
return TrackMetadata(
title: track.title,
artist: track.artist,
album: track.album,
artBytes: artBytes,
);
}
return TrackMetadata();
} else {
// For local tracks, use file metadata
final service = MetadataService();
return service.getMetadata(path);
}
}

127
lib/logic/metadata_service.g.dart
View File

@@ -1,127 +0,0 @@
// GENERATED CODE - DO NOT MODIFY BY HAND
part of 'metadata_service.dart';
// **************************************************************************
// RiverpodGenerator
// **************************************************************************
// GENERATED CODE - DO NOT MODIFY BY HAND
// ignore_for_file: type=lint, type=warning
@ProviderFor(metadataService)
const metadataServiceProvider = MetadataServiceProvider._();
final class MetadataServiceProvider
extends
$FunctionalProvider<MetadataService, MetadataService, MetadataService>
with $Provider<MetadataService> {
const MetadataServiceProvider._()
: super(
from: null,
argument: null,
retry: null,
name: r'metadataServiceProvider',
isAutoDispose: false,
dependencies: null,
$allTransitiveDependencies: null,
);
@override
String debugGetCreateSourceHash() => _$metadataServiceHash();
@$internal
@override
$ProviderElement<MetadataService> $createElement($ProviderPointer pointer) =>
$ProviderElement(pointer);
@override
MetadataService create(Ref ref) {
return metadataService(ref);
}
/// {@macro riverpod.override_with_value}
Override overrideWithValue(MetadataService value) {
return $ProviderOverride(
origin: this,
providerOverride: $SyncValueProvider<MetadataService>(value),
);
}
}
String _$metadataServiceHash() => r'62471f009f532ce97bab1ea7e87171ae385592b7';
@ProviderFor(trackMetadata)
const trackMetadataProvider = TrackMetadataFamily._();
final class TrackMetadataProvider
extends
$FunctionalProvider<
AsyncValue<TrackMetadata>,
TrackMetadata,
FutureOr<TrackMetadata>
>
with $FutureModifier<TrackMetadata>, $FutureProvider<TrackMetadata> {
const TrackMetadataProvider._({
required TrackMetadataFamily super.from,
required String super.argument,
}) : super(
retry: null,
name: r'trackMetadataProvider',
isAutoDispose: true,
dependencies: null,
$allTransitiveDependencies: null,
);
@override
String debugGetCreateSourceHash() => _$trackMetadataHash();
@override
String toString() {
return r'trackMetadataProvider'
''
'($argument)';
}
@$internal
@override
$FutureProviderElement<TrackMetadata> $createElement(
$ProviderPointer pointer,
) => $FutureProviderElement(pointer);
@override
FutureOr<TrackMetadata> create(Ref ref) {
final argument = this.argument as String;
return trackMetadata(ref, argument);
}
@override
bool operator ==(Object other) {
return other is TrackMetadataProvider && other.argument == argument;
}
@override
int get hashCode {
return argument.hashCode;
}
}
String _$trackMetadataHash() => r'9833c87e90297f7c9aa952c31f78a73aae78422b';
final class TrackMetadataFamily extends $Family
with $FunctionalFamilyOverride<FutureOr<TrackMetadata>, String> {
const TrackMetadataFamily._()
: super(
retry: null,
name: r'trackMetadataProvider',
dependencies: null,
$allTransitiveDependencies: null,
isAutoDispose: true,
);
TrackMetadataProvider call(String path) =>
TrackMetadataProvider._(argument: path, from: this);
@override
String toString() => r'trackMetadataProvider';
}

124
lib/providers/remote_provider.dart
View File

@@ -97,7 +97,7 @@ class RemoteProviderService {
final client = JellyfinDart(basePathOverride: provider.serverUrl);
// Set device info
client.setDeviceId('groovybox-${providerId}');
client.setDeviceId('groovybox-$providerId');
client.setVersion('1.0.0');
// Authenticate
@@ -151,47 +151,56 @@ class RemoteProviderService {
BaseItemDto item,
String token,
) async {
// Generate streaming URL
final streamUrl =
'${provider.serverUrl}/Audio/${item.id}/stream.mp3?api_key=$token&static=true';
// Generate secure protocol URL instead of exposing API key
final streamUrl = 'groovybox://remote/jellyfin/${provider.id}/${item.id}';
// Extract metadata
final title = item.name ?? 'Unknown Title';
// Better artist extraction: prefer album artist, then track artists
final artist =
item.albumArtist ?? item.artists?.join(', ') ?? 'Unknown Artist';
item.albumArtist ??
(item.artists?.isNotEmpty == true ? item.artists!.join(', ') : null) ??
'Unknown Artist';
final album = item.album ?? 'Unknown Album';
final duration =
(item.runTimeTicks ?? 0) ~/ 10000; // Convert ticks to milliseconds
// Generate album art URL (try Primary image)
final artUri =
'${provider.serverUrl}/Items/${item.id}/Images/Primary?api_key=$token';
// Extract overview/description as lyrics placeholder if no real lyrics
final overview = item.overview;
// Check if track already exists
final existingTrack = await (db.select(
db.tracks,
)..where((t) => t.path.equals(streamUrl))).getSingleOrNull();
if (existingTrack != null) {
// Update existing track
await (db.update(
db.tracks,
)..where((t) => t.id.equals(existingTrack.id))).write(
TracksCompanion(
final trackCompanion = TracksCompanion(
title: Value(title),
artist: Value(artist),
album: Value(album),
duration: Value(duration),
artUri: Value(artUri),
lyrics: Value(overview), // Store overview as placeholder for lyrics
addedAt: Value(DateTime.now()),
),
);
if (existingTrack != null) {
// Update existing track
await (db.update(
db.tracks,
)..where((t) => t.id.equals(existingTrack.id))).write(trackCompanion);
} else {
// Insert new track
await db
.into(db.tracks)
.insert(
TracksCompanion.insert(
title: title,
path: streamUrl, // Remote streaming URL
artist: Value(artist),
album: Value(album),
duration: Value(duration),
trackCompanion.copyWith(
path: Value(streamUrl), // Remote streaming URL
),
mode: InsertMode.insertOrIgnore,
);
@@ -199,6 +208,85 @@ class RemoteProviderService {
}
}
// URL resolver for secure protocol URLs
class RemoteUrlResolver {
final Ref ref;
RemoteUrlResolver(this.ref);
/// Resolves a groovybox protocol URL to an actual streaming URL
Future<String?> resolveUrl(String protocolUrl) async {
final uri = Uri.parse(protocolUrl);
if (uri.scheme != 'groovybox' || uri.host != 'remote') {
return null; // Not a protocol URL we handle
}
final pathSegments = uri.pathSegments;
if (pathSegments.length < 3 || pathSegments[0] != 'jellyfin') {
return null;
}
final providerId = int.tryParse(pathSegments[1]);
final itemId = pathSegments[2];
if (providerId == null || itemId.isEmpty) {
return null;
}
final db = ref.read(databaseProvider);
// Get provider details
final provider = await (db.select(
db.remoteProviders,
)..where((t) => t.id.equals(providerId))).getSingleOrNull();
if (provider == null || !provider.isActive) {
return null;
}
try {
// Create Jellyfin client and authenticate
final client = JellyfinDart(basePathOverride: provider.serverUrl);
client.setDeviceId('groovybox-${providerId}');
client.setVersion('1.0.0');
final userApi = client.getUserApi();
final authResponse = await userApi.authenticateUserByName(
authenticateUserByName: AuthenticateUserByName(
username: provider.username,
pw: provider.password,
),
);
final token = authResponse.data?.accessToken;
if (token == null) {
return null;
}
// Return the actual streaming URL
return '${provider.serverUrl}/Audio/$itemId/stream.mp3?api_key=$token&static=true';
} catch (e) {
debugPrint('Error resolving URL $protocolUrl: $e');
return null;
}
}
/// Checks if a URL is a protocol URL we handle
bool isProtocolUrl(String url) {
try {
final uri = Uri.parse(url);
return uri.scheme == 'groovybox' && uri.host == 'remote';
} catch (e) {
return false;
}
}
}
// Provider for the URL resolver
final remoteUrlResolverProvider = Provider<RemoteUrlResolver>((ref) {
return RemoteUrlResolver(ref);
});
// Provider for the service
final remoteProviderServiceProvider = Provider<RemoteProviderService>((ref) {
return RemoteProviderService(ref);

97
lib/ui/screens/library_screen.dart
View File

@@ -1,4 +1,5 @@
import 'dart:io';
import 'dart:typed_data';
import 'package:file_picker/file_picker.dart';
import 'package:flutter/material.dart';
import 'package:flutter_hooks/flutter_hooks.dart';
@@ -8,10 +9,12 @@ import 'package:groovybox/data/playlist_repository.dart';
import 'package:groovybox/data/track_repository.dart';
import 'package:groovybox/logic/lyrics_parser.dart';
import 'package:groovybox/providers/audio_provider.dart';
import 'package:groovybox/providers/remote_provider.dart';
import 'package:groovybox/providers/watch_folder_provider.dart';
import 'package:groovybox/ui/screens/settings_screen.dart';
import 'package:groovybox/ui/tabs/albums_tab.dart';
import 'package:groovybox/ui/tabs/playlists_tab.dart';
import 'package:http/http.dart' as http;
import 'package:hooks_riverpod/hooks_riverpod.dart';
import 'package:path/path.dart' as p;
import 'package:styled_widget/styled_widget.dart';
@@ -483,24 +486,7 @@ class LibraryScreen extends HookConsumerWidget {
child: ListTile(
leading: AspectRatio(
aspectRatio: 1,
child: Container(
decoration: BoxDecoration(
color: Colors.grey[800],
borderRadius: BorderRadius.circular(8),
image: track.artUri != null
? DecorationImage(
image: FileImage(File(track.artUri!)),
fit: BoxFit.cover,
)
: null,
),
child: track.artUri == null
? const Icon(
Icons.music_note,
color: Colors.white54,
)
: null,
),
child: _buildAlbumArt(track, ref),
),
title: Text(
track.title,
@@ -867,6 +853,81 @@ class LibraryScreen extends HookConsumerWidget {
);
}
Widget _buildAlbumArt(Track track, WidgetRef ref) {
// Check if this is a remote track
final urlResolver = ref.watch(remoteUrlResolverProvider);
final isRemote = urlResolver.isProtocolUrl(track.path);
if (isRemote && track.artUri != null) {
// For remote tracks, fetch album art directly
return FutureBuilder<Uint8List?>(
future: _fetchRemoteAlbumArt(track.artUri!),
builder: (context, snapshot) {
if (snapshot.connectionState == ConnectionState.waiting) {
return Container(
color: Colors.grey[800],
child: const Center(
child: SizedBox(
width: 16,
height: 16,
child: CircularProgressIndicator(
strokeWidth: 2,
valueColor: AlwaysStoppedAnimation<Color>(Colors.white54),
),
),
),
);
} else if (snapshot.hasData && snapshot.data != null) {
return Container(
decoration: BoxDecoration(
color: Colors.grey[800],
borderRadius: BorderRadius.circular(8),
image: DecorationImage(
image: MemoryImage(snapshot.data!),
fit: BoxFit.cover,
),
),
);
} else {
return Container(
color: Colors.grey[800],
child: const Icon(Icons.music_note, color: Colors.white54),
);
}
},
);
} else {
// For local tracks, use existing logic
return Container(
decoration: BoxDecoration(
color: Colors.grey[800],
borderRadius: BorderRadius.circular(8),
image: track.artUri != null
? DecorationImage(
image: FileImage(File(track.artUri!)),
fit: BoxFit.cover,
)
: null,
),
child: track.artUri == null
? const Icon(Icons.music_note, color: Colors.white54)
: null,
);
}
}
Future<Uint8List?> _fetchRemoteAlbumArt(String url) async {
try {
final response = await http.get(Uri.parse(url));
if (response.statusCode == 200) {
return response.bodyBytes;
}
} catch (e) {
// Ignore errors
}
return null;
}
String _formatDuration(int? durationMs) {
if (durationMs == null) return '--:--';
final d = Duration(milliseconds: durationMs);

17
lib/ui/screens/player_screen.dart
View File

@@ -49,7 +49,10 @@ class PlayerScreen extends HookConsumerWidget {
final media = medias[index];
final path = Uri.decodeFull(Uri.parse(media.uri).path);
final metadataAsync = ref.watch(trackMetadataProvider(path));
// For now, skip metadata loading to avoid provider issues
final AsyncValue<TrackMetadata> metadataAsync = AsyncValue.data(
TrackMetadata(),
);
// Build blurred background if cover art is available
Widget? background;
@@ -491,9 +494,10 @@ class _PlayerLyrics extends HookConsumerWidget {
? ref.watch(trackByPathProvider(trackPath!))
: const AsyncValue<db.Track?>.data(null);
final metadataAsync = trackPath != null
? ref.watch(trackMetadataProvider(trackPath!))
: const AsyncValue<TrackMetadata?>.data(null);
// For now, skip metadata loading to avoid provider issues
final AsyncValue<TrackMetadata> metadataAsync = AsyncValue.data(
TrackMetadata(),
);
final lyricsFetcher = ref.watch(lyricsFetcherProvider);
final musixmatchProviderInstance = ref.watch(musixmatchProvider);
@@ -809,7 +813,10 @@ class _LyricsAdjustButton extends HookConsumerWidget {
@override
Widget build(BuildContext context, WidgetRef ref) {
final trackAsync = ref.watch(trackByPathProvider(trackPath));
final metadataAsync = ref.watch(trackMetadataProvider(trackPath));
// For now, skip metadata loading to avoid provider issues
final AsyncValue<TrackMetadata> metadataAsync = AsyncValue.data(
TrackMetadata(),
);
final musixmatchProviderInstance = ref.watch(musixmatchProvider);
final neteaseProviderInstance = ref.watch(neteaseProvider);

19
lib/ui/widgets/mini_player.dart
View File

@@ -50,12 +50,13 @@ class _MobileMiniPlayer extends HookConsumerWidget {
return const SizedBox.shrink();
}
final media = medias[index];
final path = Uri.parse(media.uri).path;
final filePath = Uri.decodeFull(path);
final devicePadding = MediaQuery.paddingOf(context);
final metadataAsync = ref.watch(trackMetadataProvider(filePath));
// For now, skip metadata loading to avoid provider issues
final AsyncValue<TrackMetadata> metadataAsync = AsyncValue.data(
TrackMetadata(),
);
Widget content = Container(
height: 72 + devicePadding.bottom,
@@ -268,12 +269,13 @@ class _DesktopMiniPlayer extends HookConsumerWidget {
return const SizedBox.shrink();
}
final media = medias[index];
final path = Uri.parse(media.uri).path;
final filePath = Uri.decodeFull(path);
final devicePadding = MediaQuery.paddingOf(context);
final metadataAsync = ref.watch(trackMetadataProvider(filePath));
// For now, skip metadata loading to avoid provider issues
final AsyncValue<TrackMetadata> metadataAsync = AsyncValue.data(
TrackMetadata(),
);
Widget content = Container(
height: 72 + devicePadding.bottom,
@@ -631,9 +633,8 @@ class _DesktopMiniPlayer extends HookConsumerWidget {
final trackPath = Uri.decodeFull(
Uri.parse(media.uri).path,
);
final trackAsync = ref.watch(
trackByPathProvider(trackPath),
);
// For now, skip track loading to avoid provider issues
final trackAsync = AsyncValue<db.Track?>.data(null);
return trackAsync.when(
loading: () => SizedBox(