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

test/downloads/online_screen_test.dart

@@ -0,0 +1,83 @@
+import 'dart:convert';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:http/http.dart' as http;
+import 'package:http/testing.dart';
+import 'package:melo/downloads/downloads_screen.dart';
+import 'package:melo/services/baka_auth.dart';
+import 'package:melo/services/yt_download_service.dart';
+import 'package:provider/provider.dart';
+import 'package:shared_preferences/shared_preferences.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);
+}
+
+Widget _wrap(BakaAuth auth) {
+  return MultiProvider(
+    providers: [
+      ChangeNotifierProvider<BakaAuth>.value(value: auth),
+      ChangeNotifierProvider<YtDownloadService>(
+        create: (_) => YtDownloadService(
+          auth: auth,
+          client: MockClient((_) async => http.Response('', 500)),
+        ),
+      ),
+    ],
+    child: const MaterialApp(home: Scaffold(body: DownloadsScreen())),
+  );
+}
+
+void main() {
+  setUp(() => SharedPreferences.setMockInitialValues({}));
+
+  testWidgets('Online-Tab hat die Unterreiter YouTube und Server',
+      (tester) async {
+    final auth =
+        BakaAuth(client: MockClient((_) async => http.Response('', 500)),
+            speicher: _MemorySpeicher());
+
+    await tester.pumpWidget(_wrap(auth));
+    await tester.pump();
+
+    expect(find.text('YouTube'), findsOneWidget);
+    expect(find.text('Server'), findsOneWidget);
+  });
+
+  testWidgets('Ohne Anmeldung fordert der YouTube-Bereich zum Anmelden auf',
+      (tester) async {
+    final auth =
+        BakaAuth(client: MockClient((_) async => http.Response('', 500)),
+            speicher: _MemorySpeicher());
+
+    await tester.pumpWidget(_wrap(auth));
+    await tester.pump();
+
+    expect(find.text('Beim Baka-Konto anmelden'), findsOneWidget);
+    expect(find.byType(TextField), findsNothing);
+  });
+
+  testWidgets('Angemeldet zeigt der YouTube-Bereich das Adressfeld',
+      (tester) async {
+    final auth = BakaAuth(
+      client: MockClient(
+          (_) async => http.Response(jsonEncode({'token': 'jwt'}), 200)),
+      speicher: _MemorySpeicher(),
+    );
+    await auth.anmelden('Baka', 'geheim');
+
+    await tester.pumpWidget(_wrap(auth));
+    await tester.pump();
+
+    expect(find.text('Angemeldet als Baka'), findsOneWidget);
+    expect(find.byType(TextField), findsOneWidget);
+    expect(find.text('Herunterladen'), findsOneWidget);
+  });
+}

test/home_shell_test.dart

@@ -7,11 +7,23 @@ import 'package:melo/library/library_service.dart';
 import 'package:melo/library/playlist_service.dart';
 import 'package:melo/main.dart';
 import 'package:melo/player/audio_handler.dart';
+import 'package:melo/services/baka_auth.dart';
 import 'package:melo/services/offline_mode.dart';
+import 'package:melo/services/yt_download_service.dart';
 import 'package:melo/settings/app_settings.dart';
 import 'package:provider/provider.dart';
 import 'package:shared_preferences/shared_preferences.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);
