dustin/Melo
1
0
Fork 0
Code Issues Pull Requests 3 Actions Packages Projects Releases Wiki Activity

Fuenf P0-Fehler behoben: Benachrichtigung, Offline, Cover, Warteschlange

Browse Source 
Ergebnis einer Durchsicht der App gegen den Massstab "Apple Music".
Alle fuenf Punkte waren keine fehlenden Funktionen, sondern Versprechen,
die die Oberflaeche gab und der Code nicht hielt.

- POST_NOTIFICATIONS fehlte im Manifest. Auf Android 13+ blieb die
  Wiedergabe-Benachrichtigung dadurch unsichtbar. Das Recht wird erst
  erfragt, wenn wirklich ein Titel laeuft.
- Der Offline-Schalter wurde nirgends gelesen. Er greift jetzt an allen
  drei Wegen in die Warteschlange; uebersprungene Titel werden benannt.
- CoverImage kannte nur file://, und der Server-Browser gab die
  Cover-Adresse gar nicht erst mit. Server-Titel waren deshalb immer ein
  graues Notensymbol.
- Warteschlange entfernen/umsortieren baute die ganze Queue neu auf:
  hoerbarer Aussetzer und doppelte Wiedergabe-Zaehlung. Jetzt mutiert nur
  der betroffene Eintrag, die Buchfuehrung steht vor dem Player.
- Das Herz bei Server-Titeln legte einen Favoriten mit leerer Kennung an,
  der nie in der Liste auftauchte. Es ist jetzt ausgegraut.

Nachgebessert aus dem Code-Review: Offline-Meldung an die Stelle geholt,
wo sie greifen kann; Queue-Buchfuehrung vor den Player gezogen;
Fehlerpfad fuer die Berechtigungs-Abfrage ergaenzt.

