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

CHANGELOG.md

@@ -5,6 +5,45 @@ Format angelehnt an [Keep a Changelog](https://keepachangelog.com/de/1.0.0/).
 
 ## [Unreleased]
 
+### ⬇️ YouTube-Downloader mit Baka-Anmeldung (2026-08-20)
+- 🎬 **Musik von YouTube holen:** Im Tab **Online → YouTube** eine Adresse
+  einfügen, auf *Herunterladen* tippen — fertig. Der Titel landet danach
+  automatisch in **Meine Musik**.
+- 🔑 **Warum eine Anmeldung nötig ist:** Das Herunterladen erledigt der
+  Baka-Server (yt.baka-net.de), und der nimmt nur Anfragen von angemeldeten
+  Konten an. Deshalb gibt es im YouTube-Bereich einen Anmelde-Knopf für dein
+  **Baka-Konto**. Die Anmeldung wird **verschlüsselt auf dem Gerät**
+  gespeichert und gilt auch nach dem Neustart.
+  Läuft sie ab, sagt Melo das im Klartext ("Anmeldung abgelaufen — bitte neu
+  anmelden") statt eine Fehlernummer zu zeigen.
+- 📂 **Wo die Musik landet:** In `Music/Melo` — dem **öffentlichen**
+  Musikordner. Das ist wichtig: Melo liest seine Bibliothek auf Android über
+  den MediaStore. Eine Datei, die nur in einem App-Ordner läge, wäre beim
+  nächsten Scan wieder verschwunden. Nebeneffekt: die Musik ist auch in
+  anderen Apps da.
+- 🧹 **Keine Bruchstücke:** Der Download geht erst in einen Zwischenordner.
+  Erst wenn die Datei vollständig da ist, wandert sie in den Musikordner.
+  Bricht etwas ab, wird die halbe Datei gelöscht statt als kaputter Titel in
+  der Bibliothek zu landen.
+- 🎤 **Künstler:** Steht der Titel als "Künstler - Lied" da, wird der
+  Künstler übernommen. Steht da nichts dergleichen, bleibt das Feld leer —
+  geraten wird nicht.
+- 🔧 **Details:**
+  - Neu: `services/baka_auth.dart` (6 Tests), `services/yt_download_service.dart`
+    (8 Tests), `services/media_store.dart` (2 Tests) und die native Brücke
+    `MediaStoreBridge.kt` (MediaStore ab Android 10, Dateisystem + Scanner
+    davor).
+  - `WRITE_EXTERNAL_STORAGE` (nur bis Android 9) im Manifest ergänzt.
+  - Der Online-Tab hat jetzt die Unterreiter **YouTube · Server** (3 Tests);
+    `SubTabs` liegt dafür in `shared/sub_tabs.dart`.
+  - ⚠️ Der Anmelde-Server meldet Fehler mit Status 200 und Text im Rumpf —
+    der Code prüft deshalb den Inhalt, nicht nur den Statuscode.
+- ✅ **Getestet:** 177 Tests grün (19 neue), `flutter analyze` ohne Befund,
+  Release-APK baut (22,8 MB).
+  ⚠️ **Ehrlich dazugesagt:** Der Weg über den echten Proxy und das Schreiben
+  in den Musikordner sind **noch nicht auf dem Handy ausprobiert** — das
+  geht nur auf dem Gerät. Alles davor ist mit Tests abgedeckt.
+
 ### 🧭 Neue Tab-Struktur nach deinen Referenzbildern (2026-08-20)
 - 🔀 **Untere Leiste wie auf deinem Bild:** Die Reihenfolge ist jetzt
   **Meine Musik · Online · Suchen · Favoriten**. Der frühere Reiter

android/app/src/main/AndroidManifest.xml

@@ -13,6 +13,10 @@
     <uses-permission android:name="android.permission.READ_MEDIA_AUDIO"/>
     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"
         android:maxSdkVersion="32"/>
+    <!-- Heruntergeladene Musik in Music/Melo ablegen. Ab Android 10 uebernimmt
+         das der MediaStore ohne Berechtigung, davor braucht es Schreibrechte. -->
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+        android:maxSdkVersion="28"/>
     <application
         android:label="melo"
         android:name="${applicationName}"

android/app/src/main/kotlin/de/baka/melo/MainActivity.kt

@@ -15,6 +15,12 @@ class MainActivity : AudioServiceActivity() {
             flutterEngine.dartExecutor.binaryMessenger,
             AudioEffectsBridge.CHANNEL
         ).setMethodCallHandler(bridge::handle)
+
+        val mediaStore = MediaStoreBridge(applicationContext)
+        MethodChannel(
+            flutterEngine.dartExecutor.binaryMessenger,
+            MediaStoreBridge.CHANNEL
+        ).setMethodCallHandler(mediaStore::handle)
     }
 
     override fun onDestroy() {

android/app/src/main/kotlin/de/baka/melo/MediaStoreBridge.kt

@@ -0,0 +1,130 @@
+package de.baka.melo
+
+import android.content.ContentValues
+import android.content.Context
+import android.os.Build
+import android.os.Environment
+import android.provider.MediaStore
+import io.flutter.plugin.common.MethodCall
+import io.flutter.plugin.common.MethodChannel
+import java.io.File
+
+/**
+ * Traegt heruntergeladene Musik in den oeffentlichen Musikordner ein
+ * (Music/Melo) und meldet sie dem MediaStore.
+ *
+ * Warum ueberhaupt: der Bibliotheks-Scan liest auf Android den MediaStore.
+ * Eine Datei, die dort nicht steht, waere beim naechsten Scan wieder weg.
+ */
+class MediaStoreBridge(private val context: Context) {
+
+    companion object {
+        const val CHANNEL = "de.baka.melo/media_store"
+        private const val UNTERORDNER = "Melo"
+    }
+
+    fun handle(call: MethodCall, result: MethodChannel.Result) {
+        if (call.method != "publishAudio") {
+            result.notImplemented()
+            return
+        }
+        val quelle = call.argument<String>("sourcePath")
+        if (quelle == null) {
+            result.error("args", "sourcePath fehlt", null)
+            return
+        }
+        try {
+            result.success(
+                publish(
+                    File(quelle),
+                    call.argument<String>("title") ?: File(quelle).nameWithoutExtension,
+                    call.argument<String>("artist")
+                )
+            )
+        } catch (e: Exception) {
+            result.error("io", e.message, null)
+        }
+    }
+
+    private fun publish(quelle: File, titel: String, kuenstler: String?): String {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            publishViaMediaStore(quelle, titel, kuenstler)
+        } else {
+            publishViaDateisystem(quelle, titel, kuenstler)
+        }
+    }
+
+    /** Android 10+: Scoped Storage — der MediaStore vergibt den Platz. */
+    private fun publishViaMediaStore(quelle: File, titel: String, kuenstler: String?): String {
+        val werte = ContentValues().apply {
+            put(MediaStore.Audio.Media.DISPLAY_NAME, quelle.name)
+            put(MediaStore.Audio.Media.MIME_TYPE, "audio/mpeg")
+            put(MediaStore.Audio.Media.TITLE, titel)
+            put(MediaStore.Audio.Media.IS_MUSIC, 1)
+            kuenstler?.takeIf { it.isNotBlank() }
+                ?.let { put(MediaStore.Audio.Media.ARTIST, it) }
+            put(
+                MediaStore.Audio.Media.RELATIVE_PATH,
+                "${Environment.DIRECTORY_MUSIC}/$UNTERORDNER"
+            )
+            // Solange 1, sieht keine andere App die halbfertige Datei.
+            put(MediaStore.Audio.Media.IS_PENDING, 1)
+        }
+
+        val aufloeser = context.contentResolver
+        val ziel = aufloeser.insert(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, werte)
+            ?: throw IllegalStateException("MediaStore nahm den Eintrag nicht an")
+
+        try {
+            aufloeser.openOutputStream(ziel).use { aus ->
+                requireNotNull(aus) { "Kein Schreibzugriff auf den Eintrag" }
+                quelle.inputStream().use { ein -> ein.copyTo(aus) }
+            }
+        } catch (e: Exception) {
+            aufloeser.delete(ziel, null, null)
+            throw e
+        }
+
+        aufloeser.update(
+            ziel,
+            ContentValues().apply { put(MediaStore.Audio.Media.IS_PENDING, 0) },
+            null,
+            null
+        )
+        quelle.delete()
+
+        // Der Scan gleicht ueber den Dateipfad ab, nicht ueber die URI —
+        // deshalb den echten Pfad nachschlagen.
+        aufloeser.query(ziel, arrayOf(MediaStore.Audio.Media.DATA), null, null, null)
+            ?.use { c ->
+                if (c.moveToFirst()) {
+                    c.getString(0)?.let { return it }
+                }
+            }
+        return ziel.toString()
+    }
+
+    /** Android 9 und aelter: direkt in den Musikordner, dann scannen lassen. */
+    private fun publishViaDateisystem(quelle: File, titel: String, kuenstler: String?): String {
+        val ordner = File(
+            Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MUSIC),
+            UNTERORDNER
+        )
+        ordner.mkdirs()
+        val ziel = File(ordner, quelle.name)
+        quelle.copyTo(ziel, overwrite = true)
+        quelle.delete()
+
+        val werte = ContentValues().apply {
+            put(MediaStore.Audio.Media.DATA, ziel.absolutePath)
+            put(MediaStore.Audio.Media.DISPLAY_NAME, ziel.name)
+            put(MediaStore.Audio.Media.MIME_TYPE, "audio/mpeg")
+            put(MediaStore.Audio.Media.TITLE, titel)
+            put(MediaStore.Audio.Media.IS_MUSIC, 1)
+            kuenstler?.takeIf { it.isNotBlank() }
+                ?.let { put(MediaStore.Audio.Media.ARTIST, it) }
+        }
+        context.contentResolver.insert(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, werte)
+        return ziel.absolutePath
+    }
+}

