add library info dialogs and sort name preference

Album and artist context menus gain an Info dialog covering the plural
album artists, sort names and the play and download details the screens
do not show. Multiple artist links collapse into one ellipsised entry
that opens the artist chooser instead of listing each artist.

Sort lists can now prefer regular names over sort names, or only use
sort names for names without Latin letters. The new plain-name indexes
keep those orders out of a temp B-tree.

Also carry plural artists through the Media3 queue so Now Playing and
the mini player keep them, drop the album artist tap ripple, and show
the aggregate download progress in the tab bar where offline mode used
to sit.

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

@@ -50,11 +50,6 @@ internal const val ALBUMS_FILTER =
         "OR instr(lower(sortName), lower(:search)) > 0 " +
         "OR instr(lower(albumArtistSort), lower(:search)) > 0))) "
 
-internal const val ALBUM_ORDER_BY_NAME = "sortName COLLATE NOCASE, id"
-internal const val ALBUM_ORDER_BY_NAME_REVERSED = "sortName COLLATE NOCASE DESC, id DESC"
-internal const val ALBUM_ORDER_BY_ARTIST = "albumArtistSort COLLATE NOCASE, year, sortName COLLATE NOCASE, id"
-internal const val ALBUM_ORDER_BY_ARTIST_REVERSED =
-    "albumArtistSort COLLATE NOCASE DESC, year DESC, sortName COLLATE NOCASE DESC, id DESC"
 internal const val ALBUM_ORDER_BY_YEAR = "year DESC, sortName COLLATE NOCASE, id"
 internal const val ALBUM_ORDER_BY_YEAR_REVERSED = "year ASC, sortName COLLATE NOCASE DESC, id DESC"
 internal const val ALBUM_ORDER_BY_ADDED = "created DESC, sortName COLLATE NOCASE, id"
@@ -70,6 +65,16 @@ internal const val ALBUM_ORDER_BY_FREQUENT_REVERSED = "playCount ASC, sortName C
 internal const val ALBUM_ORDER_BY_RECENT = "played DESC NULLS LAST, sortName COLLATE NOCASE, id"
 internal const val ALBUM_ORDER_BY_RECENT_REVERSED = "played ASC NULLS LAST, sortName COLLATE NOCASE DESC, id DESC"
 
+private const val ALBUM_NAME_SORT_KEY_MODE =
+    "(CASE :sortMode WHEN 'Name' THEN name WHEN 'NonLatin' THEN (CASE WHEN name GLOB '*[A-Za-z]*' THEN name ELSE sortName END) ELSE sortName END) COLLATE NOCASE"
+private const val ALBUM_ARTIST_SORT_KEY_MODE =
+    "(CASE :sortMode WHEN 'Name' THEN albumArtist WHEN 'NonLatin' THEN (CASE WHEN albumArtist GLOB '*[A-Za-z]*' THEN albumArtist ELSE albumArtistSort END) ELSE albumArtistSort END) COLLATE NOCASE"
+internal const val ALBUM_ORDER_BY_NAME_SORT_MODE = "$ALBUM_NAME_SORT_KEY_MODE, id"
+internal const val ALBUM_ORDER_BY_NAME_SORT_MODE_REVERSED = "$ALBUM_NAME_SORT_KEY_MODE DESC, id DESC"
+internal const val ALBUM_ORDER_BY_ARTIST_SORT_MODE = "$ALBUM_ARTIST_SORT_KEY_MODE, year, $ALBUM_NAME_SORT_KEY_MODE, id"
+internal const val ALBUM_ORDER_BY_ARTIST_SORT_MODE_REVERSED =
+    "$ALBUM_ARTIST_SORT_KEY_MODE DESC, year DESC, $ALBUM_NAME_SORT_KEY_MODE DESC, id DESC"
+
 internal const val ARTIST_CREDITED =
     "(artists.credited = 1 OR COALESCE((SELECT creditsStale FROM sources WHERE id = artists.sourceId), 1) = 1)"
 
@@ -285,8 +290,6 @@ internal const val ARTISTS_SELECT =
         "artists.starred, artists.coverArt, artists.artistImageUrl, artists.coverArts, artists.downloadedCoverArts, " +
         "artists.playCount, artists.played, artists.songCount, artists.sortName, artists.credited "
 
-internal const val ARTIST_ORDER_BY_NAME = "sortName COLLATE NOCASE, id"
-internal const val ARTIST_ORDER_BY_NAME_REVERSED = "sortName COLLATE NOCASE DESC, id DESC"
 internal const val ARTIST_ORDER_BY_ALBUM_COUNT = "albumCount DESC, sortName COLLATE NOCASE, id"
 internal const val ARTIST_ORDER_BY_ALBUM_COUNT_REVERSED = "albumCount ASC, sortName COLLATE NOCASE DESC, id DESC"
 internal const val ARTIST_ORDER_BY_STARRED = "starred DESC NULLS LAST, sortName COLLATE NOCASE, id"
@@ -296,6 +299,15 @@ internal const val ARTIST_ORDER_BY_FREQUENT_REVERSED = "artists.playCount ASC, s
 internal const val ARTIST_ORDER_BY_RECENT = "artists.played DESC NULLS LAST, sortName COLLATE NOCASE, id"
 internal const val ARTIST_ORDER_BY_RECENT_REVERSED = "artists.played ASC NULLS LAST, sortName COLLATE NOCASE DESC, id DESC"
 
+private const val ARTIST_NAME_SORT_KEY_MODE =
+    "(CASE :sortMode WHEN 'Name' THEN name WHEN 'NonLatin' THEN (CASE WHEN name GLOB '*[A-Za-z]*' THEN name ELSE sortName END) ELSE sortName END) COLLATE NOCASE"
+internal const val ARTIST_ORDER_BY_NAME_SORT_MODE = "$ARTIST_NAME_SORT_KEY_MODE, id"
+internal const val ARTIST_ORDER_BY_NAME_SORT_MODE_REVERSED = "$ARTIST_NAME_SORT_KEY_MODE DESC, id DESC"
+
+private const val SONG_NAME_SORT_KEY_MODE =
+    "(CASE :sortMode WHEN 'Name' THEN songs.title WHEN 'NonLatin' THEN (CASE WHEN songs.title GLOB '*[A-Za-z]*' THEN songs.title ELSE songs.sortName END) ELSE songs.sortName END) COLLATE NOCASE"
+internal const val SONG_SEARCH_ORDER_SORT_MODE = "$SONG_NAME_SORT_KEY_MODE, songs.id"
+
 internal const val PLAYLISTS_FILTER =
     "FROM playlists WHERE sourceId = :sourceId " +
         "AND (:downloadedFilter = 0 OR EXISTS (SELECT 1 FROM playlist_songs ps " +