360 Tests gruen (vorher 328), flutter analyze ohne Befund, Release-APK
gebaut und POST_NOTIFICATIONS darin nachgeprueft.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013xAHJTJM6UUqmjUgk1PUEd
This commit is contained in:
Hermes (Server)
2026-08-23 18:34:26 +02:00
co-authored by Claude Opus 5
parent 34d6d8e52a
commit e6d5f1c9ee
21 changed files with 1222 additions and 232 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/downloads/downloads_screen.dart
+27 -27
View File
@@ -1,6 +1,5 @@
import 'dart:io';
import 'package:audio_service/audio_service.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:shared_preferences/shared_preferences.dart';
@@ -8,6 +7,7 @@ import 'package:shared_preferences/shared_preferences.dart';
import '../library/category_service.dart';
import '../library/database.dart';
import '../library/library_service.dart';
import '../library/song_media.dart';
import '../player/audio_handler.dart';
import '../services/baka_auth.dart';
import '../services/media_store.dart';
@@ -306,19 +306,20 @@ class _ServerBrowserState extends State<_ServerBrowser> {
);
return;
}
final items = songs
.map((s) => MediaItem(
id: _nav.streamUrl(s.id).toString(),
title: s.titel,
artist: s.kuenstler,
album: s.album,
duration: Duration(seconds: s.dauerSekunden),
// Die Server-ID getrennt von der Abspiel-URI mitgeben: nur damit
// erkennt der Player einen Server-Titel (Cache, Scrobble, Bookmark).
extras: {'navidromeId': s.id},
))
.toList();
await handler.loadPlaylist(items);
final items = [for (final s in songs) subsonicToMediaItem(s, _nav)];
final uebersprungen = await handler.loadPlaylist(items);
if (mounted && uebersprungen > 0) {
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(content: Text(offlineHinweis(uebersprungen))),
);
}
} on NichtsOfflineVerfuegbar catch (e) {
// Kein Fehler, sondern die gewählte Einstellung — deshalb ohne
// "Fehler:" davor, sonst sucht der Nutzer eine Störung.
if (!mounted) return;
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(content: Text('$e')),
);
} catch (e) {
if (!mounted) {
return;
@@ -341,19 +342,18 @@ class _ServerBrowserState extends State<_ServerBrowser> {
);
return;
}
final items = songs
.map((s) => MediaItem(
id: _nav.streamUrl(s.id).toString(),
title: s.titel,
artist: s.kuenstler,
album: s.album,
duration: Duration(seconds: s.dauerSekunden),
// Die Server-ID getrennt von der Abspiel-URI mitgeben: nur damit
// erkennt der Player einen Server-Titel (Cache, Scrobble, Bookmark).
extras: {'navidromeId': s.id},
))
.toList();
await handler.loadPlaylist(items);
final items = [for (final s in songs) subsonicToMediaItem(s, _nav)];
final uebersprungen = await handler.loadPlaylist(items);
if (mounted && uebersprungen > 0) {
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(content: Text(offlineHinweis(uebersprungen))),
);
}
} on NichtsOfflineVerfuegbar catch (e) {
if (!mounted) return;
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(content: Text('$e')),
);
} catch (e) {
if (!mounted) return;
ScaffoldMessenger.of(context).showSnackBar(
lib/library/permissions.dart
+27
View File
@@ -19,3 +19,30 @@ Future<bool> ensureAudioPermission() async {
/// Öffnet die System-Einstellungen der App (für dauerhaft verweigerte Rechte).
Future<void> openMusicPermissionSettings() => openAppSettings();
/// Ob für die Wiedergabe-Benachrichtigung eine Laufzeit-Berechtigung nötig ist.
/// Erst ab Android 13 (API 33) gibt es POST_NOTIFICATIONS; davor erscheint die
/// Benachrichtigung ohne Nachfrage, und ein Antrag liefe ins Leere.
bool brauchtBenachrichtigungsRecht({
required bool istAndroid,
required int sdkInt,
}) =>
istAndroid && sdkInt >= 33;
/// Fragt das Recht an, die Wiedergabe-Benachrichtigung zu zeigen.
///
/// Ohne dieses Recht läuft die Wiedergabe auf Android 13+ zwar weiter, aber
/// Benachrichtigung und die Bedienknöpfe darin fehlen vollständig — die
/// Steuerung ist dann nur noch in der geöffneten App erreichbar.
Future<bool> ensureNotificationPermission() async {
if (!Platform.isAndroid) return true;
final info = await DeviceInfoPlugin().androidInfo;
if (!brauchtBenachrichtigungsRecht(
istAndroid: true,
sdkInt: info.version.sdkInt,
)) {
return true;
}
final status = await Permission.notification.request();
return status.isGranted;
}
lib/library/song_list.dart
+24 -11
View File
@@ -83,6 +83,11 @@ class SongList extends StatelessWidget {
}
/// Menü hinter dem Drei-Punkte-Symbol einer Songzeile.
///
/// Die Offline-Meldungen greifen hier heute nie: diese Liste zeigt nur
/// Titel der Bibliothek, und die liegen als Datei vor. Sie stehen trotzdem
/// da, weil die Alternative — den Rückgabewert wegwerfen und "hinzugefügt"
/// melden — still lügen würde, sobald ein Server-Titel hier ankommt.
Future<void> _showMenu(BuildContext context, Song song) async {
final handler = context.read<MeloAudioHandler>();
final categories = context.read<CategoryService>();
@@ -112,9 +117,11 @@ class SongList extends StatelessWidget {
title: const Text('Als Nächstes spielen'),
onTap: () async {
Navigator.pop(sheetContext);
await handler.playNext(item());
messenger.showSnackBar(const SnackBar(
content: Text('Läuft als Nächstes')));
final ok = await handler.playNext(item());
messenger.showSnackBar(SnackBar(
content: Text(ok
? 'Läuft als Nächstes'
: nichtOfflineHinweis)));
},
),
ListTile(
@@ -124,9 +131,11 @@ class SongList extends StatelessWidget {
'Nur für jetzt — nicht in Favoriten oder Wiedergabelisten'),
onTap: () async {
Navigator.pop(sheetContext);
await handler.addToQueue(item());
messenger.showSnackBar(const SnackBar(
content: Text('Zur Warteschlange hinzugefügt')));
final ok = await handler.addToQueue(item());
messenger.showSnackBar(SnackBar(
content: Text(ok
? 'Zur Warteschlange hinzugefügt'
: nichtOfflineHinweis)));
},
),
ListTile(
@@ -178,20 +187,24 @@ class SongList extends StatelessWidget {
],
),
onTap: () async {
final messenger = ScaffoldMessenger.of(context);
try {
await playSongs(
final uebersprungen = await playSongs(
handler,
songs,
i,
coverOf: (song) => categories.coverFor(song,
groupByCategory: settings.groupCoversByCategory),
);
} catch (e) {
if (context.mounted) {
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(content: Text('Wiedergabe fehlgeschlagen: $e')),
if (uebersprungen > 0) {
messenger.showSnackBar(
SnackBar(content: Text(offlineHinweis(uebersprungen))),
);
}
} catch (e) {
messenger.showSnackBar(
SnackBar(content: Text('Wiedergabe fehlgeschlagen: $e')),
);
}
},
);
lib/library/song_media.dart
+36 -2
View File
@@ -1,6 +1,7 @@
import 'package:audio_service/audio_service.dart';
import '../player/audio_handler.dart';
import '../services/navidrome_service.dart';
import 'database.dart';
/// [cover] überschreibt das Coverbild des Songs — damit auf Sperrbildschirm
@@ -19,9 +20,42 @@ MediaItem songToMediaItem(Song s, {String? cover}) {
);
}
/// Meldung für Titel, die der Offline-Modus aus der Warteschlange genommen
/// hat. Der Nutzer soll den Unterschied zwischen "nicht da" und "nicht
/// heruntergeladen" sehen, statt eine stillschweigend kürzere Liste zu hören.
String offlineHinweis(int uebersprungen) => uebersprungen == 1
? 'Offline-Modus: 1 Titel übersprungen — nicht heruntergeladen'
: 'Offline-Modus: $uebersprungen Titel übersprungen — nicht heruntergeladen';
/// Meldung für einen einzelnen Titel, den der Offline-Modus ablehnt.
const nichtOfflineHinweis =
'Offline-Modus: dieser Titel ist nicht heruntergeladen';
/// Ein Titel vom Navidrome-Server als [MediaItem].
///
/// Eine Stelle für beide Aufrufer (Album und Künstler im Server-Browser) —
/// vorher war der Aufbau doppelt von Hand geschrieben, und beide Kopien
/// vergaßen das Coverbild.
MediaItem subsonicToMediaItem(SubsonicSong s, NavidromeService nav) {
final coverId = s.coverId;
return MediaItem(
id: nav.streamUrl(s.id).toString(),
title: s.titel,
artist: s.kuenstler,
album: s.album,
duration: Duration(seconds: s.dauerSekunden),
// Das Cover liegt am Server, nicht als Datei auf dem Gerät.
artUri: coverId == null ? null : nav.coverUrl(coverId),
// Die Server-ID getrennt von der Abspiel-URI mitgeben: nur damit erkennt
// der Player einen Server-Titel (Cache, Scrobble, Bookmark).
extras: {'navidromeId': s.id},
);
}
/// Spielt [songs] ab [startIndex] ab. [coverOf] liefert je Song das
/// anzuzeigende Cover (siehe [songToMediaItem]).
Future<void> playSongs(
/// anzuzeigende Cover (siehe [songToMediaItem]). Gibt zurück, wie viele Titel
/// der Offline-Modus übersprungen hat.
Future<int> playSongs(
MeloAudioHandler handler,
List<Song> songs,
int startIndex, {
lib/main.dart
+26
View File
@@ -1,3 +1,4 @@
import 'dart:async';
import 'dart:io';
import 'package:audio_service/audio_service.dart';
@@ -12,6 +13,7 @@ import 'library/database.dart';
import 'library/favorites_screen.dart';
import 'library/library_service.dart';
import 'library/my_music_screen.dart';
import 'library/permissions.dart';
import 'library/playlist_service.dart';
import 'library/search_screen.dart';
import 'player/audio_effects.dart';
@@ -81,6 +83,12 @@ Future<void> main() async {
uebernehmeEinstellungen();
_settings.addListener(uebernehmeEinstellungen);
// Der Offline-Schalter liegt in einem eigenen Dienst, wirkt aber genauso:
// ohne diese Weitergabe war er nur gespeichert und die App streamte weiter.
void uebernehmeOfflineModus() => _handler.offlineOnly = _offlineMode.enabled;
uebernehmeOfflineModus();
_offlineMode.addListener(uebernehmeOfflineModus);
runApp(const MeloApp());
}
@@ -140,6 +148,24 @@ class _HomeShellState extends State<HomeShell> with WidgetsBindingObserver {
// Beim Start einmal mit dem Server abgleichen — neue Titel von anderen
// Geräten sind dann sofort da.
context.read<SyncService>().automatisch();
unawaited(_frageBenachrichtigungsRecht(context.read<MeloAudioHandler>()));
}
/// Fragt das Recht auf die Wiedergabe-Benachrichtigung, sobald der erste
/// Titel läuft. Beim kalten Start käme die Frage ohne Zusammenhang — und
/// zweimal weggetippt sperrt Android sie dauerhaft.
///
/// Scheitern darf das folgenlos: `permission_handler` wirft, wenn beim
/// Start noch die Abfrage der Musik-Berechtigung offen ist. Die Wiedergabe
/// läuft dann trotzdem, nur ohne Benachrichtigung — daraus einen
/// unbehandelten Fehler zu machen, wäre die schlechtere Antwort.
Future<void> _frageBenachrichtigungsRecht(MeloAudioHandler handler) async {
try {
await handler.mediaItem.firstWhere((item) => item != null);
await ensureNotificationPermission();
} catch (e) {
logger.warning('Benachrichtigungs-Recht nicht erfragt: $e');
}
}
@override
lib/player/audio_handler.dart
+178 -24
View File
@@ -36,6 +36,43 @@ int playNextIndex({required int? currentIndex, required int queueLength}) {
return (currentIndex + 1).clamp(0, queueLength);
}
/// Entfernt den Titel an [removeIndex] aus [queue].
List<MediaItem> removeFromQueue(List<MediaItem> queue, int removeIndex) {
return List<MediaItem>.from(queue)..removeAt(removeIndex);
}
/// Verschiebt den Titel von [oldIndex] nach [newIndex]. `newIndex` ist bereits
/// um das entfernte Element bereinigt (siehe `ReorderableListView.onReorderItem`)
/// und passt damit zu `AudioPlayer.moveAudioSource`.
List<MediaItem> reorderQueue(List<MediaItem> queue, int oldIndex, int newIndex) {
final result = List<MediaItem>.from(queue);
final moved = result.removeAt(oldIndex);
result.insert(newIndex, moved);
return result;
}
/// Der zuletzt als Wiedergabe gezählte Index, nachdem der Titel an
/// [entfernt] aus der Warteschlange genommen wurde.
///
/// Ohne diese Nachführung zeigt der gemerkte Index auf den Nachbarn: der
/// laufende Titel bekäme beim nächsten `currentIndexStream`-Ereignis eine
/// zweite Wiedergabe gutgeschrieben, obwohl er nie neu gestartet wurde.
int? gezaehlterIndexNachEntfernen(int? gezaehlt, int entfernt) {
if (gezaehlt == null) return null;
if (gezaehlt == entfernt) return null;
return gezaehlt > entfernt ? gezaehlt - 1 : gezaehlt;
}
/// Der zuletzt als Wiedergabe gezählte Index, nachdem ein Titel von [von]
/// nach [nach] verschoben wurde. Siehe [gezaehlterIndexNachEntfernen].
int? gezaehlterIndexNachVerschieben(int? gezaehlt, int von, int nach) {
if (gezaehlt == null) return null;
if (gezaehlt == von) return nach;
if (von < gezaehlt && gezaehlt <= nach) return gezaehlt - 1;
if (nach <= gezaehlt && gezaehlt < von) return gezaehlt + 1;
return gezaehlt;
}
/// Navidrome-Song-ID eines Warteschlangen-Eintrags, oder `null` bei einem
/// Titel vom Gerät.
///
@@ -60,6 +97,34 @@ bool nutztServerCache(MediaItem item) => navidromeIdOf(item) != null;
Uri quelleFuer(MediaItem item, {String? cacheTreffer}) =>
cacheTreffer != null ? Uri.file(cacheTreffer) : Uri.parse(item.id);
/// Ob [item] ohne Netz läuft: Titel vom Gerät immer, Server-Titel nur mit
/// vollständigem Cache-Treffer.
bool istOfflineVerfuegbar(MediaItem item, {required bool cacheTreffer}) =>
navidromeIdOf(item) == null || cacheTreffer;
/// Der Startindex, nachdem Titel aus der Warteschlange gefiltert wurden.
/// [behalten] hat einen Eintrag je ursprünglichem Titel.
///
/// Fällt der gewählte Titel selbst weg, rückt der nächste behaltene an seine
/// Stelle — der Nutzer landet dort, wo er getippt hat, und nicht am Anfang.
int startIndexNachFilter(List<bool> behalten, int startIndex) {
var davor = 0;
for (var i = 0; i < startIndex && i < behalten.length; i++) {
if (behalten[i]) davor++;
}
final gesamt = behalten.where((b) => b).length;
if (gesamt == 0) return 0;
return davor.clamp(0, gesamt - 1);
}
/// Im Offline-Modus ist keiner der gewählten Titel ohne Netz abspielbar.
class NichtsOfflineVerfuegbar implements Exception {
const NichtsOfflineVerfuegbar();
@override
String toString() => 'Im Offline-Modus ist keiner dieser Titel verfügbar';
}
/// Kern der Wiedergabe: kapselt just_audio hinter audio_service,
/// damit Hintergrund-Wiedergabe + Lockscreen/Notification funktionieren.
class MeloAudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
@@ -79,6 +144,10 @@ class MeloAudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
/// Wird von den App-Einstellungen gesetzt.
bool normalizeVolume = true;
/// Nur abspielen, was ohne Netz da ist. Wird vom Offline-Schalter in den
/// Einstellungen gesetzt; siehe [loadPlaylist].
bool offlineOnly = false;
MeloAudioHandler({required this.db}) {
_cache = CacheManager();
_cache.init();
@@ -159,40 +228,51 @@ class MeloAudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
Stream<int?> get androidAudioSessionIdStream =>
_player.androidAudioSessionIdStream;
/// Ersetzt die Warteschlange und startet ab [startIndex].
/// Ersetzt die Warteschlange und startet ab [startIndex]. Gibt zurück, wie
/// viele Titel der Offline-Modus übersprungen hat (sonst 0).
///
/// Baut die Quellen ohne einen einzigen Netzzugriff: [MediaItem.id] ist
/// bereits abspielbar. Früher lud diese Schleife die *ganze* Warteschlange
/// vorab vom Server herunter — bei einer Bibliothek mit hunderten Titeln
/// begann die Wiedergabe deshalb nie, und ein zweiter Tipp brach den
/// laufenden Ladevorgang ab ("Loading interrupted").
Future<void> loadPlaylist(List<MediaItem> items, {int startIndex = 0}) async {
queue.add(items);
///
/// Ist [offlineOnly] gesetzt, fallen Server-Titel ohne Cache-Treffer heraus,
/// statt still gestreamt zu werden. Wirft [NichtsOfflineVerfuegbar], wenn
/// dadurch nichts übrig bleibt.
Future<int> loadPlaylist(List<MediaItem> items, {int startIndex = 0}) async {
// Ohne Titel gibt es nichts zu tun. Ohne diese Zeile sähe der Filter
// unten "alle übersprungen" und meldete fälschlich den Offline-Modus.
if (items.isEmpty) return 0;
final quellen = [for (final item in items) await _quelle(item)];
final behalten = [for (final quelle in quellen) quelle != null];
final uebersprungen = behalten.where((b) => !b).length;
if (uebersprungen == items.length) throw const NichtsOfflineVerfuegbar();
final gefiltert = <MediaItem>[];
final sources = <AudioSource>[];
for (var i = 0; i < items.length; i++) {
final quelle = quellen[i];
if (quelle == null) continue;
gefiltert.add(items[i]);
sources.add(quelle);
}
final start = startIndexNachFilter(behalten, startIndex);
queue.add(gefiltert);
// Neue Warteschlange: der erste Titel soll wieder zählen, auch wenn er
// denselben Index wie der zuletzt gezählte hat.
_lastCountedIndex = null;
final sources = <AudioSource>[];
for (final item in items) {
// Ein vollständig zwischengespeicherter Server-Titel läuft offline.
final navId = navidromeIdOf(item);
final treffer = navId == null
? null
: await _cache.getCachedFile(NavidromeService.cacheSchluessel(navId));
sources.add(AudioSource.uri(
quelleFuer(item, cacheTreffer: treffer?.path),
tag: item,
));
}
await _player.setAudioSources(sources, initialIndex: startIndex);
await _player.setAudioSources(sources, initialIndex: start);
// Bei bekannter letzter Position an dieser Stelle fortsetzen,
// statt immer von vorne zu beginnen.
final item = items[startIndex];
final item = gefiltert[start];
final resumeMs = await _fortsetzPosition(item);
if (resumeMs != null) {
await _player.seek(Duration(milliseconds: resumeMs), index: startIndex);
await _player.seek(Duration(milliseconds: resumeMs), index: start);
}
await play();
@@ -202,6 +282,28 @@ class MeloAudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
if (navId != null) {
unawaited(_nav.ladeInCache(navId, Uri.parse(item.id), _cache));
}
return uebersprungen;
}
/// Baut die Abspiel-Quelle für [item] und sieht dabei einmal im Cache nach:
/// ein vollständig zwischengespeicherter Server-Titel läuft ohne Netz.
///
/// Gibt `null` zurück, wenn [offlineOnly] gesetzt ist und der Titel das Netz
/// bräuchte. Eine Stelle für alle drei Wege in die Warteschlange — sonst
/// gälte der Offline-Modus beim Starten, aber nicht beim Anhängen.
Future<AudioSource?> _quelle(MediaItem item) async {
final navId = navidromeIdOf(item);
final treffer = navId == null
? null
: await _cache.getCachedFile(NavidromeService.cacheSchluessel(navId));
if (offlineOnly &&
!istOfflineVerfuegbar(item, cacheTreffer: treffer != null)) {
return null;
}
return AudioSource.uri(
quelleFuer(item, cacheTreffer: treffer?.path),
tag: item,
);
}
/// Position, an der [item] fortgesetzt wird, oder `null` für den Anfang.
@@ -228,21 +330,73 @@ class MeloAudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
/// Hängt [item] hinten an die Warteschlange an, ohne die laufende
/// Wiedergabe zu unterbrechen. Favoriten und Wiedergabelisten bleiben
/// unberührt — die Warteschlange ist nur für diese Sitzung.
Future<void> addToQueue(MediaItem item) async {
await _player.addAudioSource(AudioSource.uri(Uri.parse(item.id), tag: item));
///
/// `false`, wenn der Offline-Modus den Titel ausschließt.
Future<bool> addToQueue(MediaItem item) async {
final quelle = await _quelle(item);
if (quelle == null) return false;
await _player.addAudioSource(quelle);
queue.add([...queue.value, item]);
return true;
}
/// Spielt [item] als Nächstes, direkt nach dem laufenden Titel.
Future<void> playNext(MediaItem item) async {
/// `false`, wenn der Offline-Modus den Titel ausschließt.
///
/// Eingefügt wird immer *hinter* dem laufenden Titel — der zuletzt gezählte
/// Index verschiebt sich dadurch nie.
Future<bool> playNext(MediaItem item) async {
final quelle = await _quelle(item);
if (quelle == null) return false;
final index = playNextIndex(
currentIndex: _player.currentIndex,
queueLength: queue.value.length,
);
await _player.insertAudioSource(
index, AudioSource.uri(Uri.parse(item.id), tag: item));
await _player.insertAudioSource(index, quelle);
final updated = [...queue.value]..insert(index, item);
queue.add(updated);
return true;
}
/// Nimmt den Titel an [index] aus der Warteschlange, ohne die Wiedergabe
/// zu unterbrechen.
///
/// Früher baute diese Aktion die ganze Warteschlange mit [loadPlaylist] neu
/// auf: die Wiedergabe setzte hörbar aus, sprang an den Anfang des Titels
/// zurück und wurde erneut gezählt. `just_audio` kann einzelne Quellen
/// entfernen — der laufende Titel merkt davon nichts.
/// Warteschlange und Zählerstand werden **vor** dem Player gesetzt.
///
/// `just_audio` sendet beim Umbauen seiner Quellenliste noch während des
/// `await` neue Index-Ereignisse. Käme unsere Buchführung erst danach, sähe
/// der Zuhörer auf `currentIndexStream` (siehe Konstruktor) die *alte*
/// Warteschlange und meldete den falschen Titel — samt Wiedergabe-Zählung
/// für ein Lied, das gar nicht läuft. [loadPlaylist] macht es genauso.
@override
Future<void> removeQueueItemAt(int index) async {
final aktuell = queue.value;
if (index < 0 || index >= aktuell.length) return;
final rest = removeFromQueue(aktuell, index);
queue.add(rest);
_lastCountedIndex = gezaehlterIndexNachEntfernen(_lastCountedIndex, index);
await _player.removeAudioSourceAt(index);
// War es der letzte Titel, bleibt sonst eine Benachrichtigung ohne
// Wiedergabe stehen — mitsamt Knöpfen, die ins Leere greifen.
if (rest.isEmpty) await stop();
}
/// Verschiebt den Titel von [oldIndex] nach [newIndex], ohne die Wiedergabe
/// zu unterbrechen. Siehe [removeQueueItemAt] — auch hier steht die
/// Buchführung vor dem Player.
Future<void> moveQueueItem(int oldIndex, int newIndex) async {
final aktuell = queue.value;
if (oldIndex < 0 || oldIndex >= aktuell.length) return;
if (newIndex < 0 || newIndex >= aktuell.length) return;
if (oldIndex == newIndex) return;
queue.add(reorderQueue(aktuell, oldIndex, newIndex));
_lastCountedIndex =
gezaehlterIndexNachVerschieben(_lastCountedIndex, oldIndex, newIndex);
await _player.moveAudioSource(oldIndex, newIndex);
}
@override
lib/player/queue_screen.dart
+5 -69
View File
@@ -9,9 +9,9 @@ import 'audio_handler.dart';
/// Warteschlangen-Ansicht: aktuelle Queue anzeigen, zu einem Titel springen,
/// Titel entfernen oder per Drag & Drop umsortieren.
///
/// Der `MeloAudioHandler` bietet keine Live-Queue-Mutation (kein
/// `removeQueueItem`/`moveQueueItem`), daher wird die Queue clientseitig neu
/// berechnet und per `loadPlaylist` neu geladen.
/// Der `MeloAudioHandler` mutiert die Warteschlange direkt
/// ([MeloAudioHandler.removeQueueItemAt], [MeloAudioHandler.moveQueueItem]) —
/// die laufende Wiedergabe bleibt dabei unangetastet.
class QueueScreen extends StatelessWidget {
const QueueScreen({super.key});
@@ -37,7 +37,7 @@ class QueueScreen extends StatelessWidget {
return ReorderableListView.builder(
itemCount: queue.length,
onReorderItem: (oldIndex, newIndex) =>
_reorder(handler, oldIndex, newIndex),
handler.moveQueueItem(oldIndex, newIndex),
itemBuilder: (context, i) {
final item = queue[i];
final playing = item.id == currentId;
@@ -58,7 +58,7 @@ class QueueScreen extends StatelessWidget {
trailing: IconButton(
tooltip: 'Aus Warteschlange entfernen',
icon: const Icon(Icons.close),
onPressed: () => _remove(handler, i),
onPressed: () => handler.removeQueueItemAt(i),
),
onTap: () => handler.skipToQueueItem(i),
);
@@ -70,68 +70,4 @@ class QueueScreen extends StatelessWidget {
),
);
}
Future<void> _remove(MeloAudioHandler handler, int index) async {
final queue = handler.queue.valueOrNull ?? const <MediaItem>[];
if (index < 0 || index >= queue.length) return;
final playingId = handler.mediaItem.valueOrNull?.id;
final position = await handler.positionStream.first;
final newQueue = removeFromQueue(queue, index);
if (newQueue.isEmpty) {
await handler.stop();
return;
}
final fallbackIndex = index.clamp(0, newQueue.length - 1);
final newIndex = newPlayingIndex(newQueue, playingId, fallbackIndex);
await handler.loadPlaylist(newQueue, startIndex: newIndex);
if (newQueue[newIndex].id == playingId) {
await handler.seek(position);
}
}
Future<void> _reorder(
MeloAudioHandler handler, int oldIndex, int newIndex) async {
final queue = handler.queue.valueOrNull ?? const <MediaItem>[];
if (queue.isEmpty) return;
final playingId = handler.mediaItem.valueOrNull?.id;
final position = await handler.positionStream.first;
final newQueue = reorderQueue(queue, oldIndex, newIndex);
final fallbackIndex = newIndex.clamp(0, newQueue.length - 1);
final newPlayIndex = newPlayingIndex(newQueue, playingId, fallbackIndex);
await handler.loadPlaylist(newQueue, startIndex: newPlayIndex);
if (newQueue[newPlayIndex].id == playingId) {
await handler.seek(position);
}
}
}
// === Reine Queue-Logik (ohne AudioHandler testbar) ===
/// Entfernt den Titel an [removeIndex] aus [queue].
List<MediaItem> removeFromQueue(List<MediaItem> queue, int removeIndex) {
return List<MediaItem>.from(queue)..removeAt(removeIndex);
}
/// Verschiebt den Titel von [oldIndex] nach [newIndex]. `newIndex` ist bereits
/// um das entfernte Element bereinigt (siehe `ReorderableListView.onReorderItem`).
List<MediaItem> reorderQueue(List<MediaItem> queue, int oldIndex, int newIndex) {
final result = List<MediaItem>.from(queue);
final moved = result.removeAt(oldIndex);
result.insert(newIndex, moved);
return result;
}
/// Ermittelt den Index des zuvor abgespielten Titels ([playingId]) in
/// [newQueue]. Ist er nicht mehr vorhanden, wird auf [fallbackIndex]
/// zurückgefallen (z.B. der Titel, der jetzt an seiner alten Position steht).
int newPlayingIndex(
List<MediaItem> newQueue, String? playingId, int fallbackIndex) {
if (newQueue.isEmpty) return 0;
if (playingId != null) {
final idx = newQueue.indexWhere((item) => item.id == playingId);
if (idx != -1) return idx;
}
return fallbackIndex.clamp(0, newQueue.length - 1);
}
lib/settings/settings_screen.dart
+3 -2
View File
@@ -187,8 +187,9 @@ class _SettingsScreenState extends State<SettingsScreen> {
),
ListTile(
leading: const Icon(Icons.wifi_off),
title: const Text('📴 Offline-Modus'),
subtitle: const Text('Nur gecachte Lieder abspielen'),
title: const Text('Offline-Modus'),
subtitle: const Text(
'Titel vom Server nur abspielen, wenn sie schon hier liegen'),
trailing: Consumer<OfflineMode>(
builder: (context, offlineMode, _) {
return Switch(
lib/shared/cover.dart
+29 -11
View File
@@ -4,7 +4,14 @@ import 'package:flutter/material.dart';
import 'theme.dart';
/// Cover-Bild aus einer file-URI, mit Noten-Platzhalter als Fallback.
/// Cover-Bild aus einer Datei- oder Server-Adresse, mit Noten-Platzhalter
/// als Fallback.
///
/// Der Server-Fall ist nicht nachträglich angeflanscht, sondern der Regelfall
/// für jeden Titel aus Navidrome: dessen Cover liegt hinter `getCoverArt.view`
/// und nicht als Datei auf dem Gerät. Vorher kannte diese Klasse nur `file://`
/// — jeder Server-Titel war deshalb ein graues Notensymbol, in der Liste wie
/// auf dem Sperrbildschirm.
class CoverImage extends StatelessWidget {
const CoverImage({
super.key,
@@ -35,16 +42,27 @@ class CoverImage extends StatelessWidget {
},
),
);
Widget child = placeholder;
if (artUri != null && artUri!.scheme == 'file') {
child = Image.file(
File(artUri!.toFilePath()),
width: size,
height: size,
fit: BoxFit.cover,
errorBuilder: (_, _, _) => placeholder,
);
}
Widget child = switch (artUri?.scheme) {
'file' => Image.file(
File(artUri!.toFilePath()),
width: size,
height: size,
fit: BoxFit.cover,
errorBuilder: (_, _, _) => placeholder,
),
// Solange das Bild vom Server unterwegs ist, steht der Platzhalter da —
// sonst springt die Zeile in der Liste, sobald es ankommt.
'http' || 'https' => Image.network(
artUri!.toString(),
width: size,
height: size,
fit: BoxFit.cover,
errorBuilder: (_, _, _) => placeholder,
frameBuilder: (_, kind, frame, warAusCache) =>
frame == null && !warAusCache ? placeholder : kind,
),
_ => placeholder,
};
return ClipRRect(borderRadius: BorderRadius.circular(radius), child: child);
}
}
lib/shared/favorite_button.dart
+12
View File
@@ -5,12 +5,24 @@ import '../library/playlist_service.dart';
import 'theme.dart';
/// Herz-Toggle: ausgefüllt = favorisiert, umrandet = nicht favorisiert.
///
/// Ohne [songId] (Titel, der nur am Server liegt) bleibt das Herz sichtbar,
/// aber ausgegraut. Vorher kam hier der leere String an: das Herz füllte sich,
/// die Favoritenliste blieb leer — sie verbindet über die Song-UUID, die ein
/// reiner Server-Titel nicht hat.
class FavoriteButton extends StatelessWidget {
const FavoriteButton({super.key, required this.songId});
final String songId;
@override
Widget build(BuildContext context) {
if (songId.isEmpty) {
return const IconButton(
tooltip: 'Nur für Titel in deiner Bibliothek',
icon: Icon(Icons.favorite_border, color: MeloTheme.text3),
onPressed: null,
);
}
final db = context.read<MeloDb>();
final service = context.read<PlaylistService>();
return StreamBuilder<bool>(
lib/shared/sortable_song_list.dart
+6 -1
View File
@@ -54,13 +54,18 @@ class _SortableSongListState extends State<SortableSongList> {
final messenger = ScaffoldMessenger.of(context);
final shuffled = [...widget.songs]..shuffle();
try {
await playSongs(
final uebersprungen = await playSongs(
handler,
shuffled,
0,
coverOf: (song) => categories.coverFor(song,
groupByCategory: settings.groupCoversByCategory),
);
if (uebersprungen > 0) {
messenger.showSnackBar(
SnackBar(content: Text(offlineHinweis(uebersprungen))),
);
}
} catch (e) {
messenger.showSnackBar(
SnackBar(content: Text('Wiedergabe fehlgeschlagen: $e')),