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/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);
}