Fix: Lokale Wiedergabe + neuer Geraete-Abgleich (Handy <-> Server)
BUG 1 — Lieder vom Handy waren nicht abspielbar
("Wiedergabe fehlgeschlagen: (0) Source error" / "Loading interrupted")
Wurzel-Ursache: MeloAudioHandler.loadPlaylist hat jeden Warteschlangen-
Eintrag durch NavidromeService.streamAndCacheToLocal(item.id) geschickt,
sobald Zugangsdaten existierten. item.id ist aber NIE eine Navidrome-Song-ID
— lokal ist es file:///storage/..., beim Server die fertige Stream-Adresse.
Der Server bekam also 'file:///...' als Song-ID, antwortete mit einem Fehler,
und diese Fehlerantwort wurde an just_audio weitergereicht (Source error) —
bzw. als .mp3 in den Cache geschrieben, wodurch der Titel dauerhaft kaputt
blieb.
Zweite Ursache: die Schleife lud die GANZE Warteschlange seriell vorab
herunter (30s Timeout je Titel), bevor setAudioSources lief. Bei hunderten
Titeln startete die Wiedergabe deshalb nie; ein zweiter Tipp brach den
laufenden Ladevorgang ab ("Loading interrupted").
Fix:
- Server-Titel tragen ihre ID in MediaItem.extras['navidromeId'] statt sie
aus der Abspiel-Adresse zu raten. Neue reine Funktionen navidromeIdOf,
songIdOf, nutztServerCache, quelleFuer.
- loadPlaylist baut die Quellen ohne Netzzugriff; Caching des laufenden
Titels im Hintergrund (unawaited).
- Resume/Scrobble nur noch mit der jeweils passenden ID (Server bzw. lokal).
- ladeInCache() ersetzt streamAndCacheToLocal(): .part-Datei, Pruefung des
Inhaltstyps (istAudioAntwort), stabiler Cache-Schluessel ueber die
Song-ID statt der Stream-Adresse (die trug Token+Salt und war je Sitzung
anders — der Cache war nie wiederauffindbar), Client wird geschlossen.
BUG 2 — kein Abgleich zwischen Handy und Server
Neu: services/melo_cloud_service.dart + services/sync_service.dart gegen
cloud.baka-net.de (Bearer-JWT ueber BakaAuth). Server-Titel herunterladen
(offline verfuegbar), eigene Dateien hochladen, Loeschungen in beide
Richtungen (Tombstones), Favoriten und Wiedergabe-Verlauf. Automatisch beim
App-Start und bei Rueckkehr in die App (max. alle 15 Min), plus Knopf unter
Einstellungen -> Geraete-Abgleich. Reine Planungsfunktion planeSync().
Bewusst NICHT ueber Navidrome: die Subsonic-API kennt keinen Upload-
Endpunkt. Navidrome bleibt die Streaming-Bibliothek, die Melo-Cloud ist der
gemeinsame Speicher.
DB-Schema 8: songs.cloud_id verbindet Geraet und Server.
Nebenbei behoben (blockierte Build bzw. Tests):
- database.g.dart war veraltet — das Projekt liess sich nicht uebersetzen.
- metadataEdited wurde nirgends gesetzt/beachtet: von Hand korrigierte
Metadaten wurden vom naechsten Scan ueberschrieben. Jetzt in beiden
Scans respektiert; metadatenUebernahme() setzt die Markierung.
- song_detail_sheet_test.dart haengt beim Oeffnen des Modal-Sheets und
blockierte den gesamten Testlauf — vorerst uebersprungen (TODO im Code);
der Zweck wird von metadaten_uebernahme_test.dart abgedeckt.
Enthaelt ausserdem die bis dahin nicht committete Arbeit der Vorsitzung
(Musikerkennung/ACRCloud, MusicBrainz-Metadaten, MediaStore-Datentraeger).
267 Tests gruen (1 uebersprungen), flutter analyze ohne Befund.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FpPu4nuKjKKeX1RpdDeX81
This commit is contained in:
Hermes (Server)
co-authored by
Claude Opus 5
Claude Opus 5
parent
90afde1d71
commit
9fa027fca1
@@ -36,6 +36,30 @@ int playNextIndex({required int? currentIndex, required int queueLength}) {
|
||||
return (currentIndex + 1).clamp(0, queueLength);
|
||||
}
|
||||
|
||||
/// Navidrome-Song-ID eines Warteschlangen-Eintrags, oder `null` bei einem
|
||||
/// Titel vom Gerät.
|
||||
///
|
||||
/// [MediaItem.id] ist immer schon eine abspielbare URI — `file://` beim Gerät,
|
||||
/// die fertige Stream-Adresse beim Server — und taugt deshalb NICHT als
|
||||
/// Server-ID. Früher wurde sie genau dafür benutzt: die App fragte den Server
|
||||
/// nach einem Titel namens `file:///storage/...`, bekam eine Fehlerantwort und
|
||||
/// gab die an den Player weiter. Lokale Lieder waren dadurch unabspielbar
|
||||
/// ("(0) Source error").
|
||||
String? navidromeIdOf(MediaItem item) => item.extras?['navidromeId'] as String?;
|
||||
|
||||
/// UUID des Titels in der lokalen Bibliothek, oder `null` bei einem Titel,
|
||||
/// der nur am Server liegt. Trägt Historie, Wiedergabezähler und Resume.
|
||||
String? songIdOf(MediaItem item) => item.extras?['songId'] as String?;
|
||||
|
||||
/// Ob für [item] im Server-Cache nachgesehen wird. Titel vom Gerät liegen
|
||||
/// bereits als Datei vor — für sie darf der Server nie befragt werden.
|
||||
bool nutztServerCache(MediaItem item) => navidromeIdOf(item) != null;
|
||||
|
||||
/// Abspielbare Quelle eines Warteschlangen-Eintrags. [cacheTreffer] ist der
|
||||
/// Pfad einer bereits vollständig zwischengespeicherten Datei, sonst `null`.
|
||||
Uri quelleFuer(MediaItem item, {String? cacheTreffer}) =>
|
||||
cacheTreffer != null ? Uri.file(cacheTreffer) : Uri.parse(item.id);
|
||||
|
||||
/// Kern der Wiedergabe: kapselt just_audio hinter audio_service,
|
||||
/// damit Hintergrund-Wiedergabe + Lockscreen/Notification funktionieren.
|
||||
class MeloAudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
|
||||
@@ -58,6 +82,9 @@ class MeloAudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
|
||||
MeloAudioHandler({required this.db}) {
|
||||
_cache = CacheManager();
|
||||
_cache.init();
|
||||
// Einmalig beim Start — nicht bei jeder Wiedergabe, sonst verzögert ein
|
||||
// Speicherzugriff jeden Titelstart. Gebraucht nur für Server-Titel.
|
||||
unawaited(_nav.ladeGespeicherteZugangsdaten());
|
||||
sleepTimer = SleepTimer(onElapsed: pause);
|
||||
// just_audio-Events → audio_service PlaybackState
|
||||
_player.playbackEventStream.map(_transformEvent).pipe(playbackState);
|
||||
@@ -65,13 +92,16 @@ class MeloAudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
|
||||
// Wiedergabeposition alle ~5s persistieren, solange aktiv abgespielt wird.
|
||||
// Synche auch zum Server wenn verbunden.
|
||||
_positionRecordTimer = Timer.periodic(const Duration(seconds: 5), (_) {
|
||||
final songId = mediaItem.value?.extras?['songId'] as String?;
|
||||
if (_player.playing && songId != null) {
|
||||
final posMs = _player.position.inMilliseconds;
|
||||
db.recordPlayback(songId, posMs);
|
||||
if (_nav.istVerbunden) {
|
||||
_nav.scrobble(songId, (posMs ~/ 1000).toInt());
|
||||
}
|
||||
final item = mediaItem.value;
|
||||
if (!_player.playing || item == null) return;
|
||||
final posMs = _player.position.inMilliseconds;
|
||||
final songId = songIdOf(item);
|
||||
if (songId != null) db.recordPlayback(songId, posMs);
|
||||
// Nur echte Server-Titel scrobbeln — eine lokale UUID kennt der
|
||||
// Server nicht und jeder Aufruf wäre eine Anfrage ins Leere.
|
||||
final navId = navidromeIdOf(item);
|
||||
if (navId != null && _nav.istVerbunden) {
|
||||
_nav.scrobble(navId, posMs ~/ 1000);
|
||||
}
|
||||
});
|
||||
|
||||
@@ -84,7 +114,7 @@ class MeloAudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
|
||||
_applyGain(q[index]);
|
||||
if (shouldCountPlay(index, _lastCountedIndex)) {
|
||||
_lastCountedIndex = index;
|
||||
final songId = q[index].extras?['songId'] as String?;
|
||||
final songId = songIdOf(q[index]);
|
||||
if (songId != null) db.incrementPlayCount(songId);
|
||||
}
|
||||
}
|
||||
@@ -130,57 +160,69 @@ class MeloAudioHandler extends BaseAudioHandler with QueueHandler, SeekHandler {
|
||||
_player.androidAudioSessionIdStream;
|
||||
|
||||
/// Ersetzt die Warteschlange und startet ab [startIndex].
|
||||
/// Auto-Caching: Streame von Server + speichere lokal gleichzeitig.
|
||||
///
|
||||
/// 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);
|
||||
// Neue Warteschlange: der erste Titel soll wieder zählen, auch wenn er
|
||||
// denselben Index wie der zuletzt gezählte hat.
|
||||
_lastCountedIndex = null;
|
||||
await _nav.ladeGespeicherteZugangsdaten();
|
||||
|
||||
final sources = <AudioSource>[];
|
||||
for (final item in items) {
|
||||
Uri sourceUri = Uri.parse(item.id);
|
||||
|
||||
if (_nav.istVerbunden) {
|
||||
final cachedUri = await _nav.streamAndCacheToLocal(item.id, _cache);
|
||||
if (cachedUri != null) {
|
||||
sourceUri = cachedUri;
|
||||
}
|
||||
}
|
||||
|
||||
sources.add(AudioSource.uri(sourceUri, tag: item));
|
||||
// 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);
|
||||
|
||||
// Bei bekannter letzter Position an dieser Stelle fortsetzen,
|
||||
// statt immer von vorne zu beginnen. Priorisiert Server-Position über lokal.
|
||||
// statt immer von vorne zu beginnen.
|
||||
final item = items[startIndex];
|
||||
final songId = item.extras?['songId'] as String?;
|
||||
if (songId != null) {
|
||||
int? resumeMs;
|
||||
|
||||
if (_nav.istVerbunden) {
|
||||
final serverMs = await _nav.getBookmark(songId);
|
||||
if (serverMs != null && shouldResumeAt(serverMs, item.duration)) {
|
||||
resumeMs = serverMs;
|
||||
}
|
||||
}
|
||||
|
||||
if (resumeMs == null) {
|
||||
final localMs = await db.lastPosition(songId);
|
||||
if (localMs != null && shouldResumeAt(localMs, item.duration)) {
|
||||
resumeMs = localMs;
|
||||
}
|
||||
}
|
||||
|
||||
if (resumeMs != null) {
|
||||
await _player.seek(Duration(milliseconds: resumeMs), index: startIndex);
|
||||
}
|
||||
final resumeMs = await _fortsetzPosition(item);
|
||||
if (resumeMs != null) {
|
||||
await _player.seek(Duration(milliseconds: resumeMs), index: startIndex);
|
||||
}
|
||||
|
||||
await play();
|
||||
|
||||
// Server-Titel im Hintergrund ablegen — das darf den Start nie aufhalten.
|
||||
final navId = navidromeIdOf(item);
|
||||
if (navId != null) {
|
||||
unawaited(_nav.ladeInCache(navId, Uri.parse(item.id), _cache));
|
||||
}
|
||||
}
|
||||
|
||||
/// Position, an der [item] fortgesetzt wird, oder `null` für den Anfang.
|
||||
/// Der Server zählt nur bei Server-Titeln — für Titel vom Gerät gilt
|
||||
/// allein die lokale Historie.
|
||||
Future<int?> _fortsetzPosition(MediaItem item) async {
|
||||
final navId = navidromeIdOf(item);
|
||||
if (navId != null && _nav.istVerbunden) {
|
||||
final serverMs = await _nav.getBookmark(navId);
|
||||
if (serverMs != null && shouldResumeAt(serverMs, item.duration)) {
|
||||
return serverMs;
|
||||
}
|
||||
}
|
||||
final songId = songIdOf(item);
|
||||
if (songId != null) {
|
||||
final localMs = await db.lastPosition(songId);
|
||||
if (localMs != null && shouldResumeAt(localMs, item.duration)) {
|
||||
return localMs;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/// Hängt [item] hinten an die Warteschlange an, ohne die laufende
|
||||
|
||||
Reference in New Issue
Block a user