+}
+
 void main() {
   setUp(() => SharedPreferences.setMockInitialValues({}));
 
@@ -21,6 +33,7 @@ void main() {
     final lib = LibraryService(db);
     final playlists = PlaylistService(db);
     final handler = MeloAudioHandler(db: db);
+    final auth = BakaAuth(speicher: _MemorySpeicher());
 
     await tester.pumpWidget(MultiProvider(
       providers: [
@@ -31,6 +44,9 @@ void main() {
         ChangeNotifierProvider<CategoryService>(create: (_) => CategoryService(db)),
         ChangeNotifierProvider<AppSettings>(create: (_) => AppSettings()),
         ChangeNotifierProvider<OfflineMode>(create: (_) => OfflineMode()),
+        ChangeNotifierProvider<BakaAuth>(create: (_) => auth),
+        ChangeNotifierProvider<YtDownloadService>(
+            create: (_) => YtDownloadService(auth: auth)),
       ],
       child: const MaterialApp(home: HomeShell()),
     ));

test/services/baka_auth_test.dart

@@ -0,0 +1,106 @@
+import 'dart:convert';
+
+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';
+
+/// Einfacher Speicher im Arbeitsspeicher — FlutterSecureStorage braucht
+/// Plattform-Kanäle und ist im Test nicht verfügbar.
+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);
+}
+
+void main() {
+  test('Anmeldung mit gültigen Daten speichert den Token', () async {
+    final speicher = _MemorySpeicher();
+    late String gesendet;
+    final client = MockClient((req) async {
+      gesendet = req.body;
+      return http.Response(jsonEncode({'token': 'jwt-abc'}), 200);
+    });
+    final auth = BakaAuth(client: client, speicher: speicher);
+
+    final fehler = await auth.anmelden('Baka', 'geheim');
+
+    expect(fehler, isNull);
+    expect(auth.istAngemeldet, isTrue);
+    expect(auth.benutzer, 'Baka');
+    expect(speicher.werte['baka_token'], 'jwt-abc');
+    expect(jsonDecode(gesendet), {'username': 'Baka', 'password': 'geheim'});
+  });
+
+  test('Auth-Header trägt den Token als Bearer', () async {
+    final client = MockClient(
+        (_) async => http.Response(jsonEncode({'token': 'jwt-abc'}), 200));
+    final auth = BakaAuth(client: client, speicher: _MemorySpeicher());
+    await auth.anmelden('Baka', 'geheim');
+
+    expect(auth.authHeader['Authorization'], 'Bearer jwt-abc');
+  });
+
+  test('Falsches Passwort liefert die Server-Meldung, obwohl HTTP 200 kommt',
+      () async {
+    // Der Baka-Auth-Server antwortet auch bei Fehlern mit Status 200.
+    final client = MockClient((_) async => http.Response(
+        jsonEncode({'status': 'error', 'message': 'Falscher Benutzer'}), 200));
+    final auth = BakaAuth(client: client, speicher: _MemorySpeicher());
+
+    final fehler = await auth.anmelden('Baka', 'falsch');
+
+    expect(fehler, 'Falscher Benutzer');
+    expect(auth.istAngemeldet, isFalse);
+  });
+
+  test('Nicht erreichbarer Server meldet einen Verbindungsfehler', () async {
+    final client = MockClient((_) async => throw const SocketAusfall());
+    final auth = BakaAuth(client: client, speicher: _MemorySpeicher());
+
+    final fehler = await auth.anmelden('Baka', 'geheim');
+
+    expect(fehler, 'Keine Verbindung zum Anmelde-Server');
+    expect(auth.istAngemeldet, isFalse);
+  });
+
+  test('laden() stellt einen gespeicherten Token wieder her', () async {
+    final speicher = _MemorySpeicher();
+    speicher.werte['baka_token'] = 'jwt-alt';
+    speicher.werte['baka_user'] = 'Baka';
+    final auth = BakaAuth(
+        client: MockClient((_) async => http.Response('', 500)),
+        speicher: speicher);
+
+    await auth.laden();
+
+    expect(auth.istAngemeldet, isTrue);
+    expect(auth.benutzer, 'Baka');
+  });
+
+  test('Abmelden löscht Token und Benutzer aus dem Speicher', () async {
+    final speicher = _MemorySpeicher();
+    final auth = BakaAuth(
+        client: MockClient(
+            (_) async => http.Response(jsonEncode({'token': 'jwt-abc'}), 200)),
+        speicher: speicher);
+    await auth.anmelden('Baka', 'geheim');
+
+    await auth.abmelden();
+
+    expect(auth.istAngemeldet, isFalse);
+    expect(speicher.werte, isEmpty);
+  });
+}
+
+/// Steht im Test für einen Netzwerkausfall.
+class SocketAusfall implements Exception {
+  const SocketAusfall();
+}

test/services/media_store_test.dart

@@ -0,0 +1,47 @@
+import 'package:flutter/services.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:melo/services/media_store.dart';
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  const kanal = MethodChannel('de.baka.melo/media_store');
+  final messenger =
+      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger;
+
+  tearDown(() => messenger.setMockMethodCallHandler(kanal, null));
+
+  test('veroeffentliche reicht Pfad, Titel und Künstler nach Android durch',
+      () async {
+    MethodCall? gesehen;
+    messenger.setMockMethodCallHandler(kanal, (call) async {
+      gesehen = call;
+      return '/storage/emulated/0/Music/Melo/Roses.mp3';
+    });
+
+    final pfad = await const MediaStore().veroeffentliche(
+      quellPfad: '/tmp/Roses.mp3',
+      titel: 'Roses',
+      kuenstler: 'Neoni',
+    );
+
+    expect(pfad, '/storage/emulated/0/Music/Melo/Roses.mp3');
+    expect(gesehen!.method, 'publishAudio');
+    expect(gesehen!.arguments, {
+      'sourcePath': '/tmp/Roses.mp3',
+      'title': 'Roses',
+      'artist': 'Neoni',
+    });
+  });
+
+  test('Scheitert die Android-Seite, gibt es null statt einer Ausnahme',
+      () async {
+    messenger.setMockMethodCallHandler(
+        kanal, (_) async => throw PlatformException(code: 'io'));
+
+    final pfad = await const MediaStore()
+        .veroeffentliche(quellPfad: '/tmp/x.mp3', titel: 'X');
+
+    expect(pfad, isNull);
+  });
+}

test/services/yt_download_test.dart

@@ -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);
+  });
+}