Welcome screen first-use only + bump version to 2.6.0-beta

- Welcome screen now only shows on first app launch
- Added hasCompletedOnboarding setting (separate from showHints)
- Onboarding marked complete when user skips or swipes to reveal
- Version bumped to 2.6.0-beta+28

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

lib/database/database.dart

@@ -153,12 +153,27 @@ class CachedQueue extends Table {
   IntColumn get position => integer()();
 }
 
-@DriftDatabase(tables: [Profiles, RecentlyPlayed, LibraryCache, SyncMetadata, PlaybackState, CachedPlayers, CachedQueue])
+/// Cached home row data for instant display on startup
+class HomeRowCache extends Table {
+  /// Row type: 'recent_albums', 'discover_artists', 'discover_albums'
+  TextColumn get rowType => text()();
+
+  /// Serialized list of items as JSON array
+  TextColumn get itemsJson => text()();
+
+  /// When this was last updated
+  DateTimeColumn get lastUpdated => dateTime()();
+
+  @override
+  Set<Column> get primaryKey => {rowType};
+}
+
+@DriftDatabase(tables: [Profiles, RecentlyPlayed, LibraryCache, SyncMetadata, PlaybackState, CachedPlayers, CachedQueue, HomeRowCache])
 class AppDatabase extends _$AppDatabase {
   AppDatabase([QueryExecutor? executor]) : super(executor ?? _openConnection());
 
   @override
-  int get schemaVersion => 2;
+  int get schemaVersion => 3;
 
   @override
   MigrationStrategy get migration {
@@ -173,6 +188,10 @@ class AppDatabase extends _$AppDatabase {
           await m.createTable(cachedPlayers);
           await m.createTable(cachedQueue);
         }
+        // Migration from v2 to v3: Add home row cache table
+        if (from < 3) {
+          await m.createTable(homeRowCache);
+        }
       },
     );
   }
@@ -524,4 +543,30 @@ class AppDatabase extends _$AppDatabase {
   Future<void> clearAllCachedQueues() async {
     await delete(cachedQueue).go();
   }
+
+  // ============================================
+  // Home Row Cache Operations
+  // ============================================
+
+  /// Save home row data
+  Future<void> saveHomeRowCache(String rowType, String itemsJson) async {
+    await into(homeRowCache).insertOnConflictUpdate(
+      HomeRowCacheCompanion(
+        rowType: Value(rowType),
+        itemsJson: Value(itemsJson),
+        lastUpdated: Value(DateTime.now()),
+      ),
+    );
+  }
+
+  /// Get cached home row data
+  Future<HomeRowCacheData?> getHomeRowCache(String rowType) async {
+    return (select(homeRowCache)..where((h) => h.rowType.equals(rowType)))
+        .getSingleOrNull();
+  }
+
+  /// Clear all home row cache
+  Future<void> clearHomeRowCache() async {
+    await delete(homeRowCache).go();
+  }
 }

lib/l10n/app_de.arb

@@ -281,5 +281,10 @@
   "playerStateIdle": "Inaktiv",
   "playerSelected": "Ausgewählt",
   "actionQueuedForSync": "Wird synchronisiert wenn online",
-  "pendingOfflineActions": "{count} ausstehende Synchronisierung"
+  "pendingOfflineActions": "{count} ausstehende Synchronisierung",
+  "hintsAndTips": "Tipps & Hinweise",
+  "showHints": "Hinweise anzeigen",
+  "showHintsDescription": "Hilfreiche Tipps zum Entdecken von Funktionen anzeigen",
+  "pullToSelectPlayers": "Ziehen um Geräte auszuwählen",
+  "holdToSync": "Gerät gedrückt halten zum Synchronisieren"
 }

lib/l10n/app_en.arb

@@ -1078,7 +1078,7 @@
     "description": "Hint for Last.fm API key field"
   },
 
-  "swipeToSwitchDevice": "Swipe to switch device",
+  "swipeToSwitchDevice": "Swipe to change player",
   "@swipeToSwitchDevice": {
     "description": "Hint for device switching gesture"
   },
@@ -1211,5 +1211,55 @@
         "type": "int"
       }
     }
+  },
+
+  "hintsAndTips": "Hints & Tips",
+  "@hintsAndTips": {
+    "description": "Settings section title for hints"
+  },
+
+  "showHints": "Show Hints",
+  "@showHints": {
+    "description": "Toggle label for showing hints"
+  },
+
+  "showHintsDescription": "Display helpful tips for discovering features",
+  "@showHintsDescription": {
+    "description": "Description for show hints toggle"
+  },
+
+  "pullToSelectPlayers": "Pull to select players",
+  "@pullToSelectPlayers": {
+    "description": "Hint shown when mini player bounces"
+  },
+
+  "holdToSync": "Tap and hold a player to sync",
+  "@holdToSync": {
+    "description": "Hint for long-press to sync players"
+  },
+
+  "selectPlayerHint": "Choose a player, or dismiss by swiping down",
+  "@selectPlayerHint": {
+    "description": "First-time hint for selecting a player in device selector"
+  },
+
+  "welcomeToEnsemble": "Welcome to Ensemble",
+  "@welcomeToEnsemble": {
+    "description": "Welcome message title for onboarding"
+  },
+
+  "welcomeMessage": "By default your phone is the selected player.\nPull the mini player down to select another player.",
+  "@welcomeMessage": {
+    "description": "Welcome message body explaining how to select players"
+  },
+
+  "skip": "Skip",
+  "@skip": {
+    "description": "Button to skip onboarding or hints"
+  },
+
+  "dismissPlayerHint": "Swipe down, tap outside, or press back to return",
+  "@dismissPlayerHint": {
+    "description": "Hint explaining how to dismiss the player selector"
   }
 }

lib/l10n/app_es.arb

@@ -434,7 +434,7 @@
   "metadataApisDescription": "Las imágenes de artistas se obtienen automáticamente de Deezer. Añade claves API a continuación para biografías de artistas y descripciones de álbumes.",
   "lastFmApiKey": "Clave API de Last.fm",
   "lastFmApiKeyHint": "Obtén una clave gratuita en last.fm/api",
