v2.54.1 — Queue zeigt echte Wiedergabe-Reihenfolge (inkl. Shuffle), aktuelles Lied markiert

lib/screens/now_playing_screen.dart

@@ -288,15 +288,12 @@ class _NowPlayingScreenState extends State<NowPlayingScreen>
     );
   }
 
-  /// Menü „Als Nächstes": zeigt die kommenden Songs der Warteschlange.
+  /// Menü „Als Nächstes": zeigt die kommenden Songs in der tatsächlichen
-  /// Tipp = Song wird als Nächstes gespielt (spieleAlsNaechstes).
+  /// Wiedergabe-Reihenfolge (inkl. Shuffle). Tipp = Song wird als Nächstes
+  /// gespielt (spieleAlsNaechstes).
   void _zeigePlayNextMenue() {
-    final queue = _player.warteschlange;
+    // Position 0 = aktuell spielender Song → nur die kommenden anzeigen
-    final aktuell = _player.aktuellerIndex;
+    final kommende = _player.wiedergabeReihenfolge.skip(1).toList();
-    final kommende = <Song>[];
-    for (var i = aktuell + 1; i < queue.length; i++) {
-      kommende.add(queue[i]);
-    }
     showModalBottomSheet(
       context: context,
       isScrollControlled: true,
@@ -356,7 +353,7 @@ class _NowPlayingScreenState extends State<NowPlayingScreen>
                     return ListTile(
                       dense: true,
                       leading: Text(
-                        '${aktuell + i + 2}',
+                        '${i + 1}', // Position in der Wiedergabe-Reihenfolge
                         style: const TextStyle(
                             fontSize: 11, color: MeloTheme.textSekundaer),
                       ),

lib/services/player_service.dart

@@ -341,6 +341,68 @@ class PlayerService extends ChangeNotifier {
   /// Index des aktuell spielenden Songs in der Warteschlange.
   int get aktuellerIndex => _aktuellerIndex;
 
+  /// Die tatsächliche Wiedergabe-Reihenfolge — beginnend mit dem aktuell
+  /// spielenden Song (Position 0). NICHT die Bibliotheks-Reihenfolge:
+  /// - Normal: Warteschlange ab dem aktuellen Index
+  /// - Shuffle: aktuelle Shuffle-Position + Rest der Zufallsreihenfolge
+  List<Song> get wiedergabeReihenfolge {
+    final ergebnis = <Song>[];
+    if (_warteschlange.isEmpty) return List.unmodifiable(ergebnis);
+    if (_aktuellerIndex >= 0 && _aktuellerIndex < _warteschlange.length) {
+      ergebnis.add(_warteschlange[_aktuellerIndex]);
+    }
+    if (_zufallsmodus) {
+      if (_shuffleReihenfolge.isNotEmpty) {
+        // _shufflePos == -1 → Shuffle gerade eingeschaltet, aktueller Song
+        // ist noch nicht in der Reihenfolge → ab Position 0 auflisten
+        final start = _shufflePos >= 0 ? _shufflePos + 1 : 0;
+        for (var i = start; i < _shuffleReihenfolge.length; i++) {
+          final idx = _shuffleReihenfolge[i];
+          if (idx >= 0 && idx < _warteschlange.length) {
+            ergebnis.add(_warteschlange[idx]);
+          }
+        }
+      }
+    } else {
+      for (var i = _aktuellerIndex + 1; i < _warteschlange.length; i++) {
+        ergebnis.add(_warteschlange[i]);
+      }
+    }
+    return List.unmodifiable(ergebnis);
+  }
+
+  /// Verschiebt einen Eintrag in der tatsächlichen Wiedergabe-Reihenfolge
+  /// (Drag-and-Drop im Queue-Sheet). Position 0 = aktuell spielender Song
+  /// (bleibt oben und kann nicht verschoben werden).
+  /// - Normal: verschiebt in der Warteschlange (ab dem aktuellen Index)
+  /// - Shuffle: verschiebt in der Zufallsreihenfolge — das ändert die echte
+  ///   Abspiel-Reihenfolge, ohne die Bibliotheks-Liste anzufassen
+  void verschiebeInWiedergabeReihenfolge(int von, int nach) {
+    if (von <= 0) return; // aktueller Song bleibt an Position 0
+    if (nach <= 0) nach = 1; // nie vor den aktuellen Song
+    if (von == nach) return;
+    if (_warteschlange.isEmpty) return;
+
+    if (_zufallsmodus) {
+      final start = _shufflePos >= 0 ? _shufflePos + 1 : 0;
+      final vonShuffle = start + von - 1;
+      final nachShuffle = start + nach - 1;
+      if (vonShuffle < 0 || vonShuffle >= _shuffleReihenfolge.length) return;
+      final item = _shuffleReihenfolge.removeAt(vonShuffle);
+      final ziel = nachShuffle > _shuffleReihenfolge.length
+          ? _shuffleReihenfolge.length
+          : nachShuffle;
+      _shuffleReihenfolge.insert(ziel, item);
+      notifyListeners();
+      return;
+    }
+
+    final vonQueue = _aktuellerIndex + von;
+    final nachQueue = _aktuellerIndex + nach;
+    if (vonQueue < 0 || vonQueue >= _warteschlange.length) return;
+    verschiebeInWarteschlange(vonQueue, nachQueue);
+  }
+
   /// Setzt [song] als nächstes auf die Wiedergabe — direkt nach dem aktuellen
   /// Song. Ist der Song bereits in der Warteschlange, wird er dorthin VERSCHOBEN
   /// statt dupliziert. Im Shuffle wird die Reihenfolge nicht neu gemischt:

lib/widgets/warteschlange_sheet.dart

@@ -37,8 +37,10 @@ class _WarteschlangeSheetState extends State<WarteschlangeSheet> {
     return ListenableBuilder(
       listenable: _player,
       builder: (context, _) {
-        final queue = _player.warteschlange;
+        // Echte Wiedergabe-Reihenfolge (Position 0 = aktuell spielender Song):
-        final aktueller = _player.aktuellerIndex;
+        // normal = Warteschlange ab aktuellem Index, Shuffle = Zufallsreihenfolge.
+        final reihenfolge = _player.wiedergabeReihenfolge;
+        final wiederholung = _player.wiederholmodus == Wiederholmodus.playlist;
         return SafeArea(
           child: Padding(
             padding: EdgeInsets.only(
@@ -78,7 +80,7 @@ class _WarteschlangeSheetState extends State<WarteschlangeSheet> {
                         ),
                         const SizedBox(width: 8),
                         Text(
-                          '${queue.length} Titel',
+                          '${reihenfolge.length} Titel',
                           style: const TextStyle(
                             fontSize: 12,
                             color: MeloTheme.textSekundaer,
@@ -96,8 +98,9 @@ class _WarteschlangeSheetState extends State<WarteschlangeSheet> {
                   const Divider(height: 1, color: MeloTheme.dunkel2),
                   _sleepTimerZeile(),
                   const Divider(height: 1, color: MeloTheme.dunkel2),
-                  // Liste
+                  // Liste: aktueller Song oben (markiert, nicht verschiebbar),
-                  if (queue.isEmpty)
+                  // danach die tatsächlichen nächsten Lieder (Drag = umsortieren)
+                  if (reihenfolge.isEmpty)
                     const Expanded(
                       child: Center(
                         child: Text(
@@ -106,18 +109,38 @@ class _WarteschlangeSheetState extends State<WarteschlangeSheet> {
                         ),
                       ),
                     )
-                  else
+                  else ...[
                     Flexible(
                       child: ReorderableListView.builder(
                         shrinkWrap: true,
-                        padding: const EdgeInsets.fromLTRB(8, 4, 8, 16),
+                        padding: const EdgeInsets.fromLTRB(8, 4, 8, 4),
-                        itemCount: queue.length,
+                        itemCount: reihenfolge.length,
+                        // Eigene Drag-Handles: nur kommende Songs sind
+                        // verschiebbar, der aktuelle bleibt oben gepinnt.
+                        buildDefaultDragHandles: false,
                         // onReorderItem liefert den newIndex bereits angepasst
                         onReorderItem: (alt, neu) =>
-                            _player.verschiebeInWarteschlange(alt, neu),
+                            _player.verschiebeInWiedergabeReihenfolge(alt, neu),
-                        itemBuilder: (_, i) => _eintrag(queue[i], i, aktueller),
+                        itemBuilder: (_, i) {
+                          // Der Key MUSS am obersten Widget des Items liegen
+                          // (Pflicht für ReorderableListView)
+                          final key = ValueKey(
+                              'pos$i-${reihenfolge[i].id ?? reihenfolge[i].titel}');
+                          final eintrag = _eintrag(reihenfolge[i], i);
+                          if (i == 0) {
+                            return KeyedSubtree(key: key, child: eintrag);
+                          }
+                          return ReorderableDelayedDragStartListener(
+                            key: key,
+                            index: i,
+                            child: eintrag,
+                          );
+                        },
                       ),
                     ),
+                    if (wiederholung)
+                      _wiederholungHinweis(),
+                  ],
                 ],
               ),
             ),
@@ -127,6 +150,32 @@ class _WarteschlangeSheetState extends State<WarteschlangeSheet> {
     );
   }
 
+  /// Hinweis am Listenende, wenn Repeat (Playlist) aktiv ist: Nach dem
+  /// letzten Eintrag beginnt die Wiedergabe wieder von vorn (bzw. wird
+  /// im Shuffle neu gemischt).
+  Widget _wiederholungHinweis() {
+    return Padding(
+      padding: const EdgeInsets.fromLTRB(20, 6, 20, 12),
+      child: Row(
+        children: [
+          const Icon(Icons.repeat, size: 14, color: MeloTheme.rot),
+          const SizedBox(width: 6),
+          Expanded(
+            child: Text(
+              _player.zufallsmodus
+                  ? 'Wiederholung aktiv — danach wird neu gemischt'
+                  : 'Wiederholung aktiv — danach geht es von vorn weiter',
+              style: const TextStyle(
+                fontSize: 11,
+                color: MeloTheme.textSekundaer,
+              ),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
   /// Sleep-Timer-Zeile: Optionen Aus/15/30/45/60 Min + Restzeit wenn aktiv
   Widget _sleepTimerZeile() {
     final aktiv = _player.sleepTimerAktiv;
@@ -196,27 +245,71 @@ class _WarteschlangeSheetState extends State<WarteschlangeSheet> {
     return '⏱ ${min.toString().padLeft(2, '0')}:${sek.toString().padLeft(2, '0')}';
   }
 
-  Widget _eintrag(Song song, int index, int aktueller) {
+  /// Ein Eintrag der Wiedergabe-Reihenfolge. Position 0 = aktuell spielender
-    final istAktuell = index == aktueller;
+  /// Song: deutlich markiert (▶ + Highlight-Hintergrund + „Jetzt spielt"-Chip).
+  Widget _eintrag(Song song, int position) {
+    final istAktuell = position == 0;
     return ListTile(
-      key: ValueKey('$index-${song.id ?? song.titel}'),
       dense: true,
+      // tileColor direkt am ListTile statt Container-Decoration: verhindert
+      // die „ListTile background color may be invisible"-Assertion
+      tileColor: istAktuell ? MeloTheme.rotHell : null,
+      shape: istAktuell
+          ? RoundedRectangleBorder(borderRadius: BorderRadius.circular(10))
+          : null,
       leading: istAktuell
-          ? const Icon(Icons.play_arrow, color: MeloTheme.rot, size: 18)
+          ? const Icon(Icons.play_arrow, color: MeloTheme.rot, size: 20)
           : SizedBox(
               width: 18,
               child: Text(
-                '${index + 1}',
+                '$position', // Position in der Wiedergabe-Reihenfolge
                 textAlign: TextAlign.center,
-                style: const TextStyle(fontSize: 11, color: MeloTheme.textSekundaer),
+                style: const TextStyle(
+                    fontSize: 11, color: MeloTheme.textSekundaer),
               ),
             ),
-      title: Text(
+      title: istAktuell
+          ? Row(
+              children: [
+                Expanded(
+                  child: Text(
                     song.titel,
-        style: TextStyle(
+                    maxLines: 1,
+                    overflow: TextOverflow.ellipsis,
+                    style: const TextStyle(
                       fontSize: 13,
-          fontWeight: istAktuell ? FontWeight.w700 : FontWeight.w400,
+                      fontWeight: FontWeight.w700,
-          color: istAktuell ? MeloTheme.rot : Colors.white,
+                      color: MeloTheme.rot,
+                    ),
+                  ),
+                ),
+                const SizedBox(width: 8),
+                Container(
+                  padding:
+                      const EdgeInsets.symmetric(horizontal: 8, vertical: 2),
+                  decoration: BoxDecoration(
+                    color: MeloTheme.rot,
+                    borderRadius: BorderRadius.circular(10),
+                  ),
+                  child: const Text(
+                    'Jetzt spielt',
+                    style: TextStyle(
+                      fontSize: 10,
+                      fontWeight: FontWeight.w600,
+                      color: Colors.white,
+                    ),
+                  ),
+                ),
+              ],
+            )
+          : Text(
+              song.titel,
+              maxLines: 1,
+              overflow: TextOverflow.ellipsis,
+              style: const TextStyle(
+                fontSize: 13,
+                fontWeight: FontWeight.w400,
+                color: Colors.white,
               ),
             ),
       subtitle: Text(

test/player_service_test.dart

@@ -1,4 +1,5 @@
 import 'package:flutter_test/flutter_test.dart';
+import 'package:melo_app/config/app_config.dart';
 import 'package:melo_app/models/song.dart';
 import 'package:melo_app/services/player_service.dart';
 
@@ -18,6 +19,9 @@ void main() {
     p.setWiederholmodus(Wiederholmodus.aus);
     p.cancelSleepTimer();
     p.setWarteschlange([]);
+    // spiele() mit ungültiger Quelle loggt einen Fehler — ohne Netzwerk-Send
+    // (sonst versucht der Test einen echten HTTP-Post an den Log-Server).
+    AppConfig.sendeDiagnosedaten = false;
   });
 
   group('Warteschlange', () {
@@ -200,6 +204,98 @@ void main() {
     });
   });
 
+  group('Wiedergabe-Reihenfolge (Queue zeigt echte Reihenfolge)', () {
+    test('normal: aktueller Song zuerst, dann der Rest der Warteschlange', () {
+      final p = PlayerService();
+      p.setWarteschlange(
+          [_song(1, 'A'), _song(2, 'B'), _song(3, 'C'), _song(4, 'D')],
+          startIndex: 1);
+      // NICHT die Bibliotheks-Liste [1,2,3,4] — sondern ab dem aktuellen Song
+      expect(p.wiedergabeReihenfolge.map((s) => s.id).toList(), [2, 3, 4]);
+    });
+
+    test('shuffle: folgt der Zufallsreihenfolge ab der aktuellen Position', () {
+      final p = PlayerService();
+      p.setWarteschlange([for (var i = 1; i <= 5; i++) _song(i, 'S$i')]);
+      p.setZufallsmodus(true);
+      final vorher = p.wiedergabeReihenfolge;
+      expect(vorher.length, 5);
+      expect(vorher.first.id, 1); // aktueller Song zuerst
+      expect(vorher.map((s) => s.id).toSet(), {1, 2, 3, 4, 5});
+      // Der erste kommende Eintrag ist exakt der, den naechsterIndex() spielt
+      // (naechsterIndex liefert Queue-Indizes, daher über die Warteschlange vergleichen)
+      final naechster = p.naechsterIndex();
+      expect(p.warteschlange[naechster!].id, vorher[1].id);
+    });
+
+    test('shuffle nach Songwechsel: beginnt mit dem neuen aktuellen Song', () {
+      final p = PlayerService();
+      p.setWarteschlange([for (var i = 1; i <= 5; i++) _song(i, 'S$i')]);
+      p.setZufallsmodus(true);
+      final naechster = p.naechsterIndex()!;
+      p.spiele(p.warteschlange[naechster]); // Shuffle-Position wird synchronisiert
+      final reihenfolge = p.wiedergabeReihenfolge;
+      expect(reihenfolge.first.id, p.warteschlange[naechster].id);
+      // Der beim Mischen ausgeschlossene Song (Index 0 / id 1) taucht erst
+      // wieder auf, wenn er manuell gewählt wird — der Rest der Rotation
+      // (4 Songs) ist vollständig enthalten
+      expect(reihenfolge.length, 4);
+      expect(reihenfolge.map((s) => s.id).toSet(), {2, 3, 4, 5});
+    });
+
+    test('shuffle mit Einzel-Song-Queue: nur der aktuelle Song', () {
+      final p = PlayerService();
+      p.setWarteschlange([_song(1, 'A')]);
+      p.setZufallsmodus(true);
+      expect(p.wiedergabeReihenfolge.map((s) => s.id).toList(), [1]);
+    });
+
+    test('verschieben (normal): ändert Wiedergabe-Reihenfolge und Queue', () {
+      final p = PlayerService();
+      p.setWarteschlange(
+          [_song(1, 'A'), _song(2, 'B'), _song(3, 'C'), _song(4, 'D')],
+          startIndex: 1);
+      p.verschiebeInWiedergabeReihenfolge(2, 1); // D vor C ziehen
+      expect(p.wiedergabeReihenfolge.map((s) => s.id).toList(), [2, 4, 3]);
+      expect(p.warteschlange.map((s) => s.id).toList(), [1, 2, 4, 3]);
+      expect(p.aktuellerIndex, 1); // aktueller Song bleibt an Position 0
+    });
+
+    test('verschieben (shuffle): ändert Zufallsreihenfolge, nicht die Queue', () {
+      final p = PlayerService();
+      p.setWarteschlange([for (var i = 1; i <= 5; i++) _song(i, 'S$i')]);
+      p.setZufallsmodus(true);
+      final vorher = p.wiedergabeReihenfolge;
+      p.verschiebeInWiedergabeReihenfolge(4, 1); // letzten vor den ersten Kommenden
+      final nachher = p.wiedergabeReihenfolge;
+      expect(nachher.length, vorher.length);
+      expect(nachher.map((s) => s.id).toSet(), vorher.map((s) => s.id).toSet());
+      expect(nachher[1].id, vorher[4].id);
+      expect(nachher[2].id, vorher[1].id);
+      // Bibliotheks-Queue bleibt unangetastet (Shuffle-Liste ist die Wiedergabe)
+      expect(p.warteschlange.map((s) => s.id).toList(), [1, 2, 3, 4, 5]);
+      // Der verschobene Song wird wirklich als Nächstes gespielt
+      final naechster = p.naechsterIndex();
+      expect(p.warteschlange[naechster!].id, nachher[1].id);
+    });
+
+    test('Position 0 (aktueller Song) kann nicht verschoben werden', () {
+      final p = PlayerService();
+      p.setWarteschlange([_song(1, 'A'), _song(2, 'B'), _song(3, 'C')]);
+      p.verschiebeInWiedergabeReihenfolge(0, 2); // von = aktueller Song → No-op
+      expect(p.warteschlange.map((s) => s.id).toList(), [1, 2, 3]);
+      // „Vor" den aktuellen Song ziehen landet auf Position 1 (danach)
+      p.verschiebeInWiedergabeReihenfolge(2, 0);
+      expect(p.warteschlange.map((s) => s.id).toList(), [1, 3, 2]);
+    });
+
+    test('leere Warteschlange: No-op', () {
+      final p = PlayerService();
+      p.verschiebeInWiedergabeReihenfolge(1, 2);
+      expect(p.wiedergabeReihenfolge, isEmpty);
+    });
+  });
+
   group('Sleep-Timer', () {
     test('setSleepTimer aktiviert + Restzeit vorhanden', () {
       final p = PlayerService();

test/widget_test.dart

@@ -1,12 +1,64 @@
 import 'package:flutter_test/flutter_test.dart';
 import 'package:flutter/material.dart';
+import 'package:melo_app/models/song.dart';
 import 'package:melo_app/screens/login_screen.dart';
+import 'package:melo_app/services/player_service.dart';
+import 'package:melo_app/widgets/warteschlange_sheet.dart';
+
+Song _song(int id, String titel) => Song(
+  id: id,
+  titel: titel,
+  kuenstler: 'Künstler $id',
+  dauerSekunden: 100,
+  dateiPfad: '',
+);
 
 void main() {
+  setUp(() {
+    // PlayerService ist ein Singleton — Zustand vor jedem Test zurücksetzen
+    final p = PlayerService();
+    p.setZufallsmodus(false);
+    p.setWiederholmodus(Wiederholmodus.aus);
+    p.cancelSleepTimer();
+    p.setWarteschlange([]);
+  });
+
   testWidgets('LoginScreen zeigt Anmelde-Felder', (WidgetTester tester) async {
     await tester.pumpWidget(const MaterialApp(home: LoginScreen()));
     await tester.pumpAndSettle();
     // Prüft dass was gerendert wird (kein Crash)
     expect(find.byType(TextField), findsWidgets);
   });
+
+  testWidgets('WarteschlangeSheet zeigt echte Wiedergabe-Reihenfolge',
+      (WidgetTester tester) async {
+    final p = PlayerService();
+    p.setWarteschlange(
+        [_song(1, 'Aktuell'), _song(2, 'Naechster'), _song(3, 'Danach')],
+        startIndex: 1);
+    await tester.pumpWidget(
+        const MaterialApp(home: Scaffold(body: WarteschlangeSheet())));
+    await tester.pump();
+
+    // Aktueller Song oben, deutlich markiert (▶ + „Jetzt spielt"-Chip)
+    expect(find.text('Jetzt spielt'), findsOneWidget);
+    expect(find.byIcon(Icons.play_arrow), findsOneWidget);
+    // Echte Reihenfolge: aktueller Song zuerst, dann die nächsten Lieder
+    expect(find.text('Naechster'), findsOneWidget);
+    expect(find.text('Danach'), findsOneWidget);
+    // Kopfzeile zählt die Wiedergabe-Reihenfolge (nicht die Bibliothek)
+    expect(find.text('2 Titel'), findsOneWidget);
+  });
+
+  testWidgets('WarteschlangeSheet zeigt Wiederholung-Hinweis bei Repeat',
+      (WidgetTester tester) async {
+    final p = PlayerService();
+    p.setWarteschlange([_song(1, 'A'), _song(2, 'B'), _song(3, 'C')]);
+    p.setWiederholmodus(Wiederholmodus.playlist);
+    await tester.pumpWidget(
+        const MaterialApp(home: Scaffold(body: WarteschlangeSheet())));
+    await tester.pump();
+
+    expect(find.textContaining('Wiederholung aktiv'), findsOneWidget);
+  });
 }