tristate starred filter, filter-aware empty state, keyboard-safe search bar

app/src/main/kotlin/com/subtracks/data/db/LibraryDao.kt

@@ -91,193 +91,193 @@ interface LibraryDao {
 
     @Query(
         "SELECT * FROM albums WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%' OR albumArtist LIKE '%' || :search || '%') " +
             "ORDER BY name COLLATE NOCASE",
     )
     fun albumsByName(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Album>
 
     @Query(
         "SELECT * FROM albums WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%' OR albumArtist LIKE '%' || :search || '%') " +
             "ORDER BY name COLLATE NOCASE DESC",
     )
     fun albumsByNameReversed(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Album>
 
     @Query(
         "SELECT * FROM albums WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%' OR albumArtist LIKE '%' || :search || '%') " +
             "ORDER BY albumArtist COLLATE NOCASE, year, name COLLATE NOCASE",
     )
     fun albumsByArtist(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Album>
 
     @Query(
         "SELECT * FROM albums WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%' OR albumArtist LIKE '%' || :search || '%') " +
             "ORDER BY albumArtist COLLATE NOCASE DESC, year DESC, name COLLATE NOCASE DESC",
     )
     fun albumsByArtistReversed(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Album>
 
     @Query(
         "SELECT * FROM albums WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%' OR albumArtist LIKE '%' || :search || '%') " +
             "ORDER BY year DESC, name COLLATE NOCASE",
     )
     fun albumsByYear(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Album>
 
     @Query(
         "SELECT * FROM albums WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%' OR albumArtist LIKE '%' || :search || '%') " +
             "ORDER BY year ASC, name COLLATE NOCASE",
     )
     fun albumsByYearReversed(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Album>
 
     @Query(
         "SELECT * FROM albums WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%' OR albumArtist LIKE '%' || :search || '%') " +
             "ORDER BY created DESC, name COLLATE NOCASE",
     )
     fun albumsByRecentlyAdded(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Album>
 
     @Query(
         "SELECT * FROM albums WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%' OR albumArtist LIKE '%' || :search || '%') " +
             "ORDER BY created ASC, name COLLATE NOCASE",
     )
     fun albumsByRecentlyAddedReversed(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Album>
 
     @Query(
         "SELECT * FROM albums WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%' OR albumArtist LIKE '%' || :search || '%') " +
             "ORDER BY starred IS NULL, starred DESC, name COLLATE NOCASE",
     )
     fun albumsByStarred(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Album>
 
     @Query(
         "SELECT * FROM albums WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%' OR albumArtist LIKE '%' || :search || '%') " +
             "ORDER BY starred IS NULL, starred ASC, name COLLATE NOCASE",
     )
     fun albumsByStarredReversed(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Album>
 
     @Query(
         "SELECT * FROM artists WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%') " +
             "ORDER BY name COLLATE NOCASE",
     )
     fun artistsByName(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Artist>
 
     @Query(
         "SELECT * FROM artists WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%') " +
             "ORDER BY name COLLATE NOCASE DESC",
     )
     fun artistsByNameReversed(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Artist>
 
     @Query(
         "SELECT * FROM artists WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%') " +
             "ORDER BY albumCount DESC, name COLLATE NOCASE",
     )
     fun artistsByAlbumCount(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Artist>
 
     @Query(
         "SELECT * FROM artists WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%') " +
             "ORDER BY albumCount ASC, name COLLATE NOCASE",
     )
     fun artistsByAlbumCountReversed(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Artist>
 
     @Query(
         "SELECT * FROM artists WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%') " +
             "ORDER BY starred IS NULL, starred DESC, name COLLATE NOCASE",
     )
     fun artistsByStarred(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Artist>
 
     @Query(
         "SELECT * FROM artists WHERE sourceId = :sourceId " +
-            "AND (:starredOnly = 0 OR starred IS NOT NULL) " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND starred IS NOT NULL) OR (:starredFilter = 2 AND starred IS NULL)) " +
             "AND (:search = '' OR name LIKE '%' || :search || '%') " +
             "ORDER BY starred IS NULL, starred ASC, name COLLATE NOCASE",
     )
     fun artistsByStarredReversed(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, Artist>
 
@@ -344,7 +344,9 @@ interface LibraryDao {
     @Query(
         "SELECT songs.*, albums.coverArt AS coverArt FROM songs " +
             "LEFT JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
-            "WHERE songs.sourceId = :sourceId AND (:starredOnly = 0 OR songs.starred IS NOT NULL) " +
+            "WHERE songs.sourceId = :sourceId " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND songs.starred IS NOT NULL) OR " +
+            "(:starredFilter = 2 AND songs.starred IS NULL)) " +
             "AND (:search = '' OR songs.title LIKE '%' || :search || '%' " +
             "OR songs.artist LIKE '%' || :search || '%' OR songs.album LIKE '%' || :search || '%') " +
             "ORDER BY albums.albumArtist COLLATE NOCASE, songs.album COLLATE NOCASE, songs.disc, songs.track, " +
@@ -352,91 +354,103 @@ interface LibraryDao {
     )
     fun songs(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, SongListItem>
 
     @Query(
         "SELECT songs.*, albums.coverArt AS coverArt FROM songs " +
             "LEFT JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
-            "WHERE songs.sourceId = :sourceId AND (:starredOnly = 0 OR songs.starred IS NOT NULL) " +
+            "WHERE songs.sourceId = :sourceId " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND songs.starred IS NOT NULL) OR " +
+            "(:starredFilter = 2 AND songs.starred IS NULL)) " +
             "AND (:search = '' OR songs.title LIKE '%' || :search || '%' " +
             "OR songs.artist LIKE '%' || :search || '%' OR songs.album LIKE '%' || :search || '%') " +
             "ORDER BY songs.title COLLATE NOCASE, songs.id",
     )
     fun songsByTitle(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, SongListItem>
 
     @Query(
         "SELECT songs.*, albums.coverArt AS coverArt FROM songs " +
             "LEFT JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
-            "WHERE songs.sourceId = :sourceId AND (:starredOnly = 0 OR songs.starred IS NOT NULL) " +
+            "WHERE songs.sourceId = :sourceId " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND songs.starred IS NOT NULL) OR " +
+            "(:starredFilter = 2 AND songs.starred IS NULL)) " +
             "AND (:search = '' OR songs.title LIKE '%' || :search || '%' " +
             "OR songs.artist LIKE '%' || :search || '%' OR songs.album LIKE '%' || :search || '%') " +
             "ORDER BY songs.title COLLATE NOCASE DESC, songs.id",
     )
     fun songsByTitleReversed(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, SongListItem>
 
     @Query(
         "SELECT songs.*, albums.coverArt AS coverArt FROM songs " +
             "LEFT JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
-            "WHERE songs.sourceId = :sourceId AND (:starredOnly = 0 OR songs.starred IS NOT NULL) " +
+            "WHERE songs.sourceId = :sourceId " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND songs.starred IS NOT NULL) OR " +
+            "(:starredFilter = 2 AND songs.starred IS NULL)) " +
             "AND (:search = '' OR songs.title LIKE '%' || :search || '%' " +
             "OR songs.artist LIKE '%' || :search || '%' OR songs.album LIKE '%' || :search || '%') " +
             "ORDER BY songs.artist COLLATE NOCASE, songs.album COLLATE NOCASE, songs.disc, songs.track, songs.id",
     )
     fun songsByArtist(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, SongListItem>
 
     @Query(
         "SELECT songs.*, albums.coverArt AS coverArt FROM songs " +
             "LEFT JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
-            "WHERE songs.sourceId = :sourceId AND (:starredOnly = 0 OR songs.starred IS NOT NULL) " +
+            "WHERE songs.sourceId = :sourceId " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND songs.starred IS NOT NULL) OR " +
+            "(:starredFilter = 2 AND songs.starred IS NULL)) " +
             "AND (:search = '' OR songs.title LIKE '%' || :search || '%' " +
             "OR songs.artist LIKE '%' || :search || '%' OR songs.album LIKE '%' || :search || '%') " +
             "ORDER BY songs.artist COLLATE NOCASE DESC, songs.album COLLATE NOCASE, songs.disc, songs.track, songs.id",
     )
     fun songsByArtistReversed(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, SongListItem>
 
     @Query(
         "SELECT songs.*, albums.coverArt AS coverArt FROM songs " +
             "LEFT JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
-            "WHERE songs.sourceId = :sourceId AND (:starredOnly = 0 OR songs.starred IS NOT NULL) " +
+            "WHERE songs.sourceId = :sourceId " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND songs.starred IS NOT NULL) OR " +
+            "(:starredFilter = 2 AND songs.starred IS NULL)) " +
             "AND (:search = '' OR songs.title LIKE '%' || :search || '%' " +
             "OR songs.artist LIKE '%' || :search || '%' OR songs.album LIKE '%' || :search || '%') " +
             "ORDER BY songs.starred IS NULL, songs.starred DESC, songs.title COLLATE NOCASE, songs.id",
     )
     fun songsByStarred(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, SongListItem>
 
     @Query(
         "SELECT songs.*, albums.coverArt AS coverArt FROM songs " +
             "LEFT JOIN albums ON albums.sourceId = songs.sourceId AND albums.id = songs.albumId " +
-            "WHERE songs.sourceId = :sourceId AND (:starredOnly = 0 OR songs.starred IS NOT NULL) " +
+            "WHERE songs.sourceId = :sourceId " +
+            "AND (:starredFilter = 0 OR (:starredFilter = 1 AND songs.starred IS NOT NULL) OR " +
+            "(:starredFilter = 2 AND songs.starred IS NULL)) " +
             "AND (:search = '' OR songs.title LIKE '%' || :search || '%' " +
             "OR songs.artist LIKE '%' || :search || '%' OR songs.album LIKE '%' || :search || '%') " +
             "ORDER BY songs.starred IS NULL, songs.starred ASC, songs.title COLLATE NOCASE, songs.id",
     )
     fun songsByStarredReversed(
         sourceId: Long,
-        starredOnly: Boolean,
+        starredFilter: Int,
         search: String,
     ): PagingSource<Int, SongListItem>
 

app/src/main/kotlin/com/subtracks/data/prefs/UserPreferences.kt

@@ -29,10 +29,12 @@ enum class LibraryListTab(
     Songs("songs", SongSort.Album.name, true),
 }
 
+enum class StarredFilter { Any, Starred, NotStarred }
+
 data class ListQuery(
     val sort: String,
     val descending: Boolean = false,
-    val starredOnly: Boolean = false,
+    val starred: StarredFilter = StarredFilter.Any,
 )
 
 private val Context.preferences: DataStore<Preferences> by preferencesDataStore("user_prefs")
@@ -65,7 +67,7 @@ class UserPreferences(
 
     private fun listQueryKey(tab: LibraryListTab) = stringPreferencesKey("list_query_${tab.key}")
 
-    private fun encode(query: ListQuery) = "${query.sort}|${if (query.descending) 1 else 0}|${if (query.starredOnly) 1 else 0}"
+    private fun encode(query: ListQuery) = "${query.sort}|${if (query.descending) 1 else 0}|${query.starred.ordinal}"
 
     private fun decode(
         stored: String?,
@@ -76,7 +78,7 @@ class UserPreferences(
         return ListQuery(
             sort = parts[0].ifEmpty { defaultSort },
             descending = parts[1] == "1",
-            starredOnly = parts[2] == "1",
+            starred = StarredFilter.entries.getOrElse(parts[2].toIntOrNull() ?: 0) { StarredFilter.Any },
         )
     }
 

app/src/main/kotlin/com/subtracks/data/repo/LibraryRepository.kt

@@ -14,6 +14,7 @@ import com.subtracks.data.prefs.AlbumSort
 import com.subtracks.data.prefs.ArtistSort
 import com.subtracks.data.prefs.PlaylistSort
 import com.subtracks.data.prefs.SongSort
+import com.subtracks.data.prefs.StarredFilter
 import kotlinx.coroutines.flow.Flow
 
 class LibraryRepository(
@@ -26,7 +27,7 @@ class LibraryRepository(
         sourceId: Long,
         sort: AlbumSort,
         descending: Boolean,
-        starredOnly: Boolean,
+        starred: StarredFilter,
         search: String,
     ): Flow<PagingData<Album>> =
         pager(40) {
@@ -34,41 +35,41 @@ class LibraryRepository(
             when (sort) {
                 AlbumSort.Name -> {
                     if (descending) {
-                        dao.albumsByNameReversed(sourceId, starredOnly, search)
+                        dao.albumsByNameReversed(sourceId, starred.ordinal, search)
                     } else {
-                        dao.albumsByName(sourceId, starredOnly, search)
+                        dao.albumsByName(sourceId, starred.ordinal, search)
                     }
                 }
 
                 AlbumSort.Artist -> {
                     if (descending) {
-                        dao.albumsByArtistReversed(sourceId, starredOnly, search)
+                        dao.albumsByArtistReversed(sourceId, starred.ordinal, search)
                     } else {
-                        dao.albumsByArtist(sourceId, starredOnly, search)
+                        dao.albumsByArtist(sourceId, starred.ordinal, search)
                     }
                 }
 
                 AlbumSort.Year -> {
                     if (descending) {
-                        dao.albumsByYearReversed(sourceId, starredOnly, search)
+                        dao.albumsByYearReversed(sourceId, starred.ordinal, search)
                     } else {
-                        dao.albumsByYear(sourceId, starredOnly, search)
+                        dao.albumsByYear(sourceId, starred.ordinal, search)
                     }
                 }
 
                 AlbumSort.Added -> {
                     if (descending) {
-                        dao.albumsByRecentlyAddedReversed(sourceId, starredOnly, search)
+                        dao.albumsByRecentlyAddedReversed(sourceId, starred.ordinal, search)
                     } else {
-                        dao.albumsByRecentlyAdded(sourceId, starredOnly, search)
+                        dao.albumsByRecentlyAdded(sourceId, starred.ordinal, search)
                     }
                 }
 
                 AlbumSort.Starred -> {
                     if (descending) {
-                        dao.albumsByStarredReversed(sourceId, starredOnly, search)
+                        dao.albumsByStarredReversed(sourceId, starred.ordinal, search)
                     } else {
-                        dao.albumsByStarred(sourceId, starredOnly, search)
+                        dao.albumsByStarred(sourceId, starred.ordinal, search)
                     }
                 }
             }
@@ -78,7 +79,7 @@ class LibraryRepository(
         sourceId: Long,
         sort: ArtistSort,
         descending: Boolean,
-        starredOnly: Boolean,
+        starred: StarredFilter,
         search: String,
     ): Flow<PagingData<Artist>> =
         pager(60) {
@@ -86,25 +87,25 @@ class LibraryRepository(
             when (sort) {
                 ArtistSort.Name -> {
                     if (descending) {
-                        dao.artistsByNameReversed(sourceId, starredOnly, search)
+                        dao.artistsByNameReversed(sourceId, starred.ordinal, search)
                     } else {
-                        dao.artistsByName(sourceId, starredOnly, search)
+                        dao.artistsByName(sourceId, starred.ordinal, search)
                     }
                 }
 
                 ArtistSort.AlbumCount -> {
                     if (descending) {
-                        dao.artistsByAlbumCountReversed(sourceId, starredOnly, search)
+                        dao.artistsByAlbumCountReversed(sourceId, starred.ordinal, search)
                     } else {
-                        dao.artistsByAlbumCount(sourceId, starredOnly, search)
+                        dao.artistsByAlbumCount(sourceId, starred.ordinal, search)
                     }
                 }
 
                 ArtistSort.Starred -> {
                     if (descending) {
-                        dao.artistsByStarredReversed(sourceId, starredOnly, search)
+                        dao.artistsByStarredReversed(sourceId, starred.ordinal, search)
                     } else {
-                        dao.artistsByStarred(sourceId, starredOnly, search)
+                        dao.artistsByStarred(sourceId, starred.ordinal, search)
                     }
                 }
             }
@@ -149,37 +150,37 @@ class LibraryRepository(
         sourceId: Long,
         sort: SongSort,
         descending: Boolean,
-        starredOnly: Boolean,
+        starred: StarredFilter,
         search: String,
     ): Flow<PagingData<SongListItem>> =
         pager(60) {
             val dao = db.libraryDao()
             when (sort) {
                 SongSort.Album -> {
-                    dao.songs(sourceId, starredOnly, search)
+                    dao.songs(sourceId, starred.ordinal, search)
                 }
 
                 SongSort.Title -> {
                     if (descending) {
-                        dao.songsByTitleReversed(sourceId, starredOnly, search)
+                        dao.songsByTitleReversed(sourceId, starred.ordinal, search)
                     } else {
-                        dao.songsByTitle(sourceId, starredOnly, search)
+                        dao.songsByTitle(sourceId, starred.ordinal, search)
                     }
                 }
 
                 SongSort.Artist -> {
                     if (descending) {
-                        dao.songsByArtistReversed(sourceId, starredOnly, search)
+                        dao.songsByArtistReversed(sourceId, starred.ordinal, search)
                     } else {
-                        dao.songsByArtist(sourceId, starredOnly, search)
+                        dao.songsByArtist(sourceId, starred.ordinal, search)
                     }
                 }
 
                 SongSort.Starred -> {
                     if (descending) {
-                        dao.songsByStarredReversed(sourceId, starredOnly, search)
+                        dao.songsByStarredReversed(sourceId, starred.ordinal, search)
                     } else {
-                        dao.songsByStarred(sourceId, starredOnly, search)
+                        dao.songsByStarred(sourceId, starred.ordinal, search)
                     }
                 }
             }

app/src/main/kotlin/com/subtracks/ui/components/Components.kt

@@ -3,13 +3,16 @@ package com.subtracks.ui.components
 import android.content.Context
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.BoxScope
 import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Button
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
@@ -182,3 +185,29 @@ fun EmptyState(
         )
     }
 }
+
+@Composable
+fun FilteredEmptyState(
+    onClearFilters: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Box(
+        modifier = modifier.fillMaxSize().padding(32.dp),
+        contentAlignment = Alignment.Center,
+    ) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            Text(
+                text = "Filters are hiding everything.",
+                style = MaterialTheme.typography.bodyLarge,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                textAlign = TextAlign.Center,
+            )
+            Button(onClick = onClearFilters) {
+                Text("Clear filters")
+            }
+        }
+    }
+}

app/src/main/kotlin/com/subtracks/ui/library/AlbumsContent.kt

@@ -27,6 +27,7 @@ import com.subtracks.data.model.Album
 import com.subtracks.data.model.CoverArtRef
 import com.subtracks.ui.components.CoverArt
 import com.subtracks.ui.components.EmptyState
+import com.subtracks.ui.components.FilteredEmptyState
 import com.subtracks.ui.components.LoadingState
 import com.subtracks.ui.components.rememberViewportFill
 import com.subtracks.ui.theme.PrefetchArtworkSeeds
@@ -39,6 +40,8 @@ fun AlbumsContent(
     coverArt: (String?, Boolean) -> CoverArtRef?,
     bottomInset: Dp,
     onAlbumClick: (Album) -> Unit,
+    filtered: Boolean = false,
+    onClearFilters: () -> Unit = {},
     resetKey: Any? = null,
     modifier: Modifier = Modifier,
 ) {
@@ -48,7 +51,11 @@ fun AlbumsContent(
         }
 
         items.itemCount == 0 -> {
-            EmptyState("No albums yet.\nSync with your server to fill your library.", modifier)
+            if (filtered) {
+                FilteredEmptyState(onClearFilters, modifier)
+            } else {
+                EmptyState("No albums yet.\nSync with your server to fill your library.", modifier)
+            }
         }
 
         else -> {

app/src/main/kotlin/com/subtracks/ui/library/ArtistsContent.kt

@@ -27,6 +27,7 @@ import com.subtracks.data.model.Artist
 import com.subtracks.data.model.CoverArtRef
 import com.subtracks.ui.components.CoverArt
 import com.subtracks.ui.components.EmptyState
+import com.subtracks.ui.components.FilteredEmptyState
 import com.subtracks.ui.components.LoadingState
 import com.subtracks.ui.components.rememberViewportFill
 import com.subtracks.ui.theme.PrefetchArtworkSeeds
@@ -37,6 +38,8 @@ fun ArtistsContent(
     coverArt: (String?, Boolean) -> CoverArtRef?,
     bottomInset: Dp,
     onArtistClick: (Artist) -> Unit,
+    filtered: Boolean = false,
+    onClearFilters: () -> Unit = {},
     resetKey: Any? = null,
     modifier: Modifier = Modifier,
 ) {
@@ -46,7 +49,11 @@ fun ArtistsContent(
         }
 
         items.itemCount == 0 -> {
-            EmptyState("No artists yet.", modifier)
+            if (filtered) {
+                FilteredEmptyState(onClearFilters, modifier)
+            } else {
+                EmptyState("No artists yet.", modifier)
+            }
         }
 
         else -> {

app/src/main/kotlin/com/subtracks/ui/library/LibraryScreen.kt

@@ -12,6 +12,7 @@ import androidx.compose.foundation.layout.WindowInsets
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.navigationBars
 import androidx.compose.foundation.layout.offset
 import androidx.compose.foundation.layout.padding
@@ -27,18 +28,21 @@ import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.rounded.PlaylistPlay
 import androidx.compose.material.icons.filled.Sort
+import androidx.compose.material.icons.rounded.Add
 import androidx.compose.material.icons.rounded.Album
 import androidx.compose.material.icons.rounded.ArrowDownward
 import androidx.compose.material.icons.rounded.ArrowUpward
 import androidx.compose.material.icons.rounded.Close
 import androidx.compose.material.icons.rounded.MusicNote
 import androidx.compose.material.icons.rounded.Person
+import androidx.compose.material.icons.rounded.Remove
 import androidx.compose.material.icons.rounded.Search
 import androidx.compose.material.icons.rounded.Settings
 import androidx.compose.material.icons.rounded.Sync
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.FilterChip
+import androidx.compose.material3.FilterChipDefaults
 import androidx.compose.material3.FloatingActionButton
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
@@ -93,6 +97,7 @@ import com.subtracks.data.prefs.LibraryListTab
 import com.subtracks.data.prefs.ListQuery
 import com.subtracks.data.prefs.PlaylistSort
 import com.subtracks.data.prefs.SongSort
+import com.subtracks.data.prefs.StarredFilter
 import org.koin.compose.viewmodel.koinViewModel
 import kotlin.math.abs
 import kotlin.math.roundToInt
@@ -190,8 +195,19 @@ fun LibraryRoute(
         starredSupported = listTab.supportsStarred,
         onSortChange = { viewModel.setListQuery(listTab, listQuery.copy(sort = it)) },
         onToggleSortDirection = { viewModel.setListQuery(listTab, listQuery.copy(descending = !listQuery.descending)) },
-        onToggleStarred = { viewModel.setListQuery(listTab, listQuery.copy(starredOnly = !listQuery.starredOnly)) },
-        onClearFilters = { viewModel.setListQuery(listTab, listQuery.copy(starredOnly = false)) },
+        onCycleStarred = {
+            val next =
+                when (listQuery.starred) {
+                    StarredFilter.Any -> StarredFilter.Starred
+                    StarredFilter.Starred -> StarredFilter.NotStarred
+                    StarredFilter.NotStarred -> StarredFilter.Any
+                }
+            viewModel.setListQuery(listTab, listQuery.copy(starred = next))
+        },
+        onClearFilters = {
+            viewModel.setListQuery(listTab, listQuery.copy(starred = StarredFilter.Any))
+            viewModel.setSearch(listTab, "")
+        },
         search = search,
         onSearchChange = { viewModel.setSearch(listTab, it) },
     )
@@ -221,7 +237,7 @@ fun LibraryScreen(
     starredSupported: Boolean = false,
     onSortChange: (String) -> Unit = {},
     onToggleSortDirection: () -> Unit = {},
-    onToggleStarred: () -> Unit = {},
+    onCycleStarred: () -> Unit = {},
     onClearFilters: () -> Unit = {},
     search: String = "",
     onSearchChange: (String) -> Unit = {},
@@ -261,8 +277,9 @@ fun LibraryScreen(
     val titleFraction = scrollBehavior.state.collapsedFraction
 
     val statusBarTop = with(density) { WindowInsets.statusBars.getTop(this).toDp() }
-    val listBottomInset = bottomInset + if (searchActive) 0.dp else FAB_CLEARANCE
-    val resetKey = listOf(listQuery.sort, listQuery.descending, listQuery.starredOnly, search)
+    val filtersActive = listQuery.starred != StarredFilter.Any || search.isNotEmpty()
+    val listBottomInset = bottomInset + if (searchActive) SEARCH_BAR_CLEARANCE else FAB_CLEARANCE
+    val resetKey = listOf(listQuery.sort, listQuery.descending, listQuery.starred, search)
 
     Box(modifier.fillMaxSize()) {
         Column(
@@ -312,11 +329,27 @@ fun LibraryScreen(
             ) { page ->
                 when (LibraryTab.entries[page]) {
                     LibraryTab.Albums -> {
-                        AlbumsContent(albums, coverArt, listBottomInset, onAlbumClick, resetKey = resetKey)
+                        AlbumsContent(
+                            albums,
+                            coverArt,
+                            listBottomInset,
+                            onAlbumClick,
+                            filtered = filtersActive,
+                            onClearFilters = onClearFilters,
+                            resetKey = resetKey,
+                        )
                     }
 
                     LibraryTab.Artists -> {
-                        ArtistsContent(artists, coverArt, listBottomInset, onArtistClick, resetKey = resetKey)
+                        ArtistsContent(
+                            artists,
+                            coverArt,
+                            listBottomInset,
+                            onArtistClick,
+                            filtered = filtersActive,
+                            onClearFilters = onClearFilters,
+                            resetKey = resetKey,
+                        )
                     }
 
                     LibraryTab.Songs -> {
@@ -326,28 +359,43 @@ fun LibraryScreen(
                             listBottomInset,
                             onSongClick,
                             playingSongId,
+                            filtered = filtersActive,
+                            onClearFilters = onClearFilters,
                             resetKey = resetKey,
                         )
                     }
 
                     LibraryTab.Playlists -> {
-                        PlaylistsContent(playlists, coverArt, listBottomInset, onPlaylistClick, resetKey = resetKey)
+                        PlaylistsContent(
+                            playlists,
+                            coverArt,
+                            listBottomInset,
+                            onPlaylistClick,
+                            filtered = filtersActive,
+                            onClearFilters = onClearFilters,
+                            resetKey = resetKey,
+                        )
                     }
                 }
             }
+        }
 
-            if (searchActive) {
-                SearchField(
-                    value = search,
-                    onValueChange = onSearchChange,
-                    onClose = {
-                        searchActive = false
-                        onSearchChange("")
-                    },
-                    focusRequester = searchFocus,
-                    modifier = Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 8.dp),
-                )
-            }
+        if (searchActive) {
+            SearchField(
+                value = search,
+                onValueChange = onSearchChange,
+                onClose = {
+                    searchActive = false
+                    onSearchChange("")
+                },
+                focusRequester = searchFocus,
+                modifier =
+                    Modifier
+                        .align(Alignment.BottomCenter)
+                        .fillMaxWidth()
+                        .imePadding()
+                        .padding(horizontal = 12.dp, vertical = 8.dp),
+            )
         }
 
         if (!searchActive) {
@@ -359,7 +407,7 @@ fun LibraryScreen(
             ) {
                 Box {
                     Icon(Icons.Filled.Sort, contentDescription = "List options")
-                    if (listQuery.starredOnly) {
+                    if (listQuery.starred != StarredFilter.Any) {
                         Box(
                             modifier =
                                 Modifier
@@ -383,7 +431,7 @@ fun LibraryScreen(
                 starredSupported = starredSupported,
                 onSortChange = onSortChange,
                 onToggleSortDirection = onToggleSortDirection,
-                onToggleStarred = onToggleStarred,
+                onCycleStarred = onCycleStarred,
                 onClearFilters = onClearFilters,
                 onSearch = {
                     showOptions = false
@@ -402,7 +450,7 @@ private fun ListOptionsSheet(
     starredSupported: Boolean,
     onSortChange: (String) -> Unit,
     onToggleSortDirection: () -> Unit,
-    onToggleStarred: () -> Unit,
+    onCycleStarred: () -> Unit,
     onClearFilters: () -> Unit,
     onSearch: () -> Unit,
 ) {
@@ -456,12 +504,38 @@ private fun ListOptionsSheet(
                 modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp),
             ) {
                 FilterChip(
-                    selected = listQuery.starredOnly,
-                    onClick = onToggleStarred,
+                    selected = listQuery.starred != StarredFilter.Any,
+                    onClick = onCycleStarred,
                     label = { Text("Starred") },
+                    leadingIcon =
+                        when (listQuery.starred) {
+                            StarredFilter.Any -> {
+                                null
+                            }
+
+                            StarredFilter.Starred -> {
+                                {
+                                    Icon(
+                                        Icons.Rounded.Add,
+                                        contentDescription = null,
+                                        modifier = Modifier.size(FilterChipDefaults.IconSize),
+                                    )
+                                }
+                            }
+
+                            StarredFilter.NotStarred -> {
+                                {
+                                    Icon(
+                                        Icons.Rounded.Remove,
+                                        contentDescription = null,
+                                        modifier = Modifier.size(FilterChipDefaults.IconSize),
+                                    )
+                                }
+                            }
+                        },
                 )
-                if (listQuery.starredOnly) {
-                    TextButton(onClick = onClearFilters) { Text("Clear") }
+                if (listQuery.starred != StarredFilter.Any) {
+                    TextButton(onClick = onClearFilters) { Text("Clear filters") }
                 }
             }
         }
@@ -469,6 +543,7 @@ private fun ListOptionsSheet(
 }
 
 private val FAB_CLEARANCE = 80.dp
+private val SEARCH_BAR_CLEARANCE = 80.dp
 
 @Composable
 private fun SearchField(

app/src/main/kotlin/com/subtracks/ui/library/LibraryViewModel.kt

@@ -59,7 +59,7 @@ class LibraryViewModel(
                 combine(listQueries.getValue(LibraryListTab.Albums), searches.getValue(LibraryListTab.Albums)) { query, search ->
                     query to search
                 }.flatMapLatest { (query, search) ->
-                    libraryRepository.albums(sourceId, query.albumSort(), query.descending, query.starredOnly, search)
+                    libraryRepository.albums(sourceId, query.albumSort(), query.descending, query.starred, search)
                 }
             }.cachedIn(viewModelScope)
 
@@ -70,7 +70,7 @@ class LibraryViewModel(
                 combine(listQueries.getValue(LibraryListTab.Artists), searches.getValue(LibraryListTab.Artists)) { query, search ->
                     query to search
                 }.flatMapLatest { (query, search) ->
-                    libraryRepository.artists(sourceId, query.artistSort(), query.descending, query.starredOnly, search)
+                    libraryRepository.artists(sourceId, query.artistSort(), query.descending, query.starred, search)
                 }
             }.cachedIn(viewModelScope)
 
@@ -92,7 +92,7 @@ class LibraryViewModel(
                 combine(listQueries.getValue(LibraryListTab.Songs), searches.getValue(LibraryListTab.Songs)) { query, search ->
                     query to search
                 }.flatMapLatest { (query, search) ->
-                    libraryRepository.songs(sourceId, query.songSort(), query.descending, query.starredOnly, search)
+                    libraryRepository.songs(sourceId, query.songSort(), query.descending, query.starred, search)
                 }
             }.cachedIn(viewModelScope)
 

app/src/main/kotlin/com/subtracks/ui/library/PlaylistsContent.kt

@@ -27,6 +27,7 @@ import com.subtracks.data.model.CoverArtRef
 import com.subtracks.data.model.Playlist
 import com.subtracks.ui.components.CoverArt
 import com.subtracks.ui.components.EmptyState
+import com.subtracks.ui.components.FilteredEmptyState
 import com.subtracks.ui.components.LoadingState
 import com.subtracks.ui.components.rememberViewportFill
 
@@ -36,6 +37,8 @@ fun PlaylistsContent(
     coverArt: (String?, Boolean) -> CoverArtRef?,
     bottomInset: Dp,
     onPlaylistClick: (Playlist) -> Unit,
+    filtered: Boolean = false,
+    onClearFilters: () -> Unit = {},
     resetKey: Any? = null,
     modifier: Modifier = Modifier,
 ) {
@@ -45,7 +48,11 @@ fun PlaylistsContent(
         }
 
         items.itemCount == 0 -> {
-            EmptyState("No playlists yet.", modifier)
+            if (filtered) {
+                FilteredEmptyState(onClearFilters, modifier)
+            } else {
+                EmptyState("No playlists yet.", modifier)
+            }
         }
 
         else -> {

app/src/main/kotlin/com/subtracks/ui/library/SongsContent.kt

@@ -38,6 +38,7 @@ import com.subtracks.data.model.Song
 import com.subtracks.data.model.SongListItem
 import com.subtracks.ui.components.CoverArt
 import com.subtracks.ui.components.EmptyState
+import com.subtracks.ui.components.FilteredEmptyState
 import com.subtracks.ui.components.LoadingState
 import com.subtracks.ui.components.rememberViewportFill
 
@@ -48,6 +49,8 @@ fun SongsContent(
     bottomInset: Dp,
     onSongClick: (Int) -> Unit,
     playingSongId: String? = null,
+    filtered: Boolean = false,
+    onClearFilters: () -> Unit = {},
     resetKey: Any? = null,
     modifier: Modifier = Modifier,
 ) {
@@ -57,7 +60,11 @@ fun SongsContent(
         }
 
         items.itemCount == 0 -> {
-            EmptyState("No songs yet.", modifier)
+            if (filtered) {
+                FilteredEmptyState(onClearFilters, modifier)
+            } else {
+                EmptyState("No songs yet.", modifier)
+            }
         }
 
         else -> {