-  "swipeToSwitchDevice": "Desliza para cambiar de dispositivo",
+  "swipeToSwitchDevice": "Desliza para cambiar dispositivo",
   "chapterNumber": "Capítulo {number}",
   "@chapterNumber": {
     "placeholders": {
@@ -477,5 +477,10 @@
   "playerStateIdle": "Inactivo",
   "playerSelected": "Seleccionado",
   "actionQueuedForSync": "Se sincronizará cuando esté en línea",
-  "pendingOfflineActions": "{count} sincronización pendiente"
+  "pendingOfflineActions": "{count} sincronización pendiente",
+  "hintsAndTips": "Consejos y Sugerencias",
+  "showHints": "Mostrar Sugerencias",
+  "showHintsDescription": "Mostrar consejos útiles para descubrir funciones",
+  "pullToSelectPlayers": "Desliza para seleccionar dispositivos",
+  "holdToSync": "Mantén presionado un dispositivo para sincronizar"
 }

lib/providers/music_assistant_provider.dart

@@ -51,6 +51,7 @@ class MusicAssistantProvider with ChangeNotifier {
   List<Artist> _artists = [];
   List<Album> _albums = [];
   List<Track> _tracks = [];
+  List<Track> _cachedFavoriteTracks = []; // Cached for instant display before full library loads
   bool _isLoading = false;
 
   // Player state
@@ -221,6 +222,15 @@ class MusicAssistantProvider with ChangeNotifier {
     // Load cached players from database for instant display (before connecting)
     await _loadPlayersFromDatabase();
 
+    // Load cached library from SyncService for instant favorites display
+    await _loadLibraryFromCache();
+
+    // Load cached favorite tracks from database (tracks aren't in SyncService)
+    await _loadFavoriteTracksFromDatabase();
+
+    // Load cached home rows from database for instant discover/recent display
+    await _cacheService.loadHomeRowsFromDatabase();
+
     // Initialize offline action queue
     await OfflineActionQueue.instance.initialize();
 
@@ -272,12 +282,122 @@ class MusicAssistantProvider with ChangeNotifier {
 
         _logger.log('📦 Loaded ${players.length} players from database (instant)');
         notifyListeners();
+
+        // Also load saved playback state for instant track display
+        if (_selectedPlayer != null) {
+          await _loadPlaybackStateFromDatabase();
+        }
       }
     } catch (e) {
       _logger.log('⚠️ Error loading players from database: $e');
     }
   }
 
+  /// Load saved playback state (currentTrack) from database for instant display
+  Future<void> _loadPlaybackStateFromDatabase() async {
+    try {
+      final playbackState = await DatabaseService.instance.getPlaybackState();
+      if (playbackState == null) {
+        _logger.log('📦 No saved playback state in database');
+        return;
+      }
+
+      // Only restore if it matches the current player
+      if (playbackState.playerId != _selectedPlayer?.playerId) {
+        _logger.log('📦 Saved playback state is for different player, skipping');
+        return;
+      }
+
+      if (playbackState.currentTrackJson != null) {
+        try {
+          final trackData = jsonDecode(playbackState.currentTrackJson!) as Map<String, dynamic>;
+          _currentTrack = Track.fromJson(trackData);
+          _logger.log('📦 Restored currentTrack from database: ${_currentTrack?.name}');
+          notifyListeners();
+        } catch (e) {
+          _logger.log('⚠️ Error parsing cached track: $e');
+        }
+      }
+    } catch (e) {
+      _logger.log('⚠️ Error loading playback state: $e');
+    }
+  }
+
+  /// Load library data from SyncService cache for instant favorites display
+  Future<void> _loadLibraryFromCache() async {
+    try {
+      final syncService = SyncService.instance;
+
+      // Ensure SyncService has loaded from database
+      if (!syncService.hasCache) {
+        await syncService.loadFromCache();
+      }
+
+      if (syncService.hasCache) {
+        _albums = syncService.cachedAlbums;
+        _artists = syncService.cachedArtists;
+        // Note: tracks are loaded separately via API, not cached in SyncService
+        _logger.log('📦 Pre-loaded library for favorites: ${_albums.length} albums, ${_artists.length} artists');
+        notifyListeners();
+      }
+    } catch (e) {
+      _logger.log('⚠️ Error loading library from cache: $e');
+    }
+  }
+
+  /// Persist current playback state to database (fire-and-forget)
+  void _persistPlaybackState() {
+    if (_selectedPlayer == null) return;
+
+    () async {
+      try {
+        if (!DatabaseService.instance.isInitialized) return;
+
+        await DatabaseService.instance.savePlaybackState(
+          playerId: _selectedPlayer!.playerId,
+          playerName: _selectedPlayer!.name,
+          currentTrackJson: _currentTrack != null ? jsonEncode(_currentTrack!.toJson()) : null,
+          isPlaying: _selectedPlayer!.state == 'playing',
+        );
+        _logger.log('💾 Persisted playback state to database');
+      } catch (e) {
+        _logger.log('⚠️ Error persisting playback state: $e');
+      }
+    }();
+  }
+
+  /// Persist favorite tracks to database (fire-and-forget)
+  void _persistFavoriteTracks(List<Track> tracks) {
+    () async {
+      try {
+        if (!DatabaseService.instance.isInitialized) return;
+        final tracksJson = jsonEncode(tracks.map((t) => t.toJson()).toList());
+        await DatabaseService.instance.saveHomeRowCache('favorite_tracks', tracksJson);
+        _logger.log('💾 Persisted ${tracks.length} favorite tracks to database');
+      } catch (e) {
+        _logger.log('⚠️ Error persisting favorite tracks: $e');
+      }
+    }();
+  }
+
+  /// Load cached favorite tracks from database
+  Future<void> _loadFavoriteTracksFromDatabase() async {
+    try {
+      if (!DatabaseService.instance.isInitialized) return;
+
+      final data = await DatabaseService.instance.getHomeRowCache('favorite_tracks');
+      if (data == null) return;
+
+      final items = (jsonDecode(data.itemsJson) as List)
+          .map((json) => Track.fromJson(json as Map<String, dynamic>))
+          .toList();
+      _cachedFavoriteTracks = items;
+      _logger.log('📦 Loaded ${items.length} cached favorite tracks from database');
+    } catch (e) {
+      _logger.log('⚠️ Error loading favorite tracks: $e');
+    }
+  }
+
   /// Persist players to database for app restart persistence
   void _persistPlayersToDatabase(List<Player> players) {
     // Run async but don't await - this is fire-and-forget persistence
@@ -1758,8 +1878,18 @@ class MusicAssistantProvider with ChangeNotifier {
 
   /// Get favorite tracks from the library
   Future<List<Track>> getFavoriteTracks() async {
-    // Filter from loaded library - favorites are already loaded
+    // If full tracks list is loaded, filter from it
-    return _tracks.where((t) => t.favorite == true).toList();
+    if (_tracks.isNotEmpty) {
+      final favTracks = _tracks.where((t) => t.favorite == true).toList();
+      // Update cache if we have new data
+      if (favTracks.isNotEmpty && favTracks.length != _cachedFavoriteTracks.length) {
+        _cachedFavoriteTracks = favTracks;
+        _persistFavoriteTracks(favTracks);
+      }
+      return favTracks;
+    }
+    // Otherwise return cached favorites (for instant display before full library loads)
+    return _cachedFavoriteTracks;
   }
 
   // ============================================================================
@@ -2057,8 +2187,9 @@ class MusicAssistantProvider with ChangeNotifier {
           .where((p) => p.name.endsWith(sendspinSuffix))
           .toList();
 
-      // Clear the Cast-to-Sendspin ID mapping
+      // NOTE: Don't clear _castToSendspinIdMap - we want to remember mappings
-      _castToSendspinIdMap = {};
+      // even when the Sendspin player is temporarily unavailable (e.g., device off)
+      // This allows syncing to work when the device powers back on
 
       if (sendspinPlayers.isNotEmpty) {
         // Build maps for Sendspin players and their grouped status
@@ -2728,6 +2859,8 @@ class MusicAssistantProvider with ChangeNotifier {
         if (_currentTrack != null) {
           _currentTrack = null;
           stateChanged = true;
+          // Persist cleared track state
+          _persistPlaybackState();
         }
         // Clear audiobook context when playback stops
         if (_currentAudiobook != null) {
@@ -2798,6 +2931,9 @@ class MusicAssistantProvider with ChangeNotifier {
           }
           stateChanged = true;
 
+          // Persist the updated playback state to database for instant restore on next launch
+          _persistPlaybackState();
+
           // Clear audiobook context if switched to a different media item
           // Check if the new track is from the same audiobook (by comparing URIs)
           if (_currentAudiobook != null) {
@@ -2868,6 +3004,8 @@ class MusicAssistantProvider with ChangeNotifier {
         if (_currentTrack != null) {
           _currentTrack = null;
           stateChanged = true;
+          // Persist cleared track state
+          _persistPlaybackState();
         }
 
         // Show player name placeholder so notification shows correct player
@@ -3476,6 +3614,7 @@ class MusicAssistantProvider with ChangeNotifier {
   }
 
   /// Toggle sync state: if player is synced, unsync it; otherwise sync to selected
+  /// For Cast/Sendspin players that are powered off, powers on first then syncs
   Future<void> togglePlayerSync(String playerId) async {
     _logger.log('🔗 togglePlayerSync called for: $playerId');
 
@@ -3487,13 +3626,52 @@ class MusicAssistantProvider with ChangeNotifier {
 
       _logger.log('🔗 Player found: ${player.name}, isGrouped: ${player.isGrouped}');
       _logger.log('🔗 groupMembers: ${player.groupMembers}, syncedTo: ${player.syncedTo}');
+      _logger.log('🔗 powered: ${player.powered}, available: ${player.available}');
 
       if (player.isGrouped) {
         _logger.log('🔓 Player is grouped, unsyncing...');
         await unsyncPlayer(playerId);
       } else {
-        _logger.log('🔗 Player not grouped, syncing to selected...');
+        // Check if this is a Cast player with a Sendspin counterpart that's powered off
-        await syncPlayerToSelected(playerId);
+        final hasSendspinCounterpart = _castToSendspinIdMap.containsKey(playerId);
+
+        if (hasSendspinCounterpart && !player.powered) {
+          _logger.log('🔌 Cast/Sendspin player is off, powering on first...');
+
+          // Power on the Cast player
+          await _api?.setPower(playerId, true);
+
+          // Wait for the player to power on and Sendspin to become ready
+          _logger.log('🔗 Waiting for player to power on...');
+
+          // Poll for up to 10 seconds for the player to be powered and available
+          const maxAttempts = 20;
+          const pollInterval = Duration(milliseconds: 500);
+
+          for (var attempt = 0; attempt < maxAttempts; attempt++) {
+            await Future.delayed(pollInterval);
+            await refreshPlayers();
+
+            // Check if the Cast player is now powered on
+            final updatedPlayer = _availablePlayers.where(
+              (p) => p.playerId == playerId
+            ).firstOrNull;
+
+            if (updatedPlayer != null && updatedPlayer.powered && updatedPlayer.available) {
+              _logger.log('✅ Player powered on, syncing...');
+              await syncPlayerToSelected(playerId);
+              return;
+            }
+
+            _logger.log('⏳ Attempt ${attempt + 1}/$maxAttempts - waiting for power on...');
+          }
+
+          _logger.log('⚠️ Timeout waiting for power on, attempting sync anyway...');
+          await syncPlayerToSelected(playerId);
+        } else {
+          _logger.log('🔗 Player not grouped, syncing to selected...');
+          await syncPlayerToSelected(playerId);
+        }
       }
     } catch (e) {
       _logger.log('❌ togglePlayerSync error: $e');

lib/screens/settings_screen.dart

@@ -41,6 +41,8 @@ class _SettingsScreenState extends State<SettingsScreen> {
   // Player settings
   bool _preferLocalPlayer = false;
   bool _smartSortPlayers = false;
+  // Hint settings
+  bool _showHints = true;
 
   @override
   void initState() {
@@ -89,6 +91,9 @@ class _SettingsScreenState extends State<SettingsScreen> {
     final preferLocal = await SettingsService.getPreferLocalPlayer();
     final smartSort = await SettingsService.getSmartSortPlayers();
 
+    // Load hint settings
+    final showHints = await SettingsService.getShowHints();
+
     if (mounted) {
       setState(() {
         _showRecentAlbums = showRecent;
@@ -105,6 +110,7 @@ class _SettingsScreenState extends State<SettingsScreen> {
         _libraryEnabled = libraryEnabled;
         _preferLocalPlayer = preferLocal;
         _smartSortPlayers = smartSort;
+        _showHints = showHints;
       });
     }
   }
@@ -699,6 +705,46 @@ class _SettingsScreenState extends State<SettingsScreen> {
 
             const SizedBox(height: 32),
 
+            // Hints & Tips section
+            Text(
+              S.of(context)!.hintsAndTips,
+              style: textTheme.titleMedium?.copyWith(
+                color: colorScheme.onBackground,
+                fontWeight: FontWeight.bold,
+              ),
+            ),
+            const SizedBox(height: 8),
+            Text(
+              S.of(context)!.showHintsDescription,
+              style: textTheme.bodySmall?.copyWith(
+                color: colorScheme.onBackground.withOpacity(0.6),
+              ),
+            ),
+            const SizedBox(height: 16),
+
+            Container(
+              padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
+              decoration: BoxDecoration(
+                color: colorScheme.surfaceVariant.withOpacity(0.3),
+                borderRadius: BorderRadius.circular(12),
+              ),
+              child: SwitchListTile(
+                title: Text(
+                  S.of(context)!.showHints,
+                  style: TextStyle(color: colorScheme.onSurface),
+                ),
+                value: _showHints,
+                onChanged: (value) {
+                  setState(() => _showHints = value);
+                  SettingsService.setShowHints(value);
+                },
+                activeColor: colorScheme.primary,
+                contentPadding: EdgeInsets.zero,
+              ),
+            ),
+
+            const SizedBox(height: 32),
+
             // Home Screen section
             Text(
               S.of(context)!.homeScreen,

lib/services/cache_service.dart

@@ -1,12 +1,15 @@
+import 'dart:convert';
 import '../models/media_item.dart';
 import '../models/player.dart';
 import '../services/debug_logger.dart';
+import '../services/database_service.dart';
 import '../constants/timings.dart';
 
 /// Centralized cache service for all app data caching
 /// This is a non-notifying service - it just stores and retrieves cached data
 class CacheService {
   final DebugLogger _logger = DebugLogger();
+  bool _homeRowsLoaded = false;
 
   // Home screen row caching
   List<Album>? _cachedRecentAlbums;
@@ -57,6 +60,8 @@ class CacheService {
     _cachedRecentAlbums = albums;
     _recentAlbumsLastFetched = DateTime.now();
     _logger.log('✅ Cached ${albums.length} recent albums');
+    // Persist to database for instant load on next launch
+    _persistHomeRowToDatabase('recent_albums', albums.map((a) => a.toJson()).toList());
   }
 
   /// Check if discover artists cache is valid
@@ -76,6 +81,8 @@ class CacheService {
     _cachedDiscoverArtists = artists;
     _discoverArtistsLastFetched = DateTime.now();
     _logger.log('✅ Cached ${artists.length} discover artists');
+    // Persist to database for instant load on next launch
+    _persistHomeRowToDatabase('discover_artists', artists.map((a) => a.toJson()).toList());
   }
 
   /// Check if discover albums cache is valid
@@ -95,6 +102,8 @@ class CacheService {
     _cachedDiscoverAlbums = albums;
     _discoverAlbumsLastFetched = DateTime.now();
     _logger.log('✅ Cached ${albums.length} discover albums');
+    // Persist to database for instant load on next launch
+    _persistHomeRowToDatabase('discover_albums', albums.map((a) => a.toJson()).toList());
   }
 
   /// Invalidate home screen cache (call on pull-to-refresh)
@@ -276,4 +285,78 @@ class CacheService {
     _cachedSelectedPlayer = null;
     _playersLastFetched = null;
   }
+
+  // ============================================================================
+  // DATABASE PERSISTENCE FOR HOME ROWS
+  // ============================================================================
+
+  /// Load home row data from database for instant display on startup
+  Future<void> loadHomeRowsFromDatabase() async {
+    if (_homeRowsLoaded) return;
+    _homeRowsLoaded = true;
+
+    try {
+      if (!DatabaseService.instance.isInitialized) return;
+
+      // Load recent albums
+      final recentData = await DatabaseService.instance.getHomeRowCache('recent_albums');
+      if (recentData != null) {
+        try {
+          final items = (jsonDecode(recentData.itemsJson) as List)
+              .map((json) => Album.fromJson(json as Map<String, dynamic>))
+              .toList();
+          _cachedRecentAlbums = items;
+          _recentAlbumsLastFetched = recentData.lastUpdated;
+          _logger.log('📦 Loaded ${items.length} recent albums from database');
+        } catch (e) {
+          _logger.log('⚠️ Failed to parse recent albums: $e');
+        }
+      }
+
+      // Load discover artists
+      final artistsData = await DatabaseService.instance.getHomeRowCache('discover_artists');
+      if (artistsData != null) {
+        try {
+          final items = (jsonDecode(artistsData.itemsJson) as List)
+              .map((json) => Artist.fromJson(json as Map<String, dynamic>))
+              .toList();
+          _cachedDiscoverArtists = items;
+          _discoverArtistsLastFetched = artistsData.lastUpdated;
+          _logger.log('📦 Loaded ${items.length} discover artists from database');
+        } catch (e) {
+          _logger.log('⚠️ Failed to parse discover artists: $e');
+        }
+      }
+
+      // Load discover albums
+      final albumsData = await DatabaseService.instance.getHomeRowCache('discover_albums');
+      if (albumsData != null) {
+        try {
+          final items = (jsonDecode(albumsData.itemsJson) as List)
+              .map((json) => Album.fromJson(json as Map<String, dynamic>))
+              .toList();
+          _cachedDiscoverAlbums = items;
+          _discoverAlbumsLastFetched = albumsData.lastUpdated;
+          _logger.log('📦 Loaded ${items.length} discover albums from database');
+        } catch (e) {
+          _logger.log('⚠️ Failed to parse discover albums: $e');
+        }
+      }
+    } catch (e) {
+      _logger.log('⚠️ Error loading home rows from database: $e');
+    }
+  }
+
+  /// Persist home row data to database (fire-and-forget)
+  void _persistHomeRowToDatabase(String rowType, List<Map<String, dynamic>> items) {
+    () async {
+      try {
+        if (!DatabaseService.instance.isInitialized) return;
+        await DatabaseService.instance.saveHomeRowCache(rowType, jsonEncode(items));
+        _logger.log('💾 Persisted $rowType to database');
+      } catch (e) {
+        _logger.log('⚠️ Failed to persist $rowType: $e');
+      }
+    }();
+  }
 }

lib/services/database_service.dart

@@ -222,4 +222,21 @@ class DatabaseService {
 
   /// Clear queue for a player
   Future<void> clearCachedQueue(String playerId) => db.clearCachedQueue(playerId);
+
+  // ============================================
+  // Home Row Cache Convenience Methods
+  // ============================================
+
+  /// Save home row data (recent albums, discover artists, etc.)
+  Future<void> saveHomeRowCache(String rowType, String itemsJson) {
+    return db.saveHomeRowCache(rowType, itemsJson);
+  }
+
+  /// Get cached home row data
+  Future<HomeRowCacheData?> getHomeRowCache(String rowType) {
+    return db.getHomeRowCache(rowType);
+  }
+
+  /// Clear all home row cache
+  Future<void> clearHomeRowCache() => db.clearHomeRowCache();
 }

lib/services/settings_service.dart

@@ -74,6 +74,11 @@ class SettingsService {
   static const String _keyEnabledAbsLibraries = 'enabled_abs_libraries'; // JSON list of library paths
   static const String _keyDiscoveredAbsLibraries = 'discovered_abs_libraries'; // JSON list of {path, name}
 
+  // Hint System Settings
+  static const String _keyShowHints = 'show_hints'; // Master toggle for hints
+  static const String _keyHasUsedPlayerReveal = 'has_used_player_reveal'; // Track if user has pulled to reveal players
+  static const String _keyHasCompletedOnboarding = 'has_completed_onboarding'; // Track if user has seen welcome screen
+
   static Future<String?> getServerUrl() async {
     final prefs = await SharedPreferences.getInstance();
     return prefs.getString(_keyServerUrl);
@@ -762,4 +767,42 @@ class SettingsService {
 
     await setEnabledAbsLibraries(enabled);
   }
+
+  // Hint System Settings
+
+  /// Get whether hints are enabled (default: true)
+  static Future<bool> getShowHints() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyShowHints) ?? true;
+  }
+
+  /// Set whether hints are enabled
+  static Future<void> setShowHints(bool show) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyShowHints, show);
+  }
+
+  /// Check if user has ever used the player reveal gesture
+  static Future<bool> getHasUsedPlayerReveal() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyHasUsedPlayerReveal) ?? false;
+  }
+
+  /// Mark that user has used the player reveal gesture
+  static Future<void> setHasUsedPlayerReveal(bool hasUsed) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyHasUsedPlayerReveal, hasUsed);
+  }
+
+  /// Check if user has completed onboarding (seen welcome screen)
+  static Future<bool> getHasCompletedOnboarding() async {
+    final prefs = await SharedPreferences.getInstance();
+    return prefs.getBool(_keyHasCompletedOnboarding) ?? false;
+  }
+
+  /// Mark that user has completed onboarding
+  static Future<void> setHasCompletedOnboarding(bool completed) async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setBool(_keyHasCompletedOnboarding, completed);
+  }
 }

lib/widgets/expandable_player.dart

@@ -36,12 +36,17 @@ class ExpandablePlayer extends StatefulWidget {
   /// When true, shows player name instead of track name in collapsed state
   final bool isDeviceRevealVisible;
 
+  /// Whether the hint text should be shown
+  /// When true, shows "Pull to select players" instead of track info
+  final bool isHintVisible;
+
   const ExpandablePlayer({
     super.key,
     this.slideOffset = 0.0,
     this.bounceOffset = 0.0,
     this.onRevealPlayers,
     this.isDeviceRevealVisible = false,
+    this.isHintVisible = false,
   });
 
   @override
@@ -1483,11 +1488,48 @@ class ExpandablePlayerState extends State<ExpandablePlayer>
                   ),
 
                 // Track title - with slide animation when collapsed
+                // When hint is visible, show lightbulb icon + "Pull to select players"
                 // When device reveal is visible, show player name instead of track name
                 // Hidden during transition to prevent flash
                 // FALLBACK: Show if transition active but no peek content available
                 // GPU PERF: Use conditional instead of Opacity to avoid saveLayer
-                if (!(_inTransition && t < 0.1 && _peekPlayer != null))
+                // Hint text - vertically centered in mini player
+                if (widget.isHintVisible && t < 0.5 && !(_inTransition && t < 0.1 && _peekPlayer != null))
+                  Positioned(
+                    left: titleLeft + miniPlayerSlideOffset,
+                    // Center vertically: (64 - ~20) / 2 = 22
+                    top: (MiniPlayerLayout.height - 20) / 2,
+                    child: SizedBox(
+                      width: titleWidth,
+                      child: Row(
+                        mainAxisSize: MainAxisSize.min,
+                        children: [
+                          Icon(
+                            Icons.lightbulb_outline,
+                            size: 16,
+                            color: textColor,
+                          ),
+                          const SizedBox(width: 6),
+                          Flexible(
+                            child: Text(
+                              S.of(context)!.pullToSelectPlayers,
+                              style: TextStyle(
+                                color: textColor,
+                                fontSize: titleFontSize,
+                                fontWeight: MiniPlayerLayout.primaryFontWeight,
+                              ),
+                              maxLines: 1,
+                              overflow: TextOverflow.ellipsis,
+                            ),
+                          ),
+                        ],
+                      ),
+                    ),
+                  ),
+
+                // Track title - with slide animation when collapsed
+                // Hidden when hint is visible
+                if (!(widget.isHintVisible && t < 0.5) && !(_inTransition && t < 0.1 && _peekPlayer != null))
                   Positioned(
                     left: titleLeft + miniPlayerSlideOffset,
                     top: titleTop,
@@ -1514,24 +1556,23 @@ class ExpandablePlayerState extends State<ExpandablePlayer>
                   ),
 
                 // Artist/Author name - with slide animation when collapsed
+                // When hint is visible, show blank line
                 // When device reveal is visible, show "Now Playing" hint
                 // For audiobooks: show author from audiobook context
                 // Hidden during transition to prevent flash
                 // FALLBACK: Show if transition active but no peek content available
                 // GPU PERF: Use conditional instead of Opacity to avoid saveLayer
-                if (!(_inTransition && t < 0.1 && _peekPlayer != null))
+                if (!(_inTransition && t < 0.1 && _peekPlayer != null) && !(widget.isHintVisible && t < 0.5))
                   Positioned(
                     left: titleLeft + miniPlayerSlideOffset,
                     top: artistTop,
                     child: SizedBox(
                       width: titleWidth,
                       child: Text(
-                        // Show "Now Playing" when device reveal visible and collapsed
+                        // Always show artist/author (was showing "Now Playing" when device reveal visible)
-                        (widget.isDeviceRevealVisible && t < 0.5)
+                        maProvider.isPlayingAudiobook
-                            ? S.of(context)!.nowPlaying
+                            ? (maProvider.currentAudiobook?.authorsString ?? S.of(context)!.unknownAuthor)
-                            : maProvider.isPlayingAudiobook
+                            : currentTrack.artistsString,
-                                ? (maProvider.currentAudiobook?.authorsString ?? S.of(context)!.unknownAuthor)
-                                : currentTrack.artistsString,
                         style: TextStyle(
                           color: textColor.withOpacity(t > 0.5 ? 0.7 : MiniPlayerLayout.secondaryTextOpacity),
                           fontSize: artistFontSize,

lib/widgets/global_player_overlay.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:ui';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
@@ -5,6 +6,7 @@ import 'package:provider/provider.dart';
 import '../l10n/app_localizations.dart';
 import '../providers/music_assistant_provider.dart';
 import '../providers/navigation_provider.dart';
+import '../services/settings_service.dart';
 import '../theme/theme_provider.dart';
 import 'expandable_player.dart';
 import 'player/player_reveal_overlay.dart';
@@ -130,7 +132,7 @@ class GlobalPlayerOverlay extends StatefulWidget {
     _overlayStateKey.currentState?._dismissPlayerReveal();
   }
 
-  /// Trigger the bounce animation on mini player (called when overlay dismiss starts)
+  /// Trigger single bounce on mini player (called when device selector collapses)
   static void triggerBounce() {
     _overlayStateKey.currentState?._triggerBounce();
   }
@@ -145,17 +147,34 @@ class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
   late AnimationController _slideController;
   late Animation<double> _slideAnimation;
 
-  // Controller for player reveal animation with bounce
+  // Single bounce controller for device selector expand/collapse
-  late AnimationController _bounceController;
+  late AnimationController _singleBounceController;
-  late Animation<double> _bounceAnimation;
+
+  // Double bounce controller for hint
+  late AnimationController _doubleBounceController;
 
   // State for player reveal overlay
   bool _isRevealVisible = false;
 
-  // Use ValueNotifier instead of setState for bounce offset
+  // State for interactive hint mode (blur backdrop + wait for user action)
-  // This prevents full widget tree rebuilds during animation
+  bool _isHintModeActive = false;
+  Timer? _hintBounceTimer;
+
+  // Track if player reveal was triggered from onboarding (for showing extra hints)
+  bool _isOnboardingReveal = false;
+
+  // Bounce offset for mini player (used by both single and double bounce)
   final _bounceOffsetNotifier = ValueNotifier<double>(0.0);
 
+  // Hint system state
+  bool _showHints = true;
+  bool _hasCompletedOnboarding = false; // First-use welcome screen
+  bool _hintTriggered = false; // Prevent multiple triggers per session
+  final _hintOpacityNotifier = ValueNotifier<double>(0.0);
+
+  // Welcome content fade-in animation
+  late AnimationController _welcomeFadeController;
+
   // Key for the reveal overlay
   final _revealKey = GlobalKey<PlayerRevealOverlayState>();
 
@@ -172,30 +191,94 @@ class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
       reverseCurve: Curves.easeInCubic,
     );
 
-    // Bounce animation - quick dip down then back up
+    // Single bounce for device selector expand/collapse
-    _bounceController = AnimationController(
+    _singleBounceController = AnimationController(
-      duration: const Duration(milliseconds: 200),
+      duration: const Duration(milliseconds: 400),
       vsync: this,
     );
-    _bounceAnimation = CurvedAnimation(
+    _singleBounceController.addListener(() {
-      parent: _bounceController,
+      final t = Curves.easeOut.transform(_singleBounceController.value);
-      curve: Curves.easeOut,
+      // Single bounce: up to 10px then back to 0
+      if (t < 0.5) {
+        _bounceOffsetNotifier.value = 10.0 * (t * 2);           // 0 -> 10
+      } else {
+        _bounceOffsetNotifier.value = 10.0 * ((1.0 - t) * 2);   // 10 -> 0
+      }
+    });
+
+    // Hint bounce - single gentle bounce to draw attention
+    _doubleBounceController = AnimationController(
+      duration: const Duration(milliseconds: 600),
+      vsync: this,
+    );
+    _doubleBounceController.addListener(() {
+      final t = Curves.easeOut.transform(_doubleBounceController.value);
+      // Single bounce: up 20px then back down
+      if (t < 0.5) {
+        _bounceOffsetNotifier.value = 20.0 * (t * 2);           // 0 -> 20
+      } else {
+        _bounceOffsetNotifier.value = 20.0 * ((1.0 - t) * 2);   // 20 -> 0
+      }
+    });
+
+    // Welcome content fade-in
+    _welcomeFadeController = AnimationController(
+      duration: const Duration(milliseconds: 800),
+      vsync: this,
     );
 
-    // Use ValueNotifier instead of setState to avoid full widget rebuilds
+    // Load hint settings and start welcome immediately if needed
-    // This isolates the rebuild to only the widgets that depend on bounce offset
+    _loadHintSettings();
-    _bounceController.addListener(() {
+  }
-      final t = _bounceAnimation.value;
+
-      // Sine curve: 0 -> 1 -> 0 as t goes 0 -> 0.5 -> 1
+  Future<void> _loadHintSettings() async {
-      _bounceOffsetNotifier.value = 10.0 * (t < 0.5 ? t * 2 : (1.0 - t) * 2);
+    _showHints = await SettingsService.getShowHints();
+    _hasCompletedOnboarding = await SettingsService.getHasCompletedOnboarding();
+    // Show welcome screen only on first use (not completed onboarding yet)
+    if (!_hasCompletedOnboarding && mounted && !_hintTriggered) {
+      _startWelcomeScreen();
+    }
+  }
+
+  /// Start the welcome screen with fade-in animation
+  void _startWelcomeScreen() {
+    if (_hintTriggered) return;
+    _hintTriggered = true;
+
+    // Activate hint mode immediately (blur backdrop visible)
+    setState(() {
+      _isHintModeActive = true;
+    });
+
+    // Fade in welcome content
+    _welcomeFadeController.forward();
+
+    // Start bounce animation after fade completes
+    _welcomeFadeController.addStatusListener((status) {
+      if (status == AnimationStatus.completed && mounted) {
+        _doubleBounceController.reset();
+        _doubleBounceController.forward();
+
+        // Repeat bounce every 2 seconds
+        _hintBounceTimer = Timer.periodic(const Duration(seconds: 2), (_) {
+          if (_isHintModeActive && mounted) {
+            _doubleBounceController.reset();
+            _doubleBounceController.forward();
+          }
+        });
+      }
     });
   }
 
   @override
   void dispose() {
+    _hintBounceTimer?.cancel();
     _slideController.dispose();
-    _bounceController.dispose();
+    _singleBounceController.dispose();
+    _doubleBounceController.dispose();
+    _welcomeFadeController.dispose();
     _bounceOffsetNotifier.dispose();
+    _hintOpacityNotifier.dispose();
     super.dispose();
   }
 
@@ -213,11 +296,29 @@ class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
       GlobalPlayerOverlay.collapsePlayer();
     }
     HapticFeedback.mediumImpact();
-    _bounceController.reset();
+
+    // Track if coming from hint mode (for onboarding hints in player selector)
+    final wasInHintMode = _isHintModeActive;
+
+    // End hint mode if active (user learned the gesture!)
+    _hintBounceTimer?.cancel();
+    _hintBounceTimer = null;
+    _hintOpacityNotifier.value = 0.0;
+    _isHintModeActive = false;
+
+    // Mark onboarding as completed if coming from welcome screen
+    if (wasInHintMode) {
+      SettingsService.setHasCompletedOnboarding(true);
+    }
+
+    // Trigger single bounce on expand
+    _singleBounceController.reset();
+    _singleBounceController.forward();
+
     setState(() {
       _isRevealVisible = true;
+      _isOnboardingReveal = wasInHintMode;
     });
-    _bounceController.forward();
   }
 
   void _hidePlayerReveal() {
@@ -225,6 +326,7 @@ class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
     _bounceOffsetNotifier.value = 0;
     setState(() {
       _isRevealVisible = false;
+      _isOnboardingReveal = false;
     });
   }
 
@@ -232,14 +334,27 @@ class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
   void _dismissPlayerReveal() {
     if (!_isRevealVisible) return;
     // Call the overlay's dismiss method which has the slide animation
-    // Note: dismiss() triggers the bounce animation internally
     _revealKey.currentState?.dismiss();
   }
 
-  /// Trigger bounce animation on mini player
+  /// Trigger single bounce on mini player (called when device selector collapses)
   void _triggerBounce() {
-    _bounceController.reset();
+    _singleBounceController.reset();
-    _bounceController.forward();
+    _singleBounceController.forward();
+  }
+
+  /// End hint mode (called when user taps skip button)
+  void _endHintMode() {
+    if (!_isHintModeActive) return;
+    _hintBounceTimer?.cancel();
+    _hintBounceTimer = null;
+    _hintOpacityNotifier.value = 0.0;
+    _bounceOffsetNotifier.value = 0.0;
+    // Mark onboarding as completed (first use only)
+    SettingsService.setHasCompletedOnboarding(true);
+    setState(() {
+      _isHintModeActive = false;
+    });
   }
 
   @override
@@ -247,12 +362,16 @@ class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
     final theme = Theme.of(context);
     final colorScheme = theme.colorScheme;
 
-    // Handle back gesture at top level - dismiss device list if visible
+    // Handle back gesture at top level - dismiss hint mode or device list if visible
     return PopScope(
-      canPop: !_isRevealVisible,
+      canPop: !_isRevealVisible && !_isHintModeActive,
       onPopInvokedWithResult: (didPop, result) {
-        if (!didPop && _isRevealVisible) {
+        if (!didPop) {
-          _dismissPlayerReveal();
+          if (_isHintModeActive) {
+            _endHintMode();
+          } else if (_isRevealVisible) {
+            _dismissPlayerReveal();
+          }
         }
       },
       child: Stack(
@@ -363,19 +482,119 @@ class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
             },
           ),
         ),
-        // Blur backdrop when device selector is open
+        // Blur backdrop for device selector (reveal mode) - static, no animation
-        if (_isRevealVisible)
+        if (_isRevealVisible && !_isHintModeActive)
           Positioned.fill(
-            child: IgnorePointer(
+            child: GestureDetector(
+              behavior: HitTestBehavior.opaque,
+              onTap: _dismissPlayerReveal,
               child: BackdropFilter(
                 filter: ImageFilter.blur(sigmaX: 8.0, sigmaY: 8.0),
                 child: Container(
-                  color: Colors.black.withOpacity(0.1),
+                  color: colorScheme.surface.withOpacity(0.5),
                 ),
               ),
             ),
           ),
 
+        // Blur backdrop for hint/welcome mode - animated fade from solid to semi-transparent
+        if (_isHintModeActive)
+          Positioned.fill(
+            child: TweenAnimationBuilder<double>(
+              // Hold solid for 2s, then fade to 0.5 over 1s
+              tween: Tween<double>(begin: 1.0, end: 0.5),
+              duration: const Duration(seconds: 3),
+              curve: const Interval(0.67, 1.0, curve: Curves.easeOut),
+              builder: (context, opacity, child) {
+                return BackdropFilter(
+                  filter: ImageFilter.blur(sigmaX: 8.0, sigmaY: 8.0),
+                  child: Container(
+                    color: colorScheme.surface.withOpacity(opacity),
+                  ),
+                );
+              },
+            ),
+          ),
+
+        // Welcome message during hint mode - two positioned sections with fade-in
+        // Top section: Logo and Welcome title (stays fixed at top area)
+        if (_isHintModeActive)
+          Positioned(
+            left: 24,
+            right: 24,
+            // Position logo section high up - about 1/3 from top
+            top: MediaQuery.of(context).size.height * 0.15,
+            child: FadeTransition(
+              opacity: CurvedAnimation(
+                parent: _welcomeFadeController,
+                curve: Curves.easeOut,
+              ),
+              child: Column(
+                mainAxisSize: MainAxisSize.min,
+                children: [
+                  // Ensemble logo - same as settings screen
+                  Image.asset(
+                    'assets/images/ensemble_icon_transparent.png',
+                    width: MediaQuery.of(context).size.width * 0.5,
+                    fit: BoxFit.contain,
+                  ),
+                  const SizedBox(height: 24),
+                  // Welcome title
+                  Text(
+                    S.of(context)!.welcomeToEnsemble,
+                    style: theme.textTheme.headlineSmall?.copyWith(
+                      color: Colors.white,
+                      fontWeight: FontWeight.bold,
+                    ),
+                    textAlign: TextAlign.center,
+                  ),
+                ],
+              ),
+            ),
+          ),
+
+        // Bottom section: Hint text and Skip button (positioned relative to mini player)
+        if (_isHintModeActive)
+          Positioned(
+            left: 24,
+            right: 24,
+            // Position so skip button is ~32px above mini player, matching skip-to-miniplayer gap
+            bottom: BottomSpacing.navBarHeight + BottomSpacing.miniPlayerHeight + MediaQuery.of(context).padding.bottom + 32,
+            child: FadeTransition(
+              opacity: CurvedAnimation(
+                parent: _welcomeFadeController,
+                curve: Curves.easeOut,
+              ),
+              child: Column(
+                mainAxisSize: MainAxisSize.min,
+                children: [
+                  // Hint text
+                  Text(
+                    S.of(context)!.welcomeMessage,
+                    style: theme.textTheme.bodyLarge?.copyWith(
+                      color: Colors.white,
+                      fontSize: 16,
+                      height: 1.4,
+                    ),
+                    textAlign: TextAlign.center,
+                  ),
+                  const SizedBox(height: 32),
+                  // Skip button - same gap above as below to mini player
+                  TextButton(
+                    onPressed: _endHintMode,
+                    child: Text(
+                      S.of(context)!.skip,
+                      style: TextStyle(
+                        color: Colors.white.withOpacity(0.7),
+                        fontSize: 14,
+                      ),
+                    ),
+                  ),
+                ],
+              ),
+            ),
+          ),
+
         // Player reveal overlay - renders BELOW mini player so cards slide behind it
         if (_isRevealVisible)
           PlayerRevealOverlay(
@@ -383,34 +602,43 @@ class _GlobalPlayerOverlayState extends State<GlobalPlayerOverlay>
             onDismiss: _hidePlayerReveal,
             miniPlayerBottom: BottomSpacing.navBarHeight + MediaQuery.of(context).padding.bottom + 12,
             miniPlayerHeight: 64,
+            showOnboardingHints: _isOnboardingReveal,
           ),
 
         // Global player overlay - renders ON TOP so cards slide behind it
         // Use Selector instead of Consumer to avoid rebuilds during animation
-        Selector<MusicAssistantProvider, ({bool isConnected, bool hasPlayer})>(
+        Selector<MusicAssistantProvider, ({bool isConnected, bool hasPlayer, bool hasTrack})>(
           selector: (_, provider) => (
             isConnected: provider.isConnected,
             hasPlayer: provider.selectedPlayer != null,
+            hasTrack: provider.currentTrack != null,
           ),
           builder: (context, state, child) {
             // Only show player if connected and has a selected player
             if (!state.isConnected || !state.hasPlayer) {
               return const SizedBox.shrink();
             }
-            // Combine slide and bounce animations with ValueListenableBuilder
+
+            // Combine slide, bounce, and hint animations with ValueListenableBuilders
             // This prevents full widget tree rebuilds - only ExpandablePlayer updates
             return ValueListenableBuilder<double>(
               valueListenable: _bounceOffsetNotifier,
               builder: (context, bounceOffset, _) {
-                return AnimatedBuilder(
+                return ValueListenableBuilder<double>(
-                  animation: _slideAnimation,
+                  valueListenable: _hintOpacityNotifier,
-                  builder: (context, _) {
+                  builder: (context, hintOpacity, _) {
-                    return ExpandablePlayer(
+                    return AnimatedBuilder(
-                      key: globalPlayerKey,
+                      animation: _slideAnimation,
-                      slideOffset: _slideAnimation.value,
+                      builder: (context, _) {
-                      bounceOffset: bounceOffset,
+                        return ExpandablePlayer(
-                      onRevealPlayers: _showPlayerReveal,
+                          key: globalPlayerKey,
-                      isDeviceRevealVisible: _isRevealVisible,
+                          slideOffset: _slideAnimation.value,
+                          bounceOffset: bounceOffset,
+                          onRevealPlayers: _showPlayerReveal,
+                          isDeviceRevealVisible: _isRevealVisible,
+                          isHintVisible: hintOpacity > 0,
+                        );
+                      },
                     );
                   },
                 );

lib/widgets/player/device_selector_bar.dart

@@ -67,6 +67,7 @@ class DeviceSelectorBar extends StatelessWidget {
                   textColor: textColor,
                   width: width,
                   slideOffset: slideOffset,
+                  isHint: swipeHint != null,
                 ),
               ],
             ),
@@ -97,6 +98,7 @@ class DeviceSelectorBar extends StatelessWidget {
         textColor: textColor,
         width: width,
         slideOffset: 0, // No additional slide - Transform handles positioning
+        isHint: swipeHint != null,
       ),
     );
   }

lib/widgets/player/mini_player_content.dart

@@ -48,6 +48,9 @@ class MiniPlayerContent extends StatelessWidget {
   /// Horizontal slide offset for swipe animation (-1 to 1)
   final double slideOffset;
 
+  /// Whether secondary text is a hint (shows lightbulb icon)
+  final bool isHint;
+
   /// Whether to show the progress bar overlay (for playing state)
   final bool showProgress;
 
@@ -64,6 +67,7 @@ class MiniPlayerContent extends StatelessWidget {
     required this.textColor,
     required this.width,
     this.slideOffset = 0.0,
+    this.isHint = false,
     this.showProgress = false,
     this.progress = 0.0,
   });
@@ -136,21 +140,44 @@ class MiniPlayerContent extends StatelessWidget {
             ),
           ),
 
-          // Secondary text line
+          // Secondary text line (with optional hint icon)
           if (hasSecondaryLine)
             Positioned(
               left: MiniPlayerLayout.textLeft + slidePixels,
               top: MiniPlayerLayout.secondaryTop,
               right: MiniPlayerLayout.textRightPadding - slidePixels,
-              child: Text(
+              child: isHint
-                secondaryText!,
+                  ? Row(
-                style: TextStyle(
+                      mainAxisSize: MainAxisSize.min,
-                  color: textColor.withOpacity(MiniPlayerLayout.secondaryTextOpacity),
+                      children: [
-                  fontSize: MiniPlayerLayout.secondaryFontSize,
+                        Icon(
-                ),
+                          Icons.lightbulb_outline,
-                maxLines: 1,
+                          size: 14,
-                overflow: TextOverflow.ellipsis,
+                          color: textColor.withOpacity(MiniPlayerLayout.secondaryTextOpacity),
-              ),
+                        ),
+                        const SizedBox(width: 4),
+                        Flexible(
+                          child: Text(
+                            secondaryText!,
+                            style: TextStyle(
+                              color: textColor.withOpacity(MiniPlayerLayout.secondaryTextOpacity),
+                              fontSize: MiniPlayerLayout.secondaryFontSize,
+                            ),
+                            maxLines: 1,
+                            overflow: TextOverflow.ellipsis,
+                          ),
+                        ),
+                      ],
+                    )
+                  : Text(
+                      secondaryText!,
+                      style: TextStyle(
+                        color: textColor.withOpacity(MiniPlayerLayout.secondaryTextOpacity),
+                        fontSize: MiniPlayerLayout.secondaryFontSize,
+                      ),
+                      maxLines: 1,
+                      overflow: TextOverflow.ellipsis,
+                    ),
             ),
         ],
       ),

lib/widgets/player/player_reveal_overlay.dart

@@ -2,7 +2,9 @@ import 'dart:async';
 import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:provider/provider.dart';
+import '../../l10n/app_localizations.dart';
 import '../../providers/music_assistant_provider.dart';
+import '../../services/settings_service.dart';
 import '../../theme/design_tokens.dart';
 import '../../theme/theme_provider.dart';
 import '../../theme/palette_helper.dart';
@@ -16,12 +18,14 @@ class PlayerRevealOverlay extends StatefulWidget {
   final VoidCallback onDismiss;
   final double miniPlayerBottom; // Bottom position of mini player
   final double miniPlayerHeight;
+  final bool showOnboardingHints; // Show additional hints for first-time users
 
   const PlayerRevealOverlay({
     super.key,
     required this.onDismiss,
     required this.miniPlayerBottom,
     required this.miniPlayerHeight,
+    this.showOnboardingHints = false,
   });
 
   @override
@@ -43,10 +47,18 @@ class PlayerRevealOverlayState extends State<PlayerRevealOverlay>
   // Cache extracted colors per player for per-device accent colors
   final Map<String, ColorScheme?> _playerColors = {};
 
+  // Hint system
+  bool _showHints = true;
+
   @override
   void initState() {
     super.initState();
 
+    // Load hint settings
+    SettingsService.getShowHints().then((value) {
+      if (mounted) setState(() => _showHints = value);
+    });
+
     _revealController = AnimationController(
       vsync: this,
     );
@@ -127,7 +139,7 @@ class PlayerRevealOverlayState extends State<PlayerRevealOverlay>
 
   /// Animate dismissal and call callback when done
   void dismiss() {
-    // Trigger settle bounce on mini player when cards are ~70% collapsed
+    // Trigger single bounce on mini player when cards are ~70% collapsed
     // This creates the effect of cards "landing" on the mini player
     bool bounceFired = false;
     void checkBounce() {
@@ -210,13 +222,12 @@ class PlayerRevealOverlayState extends State<PlayerRevealOverlay>
 
             return Stack(
               children: [
-                // Backdrop - tap to dismiss
+                // Backdrop - tap to dismiss (darkness handled by GlobalPlayerOverlay)
                 Positioned.fill(
                   child: GestureDetector(
                     onTap: dismiss,
-                    child: Container(
+                    behavior: HitTestBehavior.opaque,
-                      color: Colors.black.withOpacity(0.6 * _backdropAnimation.value),
+                    child: const SizedBox.expand(),
-                    ),
                   ),
                 ),
 
@@ -231,6 +242,53 @@ class PlayerRevealOverlayState extends State<PlayerRevealOverlay>
                     child: Column(
                       mainAxisSize: MainAxisSize.min,
                       children: [
+                        // Hint above player list - different for onboarding vs regular use
+                        // Onboarding: show first-time hint (how to select)
+                        // Regular: show sync hint (tap and hold to sync)
+                        if (players.isNotEmpty && (_showHints || widget.showOnboardingHints))
+                          Builder(
+                            builder: (context) {
+                              // Calculate slide offset to match the topmost card
+                              const baseOffset = 80.0;
+                              final hintDistanceToTravel = baseOffset + (players.length * (cardHeight + cardSpacing));
+                              final hintSlideOffset = hintDistanceToTravel * (1.0 - t);
+
+                              // Show different hint for onboarding vs regular use
+                              final isOnboarding = widget.showOnboardingHints;
+                              final hintText = isOnboarding
+                                  ? S.of(context)!.selectPlayerHint
+                                  : S.of(context)!.holdToSync;
+
+                              return Transform.translate(
+                                offset: Offset(0, hintSlideOffset),
+                                child: Padding(
+                                  padding: const EdgeInsets.only(bottom: 12),
+                                  child: Material(
+                                    type: MaterialType.transparency,
+                                    child: Row(
+                                      mainAxisSize: MainAxisSize.min,
+                                      children: [
+                                        Icon(
+                                          isOnboarding ? Icons.touch_app_outlined : Icons.lightbulb_outline,
+                                          size: 18,
+                                          color: colorScheme.onSurface.withOpacity(0.7),
+                                        ),
+                                        const SizedBox(width: 6),
+                                        Text(
+                                          hintText,
+                                          style: TextStyle(
+                                            color: colorScheme.onSurface.withOpacity(0.7),
+                                            fontSize: 16,
+                                            fontWeight: FontWeight.w500,
+                                          ),
+                                        ),
+                                      ],
+                                    ),
+                                  ),
+                                ),
+                              );
+                            },
+                          ),
                         // Build player cards - all slide from behind mini player
                         ...List.generate(players.length, (index) {
                           final player = players[index];
@@ -277,7 +335,7 @@ class PlayerRevealOverlayState extends State<PlayerRevealOverlay>
                                   maProvider.selectPlayer(player);
                                   dismiss();
                                 },
-                                onLongPress: player.available ? () {
+                                onLongPress: () {
                                   HapticFeedback.mediumImpact();
                                   debugPrint('🔗 Long-press on ${player.name} (${player.playerId})');
                                   ScaffoldMessenger.of(context).showSnackBar(
@@ -287,7 +345,7 @@ class PlayerRevealOverlayState extends State<PlayerRevealOverlay>
                                     ),
                                   );
                                   maProvider.togglePlayerSync(player.playerId);
-                                } : null,
+                                },
                                 onPlayPause: () {
                                   if (isPlaying) {
                                     maProvider.pausePlayer(player.playerId);

lib/widgets/player_selector.dart

@@ -231,25 +231,23 @@ class _PlayerSelectorSheetState extends State<_PlayerSelectorSheet> {
                                     maProvider.selectPlayer(player);
                                     Navigator.pop(context);
                                   },
-                                  onLongPress: player.available
+                                  onLongPress: () {
-                                      ? () {
+                                    // Haptic feedback for sync action
-                                          // Haptic feedback for sync action
+                                    HapticFeedback.mediumImpact();
-                                          HapticFeedback.mediumImpact();
 
-                                          // Show snackbar for visual feedback
+                                    // Show snackbar for visual feedback
-                                          ScaffoldMessenger.of(context).showSnackBar(
+                                    ScaffoldMessenger.of(context).showSnackBar(
-                                            SnackBar(
+                                      SnackBar(
-                                              content: Text('Syncing ${player.name}...'),
+                                        content: Text('Syncing ${player.name}...'),
-                                              duration: const Duration(seconds: 2),
+                                        duration: const Duration(seconds: 2),
-                                            ),
+                                      ),
-                                          );
+                                    );
 
-                                          // Long-press to sync/unsync player
+                                    // Long-press to sync/unsync player
-                                          debugPrint('🔗 Long-press on ${player.name} (${player.playerId})');
+                                    debugPrint('🔗 Long-press on ${player.name} (${player.playerId})');
-                                          debugPrint('🔗 Player isGrouped: ${player.isGrouped}, groupMembers: ${player.groupMembers}');
+                                    debugPrint('🔗 Player isGrouped: ${player.isGrouped}, groupMembers: ${player.groupMembers}');
-                                          maProvider.togglePlayerSync(player.playerId);
+                                    maProvider.togglePlayerSync(player.playerId);
-                                        }
+                                  },
-                                      : null,
                                   borderRadius: BorderRadius.circular(16),
                                   child: Container(
                                     height: 72,

pubspec.yaml

@@ -1,7 +1,7 @@
 name: ensemble
 description: A minimalistic Music Assistant client built with Flutter
 publish_to: 'none'
-version: 2.5.0-beta+27
+version: 2.6.0-beta+28
 
 environment:
   sdk: '>=3.0.0 <4.0.0'