lib/downloads/downloads_screen.dart

@@ -1,23 +1,38 @@
+import 'dart:io';
+
 import 'package:audio_service/audio_service.dart';
 import 'package:flutter/material.dart';
 import 'package:provider/provider.dart';
 
+import '../library/library_service.dart';
 import '../player/audio_handler.dart';
+import '../services/baka_auth.dart';
+import '../services/media_store.dart';
 import '../services/navidrome_service.dart';
+import '../services/yt_download_service.dart';
+import '../shared/sub_tabs.dart';
 
 /// Online-Tab: durchsucht den verbundenen Navidrome-Server. Abgespielte
 /// Titel werden vom [MeloAudioHandler] automatisch lokal zwischengespeichert
 /// und stehen danach offline zur Verfügung.
-class DownloadsScreen extends StatelessWidget {
+class DownloadsScreen extends StatefulWidget {
   const DownloadsScreen({super.key});
 
+  @override
+  State<DownloadsScreen> createState() => _DownloadsScreenState();
+}
+
+class _DownloadsScreenState extends State<DownloadsScreen> {
+  /// 0 = YouTube, 1 = Server.
+  int _subTab = 0;
+
   @override
   Widget build(BuildContext context) {
-    return const SafeArea(
+    return SafeArea(
       bottom: false,
       child: Column(
         children: [
-          Padding(
+          const Padding(
             padding: EdgeInsets.fromLTRB(20, 16, 20, 4),
             child: Align(
               alignment: Alignment.centerLeft,
@@ -25,7 +40,14 @@ class DownloadsScreen extends StatelessWidget {
                   style: TextStyle(fontSize: 24, fontWeight: FontWeight.w700)),
             ),
           ),
-          Expanded(child: _ServerBrowser()),
+          SubTabs(
+            labels: const ['YouTube', 'Server'],
+            index: _subTab,
+            onChanged: (i) => setState(() => _subTab = i),
+          ),
+          Expanded(
+            child: _subTab == 0 ? const _YouTubeBereich() : const _ServerBrowser(),
+          ),
         ],
       ),
     );
@@ -303,3 +325,201 @@ class _ServerBrowserState extends State<_ServerBrowser> {
     }
   }
 }
+
+/// YouTube-Bereich: Anmeldung am Baka-Konto und Adressfeld für den Download.
+class _YouTubeBereich extends StatefulWidget {
+  const _YouTubeBereich();
+
+  @override
+  State<_YouTubeBereich> createState() => _YouTubeBereichState();
+}
+
+class _YouTubeBereichState extends State<_YouTubeBereich> {
+  final _url = TextEditingController();
+  String? _meldung;
+
+  @override
+  void dispose() {
+    _url.dispose();
+    super.dispose();
+  }
+
+  Future<void> _anmelden() async {
+    final auth = context.read<BakaAuth>();
+    final daten = await showDialog<(String, String)>(
+      context: context,
+      builder: (_) => const _AnmeldeDialog(),
+    );
+    if (daten == null || !mounted) return;
+    final fehler = await auth.anmelden(daten.$1, daten.$2);
+    if (!mounted) return;
+    setState(() => _meldung = fehler);
+  }
+
+  Future<void> _herunterladen() async {
+    final dienst = context.read<YtDownloadService>();
+    final lib = context.read<LibraryService>();
+    final url = _url.text.trim();
+    if (url.isEmpty) return;
+
+    setState(() => _meldung = null);
+    // Erst in einen App-eigenen Zwischenordner — erst wenn die Datei
+    // vollständig da ist, wandert sie in den öffentlichen Musikordner.
+    final zwischen = Directory.systemTemp.createTempSync('melo_yt').path;
+    final ergebnis =
+        await dienst.herunterladen(url, zielOrdner: zwischen);
+    if (!mounted) return;
+
+    if (ergebnis == null) {
+      setState(() => _meldung = dienst.fehler);
+      return;
+    }
+
+    final pfad = await const MediaStore().veroeffentliche(
+      quellPfad: ergebnis.dateiPfad,
+      titel: ergebnis.titel,
+      kuenstler: ergebnis.kuenstler,
+    );
+    if (!mounted) return;
+    if (pfad == null) {
+      setState(() => _meldung =
+          'Heruntergeladen, aber nicht im Musikordner ablegbar');
+      return;
+    }
+
+    _url.clear();
+    setState(() => _meldung = '✅ ${ergebnis.titel} — wird eingelesen …');
+    // Der MediaStore kennt die Datei jetzt; ein Scan holt sie in die Bibliothek.
+    await lib.rescan();
+    if (mounted) {
+      setState(() => _meldung = '✅ ${ergebnis.titel} ist in deiner Musik');
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final auth = context.watch<BakaAuth>();
+    final dienst = context.watch<YtDownloadService>();
+
+    return ListView(
+      padding: const EdgeInsets.fromLTRB(16, 12, 16, 24),
+      children: [
+        if (!auth.istAngemeldet) ...[
+          const Text(
+            'Der Downloader läuft über den Baka-Server. Dafür brauchst du '
+            'deine Baka-Anmeldung.',
+            style: TextStyle(color: Colors.white54, fontSize: 13),
+          ),
+          const SizedBox(height: 12),
+          FilledButton.icon(
+            icon: const Icon(Icons.login),
+            label: const Text('Beim Baka-Konto anmelden'),
+            onPressed: _anmelden,
+          ),
+        ] else ...[
+          Row(
+            children: [
+              const Icon(Icons.verified_user, size: 18, color: Colors.white38),
+              const SizedBox(width: 8),
+              Expanded(
+                child: Text('Angemeldet als ${auth.benutzer}',
+                    style: const TextStyle(color: Colors.white54, fontSize: 13)),
+              ),
+              TextButton(
+                onPressed: auth.abmelden,
+                child: const Text('Abmelden'),
+              ),
+            ],
+          ),
+          const SizedBox(height: 8),
+          TextField(
+            controller: _url,
+            enabled: !dienst.laeuft,
+            decoration: const InputDecoration(
+              labelText: 'YouTube-Adresse',
+              hintText: 'https://youtu.be/…',
+              border: OutlineInputBorder(),
+            ),
+          ),
+          const SizedBox(height: 12),
+          FilledButton.icon(
+            icon: const Icon(Icons.download),
+            label: const Text('Herunterladen'),
+            onPressed: dienst.laeuft ? null : _herunterladen,
+          ),
+        ],
+        if (dienst.laeuft) ...[
+          const SizedBox(height: 16),
+          const LinearProgressIndicator(),
+          const SizedBox(height: 8),
+          Text(dienst.status ?? 'Läuft …',
+              style: const TextStyle(color: Colors.white54, fontSize: 12)),
+        ],
+        if (_meldung != null) ...[
+          const SizedBox(height: 16),
+          Text(_meldung!,
+              style: const TextStyle(color: Colors.white70, fontSize: 13)),
+        ],
+      ],
+    );
+  }
+}
+
+/// Fragt Benutzername und Passwort ab und gibt beides zurück.
+class _AnmeldeDialog extends StatefulWidget {
+  const _AnmeldeDialog();
+
+  @override
+  State<_AnmeldeDialog> createState() => _AnmeldeDialogState();
+}
+
+class _AnmeldeDialogState extends State<_AnmeldeDialog> {
+  final _benutzer = TextEditingController(text: 'Baka');
+  final _passwort = TextEditingController();
+  bool _sichtbar = false;
+
+  @override
+  void dispose() {
+    _benutzer.dispose();
+    _passwort.dispose();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return AlertDialog(
+      title: const Text('Baka-Konto'),
+      content: Column(
+        mainAxisSize: MainAxisSize.min,
+        children: [
+          TextField(
+            controller: _benutzer,
+            decoration: const InputDecoration(labelText: 'Benutzername'),
+          ),
+          TextField(
+            controller: _passwort,
+            obscureText: !_sichtbar,
+            decoration: InputDecoration(
+              labelText: 'Passwort',
+              suffixIcon: IconButton(
+                icon: Icon(_sichtbar ? Icons.visibility_off : Icons.visibility),
+                onPressed: () => setState(() => _sichtbar = !_sichtbar),
+              ),
+            ),
+          ),
+        ],
+      ),
+      actions: [
+        TextButton(
+          onPressed: () => Navigator.pop(context),
+          child: const Text('Abbrechen'),
+        ),
+        FilledButton(
+          onPressed: () => Navigator.pop(
+              context, (_benutzer.text.trim(), _passwort.text)),
+          child: const Text('Anmelden'),
+        ),
+      ],
+    );
+  }
+}

lib/library/my_music_screen.dart

@@ -5,6 +5,7 @@ import '../playlists/playlists_screen.dart';
 import '../settings/settings_screen.dart';
 import '../shared/cover.dart';
 import '../shared/sort_store.dart';
+import '../shared/sub_tabs.dart';
 import '../shared/sortable_song_list.dart';
 import '../shared/theme.dart';
 import 'album_list.dart';
@@ -82,7 +83,8 @@ class _MyMusicScreenState extends State<MyMusicScreen> {
               ),
             ),
           _QuickAccessRow(onFavoritesTap: widget.onFavoritesTap),
-          _SubTabs(
+          SubTabs(
+            labels: const ['Songs', 'Künstler', 'Alben'],
             index: _subTab,
             onChanged: (i) => setState(() => _subTab = i),
           ),
@@ -171,52 +173,6 @@ class _Header extends StatelessWidget {
   }
 }
 
-/// Unterreiter im Stil der Referenz-UI: der aktive Reiter ist eine helle
-/// Pille, die übrigen sind nur Text.
-class _SubTabs extends StatelessWidget {
-  const _SubTabs({required this.index, required this.onChanged});
-
-  final int index;
-  final ValueChanged<int> onChanged;
-
-  static const _labels = ['Songs', 'Künstler', 'Alben'];
-
-  @override
-  Widget build(BuildContext context) {
-    return Padding(
-      padding: const EdgeInsets.fromLTRB(12, 12, 12, 4),
-      child: Row(
-        children: [
-          for (var i = 0; i < _labels.length; i++)
-            Padding(
-              padding: const EdgeInsets.only(right: 8),
-              child: GestureDetector(
-                onTap: () => onChanged(i),
-                child: Container(
-                  padding:
-                      const EdgeInsets.symmetric(horizontal: 18, vertical: 9),
-                  decoration: BoxDecoration(
-                    color: i == index ? Colors.white : Colors.transparent,
-                    borderRadius: BorderRadius.circular(20),
-                  ),
-                  child: Text(
-                    _labels[i],
-                    style: TextStyle(
-                      color: i == index ? Colors.black : Colors.white70,
-                      fontSize: 15,
-                      fontWeight:
-                          i == index ? FontWeight.w600 : FontWeight.w400,
-                    ),
-                  ),
-                ),
-              ),
-            ),
-        ],
-      ),
-    );
-  }
-}
-
 /// Waagerecht scrollende Schnellzugriffe (Favoriten, Wiedergabelisten, …).
 class _QuickAccessRow extends StatelessWidget {
   const _QuickAccessRow({this.onFavoritesTap});

lib/main.dart

@@ -13,8 +13,10 @@ import 'library/search_screen.dart';
 import 'player/audio_effects.dart';
 import 'player/audio_handler.dart';
 import 'player/mini_player.dart';
+import 'services/baka_auth.dart';
 import 'services/logger_service.dart';
 import 'services/offline_mode.dart';
+import 'services/yt_download_service.dart';
 import 'settings/app_settings.dart';
 import 'shared/theme.dart';
 
@@ -26,6 +28,8 @@ late final OfflineMode _offlineMode;
 late final CategoryService _categories;
 late final AppSettings _settings;
 late final AudioEffects _effects;
+late final BakaAuth _bakaAuth;
+late final YtDownloadService _ytDownload;
 
 Future<void> main() async {
   WidgetsFlutterBinding.ensureInitialized();
@@ -49,6 +53,9 @@ Future<void> main() async {
   );
   _effects = AudioEffects();
   await _effects.init();
+  _bakaAuth = BakaAuth();
+  await _bakaAuth.laden();
+  _ytDownload = YtDownloadService(auth: _bakaAuth);
   // Die Audio-Session steht erst beim Abspielen fest und kann wechseln —
   // die Klangeffekte müssen dann neu daran gehängt werden.
   _handler.androidAudioSessionIdStream.listen((id) {
@@ -80,6 +87,8 @@ class MeloApp extends StatelessWidget {
         ChangeNotifierProvider<CategoryService>.value(value: _categories),
         ChangeNotifierProvider<AppSettings>.value(value: _settings),
         ChangeNotifierProvider<AudioEffects>.value(value: _effects),
+        ChangeNotifierProvider<BakaAuth>.value(value: _bakaAuth),
+        ChangeNotifierProvider<YtDownloadService>.value(value: _ytDownload),
       ],
       child: MaterialApp(
         title: 'Melo',

lib/services/baka_auth.dart

@@ -0,0 +1,110 @@
+import 'dart:convert';
+
+import 'package:flutter/foundation.dart';
+import 'package:flutter_secure_storage/flutter_secure_storage.dart';
+import 'package:http/http.dart' as http;
+
+/// Ablage für den Anmelde-Token. Als Schnittstelle, damit Tests ohne die
+/// Plattform-Kanäle von FlutterSecureStorage auskommen.
+abstract class TokenSpeicher {
+  Future<String?> lesen(String key);
+  Future<void> schreiben(String key, String wert);
+  Future<void> loeschen(String key);
+}
+
+/// Produktions-Ablage: verschlüsselter Gerätespeicher.
+class SicherenSpeicher implements TokenSpeicher {
+  const SicherenSpeicher();
+
+  static const _secure = FlutterSecureStorage();
+
+  @override
+  Future<String?> lesen(String key) => _secure.read(key: key);
+
+  @override
+  Future<void> schreiben(String key, String wert) =>
+      _secure.write(key: key, value: wert);
+
+  @override
+  Future<void> loeschen(String key) => _secure.delete(key: key);
+}
+
+/// Anmeldung am Baka-Konto. Der YouTube-Proxy (yt.baka-net.de) akzeptiert
+/// nur Anfragen mit dem hier erzeugten Bearer-Token.
+class BakaAuth extends ChangeNotifier {
+  BakaAuth({http.Client? client, TokenSpeicher? speicher})
+      : _client = client ?? http.Client(),
+        _speicher = speicher ?? const SicherenSpeicher();
+
+  static const basisUrl = 'https://baka-net.de/auth';
+  static const _tokenKey = 'baka_token';
+  static const _userKey = 'baka_user';
+
+  final http.Client _client;
+  final TokenSpeicher _speicher;
+
+  String? _token;
+  String _benutzer = '';
+
+  bool get istAngemeldet => _token != null && _token!.isNotEmpty;
+  String get benutzer => _benutzer;
+
+  /// Header für Anfragen an den Proxy. Ohne Anmeldung ohne `Authorization`.
+  Map<String, String> get authHeader => {
+        if (istAngemeldet) 'Authorization': 'Bearer $_token',
+      };
+
+  /// Stellt eine frühere Anmeldung wieder her (App-Start).
+  Future<void> laden() async {
+    _token = await _speicher.lesen(_tokenKey);
+    _benutzer = await _speicher.lesen(_userKey) ?? '';
+    notifyListeners();
+  }
+
+  /// Meldet an. Gibt `null` bei Erfolg zurück, sonst den Fehlertext.
+  Future<String?> anmelden(String benutzer, String passwort) async {
+    final http.Response antwort;
+    try {
+      antwort = await _client
+          .post(
+            Uri.parse('$basisUrl/login'),
+            headers: {'Content-Type': 'application/json'},
+            body: jsonEncode({'username': benutzer, 'password': passwort}),
+          )
+          .timeout(const Duration(seconds: 15));
+    } catch (e) {
+      debugPrint('Baka-Anmeldung fehlgeschlagen: $e');
+      return 'Keine Verbindung zum Anmelde-Server';
+    }
+
+    Map<String, dynamic> daten;
+    try {
+      daten = jsonDecode(antwort.body) as Map<String, dynamic>;
+    } catch (_) {
+      return 'Anmelde-Server antwortet unverständlich (${antwort.statusCode})';
+    }
+
+    final token = daten['token'] as String?;
+    if (token != null && token.isNotEmpty) {
+      _token = token;
+      _benutzer = benutzer;
+      await _speicher.schreiben(_tokenKey, token);
+      await _speicher.schreiben(_userKey, benutzer);
+      notifyListeners();
+      return null;
+    }
+
+    // Der Server meldet Fehler mit Status 200 und einem Text im Rumpf.
+    return daten['message'] as String? ??
+        daten['error'] as String? ??
+        'Anmeldung fehlgeschlagen (${antwort.statusCode})';
+  }
+
+  Future<void> abmelden() async {
+    _token = null;
+    _benutzer = '';
+    await _speicher.loeschen(_tokenKey);
+    await _speicher.loeschen(_userKey);
+    notifyListeners();
+  }
+}

lib/services/media_store.dart

@@ -0,0 +1,37 @@
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+
+/// Trägt fertige Musikdateien in den öffentlichen Musikordner von Android ein.
+///
+/// Nötig, weil der Bibliotheks-Scan auf Android über den MediaStore läuft:
+/// Songs, die dort nicht stehen, werden beim nächsten Scan als verschwunden
+/// markiert. Nebeneffekt: heruntergeladene Musik ist auch in anderen Apps da.
+class MediaStore {
+  const MediaStore({this.channel = _standardKanal});
+
+  static const _standardKanal = MethodChannel('de.baka.melo/media_store');
+
+  final MethodChannel channel;
+
+  /// Verschiebt [quellPfad] nach `Music/Melo` und meldet die Datei dem
+  /// MediaStore. Gibt den neuen Pfad zurück, oder `null` wenn es nicht klappt.
+  Future<String?> veroeffentliche({
+    required String quellPfad,
+    required String titel,
+    String? kuenstler,
+  }) async {
+    try {
+      return await channel.invokeMethod<String>('publishAudio', {
+        'sourcePath': quellPfad,
+        'title': titel,
+        'artist': kuenstler,
+      });
+    } on PlatformException catch (e) {
+      debugPrint('MediaStore-Eintrag fehlgeschlagen: ${e.message}');
+      return null;
+    } on MissingPluginException {
+      // Desktop/Tests: dort gibt es keinen MediaStore.
+      return null;
+    }
+  }
+}

lib/services/yt_download_service.dart

@@ -0,0 +1,162 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:flutter/foundation.dart';
+import 'package:http/http.dart' as http;
+
+import 'baka_auth.dart';
+
+/// Entfernt alles, was in einem Dateinamen Ärger macht.
+String sichererDateiname(String titel) =>
+    titel.replaceAll(RegExp(r'[\\/:*?"<>|]'), '_').trim();
+
+/// Ergebnis eines geglückten Downloads.
+class YtErgebnis {
+  const YtErgebnis({
+    required this.dateiPfad,
+    required this.titel,
+    required this.kuenstler,
+    required this.dauerSekunden,
+  });
+
+  final String dateiPfad;
+  final String titel;
+  final String kuenstler;
+  final int dauerSekunden;
+}
+
+/// Lädt Musik über den Baka-YouTube-Proxy herunter. Der Proxy erledigt die
+/// eigentliche Arbeit und liefert eine fertige MP3; die App speichert sie nur.
+class YtDownloadService extends ChangeNotifier {
+  YtDownloadService({required this.auth, http.Client? client})
+      : _client = client ?? http.Client();
+
+  static const proxyUrl = 'https://yt.baka-net.de';
+
+  final BakaAuth auth;
+  final http.Client _client;
+
+  bool _laeuft = false;
+  String? _status;
+  String? _fehler;
+
+  bool get laeuft => _laeuft;
+
+  /// Was gerade passiert — für die Anzeige während des Downloads.
+  String? get status => _status;
+  String? get fehler => _fehler;
+
+  void _melde(String text) {
+    _status = text;
+    notifyListeners();
+  }
+
+  void _scheitere(String text) {
+    _fehler = text;
+    _status = null;
+    _laeuft = false;
+    notifyListeners();
+  }
+
+  /// Lädt [url] herunter und legt die MP3 in [zielOrdner] ab.
+  /// Gibt bei Erfolg das Ergebnis zurück, sonst `null` (siehe [fehler]).
+  Future<YtErgebnis?> herunterladen(String url,
+      {required String zielOrdner}) async {
+    _fehler = null;
+    _laeuft = true;
+    notifyListeners();
+
+    if (!auth.istAngemeldet) {
+      _scheitere('Bitte zuerst beim Baka-Konto anmelden');
+      return null;
+    }
+    if (!url.contains('youtube.com') && !url.contains('youtu.be')) {
+      _scheitere('Das ist keine YouTube-Adresse');
+      return null;
+    }
+
+    // ─── 1/2: Proxy fragen — er lädt das Video und wandelt es um ───
+    _melde('Proxy wird gefragt …');
+    final http.Response antwort;
+    try {
+      antwort = await _client
+          .post(
+            Uri.parse('$proxyUrl/api/yt-dl'),
+            headers: {...auth.authHeader, 'Content-Type': 'application/json'},
+            body: jsonEncode({'url': url}),
+          )
+          .timeout(const Duration(seconds: 180));
+    } catch (e) {
+      debugPrint('YT-Proxy nicht erreichbar: $e');
+      _scheitere('Proxy nicht erreichbar');
+      return null;
+    }
+
+    if (antwort.statusCode == 401) {
+      _scheitere('Anmeldung abgelaufen — bitte neu anmelden');
+      return null;
+    }
+    if (antwort.statusCode != 200) {
+      _scheitere(_fehlerText(antwort));
+      return null;
+    }
+
+    final daten = jsonDecode(antwort.body) as Map<String, dynamic>;
+    final titel = daten['titel'] as String? ?? 'Unbekannt';
+    final dauer = (daten['dauer'] as int?) ?? 0;
+    final mp3Url = daten['mp3_url'] as String? ?? '/api/dl/audio.mp3';
+
+    // ─── 2/2: fertige MP3 abholen und speichern ───
+    _melde('Lade „$titel“ …');
+    final ordner = Directory(zielOrdner);
+    if (!await ordner.exists()) {
+      await ordner.create(recursive: true);
+    }
+    final datei = File('${ordner.path}/${sichererDateiname(titel)}.mp3');
+
+    try {
+      final mp3 = await _client
+          .get(Uri.parse('$proxyUrl$mp3Url'), headers: auth.authHeader)
+          .timeout(const Duration(seconds: 180));
+      if (mp3.statusCode != 200) {
+        _scheitere('Herunterladen fehlgeschlagen (${mp3.statusCode})');
+        return null;
+      }
+      await datei.writeAsBytes(mp3.bodyBytes);
+    } catch (e) {
+      debugPrint('MP3-Abruf fehlgeschlagen: $e');
+      // Halbe Dateien nicht liegen lassen — sonst taucht Müll in der
+      // Bibliothek auf, sobald der Ordner das nächste Mal gescannt wird.
+      if (await datei.exists()) {
+        await datei.delete();
+      }
+      _scheitere('Herunterladen fehlgeschlagen');
+      return null;
+    }
+
+    _laeuft = false;
+    _status = null;
+    notifyListeners();
+
+    // yt-dlp liefert nur einen Titel. "Künstler - Lied" ist die übliche
+    // Form; steht da nichts dergleichen, wird nichts geraten.
+    final teile = titel.split(' - ');
+    return YtErgebnis(
+      dateiPfad: datei.path,
+      titel: titel,
+      kuenstler: teile.length >= 2 ? teile.first.trim() : '',
+      dauerSekunden: dauer,
+    );
+  }
+
+  String _fehlerText(http.Response antwort) {
+    try {
+      final j = jsonDecode(antwort.body) as Map<String, dynamic>;
+      final text = j['error'] as String?;
+      if (text != null && text.isNotEmpty) return text;
+    } catch (_) {
+      // Kein JSON — dann eben der Statuscode.
+    }
+    return 'Proxy-Fehler (${antwort.statusCode})';
+  }
+}

lib/shared/sub_tabs.dart

@@ -0,0 +1,52 @@
+import 'package:flutter/material.dart';
+
+/// Unterreiter im Stil der Referenz-UI: der aktive Reiter ist eine helle
+/// Pille, die übrigen sind nur Text.
+class SubTabs extends StatelessWidget {
+  const SubTabs({
+    super.key,
+    required this.labels,
+    required this.index,
+    required this.onChanged,
+  });
+
+  final List<String> labels;
+
+  final int index;
+  final ValueChanged<int> onChanged;
+
+  @override
+  Widget build(BuildContext context) {
+    return Padding(
+      padding: const EdgeInsets.fromLTRB(12, 12, 12, 4),
+      child: Row(
+        children: [
+          for (var i = 0; i < labels.length; i++)
+            Padding(
+              padding: const EdgeInsets.only(right: 8),
+              child: GestureDetector(
+                onTap: () => onChanged(i),
+                child: Container(
+                  padding:
+                      const EdgeInsets.symmetric(horizontal: 18, vertical: 9),
+                  decoration: BoxDecoration(
+                    color: i == index ? Colors.white : Colors.transparent,
+                    borderRadius: BorderRadius.circular(20),
+                  ),
+                  child: Text(
+                    labels[i],
+                    style: TextStyle(
+                      color: i == index ? Colors.black : Colors.white70,
+                      fontSize: 15,
+                      fontWeight:
+                          i == index ? FontWeight.w600 : FontWeight.w400,
+                    ),
+                  ),
+                ),
+              ),
+            ),
+        ],
+      ),
+    );
+  }
+}

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