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

2026-08-05 12:20:32 +02:00
parent 8b6f0925a6
commit 5f7b652eb6
5 changed files with 333 additions and 33 deletions
@@ -288,15 +288,12 @@ class _NowPlayingScreenState extends State<NowPlayingScreen>
    );
  }

-  /// Menü „Als Nächstes": zeigt die kommenden Songs der Warteschlange.
-  /// Tipp = Song wird als Nächstes gespielt (spieleAlsNaechstes).
+  /// Menü „Als Nächstes": zeigt die kommenden Songs in der tatsächlichen
+  /// Wiedergabe-Reihenfolge (inkl. Shuffle). Tipp = Song wird als Nächstes
+  /// gespielt (spieleAlsNaechstes).
  void _zeigePlayNextMenue() {
-    final queue = _player.warteschlange;
-    final aktuell = _player.aktuellerIndex;
-    final kommende = <Song>[];
-    for (var i = aktuell + 1; i < queue.length; i++) {
-      kommende.add(queue[i]);
-    }
+    // Position 0 = aktuell spielender Song → nur die kommenden anzeigen
+    final kommende = _player.wiedergabeReihenfolge.skip(1).toList();
    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),
                      ),
@@ -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:
@@ -37,8 +37,10 @@ class _WarteschlangeSheetState extends State<WarteschlangeSheet> {
    return ListenableBuilder(
      listenable: _player,
      builder: (context, _) {
-        final queue = _player.warteschlange;
-        final aktueller = _player.aktuellerIndex;
+        // Echte Wiedergabe-Reihenfolge (Position 0 = aktuell spielender Song):
+        // 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
-                  if (queue.isEmpty)
+                  // Liste: aktueller Song oben (markiert, nicht verschiebbar),
+                  // 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),
-                        itemCount: queue.length,
+                        padding: const EdgeInsets.fromLTRB(8, 4, 8, 4),
+                        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),
-                        itemBuilder: (_, i) => _eintrag(queue[i], i, aktueller),
+                            _player.verschiebeInWiedergabeReihenfolge(alt, neu),
+                        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,29 +245,73 @@ class _WarteschlangeSheetState extends State<WarteschlangeSheet> {
    return '⏱ ${min.toString().padLeft(2, '0')}:${sek.toString().padLeft(2, '0')}';
  }

-  Widget _eintrag(Song song, int index, int aktueller) {
-    final istAktuell = index == aktueller;
+  /// Ein Eintrag der Wiedergabe-Reihenfolge. Position 0 = aktuell spielender
+  /// 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: istAktuell
+          ? Row(
+              children: [
+                Expanded(
+                  child: Text(
+                    song.titel,
+                    maxLines: 1,
+                    overflow: TextOverflow.ellipsis,
+                    style: const TextStyle(
+                      fontSize: 13,
+                      fontWeight: FontWeight.w700,
+                      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,
              ),
            ),
-      title: Text(
-        song.titel,
-        style: TextStyle(
-          fontSize: 13,
-          fontWeight: istAktuell ? FontWeight.w700 : FontWeight.w400,
-          color: istAktuell ? MeloTheme.rot : Colors.white,
-        ),
-      ),
      subtitle: Text(
        song.kuenstler,
        style: const TextStyle(fontSize: 11, color: MeloTheme.textSekundaer),