UI density: compact mode, flat placeholders, Settings tab, shelf play

android/app/build.gradle.kts

@@ -24,7 +24,7 @@ android {
     defaultConfig {
         applicationId = "com.simplecityapps.shuttle"
         // 24: Compose 1.13, which material3 1.5.0-alpha29 brings in, no longer supports API 23.
-        minSdk = 24
+        minSdk = 26
         targetSdk = 36
         versionName = versionName()
         versionCode = versionCode()
@@ -45,9 +45,22 @@ android {
         // Last.fm scrobbling (#503): the key and secret ship in the APK (owner decision, 2026-09-27).
         buildConfigField("String", "LASTFM_API_KEY", "\"${secret("LASTFM_API_KEY", "LASTFM_API_KEY").orEmpty()}\"")
         buildConfigField("String", "LASTFM_SHARED_SECRET", "\"${secret("LASTFM_SHARED_SECRET", "LASTFM_SHARED_SECRET").orEmpty()}\"")
+
+        // Short commit the APK was built from, shown in Settings > About so dev builds
+        // (which share one version name) are told apart. Forwarded by k8s/scripts/build-remote.sh.
+        buildConfigField("String", "GIT_SHA", "\"${findProperty("gitSha")?.toString()?.takeIf { it.isNotBlank() } ?: "unknown"}\"")
     }
 
     signingConfigs {
+        // A checked-in debug key shared by every builder (local or cluster): without it each
+        // machine mints its own ~/.android key and new dev APKs refuse to install over old ones.
+        // Debug keys are not secrets; the release key stays out of the repo.
+        named("debug") {
+            storeFile = file("./debug.keystore")
+            storePassword = "android"
+            keyAlias = "androiddebugkey"
+            keyPassword = "android"
+        }
         create("release") {
             if (isCiBuild() && isReleaseBuild()) {
                 val keystore = file("./keystore.ks")
@@ -64,6 +77,7 @@ android {
 
     buildTypes {
         getByName("debug") {
+            signingConfig = signingConfigs.getByName("debug")
             applicationIdSuffix = ".dev"
             if (isCiBuild()) {
                 // We want proguard enabled on CI, so our instrumented tests run on obfuscated code
@@ -80,7 +94,16 @@ android {
                 getDefaultProguardFile("proguard-android-optimize.txt"),
                 "proguard-rules.pro"
             )
-            signingConfig = signingConfigs.getByName("release")
+            // Play releases sign with the upload key (CI). Everywhere else the debug key
+            // signs release too, under the .dev id, so `assembleRelease` yields an
+            // installable, minified dev build instead of failing on a missing keystore.
+            // Same package and key as dev debug: the two swap in place, data intact.
+            if (isCiBuild() && isReleaseBuild()) {
+                signingConfig = signingConfigs.getByName("release")
+            } else {
+                signingConfig = signingConfigs.getByName("debug")
+                applicationIdSuffix = ".dev"
+            }
         }
     }
 
@@ -91,8 +114,8 @@ android {
     }
 
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
+        sourceCompatibility = JavaVersion.VERSION_21
+        targetCompatibility = JavaVersion.VERSION_21
         isCoreLibraryDesugaringEnabled = true
     }
 
@@ -292,7 +315,7 @@ android {
 
 kotlin {
     compilerOptions {
-        jvmTarget.set(JvmTarget.JVM_17)
+        jvmTarget.set(JvmTarget.JVM_21)
         freeCompilerArgs.addAll(
             "-Xopt-in=kotlin.RequiresOptIn",
             "-Xopt-in=kotlin.time.ExperimentalTime"

android/app/src/main/AndroidManifest.xml

@@ -20,10 +20,11 @@
         android:fullBackupContent="@xml/backup_descriptor"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
-        android:requestLegacyExternalStorage="true"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/AppTheme.DayNight"
+        android:enableOnBackInvokedCallback="true"
+        android:localeConfig="@xml/locales_config"
         tools:ignore="GoogleAppIndexingWarning">
 
         <activity
@@ -91,6 +92,18 @@
 
         <!-- Widget -->
 
+        <!-- Automation apps and file-sync tools trigger a rescan with
+             `adb shell am broadcast -a com.simplecityapps.shuttle.action.RESCAN_LIBRARY`.
+             Deliberately unguarded (unlike the debug import receiver): third-party apps fire it too.
+             Repeat triggers within a minute are ignored. -->
+        <receiver
+            android:name=".scan.LibraryScanReceiver"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="com.simplecityapps.shuttle.action.RESCAN_LIBRARY" />
+            </intent-filter>
+        </receiver>
+
         <receiver
             android:name=".ui.widgets.WidgetProvider41"
             android:exported="true"

android/app/src/main/java/com/simplecityapps/shuttle/appinitializers/MediaProviderInitializer.kt

@@ -6,6 +6,7 @@ import com.simplecityapps.mediaprovider.settings.LibrarySettings
 import com.simplecityapps.mediaprovider.worker.MediaImportWorker
 import com.simplecityapps.shuttle.di.ApplicationContext
 import com.simplecityapps.shuttle.sources.DefaultMediaSources
+import com.simplecityapps.shuttle.sources.MediaLibraryObserver
 import com.simplecityapps.shuttle.ui.screens.sources.MusicPermission
 import dev.zacsweers.metro.Inject
 
@@ -14,11 +15,13 @@ class MediaProviderInitializer
 constructor(
     @ApplicationContext private val context: Context,
     private val librarySettings: LibrarySettings,
-    private val mediaSources: DefaultMediaSources
+    private val mediaSources: DefaultMediaSources,
+    private val libraryObserver: MediaLibraryObserver
 ) : AppInitializer {
     override fun init(application: Application) {
         mediaSources.attachEnabled()
         mediaSources.scanIfNeverScanned(MusicPermission.isGranted(context))
+        libraryObserver.startIfReady()
 
         MediaImportWorker.updateWork(
             context = context,

android/app/src/main/java/com/simplecityapps/shuttle/scan/LibraryScanReceiver.kt

@@ -0,0 +1,72 @@
+package com.simplecityapps.shuttle.scan
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.os.SystemClock
+import com.simplecityapps.mediaprovider.MediaImporter
+import com.simplecityapps.shuttle.di.appGraph
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.ContributesTo
+import dev.zacsweers.metro.Inject
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+/**
+ * Release-build rescan trigger for automation apps and file-sync tools (Tasker, FolderSync, ...):
+ *
+ * `adb shell am broadcast -a com.simplecityapps.shuttle.action.RESCAN_LIBRARY`
+ *
+ * The debug [com.simplecityapps.shuttle.debug.DebugMediaImportReceiver] does the same thing, but it lives in the
+ * debug source set behind the DUMP permission so only adb can fire it. This receiver is deliberately unguarded, so
+ * third-party apps can fire it too. Rapid repeat triggers are debounced [DEBOUNCE_MS], and [MediaImporter.import]
+ * coalesces with an import already running through its own importLock.
+ *
+ * Launched on Main, like the onboarding scan's `appCoroutineScope` call: [MediaImporter.import] moves its own work
+ * to IO but notifies its listeners on the caller's thread, and an IO caller crashes Settings > Media's listener if
+ * the import finishes while that screen is open (#386).
+ */
+class LibraryScanReceiver : BroadcastReceiver() {
+    @ContributesTo(AppScope::class)
+    interface Injector {
+        fun inject(receiver: LibraryScanReceiver)
+    }
+
+    @Inject
+    lateinit var mediaImporter: MediaImporter
+
+    override fun onReceive(
+        context: Context,
+        intent: Intent
+    ) {
+        if (intent.action != ACTION_RESCAN_LIBRARY) return
+        if (!debounce()) return
+        context.appGraph<Injector>().inject(this)
+        val pendingResult = goAsync()
+        CoroutineScope(Dispatchers.Main).launch {
+            try {
+                mediaImporter.import()
+            } finally {
+                pendingResult.finish()
+            }
+        }
+    }
+
+    companion object {
+        const val ACTION_RESCAN_LIBRARY = "com.simplecityapps.shuttle.action.RESCAN_LIBRARY"
+
+        const val DEBOUNCE_MS = 60_000L
+
+        @Volatile
+        private var lastTriggerUptimeMs = 0L
+
+        internal fun debounce(nowUptimeMs: Long = SystemClock.uptimeMillis()): Boolean {
+            synchronized(this) {
+                if (nowUptimeMs - lastTriggerUptimeMs < DEBOUNCE_MS) return false
+                lastTriggerUptimeMs = nowUptimeMs
+                return true
+            }
+        }
+    }
+}

android/app/src/main/java/com/simplecityapps/shuttle/sources/MediaLibraryObserver.kt

@@ -0,0 +1,79 @@
+package com.simplecityapps.shuttle.sources
+
+import android.content.Context
+import android.database.ContentObserver
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import android.provider.MediaStore
+import com.simplecityapps.mediaprovider.MediaImporter
+import com.simplecityapps.shuttle.di.AppCoroutineScope
+import com.simplecityapps.shuttle.di.ApplicationContext
+import com.simplecityapps.shuttle.ui.screens.sources.MediaSources
+import com.simplecityapps.shuttle.ui.screens.sources.MusicPermission
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.Inject
+import dev.zacsweers.metro.SingleIn
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import timber.log.Timber
+
+/**
+ * Re-scans the library when MediaStore's audio changes (new downloads, tag edits from other apps, deletions).
+ *
+ * Registered once at startup by [com.simplecityapps.shuttle.appinitializers.MediaProviderInitializer], only when the
+ * music permission is held and an import has already finished: the first scan comes from the onboarding and
+ * permission-grant paths instead. Changes are debounced [DEBOUNCE_MS] so a burst of writes (an album syncing track
+ * by track) imports once. [MediaImporter.import] coalesces overlapping requests through its own importLock, so a
+ * change that lands mid-import just runs one more pass.
+ *
+ * MediaStore only covers indexed files: extra SAF trees have no observable URI (see TaglibMediaProvider's
+ * findExtraDocuments), so those folders still need a manual or scheduled scan.
+ */
+@SingleIn(AppScope::class)
+class MediaLibraryObserver @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val mediaImporter: MediaImporter,
+    private val mediaSources: MediaSources,
+    @AppCoroutineScope private val appCoroutineScope: CoroutineScope
+) {
+    private var debounceJob: Job? = null
+
+    private val observer =
+        object : ContentObserver(Handler(Looper.getMainLooper())) {
+            override fun onChange(selfChange: Boolean) = onMediaChanged()
+
+            override fun onChange(
+                selfChange: Boolean,
+                uri: Uri?
+            ) = onMediaChanged()
+        }
+
+    fun startIfReady() {
+        if (!MusicPermission.isGranted(context) || !mediaSources.hasScanned) return
+        context.contentResolver.registerContentObserver(
+            MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
+            true,
+            observer
+        )
+    }
+
+    private fun onMediaChanged() {
+        debounceJob?.cancel()
+        // The app scope runs on Main, like the onboarding scan: MediaImporter notifies its listeners on the
+        // caller's thread, and an IO caller crashes Settings > Media's listener if the import finishes while
+        // that screen is open (#386).
+        debounceJob =
+            appCoroutineScope.launch {
+                delay(DEBOUNCE_MS)
+                Timber.i("MediaStore changed, re-scanning the library")
+                mediaImporter.import()
+            }
+    }
+
+    companion object {
+        const val DEBOUNCE_MS = 20_000L
+    }
+}

android/app/src/main/java/com/simplecityapps/shuttle/ui/common/components/LoadingStatusIndicator.kt

@@ -7,9 +7,10 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.wrapContentHeight
-import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
+import androidx.compose.material3.LoadingIndicator
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedButton
 import androidx.compose.material3.Text
@@ -24,6 +25,7 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import com.simplecityapps.shuttle.R
 
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
 fun LoadingStatusIndicator(
     state: CircularLoadingState,
@@ -41,7 +43,7 @@ fun LoadingStatusIndicator(
     ) {
         when (state) {
             is CircularLoadingState.Loading -> {
-                CircularProgressIndicator(
+                LoadingIndicator(
                     color = progressColor,
                     modifier = Modifier
                 )

android/app/src/main/java/com/simplecityapps/shuttle/ui/screens/home/HomeEntries.kt

@@ -26,10 +26,11 @@ import com.simplecityapps.shuttle.ui.screens.settings.SettingsDestinationRoute
 import com.simplecityapps.shuttle.ui.screens.settings.WhatsNewRoute
 import com.simplecityapps.shuttle.ui.screens.settings.model.SettingsDestination
 import com.simplecityapps.shuttle.ui.screens.sources.ServerTypePickerRoute
+import com.simplecityapps.shuttle.model.SmartPlaylistId
+import com.simplecityapps.shuttle.ui.screens.library.SmartPlaylistRoute
 import com.simplecityapps.shuttle.ui.shell.AppNavigator
 import com.simplecityapps.shuttle.ui.shell.HomeRoute
 import com.simplecityapps.shuttle.ui.shell.LocalShellSnackbarHostState
-import com.simplecityapps.shuttle.ui.shell.SettingsRoute
 import dev.zacsweers.metrox.viewmodel.metroViewModel
 
 fun EntryProviderScope<NavKey>.homeEntries(navigator: AppNavigator) {
@@ -69,8 +70,10 @@ private fun HomeDestination(
         HomeScreen(
             uiState = uiState,
             callbacks = HomeCallbacks(
-                onOpenSettings = { onOpen(SettingsRoute) },
                 onShuffleAll = { viewModel.shuffleAll()?.let(actions::dispatch) },
+                onOpenHistory = { onOpen(SmartPlaylistRoute(SmartPlaylistId.History.id)) },
+                onOpenRecentlyAdded = { onOpen(SmartPlaylistRoute(SmartPlaylistId.RecentlyAdded.id)) },
+                onOpenFavourites = { onOpen(SmartPlaylistRoute(SmartPlaylistId.Favourites.id)) },
                 onTogglePlayback = viewModel::onTogglePlayback,
                 onShuffleQueue = { viewModel.shuffleQueue()?.let(actions::dispatch) },
                 onOpenWhatsNew = {
@@ -80,6 +83,8 @@ private fun HomeDestination(
                 onDismissWhatsNew = viewModel::onWhatsNewHandled,
                 onAlbumClick = { onOpen(it.route) },
                 onArtistClick = { onOpen(it.route) },
+                onPlayAlbums = { actions.dispatch(viewModel.playAlbums(it)) },
+                onPlayArtists = { actions.dispatch(viewModel.playArtists(it)) },
                 onShowActions = actions::showActions,
             ),
             emptyContent = (emptyState as? LibraryAvailability.Empty)?.let { empty ->