YouTube-Downloader ueber den Baka-Proxy inkl. Anmeldung und MediaStore

Neuer YouTube-Bereich im Online-Tab: Adresse einfuegen, herunterladen, der
Titel landet in Meine Musik.

- BakaAuth: Anmeldung gegen baka-net.de/auth, Token verschluesselt auf dem
  Geraet. Der Server meldet Fehler mit HTTP 200 und Text im Rumpf, deshalb
  wird der Inhalt geprueft statt nur der Statuscode.
- YtDownloadService: Proxy fragen, MP3 abholen, halbe Dateien aufraeumen.
  Kuenstler nur aus "Kuenstler - Lied", sonst leer statt geraten.
- MediaStoreBridge (Kotlin): legt die Datei in Music/Melo ab und meldet sie
  dem MediaStore. Noetig, weil der Android-Scan sonst beim naechsten Lauf
  alles wieder als verschwunden markiert.
- SubTabs nach shared/ gezogen (jetzt in Meine Musik und Online genutzt).

177 Tests gruen, flutter analyze ohne Befund, Release-APK baut.
Der Weg ueber den echten Proxy ist noch nicht auf dem Geraet erprobt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018NLW1q1hzEC9goDQ1dJ98d
This commit is contained in:
Hermes (Server)
2026-08-20 19:13:55 +02:00
co-authored by Claude Opus 5
parent a625d70da8
commit 6200c77614
17 changed files with 1210 additions and 51 deletions
+182
View File
@@ -0,0 +1,182 @@
import 'dart:convert';
import 'dart:io';
import 'package:flutter_test/flutter_test.dart';
import 'package:http/http.dart' as http;
import 'package:http/testing.dart';
import 'package:melo/services/baka_auth.dart';
import 'package:melo/services/yt_download_service.dart';
class _MemorySpeicher implements TokenSpeicher {
final Map<String, String> werte = {};
@override
Future<String?> lesen(String key) async => werte[key];
@override
Future<void> schreiben(String key, String wert) async => werte[key] = wert;
@override
Future<void> loeschen(String key) async => werte.remove(key);
}
Future<BakaAuth> _angemeldeteAuth() async {
final auth = BakaAuth(
client: MockClient(
(_) async => http.Response(jsonEncode({'token': 'jwt-abc'}), 200)),
speicher: _MemorySpeicher(),
);
await auth.anmelden('Baka', 'geheim');
return auth;
}
void main() {
late Directory ziel;
setUp(() => ziel = Directory.systemTemp.createTempSync('melo_yt_test'));
tearDown(() => ziel.deleteSync(recursive: true));
test('sichererDateiname entfernt Zeichen, die kein Dateisystem mag', () {
expect(sichererDateiname('AC/DC: Thunder*struck?'),
'AC_DC_ Thunder_struck_');
});
test('Nicht-YouTube-URL wird abgelehnt, ohne den Proxy zu fragen', () async {
var aufrufe = 0;
final dienst = YtDownloadService(
auth: await _angemeldeteAuth(),
client: MockClient((_) async {
aufrufe++;
return http.Response('', 200);
}),
);
final ergebnis = await dienst.herunterladen('https://example.com/lied',
zielOrdner: ziel.path);
expect(ergebnis, isNull);
expect(dienst.fehler, 'Das ist keine YouTube-Adresse');
expect(aufrufe, 0);
});
test('Erfolgreicher Download legt die MP3 im Zielordner ab', () async {
final dienst = YtDownloadService(
auth: await _angemeldeteAuth(),
client: MockClient((req) async {
if (req.url.path == '/api/yt-dl') {
expect(req.headers['Authorization'], 'Bearer jwt-abc');
return http.Response(
jsonEncode({
'titel': 'Neoni - Roses',
'dauer': 221,
'dateiname': 'roses.mp3',
'mp3_url': '/api/dl/roses.mp3',
'filesize': 4,
}),
200);
}
return http.Response.bytes([1, 2, 3, 4], 200);
}),
);
final ergebnis = await dienst.herunterladen(
'https://youtu.be/abc123',
zielOrdner: ziel.path);
expect(ergebnis, isNotNull);
expect(ergebnis!.titel, 'Neoni - Roses');
expect(ergebnis.kuenstler, 'Neoni');
expect(ergebnis.dauerSekunden, 221);
expect(File(ergebnis.dateiPfad).readAsBytesSync(), [1, 2, 3, 4]);
expect(ergebnis.dateiPfad, '${ziel.path}/Neoni - Roses.mp3');
expect(dienst.fehler, isNull);
expect(dienst.laeuft, isFalse);
});
test('Ohne " - " im Titel bleibt der Künstler leer statt geraten zu werden',
() async {
final dienst = YtDownloadService(
auth: await _angemeldeteAuth(),
client: MockClient((req) async {
if (req.url.path == '/api/yt-dl') {
return http.Response(
jsonEncode({
'titel': 'Irgendein Mitschnitt',
'dauer': 10,
'mp3_url': '/api/dl/x.mp3',
}),
200);
}
return http.Response.bytes([9], 200);
}),
);
final ergebnis = await dienst.herunterladen('https://youtu.be/x',
zielOrdner: ziel.path);
expect(ergebnis!.kuenstler, '');
});
test('Abgelaufener Token (401) bittet um erneute Anmeldung', () async {
final dienst = YtDownloadService(
auth: await _angemeldeteAuth(),
client: MockClient((_) async => http.Response('Unauthorized', 401)),
);
final ergebnis = await dienst.herunterladen('https://youtu.be/abc',
zielOrdner: ziel.path);
expect(ergebnis, isNull);
expect(dienst.fehler, 'Anmeldung abgelaufen — bitte neu anmelden');
});
test('Ohne Anmeldung wird gar nicht erst gefragt', () async {
final dienst = YtDownloadService(
auth: BakaAuth(
client: MockClient((_) async => http.Response('', 500)),
speicher: _MemorySpeicher()),
client: MockClient((_) async => http.Response('', 200)),
);
final ergebnis = await dienst.herunterladen('https://youtu.be/abc',
zielOrdner: ziel.path);
expect(ergebnis, isNull);
expect(dienst.fehler, 'Bitte zuerst beim Baka-Konto anmelden');
});
test('Proxy-Fehlermeldung wird im Klartext durchgereicht', () async {
final dienst = YtDownloadService(
auth: await _angemeldeteAuth(),
client: MockClient((_) async => http.Response(
jsonEncode({'error': 'Video ist gesperrt'}), 500)),
);
final ergebnis = await dienst.herunterladen('https://youtu.be/abc',
zielOrdner: ziel.path);
expect(ergebnis, isNull);
expect(dienst.fehler, 'Video ist gesperrt');
});
test('Scheitert der MP3-Abruf, bleibt keine halbe Datei liegen', () async {
final dienst = YtDownloadService(
auth: await _angemeldeteAuth(),
client: MockClient((req) async {
if (req.url.path == '/api/yt-dl') {
return http.Response(
jsonEncode({
'titel': 'Kaputt',
'dauer': 1,
'mp3_url': '/api/dl/k.mp3',
}),
200);
}
return http.Response('weg', 404);
}),
);
final ergebnis = await dienst.herunterladen('https://youtu.be/abc',
zielOrdner: ziel.path);
expect(ergebnis, isNull);
expect(ziel.listSync(), isEmpty);
});
}