@@ -566,22 +578,24 @@ interface LibraryDao {
 
     @Query(
         "SELECT * FROM albums WHERE sourceId = :sourceId AND $ALBUM_SEARCH_FILTER " +
-            "ORDER BY sortName COLLATE NOCASE, id LIMIT :limit",
+            "ORDER BY $ALBUM_ORDER_BY_NAME_SORT_MODE LIMIT :limit",
     )
     fun searchAlbums(
         sourceId: Long,
         search: String,
         limit: Int,
+        sortMode: String = "",
     ): Flow<List<Album>>
 
     @Query(
         "SELECT $ARTIST_COLUMNS FROM artists WHERE sourceId = :sourceId AND $ARTIST_SEARCH_FILTER AND $ARTIST_CREDITED " +
-            "ORDER BY sortName COLLATE NOCASE, id LIMIT :limit",
+            "ORDER BY $ARTIST_ORDER_BY_NAME_SORT_MODE LIMIT :limit",
     )
     fun searchArtists(
         sourceId: Long,
         search: String,
         limit: Int,
+        sortMode: String = "",
     ): Flow<List<Artist>>
 
     @Query(
@@ -598,12 +612,13 @@ interface LibraryDao {
         "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 $SONG_SEARCH_FILTER " +
-            "ORDER BY songs.sortName COLLATE NOCASE, songs.id LIMIT :limit",
+            "ORDER BY $SONG_SEARCH_ORDER_SORT_MODE LIMIT :limit",
     )
     fun searchSongs(
         sourceId: Long,
         search: String,
         limit: Int,
+        sortMode: String = "",
     ): Flow<List<AlbumSongItem>>
 
     @Query(
@@ -745,36 +760,40 @@ interface LibraryDao {
     @RawQuery(observedEntities = [Playlist::class])
     fun playlistsPaging(query: RoomRawQuery): PagingSource<Int, Playlist>
 
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_NAME")
+    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_NAME_SORT_MODE")
     fun albumsByName(
         sourceId: Long,
         starredFilter: Int,
         search: String,
         downloadedFilter: Int = 0,
+        sortMode: String = "",
     ): PagingSource<Int, Album>
 
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_NAME_REVERSED")
+    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_NAME_SORT_MODE_REVERSED")
     fun albumsByNameReversed(
         sourceId: Long,
         starredFilter: Int,
         search: String,
         downloadedFilter: Int = 0,
+        sortMode: String = "",
     ): PagingSource<Int, Album>
 
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_ARTIST")
+    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_ARTIST_SORT_MODE")
     fun albumsByArtist(
         sourceId: Long,
         starredFilter: Int,
         search: String,
         downloadedFilter: Int = 0,
+        sortMode: String = "",
     ): PagingSource<Int, Album>
 
-    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_ARTIST_REVERSED")
+    @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_ARTIST_SORT_MODE_REVERSED")
     fun albumsByArtistReversed(
         sourceId: Long,
         starredFilter: Int,
         search: String,
         downloadedFilter: Int = 0,
+        sortMode: String = "",
     ): PagingSource<Int, Album>
 
     @Query("SELECT * $ALBUMS_FILTER ORDER BY $ALBUM_ORDER_BY_YEAR")
@@ -857,20 +876,22 @@ interface LibraryDao {
         downloadedFilter: Int = 0,
     ): PagingSource<Int, Album>
 
-    @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_NAME")
+    @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_NAME_SORT_MODE")
     fun artistsByName(
         sourceId: Long,
         starredFilter: Int,
         search: String,
         downloadedFilter: Int = 0,
+        sortMode: String = "",
     ): PagingSource<Int, Artist>
 
-    @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_NAME_REVERSED")
+    @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_NAME_SORT_MODE_REVERSED")
     fun artistsByNameReversed(
         sourceId: Long,
         starredFilter: Int,
         search: String,
         downloadedFilter: Int = 0,
+        sortMode: String = "",
     ): PagingSource<Int, Artist>
 
     @Query("$ARTISTS_SELECT $ARTISTS_FILTER ORDER BY $ARTIST_ORDER_BY_ALBUM_COUNT")

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

@@ -5,6 +5,7 @@ import androidx.sqlite.SQLiteStatement
 import com.subtracks.data.prefs.AlbumSort
 import com.subtracks.data.prefs.ArtistSort
 import com.subtracks.data.prefs.PlaylistSort
+import com.subtracks.data.prefs.SortNameMode
 
 // These filters mirror the download-aware ones in LibraryDao but never mention song_downloads, so
 // the resulting PagingSource is not invalidated by download writes (including progress updates).
@@ -42,8 +43,9 @@ internal fun albumsDefaultQuery(
     search: String,
     sort: AlbumSort,
     descending: Boolean,
+    sortNameMode: SortNameMode = SortNameMode.SortName,
 ): RoomRawQuery {
-    val order = albumOrder(sort, descending)
+    val order = albumOrder(sort, descending, sortNameMode)
     return RoomRawQuery("SELECT * $ALBUMS_FILTER_BASE ORDER BY $order") { stmt ->
         stmt.bindAlbumFilters(sourceId, starredFilter, search)
     }
@@ -88,8 +90,9 @@ internal fun artistsDefaultQuery(
     search: String,
     sort: ArtistSort,
     descending: Boolean,
+    sortNameMode: SortNameMode = SortNameMode.SortName,
 ): RoomRawQuery {
-    val order = artistOrder(sort, descending)
+    val order = artistOrder(sort, descending, sortNameMode)
     return RoomRawQuery("SELECT $ARTIST_COLUMNS $ARTISTS_FILTER_BASE ORDER BY $order") { stmt ->
         stmt.bindLong(1, sourceId)
         stmt.bindInt(2, starredFilter)
@@ -121,27 +124,82 @@ internal fun playlistsDefaultQuery(
     }
 }
 
+internal fun albumNameSortKey(mode: SortNameMode): String =
+    when (mode) {
+        SortNameMode.SortName -> "sortName COLLATE NOCASE"
+        SortNameMode.Name -> "name COLLATE NOCASE"
+        SortNameMode.NonLatin -> "(CASE WHEN name GLOB '*[A-Za-z]*' THEN name ELSE sortName END) COLLATE NOCASE"
+    }
+
+internal fun albumArtistSortKey(mode: SortNameMode): String =
+    when (mode) {
+        SortNameMode.SortName -> {
+            "albumArtistSort COLLATE NOCASE"
+        }
+
+        SortNameMode.Name -> {
+            "albumArtist COLLATE NOCASE"
+        }
+
+        SortNameMode.NonLatin -> {
+            "(CASE WHEN albumArtist GLOB '*[A-Za-z]*' THEN albumArtist ELSE albumArtistSort END) COLLATE NOCASE"
+        }
+    }
+
+internal fun artistNameSortKey(mode: SortNameMode): String =
+    when (mode) {
+        SortNameMode.SortName -> "sortName COLLATE NOCASE"
+        SortNameMode.Name -> "name COLLATE NOCASE"
+        SortNameMode.NonLatin -> "(CASE WHEN name GLOB '*[A-Za-z]*' THEN name ELSE sortName END) COLLATE NOCASE"
+    }
+
 private fun albumOrder(
     sort: AlbumSort,
     descending: Boolean,
+    mode: SortNameMode,
 ): String =
     when (sort) {
-        AlbumSort.Name -> if (descending) ALBUM_ORDER_BY_NAME_REVERSED else ALBUM_ORDER_BY_NAME
+        AlbumSort.Name -> {
-        AlbumSort.Artist -> if (descending) ALBUM_ORDER_BY_ARTIST_REVERSED else ALBUM_ORDER_BY_ARTIST
+            val name = albumNameSortKey(mode)
-        AlbumSort.Year -> if (descending) ALBUM_ORDER_BY_YEAR_REVERSED else ALBUM_ORDER_BY_YEAR
+            if (descending) "$name DESC, id DESC" else "$name, id"
-        AlbumSort.Added -> if (descending) ALBUM_ORDER_BY_ADDED_REVERSED else ALBUM_ORDER_BY_ADDED
+        }
-        AlbumSort.Starred -> if (descending) ALBUM_ORDER_BY_STARRED_REVERSED else ALBUM_ORDER_BY_STARRED
+
-        AlbumSort.Frequent -> if (descending) ALBUM_ORDER_BY_FREQUENT_REVERSED else ALBUM_ORDER_BY_FREQUENT
+        AlbumSort.Artist -> {
-        AlbumSort.Recent -> if (descending) ALBUM_ORDER_BY_RECENT_REVERSED else ALBUM_ORDER_BY_RECENT
+            val artist = albumArtistSortKey(mode)
+            val name = albumNameSortKey(mode)
+            if (descending) "$artist DESC, year DESC, $name DESC, id DESC" else "$artist, year, $name, id"
+        }
+
+        AlbumSort.Year -> {
+            if (descending) ALBUM_ORDER_BY_YEAR_REVERSED else ALBUM_ORDER_BY_YEAR
+        }
+
+        AlbumSort.Added -> {
+            if (descending) ALBUM_ORDER_BY_ADDED_REVERSED else ALBUM_ORDER_BY_ADDED
+        }
+
+        AlbumSort.Starred -> {
+            if (descending) ALBUM_ORDER_BY_STARRED_REVERSED else ALBUM_ORDER_BY_STARRED
+        }
+
+        AlbumSort.Frequent -> {
+            if (descending) ALBUM_ORDER_BY_FREQUENT_REVERSED else ALBUM_ORDER_BY_FREQUENT
+        }
+
+        AlbumSort.Recent -> {
+            if (descending) ALBUM_ORDER_BY_RECENT_REVERSED else ALBUM_ORDER_BY_RECENT
+        }
     }
 
 private fun artistOrder(
     sort: ArtistSort,
     descending: Boolean,
+    mode: SortNameMode,
 ): String =
     when (sort) {
         ArtistSort.Name -> {
-            if (descending) ARTIST_ORDER_BY_NAME_REVERSED else ARTIST_ORDER_BY_NAME
+            val name = artistNameSortKey(mode)
+            if (descending) "$name DESC, id DESC" else "$name, id"
         }
 
         ArtistSort.AlbumCount -> {

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

@@ -706,6 +706,22 @@ val MIGRATION_35_36 =
         }
     }
 
+val MIGRATION_36_37 =
+    object : Migration(36, 37) {
+        override suspend fun migrate(connection: SQLiteConnection) {
+            connection.execSQL(
+                "CREATE INDEX IF NOT EXISTS `index_albums_name_plain` ON `albums` (`sourceId`, `name`, `id`)",
+            )
+            connection.execSQL(
+                "CREATE INDEX IF NOT EXISTS `index_albums_artist_plain` " +
+                    "ON `albums` (`sourceId`, `albumArtist`, `year`, `name`, `id`)",
+            )
+            connection.execSQL(
+                "CREATE INDEX IF NOT EXISTS `index_artists_name_plain` ON `artists` (`sourceId`, `name`, `id`)",
+            )
+        }
+    }
+
 internal fun artistSearchTriggersOptimized(connection: SQLiteConnection): Boolean {
     val triggers = mutableListOf<String>()
     connection.prepare("SELECT sql FROM sqlite_master WHERE type = 'trigger' AND name IN (?, ?)").use { statement ->
@@ -782,4 +798,5 @@ val MIGRATIONS: Array<Migration> =
         MIGRATION_33_34,
         MIGRATION_34_35,
         MIGRATION_35_36,
+        MIGRATION_36_37,
     )

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

@@ -57,7 +57,7 @@ import com.subtracks.data.model.UpNextEntry
         SongDownload::class,
         PendingAction::class,
     ],
-    version = 36,
+    version = 37,
     exportSchema = true,
 )
 @ColumnTypeConverters(

app/src/main/kotlin/com/subtracks/data/model/Download.kt

@@ -58,9 +58,14 @@ data class SongDownload(
     @ColumnInfo(defaultValue = "0") val downloadedAt: Long = 0,
 ) {
     val progress: Float?
-        get() = total.takeIf { it > 0 }?.let { (bytes.toFloat() / it).coerceIn(0f, 1f) }
+        get() = fractionOf(bytes, total)
 }
 
+internal fun fractionOf(
+    bytes: Long,
+    total: Long,
+): Float? = total.takeIf { it > 0 }?.let { (bytes.toFloat() / it).coerceIn(0f, 1f) }
+
 enum class DownloadList { Album, Playlist, Artist }
 
 enum class BulkDownloadAction { Download, Cancel, Delete }
@@ -73,6 +78,13 @@ data class ListDownloadStatus(
     val complete: Boolean get() = total > 0 && downloaded == total
 }
 
+data class DownloadProgress(
+    val bytes: Long,
+    val total: Long,
+) {
+    val fraction: Float? get() = fractionOf(bytes, total)
+}
+
 data class EntityDownloadStatus(
     val id: String,
     val total: Long = 0,
@@ -99,7 +111,7 @@ data class DownloadedSong(
     val songSort: String = title,
 ) {
     val progress: Float?
-        get() = total.takeIf { it > 0 }?.let { (bytes.toFloat() / it).coerceIn(0f, 1f) }
+        get() = fractionOf(bytes, total)
 }
 
 data class DownloadArtwork(

app/src/main/kotlin/com/subtracks/data/model/Models.kt

@@ -59,6 +59,7 @@ data class ArtistRef(
     indices = [
         Index("sourceId"),
         Index(name = "index_artists_name", value = ["sourceId", "sortName", "id"]),
+        Index(name = "index_artists_name_plain", value = ["sourceId", "name", "id"]),
         Index(
             name = "index_artists_albumCount",
             value = ["sourceId", "albumCount", "sortName", "id"],
@@ -131,7 +132,9 @@ data class ArtistBio(
         Index("sourceId"),
         Index("sourceId", "artistId"),
         Index(name = "index_albums_name", value = ["sourceId", "sortName", "id"]),
+        Index(name = "index_albums_name_plain", value = ["sourceId", "name", "id"]),
         Index(name = "index_albums_artist", value = ["sourceId", "albumArtistSort", "year", "sortName", "id"]),
+        Index(name = "index_albums_artist_plain", value = ["sourceId", "albumArtist", "year", "name", "id"]),
         Index(
             name = "index_albums_year",
             value = ["sourceId", "year", "sortName", "id"],

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

@@ -16,6 +16,8 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 
+enum class SortNameMode { SortName, Name, NonLatin }
+
 enum class AlbumSort { Name, Artist, Year, Added, Starred, Frequent, Recent }
 
 enum class ArtistSort { Name, AlbumCount, Starred, Frequent, Recent }
@@ -182,6 +184,17 @@ class UserPreferences(
 
     private val keepScreenOnKey = booleanPreferencesKey("keep_screen_on")
 
+    fun sortNameMode(): Flow<SortNameMode> =
+        store.data.map { prefs ->
+            prefs[sortNameModeKey]?.let { stored -> SortNameMode.entries.firstOrNull { it.name == stored } } ?: SortNameMode.SortName
+        }
+
+    suspend fun setSortNameMode(mode: SortNameMode) {
+        store.edit { prefs -> prefs[sortNameModeKey] = mode.name }
+    }
+
+    private val sortNameModeKey = stringPreferencesKey("sort_name_mode")
+
     fun offlineMode(): Flow<Boolean> = store.data.map { prefs -> prefs[offlineModeKey] ?: false }
 
     suspend fun setOfflineMode(enabled: Boolean) {

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

@@ -24,27 +24,32 @@ import com.subtracks.data.prefs.AlbumSort
 import com.subtracks.data.prefs.ArtistSort
 import com.subtracks.data.prefs.PlaylistSort
 import com.subtracks.data.prefs.StarredFilter
+import com.subtracks.data.prefs.UserPreferences
 import com.subtracks.data.source.ServerActionSink
 import com.subtracks.data.source.StarType
 import com.subtracks.log.Log
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
 
+@OptIn(ExperimentalCoroutinesApi::class)
 class LibraryRepository(
     private val db: SubtracksDatabase,
     private val sourceRepository: SourceRepository,
     private val serverActions: ServerActionSink,
+    private val userPreferences: UserPreferences,
     private val showMessage: (UiMessage) -> Unit = {},
     private val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO),
 ) {
@@ -111,12 +116,18 @@ class LibraryRepository(
     fun searchAlbums(
         sourceId: Long,
         query: String,
-    ): Flow<List<Album>> = db.libraryDao().searchAlbums(sourceId, query, SEARCH_RESULT_LIMIT)
+    ): Flow<List<Album>> =
+        userPreferences.sortNameMode().flatMapLatest { mode ->
+            db.libraryDao().searchAlbums(sourceId, query, SEARCH_RESULT_LIMIT, mode.name)
+        }
 
     fun searchArtists(
         sourceId: Long,
         query: String,
-    ): Flow<List<Artist>> = db.libraryDao().searchArtists(sourceId, query, SEARCH_RESULT_LIMIT)
+    ): Flow<List<Artist>> =
+        userPreferences.sortNameMode().flatMapLatest { mode ->
+            db.libraryDao().searchArtists(sourceId, query, SEARCH_RESULT_LIMIT, mode.name)
+        }
 
     fun searchPlaylists(
         sourceId: Long,
@@ -126,7 +137,10 @@ class LibraryRepository(
     fun searchSongs(
         sourceId: Long,
         query: String,
-    ): Flow<List<AlbumSongItem>> = db.libraryDao().searchSongs(sourceId, query, SEARCH_RESULT_LIMIT)
+    ): Flow<List<AlbumSongItem>> =
+        userPreferences.sortNameMode().flatMapLatest { mode ->
+            db.libraryDao().searchSongs(sourceId, query, SEARCH_RESULT_LIMIT, mode.name)
+        }
 
     fun downloadedAlbumsPage(sourceId: Long): Flow<PagingData<Album>> = pager(40) { db.libraryDao().downloadedAlbums(sourceId) }
 
@@ -178,26 +192,27 @@ class LibraryRepository(
         search: String,
         downloaded: Boolean,
     ): Flow<PagingData<Album>> =
+        userPreferences.sortNameMode().flatMapLatest { mode ->
             pager(40, enablePlaceholders = true) {
                 val dao = db.libraryDao()
                 if (!downloaded) {
-                dao.albumsPaging(albumsDefaultQuery(sourceId, starred.ordinal, search, sort, descending))
+                    dao.albumsPaging(albumsDefaultQuery(sourceId, starred.ordinal, search, sort, descending, mode))
                 } else {
                     val downloadedFilter = 1
                     when (sort) {
                         AlbumSort.Name -> {
                             if (descending) {
-                            dao.albumsByNameReversed(sourceId, starred.ordinal, search, downloadedFilter)
+                                dao.albumsByNameReversed(sourceId, starred.ordinal, search, downloadedFilter, mode.name)
                             } else {
-                            dao.albumsByName(sourceId, starred.ordinal, search, downloadedFilter)
+                                dao.albumsByName(sourceId, starred.ordinal, search, downloadedFilter, mode.name)
                             }
                         }
 
                         AlbumSort.Artist -> {
                             if (descending) {
-                            dao.albumsByArtistReversed(sourceId, starred.ordinal, search, downloadedFilter)
+                                dao.albumsByArtistReversed(sourceId, starred.ordinal, search, downloadedFilter, mode.name)
                             } else {
-                            dao.albumsByArtist(sourceId, starred.ordinal, search, downloadedFilter)
+                                dao.albumsByArtist(sourceId, starred.ordinal, search, downloadedFilter, mode.name)
                             }
                         }
 
@@ -243,6 +258,7 @@ class LibraryRepository(
                     }
                 }
             }
+        }
 
     fun artists(
         sourceId: Long,
@@ -252,18 +268,19 @@ class LibraryRepository(
         search: String,
         downloaded: Boolean,
     ): Flow<PagingData<Artist>> =
+        userPreferences.sortNameMode().flatMapLatest { mode ->
             pager(60) {
                 val dao = db.libraryDao()
                 if (!downloaded) {
-                dao.artistsPaging(artistsDefaultQuery(sourceId, starred.ordinal, search, sort, descending))
+                    dao.artistsPaging(artistsDefaultQuery(sourceId, starred.ordinal, search, sort, descending, mode))
                 } else {
                     val downloadedFilter = 1
                     when (sort) {
                         ArtistSort.Name -> {
                             if (descending) {
-                            dao.artistsByNameReversed(sourceId, starred.ordinal, search, downloadedFilter)
+                                dao.artistsByNameReversed(sourceId, starred.ordinal, search, downloadedFilter, mode.name)
                             } else {
-                            dao.artistsByName(sourceId, starred.ordinal, search, downloadedFilter)
+                                dao.artistsByName(sourceId, starred.ordinal, search, downloadedFilter, mode.name)
                             }
                         }
 
@@ -301,6 +318,7 @@ class LibraryRepository(
                     }
                 }
             }
+        }
 
     fun playlists(
         sourceId: Long,

app/src/main/kotlin/com/subtracks/di/AppModule.kt

@@ -96,7 +96,7 @@ fun appModule(
             scope = get(),
         )
     }
-    single { LibraryRepository(get(), get(), get(), toast, scope = get(named("io"))) }
+    single { LibraryRepository(get(), get(), get(), get(), toast, scope = get(named("io"))) }
     single<ArtworkSeedStore> { ArtworkSeedRepository(get()) }
     single { SyncManager(get(), get(), get(), get(), preferences = get(), showMessage = toast, scope = get()) }
     single {

app/src/main/kotlin/com/subtracks/playback/Media3PlayerHandle.kt

@@ -12,6 +12,8 @@ import androidx.media3.common.util.UnstableApi
 import androidx.media3.session.MediaController
 import com.subtracks.R
 import com.subtracks.UiMessage
+import com.subtracks.data.model.ArtistRef
+import com.subtracks.data.model.ArtistRefsCodec
 import com.subtracks.data.model.AudioEncoding
 import com.subtracks.data.repo.DownloadRepository
 import com.subtracks.data.repo.SourceRepository
@@ -229,6 +231,7 @@ class Media3PlayerHandle(
                     .orEmpty(),
             artist = mediaItem.mediaMetadata.artist?.toString(),
             album = mediaItem.mediaMetadata.albumTitle?.toString(),
+            artists = mediaItem.artistRefs(),
             coverArtId = mediaItem.mediaMetadata.extras?.getString(EXTRA_COVER_ART_ID),
             durationMs =
                 mediaItem.mediaMetadata.extras
@@ -238,7 +241,14 @@ class Media3PlayerHandle(
         )
 }
 
+internal fun MediaItem.artistRefs(): List<ArtistRef> =
+    mediaMetadata.extras
+        ?.getString(EXTRA_ARTISTS)
+        ?.let(ArtistRefsCodec::decode)
+        .orEmpty()
+
 private const val EXTRA_COVER_ART_ID = "coverArtId"
+private const val EXTRA_ARTISTS = "artists"
 private const val EXTRA_DURATION_MS = "durationMs"
 private const val EXTRA_REPLAY_GAIN_TRACK_GAIN = "replayGainTrackGain"
 private const val EXTRA_REPLAY_GAIN_ALBUM_GAIN = "replayGainAlbumGain"
@@ -286,6 +296,7 @@ internal fun queueMediaItem(
             .setExtras(
                 Bundle().apply {
                     putString(EXTRA_COVER_ART_ID, item.coverArtId)
+                    putString(EXTRA_ARTISTS, ArtistRefsCodec.encode(item.artists))
                     item.durationMs?.let { putLong(EXTRA_DURATION_MS, it) }
                     putGain(EXTRA_REPLAY_GAIN_TRACK_GAIN, item.replayGain.trackGain)
                     putGain(EXTRA_REPLAY_GAIN_ALBUM_GAIN, item.replayGain.albumGain)

app/src/main/kotlin/com/subtracks/playback/PlaybackController.kt

@@ -1,6 +1,7 @@
 package com.subtracks.playback
 
 import com.subtracks.UiMessage
+import com.subtracks.data.model.ArtistRef
 import com.subtracks.data.model.AudioEncoding
 import com.subtracks.data.model.CoverArtRef
 import com.subtracks.data.model.QueueEntry
@@ -36,6 +37,7 @@ data class QueueItem(
     val durationMs: Long? = null,
     val replayGain: ReplayGain = ReplayGain(),
     val albumContext: Boolean = false,
+    val artists: List<ArtistRef> = emptyList(),
 )
 
 data class QueueContext(

app/src/main/kotlin/com/subtracks/playback/QueueItem.kt

@@ -1,5 +1,6 @@
 package com.subtracks.playback
 
+import com.subtracks.data.model.ArtistRef
 import com.subtracks.data.model.SongItem
 
 fun SongItem.toQueueItem(albumContext: Boolean = false) =
@@ -7,6 +8,7 @@ fun SongItem.toQueueItem(albumContext: Boolean = false) =
         id = song.id,
         title = song.title,
         artist = song.artist,
+        artists = song.artistRefs,
         album = song.album,
         coverArtId = coverArt,
         durationMs = song.duration?.let { it * 1000 },

app/src/main/kotlin/com/subtracks/ui/AppRoot.kt

@@ -61,14 +61,19 @@ import androidx.navigation.compose.currentBackStackEntryAsState
 import androidx.navigation.compose.rememberNavController
 import androidx.navigation.navArgument
 import com.subtracks.R
+import com.subtracks.data.model.ArtistRef
 import com.subtracks.data.model.Song
 import com.subtracks.data.repo.DownloadRepository
 import com.subtracks.data.repo.LibraryRepository
 import com.subtracks.data.repo.SourceRepository
 import com.subtracks.playback.PlaybackController
+import com.subtracks.ui.components.AlbumInfoDialog
+import com.subtracks.ui.components.ArtistChooserSheet
+import com.subtracks.ui.components.ArtistInfoDialog
 import com.subtracks.ui.components.ContextMenuHost
 import com.subtracks.ui.components.ItemContextMenu
 import com.subtracks.ui.components.LoadingState
+import com.subtracks.ui.components.MenuTarget
 import com.subtracks.ui.components.SongInfoDialog
 import com.subtracks.ui.components.statusBarScrim
 import com.subtracks.ui.downloads.DownloadsRoute
@@ -230,7 +235,8 @@ private fun MainNavigation() {
     var settleJob by remember { mutableStateOf<Job?>(null) }
     val scope = rememberCoroutineScope()
     val contextMenuHost = remember { ContextMenuHost() }
-    var infoSong by remember { mutableStateOf<Song?>(null) }
+    var infoTarget by remember { mutableStateOf<MenuTarget?>(null) }
+    var artistChooser by remember { mutableStateOf<List<ArtistRef>?>(null) }
 
     val activeSourceId by libraryRepository.activeSourceId.collectAsStateWithLifecycle(initialValue = null)
     var previousSourceId by rememberSaveable { mutableStateOf<Long?>(null) }
@@ -312,7 +318,8 @@ private fun MainNavigation() {
         nowPlayingLauncher.openNowPlaying.collect {
             focusManager.clearFocus()
             contextMenuHost.dismissTransients()
-            infoSong = null
+            infoTarget = null
+            artistChooser = null
             showingQueue = false
             if (navController.currentDestination?.route in DETAIL_ROUTES) {
                 navController.popBackStack(Routes.LIBRARY, inclusive = false)
@@ -389,6 +396,7 @@ private fun MainNavigation() {
                                 navigateDetail(Routes.PLAYLIST_DETAIL, "playlistId", playlist.id, Routes.playlist(playlist.id))
                             },
                             onOpenSettings = { navController.navigate(Routes.SETTINGS) },
+                            onOpenDownloads = { navController.navigate(Routes.DOWNLOADS) },
                             onOpenSearch = { navController.navigate(Routes.SEARCH) },
                             onViewAlbum = { albumId -> navigateDetail(Routes.ALBUM_DETAIL, "albumId", albumId, Routes.album(albumId)) },
                             onViewArtist = { artistId ->
@@ -773,11 +781,30 @@ private fun MainNavigation() {
                     target = target,
                     actions = contextMenuHost.actions,
                     onDismiss = { contextMenuHost.dismiss() },
-                    onInfo = { infoSong = it },
+                    onInfo = { infoTarget = it },
+                    onChooseArtists = { artistChooser = it },
                 )
             }
 
-            infoSong?.let { song ->
+            artistChooser?.let { artists ->
+                ArtistChooserSheet(
+                    artists = artists,
+                    onArtistClick = { artist ->
+                        artistChooser = null
+                        navigateDetail(
+                            Routes.ARTIST_DETAIL,
+                            "artistId",
+                            artist.id,
+                            Routes.artist(artist.id),
+                        )
+                    },
+                    onDismiss = { artistChooser = null },
+                )
+            }
+
+            when (val target = infoTarget) {
+                is MenuTarget.Song -> {
+                    val song = target.song
                     val genres by
                         remember(song.sourceId, song.id) { libraryRepository.songGenres(song.sourceId, song.id) }
                             .collectAsStateWithLifecycle(initialValue = emptyList())
@@ -786,10 +813,30 @@ private fun MainNavigation() {
                         download = downloads[song.id],
                         localFile = downloadRepository.localFile(song.id),
                         streamEncoding = playbackController.currentAudioEncoding().takeIf { playback.item?.id == song.id },
-                    onDismiss = { infoSong = null },
+                        onDismiss = { infoTarget = null },
                         genres = genres,
                     )
                 }
+
+                is MenuTarget.Album -> {
+                    AlbumInfoDialog(
+                        album = target.album,
+                        download = target.download,
+                        onDismiss = { infoTarget = null },
+                    )
+                }
+
+                is MenuTarget.Artist -> {
+                    ArtistInfoDialog(
+                        artist = target.artist,
+                        onDismiss = { infoTarget = null },
+                    )
+                }
+
+                is MenuTarget.Playlist, null -> {
+                    Unit
+                }
+            }
         }
     }
 

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

@@ -291,7 +291,11 @@ fun HeroHeader(
                 modifier =
                     Modifier
                         .heightIn(min = 32.dp)
-                        .clickable(onClickLabel = stringResource(R.string.open_artist)) { onSubtitleClick() },
+                        .clickable(
+                            interactionSource = remember { MutableInteractionSource() },
+                            indication = null,
+                            onClickLabel = stringResource(R.string.open_artist),
+                        ) { onSubtitleClick() },
                 contentAlignment = Alignment.TopCenter,
             ) {
                 HeroSubtitle(subtitle, Modifier.padding(top = 4.dp))

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

@@ -15,6 +15,7 @@ import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.rounded.KeyboardArrowRight
 import androidx.compose.material.icons.automirrored.rounded.QueueMusic
 import androidx.compose.material.icons.rounded.Album
 import androidx.compose.material.icons.rounded.Cancel
@@ -50,6 +51,7 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import com.subtracks.R
+import com.subtracks.data.model.ArtistRef
 import com.subtracks.data.model.BulkDownloadAction
 import com.subtracks.data.model.CoverArtRef
 import com.subtracks.data.model.DownloadList
@@ -197,7 +199,8 @@ fun ItemContextMenu(
     target: MenuTarget,
     actions: ItemActions,
     onDismiss: () -> Unit,
-    onInfo: ((SongModel) -> Unit)? = null,
+    onInfo: ((MenuTarget) -> Unit)? = null,
+    onChooseArtists: ((List<ArtistRef>) -> Unit)? = null,
 ) {
     val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
     val scope = rememberCoroutineScope()
@@ -210,6 +213,14 @@ fun ItemContextMenu(
         }
     }
 
+    fun dismissThen(after: () -> Unit) {
+        scope.launch {
+            sheetState.hide()
+            onDismiss()
+            after()
+        }
+    }
+
     val queueRef = target.queueRef()
 
     @Composable
@@ -256,18 +267,9 @@ fun ItemContextMenu(
                             }
                         }
                     }
-                    target.song.artistRefs.forEach { artist ->
+                    ArtistItems(target.song.artistRefs, actions, onChooseArtists, ::dismiss, ::dismissThen)
-                        actions.viewArtist?.let { view ->
-                            MenuItem(
-                                Icons.Rounded.Person,
-                                artist.name.takeIf { it.isNotBlank() } ?: stringResource(R.string.resources_filter_artist),
-                            ) {
-                                dismiss { view(artist.id) }
-                            }
-                        }
-                    }
                     onInfo?.let { info ->
-                        MenuItem(Icons.Rounded.Info, stringResource(R.string.info)) { dismiss { info(target.song) } }
+                        MenuItem(Icons.Rounded.Info, stringResource(R.string.info)) { dismiss { info(target) } }
                     }
                 }
 
@@ -279,15 +281,9 @@ fun ItemContextMenu(
                         onSet = { starring -> actions.setStar(StarType.Album, target.album.id, starring) },
                         onDismiss = { dismiss() },
                     )
-                    target.album.artistRefs.forEach { artist ->
+                    ArtistItems(target.album.artistRefs, actions, onChooseArtists, ::dismiss, ::dismissThen)
-                        actions.viewArtist?.let { view ->
+                    onInfo?.let { info ->
-                            MenuItem(
+                        MenuItem(Icons.Rounded.Info, stringResource(R.string.info)) { dismiss { info(target) } }
-                                Icons.Rounded.Person,
-                                artist.name.takeIf { it.isNotBlank() } ?: stringResource(R.string.resources_filter_artist),
-                            ) {
-                                dismiss { view(artist.id) }
-                            }
-                        }
                     }
                 }
 
@@ -298,6 +294,9 @@ fun ItemContextMenu(
                         onSet = { starring -> actions.setStar(StarType.Artist, target.artist.id, starring) },
                         onDismiss = { dismiss() },
                     )
+                    onInfo?.let { info ->
+                        MenuItem(Icons.Rounded.Info, stringResource(R.string.info)) { dismiss { info(target) } }
+                    }
                 }
 
                 is MenuTarget.Playlist -> {
@@ -342,6 +341,55 @@ private fun MenuHeader(target: MenuTarget) {
     }
 }
 
+@Composable
+private fun ArtistItems(
+    artists: List<ArtistRef>,
+    actions: ItemActions,
+    onChooseArtists: ((List<ArtistRef>) -> Unit)?,
+    dismiss: (() -> Unit) -> Unit,
+    dismissThen: (() -> Unit) -> Unit,
+) {
+    val view = actions.viewArtist ?: return
+    val distinct = artists.distinctBy { it.id }
+    when (distinct.size) {
+        0 -> {
+            Unit
+        }
+
+        1 -> {
+            val artist = distinct.first()
+            MenuItem(
+                Icons.Rounded.Person,
+                artist.name.takeIf { it.isNotBlank() } ?: stringResource(R.string.resources_filter_artist),
+            ) {
+                dismiss { view(artist.id) }
+            }
+        }
+
+        else -> {
+            if (onChooseArtists == null) {
+                distinct.forEach { artist ->
+                    MenuItem(
+                        Icons.Rounded.Person,
+                        artist.name.takeIf { it.isNotBlank() } ?: stringResource(R.string.resources_filter_artist),
+                    ) {
+                        dismiss { view(artist.id) }
+                    }
+                }
+            } else {
+                val fallback = stringResource(R.string.resources_filter_artist)
+                MenuItem(
+                    Icons.Rounded.Person,
+                    distinct.joinToString(" \u00B7 ") { it.name.ifBlank { fallback } },
+                    trailing = { Icon(Icons.AutoMirrored.Rounded.KeyboardArrowRight, contentDescription = null) },
+                ) {
+                    dismissThen { onChooseArtists(distinct) }
+                }
+            }
+        }
+    }
+}
+
 @Composable
 private fun DownloadItem(
     download: SongDownload?,
@@ -439,11 +487,19 @@ private fun MenuItem(
     icon: ImageVector,
     label: String,
     tint: Color? = null,
+    trailing: (@Composable () -> Unit)? = null,
     onClick: () -> Unit,
 ) {
     ListItem(
-        headlineContent = { Text(label) },
+        headlineContent = {
+            Text(
+                text = label,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+            )
+        },
         leadingContent = { Icon(icon, contentDescription = null, tint = tint ?: LocalContentColor.current) },
+        trailingContent = trailing,
         colors = ListItemDefaults.colors(containerColor = Color.Transparent),
         modifier = Modifier.clickable(onClick = onClick),
     )

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

@@ -0,0 +1,129 @@
+package com.subtracks.ui.components
+
+import android.content.Context
+import android.text.format.DateUtils
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import com.subtracks.R
+import com.subtracks.data.model.Album
+import com.subtracks.data.model.Artist
+import com.subtracks.data.model.ArtistRef
+import com.subtracks.data.model.ListDownloadStatus
+
+private const val ARTIST_SEPARATOR = " \u00B7 "
+
+@Composable
+fun AlbumInfoDialog(
+    album: Album,
+    download: ListDownloadStatus?,
+    onDismiss: () -> Unit,
+) {
+    val context = LocalContext.current
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.info)) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+                InfoRow(stringResource(R.string.resources_sort_by_title), album.name)
+                InfoRow(stringResource(R.string.info_sort_title), album.sortName)
+                InfoRow(stringResource(R.string.info_album_artists), album.artistRefs.names())
+                InfoRow(stringResource(R.string.info_album_artist_sort), album.albumArtistSort)
+                InfoRow(stringResource(R.string.resources_sort_by_year), album.year?.takeIf { it > 0 }?.toString())
+                InfoRow(stringResource(R.string.resources_filter_genre), album.genre)
+                InfoRow(stringResource(R.string.info_songs), album.songCount.takeIf { it > 0 }?.toString())
+                download?.takeIf { it.total > 0 }?.let { status ->
+                    InfoRow(
+                        stringResource(R.string.status_downloaded),
+                        stringResource(R.string.info_downloaded_count, status.downloaded, status.total),
+                    )
+                }
+                InfoRow(stringResource(R.string.info_added), album.created.takeIf { it > 0 }?.let { formatDate(context, it) })
+                InfoRow(stringResource(R.string.info_plays), album.playCount.takeIf { it > 0 }?.toString())
+                InfoRow(stringResource(R.string.info_last_played), album.played?.let { formatDate(context, it) })
+                InfoRow(stringResource(R.string.info_starred), if (album.starred != null) stringResource(R.string.info_yes) else null)
+            }
+        },
+        confirmButton = { TextButton(onClick = onDismiss) { Text(stringResource(R.string.info_close)) } },
+    )
+}
+
+@Composable
+fun ArtistInfoDialog(
+    artist: Artist,
+    onDismiss: () -> Unit,
+) {
+    val context = LocalContext.current
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.info)) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+                InfoRow(stringResource(R.string.resources_filter_artist), artist.name)
+                InfoRow(stringResource(R.string.info_sort_name), artist.sortName)
+                InfoRow(stringResource(R.string.info_albums), artist.albumCount.takeIf { it > 0 }?.toString())
+                InfoRow(stringResource(R.string.info_songs), artist.songCount.takeIf { it > 0 }?.toString())
+                InfoRow(stringResource(R.string.info_plays), artist.playCount.takeIf { it > 0 }?.toString())
+                InfoRow(stringResource(R.string.info_last_played), artist.played?.let { formatDate(context, it) })
+                InfoRow(stringResource(R.string.info_starred), if (artist.starred != null) stringResource(R.string.info_yes) else null)
+            }
+        },
+        confirmButton = { TextButton(onClick = onDismiss) { Text(stringResource(R.string.info_close)) } },
+    )
+}
+
+@Composable
+internal fun InfoRow(
+    label: String,
+    value: String?,
+) {
+    if (value.isNullOrBlank()) return
+    Row(
+        modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(
+            text = label,
+            style = MaterialTheme.typography.bodySmall,
+            color = MaterialTheme.colorScheme.primary,
+            modifier = Modifier.width(INFO_LABEL_WIDTH),
+        )
+        Text(
+            text = value,
+            style = MaterialTheme.typography.bodyMedium,
+            modifier = Modifier.weight(1f),
+        )
+    }
+}
+
+private fun List<ArtistRef>.names(): String? =
+    map { it.name }
+        .filter { it.isNotBlank() }
+        .distinct()
+        .joinToString(ARTIST_SEPARATOR)
+        .takeIf { it.isNotEmpty() }
+
+private fun formatDate(
+    context: Context,
+    epochSeconds: Long,
+): String =
+    DateUtils.formatDateTime(
+        context,
+        epochSeconds * 1000,
+        DateUtils.FORMAT_SHOW_DATE or DateUtils.FORMAT_SHOW_YEAR,
+    )
+
+private val INFO_LABEL_WIDTH = 96.dp

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

@@ -1,10 +1,16 @@
 package com.subtracks.ui.components
 
+import com.subtracks.data.model.ArtistRef
 import com.subtracks.data.model.Song
 
 private const val ARTIST_SEPARATOR = " \u00B7 "
 
-internal fun Song.artistSubtitle(): String? {
+internal fun Song.artistSubtitle(): String? = artistSubtitle(artist, artists)
+
+internal fun artistSubtitle(
+    artist: String?,
+    artists: List<ArtistRef>,
+): String? {
     val names = artists.map { it.name }.filter { it.isNotBlank() }.distinct()
     if (names.isEmpty()) return artist?.takeIf { it.isNotBlank() }
     val primary = artist?.takeIf { it in names }

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

@@ -4,12 +4,7 @@ import android.text.format.DateUtils
 import android.text.format.Formatter
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
 import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
@@ -18,8 +13,6 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
@@ -54,7 +47,14 @@ fun SongInfoDialog(
         text = {
             Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
                 InfoRow(stringResource(R.string.resources_sort_by_title), song.title)
-                InfoRow(stringResource(R.string.resources_filter_artist), song.artistSubtitle())
+                InfoRow(stringResource(R.string.info_sort_title), song.sortName)
+                InfoRow(
+                    stringResource(
+                        if (song.artistRefs.size > 1) R.string.info_artists else R.string.resources_filter_artist,
+                    ),
+                    song.artistSubtitle(),
+                )
+                InfoRow(stringResource(R.string.info_artist_sort), song.artistSort)
                 InfoRow(stringResource(R.string.resources_filter_album), song.album)
                 InfoRow(stringResource(R.string.info_duration), song.duration?.let(DateUtils::formatElapsedTime))
                 InfoRow(
@@ -92,32 +92,6 @@ fun SongInfoDialog(
     )
 }
 
-@Composable
-private fun InfoRow(
-    label: String,
-    value: String?,
-) {
-    if (value.isNullOrBlank()) return
-    Row(
-        modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp),
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        Text(
-            text = label,
-            style = MaterialTheme.typography.bodySmall,
-            color = MaterialTheme.colorScheme.primary,
-            modifier = Modifier.width(INFO_LABEL_WIDTH),
-        )
-        Text(
-            text = value,
-            style = MaterialTheme.typography.bodyMedium,
-            modifier = Modifier.weight(1f),
-        )
-    }
-}
-
-private val INFO_LABEL_WIDTH = 80.dp
-
 @Composable
 private fun downloadStatus(status: DownloadStatus): String =
     when (status) {

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

@@ -110,6 +110,7 @@ import com.subtracks.data.model.Artist
 import com.subtracks.data.model.BulkDownloadAction
 import com.subtracks.data.model.CoverArtRef
 import com.subtracks.data.model.DownloadList
+import com.subtracks.data.model.DownloadProgress
 import com.subtracks.data.model.ListDownloadStatus
 import com.subtracks.data.model.Playlist
 import com.subtracks.data.prefs.AlbumSort
@@ -228,6 +229,7 @@ fun LibraryRoute(
     onArtistClick: (Artist) -> Unit,
     onPlaylistClick: (Playlist) -> Unit,
     onOpenSettings: () -> Unit,
+    onOpenDownloads: () -> Unit = {},
     onOpenSearch: () -> Unit = {},
     onViewAlbum: (String) -> Unit,
     onViewArtist: (String) -> Unit,
@@ -258,6 +260,7 @@ fun LibraryRoute(
     val listQueryState = listTab?.let { viewModel.listQuery(it).collectAsStateWithLifecycle() }
     val listQuery = listQueryState?.value ?: ListQuery("")
     val offline by viewModel.offline.collectAsStateWithLifecycle()
+    val downloadProgress by viewModel.downloadProgress.collectAsStateWithLifecycle()
     val playSort by viewModel.playSortAvailability.collectAsStateWithLifecycle()
     val displayQuery = if (offline) listQuery.copy(downloaded = true) else listQuery
     val searchState = listTab?.let { viewModel.search(it).collectAsStateWithLifecycle() }
@@ -315,6 +318,7 @@ fun LibraryRoute(
         onPlaylistClick = onPlaylistClick,
         onSync = viewModel::sync,
         onOpenSettings = onOpenSettings,
+        onOpenDownloads = onOpenDownloads,
         onOpenSearch = onOpenSearch,
         onItemLongClick = {
             focusManager.clearFocus()
@@ -324,6 +328,7 @@ fun LibraryRoute(
         resetKeys = resetKeys,
         offline = offline,
         onExitOffline = { viewModel.setOffline(false) },
+        downloadProgress = downloadProgress,
         sortOptions = sortOptionsFor(selectedTab, playSort),
         starredSupported = listTab?.supportsStarred == true,
         onSortChange = { sort -> listTab?.let { viewModel.setListQuery(it, listQuery.copy(sort = sort)) } },
@@ -398,10 +403,12 @@ fun LibraryScreen(
     onSync: () -> Unit,
     onOpenSettings: () -> Unit,
     modifier: Modifier = Modifier,
+    onOpenDownloads: () -> Unit = {},
     artistArt: (Artist) -> ArtistArt = { ArtistArt() },
     onOpenSearch: () -> Unit = {},
     offline: Boolean = false,
     onExitOffline: () -> Unit = {},
+    downloadProgress: DownloadProgress? = null,
     onItemLongClick: (MenuTarget) -> Unit = {},
     syncing: Boolean = false,
     refreshing: Boolean = false,
@@ -594,6 +601,8 @@ fun LibraryScreen(
                     onOpenSettings = onOpenSettings,
                     offline = offline,
                     onExitOffline = onExitOffline,
+                    downloadProgress = downloadProgress,
+                    onOpenDownloads = onOpenDownloads,
                     artwork = artwork,
                     syncing = syncing,
                 )
@@ -858,6 +867,8 @@ internal fun LibraryTabs(
     onOpenSettings: () -> Unit,
     offline: Boolean = false,
     onExitOffline: () -> Unit = {},
+    downloadProgress: DownloadProgress? = null,
+    onOpenDownloads: () -> Unit = {},
     artwork: ArtworkColors?,
     syncing: Boolean = false,
 ) {
@@ -941,7 +952,14 @@ internal fun LibraryTabs(
                         )
                     }
                     Spacer(Modifier.weight(1f))
-                    if (offline) {
+                    if (downloadProgress != null) {
+                        IconButton(onClick = onOpenDownloads) {
+                            DownloadProgressIcon(
+                                progress = downloadProgress,
+                                color = MaterialTheme.colorScheme.primary,
+                            )
+                        }
+                    } else if (offline) {
                         IconButton(onClick = onExitOffline) {
                             Icon(
                                 imageVector = Icons.Rounded.CloudOff,
@@ -972,6 +990,35 @@ internal fun LibraryTabs(
     }
 }
 
+@Composable
+private fun DownloadProgressIcon(
+    progress: DownloadProgress,
+    color: Color,
+) {
+    val description = stringResource(R.string.downloads_in_progress)
+    Box(
+        modifier = Modifier.size(24.dp).semantics { contentDescription = description },
+        contentAlignment = Alignment.Center,
+    ) {
+        val fraction = progress.fraction
+        if (fraction != null) {
+            CircularProgressIndicator(
+                progress = { fraction },
+                color = color,
+                trackColor = MaterialTheme.colorScheme.surfaceContainerHighest,
+                strokeWidth = 2.5.dp,
+                modifier = Modifier.fillMaxSize(),
+            )
+        } else {
+            CircularProgressIndicator(
+                color = color,
+                strokeWidth = 2.5.dp,
+                modifier = Modifier.fillMaxSize(),
+            )
+        }
+    }
+}
+
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 private fun TabButton(

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

@@ -9,8 +9,11 @@ import com.subtracks.data.model.Artist
 import com.subtracks.data.model.BulkDownloadAction
 import com.subtracks.data.model.CoverArtRef
 import com.subtracks.data.model.DownloadList
+import com.subtracks.data.model.DownloadProgress
+import com.subtracks.data.model.DownloadStatus
 import com.subtracks.data.model.ListDownloadStatus
 import com.subtracks.data.model.Playlist
+import com.subtracks.data.model.SongDownload
 import com.subtracks.data.prefs.AlbumSort
 import com.subtracks.data.prefs.ArtistSort
 import com.subtracks.data.prefs.LibraryListTab
@@ -115,6 +118,13 @@ class LibraryViewModel(
 
     val offline: StateFlow<Boolean> = sourceRepository.offline
 
+    val downloadProgress: StateFlow<DownloadProgress?> =
+        combine(
+            downloadRepository.activeDownloads(),
+            sourceRepository.activeSourceId(),
+        ) { rows, sourceId -> downloadProgress(rows, sourceId) }
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
+
     fun setOffline(enabled: Boolean) = sourceRepository.setOfflineMode(enabled)
 
     val syncing: StateFlow<Boolean> =
@@ -223,6 +233,21 @@ class LibraryViewModel(
     }
 }
 
+internal fun downloadProgress(
+    rows: List<SongDownload>,
+    sourceId: Long?,
+): DownloadProgress? {
+    if (sourceId == null) return null
+    val active = rows.filter { it.sourceId == sourceId }
+    if (active.isEmpty()) return null
+    val running = active.filter { it.status == DownloadStatus.Running }
+    if (running.isEmpty() || running.any { it.total <= 0 }) return DownloadProgress(bytes = 0, total = 0)
+    return DownloadProgress(
+        bytes = running.sumOf { it.bytes },
+        total = running.sumOf { it.total },
+    )
+}
+
 internal fun ListQuery.albumSort(): AlbumSort = AlbumSort.entries.firstOrNull { it.name == sort } ?: AlbumSort.Name
 
 internal fun ListQuery.artistSort(): ArtistSort = ArtistSort.entries.firstOrNull { it.name == sort } ?: ArtistSort.Name

app/src/main/kotlin/com/subtracks/ui/playback/MiniPlayer.kt

@@ -44,6 +44,7 @@ import com.subtracks.R
 import com.subtracks.data.model.CoverArtRef
 import com.subtracks.playback.PlaybackState
 import com.subtracks.ui.components.CoverArt
+import com.subtracks.ui.components.artistSubtitle
 import com.subtracks.ui.theme.ArtworkColors
 import com.subtracks.ui.theme.ArtworkTheme
 import com.subtracks.ui.theme.playerSurfaceColor
@@ -139,7 +140,7 @@ fun MiniPlayer(
                             modifier = Modifier.basicMarquee(),
                         )
                         Text(
-                            text = item.artist ?: item.album.orEmpty(),
+                            text = artistSubtitle(item.artist, item.artists) ?: item.album.orEmpty(),
                             style = MaterialTheme.typography.bodySmall,
                             color = MaterialTheme.colorScheme.onSurfaceVariant,
                             maxLines = 1,

app/src/main/kotlin/com/subtracks/ui/playback/NowPlayingScreen.kt

@@ -90,6 +90,7 @@ import com.subtracks.ui.components.ContextMenuHost
 import com.subtracks.ui.components.CoverArt
 import com.subtracks.ui.components.ItemActions
 import com.subtracks.ui.components.MenuTarget
+import com.subtracks.ui.components.artistSubtitle
 import com.subtracks.ui.components.prefetchArtworkRatio
 import com.subtracks.ui.theme.ArtworkColors
 import com.subtracks.ui.theme.ArtworkSeedCache
@@ -576,7 +577,10 @@ fun NowPlayingScreen(
                                 }
                                 Box(Modifier.height(subtitleHeight), contentAlignment = Alignment.CenterStart) {
                                     Text(
-                                        text = state.item?.artist.orEmpty(),
+                                        text =
+                                            state.item
+                                                ?.let { artistSubtitle(it.artist, it.artists) }
+                                                .orEmpty(),
                                         style = subtitleStyle,
                                         color = MaterialTheme.colorScheme.onSurfaceVariant,
                                         maxLines = 1,

app/src/main/kotlin/com/subtracks/ui/settings/SettingsScreen.kt

@@ -74,6 +74,7 @@ import com.subtracks.data.prefs.DEFAULT_SYNC_INTERVAL_MINUTES
 import com.subtracks.data.prefs.MAX_REPLAY_GAIN_PREAMP_DB
 import com.subtracks.data.prefs.MIN_REPLAY_GAIN_PREAMP_DB
 import com.subtracks.data.prefs.ReplayGainMode
+import com.subtracks.data.prefs.SortNameMode
 import com.subtracks.data.prefs.StreamQuality
 import com.subtracks.data.prefs.SyncMode
 import com.subtracks.log.Log
@@ -101,6 +102,7 @@ private enum class SettingsDialog {
     SyncMode,
     ReplayGain,
     ReplayGainPreamp,
+    SortNames,
 }
 
 @Composable
@@ -128,6 +130,7 @@ fun SettingsRoute(
     val verboseLogging by viewModel.verboseLogging.collectAsStateWithLifecycle()
     val replayGainMode by viewModel.replayGainMode.collectAsStateWithLifecycle()
     val replayGainPreamp by viewModel.replayGainPreamp.collectAsStateWithLifecycle()
+    val sortNameMode by viewModel.sortNameMode.collectAsStateWithLifecycle()
     val context = LocalContext.current
     val scope = rememberCoroutineScope()
     SettingsScreen(
@@ -143,6 +146,7 @@ fun SettingsRoute(
         scrobbling = scrobbling,
         replayGainMode = replayGainMode,
         replayGainPreamp = replayGainPreamp,
+        sortNameMode = sortNameMode,
         keepScreenOn = keepScreenOn,
         offline = offline,
         verboseLogging = verboseLogging,
@@ -158,6 +162,7 @@ fun SettingsRoute(
         onScrobblingChange = viewModel::setScrobbling,
         onReplayGainModeChange = viewModel::setReplayGainMode,
         onReplayGainPreampChange = viewModel::setReplayGainPreamp,
+        onSortNameModeChange = viewModel::setSortNameMode,
         onKeepScreenOnChange = viewModel::setKeepScreenOn,
         onOfflineChange = viewModel::setOfflineMode,
         onVerboseLoggingChange = viewModel::setVerboseLogging,
@@ -205,6 +210,7 @@ fun SettingsScreen(
     syncInterval: Int = DEFAULT_SYNC_INTERVAL_MINUTES,
     replayGainMode: ReplayGainMode = ReplayGainMode.Auto,
     replayGainPreamp: Float = 0f,
+    sortNameMode: SortNameMode = SortNameMode.SortName,
     onSelectSource: (Long) -> Unit,
     onEditServer: (Long) -> Unit,
     onWifiQualityChange: (StreamQuality) -> Unit,
@@ -217,6 +223,7 @@ fun SettingsScreen(
     onScrobblingChange: (Boolean) -> Unit,
     onReplayGainModeChange: (ReplayGainMode) -> Unit = {},
     onReplayGainPreampChange: (Float) -> Unit = {},
+    onSortNameModeChange: (SortNameMode) -> Unit = {},
     onKeepScreenOnChange: (Boolean) -> Unit = {},
     onOfflineChange: (Boolean) -> Unit = {},
     onVerboseLoggingChange: (Boolean) -> Unit = {},
@@ -348,6 +355,15 @@ fun SettingsScreen(
                     colors = ListItemDefaults.colors(containerColor = Color.Transparent),
                 )
             }
+            item { SectionHeader(stringResource(R.string.settings_library_name)) }
+            item {
+                ListItem(
+                    headlineContent = { Text(stringResource(R.string.settings_sort_names_title)) },
+                    supportingContent = { Text(sortNameModeLabel(LocalResources.current, sortNameMode)) },
+                    modifier = Modifier.clickable { dialog = SettingsDialog.SortNames },
+                    colors = ListItemDefaults.colors(containerColor = Color.Transparent),
+                )
+            }
             item { SectionHeader(stringResource(R.string.settings_music_name)) }
             item {
                 ListItem(
@@ -603,6 +619,14 @@ fun SettingsScreen(
             )
         }
 
+        SettingsDialog.SortNames -> {
+            SortNameModeDialog(
+                selected = sortNameMode,
+                onSelect = onSortNameModeChange,
+                onDismiss = { dialog = null },
+            )
+        }
+
         null -> {
             Unit
         }
@@ -756,6 +780,49 @@ private fun SyncModeDialog(
     )
 }
 
+private fun sortNameModeLabel(
+    resources: Resources,
+    mode: SortNameMode,
+): String =
+    when (mode) {
+        SortNameMode.SortName -> resources.getString(R.string.sort_name_mode_sort_name)
+        SortNameMode.Name -> resources.getString(R.string.sort_name_mode_name)
+        SortNameMode.NonLatin -> resources.getString(R.string.sort_name_mode_non_latin)
+    }
+
+@Composable
+private fun SortNameModeDialog(
+    selected: SortNameMode,
+    onSelect: (SortNameMode) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val resources = LocalResources.current
+    var draft by remember(selected) { mutableStateOf(selected) }
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.settings_sort_names_title)) },
+        text = {
+            ChoiceGroup(
+                header = stringResource(R.string.settings_sort_names_prompt),
+                options = SortNameMode.entries.map { it to sortNameModeLabel(resources, it) },
+                selected = draft,
+                onSelect = { draft = it },
+            )
+        },
+        confirmButton = {
+            TextButton(
+                onClick = {
+                    onSelect(draft)
+                    onDismiss()
+                },
+            ) { Text(stringResource(R.string.action_done)) }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) { Text(stringResource(R.string.actions_cancel)) }
+        },
+    )
+}
+
 @Composable
 private fun ReplayGainModeDialog(
     selected: ReplayGainMode,

app/src/main/kotlin/com/subtracks/ui/settings/SettingsViewModel.kt

@@ -6,6 +6,7 @@ import com.subtracks.data.model.Source
 import com.subtracks.data.net.NetworkMode
 import com.subtracks.data.prefs.DEFAULT_SYNC_INTERVAL_MINUTES
 import com.subtracks.data.prefs.ReplayGainMode
+import com.subtracks.data.prefs.SortNameMode
 import com.subtracks.data.prefs.StreamQuality
 import com.subtracks.data.prefs.SyncMode
 import com.subtracks.data.prefs.UserPreferences
@@ -76,6 +77,11 @@ class SettingsViewModel(
             .replayGainPreampDb()
             .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), 0f)
 
+    val sortNameMode: StateFlow<SortNameMode> =
+        userPreferences
+            .sortNameMode()
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), SortNameMode.SortName)
+
     val keepScreenOn: StateFlow<Boolean> =
         userPreferences
             .keepScreenOn()
@@ -143,4 +149,8 @@ class SettingsViewModel(
     fun setKeepScreenOn(enabled: Boolean) {
         viewModelScope.launch { userPreferences.setKeepScreenOn(enabled) }
     }
+
+    fun setSortNameMode(mode: SortNameMode) {
+        viewModelScope.launch { userPreferences.setSortNameMode(mode) }
+    }
 }

app/src/main/res/values/strings.xml

@@ -79,6 +79,7 @@
     <string name="settings_about_verbose_logging">Verbose logging</string>
     <string name="settings_about_verbose_logging_description">Log extra detail for troubleshooting</string>
     <string name="settings_about_version">Version %1$s</string>
+    <string name="settings_library_name">Library</string>
     <string name="settings_music_name">Playback</string>
     <string name="settings_music_options_scrobble_description_on">Send now playing and play counts</string>
     <string name="settings_music_options_scrobble_title">Scrobble to server</string>
@@ -96,6 +97,11 @@
     <string name="settings_replay_gain_title">ReplayGain</string>
     <string name="settings_music_options_keep_screen_on_description">Keep the screen on while now playing is open</string>
     <string name="settings_music_options_keep_screen_on_title">Keep screen on</string>
+    <string name="settings_sort_names_title">Sort names</string>
+    <string name="settings_sort_names_prompt">Choose how names are ordered in album and artist lists.</string>
+    <string name="sort_name_mode_sort_name">Use sort names</string>
+    <string name="sort_name_mode_name">Use regular names</string>
+    <string name="sort_name_mode_non_latin">Non-Latin names only</string>
     <string name="settings_network_name">Network</string>
     <string name="settings_network_options_max_bitrate_mobile_title">Stream quality: Mobile</string>
     <string name="settings_network_options_max_bitrate_wifi_title">Stream quality: Wi-Fi</string>
@@ -170,6 +176,7 @@
     <string name="filter_downloaded">Downloaded</string>
     <string name="close_search">Close search</string>
     <string name="offline_mode_status">Offline mode; tap to go online</string>
+    <string name="downloads_in_progress">Downloads in progress; tap to open the download manager</string>
     <string name="shuffle_artist">Shuffle artist</string>
 
     <string name="status_playing">Playing</string>
@@ -191,6 +198,18 @@
     <string name="info_sample_rate_value">%1$d Hz</string>
     <string name="info_channels">Channels</string>
     <string name="info_close">Close</string>
+    <string name="info_artists">Artists</string>
+    <string name="info_album_artists">Album artists</string>
+    <string name="info_album_artist_sort">Album artist sort</string>
+    <string name="info_sort_title">Sort title</string>
+    <string name="info_artist_sort">Artist sort</string>
+    <string name="info_sort_name">Sort name</string>
+    <string name="info_albums">Albums</string>
+    <string name="info_songs">Songs</string>
+    <string name="info_plays">Plays</string>
+    <string name="info_last_played">Last played</string>
+    <string name="info_added">Added</string>
+    <string name="info_downloaded_count">%1$d of %2$d</string>
 
     <string name="disc_header">Disc %1$d</string>
     <string name="disc_track">%1$s: Disc %2$d</string>

app/src/test/kotlin/com/subtracks/data/db/LibraryDaoTest.kt

@@ -20,6 +20,7 @@ import com.subtracks.data.model.Source
 import com.subtracks.data.prefs.AlbumSort
 import com.subtracks.data.prefs.ArtistSort
 import com.subtracks.data.prefs.PlaylistSort
+import com.subtracks.data.prefs.SortNameMode
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.test.runTest
 import org.junit.After
@@ -332,10 +333,18 @@ class LibraryDaoTest {
         runTest {
             val orders =
                 listOf(
-                    ALBUM_ORDER_BY_NAME to "index_albums_name",
+                    "${albumNameSortKey(SortNameMode.SortName)}, id" to "index_albums_name",
-                    ALBUM_ORDER_BY_NAME_REVERSED to "index_albums_name",
+                    "${albumNameSortKey(SortNameMode.SortName)} DESC, id DESC" to "index_albums_name",
-                    ALBUM_ORDER_BY_ARTIST to "index_albums_artist",
+                    "${albumNameSortKey(SortNameMode.Name)}, id" to "index_albums_name_plain",
-                    ALBUM_ORDER_BY_ARTIST_REVERSED to "index_albums_artist",
+                    "${albumNameSortKey(SortNameMode.Name)} DESC, id DESC" to "index_albums_name_plain",
+                    "${albumArtistSortKey(SortNameMode.SortName)}, year, " +
+                        "${albumNameSortKey(SortNameMode.SortName)}, id" to "index_albums_artist",
+                    "${albumArtistSortKey(SortNameMode.SortName)} DESC, year DESC, " +
+                        "${albumNameSortKey(SortNameMode.SortName)} DESC, id DESC" to "index_albums_artist",
+                    "${albumArtistSortKey(SortNameMode.Name)}, year, " +
+                        "${albumNameSortKey(SortNameMode.Name)}, id" to "index_albums_artist_plain",
+                    "${albumArtistSortKey(SortNameMode.Name)} DESC, year DESC, " +
+                        "${albumNameSortKey(SortNameMode.Name)} DESC, id DESC" to "index_albums_artist_plain",
                     ALBUM_ORDER_BY_YEAR to "index_albums_year",
                     ALBUM_ORDER_BY_YEAR_REVERSED to "index_albums_year",
                     ALBUM_ORDER_BY_ADDED to "index_albums_added",
@@ -359,8 +368,10 @@ class LibraryDaoTest {
         runTest {
             val orders =
                 listOf(
-                    ARTIST_ORDER_BY_NAME to "index_artists_name",
+                    "${artistNameSortKey(SortNameMode.SortName)}, id" to "index_artists_name",
-                    ARTIST_ORDER_BY_NAME_REVERSED to "index_artists_name",
+                    "${artistNameSortKey(SortNameMode.SortName)} DESC, id DESC" to "index_artists_name",
+                    "${artistNameSortKey(SortNameMode.Name)}, id" to "index_artists_name_plain",
+                    "${artistNameSortKey(SortNameMode.Name)} DESC, id DESC" to "index_artists_name_plain",
                     ARTIST_ORDER_BY_ALBUM_COUNT to "index_artists_albumCount",
                     ARTIST_ORDER_BY_ALBUM_COUNT_REVERSED to "index_artists_albumCount",
                     ARTIST_ORDER_BY_STARRED to "index_artists_starred",
@@ -1055,7 +1066,7 @@ class LibraryDaoTest {
             val plan =
                 plan(
                     "SELECT * ${ALBUMS_FILTER.replace(":search", "'abc'")} " +
-                        "ORDER BY $ALBUM_ORDER_BY_NAME LIMIT 20 OFFSET 0",
+                        "ORDER BY ${albumNameSortKey(SortNameMode.SortName)}, id LIMIT 20 OFFSET 0",
                 )
 
             assertTrue(plan, plan.contains("album_search"))
@@ -1320,6 +1331,70 @@ class LibraryDaoTest {
             )
         }
 
+    @Test
+    fun theSortNamePreferenceChoosesTheOrderKey() =
+        runTest {
+            val sourceId = source()
+            val dao = db.libraryDao()
+            dao.upsertArtists(
+                listOf(
+                    artist(sourceId, "ar-1", "あいみょん", albumCount = 1).copy(sortName = "Zzz"),
+                    artist(sourceId, "ar-2", "宇多田ヒカル", albumCount = 1).copy(sortName = "Aaa"),
+                    artist(sourceId, "ar-3", "Beatles", albumCount = 1).copy(sortName = "Beatles, The"),
+                    artist(sourceId, "ar-4", "Zebra", albumCount = 1).copy(sortName = "Aaa"),
+                ),
+            )
+            dao.upsertAlbums(
+                listOf(
+                    album(sourceId, "al-1", "Zzz", year = null, starred = null)
+                        .copy(sortName = "Aaa", albumArtistSort = "Zzz", albumArtist = "Beatles"),
+                    album(sourceId, "al-2", "Aaa", year = null, starred = null)
+                        .copy(sortName = "Zzz", albumArtistSort = "Aaa", albumArtist = "Aaa"),
+                    album(sourceId, "al-3", "Beatles", year = null, starred = null)
+                        .copy(sortName = "Beatles, The", albumArtistSort = "Beatles, The", albumArtist = "Zebra"),
+                ),
+            )
+
+            assertEquals(
+                listOf("宇多田ヒカル", "Zebra", "Beatles", "あいみょん"),
+                dao.artistsByName(sourceId, 0, "", sortMode = SortNameMode.SortName.name).page().map { it.name },
+            )
+            assertEquals(
+                listOf("Beatles", "Zebra", "あいみょん", "宇多田ヒカル"),
+                dao.artistsByName(sourceId, 0, "", sortMode = SortNameMode.Name.name).page().map { it.name },
+            )
+            assertEquals(
+                listOf("宇多田ヒカル", "あいみょん", "Zebra", "Beatles"),
+                dao.artistsByNameReversed(sourceId, 0, "", sortMode = SortNameMode.Name.name).page().map { it.name },
+            )
+            assertEquals(
+                listOf("宇多田ヒカル", "Beatles", "Zebra", "あいみょん"),
+                dao.artistsByName(sourceId, 0, "", sortMode = SortNameMode.NonLatin.name).page().map { it.name },
+            )
+            assertEquals(
+                listOf("Aaa", "Beatles", "Zzz"),
+                dao.albumsByName(sourceId, 0, "", sortMode = SortNameMode.Name.name).page().map { it.name },
+            )
+            assertEquals(
+                listOf("Aaa", "Zzz", "Beatles"),
+                dao.albumsByArtist(sourceId, 0, "", sortMode = SortNameMode.Name.name).page().map { it.name },
+            )
+            assertEquals(
+                listOf("Beatles", "Zebra", "あいみょん", "宇多田ヒカル"),
+                dao
+                    .artistsPaging(artistsDefaultQuery(sourceId, 0, "", ArtistSort.Name, false, SortNameMode.Name))
+                    .page()
+                    .map { it.name },
+            )
+            assertEquals(
+                listOf("Aaa", "Beatles", "Zzz"),
+                dao
+                    .albumsPaging(albumsDefaultQuery(sourceId, 0, "", AlbumSort.Name, false, SortNameMode.Name))
+                    .page()
+                    .map { it.name },
+            )
+        }
+
     @Test
     fun sortNamesAreSearchableInArtistsAlbumsAndSongs() =
         runTest {

app/src/test/kotlin/com/subtracks/data/prefs/UserPreferencesTest.kt

@@ -51,6 +51,22 @@ class UserPreferencesTest {
             file.delete()
         }
 
+    @Test
+    fun theSortNameModeRoundTrips() =
+        runTest {
+            val file = File.createTempFile("user-prefs", ".preferences_pb").apply { delete() }
+            val store = PreferenceDataStoreFactory.create(scope = backgroundScope) { file }
+            val prefs = UserPreferences(store)
+
+            assertEquals(SortNameMode.SortName, prefs.sortNameMode().first())
+
+            prefs.setSortNameMode(SortNameMode.NonLatin)
+
+            assertEquals(SortNameMode.NonLatin, prefs.sortNameMode().first())
+
+            file.delete()
+        }
+
     @Test
     fun theSelectedLibraryTabRoundTrips() =
         runTest {

app/src/test/kotlin/com/subtracks/data/repo/LibraryRepositoryTest.kt

@@ -76,6 +76,7 @@ class LibraryRepositoryTest {
                 db,
                 sourceRepository,
                 NetworkServerActionSink(sourceRepository),
+                fakeUserPreferences(),
                 showMessage = { messages += it.resolve(resources) },
                 scope = scope,
             )

app/src/test/kotlin/com/subtracks/playback/MediaItemTest.kt

@@ -2,6 +2,7 @@ package com.subtracks.playback
 
 import androidx.media3.common.C
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.subtracks.data.model.ArtistRef
 import org.junit.Assert.assertEquals
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -70,6 +71,21 @@ class MediaItemTest {
         assertEquals(gain, item.replayGain())
     }
 
+    @Test
+    fun theItemCarriesEveryArtist() {
+        val artists = listOf(ArtistRef("ar1", "A"), ArtistRef("ar2", "B"))
+
+        val item =
+            queueMediaItem(
+                song.copy(artists = artists),
+                local = null,
+                stream = "http://server/stream?s=s1",
+                transcode = false,
+            )
+
+        assertEquals(artists, item.artistRefs())
+    }
+
     @Test
     fun theItemCarriesItsGainContext() {
         val item =

app/src/test/kotlin/com/subtracks/playback/QueueItemTest.kt

@@ -1,6 +1,7 @@
 package com.subtracks.playback
 
 import com.subtracks.data.model.AlbumSongItem
+import com.subtracks.data.model.ArtistRef
 import com.subtracks.data.model.Song
 import org.junit.Assert.assertEquals
 import org.junit.Test
@@ -57,6 +58,29 @@ class QueueItemTest {
         assertEquals(true, item.albumContext)
     }
 
+    @Test
+    fun carriesEveryArtist() {
+        val song =
+            Song(
+                sourceId = 1,
+                id = "s1",
+                albumId = "al1",
+                artistId = "ar1",
+                title = "Song",
+                album = "Album",
+                artist = "A • B",
+                duration = 100,
+                track = 1,
+                disc = 1,
+                starred = null,
+                artists = listOf(ArtistRef("ar1", "A"), ArtistRef("ar2", "B")),
+            )
+
+        val item = AlbumSongItem(song, coverArt = null).toQueueItem()
+
+        assertEquals(listOf("A", "B"), item.artists.map { it.name })
+    }
+
     @Test
     fun aSongWithoutGainCarriesNoGain() {
         val item =

app/src/test/kotlin/com/subtracks/ui/components/DownloadIndicatorTest.kt

@@ -1,7 +1,10 @@
 package com.subtracks.ui.components
 
+import com.subtracks.data.model.DownloadProgress
 import com.subtracks.data.model.ListDownloadStatus
+import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
 import org.junit.Assert.assertTrue
 import org.junit.Test
 
@@ -35,4 +38,14 @@ class DownloadIndicatorTest {
     fun aFullyDownloadedListIsNotDownloading() {
         assertFalse(ListDownloadStatus(total = 4, downloaded = 4).isDownloading())
     }
+
+    @Test
+    fun totalDownloadProgressCombinesEveryInFlightTransfer() {
+        assertEquals(0.4f, DownloadProgress(bytes = 40, total = 100).fraction)
+    }
+
+    @Test
+    fun queuedDownloadsWithoutASizeShowAnIndeterminateRing() {
+        assertNull(DownloadProgress(bytes = 0, total = 0).fraction)
+    }
 }

app/src/test/kotlin/com/subtracks/ui/components/ItemContextMenuArtistTest.kt

@@ -6,15 +6,18 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.filter
+import androidx.compose.ui.test.filterToOne
+import androidx.compose.ui.test.hasClickAction
 import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule
-import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.onAllNodesWithText
 import androidx.compose.ui.test.performClick
-import androidx.compose.ui.test.performScrollTo
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.subtracks.data.model.ArtistRef
 import com.subtracks.data.model.Song
 import com.subtracks.ui.theme.SubtracksTheme
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
 import org.junit.Rule
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -44,34 +47,69 @@ class ItemContextMenuArtistTest {
         )
 
     @Test
-    fun showsOneEntryPerArtistAndOpensTheChosenOne() {
+    fun pluralArtistsShareOneEntryThatOpensTheChooser() {
-        var opened: String? = null
+        var opened: List<ArtistRef>? = null
         composeRule.setContent {
             SubtracksTheme {
                 var show by remember { mutableStateOf(true) }
                 if (show) {
                     ItemContextMenu(
                         target = MenuTarget.Song(song),
-                        actions = ItemActions(viewArtist = { opened = it }),
+                        actions = ItemActions(viewArtist = {}),
                         onDismiss = { show = false },
+                        onChooseArtists = { opened = it },
                     )
                 }
             }
         }
 
-        composeRule.onNodeWithText("A").assertIsDisplayed()
+        val entry = composeRule.onAllNodesWithText("A · B").filterToOne(hasClickAction())
-        composeRule.onNodeWithText("B").assertIsDisplayed()
+        entry.assertIsDisplayed()
+        assertTrue(
+            composeRule
+                .onAllNodesWithText("A")
+                .filter(hasClickAction())
+                .fetchSemanticsNodes()
+                .isEmpty(),
+        )
+        assertTrue(
+            composeRule
+                .onAllNodesWithText("B")
+                .filter(hasClickAction())
+                .fetchSemanticsNodes()
+                .isEmpty(),
+        )
 
         composeRule.mainClock.autoAdvance = false
-        composeRule.onNodeWithText("B").performClick()
+        entry.performClick()
         composeRule.mainClock.advanceTimeBy(1_000)
 
-        assertEquals("ar2", opened)
+        assertEquals(listOf("ar1", "ar2"), opened?.map { it.id })
     }
 
     @Test
-    fun longMenusScrollToTheLastArtist() {
+    fun aSingleArtistOpensDirectly() {
         var opened: String? = null
+        composeRule.setContent {
+            SubtracksTheme {
+                ItemContextMenu(
+                    target = MenuTarget.Song(song.copy(artists = listOf(ArtistRef("ar1", "A")))),
+                    actions = ItemActions(viewArtist = { opened = it }),
+                    onDismiss = {},
+                )
+            }
+        }
+
+        composeRule.mainClock.autoAdvance = false
+        composeRule.onAllNodesWithText("A").filterToOne(hasClickAction()).performClick()
+        composeRule.mainClock.advanceTimeBy(1_000)
+
+        assertEquals("ar1", opened)
+    }
+
+    @Test
+    fun manyArtistsStillShareOneEntry() {
+        var opened: List<ArtistRef>? = null
         composeRule.setContent {
             SubtracksTheme {
                 ItemContextMenu(
@@ -79,18 +117,23 @@ class ItemContextMenuArtistTest {
                         MenuTarget.Song(
                             song.copy(artists = (1..20).map { ArtistRef("ar$it", "Artist $it") }),
                         ),
-                    actions = ItemActions(viewArtist = { opened = it }),
+                    actions = ItemActions(viewArtist = {}),
                     onDismiss = {},
+                    onChooseArtists = { opened = it },
                 )
             }
         }
 
-        composeRule.onNodeWithText("Artist 20").performScrollTo().assertIsDisplayed()
+        val entry =
+            composeRule
+                .onAllNodesWithText((1..20).joinToString(" · ") { "Artist $it" })
+                .filterToOne(hasClickAction())
+        entry.assertIsDisplayed()
 
         composeRule.mainClock.autoAdvance = false
-        composeRule.onNodeWithText("Artist 20").performClick()
+        entry.performClick()
         composeRule.mainClock.advanceTimeBy(1_000)
 
-        assertEquals("ar20", opened)
+        assertEquals(20, opened?.size)
     }
 }

app/src/test/kotlin/com/subtracks/ui/components/ItemContextMenuInfoTest.kt

@@ -0,0 +1,86 @@
+package com.subtracks.ui.components
+
+import androidx.activity.ComponentActivity
+import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.subtracks.data.model.Album
+import com.subtracks.data.model.Artist
+import com.subtracks.ui.theme.SubtracksTheme
+import org.junit.Assert.assertEquals
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.GraphicsMode
+
+@RunWith(AndroidJUnit4::class)
+@GraphicsMode(GraphicsMode.Mode.NATIVE)
+class ItemContextMenuInfoTest {
+    @get:Rule
+    val composeRule = createAndroidComposeRule<ComponentActivity>()
+
+    private val album =
+        Album(
+            sourceId = 1,
+            id = "al1",
+            artistId = "ar1",
+            name = "Album",
+            albumArtist = "Artist",
+            created = 0,
+            coverArt = null,
+            genre = null,
+            year = null,
+            starred = null,
+            songCount = 1,
+        )
+
+    @Test
+    fun anAlbumMenuOpensItsInfo() {
+        var opened: MenuTarget? = null
+        composeRule.setContent {
+            SubtracksTheme {
+                ItemContextMenu(
+                    target = MenuTarget.Album(album),
+                    actions = ItemActions(),
+                    onDismiss = {},
+                    onInfo = { opened = it },
+                )
+            }
+        }
+
+        composeRule.onNodeWithText("Info").performClick()
+        composeRule.mainClock.advanceTimeBy(1_000)
+
+        assertEquals(album, (opened as? MenuTarget.Album)?.album)
+    }
+
+    @Test
+    fun anArtistMenuOpensItsInfo() {
+        var opened: MenuTarget? = null
+        composeRule.setContent {
+            SubtracksTheme {
+                ItemContextMenu(
+                    target =
+                        MenuTarget.Artist(
+                            Artist(
+                                sourceId = 1,
+                                id = "ar1",
+                                name = "Artist",
+                                albumCount = 1,
+                                starred = null,
+                            ),
+                        ),
+                    actions = ItemActions(),
+                    onDismiss = {},
+                    onInfo = { opened = it },
+                )
+            }
+        }
+
+        composeRule.onNodeWithText("Info").performClick()
+        composeRule.mainClock.advanceTimeBy(1_000)
+
+        assertEquals("ar1", (opened as? MenuTarget.Artist)?.artist?.id)
+    }
+}

app/src/test/kotlin/com/subtracks/ui/components/LibraryInfoDialogTest.kt

@@ -0,0 +1,81 @@
+package com.subtracks.ui.components
+
+import androidx.activity.ComponentActivity
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.junit4.v2.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.subtracks.data.model.Album
+import com.subtracks.data.model.Artist
+import com.subtracks.data.model.ArtistRef
+import com.subtracks.ui.theme.SubtracksTheme
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.GraphicsMode
+
+@RunWith(AndroidJUnit4::class)
+@GraphicsMode(GraphicsMode.Mode.NATIVE)
+class LibraryInfoDialogTest {
+    @get:Rule
+    val composeRule = createAndroidComposeRule<ComponentActivity>()
+
+    @Test
+    fun anAlbumShowsEveryArtistAndBothSortNames() {
+        composeRule.setContent {
+            SubtracksTheme {
+                AlbumInfoDialog(
+                    album =
+                        Album(
+                            sourceId = 1,
+                            id = "al1",
+                            artistId = "ar1",
+                            name = "Album",
+                            albumArtist = "A",
+                            created = 0,
+                            coverArt = null,
+                            genre = "Rock",
+                            year = 1999,
+                            starred = null,
+                            songCount = 12,
+                            artists = listOf(ArtistRef("ar1", "A"), ArtistRef("ar2", "B")),
+                            sortName = "Album, The",
+                            albumArtistSort = "A, The",
+                        ),
+                    download = null,
+                    onDismiss = {},
+                )
+            }
+        }
+
+        composeRule.onNodeWithText("A · B").assertIsDisplayed()
+        composeRule.onNodeWithText("Album, The").assertIsDisplayed()
+        composeRule.onNodeWithText("A, The").assertIsDisplayed()
+        composeRule.onNodeWithText("1999").assertIsDisplayed()
+    }
+
+    @Test
+    fun anArtistShowsItsSortNameAndCounts() {
+        composeRule.setContent {
+            SubtracksTheme {
+                ArtistInfoDialog(
+                    artist =
+                        Artist(
+                            sourceId = 1,
+                            id = "ar1",
+                            name = "The Artist",
+                            albumCount = 4,
+                            starred = null,
+                            songCount = 40,
+                            sortName = "Artist, The",
+                        ),
+                    onDismiss = {},
+                )
+            }
+        }
+
+        composeRule.onNodeWithText("Artist, The").assertIsDisplayed()
+        composeRule.onNodeWithText("4").assertIsDisplayed()
+        composeRule.onNodeWithText("40").assertIsDisplayed()
+    }
+}

app/src/test/kotlin/com/subtracks/ui/downloads/DownloadsViewModelTest.kt

@@ -90,7 +90,13 @@ class DownloadsViewModelTest {
             )
         viewModel =
             DownloadsViewModel(
-                LibraryRepository(db, sourceRepository, NetworkServerActionSink(sourceRepository), scope = repoScope),
+                LibraryRepository(
+                    db,
+                    sourceRepository,
+                    NetworkServerActionSink(sourceRepository),
+                    fakeUserPreferences(),
+                    scope = repoScope,
+                ),
                 downloadRepository,
                 controller,
                 "Unknown artist",

app/src/test/kotlin/com/subtracks/ui/library/LibraryViewModelTest.kt

@@ -1,11 +1,15 @@
 package com.subtracks.ui.library
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.subtracks.data.model.DownloadProgress
+import com.subtracks.data.model.DownloadStatus
+import com.subtracks.data.model.SongDownload
 import com.subtracks.data.prefs.AlbumSort
 import com.subtracks.data.prefs.ArtistSort
 import com.subtracks.data.prefs.ListQuery
 import com.subtracks.data.prefs.PlaylistSort
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
 import org.junit.Test
 import org.junit.runner.RunWith
 
@@ -24,4 +28,39 @@ class LibraryViewModelTest {
         assertEquals(ArtistSort.Name, ListQuery("LegacyArtistOrder").artistSort())
         assertEquals(PlaylistSort.Name, ListQuery("LegacyPlaylistOrder").playlistSort())
     }
+
+    @Test
+    fun downloadProgressOnlyCountsTheActiveSource() {
+        val rows = listOf(download(1, bytes = 40, total = 100), download(2, bytes = 10, total = 20))
+
+        assertEquals(DownloadProgress(bytes = 40, total = 100), downloadProgress(rows, sourceId = 1))
+    }
+
+    @Test
+    fun anotherSourcesDownloadsDoNotShowAProgressRing() {
+        assertNull(downloadProgress(listOf(download(2, bytes = 10, total = 20)), sourceId = 1))
+    }
+
+    @Test
+    fun aTransferWithoutAKnownSizeIsIndeterminate() {
+        val rows =
+            listOf(
+                download(1, bytes = 100, total = 100),
+                download(1, bytes = 20, total = 0).copy(songId = "s2"),
+            )
+
+        assertEquals(DownloadProgress(bytes = 0, total = 0), downloadProgress(rows, sourceId = 1))
+    }
+
+    private fun download(
+        sourceId: Long,
+        bytes: Long,
+        total: Long,
+    ) = SongDownload(
+        sourceId = sourceId,
+        songId = "s1",
+        status = DownloadStatus.Running,
+        bytes = bytes,
+        total = total,
+    )
 }

app/src/test/kotlin/com/subtracks/ui/playback/NowPlayingRouteTest.kt

@@ -98,7 +98,7 @@ class NowPlayingRouteTest {
                 artworkFetcher = { ByteArray(0) },
                 scope = repoScope,
             ).also { it.start() }
-        library = LibraryRepository(db, sources, serverActions, scope = repoScope)
+        library = LibraryRepository(db, sources, serverActions, prefs, scope = repoScope)
         handle = FakePlayerHandle()
         controller =
             PlaybackController(

app/src/test/kotlin/com/subtracks/ui/search/SearchViewModelTest.kt

@@ -90,7 +90,13 @@ class SearchViewModelTest {
             )
         viewModel =
             SearchViewModel(
-                LibraryRepository(db, sourceRepository, NetworkServerActionSink(sourceRepository), scope = repoScope),
+                LibraryRepository(
+                    db,
+                    sourceRepository,
+                    NetworkServerActionSink(sourceRepository),
+                    fakeUserPreferences(),
+                    scope = repoScope,
+                ),
                 sourceRepository,
                 controller,
             )

app/src/test/kotlin/com/subtracks/ui/settings/SettingsScreenTest.kt

@@ -12,6 +12,7 @@ import androidx.compose.ui.test.performClick
 import androidx.compose.ui.test.performScrollToNode
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.github.takahirom.roborazzi.RobolectricDeviceQualifiers
+import com.subtracks.data.prefs.SortNameMode
 import com.subtracks.data.prefs.StreamQuality
 import com.subtracks.ui.theme.SubtracksTheme
 import org.junit.Assert.assertEquals
@@ -31,7 +32,7 @@ class SettingsScreenTest {
     @Test
     fun theKeepScreenOnRowTurnsTheSettingOn() {
         var requested: Boolean? = null
-        renderSettings(keepScreenOn = false) { requested = it }
+        renderSettings(keepScreenOn = false, onKeepScreenOnChange = { requested = it })
 
         composeRule.onNodeWithText("Keep screen on").performClick()
         composeRule.waitForIdle()
@@ -42,7 +43,7 @@ class SettingsScreenTest {
     @Test
     fun theKeepScreenOnRowTurnsTheSettingOff() {
         var requested: Boolean? = null
-        renderSettings(keepScreenOn = true) { requested = it }
+        renderSettings(keepScreenOn = true, onKeepScreenOnChange = { requested = it })
 
         composeRule.onNodeWithText("Keep screen on").performClick()
         composeRule.waitForIdle()
@@ -53,7 +54,7 @@ class SettingsScreenTest {
     @Test
     fun theKeepScreenOnSwitchTurnsTheSettingOn() {
         var requested: Boolean? = null
-        renderSettings(keepScreenOn = false) { requested = it }
+        renderSettings(keepScreenOn = false, onKeepScreenOnChange = { requested = it })
 
         composeRule
             .onNode(isToggleable() and hasAnySibling(hasText("Keep screen on")), useUnmergedTree = true)
@@ -63,9 +64,29 @@ class SettingsScreenTest {
         assertEquals(true, requested)
     }
 
+    @Test
+    fun theSortNamesRowChangesTheSortNameMode() {
+        var requested: SortNameMode? = null
+        renderSettings(
+            keepScreenOn = false,
+            onKeepScreenOnChange = {},
+            onSortNameModeChange = { requested = it },
+            scrollTo = "Sort names",
+        )
+
+        composeRule.onNodeWithText("Sort names").performClick()
+        composeRule.onNodeWithText("Use regular names").performClick()
+        composeRule.onNodeWithText("Done").performClick()
+        composeRule.waitForIdle()
+
+        assertEquals(SortNameMode.Name, requested)
+    }
+
     private fun renderSettings(
         keepScreenOn: Boolean,
         onKeepScreenOnChange: (Boolean) -> Unit,
+        onSortNameModeChange: (SortNameMode) -> Unit = {},
+        scrollTo: String = "Keep screen on",
     ) {
         composeRule.setContent {
             SubtracksTheme {
@@ -88,6 +109,7 @@ class SettingsScreenTest {
                     onDownloadOverMeteredChange = {},
                     onScrobblingChange = {},
                     onKeepScreenOnChange = onKeepScreenOnChange,
+                    onSortNameModeChange = onSortNameModeChange,
                     onAddServer = {},
                     onOpenDownloads = {},
                     onOpenLicenses = {},
@@ -97,7 +119,7 @@ class SettingsScreenTest {
             }
         }
         awaitText("Add server")
-        composeRule.onNode(hasScrollToNodeAction()).performScrollToNode(hasText("Keep screen on"))
+        composeRule.onNode(hasScrollToNodeAction()).performScrollToNode(hasText(scrollTo))
     }
 
     private fun awaitText(text: String) {