📋 Feature: Playlisten-Sync vom Navidrome-Server (Phase 2, Part 6/X)

- getPlaylists() + getPlaylistSongs() APIs für Subsonic-Playlist-Laden
- syncPlaylistsFromServer() in PlaylistService importiert alle Server-Playlisten als lokale
- Benennung mit 🌐 Präfix um Server-Playlisten zu kennzeichnen
- Settings-Button lädt alle Playlisten mit ihren Songs vom Server
- Zeigt Anzahl importierter Playlisten mit SnackBar

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XJzQjUtnvYUtHdnTs3iCru

lib/library/playlist_service.dart

@@ -69,4 +69,42 @@ class PlaylistService extends ChangeNotifier {
       return 0;
     }
   }
+
+  /// Lädt alle Playlisten vom Navidrome-Server und importiert sie als lokale Playlisten.
+  /// Gibt die Anzahl importierter Playlisten zurück oder 0 wenn nicht verbunden.
+  Future<int> syncPlaylistsFromServer() async {
+    await _navidrome.ladeGespeicherteZugangsdaten();
+    if (!_navidrome.istVerbunden) return 0;
+
+    try {
+      final serverPlaylists = await _navidrome.getPlaylists();
+      int importedCount = 0;
+
+      for (final playlist in serverPlaylists) {
+        // Lade Songs aus der Server-Playlist
+        final songs = await _navidrome.getPlaylistSongs(playlist.id);
+        if (songs.isEmpty) continue;
+
+        // Erstelle lokale Playlist mit gleichem Namen
+        final playlistId = await createPlaylist(
+          '🌐 ${playlist.name}',
+          description: playlist.comment,
+        );
+
+        // Füge Songs hinzu (nur wenn sie lokal existieren)
+        for (int i = 0; i < songs.length; i++) {
+          final exists = await db.songExists(songs[i].id);
+          if (exists) {
+            await addSongToPlaylist(playlistId, songs[i].id, i);
+          }
+        }
+        importedCount++;
+      }
+      notifyListeners();
+      return importedCount;
+    } catch (e) {
+      debugPrint('Fehler beim Laden von Server-Playlisten: $e');
+      return 0;
+    }
+  }
 }

lib/services/navidrome_service.dart

@@ -341,6 +341,56 @@ class NavidromeService {
       return null;
     }
   }
+
+  /// Lädt alle Playlisten vom Server.
+  Future<List<SubsonicPlaylist>> getPlaylists() async {
+    if (!istVerbunden) return [];
+    try {
+      final uri = _uri('getPlaylists.view');
+      final response = await http.get(uri).timeout(const Duration(seconds: 10));
+      if (response.statusCode != 200) return [];
+
+      final json = jsonDecode(response.body) as Map<String, dynamic>;
+      final subsonicResponse = json['subsonic-response'] as Map<String, dynamic>?;
+      if (subsonicResponse == null) return [];
+
+      final playlists = subsonicResponse['playlists'] as List<dynamic>?;
+      if (playlists == null) return [];
+
+      return playlists
+          .cast<Map<String, dynamic>>()
+          .map(SubsonicPlaylist.fromJson)
+          .toList();
+    } catch (e) {
+      debugPrint('getPlaylists Fehler: $e');
+      return [];
+    }
+  }
+
+  /// Lädt alle Songs einer Playlist vom Server.
+  Future<List<SubsonicSong>> getPlaylistSongs(String playlistId) async {
+    if (!istVerbunden) return [];
+    try {
+      final uri = _uri('getPlaylist.view', {'id': playlistId});
+      final response = await http.get(uri).timeout(const Duration(seconds: 10));
+      if (response.statusCode != 200) return [];
+
+      final json = jsonDecode(response.body) as Map<String, dynamic>;
+      final subsonicResponse = json['subsonic-response'] as Map<String, dynamic>?;
+      if (subsonicResponse == null) return [];
+
+      final playlist = subsonicResponse['playlist'] as Map<String, dynamic>?;
+      if (playlist == null) return [];
+
+      final songs = playlist['entry'] as List<dynamic>?;
+      if (songs == null) return [];
+
+      return songs.cast<Map<String, dynamic>>().map(SubsonicSong.fromJson).toList();
+    } catch (e) {
+      debugPrint('getPlaylistSongs Fehler: $e');
+      return [];
+    }
+  }
 }
 
 class SubsonicArtist {
@@ -358,6 +408,27 @@ class SubsonicArtist {
   );
 }
 
+class SubsonicPlaylist {
+  final String id;
+  final String name;
+  final String? comment;
+  final int songCount;
+
+  const SubsonicPlaylist({
+    required this.id,
+    required this.name,
+    this.comment,
+    this.songCount = 0,
+  });
+
+  factory SubsonicPlaylist.fromJson(Map<String, dynamic> j) => SubsonicPlaylist(
+    id: j['id'] as String,
+    name: j['name'] as String? ?? 'Unbekannt',
+    comment: j['comment'] as String?,
+    songCount: (j['songCount'] as int?) ?? 0,
+  );
+}
+
 class Lyrics {
   final String? text;
   final bool isEmpty;

lib/settings/settings_screen.dart

@@ -114,6 +114,16 @@ class _SettingsScreenState extends State<SettingsScreen> {
               onPressed: () => _syncServerFavorites(),
             ),
           ),
+          ListTile(
+            leading: const Icon(Icons.playlist_play),
+            title: const Text('📋 Playlisten-Sync'),
+            subtitle: const Text('Server-Playlisten importieren'),
+            trailing: IconButton(
+              tooltip: 'Vom Server laden',
+              icon: const Icon(Icons.cloud_download),
+              onPressed: () => _syncServerPlaylists(),
+            ),
+          ),
           const Divider(height: 1),
           const _SectionLabel('Berechtigungen'),
           ListTile(
@@ -275,6 +285,28 @@ class _SettingsScreenState extends State<SettingsScreen> {
     }
   }
 
+  Future<void> _syncServerPlaylists() async {
+    final playlistService = context.read<PlaylistService>();
+    if (!mounted) return;
+
+    ScaffoldMessenger.of(context).showSnackBar(
+      const SnackBar(content: Text('Lade Playlisten vom Server...')),
+    );
+
+    final count = await playlistService.syncPlaylistsFromServer();
+    if (mounted) {
+      if (count == 0) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          const SnackBar(content: Text('❌ Server nicht verbunden oder keine Playlisten')),
+        );
+      } else {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text('✅ $count Playlisten importiert')),
+        );
+      }
+    }
+  }
+
   String _formatBytes(int bytes) {
     if (bytes < 1024) return '$bytes B';
     if (bytes < 1024 * 1024) return '${(bytes / 1024).toStringAsFixed(1)} KB';