feat: auto-sync the library on a timer while the app is open

While the app is in the foreground a timer checks the auto-sync setting and
syncs when due (default every 24h; the interval is selectable from 15 minutes
to 24 hours). It stops when the app is backgrounded. "Sync automatically"
is one setting: Off, Wi-Fi only (default) or Always.

A running sync is shown by a silent, dismissible notification and a small
spinner on the library tab bar's settings button. A manual pull-to-refresh
still holds the pull spinner; only an automatic sync does not. The library
and Home sync actions no-op while a sync is running, and SyncManager
coalesces a request that arrives mid-run into a single follow-up, so repeated
pull-to-refresh cannot pile up runs while adding a server still syncs it.

The time of the last sync attempt is recorded, so a failing server is retried
once per interval rather than every poll. The sync consumer and the auto-sync
loop both survive an unexpected failure instead of silently disabling syncing
for the rest of the process.

The poll sleeps for the interval (capped at 15 minutes) instead of a fixed
minute, the network mode is collected once rather than re-registering a
connectivity callback each poll, and the decision is logged at DEBUG (visible
with Verbose logging) rather than writing to the log file every poll.

.github/actions/build/action.yml

@@ -0,0 +1,74 @@
+name: Build
+description: Set up Nix, optionally sign, run Gradle and report the version code
+
+inputs:
+  gradle-args:
+    description: Gradle tasks and flags to run
+    required: true
+  sign:
+    description: Decode and use the store keystore when "true"
+    required: false
+    default: "false"
+  keystore-base64:
+    description: Base64 of the release keystore
+    required: false
+    default: ""
+  keyproperties-base64:
+    description: Base64 of the key.properties holding the key alias
+    required: false
+    default: ""
+  keystore-password:
+    description: Keystore (store) password
+    required: false
+    default: ""
+  key-password:
+    description: Signing key password
+    required: false
+    default: ""
+
+outputs:
+  version-code:
+    description: versionCode read from app/build.gradle.kts
+    value: ${{ steps.version.outputs.code }}
+
+runs:
+  using: composite
+  steps:
+    - uses: ./.github/actions/nix
+    - uses: actions/cache@v6
+      with:
+        path: ~/.gradle/caches
+        key: gradle-${{ hashFiles('**/*.gradle*', '**/gradle.properties', 'gradle/libs.versions.toml', 'gradle/wrapper/gradle-wrapper.properties') }}
+        restore-keys: gradle-
+    - id: signing
+      if: inputs.sign == 'true'
+      shell: bash
+      env:
+        KEYSTORE_BASE64: ${{ inputs.keystore-base64 }}
+        KEYPROPERTIES_BASE64: ${{ inputs.keyproperties-base64 }}
+      run: |
+        umask 077
+        echo "$KEYSTORE_BASE64" | base64 -d > "$RUNNER_TEMP/release.keystore"
+        alias=$(printf '%s' "$KEYPROPERTIES_BASE64" | base64 -d | sed -n 's/^keyAlias=//p' | tr -d '\r')
+        test -n "$alias" || { echo "no keyAlias in keyproperties" >&2; exit 1; }
+        echo "alias=$alias" >> "$GITHUB_OUTPUT"
+    - shell: bash
+      env:
+        SIGN: ${{ inputs.sign }}
+        KEYSTORE_PASSWORD: ${{ inputs.keystore-password }}
+        KEY_ALIAS: ${{ steps.signing.outputs.alias }}
+        KEY_PASSWORD: ${{ inputs.key-password }}
+      run: |
+        if [ "$SIGN" = "true" ]; then
+          export RELEASE_KEYSTORE="$RUNNER_TEMP/release.keystore"
+          export RELEASE_KEYSTORE_PASSWORD="$KEYSTORE_PASSWORD"
+          export RELEASE_KEY_ALIAS="$KEY_ALIAS"
+          export RELEASE_KEY_PASSWORD="$KEY_PASSWORD"
+        fi
+        nix develop --command gradle ${{ inputs.gradle-args }}
+    - if: always()
+      shell: bash
+      run: rm -f "$RUNNER_TEMP/release.keystore"
+    - id: version
+      shell: bash
+      run: echo "code=$(grep -oP 'versionCode = \K\d+' app/build.gradle.kts)" >> "$GITHUB_OUTPUT"

.github/actions/nix/action.yml

@@ -0,0 +1,14 @@
+name: Nix
+description: Install Nix and restore the store cache
+
+runs:
+  using: composite
+  steps:
+    - uses: cachix/install-nix-action@13d8dd58da0234aa297dedd986986ccb8e7f3e24 # v31.11.1
+      with:
+        extra_nix_config: experimental-features = nix-command flakes
+    - uses: nix-community/cache-nix-action@7df957e333c1e5da7721f60227dbba6d06080569 # v7.0.2
+      with:
+        primary-key: nix-v2-${{ hashFiles('flake.lock', '**/*.nix') }}
+        restore-prefixes-first-match: nix-v2-
+        gc-max-store-size-linux: 6G

.github/workflows/ci.yml

@@ -9,37 +9,46 @@ concurrency:
   group: ci-${{ github.ref }}
   cancel-in-progress: true
 
-env:
-  GRADLE_OPTS: -Dorg.gradle.daemon=false
-  NIX_CONFIG: experimental-features = nix-command flakes
-
-defaults:
-  run:
-    shell: sh
-
 jobs:
   ci:
     runs-on: ubuntu-26.04
     timeout-minutes: 90
     permissions:
       contents: read
+    env:
+      GRADLE_OPTS: -Dorg.gradle.daemon=false
     steps:
       - uses: actions/checkout@v7
-      - uses: cachix/install-nix-action@13d8dd58da0234aa297dedd986986ccb8e7f3e24 # v31.11.1
-      - uses: nix-community/cache-nix-action@7df957e333c1e5da7721f60227dbba6d06080569 # v7.0.2
         with:
-          primary-key: nix-v2-${{ hashFiles('flake.lock', '**/*.nix') }}
+          persist-credentials: false
-          restore-prefixes-first-match: nix-v2-
+      - uses: ./.github/actions/build
-          gc-max-store-size-linux: 6G
-      - uses: actions/cache@v6
         with:
-          path: |
+          gradle-args: ":app:ktlintCheck :app:lintDebug :app:testDebugUnitTest :app:assembleDebug :app:assembleNightly --no-configuration-cache --console=plain --no-daemon"
-            ~/.gradle/caches
+      - name: Collect nightly builds
-          key: gradle-${{ hashFiles('**/*.gradle*', '**/gradle.properties', 'gradle/libs.versions.toml', 'gradle/wrapper/gradle-wrapper.properties') }}
+        if: github.ref == 'refs/heads/main'
-          restore-keys: gradle-
+        run: |
+          cp app/build/outputs/apk/debug/app-debug.apk subtracks-nightly-debug.apk
+          cp app/build/outputs/apk/nightly/app-nightly.apk subtracks-nightly.apk
+      - name: Checksums
+        if: github.ref == 'refs/heads/main'
+        run: sha256sum subtracks-nightly.apk subtracks-nightly-debug.apk | tee SHA256SUMS
+      - uses: actions/upload-artifact@v7
+        if: github.ref == 'refs/heads/main'
+        with:
+          path: subtracks-nightly.apk
+          archive: false
+      - uses: actions/upload-artifact@v7
+        if: github.ref == 'refs/heads/main'
+        with:
+          path: subtracks-nightly-debug.apk
+          archive: false
+      - uses: actions/upload-artifact@v7
+        if: github.ref == 'refs/heads/main'
+        with:
+          path: SHA256SUMS
+          archive: false
       - uses: actions/cache@v6
         with:
           path: .integration/music
           key: integration-music-v1
-      - run: nix develop --command gradle :app:ktlintCheck :app:lintDebug :app:testDebugUnitTest --no-configuration-cache --console=plain
       - run: nix develop .#integration --command nu tools/integration-test.nu

.github/workflows/release.yml

@@ -0,0 +1,148 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+concurrency:
+  group: release
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-26.04
+    timeout-minutes: 60
+    permissions:
+      contents: read
+    outputs:
+      version-code: ${{ steps.build.outputs.version-code }}
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+      - name: Check tag matches versionName
+        run: |
+          version=$(grep -oP 'versionName = "\K[^"]+' app/build.gradle.kts)
+          case "$GITHUB_REF_NAME" in
+            "v$version" | "v$version"-*) ;;
+            *)
+              echo "tag $GITHUB_REF_NAME does not match versionName $version" >&2
+              exit 1
+              ;;
+          esac
+      - id: build
+        uses: ./.github/actions/build
+        with:
+          gradle-args: ":app:assembleRelease :app:bundleRelease --no-daemon"
+          sign: "true"
+          keystore-base64: ${{ secrets.SUBTRACKS_KEYSTORE_BASE64 }}
+          keyproperties-base64: ${{ secrets.SUBTRACKS_KEYPROPERTIES_BASE64 }}
+          keystore-password: ${{ secrets.SUBTRACKS_UPLOAD_STORE_PASSWORD }}
+          key-password: ${{ secrets.SUBTRACKS_UPLOAD_KEY_PASSWORD }}
+      - name: Export release certificate
+        env:
+          KEYSTORE_BASE64: ${{ secrets.SUBTRACKS_KEYSTORE_BASE64 }}
+          KEYPROPERTIES_BASE64: ${{ secrets.SUBTRACKS_KEYPROPERTIES_BASE64 }}
+          KEYSTORE_PASSWORD: ${{ secrets.SUBTRACKS_UPLOAD_STORE_PASSWORD }}
+        run: |
+          umask 077
+          trap 'rm -f "$RUNNER_TEMP/keystore"' EXIT
+          echo "$KEYSTORE_BASE64" | base64 -d > "$RUNNER_TEMP/keystore"
+          alias=$(printf '%s' "$KEYPROPERTIES_BASE64" | base64 -d | sed -n 's/^keyAlias=//p' | tr -d '\r')
+          nix develop --command keytool -exportcert -rfc -keystore "$RUNNER_TEMP/keystore" -alias "$alias" -storepass "$KEYSTORE_PASSWORD" -file app/build/outputs/release-certificate.pem
+      - uses: actions/upload-artifact@v7
+        with:
+          name: release
+          path: app/build/outputs
+
+  publish:
+    needs: build
+    runs-on: ubuntu-26.04
+    timeout-minutes: 60
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+      - uses: actions/download-artifact@v8
+        with:
+          name: release
+          path: dist
+      - uses: ./.github/actions/nix
+      - name: Detect stable tag
+        id: stable
+        run: |
+          if [[ "$GITHUB_REF_NAME" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            echo "value=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "value=false" >> "$GITHUB_OUTPUT"
+          fi
+      - name: Check release notes exist
+        run: test -f "metadata/en-US/changelogs/${{ needs.build.outputs.version-code }}.txt"
+      - name: Write Play service account
+        if: steps.stable.outputs.value == 'true'
+        env:
+          PLAY_SERVICE_ACCOUNT_JSON: ${{ secrets.PLAY_SERVICE_ACCOUNT_JSON }}
+        run: |
+          umask 077
+          printf '%s' "$PLAY_SERVICE_ACCOUNT_JSON" > "$RUNNER_TEMP/play.json"
+      - name: Upload to Google Play
+        if: steps.stable.outputs.value == 'true'
+        run: |
+          nix develop .#release --command fastlane supply \
+            --aab dist/bundle/release/app-release.aab \
+            --package_name com.subtracks \
+            --track "${{ vars.PLAY_TRACK || 'internal' }}" \
+            --json_key "$RUNNER_TEMP/play.json" \
+            --mapping dist/mapping/release/mapping.txt
+      - name: Remove Play service account
+        if: always()
+        run: rm -f "$RUNNER_TEMP/play.json"
+      - name: Checksums and signature
+        id: checksums
+        run: |
+          cp dist/apk/release/app-release.apk subtracks.apk
+          cp dist/bundle/release/app-release.aab subtracks.aab
+          gzip -n -9 -c dist/mapping/release/mapping.txt > mapping.txt.gz
+          sha256sum subtracks.apk subtracks.aab > SHA256SUMS
+          echo "Artifact SHA-256:"
+          sha256sum subtracks.apk subtracks.aab
+          echo "APK signature:"
+          certs=$(nix develop --command bash -c '"$ANDROID_HOME/build-tools/37.0.0/apksigner" verify --print-certs subtracks.apk')
+          printf '%s\n' "$certs"
+          fingerprint=$(printf '%s\n' "$certs" | sed -n 's/.*certificate SHA-256 digest: //p' | head -1 | tr '[:lower:]' '[:upper:]' | sed 's/\(..\)/\1:/g; s/:$//')
+          echo "fingerprint=$fingerprint" >> "$GITHUB_OUTPUT"
+      - name: Compose release notes
+        run: |
+          {
+            cat "metadata/en-US/changelogs/${{ needs.build.outputs.version-code }}.txt"
+            echo
+            echo '---'
+            echo
+            echo "APK SHA-256: \`$(grep 'subtracks\.apk$' SHA256SUMS | cut -d ' ' -f1)\`"
+            echo
+            echo "AAB SHA-256: \`$(grep 'subtracks\.aab$' SHA256SUMS | cut -d ' ' -f1)\`"
+            echo
+            echo "Signing certificate SHA-256: \`${{ steps.checksums.outputs.fingerprint }}\`"
+            echo
+            echo 'The signing certificate is attached as `release-certificate.pem`.'
+            if [ "${{ steps.stable.outputs.value }}" = "true" ]; then
+              echo 'The `.aab` is the exact bundle uploaded to Google Play; the `.apk` is the universal APK for sideloading.'
+            else
+              echo 'The `.aab` is the built app bundle (this pre-release was not uploaded to Google Play); the `.apk` is the universal APK for sideloading.'
+            fi
+          } > release-notes.md
+      - name: Create GitHub release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          args=(--verify-tag --title "$GITHUB_REF_NAME" --notes-file release-notes.md)
+          if [ "${{ steps.stable.outputs.value }}" != "true" ]; then
+            args+=(--prerelease)
+          fi
+          gh release create "$GITHUB_REF_NAME" subtracks.apk subtracks.aab SHA256SUMS dist/release-certificate.pem mapping.txt.gz "${args[@]}"

.gitignore

@@ -1,5 +1,6 @@
 .gradle/
 build/
+!.github/actions/build/
 local.properties
 
 *.apk

AGENTS.md

@@ -4,7 +4,7 @@ Guidance for agents (and humans) working in this repository.
 
 ## What this is
 
-A native Android rewrite of Subtracks, a client for Subsonic-compatible servers (Navidrome, gonic, Airsonic, ...), in Kotlin and Jetpack Compose. The `main` history still contains the earlier Flutter app; the native app is being built fresh under `app/` and ships as `com.subtracks.next` for side-by-side beta. The aim is a clean, F-Droid-friendly client: free/libre dependencies only, no telemetry.
+A native Android rewrite of Subtracks, a client for Subsonic-compatible servers (Navidrome, gonic, Airsonic, ...), in Kotlin and Jetpack Compose. The `main` history still contains the earlier Flutter app; the native app is being built fresh under `app/` and ships as `com.subtracks`. The aim is a clean, F-Droid-friendly client: free/libre dependencies only, no telemetry.
 
 ## Environment
 
@@ -34,7 +34,7 @@ Everything comes from the Nix flake devshell; do not install toolchains by hand.
 
 ## CI
 
-- Forgejo Actions, `.forgejo/workflows/ci.yml`, a single `ci` job that runs the lint, unit test and integration test steps (one cache restore/save and Gradle warm-up instead of three).
+- Forgejo Actions, `.forgejo/workflows/ci.yml`, a single `ci` job that runs lint, the unit tests, the debug and nightly assembles and the integration suite (one cache restore/save and Gradle warm-up instead of several); the GitHub copy uploads the debug and nightly APKs and the checksums as separate artifacts on a push to `main`.
 - Runs on the `nix-docker` runner (the `localhost/nix-ci` image built by the separate `nix-home` repo) inside the devshell, restoring the Nix store via `cache-nix-action` and caching Gradle and the integration test music.
 - The `nix-docker` and `bookworm` runner labels, their images and the runner's networking are defined in the separate `nix-home` repo (`hosts-incus/git-runner.nix`).
 - Pull requests from a fork need approval before the workflow runs.
@@ -48,6 +48,7 @@ Everything comes from the Nix flake devshell; do not install toolchains by hand.
 - Networking uses OkHttp and DOM XML parsing; auth uses the Subsonic token scheme by default.
 - Use coroutines and `Flow`; library reads are exposed as `Flow` from Room. Large lists page with Paging 3 over Room `PagingSource` rather than loading the whole table.
 - The library is mirrored in full at sync and must work offline. Never fetch library metadata on demand for browsing, filtering or sorting; only media bytes (streams, downloads) and images are on-demand. A server-derived sort key must be synced into a local column, not requested lazily when the sort is selected.
+- Auto-sync is a foreground-only, in-process timer (`AutoSync`, driven by the Activity lifecycle), not a background worker: do not move it to WorkManager or an alarm. `SyncManager` coalesces a request that arrives while a sync is running into a single follow-up; the library and Home sync actions no-op while one is running.
 - Playback is Media3: `PlaybackService` is a `MediaSessionService` owning an `ExoPlayer`, and `PlaybackController` (app-scoped Koin singleton) is the only thing the UI talks to. The queue is a `queue_entries` list of references with optional ranges plus a `playback_cursor` row; keep only a bounded window in memory (never the whole queue, and never load a whole table to build one). Stream URLs are freshly salted per request, so attach artwork by `CoverArtRef` cache key, not by URL.
 - UI state lives in `androidx.lifecycle.ViewModel`, wired with Koin (`koinViewModel()`); screens split into a stateful `*Route` and a stateless `*Screen` for screenshot tests.
 - UI and playback preferences go in DataStore (`UserPreferences`), not Room.
@@ -59,8 +60,8 @@ Everything comes from the Nix flake devshell; do not install toolchains by hand.
 - Room 3 does not map `PagingSource` automatically: a DAO that returns it needs `@DaoReturnTypeConverters(PagingSourceDaoReturnTypeConverter::class)`.
 - Material icons are not pulled in by `material3`; use the BOM-managed `material-icons-core`/`material-icons-extended` (frozen at 1.7.8). Extended is large in debug builds but R8 strips unused icons from release.
 - Robolectric creates a fresh `Application` per test in one JVM, so `SubtracksApp.onCreate` stops any running Koin before `startKoin`.
-- `applicationId` is `com.subtracks.next` for the beta; change it to `com.subtracks` before any store release.
 - The CI image provides `nix-ld`, `jq`, `sqlite`, `node`, `zstd` and a `runner` user that `cache-nix-action` expects. None of that is needed locally beyond the devshell.
 - Integration servers: navidrome on 4533 (`admin`/`password`), gonic on 4747 (`admin`/`admin`), lms on 5082 (`admin`/`subtracks-lms`), Nextcloud Music on 8090 (`admin`/`subtracks-nextcloud`, base URL `http://localhost:8090/index.php/apps/music/subsonic/`). The test music is cached in `.integration/music` (gitignored).
 - lms and Nextcloud Music authenticate the Subsonic API with per-user **API keys** instead of passwords. The harness seeds a key and most tests use `useTokenAuth = false`; `SubsonicAuthIntegrationTest` drives `useTokenAuth = true` and asserts the fallback to plaintext (lms answers code 42, Nextcloud 41).
 - `nix develop` does not source your shell rc files (so tools like atuin are not active); use direnv if you want your normal interactive shell.
+- The store screenshots in `metadata/en-US/images/phoneScreenshots/` must be 24-bit no-alpha PNGs (Play rejects palette and alpha PNGs for screenshots). `:app:demoScreenshots` writes its captures in that form, so copy them across as-is and don't run a palette optimizer over them.

README.md

@@ -26,21 +26,21 @@ subtracks is an open source Android client for [Subsonic-compatible](http://www.
   <a href="https://github.com/austinried/subtracks/releases/"><img src=".assets/github-badge.png" width="250"/></a>
 </div>
 
+See [signing/README.md](signing/README.md) for the fingerprints and the commands to verify a download.
+
 ## Features
 
-- Home screen to browse your library over many categories, genres, and more
+- **Large Libraries:** Built for very large libraries, from syncing the whole collection to playing playlists with thousands of tracks.
-- Album and artist artwork, shown full-resolution in the detail and now playing views
+- **Downloads:** Song and bulk downloads, with download quality (encoding, bitrate) and metered-connection settings.
-- Downloads with album, artist and playlist bulk downloads, download quality and a metered-connection toggle
+- **Offline Mode:** Stars, scrobbles and play counts queue up while you're offline and sync back to the server when you're online again.
-- Search across albums, artists, playlists and songs, with per-list sort and filter controls
+- **Artwork-first:** Album and artist art everywhere, shown full-resolution in the detail and now playing views.
-- Gapless playback, an editable queue you can reorder and jump through, and loop and shuffle modes
+- **Adaptive Theming:** Colours drawn from the current song's artwork.
-- Up next queue to add items into the currently playing queue without rewriting it
+- **Search:** Fast search across the whole library, with per-list sort and filter controls.
-- Multiple server support with quick switching
+- **Playback:** Gapless playback, an editable queue you can reorder and jump through, plus loop and shuffle modes.
-- Stream quality (bitrate and format) settings for Wi-Fi and mobile and automatic switching
+- **Up Next:** Add items into the currently playing queue without rewriting it.
-- Scrobbling and starred items, cached while offline and sent back to the server when online
+- **Multiple Servers:** Connect several servers and switch between them quickly.
-- Media notification and headset/Bluetooth controls
+- **Stream Quality:** Bitrate and format settings for Wi-Fi and mobile, with automatic switching.
-- Adaptive theming from the current song's artwork
+- **System Controls:** Media notification and headset/Bluetooth controls.
-
-The full library is mirrored at sync, so browsing, searching, sorting and filtering all work without waiting on the server. Only media and artwork are fetched on demand, and not even that when they're already downloaded.
 
 ## Building
 
@@ -55,6 +55,14 @@ gradle :app:assembleDebug
 
 Test, lint and screenshot commands, plus the integration harness, are documented in [AGENTS.md](AGENTS.md). The architecture is described in [docs/architecture.md](docs/architecture.md).
 
+## Contributing
+
+The GitHub repository [austinried/subtracks](https://github.com/austinried/subtracks) is a mirror of the repo hosted on my personal (private) code forge that syncs whenever I commit to it.
+
+Bug reports and feature requests are accepted on GitHub, as well as pull requests, but:
+* A well-crafted issue with clear reproduction and logs for bugs or mock-ups and use case details for features is preferred over a pull request
+* Pull requests will be pulled in as patches to my code forge and then synced back (you'll still be the author, I'll be shown as the committer)
+
 ## Translations
 
 Want to see subtracks in your language? Visit the project on [Weblate](https://hosted.weblate.org/engage/subtracks/) to help!
@@ -65,7 +73,7 @@ Want to see subtracks in your language? Visit the project on [Weblate](https://h
 
 ## AI usage disclosure
 
-This project contains code and documentation generated by LLM, which is created via human prompting, iteration and review.
+This project contains code and documentation generated by LLM, which is created via human prompting, iteration and review. The current native rewrite is based on two (and a half) other iterations of this project that I coded by hand, so the architecture and other decisions behind that are all still coming from me.
 
 ## License
 

app/build.gradle.kts

@@ -14,27 +14,48 @@ ktlint {
     version.set(libs.versions.ktlint.get())
 }
 
+val commitHash: String =
+    runCatching {
+        providers
+            .exec {
+                commandLine("git", "rev-parse", "HEAD")
+                workingDir = rootProject.layout.projectDirectory.asFile
+                isIgnoreExitValue = true
+            }.standardOutput.asText
+            .get()
+            .trim()
+            .take(7)
+    }.getOrDefault("")
+
 android {
     namespace = "com.subtracks"
     compileSdk = 37
     buildToolsVersion = "37.0.0"
 
     defaultConfig {
-        applicationId = "com.subtracks.next"
+        applicationId = "com.subtracks"
         minSdk = 24
         targetSdk = 37
         versionCode = 13
         versionName = "3.0.0"
+        buildConfigField("String", "COMMIT_HASH", "\"$commitHash\"")
     }
 
     buildFeatures {
         compose = true
+        buildConfig = true
     }
 
     androidResources {
         generateLocaleConfig = true
     }
 
+    dependenciesInfo {
+        // The APK signing-block copy is encrypted per build, breaking APK reproducibility, and
+        // F-Droid rejects it; the bundle keeps its copy for Play.
+        includeInApk = false
+    }
+
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_17
         targetCompatibility = JavaVersion.VERSION_17
@@ -43,7 +64,28 @@ android {
 
     lint {
         checkReleaseBuilds = false
-        disable += setOf("MissingTranslation", "MissingQuantity")
+        warningsAsErrors = true
+        disable +=
+            setOf(
+                "MissingTranslation",
+                "MissingQuantity",
+                // Version nags are handled by the dependency-update process, not the build.
+                "AndroidGradlePluginVersion",
+                "GradleDependency",
+                "NewerVersionAvailable",
+            )
+    }
+
+    packaging {
+        jniLibs {
+            // Prebuilt .so files with no symbol table; leaving them unstripped avoids the strip warning.
+            keepDebugSymbols +=
+                setOf(
+                    "**/libandroidx.graphics.path.so",
+                    "**/libdatastore_shared_counter.so",
+                    "**/libsqliteJni.so",
+                )
+        }
     }
 
     testOptions {
@@ -57,12 +99,43 @@ android {
         .kotlin.directories
         .add("src/integrationTest/kotlin")
 
+    signingConfigs {
+        // Committed on purpose: a public key for debug and nightly builds, never for distribution.
+        getByName("debug") {
+            storeFile = file("debug.keystore")
+            storePassword = "android"
+            keyAlias = "androiddebugkey"
+            keyPassword = "android"
+        }
+        val keystorePath = providers.environmentVariable("RELEASE_KEYSTORE").orNull
+        if (keystorePath != null) {
+            create("release") {
+                storeFile = file(keystorePath)
+                storePassword = providers.environmentVariable("RELEASE_KEYSTORE_PASSWORD").orNull
+                keyAlias = providers.environmentVariable("RELEASE_KEY_ALIAS").orNull
+                keyPassword = providers.environmentVariable("RELEASE_KEY_PASSWORD").orNull
+            }
+        }
+    }
+
+    sourceSets {
+        getByName("debug").res.srcDir("src/nightly/res")
+    }
+
     buildTypes {
+        debug {
+            applicationIdSuffix = ".nightly"
+        }
         release {
             isMinifyEnabled = true
             isShrinkResources = true
             proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"))
-            // Debug key so `installRelease` works locally; store and F-Droid builds re-sign.
+            // Release signing when the keystore is supplied (CI); debug elsewhere so local build/install works.
+            signingConfig = signingConfigs.findByName("release") ?: signingConfigs.getByName("debug")
+        }
+        create("nightly") {
+            initWith(getByName("release"))
+            applicationIdSuffix = ".nightly"
             signingConfig = signingConfigs.getByName("debug")
         }
     }
@@ -71,6 +144,7 @@ android {
 kotlin {
     compilerOptions {
         jvmTarget.set(JvmTarget.JVM_17)
+        allWarningsAsErrors.set(true)
     }
 }
 
@@ -82,6 +156,8 @@ ksp {
     arg("room.schemaLocation", "$projectDir/schemas")
 }
 
+// Resolving the variant classpaths here makes AGP warn that a configuration was resolved during
+// configuration time; upstream, tracked in mikepenz/AboutLibraries#1369.
 aboutLibraries {
     collect {
         configPath = file("config")
@@ -102,10 +178,12 @@ val integrationTestClasses =
 
 val demoScreenshotClass = "com.subtracks.ui.DemoScreenshotTest"
 
+val queryTimingClass = "com.subtracks.data.db.QueryTimingMeasurementTest"
+
 tasks.withType<Test>().configureEach {
     if (name.endsWith("UnitTest")) {
         filter {
-            (integrationTestClasses + demoScreenshotClass).forEach { excludeTestsMatching(it) }
+            (integrationTestClasses + demoScreenshotClass + queryTimingClass).forEach { excludeTestsMatching(it) }
         }
     }
     testLogging {
@@ -141,6 +219,20 @@ tasks.register<Test>("demoScreenshots") {
     outputs.upToDateWhen { false }
 }
 
+tasks.register<Test>("queryTiming") {
+    description = "Measures SQL query timings for the logging threshold (not a CI gate)"
+    group = "verification"
+    val unitTest = tasks.named<Test>("testDebugUnitTest")
+    dependsOn("compileDebugUnitTestKotlin")
+    testClassesDirs = files(provider { unitTest.get().testClassesDirs })
+    classpath = files(provider { unitTest.get().classpath })
+    filter {
+        includeTestsMatching(queryTimingClass)
+    }
+    providers.gradleProperty("measureSongs").orNull?.let { systemProperty("measure.songs", it) }
+    outputs.upToDateWhen { false }
+}
+
 dependencies {
     implementation(platform(libs.androidx.compose.bom))
     implementation(libs.androidx.core.ktx)
@@ -166,7 +258,9 @@ dependencies {
     implementation(libs.androidx.datastore.preferences)
     implementation(libs.androidx.media3.exoplayer)
     implementation(libs.androidx.media3.session)
+    implementation(libs.androidx.media3.datasource)
     implementation(libs.androidx.media3.datasource.okhttp)
+    implementation(libs.androidx.media3.database)
     implementation(libs.okhttp)
     implementation(libs.coil.compose)
     implementation(libs.coil.network.okhttp)

app/config/libraries/subtracks.json

@@ -1,5 +1,5 @@
 {
-  "uniqueId": "com.subtracks:next",
+  "uniqueId": "com.subtracks",
   "name": "Subtracks",
   "description": "Subtracks itself, a client for Subsonic-compatible servers.",
   "website": "https://github.com/austinried/subtracks",

app/src/main/AndroidManifest.xml

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
 
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.DOWNLOAD_WITHOUT_NOTIFICATION" />
@@ -18,7 +19,8 @@
         android:networkSecurityConfig="@xml/network_security_config"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
-        android:theme="@style/Theme.Subtracks">
+        android:theme="@style/Theme.Subtracks"
+        tools:ignore="DataExtractionRules,UnusedAttribute">
 
         <activity
             android:name=".MainActivity"
@@ -35,7 +37,8 @@
         <service
             android:name=".playback.PlaybackService"
             android:exported="true"
-            android:foregroundServiceType="mediaPlayback">
+            android:foregroundServiceType="mediaPlayback"
+            tools:ignore="ExportedService">
             <intent-filter>
                 <action android:name="androidx.media3.session.MediaSessionService" />
             </intent-filter>
@@ -44,6 +47,16 @@
         <receiver
             android:name=".data.download.DownloadCancelReceiver"
             android:exported="false" />
+
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.fileprovider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths" />
+        </provider>
     </application>
 
 </manifest>

app/src/main/kotlin/com/subtracks/MainActivity.kt

@@ -11,6 +11,7 @@ import androidx.activity.enableEdgeToEdge
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.activity.viewModels
 import androidx.core.content.ContextCompat
+import com.subtracks.data.sync.AutoSync
 import com.subtracks.ui.NowPlayingLauncher
 import com.subtracks.ui.SubtracksRoot
 import com.subtracks.ui.theme.SubtracksTheme
@@ -19,10 +20,21 @@ import org.koin.core.context.GlobalContext
 class MainActivity : ComponentActivity() {
     private val launchViewModel: NowPlayingLaunchViewModel by viewModels()
     private val nowPlayingLauncher: NowPlayingLauncher by lazy { GlobalContext.get().get() }
+    private val autoSync: AutoSync by lazy { GlobalContext.get().get() }
 
     private val requestNotifications =
         registerForActivityResult(ActivityResultContracts.RequestPermission()) { }
 
+    override fun onStart() {
+        super.onStart()
+        autoSync.setForeground(true)
+    }
+
+    override fun onStop() {
+        super.onStop()
+        autoSync.setForeground(false)
+    }
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         requestNotificationPermission()

app/src/main/kotlin/com/subtracks/SubtracksApp.kt

@@ -5,20 +5,28 @@ import coil3.ImageLoader
 import coil3.SingletonImageLoader
 import coil3.annotation.DelicateCoilApi
 import coil3.network.okhttp.OkHttpNetworkFetcherFactory
+import com.subtracks.data.LegacyDataCleanup
 import com.subtracks.data.prefs.UserPreferences
 import com.subtracks.data.repo.ArtworkSeedStore
 import com.subtracks.di.appModule
+import com.subtracks.log.Log
 import com.subtracks.ui.theme.ArtworkSeedCache
-import okhttp3.OkHttpClient
 import org.koin.core.context.startKoin
 import org.koin.core.context.stopKoin
 
 class SubtracksApp : Application() {
-    private val http = OkHttpClient()
+    private val http =
+        UserAgent
+            .httpClient()
+            .newBuilder()
+            .addInterceptor(Log.interceptor())
+            .build()
 
     @OptIn(DelicateCoilApi::class)
     override fun onCreate() {
         super.onCreate()
+        Log.init(this)
+        LegacyDataCleanup.run(this)
         stopKoin()
         SingletonImageLoader.reset()
         val koin =

app/src/main/kotlin/com/subtracks/UserAgent.kt

@@ -0,0 +1,22 @@
+package com.subtracks
+
+import android.os.Build
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+
+object UserAgent {
+    val value: String = "subtracks (Android ${Build.VERSION.RELEASE}; ${BuildConfig.VERSION_NAME})"
+
+    fun interceptor(): Interceptor =
+        Interceptor { chain ->
+            chain.proceed(
+                chain
+                    .request()
+                    .newBuilder()
+                    .header("User-Agent", value)
+                    .build(),
+            )
+        }
+
+    fun httpClient(): OkHttpClient = OkHttpClient.Builder().addInterceptor(interceptor()).build()
+}

app/src/main/kotlin/com/subtracks/data/LegacyDataCleanup.kt

@@ -0,0 +1,41 @@
+package com.subtracks.data
+
+import android.content.Context
+import com.subtracks.log.Log
+import java.io.File
+
+// One-shot cleanup of the 1.x React Native app, which shipped as com.subtracks before this rewrite.
+// It left an AsyncStorage database (RKStorage), an older `servers` dump and a downloaded/cached
+// artwork+audio tree (under the app's external files dir) that v3 never reads. Only a real 1.x upgrade
+// has those paths, so a fresh install does nothing and an upgrade is cleaned exactly once.
+//
+// Delete this file and its call in SubtracksApp once installs can no longer be coming from 1.x.
+internal object LegacyDataCleanup {
+    fun run(context: Context) {
+        // The cached trees can be large, so keep the walk off the main thread.
+        Thread { run(context.dataDir, context.getExternalFilesDir(null)) }.start()
+    }
+
+    internal fun run(
+        dataDir: File,
+        externalFilesDir: File?,
+    ) {
+        val database = File(dataDir, "databases/RKStorage")
+        val servers = File(dataDir, "files/servers")
+        val cache = externalFilesDir?.let { File(it, "s") }
+        if (!database.exists() && !servers.exists() && cache?.exists() != true) return
+        deleteDatabase(database)
+        deleteTree(servers)
+        cache?.let(::deleteTree)
+    }
+
+    private fun deleteDatabase(database: File) {
+        listOf("", "-wal", "-shm", "-journal").forEach { deleteTree(File(database.path + it)) }
+    }
+
+    private fun deleteTree(target: File) {
+        if (!target.exists()) return
+        val removed = target.deleteRecursively()
+        Log.i("legacy", "removed ${target.path} ($removed)")
+    }
+}

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

@@ -3,10 +3,14 @@ package com.subtracks.data.db
 import android.content.Context
 import androidx.room3.Room
 import androidx.sqlite.driver.bundled.BundledSQLiteDriver
+import com.subtracks.log.Log
 
-fun createAndroidDatabase(context: Context): SubtracksDatabase =
+fun createAndroidDatabase(context: Context): SubtracksDatabase {
-    Room
+    val driver = LoggingSQLiteDriver(BundledSQLiteDriver(), Log::sql)
+    return Room
         .databaseBuilder<SubtracksDatabase>(context, "subtracks.db")
-        .setDriver(BundledSQLiteDriver())
+        .setDriver(driver)
-        .addMigrations(*MIGRATIONS)
+        .addMigrations(*MIGRATIONS.map(::LoggedMigration).toTypedArray())
+        .addCallback(SqliteLifecycleLogging)
         .build()
+}

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

@@ -0,0 +1,129 @@
+package com.subtracks.data.db
+
+import androidx.room3.RoomDatabase
+import androidx.room3.migration.Migration
+import androidx.sqlite.SQLiteConnection
+import androidx.sqlite.SQLiteDriver
+import androidx.sqlite.SQLiteStatement
+import com.subtracks.log.Log
+import kotlinx.coroutines.CancellationException
+
+data class SqlExecution(
+    val sql: String,
+    val durationNanos: Long,
+    val rows: Long,
+    val error: Throwable?,
+) {
+    val durationMillis: Double get() = durationNanos / 1_000_000.0
+}
+
+class LoggingSQLiteDriver(
+    private val delegate: SQLiteDriver,
+    private val onExecution: (SqlExecution) -> Unit,
+) : SQLiteDriver {
+    override val hasConnectionPool: Boolean
+        get() = delegate.hasConnectionPool
+
+    override fun open(fileName: String): SQLiteConnection = LoggingConnection(delegate.open(fileName), onExecution)
+}
+
+private class LoggingConnection(
+    private val delegate: SQLiteConnection,
+    private val onExecution: (SqlExecution) -> Unit,
+) : SQLiteConnection by delegate {
+    override fun prepare(sql: String): SQLiteStatement {
+        val start = System.nanoTime()
+        return try {
+            LoggingStatement(delegate.prepare(sql), sql, onExecution)
+        } catch (failure: Throwable) {
+            onExecution(SqlExecution(sql, System.nanoTime() - start, 0, failure))
+            throw failure
+        }
+    }
+}
+
+private class LoggingStatement(
+    private val delegate: SQLiteStatement,
+    private val sql: String,
+    private val onExecution: (SqlExecution) -> Unit,
+) : SQLiteStatement by delegate {
+    private var startNanos = 0L
+    private var rows = 0L
+    private var failure: Throwable? = null
+    private var active = false
+
+    override fun step(): Boolean {
+        begin()
+        val result =
+            try {
+                delegate.step()
+            } catch (error: Throwable) {
+                failure = error
+                report()
+                throw error
+            }
+        if (result) rows++
+        if (!result) report()
+        return result
+    }
+
+    override fun reset() {
+        report()
+        delegate.reset()
+    }
+
+    override fun close() {
+        report()
+        delegate.close()
+    }
+
+    private fun report() {
+        if (!active) return
+        active = false
+        onExecution(SqlExecution(sql, System.nanoTime() - startNanos, rows, failure))
+    }
+
+    // Started on the first step, not on reset: Room's statement cache resets a statement when it is
+    // returned to the cache (BasePreparedStatementCache.CachedStatement.close), so timing from reset
+    // would count however long the statement idled there before its next use.
+    private fun begin() {
+        if (active) return
+        startNanos = System.nanoTime()
+        rows = 0
+        failure = null
+        active = true
+    }
+}
+
+class LoggedMigration(
+    private val delegate: Migration,
+) : Migration(delegate.startVersion, delegate.endVersion) {
+    override suspend fun migrate(connection: SQLiteConnection) {
+        val label = "${delegate.startVersion} -> ${delegate.endVersion}"
+        Log.i("sql", "migrating $label")
+        val start = System.nanoTime()
+        try {
+            delegate.migrate(connection)
+        } catch (cancellation: CancellationException) {
+            throw cancellation
+        } catch (failure: Throwable) {
+            Log.e("sql", "migration $label failed after ${(System.nanoTime() - start) / 1_000_000}ms", failure)
+            throw failure
+        }
+        Log.i("sql", "migrated $label in ${(System.nanoTime() - start) / 1_000_000}ms")
+    }
+}
+
+internal object SqliteLifecycleLogging : RoomDatabase.Callback() {
+    override suspend fun onCreate(connection: SQLiteConnection) {
+        Log.i("sql", "created fresh database")
+    }
+
+    override suspend fun onOpen(connection: SQLiteConnection) {
+        Log.i("sql", "database opened")
+    }
+
+    override suspend fun onDestructiveMigration(connection: SQLiteConnection) {
+        Log.w("sql", "destructive migration: dropping all tables")
+    }
+}

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

@@ -2,8 +2,8 @@ package com.subtracks.data.db
 
 import androidx.room3.Dao
 import androidx.room3.Insert
+import androidx.room3.OnConflictStrategy
 import androidx.room3.Query
-import androidx.room3.Upsert
 import com.subtracks.data.model.AlbumSongItem
 import com.subtracks.data.model.PlaybackCursor
 import com.subtracks.data.model.PlaylistSongItem
@@ -55,7 +55,7 @@ interface QueueDao {
     @Query("SELECT * FROM playback_cursor WHERE id = 1")
     suspend fun cursor(): PlaybackCursor?
 
-    @Upsert
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun setCursor(cursor: PlaybackCursor)
 
     @Query(

app/src/main/kotlin/com/subtracks/data/download/SystemDownloadEngine.kt

@@ -2,8 +2,9 @@ package com.subtracks.data.download
 
 import android.app.DownloadManager
 import android.content.Context
-import android.net.Uri
 import android.os.Environment
+import androidx.core.net.toUri
+import com.subtracks.UserAgent
 import com.subtracks.data.model.DownloadError
 
 class SystemDownloadEngine(
@@ -12,10 +13,11 @@ class SystemDownloadEngine(
     override fun enqueue(request: EngineRequest): Long {
         val download =
             DownloadManager
-                .Request(Uri.parse(request.uri))
+                .Request(request.uri.toUri())
                 .setTitle(request.title)
                 .setDestinationInExternalFilesDir(context, Environment.DIRECTORY_MUSIC, request.path)
                 .setNotificationVisibility(DownloadManager.Request.VISIBILITY_HIDDEN)
+                .addRequestHeader("User-Agent", UserAgent.value)
                 // Wi-Fi only unless the preference allows a metered network, and roaming counts as
                 // one of those; the platform otherwise permits it by default.
                 .setAllowedOverMetered(request.allowMetered)

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

@@ -6,6 +6,7 @@ import androidx.datastore.preferences.core.Preferences
 import androidx.datastore.preferences.core.booleanPreferencesKey
 import androidx.datastore.preferences.core.edit
 import androidx.datastore.preferences.core.intPreferencesKey
+import androidx.datastore.preferences.core.longPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import androidx.datastore.preferences.preferencesDataStore
 import com.subtracks.data.net.NetworkMode
@@ -48,6 +49,10 @@ data class StreamQuality(
 
 private val Context.preferences: DataStore<Preferences> by preferencesDataStore("user_prefs")
 
+const val DEFAULT_SYNC_INTERVAL_MINUTES = 24 * 60
+
+enum class SyncMode { Off, WifiOnly, Always }
+
 data class ArtworkSeedValue(
     val cacheKey: String,
     val primary: Int,
@@ -105,6 +110,34 @@ class UserPreferences(
 
     private val syncConcurrencyKey = intPreferencesKey("sync_concurrency")
 
+    fun syncMode(): Flow<SyncMode> =
+        store.data.map { prefs ->
+            prefs[syncModeKey]?.let { stored -> SyncMode.entries.firstOrNull { it.name == stored } } ?: SyncMode.WifiOnly
+        }
+
+    suspend fun setSyncMode(mode: SyncMode) {
+        store.edit { prefs -> prefs[syncModeKey] = mode.name }
+    }
+
+    private val syncModeKey = stringPreferencesKey("sync_mode")
+
+    fun lastSyncAt(): Flow<Long> = store.data.map { prefs -> prefs[lastSyncAtKey] ?: 0L }
+
+    suspend fun setLastSyncAt(value: Long) {
+        store.edit { prefs -> prefs[lastSyncAtKey] = value }
+    }
+
+    private val lastSyncAtKey = longPreferencesKey("last_sync_at")
+
+    fun syncIntervalMinutes(): Flow<Int> =
+        store.data.map { prefs -> (prefs[syncIntervalKey] ?: DEFAULT_SYNC_INTERVAL_MINUTES).coerceAtLeast(1) }
+
+    suspend fun setSyncIntervalMinutes(value: Int) {
+        store.edit { prefs -> prefs[syncIntervalKey] = value.coerceAtLeast(1) }
+    }
+
+    private val syncIntervalKey = intPreferencesKey("sync_interval_minutes")
+
     fun scrobbling(): Flow<Boolean> = store.data.map { prefs -> prefs[scrobblingKey] ?: true }
 
     suspend fun setScrobbling(enabled: Boolean) {
@@ -121,6 +154,14 @@ class UserPreferences(
 
     private val offlineModeKey = booleanPreferencesKey("offline_mode")
 
+    fun verboseLogging(): Flow<Boolean> = store.data.map { prefs -> prefs[verboseLoggingKey] ?: false }
+
+    suspend fun setVerboseLogging(enabled: Boolean) {
+        store.edit { prefs -> prefs[verboseLoggingKey] = enabled }
+    }
+
+    private val verboseLoggingKey = booleanPreferencesKey("verbose_logging")
+
     suspend fun lastSeed(): ArtworkSeedValue? {
         val prefs = store.data.first()
         val cacheKey = prefs[lastSeedKey] ?: return null

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

@@ -19,6 +19,7 @@ import com.subtracks.data.model.DownloadedSong
 import com.subtracks.data.model.ListDownloadStatus
 import com.subtracks.data.model.SongDownload
 import com.subtracks.data.model.coverArtKey
+import com.subtracks.log.Log
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineDispatcher
@@ -79,7 +80,10 @@ class DownloadRepository(
         }
         scope.launch {
             sourceRepository.offline.collect { offline ->
-                if (offline) cancelActive()
+                if (offline) {
+                    Log.i("download", "offline: cancelling active downloads")
+                    cancelActive()
+                }
             }
         }
     }
@@ -140,6 +144,7 @@ class DownloadRepository(
         dir(sourceId).mkdirs()
         file(sourceId, songId).delete()
         db.downloadDao().upsert(SongDownload(sourceId = sourceId, songId = songId, status = DownloadStatus.Queued))
+        Log.i("download", "queued song=$songId (source $sourceId)")
         ensurePolling()
         return true
     }
@@ -336,6 +341,7 @@ class DownloadRepository(
 
     private suspend fun removeRows(rows: List<SongDownload>) {
         if (rows.isEmpty()) return
+        Log.i("download", "removed ${rows.size} download(s)")
         val engineIds = rows.mapNotNull { it.engineId }
         if (engineIds.isNotEmpty()) engine.cancel(engineIds)
         rows.groupBy { it.sourceId }.forEach { (sourceId, group) ->
@@ -581,6 +587,14 @@ class DownloadRepository(
                     },
             )
         if (updated != row) db.downloadDao().upsert(updated)
+        if (updated.status != row.status) {
+            when (updated.status) {
+                DownloadStatus.Completed -> Log.i("download", "completed ${row.songId} (${updated.total} bytes)")
+                DownloadStatus.Failed -> Log.w("download", "failed ${row.songId}: ${updated.error}")
+                DownloadStatus.Running -> Log.i("download", "started ${row.songId}")
+                DownloadStatus.Queued -> Unit
+            }
+        }
     }
 
     private suspend fun markFailed(
@@ -590,6 +604,7 @@ class DownloadRepository(
         row.engineId?.let { engine.cancel(listOf(it)) }
         file(row.sourceId, row.songId).delete()
         db.downloadDao().upsert(row.copy(status = DownloadStatus.Failed, engineId = null, error = error))
+        Log.w("download", "failed ${row.songId}: $error")
     }
 
     private fun ensurePolling() {

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

@@ -24,6 +24,7 @@ import com.subtracks.data.prefs.PlaylistSort
 import com.subtracks.data.prefs.StarredFilter
 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
@@ -464,14 +465,17 @@ class LibraryRepository(
         }
         val previous = starredValue(sourceId, type, id)
         updateStarred(sourceId, type, id, if (starred) System.currentTimeMillis() else null)
+        val action = if (starred) "star" else "unstar"
         return try {
             serverActions.setStar(type, id, starred)
+            Log.i("star", "$action ${type.name.lowercase()} $id")
             Result.success(Unit)
         } catch (cancellation: CancellationException) {
             throw cancellation
         } catch (failure: Exception) {
             withContext(NonCancellable) { updateStarred(sourceId, type, id, previous) }
             showMessage(UiMessage(R.string.star_update_failed))
+            Log.w("star", "failed to $action ${type.name.lowercase()} $id", failure)
             Result.failure(failure)
         }
     }

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

@@ -6,6 +6,7 @@ import com.subtracks.data.model.PendingActionKind
 import com.subtracks.data.source.ServerActionSink
 import com.subtracks.data.source.StarType
 import com.subtracks.data.source.subsonic.SubsonicException
+import com.subtracks.log.Log
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
@@ -29,8 +30,13 @@ class PendingServerActionSink(
 
     init {
         scope.launch {
+            var lastReady: Boolean? = null
             combine(offlinePreferences, networkAvailable) { isOffline, online -> !isOffline && online }
                 .collect { ready ->
+                    if (ready && lastReady == false) {
+                        Log.i("net", "connection available, replaying pending server actions")
+                    }
+                    lastReady = ready
                     // The persisted flag and connectivity are authoritative, unlike the process
                     // flag's default at cold start, so wait for that flag to agree before replaying.
                     if (ready) {
@@ -96,12 +102,14 @@ class PendingServerActionSink(
         for (action in dao.pending(sourceId)) {
             try {
                 deliver(action)
+                Log.i("net", "replayed ${action.kind.name.lowercase()} ${action.targetId}")
             } catch (cancellation: CancellationException) {
                 throw cancellation
             } catch (failure: Exception) {
                 // Still unreachable: keep this and the remaining actions for the next attempt.
                 if (isRetryable(failure)) return
                 // The server answered and refused; drop the action rather than block the queue.
+                Log.w("net", "dropped ${action.kind.name.lowercase()} ${action.targetId}", failure)
             }
             dao.delete(action.id)
         }
@@ -139,6 +147,7 @@ class PendingServerActionSink(
         db.pendingActionDao().replace(
             PendingAction(sourceId = sourceId, kind = kind, targetId = targetId, starType = starType, time = time),
         )
+        Log.i("net", "queued ${kind.name.lowercase()} $targetId")
         return true
     }
 

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

@@ -17,6 +17,7 @@ import com.subtracks.data.source.MusicSource
 import com.subtracks.data.source.declaredStreamLength
 import com.subtracks.data.source.streamLengthSuffix
 import com.subtracks.data.source.subsonic.SubsonicClient
+import com.subtracks.log.Log
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -46,6 +47,13 @@ class SourceRepository(
         val source: SubsonicMusicSource,
     )
 
+    private data class ResolvedSource(
+        val config: SubsonicConfig?,
+        val quality: StreamQuality,
+        val mode: NetworkMode,
+        val concurrency: Int,
+    )
+
     @Volatile
     private var active: ActiveSource? = null
 
@@ -64,6 +72,7 @@ class SourceRepository(
     fun downloadsAllowedOverMetered(): Boolean = allowMeteredDownloads
 
     fun setOfflineMode(enabled: Boolean) {
+        Log.i("net", "offline mode -> $enabled")
         scope.launch { prefs.setOfflineMode(enabled) }
     }
 
@@ -81,6 +90,7 @@ class SourceRepository(
             // Read the persisted flag before the source config can build a source or probe it, so a
             // cold start with offline on never touches the network.
             _offline.value = prefs.offlineMode().first()
+            var lastMode: NetworkMode? = null
             combine(
                 db.sourcesDao().activeSubsonicConfig(),
                 networkMode,
@@ -88,13 +98,23 @@ class SourceRepository(
                 prefs.streamQuality(NetworkMode.Mobile),
                 prefs.syncConcurrency(),
             ) { config, mode, wifi, mobile, concurrency ->
-                Triple(config, if (mode == NetworkMode.Wifi) wifi else mobile, concurrency)
+                ResolvedSource(config, if (mode == NetworkMode.Wifi) wifi else mobile, mode, concurrency)
-            }.collect { (config, quality, concurrency) ->
+            }.collect { (config, quality, mode, concurrency) ->
+                if (mode != lastMode) {
+                    Log.i("net", "network mode -> ${mode.key}")
+                    lastMode = mode
+                }
                 val sourceChanged = config?.id != active?.id
+                if (sourceChanged) {
+                    Log.i("net", "active source -> ${config?.name ?: "none"}")
+                }
                 active = config?.let { ActiveSource(it.id, it.toMusicSource(quality, concurrency)) }
                 _quality.value = quality
                 if (sourceChanged && config != null && config.useTokenAuth && !_offline.value) {
-                    scope.launch { runCatching { config.toClient().check("ping") } }
+                    scope.launch {
+                        runCatching { config.toClient().check("ping") }
+                            .onSuccess { Log.i("net", "connected (ping ok)") }
+                    }
                 }
             }
         }

app/src/main/kotlin/com/subtracks/data/source/subsonic/SubsonicClient.kt

@@ -2,6 +2,7 @@ package com.subtracks.data.source.subsonic
 
 import com.subtracks.R
 import com.subtracks.UiMessage
+import com.subtracks.log.Log
 import okhttp3.HttpUrl
 import okhttp3.OkHttpClient
 import okhttp3.Request
@@ -20,7 +21,6 @@ class SubsonicClient(
     private val password: String,
     useTokenAuth: Boolean,
     private val http: OkHttpClient,
-    private val userAgent: String = "subtracks/android",
     private val onTokenAuthUnsupported: () -> Unit = {},
 ) {
     @Volatile
@@ -61,7 +61,11 @@ class SubsonicClient(
         return try {
             execute(method, params, body)
         } catch (failure: SubsonicException) {
-            if (failure.code !in TOKEN_AUTH_UNSUPPORTED_CODES || !usedTokenAuth) throw failure
+            if (failure.code !in TOKEN_AUTH_UNSUPPORTED_CODES || !usedTokenAuth) {
+                Log.w("http", "$method failed: server code ${failure.code} \"${failure.message}\"")
+                throw failure
+            }
+            Log.w("http", "$method: token auth unsupported (server code ${failure.code}), retrying with plaintext")
             disableTokenAuth()
             execute(method, params, body)
         }
@@ -76,7 +80,6 @@ class SubsonicClient(
             Request
                 .Builder()
                 .url(uri(method, params))
-                .header("User-Agent", userAgent)
                 .build()
         http.newCall(request).execute().use { response ->
             if (!response.isSuccessful) {

app/src/main/kotlin/com/subtracks/data/sync/AutoSync.kt

@@ -0,0 +1,108 @@
+package com.subtracks.data.sync
+
+import com.subtracks.data.net.NetworkMode
+import com.subtracks.data.prefs.SyncMode
+import com.subtracks.data.prefs.UserPreferences
+import com.subtracks.log.Log
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+
+internal const val AUTO_SYNC_MAX_POLL_MS = 15L * 60 * 1000
+
+internal fun shouldAutoSync(
+    mode: SyncMode,
+    network: NetworkMode,
+    offline: Boolean,
+    hasSource: Boolean,
+    lastSyncAt: Long,
+    now: Long,
+    intervalMs: Long,
+): Boolean {
+    val allowed =
+        when (mode) {
+            SyncMode.Off -> false
+            SyncMode.WifiOnly -> network == NetworkMode.Wifi
+            SyncMode.Always -> true
+        }
+    return allowed && !offline && hasSource && (lastSyncAt > now || now - lastSyncAt >= intervalMs)
+}
+
+class AutoSync(
+    private val preferences: UserPreferences,
+    private val networkMode: Flow<NetworkMode>,
+    private val hasSource: suspend () -> Boolean,
+    private val requestSync: () -> Unit,
+    private val scope: CoroutineScope,
+    private val now: () -> Long = System::currentTimeMillis,
+    private val maxPollMs: Long = AUTO_SYNC_MAX_POLL_MS,
+) {
+    @Volatile
+    private var lastNetwork: NetworkMode? = null
+    private var loop: Job? = null
+
+    init {
+        scope.launch { networkMode.collect { lastNetwork = it } }
+    }
+
+    fun setForeground(active: Boolean) {
+        if (active) start() else stop()
+    }
+
+    private fun start() {
+        if (loop?.isActive == true) return
+        loop =
+            scope.launch {
+                while (isActive) {
+                    val intervalMs =
+                        try {
+                            checkAndRequest()
+                        } catch (cancellation: CancellationException) {
+                            throw cancellation
+                        } catch (failure: Exception) {
+                            Log.w("sync", "auto-sync check failed", failure)
+                            maxPollMs
+                        }
+                    delay(intervalMs.coerceAtMost(maxPollMs))
+                }
+            }
+    }
+
+    private fun stop() {
+        loop?.cancel()
+        loop = null
+    }
+
+    private suspend fun checkAndRequest(): Long {
+        val mode = preferences.syncMode().first()
+        val network = lastNetwork ?: networkMode.first()
+        val offline = preferences.offlineMode().first()
+        val hasSource = hasSource()
+        val lastSyncAt = preferences.lastSyncAt().first()
+        val intervalMs = preferences.syncIntervalMinutes().first() * 60_000L
+        val time = now()
+        val due =
+            shouldAutoSync(
+                mode = mode,
+                network = network,
+                offline = offline,
+                hasSource = hasSource,
+                lastSyncAt = lastSyncAt,
+                now = time,
+                intervalMs = intervalMs,
+            )
+        Log.d(
+            "sync",
+            "auto-sync due=$due (mode=$mode, network=$network, offline=$offline, hasSource=$hasSource, " +
+                "sinceLast=${time - lastSyncAt}ms, interval=${intervalMs}ms)",
+        )
+        if (due && currentCoroutineContext().isActive) requestSync()
+        return intervalMs
+    }
+}

app/src/main/kotlin/com/subtracks/data/sync/SyncManager.kt

@@ -1,26 +1,31 @@
 package com.subtracks.data.sync
 
-import android.util.Log
 import com.subtracks.R
 import com.subtracks.UiMessage
 import com.subtracks.data.db.SubtracksDatabase
+import com.subtracks.data.prefs.UserPreferences
 import com.subtracks.data.repo.QueueRepository
 import com.subtracks.data.repo.SourceRepository
 import com.subtracks.data.source.ServerActionSink
 import com.subtracks.data.source.subsonic.SubsonicException
+import com.subtracks.log.Log
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 
 sealed interface SyncStatus {
     data object Idle : SyncStatus
 
-    data object Running : SyncStatus
+    data class Running(
+        val silent: Boolean,
+    ) : SyncStatus
 
     data object Success : SyncStatus
 
@@ -34,41 +39,65 @@ class SyncManager(
     private val sourceRepository: SourceRepository,
     private val queueRepository: QueueRepository,
     private val serverActions: ServerActionSink,
+    private val preferences: UserPreferences,
     private val showMessage: (UiMessage) -> Unit = {},
     private val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default),
 ) {
-    private val requests = Channel<Unit>(Channel.CONFLATED)
+    private val requests = Channel<Boolean>(Channel.CONFLATED)
     private val _status = MutableStateFlow<SyncStatus>(SyncStatus.Idle)
     val status: StateFlow<SyncStatus> = _status
 
     init {
         scope.launch {
-            for (ignored in requests) runSync()
+            for (silent in requests) {
+                try {
+                    runSync(silent)
+                } catch (cancellation: CancellationException) {
+                    if (!currentCoroutineContext().isActive) throw cancellation
+                    _status.value = SyncStatus.Idle
+                    Log.w("sync", "sync interrupted", cancellation)
+                } catch (failure: Throwable) {
+                    _status.value = SyncStatus.Idle
+                    Log.w("sync", "unexpected failure", failure)
+                }
+            }
         }
     }
 
-    fun requestSync() {
+    fun requestSync(silent: Boolean = false) {
-        requests.trySend(Unit)
+        requests.trySend(silent)
     }
 
-    private suspend fun runSync() {
+    private suspend fun runSync(silent: Boolean) {
         if (sourceRepository.offline.value) {
+            if (!silent) {
                 val offline = UiMessage(R.string.sync_offline)
                 showMessage(offline)
                 _status.value = SyncStatus.Failed(offline)
+            }
             return
         }
-        _status.value = SyncStatus.Running
+        _status.value = SyncStatus.Running(silent)
+        runCatching { preferences.setLastSyncAt(System.currentTimeMillis()) }
+            .onFailure { Log.w("sync", "could not record the sync attempt", it) }
+        val startedAt = System.nanoTime()
         val result =
             try {
                 val source = sourceRepository.activeMusicSource() ?: throw NoServerException()
+                Log.i("sync", "started (source ${source.id})")
                 serverActions.flush()
-                SyncService(db, source).sync()
+                val summary = SyncService(db, source).sync()
+                Log.i(
+                    "sync",
+                    "finished in ${elapsedMs(startedAt)}ms: " +
+                        "${summary.artists} artists, ${summary.albums} albums, ${summary.songs} songs, " +
+                        "${summary.playlists} playlists, ${summary.playlistSongs} playlist tracks, ${summary.pruned} pruned",
+                )
                 SyncStatus.Success
             } catch (cancellation: CancellationException) {
                 throw cancellation
             } catch (failure: Exception) {
-                Log.w(TAG, "Sync failed", failure)
+                Log.w("sync", "failed after ${elapsedMs(startedAt)}ms", failure)
                 val message =
                     when (failure) {
                         is NoServerException -> {
@@ -80,16 +109,14 @@ class SyncManager(
                                 ?: UiMessage(R.string.sync_failed_detail, listOf(failure.message ?: ""))
                         }
                     }
-                showMessage(message)
+                if (!silent) showMessage(message)
                 SyncStatus.Failed(message)
             }
         queueRepository.invalidateLibraryCache()
         _status.value = result
     }
 
-    private companion object {
+    private fun elapsedMs(startNanos: Long): Long = (System.nanoTime() - startNanos) / 1_000_000
-        const val TAG = "SubtracksSync"
-    }
 }
 
 private class NoServerException : IllegalStateException()

app/src/main/kotlin/com/subtracks/data/sync/SyncNotifier.kt

@@ -0,0 +1,72 @@
+package com.subtracks.data.sync
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import com.subtracks.R
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.launch
+
+class SyncNotifier(
+    private val context: Context,
+    private val status: Flow<SyncStatus>,
+    private val scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Default),
+) {
+    private val manager = NotificationManagerCompat.from(context)
+
+    fun start() {
+        createChannel()
+        scope.launch {
+            status.collect { syncStatus ->
+                if (syncStatus is SyncStatus.Running && manager.areNotificationsEnabled()) {
+                    manager.notify(ID, build())
+                } else {
+                    manager.cancel(ID)
+                }
+            }
+        }
+    }
+
+    private fun build(): Notification =
+        NotificationCompat
+            .Builder(context, CHANNEL_ID)
+            .setSmallIcon(R.drawable.ic_stat_name)
+            .setContentTitle(context.getString(R.string.sync_notification_title))
+            .setContentText(context.getString(R.string.sync_notification_text))
+            .setOnlyAlertOnce(true)
+            .setSilent(true)
+            .setProgress(0, 0, true)
+            .setContentIntent(launchIntent())
+            .build()
+
+    private fun launchIntent(): PendingIntent? =
+        context.packageManager
+            .getLaunchIntentForPackage(context.packageName)
+            ?.let { PendingIntent.getActivity(context, 0, it, PendingIntent.FLAG_IMMUTABLE) }
+
+    private fun createChannel() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val manager = context.getSystemService(NotificationManager::class.java) ?: return
+        if (manager.getNotificationChannel(CHANNEL_ID) != null) return
+        manager.createNotificationChannel(
+            NotificationChannel(
+                CHANNEL_ID,
+                context.getString(R.string.sync_notification_channel),
+                NotificationManager.IMPORTANCE_LOW,
+            ).apply { setShowBadge(false) },
+        )
+    }
+
+    companion object {
+        private const val ID = 2
+        private const val CHANNEL_ID = "sync"
+    }
+}

app/src/main/kotlin/com/subtracks/data/sync/SyncService.kt

@@ -20,13 +20,28 @@ class SyncService(
     private val db: SubtracksDatabase,
     private val source: MusicSource,
 ) {
-    suspend fun sync() {
+    private var artistsSynced = 0
+    private var albumsSynced = 0
+    private var songsSynced = 0
+    private var playlistsSynced = 0
+    private var playlistSongsSynced = 0
+    private var pruned = 0
+
+    suspend fun sync(): SyncSummary {
         syncArtists()
         syncAlbums()
         syncSongs()
         aggregatePlayData()
         syncPlaylists()
         syncPlaylistSongs()
+        return SyncSummary(
+            artists = artistsSynced,
+            albums = albumsSynced,
+            songs = songsSynced,
+            playlists = playlistsSynced,
+            playlistSongs = playlistSongsSynced,
+            pruned = pruned,
+        )
     }
 
     private suspend fun syncArtists() {
@@ -36,8 +51,9 @@ class SyncService(
             if (batch.isEmpty()) return@collect
             write("artists", artistColumns, primaryKey, batch) { it.values() }
             batch.forEach { seen.add(idHash(it.id)) }
+            artistsSynced += batch.size
         }
-        pruneStaleIds(seen, { library.artistIdsAfter(source.id, it, PRUNE_PAGE) }, { library.deleteArtists(source.id, it) })
+        pruned += pruneStaleIds(seen, { library.artistIdsAfter(source.id, it, PRUNE_PAGE) }, { library.deleteArtists(source.id, it) })
     }
 
     private suspend fun syncAlbums() {
@@ -53,8 +69,10 @@ class SyncService(
             writeAlbumsAndDiscs(batch, discs)
             batch.forEach { seenAlbums.add(idHash(it.id)) }
             discs.forEach { seenDiscs.add(discHash(it.albumId, it.disc)) }
+            albumsSynced += batch.size
         }
-        pruneStaleIds(seenAlbums, { library.albumIdsAfter(source.id, it, PRUNE_PAGE) }, { library.deleteAlbums(source.id, it) })
+        pruned += pruneStaleIds(seenAlbums, { library.albumIdsAfter(source.id, it, PRUNE_PAGE) }, { library.deleteAlbums(source.id, it) })
+        pruned +=
             pruneStaleDiscs(seenDiscs, { albumId, disc -> library.discKeysAfter(source.id, albumId, disc, PRUNE_PAGE) }) {
                 deleteStaleDiscs(it)
             }
@@ -67,8 +85,9 @@ class SyncService(
             if (batch.isEmpty()) return@collect
             writeSongs(batch)
             batch.forEach { seen.add(idHash(it.id)) }
+            songsSynced += batch.size
         }
-        pruneStaleIds(seen, { library.songIdsAfter(source.id, it, PRUNE_PAGE) }, { library.deleteSongs(source.id, it) })
+        pruned += pruneStaleIds(seen, { library.songIdsAfter(source.id, it, PRUNE_PAGE) }, { library.deleteSongs(source.id, it) })
     }
 
     private suspend fun writeSongs(batch: List<Song>) {
@@ -106,8 +125,9 @@ class SyncService(
             if (batch.isEmpty()) return@collect
             write("playlists", playlistColumns, primaryKey, batch) { it.values() }
             batch.forEach { seen.add(idHash(it.id)) }
+            playlistsSynced += batch.size
         }
-        pruneStaleIds(seen, { library.playlistIdsAfter(source.id, it, PRUNE_PAGE) }, { library.deletePlaylists(source.id, it) })
+        pruned += pruneStaleIds(seen, { library.playlistIdsAfter(source.id, it, PRUNE_PAGE) }, { library.deletePlaylists(source.id, it) })
     }
 
     private suspend fun syncPlaylistSongs() {
@@ -118,6 +138,7 @@ class SyncService(
             if (batch.isEmpty()) return@collect
             write("playlist_songs", playlistSongColumns, playlistSongKey, batch) { it.values() }
             batch.forEach { counts[it.playlistId] = (counts[it.playlistId] ?: 0L) + 1L }
+            playlistSongsSynced += batch.size
         }
         playlistIds.forEach { library.deletePlaylistSongsFrom(source.id, it, counts[it] ?: 0L) }
         library.deleteOrphanPlaylistSongs(source.id)
@@ -173,15 +194,17 @@ class SyncService(
         seen: HashedIds,
         pageOf: suspend (afterId: String) -> List<String>,
         delete: suspend (Collection<String>) -> Unit,
-    ) {
+    ): Int {
         seen.freeze()
         var afterId = ""
+        var pruned = 0
         while (true) {
             val ids = pageOf(afterId)
-            if (ids.isEmpty()) return
+            if (ids.isEmpty()) return pruned
             val stale = ids.filterNot { seen.contains(idHash(it)) }
             stale.chunked(DELETE_CHUNK).forEach { delete(it) }
-            if (ids.size < PRUNE_PAGE) return
+            pruned += stale.size
+            if (ids.size < PRUNE_PAGE) return pruned
             afterId = ids.last()
         }
     }
@@ -190,22 +213,33 @@ class SyncService(
         seen: HashedIds,
         pageOf: suspend (afterAlbumId: String, afterDisc: Long) -> List<DiscKey>,
         delete: suspend (Collection<DiscKey>) -> Unit,
-    ) {
+    ): Int {
         seen.freeze()
         var afterAlbumId = ""
         var afterDisc = 0L
+        var pruned = 0
         while (true) {
             val keys = pageOf(afterAlbumId, afterDisc)
-            if (keys.isEmpty()) return
+            if (keys.isEmpty()) return pruned
             val stale = keys.filterNot { seen.contains(discHash(it.albumId, it.disc)) }
             stale.chunked(DELETE_CHUNK).forEach { delete(it) }
-            if (keys.size < PRUNE_PAGE) return
+            pruned += stale.size
+            if (keys.size < PRUNE_PAGE) return pruned
             afterAlbumId = keys.last().albumId
             afterDisc = keys.last().disc
         }
     }
 }
 
+data class SyncSummary(
+    val artists: Int,
+    val albums: Int,
+    val songs: Int,
+    val playlists: Int,
+    val playlistSongs: Int,
+    val pruned: Int,
+)
+
 private const val DELETE_CHUNK = 500
 private const val PRUNE_PAGE = 500
 private const val INITIAL_HASH_CAPACITY = 256

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

@@ -27,7 +27,10 @@ import com.subtracks.data.repo.PendingServerActionSink
 import com.subtracks.data.repo.QueueRepository
 import com.subtracks.data.repo.SourceRepository
 import com.subtracks.data.source.ServerActionSink
+import com.subtracks.data.sync.AutoSync
 import com.subtracks.data.sync.SyncManager
+import com.subtracks.data.sync.SyncNotifier
+import com.subtracks.log.Log
 import com.subtracks.playback.MediaSessionConnection
 import com.subtracks.playback.PlaybackController
 import com.subtracks.playback.PlayerConnection
@@ -48,6 +51,8 @@ import com.subtracks.ui.settings.SettingsViewModel
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
 import okhttp3.OkHttpClient
 import org.koin.core.module.dsl.viewModel
 import org.koin.core.qualifier.named
@@ -68,6 +73,7 @@ fun appModule(
     single { CoroutineScope(SupervisorJob() + Dispatchers.Default) }
     single(named("io")) { CoroutineScope(SupervisorJob() + Dispatchers.IO) }
     single(named("playback")) { CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) }
+    single(createdAtStart = true) { get<UserPreferences>().verboseLogging().onEach(Log::setVerbose).launchIn(get()) }
     single {
         SourceRepository(
             get(),
@@ -92,7 +98,16 @@ fun appModule(
     }
     single { LibraryRepository(get(), get(), get(), toast, scope = get(named("io"))) }
     single<ArtworkSeedStore> { ArtworkSeedRepository(get()) }
-    single { SyncManager(get(), get(), get(), get(), showMessage = toast, scope = get()) }
+    single { SyncManager(get(), get(), get(), get(), preferences = get(), showMessage = toast, scope = get()) }
+    single {
+        AutoSync(
+            preferences = get(),
+            networkMode = networkMode(context.applicationContext),
+            hasSource = { get<SourceRepository>().activeSourceIdOnce() != null },
+            requestSync = { get<SyncManager>().requestSync(silent = true) },
+            scope = get(),
+        )
+    }
     single { QueueRepository(get()) }
     single { ArtworkStore(downloadsRoot(context)) }
     single<ArtworkFetcher> { OkHttpArtworkFetcher(get()) }
@@ -111,6 +126,7 @@ fun appModule(
         ).also { it.start() }
     }
     single(createdAtStart = true) { DownloadNotifier(context.applicationContext, get(), scope = get()).also { it.start() } }
+    single(createdAtStart = true) { SyncNotifier(context.applicationContext, get<SyncManager>().status, scope = get()).also { it.start() } }
     single<PlayerConnection> { MediaSessionConnection(context.applicationContext, get(), get()) }
     single { PlaybackController(get(), get(), get(), get(), showMessage = toast, scope = get(named("playback"))) }
     single(createdAtStart = true) {

app/src/main/kotlin/com/subtracks/log/Log.kt

@@ -0,0 +1,208 @@
+package com.subtracks.log
+
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import androidx.core.content.FileProvider
+import com.subtracks.BuildConfig
+import com.subtracks.R
+import com.subtracks.data.db.SqlExecution
+import okhttp3.Interceptor
+import java.io.File
+import java.io.IOException
+import kotlin.math.roundToLong
+import android.util.Log as AndroidLog
+
+object Log {
+    private const val SLOW_QUERY_MS = 100.0
+    private const val MAX_SQL_CHARS = 500
+    private val WHITESPACE = Regex("\\s+")
+
+    private var fileStore: LogFileStore? = null
+    private var appContext: Context? = null
+    private var consoleLevel = LogLevel.DEBUG
+    private var defaultFileLevel = LogLevel.INFO
+    private var crashHandlerInstalled = false
+
+    fun init(context: Context) {
+        val app = context.applicationContext
+        appContext = app
+        consoleLevel = if (BuildConfig.DEBUG) LogLevel.VERBOSE else LogLevel.INFO
+        defaultFileLevel = if (BuildConfig.DEBUG) LogLevel.DEBUG else LogLevel.INFO
+        fileStore?.shutdown()
+        fileStore = LogFileStore(File(app.filesDir, "logs"), defaultFileLevel)
+        installCrashHandler()
+        i("app", "started ${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE}) on Android ${Build.VERSION.SDK_INT} ${Build.MODEL}")
+    }
+
+    fun setVerbose(enabled: Boolean) {
+        fileStore?.setMinLevel(if (enabled) LogLevel.VERBOSE else defaultFileLevel)
+    }
+
+    fun v(
+        tag: String,
+        message: String,
+    ) = log(LogLevel.VERBOSE, tag, message, null)
+
+    fun d(
+        tag: String,
+        message: String,
+    ) = log(LogLevel.DEBUG, tag, message, null)
+
+    fun i(
+        tag: String,
+        message: String,
+    ) = log(LogLevel.INFO, tag, message, null)
+
+    fun w(
+        tag: String,
+        message: String,
+        throwable: Throwable? = null,
+    ) = log(LogLevel.WARN, tag, message, throwable)
+
+    fun e(
+        tag: String,
+        message: String,
+        throwable: Throwable? = null,
+    ) = log(LogLevel.ERROR, tag, message, throwable)
+
+    fun exportZip(): File? {
+        val store = fileStore ?: return null
+        val context = appContext ?: return null
+        store.flush()
+        return store.exportZip(File(context.cacheDir, "log_dumps"))
+    }
+
+    fun share(
+        context: Context,
+        file: File,
+    ) {
+        val uri = FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", file)
+        val send =
+            Intent(Intent.ACTION_SEND).apply {
+                type = "application/zip"
+                putExtra(Intent.EXTRA_STREAM, uri)
+                putExtra(Intent.EXTRA_SUBJECT, context.getString(R.string.settings_about_share_logs_subject))
+                addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+            }
+        context.startActivity(
+            Intent.createChooser(send, context.getString(R.string.settings_about_actions_share_logs)),
+        )
+    }
+
+    fun interceptor(): Interceptor =
+        Interceptor { chain ->
+            val request = chain.request()
+            v("http", "${request.method} ${request.url}")
+            try {
+                val response = chain.proceed(request)
+                if (response.code >= 400) {
+                    w("http", "${request.method} ${request.url} -> ${response.code}")
+                }
+                response
+            } catch (failure: IOException) {
+                if (chain.call().isCanceled()) {
+                    v("http", "${request.method} ${request.url} cancelled")
+                } else {
+                    w("http", "${request.method} ${request.url} failed", failure)
+                }
+                throw failure
+            }
+        }
+
+    fun sql(execution: SqlExecution) {
+        val failure = execution.error
+        if (failure != null) {
+            if (isUpsertConflict(execution.sql, failure)) {
+                v("sql", "upsert fallback conflict: ${shortSql(execution.sql)}")
+            } else {
+                e("sql", "failed: ${shortSql(execution.sql)}", failure)
+            }
+            return
+        }
+        if (!isSlowQuery(execution, SLOW_QUERY_MS)) return
+        val rows = if (isReadStatement(execution.sql)) " rows=${execution.rows}" else ""
+        w("sql", "slow ${execution.durationMillis.roundToLong()}ms$rows: ${shortSql(execution.sql)}")
+    }
+
+    private fun log(
+        level: LogLevel,
+        tag: String,
+        message: String,
+        throwable: Throwable?,
+    ) {
+        val toConsole = level.ordinal >= consoleLevel.ordinal
+        val store = fileStore
+        if (!toConsole && store?.willLog(level) != true) return
+        val redacted = redactLogs(message)
+        if (toConsole) {
+            // Logging is best effort: a logcat write must never disturb the caller.
+            runCatching {
+                val text =
+                    if (throwable != null) {
+                        "$redacted\n${redactLogs(AndroidLog.getStackTraceString(throwable))}"
+                    } else {
+                        redacted
+                    }
+                AndroidLog.println(priority(level), tag.take(23), text)
+            }
+        }
+        store?.write(level, tag, redacted, throwable)
+    }
+
+    private fun priority(level: LogLevel): Int =
+        when (level) {
+            LogLevel.VERBOSE -> AndroidLog.VERBOSE
+            LogLevel.DEBUG -> AndroidLog.DEBUG
+            LogLevel.INFO -> AndroidLog.INFO
+            LogLevel.WARN -> AndroidLog.WARN
+            LogLevel.ERROR -> AndroidLog.ERROR
+        }
+
+    private fun installCrashHandler() {
+        if (crashHandlerInstalled) return
+        crashHandlerInstalled = true
+        val previous = Thread.getDefaultUncaughtExceptionHandler()
+        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+            runCatching {
+                fileStore?.writeImmediately(LogLevel.ERROR, "crash", "uncaught exception on ${thread.name}", throwable)
+            }
+            previous?.uncaughtException(thread, throwable)
+        }
+    }
+
+    private fun shortSql(sql: String): String = sql.replace(WHITESPACE, " ").take(MAX_SQL_CHARS)
+}
+
+private val DATA_KEYWORDS = setOf("SELECT", "INSERT", "UPDATE", "DELETE", "WITH", "REPLACE")
+private val READ_KEYWORDS = setOf("SELECT", "WITH")
+private const val SQL_INTERNAL = "room_table_modification_log"
+
+internal fun isDataStatement(sql: String): Boolean {
+    val normalized = sql.trimStart()
+    if (normalized.contains(SQL_INTERNAL)) return false
+    return normalized.takeWhile { !it.isWhitespace() }.uppercase() in DATA_KEYWORDS
+}
+
+internal fun isReadStatement(sql: String): Boolean = sql.trimStart().takeWhile { !it.isWhitespace() }.uppercase() in READ_KEYWORDS
+
+internal fun isSlowQuery(
+    execution: SqlExecution,
+    thresholdMs: Double,
+): Boolean = execution.error == null && execution.durationMillis >= thresholdMs && isDataStatement(execution.sql)
+
+// Room's EntityUpsertAdapter implements @Upsert as an INSERT and treats a uniqueness conflict as the
+// signal to UPDATE instead (EntityUpsertAdapter.checkUniquenessException). Only downgrade a failed
+// INSERT whose error says the conflict was a unique/primary key; anything else stays an ERROR so a
+// genuine failure isn't hidden in release.
+private const val CONSTRAINT_UNIQUE_MESSAGE = "unique constraint failed"
+private const val CONSTRAINT_PRIMARY_KEY_MESSAGE = "primary key constraint failed"
+
+internal fun isUpsertConflict(
+    sql: String,
+    error: Throwable,
+): Boolean {
+    if (!sql.trimStart().uppercase().startsWith("INSERT")) return false
+    val message = error.message?.lowercase() ?: return false
+    return message.contains(CONSTRAINT_UNIQUE_MESSAGE) || message.contains(CONSTRAINT_PRIMARY_KEY_MESSAGE)
+}

app/src/main/kotlin/com/subtracks/log/LogFileStore.kt

@@ -0,0 +1,177 @@
+package com.subtracks.log
+
+import java.io.File
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.zip.ZipEntry
+import java.util.zip.ZipOutputStream
+
+enum class LogLevel { VERBOSE, DEBUG, INFO, WARN, ERROR }
+
+class LogFileStore(
+    private val rootDir: File,
+    @Volatile private var minLevel: LogLevel,
+    private val maxFileBytes: Long = DEFAULT_MAX_FILE_BYTES,
+    private val maxFiles: Int = DEFAULT_MAX_FILES,
+) {
+    private val executor =
+        Executors.newSingleThreadExecutor { runnable ->
+            Thread(runnable, "log-writer").apply { isDaemon = true }
+        }
+    private val lock = Any()
+    private val pending = AtomicInteger()
+    private val dateFormat = SimpleDateFormat("yyyy-MM-dd", Locale.US)
+    private val lineFormat = SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.US)
+    private var current = currentFile()
+
+    init {
+        // Log.init runs in Application.onCreate, so clean up leftovers on the writer thread.
+        runCatching { executor.execute { synchronized(lock) { prune() } } }
+    }
+
+    fun willLog(level: LogLevel): Boolean = level.ordinal >= minLevel.ordinal
+
+    fun write(
+        level: LogLevel,
+        tag: String,
+        message: String,
+        throwable: Throwable?,
+    ) {
+        if (level.ordinal < minLevel.ordinal) return
+        // Drop under pressure rather than grow the queue without bound (verbose logs every request).
+        if (pending.get() >= MAX_PENDING) return
+        pending.incrementAndGet()
+        runCatching {
+            executor.execute {
+                try {
+                    synchronized(lock) { append(level, tag, message, throwable) }
+                } finally {
+                    pending.decrementAndGet()
+                }
+            }
+        }.onFailure { pending.decrementAndGet() }
+    }
+
+    fun writeImmediately(
+        level: LogLevel,
+        tag: String,
+        message: String,
+        throwable: Throwable?,
+    ) {
+        if (level.ordinal < minLevel.ordinal) return
+        runCatching { synchronized(lock) { append(level, tag, message, throwable) } }
+    }
+
+    fun flush() {
+        runCatching { executor.submit {}.get() }
+    }
+
+    fun setMinLevel(level: LogLevel) {
+        minLevel = level
+    }
+
+    fun shutdown() {
+        executor.shutdownNow()
+    }
+
+    fun files(): List<File> =
+        rootDir
+            .listFiles { file -> file.isFile && file.name.endsWith(LOG_SUFFIX) }
+            ?.sortedByDescending { it.lastModified() }
+            .orEmpty()
+
+    fun exportZip(destDir: File): File? =
+        synchronized(lock) {
+            val logs = files()
+            if (logs.isEmpty()) return null
+            destDir.mkdirs()
+            destDir.listFiles()?.forEach { if (it.isFile) it.delete() }
+            val zip = File(destDir, "subtracks-logs-${System.currentTimeMillis()}.zip")
+            ZipOutputStream(zip.outputStream().buffered()).use { out ->
+                logs.forEach { log ->
+                    if (!log.isFile) return@forEach
+                    out.putNextEntry(ZipEntry(log.name))
+                    log.inputStream().use { it.copyTo(out) }
+                    out.closeEntry()
+                }
+            }
+            zip
+        }
+
+    private fun append(
+        level: LogLevel,
+        tag: String,
+        message: String,
+        throwable: Throwable?,
+    ) {
+        val text =
+            buildString {
+                append(lineFormat.format(Date()))
+                append(' ')
+                append(LEVEL_CHARS[level.ordinal])
+                append(' ')
+                append(tag)
+                append(' ')
+                append(message)
+                throwable?.let {
+                    append('\n')
+                    append(it.stackTraceToString().trimEnd())
+                }
+                append('\n')
+            }
+        rootDir.mkdirs()
+        var rolled = false
+        val today = currentFile()
+        if (current.name != today.name) {
+            current = today
+            rolled = true
+        }
+        if (current.length() >= maxFileBytes) {
+            roll()
+            rolled = true
+        }
+        current.appendText(redactLogs(text))
+        if (rolled) prune()
+    }
+
+    private var rollSequence = 0
+
+    private fun roll() {
+        if (current.exists()) {
+            current.renameTo(uniqueRolledFile())
+        }
+        current = currentFile()
+    }
+
+    private fun uniqueRolledFile(): File {
+        val day = dateFormat.format(Date())
+        while (true) {
+            val candidate = File(rootDir, "$day-${rollSequence++}$LOG_SUFFIX")
+            if (!candidate.exists()) return candidate
+        }
+    }
+
+    private fun prune() {
+        // Never prune the file we are writing to, and never keep fewer than one rolled file slot.
+        val rolled = files().filterNot { it == current }
+        if (rolled.size > maxFiles - 1) rolled.drop(maxFiles - 1).forEach { it.delete() }
+    }
+
+    private fun currentFile(): File = File(rootDir, dateFormat.format(Date()) + LOG_SUFFIX)
+
+    companion object {
+        const val DEFAULT_MAX_FILE_BYTES = 1L * 1024 * 1024
+        const val DEFAULT_MAX_FILES = 7
+        private const val MAX_PENDING = 4096
+        private const val LOG_SUFFIX = ".log"
+        private val LEVEL_CHARS = charArrayOf('V', 'D', 'I', 'W', 'E')
+    }
+}
+
+private val URL_USERINFO = Regex("([a-zA-Z][a-zA-Z0-9+.\\-]*://)[^/@\\s]+@")
+private val URL_PARAM = Regex("([?&](?:u|p|s|t)=)[^&\\s]+")
+
+internal fun redactLogs(input: String): String = input.replace(URL_USERINFO, "$1REDACTED@").replace(URL_PARAM, "$1REDACTED")

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

@@ -1,7 +1,6 @@
 package com.subtracks.playback
 
 import android.os.Bundle
-import android.util.Log
 import androidx.media3.common.C
 import androidx.media3.common.Format
 import androidx.media3.common.MediaItem
@@ -16,6 +15,7 @@ import com.subtracks.UiMessage
 import com.subtracks.data.model.AudioEncoding
 import com.subtracks.data.repo.DownloadRepository
 import com.subtracks.data.repo.SourceRepository
+import com.subtracks.log.Log
 
 class Media3PlayerHandle(
     private val controller: MediaController,
@@ -112,14 +112,19 @@ class Media3PlayerHandle(
     ) = controller.replaceMediaItem(index, toMediaItem(item))
 
     override fun seekToIndex(index: Int) {
-        Log.d(TAG, "seekToIndex($index) playerDuration=${controller.duration} state=${controller.playbackState}")
+        Log.d(
+            "playback",
+            "seekToIndex($index) position=${controller.currentPosition} duration=${duration(
+                controller.duration,
+            )} state=${controller.playbackState}",
+        )
         controller.seekTo(index, 0)
     }
 
     override fun seekTo(positionMs: Long) {
         Log.d(
-            TAG,
+            "playback",
-            "seekTo(${positionMs}ms) from=${controller.currentPosition} playerDuration=${controller.duration} " +
+            "seekTo(${positionMs}ms) from=${controller.currentPosition} duration=${duration(controller.duration)} " +
                 "itemDuration=${currentItem?.durationMs} state=${controller.playbackState}",
         )
         controller.seekTo(positionMs)
@@ -136,7 +141,7 @@ class Media3PlayerHandle(
                     mediaItem: MediaItem?,
                     reason: Int,
                 ) {
-                    Log.d(TAG, "item=${mediaItem?.mediaId}")
+                    Log.i("playback", "${describe(mediaItem)} transition=${transitionReason(reason)}")
                     listener.onTransition()
                 }
 
@@ -147,8 +152,9 @@ class Media3PlayerHandle(
 
                 override fun onPlayerError(error: PlaybackException) {
                     Log.w(
-                        TAG,
+                        "playback",
-                        "Playback error ${error.errorCodeName} at ${controller.currentPosition}/${controller.duration}",
+                        "error ${error.errorCodeName} ${describe(controller.currentMediaItem)} " +
+                            "position=${controller.currentPosition} duration=${duration(controller.duration)}",
                         error,
                     )
                     listener.onError(playbackErrorMessage(error))
@@ -156,15 +162,54 @@ class Media3PlayerHandle(
 
                 override fun onPlaybackStateChanged(playbackState: Int) {
                     Log.d(
-                        TAG,
+                        "playback",
                         "state=$playbackState position=${controller.currentPosition} " +
-                            "playerDuration=${controller.duration} itemDuration=${currentItem?.durationMs}",
+                            "duration=${duration(controller.duration)} itemDuration=${currentItem?.durationMs}",
                     )
+                    if (playbackState == Player.STATE_ENDED) {
+                        Log.i("playback", "ended ${describe(controller.currentMediaItem)}")
+                    }
                 }
             },
         )
     }
 
+    private fun describe(mediaItem: MediaItem?): String {
+        if (mediaItem == null) return "item=none"
+        val metadata = mediaItem.mediaMetadata
+        val artist =
+            metadata.artist
+                ?.toString()
+                ?.takeIf { it.isNotBlank() }
+                ?.let { " artist=\"$it\"" }
+                .orEmpty()
+        val album =
+            metadata.albumTitle
+                ?.toString()
+                ?.takeIf { it.isNotBlank() }
+                ?.let { " album=\"$it\"" }
+                .orEmpty()
+        val source =
+            when (mediaItem.localConfiguration?.uri?.scheme) {
+                "file", "content" -> "file"
+                "http", "https" -> "http"
+                null -> "none"
+                else -> "other"
+            }
+        return "item id=${mediaItem.mediaId} title=\"${metadata.title?.toString().orEmpty()}\"$artist$album source=$source"
+    }
+
+    private fun duration(value: Long): String = if (value == C.TIME_UNSET) "unset" else "${value}ms"
+
+    private fun transitionReason(reason: Int): String =
+        when (reason) {
+            Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT -> "repeat"
+            Player.MEDIA_ITEM_TRANSITION_REASON_AUTO -> "auto"
+            Player.MEDIA_ITEM_TRANSITION_REASON_SEEK -> "seek"
+            Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED -> "playlist"
+            else -> reason.toString()
+        }
+
     private fun toMediaItem(item: QueueItem): MediaItem {
         val quality = sourceRepository.quality.value
         return queueMediaItem(
@@ -190,10 +235,6 @@ class Media3PlayerHandle(
                     ?.takeIf { it.containsKey(EXTRA_DURATION_MS) }
                     ?.getLong(EXTRA_DURATION_MS),
         )
-
-    private companion object {
-        const val TAG = "SubtracksPlayback"
-    }
 }
 
 private const val EXTRA_COVER_ART_ID = "coverArtId"

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

@@ -11,6 +11,7 @@ import com.subtracks.data.repo.QueueSnapshot
 import com.subtracks.data.repo.QueueWindowItem
 import com.subtracks.data.repo.Shuffle
 import com.subtracks.data.repo.SourceRepository
+import com.subtracks.log.Log
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -127,7 +128,9 @@ class PlaybackController(
     private var positionJob: Job? = null
     private var windowJob: Job? = null
     private var bufferingJob: Job? = null
+    private var stallJob: Job? = null
     private var showBuffering = false
+    private var stalled = false
     private val startLock = Mutex()
 
     private var snapshot: QueueSnapshot? = null
@@ -258,6 +261,15 @@ class PlaybackController(
         artistId: String,
     ) = shuffleContext(queueRepository.artistEntry(sourceId, artistId))
 
+    fun shuffleGenre(
+        sourceId: Long,
+        genre: String,
+    ) = shuffleContext(queueRepository.genreEntry(sourceId, genre))
+
+    fun shuffleStarred(sourceId: Long) = shuffleContext(queueRepository.starredEntry(sourceId))
+
+    fun shuffleDownloaded(sourceId: Long) = shuffleContext(queueRepository.downloadedEntry(sourceId))
+
     private fun playContext(
         entry: QueueEntry,
         start: Long,
@@ -1047,6 +1059,9 @@ class PlaybackController(
         windowJob?.cancel()
         bufferingJob?.cancel()
         bufferingJob = null
+        stallJob?.cancel()
+        stallJob = null
+        stalled = false
         showBuffering = false
         snapshot = null
         queueSourceId = null
@@ -1460,22 +1475,43 @@ class PlaybackController(
     suspend fun sourceTitle(context: QueueContext?): String? = context?.let { queueRepository.sourceName(it.kind, it.sourceId, it.refId) }
 
     private fun updateBuffering() {
+        val player = player
         if (player?.isBuffering != true) {
             bufferingJob?.cancel()
             bufferingJob = null
+            stallJob?.cancel()
+            stallJob = null
+            stalled = false
             showBuffering = false
             return
         }
-        if (showBuffering || bufferingJob?.isActive == true) return
+        if (!showBuffering && bufferingJob?.isActive != true) {
             bufferingJob =
                 scope.launch {
                     delay(BUFFERING_INDICATOR_DELAY_MS)
-                if (player?.isBuffering == true) {
+                    if (player.isBuffering) {
                         showBuffering = true
                         refresh()
                     }
                 }
         }
+        // A stall is buffering that persists long enough to be a real problem, not a track change.
+        if (stallJob?.isActive != true && !stalled) {
+            stallJob =
+                scope.launch {
+                    delay(STALL_WATCHDOG_MS)
+                    if (player === this@PlaybackController.player && player.isBuffering && player.playWhenReady) {
+                        stalled = true
+                        val item = player.currentItem
+                        Log.w(
+                            "playback",
+                            "stalled: buffering for ${STALL_WATCHDOG_MS / 1000}s at ${player.currentPositionMs}ms " +
+                                "item id=${item?.id} title=\"${item?.title}\"",
+                        )
+                    }
+                }
+        }
+    }
 
     private fun refresh(position: Long? = currentPosition()) {
         val player = player ?: return
@@ -1541,6 +1577,7 @@ class PlaybackController(
         const val POSITION_TICK_MS = 500L
         const val POSITION_SAVE_INTERVAL_MS = 15_000L
         const val BUFFERING_INDICATOR_DELAY_MS = 1_000L
+        const val STALL_WATCHDOG_MS = 15_000L
         const val QUEUE_WINDOW_RADIUS = 25L
         const val WINDOW_SHIFT_DELAY_MS = 400L
         const val RESTART_THRESHOLD_MS = 3_000L

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

@@ -5,7 +5,6 @@ import android.content.Context
 import android.content.Intent
 import android.os.Bundle
 import android.os.SystemClock
-import android.util.Log
 import androidx.annotation.OptIn
 import androidx.media3.common.AudioAttributes
 import androidx.media3.common.C
@@ -13,8 +12,13 @@ import androidx.media3.common.MediaItem
 import androidx.media3.common.Player
 import androidx.media3.common.util.ExperimentalApi
 import androidx.media3.common.util.UnstableApi
+import androidx.media3.database.StandaloneDatabaseProvider
 import androidx.media3.datasource.DataSource
 import androidx.media3.datasource.DefaultDataSource
+import androidx.media3.datasource.cache.Cache
+import androidx.media3.datasource.cache.CacheDataSource
+import androidx.media3.datasource.cache.LeastRecentlyUsedCacheEvictor
+import androidx.media3.datasource.cache.SimpleCache
 import androidx.media3.datasource.okhttp.OkHttpDataSource
 import androidx.media3.exoplayer.ExoPlayer
 import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
@@ -29,9 +33,11 @@ import com.google.common.util.concurrent.Futures
 import com.google.common.util.concurrent.ListenableFuture
 import com.subtracks.MainActivity
 import com.subtracks.R
+import com.subtracks.UserAgent
 import com.subtracks.data.repo.LibraryRepository
 import com.subtracks.data.repo.SourceRepository
 import com.subtracks.data.source.StarType
+import com.subtracks.log.Log
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -40,6 +46,7 @@ import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import okhttp3.OkHttpClient
 import org.koin.core.context.GlobalContext
+import java.io.File
 
 @OptIn(UnstableApi::class)
 class PlaybackService : MediaSessionService() {
@@ -90,6 +97,7 @@ class PlaybackService : MediaSessionService() {
         val sources = GlobalContext.get().get<SourceRepository>()
         sourceRepository = sources
         library = GlobalContext.get().get<LibraryRepository>()
+        val cache = StreamCache.open(this)
         val exoPlayer =
             ExoPlayer
                 .Builder(this)
@@ -104,7 +112,13 @@ class PlaybackService : MediaSessionService() {
                 .setMediaSourceFactory(
                     DefaultMediaSourceFactory(this)
                         .setEnableClippingInMediaPeriod(true)
-                        .setDataSourceFactory(mediaDataSourceFactory(this, OkHttpDataSource.Factory(streamingClient()))),
+                        .setDataSourceFactory(
+                            mediaDataSourceFactory(
+                                this,
+                                cache,
+                                OkHttpDataSource.Factory(streamingClient()).setUserAgent(UserAgent.value),
+                            ),
+                        ),
                 ).build()
         exoPlayer.addListener(
             object : Player.Listener {
@@ -183,12 +197,13 @@ class PlaybackService : MediaSessionService() {
     private fun streamingClient(): OkHttpClient =
         OkHttpClient
             .Builder()
+            .addInterceptor(Log.interceptor())
             .addInterceptor { chain ->
                 val started = SystemClock.elapsedRealtime()
                 val response = chain.proceed(chain.request())
                 Log.d(
-                    STREAM_TAG,
+                    "stream",
-                    "stream range=${chain.request().header("Range")} code=${response.code} " +
+                    "range=${chain.request().header("Range")} code=${response.code} " +
                         "contentRange=${response.header("Content-Range")} " +
                         "length=${response.body.contentLength()} in ${SystemClock.elapsedRealtime() - started}ms",
                 )
@@ -208,13 +223,50 @@ class PlaybackService : MediaSessionService() {
     }
 
     private companion object {
-        const val STREAM_TAG = "SubtracksPlayback"
         val STAR_COMMAND = SessionCommand("com.subtracks.STAR", Bundle.EMPTY)
     }
 }
 
+// Process-scoped so it is never released while a loader thread is still committing to it, and so
+// a recreated service does not try to lock the directory a second time.
+@OptIn(UnstableApi::class)
+private object StreamCache {
+    @Volatile
+    private var instance: SimpleCache? = null
+
+    fun open(context: Context): SimpleCache? =
+        instance ?: synchronized(this) {
+            instance ?: runCatching {
+                SimpleCache(
+                    File(context.cacheDir, STREAM_CACHE_DIR),
+                    LeastRecentlyUsedCacheEvictor(STREAM_CACHE_BYTES),
+                    StandaloneDatabaseProvider(context),
+                )
+            }.onFailure { Log.w("playback", "stream cache unavailable: ${it.message}") }
+                .getOrNull()
+                ?.also { instance = it }
+        }
+
+    private const val STREAM_CACHE_DIR = "stream-cache"
+    private const val STREAM_CACHE_BYTES = 64L * 1024 * 1024
+}
+
 @OptIn(UnstableApi::class)
 internal fun mediaDataSourceFactory(
     context: Context,
+    cache: Cache?,
     upstream: DataSource.Factory,
-): DataSource.Factory = DefaultDataSource.Factory(context, KnownLengthDataSourceFactory(upstream))
+): DataSource.Factory {
+    val known = KnownLengthDataSourceFactory(upstream)
+    val source: DataSource.Factory =
+        if (cache == null) {
+            known
+        } else {
+            CacheDataSource
+                .Factory()
+                .setCache(cache)
+                .setUpstreamDataSourceFactory(known)
+                .setFlags(CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR)
+        }
+    return DefaultDataSource.Factory(context, source)
+}

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

@@ -1,6 +1,7 @@
 package com.subtracks.playback
 
 import com.subtracks.data.source.ServerActionSink
+import com.subtracks.log.Log
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -58,6 +59,7 @@ class ScrobblePolicy(
             item?.id != songId ||
                 (item != null && item.id == lastItemId && positionMs < previousPosition && positionMs <= RESTART_POSITION_MS)
         if (restarted) {
+            val alreadyAnnounced = nowPlayingSent && item?.id == songId
             songId = item?.id
             lastItemId = null
             playedMs = 0
@@ -67,7 +69,7 @@ class ScrobblePolicy(
             if (item == null || !isPlaying) return null
             nowPlayingSent = true
             startedAt = now()
-            return Scrobble.NowPlaying(item.id)
+            return if (alreadyAnnounced) null else Scrobble.NowPlaying(item.id)
         }
         lastPositionMs = positionMs
         lastItemId = item?.id
@@ -128,22 +130,28 @@ class Scrobbler(
     private suspend fun submit(event: Scrobble) {
         when (event) {
             is Scrobble.NowPlaying -> {
-                attempt { sink.nowPlaying(event.songId) }
+                Log.i("scrobble", "now playing ${event.songId}")
+                attempt("now playing ${event.songId}") { sink.nowPlaying(event.songId) }
             }
 
             is Scrobble.Submission -> {
-                attempt { recordPlay(event.songId, event.time / 1000) }
+                Log.i("scrobble", "submitting ${event.songId}")
-                attempt { sink.scrobble(event.songId, event.time) }
+                attempt("record play ${event.songId}") { recordPlay(event.songId, event.time / 1000) }
+                attempt("scrobble ${event.songId}") { sink.scrobble(event.songId, event.time) }
             }
         }
     }
 
-    private suspend fun attempt(block: suspend () -> Unit) {
+    private suspend fun attempt(
+        label: String,
+        block: suspend () -> Unit,
+    ) {
         try {
             block()
         } catch (cancellation: CancellationException) {
             throw cancellation
-        } catch (_: Exception) {
+        } catch (failure: Exception) {
+            Log.w("scrobble", "$label failed", failure)
         }
     }
 }

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

@@ -87,9 +87,11 @@ fun CoverArt(
     colorFilter: ColorFilter? = null,
 ) {
     val context = LocalPlatformContext.current
-    var failed by remember(ref, thumbnailRef) { mutableStateOf(false) }
+    val refKey = ref?.cacheKey
-    var thumbnailLoaded by remember(ref, thumbnailRef) { mutableStateOf(false) }
+    val thumbnailKey = thumbnailRef?.cacheKey
-    var thumbnailRatio by remember(ref, thumbnailRef) { mutableStateOf(thumbnailRef?.cacheKey?.let(ArtworkRatioCache::get)) }
+    var failed by remember(refKey, thumbnailKey) { mutableStateOf(false) }
+    var thumbnailLoaded by remember(refKey, thumbnailKey) { mutableStateOf(false) }
+    var thumbnailRatio by remember(refKey, thumbnailKey) { mutableStateOf(thumbnailKey?.let(ArtworkRatioCache::get)) }
     val letterScheme =
         if (showPlaceholder || (failed && !thumbnailLoaded)) {
             remember(name) { artworkColorsFromSeed(placeholderSeed(name)).scheme }
@@ -102,7 +104,7 @@ fun CoverArt(
             .background(letterScheme?.primaryContainer ?: MaterialTheme.colorScheme.surfaceVariant)
 
     if (square) {
-        val model = remember(ref, thumbnailRef) { ref?.let { imageRequest(context, it, crossfade = true) } }
+        val model = remember(refKey, thumbnailKey) { ref?.let { imageRequest(context, it, crossfade = true) } }
         Box(modifier.then(frameModifier)) {
             CoverArtContent(
                 ref = ref,
@@ -147,7 +149,7 @@ fun CoverArt(
             val painter =
                 rememberAsyncImagePainter(
                     model =
-                        remember(ref, thumbnailRef, target) {
+                        remember(refKey, thumbnailKey, target) {
                             ref?.let {
                                 imageRequest(
                                     context,
@@ -231,7 +233,7 @@ private fun BoxScope.CoverArtContent(
     }
     if (thumbnailRef != null && thumbnailRef != ref) {
         AsyncImage(
-            model = remember(thumbnailRef) { imageRequest(context, thumbnailRef, crossfade = false) },
+            model = remember(thumbnailRef.cacheKey) { imageRequest(context, thumbnailRef, crossfade = false) },
             contentDescription = null,
             contentScale = contentScale,
             colorFilter = colorFilter,

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

@@ -51,6 +51,7 @@ import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -77,6 +78,7 @@ import com.subtracks.ui.theme.ArtworkTheme
 import com.subtracks.ui.theme.HeroGradient
 import com.subtracks.ui.theme.baseArtworkColors
 import com.subtracks.ui.theme.heroBarColor
+import kotlinx.coroutines.launch
 
 private const val FADE_DISTANCE_DP = 64
 
@@ -102,6 +104,7 @@ fun HeroDetailScaffold(
         ArtworkTheme(effectiveArtwork) {
             BoxWithConstraints(modifier.fillMaxSize().background(MaterialTheme.colorScheme.background)) {
                 val listState = rememberLazyListState()
+                val scope = rememberCoroutineScope()
                 val fill = rememberViewportFill(listState)
                 val density = LocalDensity.current
                 val screenHeightPx = with(density) { maxHeight.toPx() }
@@ -195,7 +198,8 @@ fun HeroDetailScaffold(
                             .clickable(
                                 interactionSource = remember { MutableInteractionSource() },
                                 indication = null,
-                            ) {},
+                                onClickLabel = stringResource(R.string.scroll_to_top),
+                            ) { scope.launch { listState.animateScrollToItem(0) } },
                 )
             }
         }
@@ -248,11 +252,11 @@ fun HeroHeader(
     onDownloadAction: (BulkDownloadAction) -> Unit,
     onMore: () -> Unit,
     topInset: Dp,
+    modifier: Modifier = Modifier,
     controlsModifier: Modifier = Modifier,
     thumbnailRef: CoverArtRef? = null,
     comment: String? = null,
     onSubtitleClick: (() -> Unit)? = null,
-    modifier: Modifier = Modifier,
 ) {
     Column(
         modifier =

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

@@ -0,0 +1,33 @@
+package com.subtracks.ui.components
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.scaleIn
+import androidx.compose.animation.scaleOut
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.rounded.Shuffle
+import androidx.compose.material3.FloatingActionButton
+import androidx.compose.material3.Icon
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import com.subtracks.R
+
+@Composable
+fun ShuffleFab(
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+    visible: Boolean = true,
+) {
+    AnimatedVisibility(
+        visible = visible,
+        enter = fadeIn() + scaleIn(),
+        exit = fadeOut() + scaleOut(),
+        modifier = modifier,
+    ) {
+        FloatingActionButton(onClick = onClick) {
+            Icon(Icons.Rounded.Shuffle, contentDescription = stringResource(R.string.controls_shuffle_play))
+        }
+    }
+}

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

@@ -88,3 +88,34 @@ fun rememberViewportFill(state: LazyGridState): Dp {
     }
     return with(density) { fillPx.toDp() }
 }
+
+/**
+ * Scrolls to the top when [request] changes to a new non-null value, but not when it merely becomes
+ * non-null. Selecting a page passes it the current request; only a fresh request (a tab re-tap)
+ * should move the list, so a stale scroll position survives tab switches.
+ */
+@Composable
+fun ScrollToTopOnRequest(
+    request: Any?,
+    state: LazyListState,
+) {
+    var previous by remember { mutableStateOf(request) }
+    LaunchedEffect(request) {
+        val stale = previous
+        previous = request
+        if (request != null && stale != null && request != stale) state.animateScrollToItem(0)
+    }
+}
+
+@Composable
+fun ScrollToTopOnRequest(
+    request: Any?,
+    state: LazyGridState,
+) {
+    var previous by remember { mutableStateOf(request) }
+    LaunchedEffect(request) {
+        val stale = previous
+        previous = request
+        if (request != null && stale != null && request != stale) state.animateScrollToItem(0)
+    }
+}

app/src/main/kotlin/com/subtracks/ui/home/HomeListScreen.kt

@@ -14,7 +14,9 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyListState
 import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
@@ -31,11 +33,12 @@ import androidx.compose.material3.TopAppBar
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalResources
 import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
@@ -59,8 +62,10 @@ import com.subtracks.ui.components.CoverArt
 import com.subtracks.ui.components.ItemActions
 import com.subtracks.ui.components.LoadingState
 import com.subtracks.ui.components.MenuTarget
+import com.subtracks.ui.components.ShuffleFab
 import com.subtracks.ui.library.PlaylistsContent
 import com.subtracks.ui.library.SongRow
+import kotlinx.coroutines.launch
 import org.koin.compose.koinInject
 import org.koin.compose.viewmodel.koinViewModel
 import org.koin.core.parameter.parametersOf
@@ -110,6 +115,7 @@ fun HomeListRoute(
         onPlaylistClick = onPlaylistClick,
         onSongClick = viewModel::play,
         onLongClick = { contextMenuHost?.show(it, actions) },
+        onShuffle = if (viewModel.canShuffle) viewModel::shuffle else null,
         onGenreClick = onGenreClick,
         onDecadeClick = onDecadeClick,
     )
@@ -123,6 +129,7 @@ fun HomeListScreen(
     artists: LazyPagingItems<Artist>,
     songs: LazyPagingItems<AlbumSongItem>,
     playlists: LazyPagingItems<Playlist>,
+    modifier: Modifier = Modifier,
     genres: List<String> = emptyList(),
     decades: List<Long> = emptyList(),
     coverArt: (String?, Boolean) -> CoverArtRef? = { _, _ -> null },
@@ -133,12 +140,14 @@ fun HomeListScreen(
     onPlaylistClick: (Playlist) -> Unit = {},
     onSongClick: (Song) -> Unit = {},
     onLongClick: (MenuTarget) -> Unit = {},
+    onShuffle: (() -> Unit)? = null,
     onGenreClick: (String) -> Unit = {},
     onDecadeClick: (Long) -> Unit = {},
-    modifier: Modifier = Modifier,
 ) {
     val now = remember { System.currentTimeMillis() }
-    val resources = LocalContext.current.resources
+    val resources = LocalResources.current
+    val scope = rememberCoroutineScope()
+    val songListState = rememberLazyListState()
     Scaffold(
         modifier = modifier,
         topBar = {
@@ -149,8 +158,21 @@ fun HomeListScreen(
                         Icon(Icons.AutoMirrored.Rounded.ArrowBack, contentDescription = stringResource(R.string.navigation_back))
                     }
                 },
+                modifier =
+                    if (onShuffle != null) {
+                        Modifier.clickable(onClickLabel = stringResource(R.string.scroll_to_top)) {
+                            scope.launch { songListState.animateScrollToItem(0) }
+                        }
+                    } else {
+                        Modifier
+                    },
             )
         },
+        floatingActionButton = {
+            if (onShuffle != null && songs.itemCount > 0) {
+                ShuffleFab(onClick = onShuffle)
+            }
+        },
     ) { padding ->
         val downloaded = request.downloaded
         if (downloaded != null) {
@@ -184,6 +206,7 @@ fun HomeListScreen(
                         playingSongId = playingSongId,
                         onSongClick = onSongClick,
                         onLongClick = onLongClick,
+                        listState = songListState,
                         modifier = Modifier.padding(padding),
                     )
                 }
@@ -237,6 +260,7 @@ fun HomeListScreen(
                         playingSongId = playingSongId,
                         onSongClick = onSongClick,
                         onLongClick = onLongClick,
+                        listState = songListState,
                         modifier = Modifier.padding(padding),
                     )
                 }
@@ -254,6 +278,7 @@ fun HomeListScreen(
                             playingSongId = playingSongId,
                             onSongClick = onSongClick,
                             onLongClick = onLongClick,
+                            listState = songListState,
                             modifier = Modifier.padding(padding),
                         )
                     } else {
@@ -297,6 +322,7 @@ private fun SongsList(
     playingSongId: String?,
     onSongClick: (Song) -> Unit,
     onLongClick: (MenuTarget) -> Unit,
+    listState: LazyListState,
     modifier: Modifier = Modifier,
 ) {
     if (songs.itemCount == 0 && songs.loadState.refresh is LoadState.Loading) {
@@ -304,8 +330,9 @@ private fun SongsList(
         return
     }
     LazyColumn(
+        state = listState,
         modifier = modifier.fillMaxSize(),
-        contentPadding = PaddingValues(bottom = 24.dp),
+        contentPadding = PaddingValues(bottom = 88.dp),
     ) {
         items(count = songs.itemCount, key = songs.itemKey { it.song.id }) { index ->
             val item = songs[index]

app/src/main/kotlin/com/subtracks/ui/home/HomeListViewModel.kt

@@ -21,9 +21,11 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
 
 data class HomeListRequest(
     val title: String,
@@ -51,6 +53,11 @@ class HomeListViewModel(
 ) : ViewModel() {
     private val sourceId = libraryRepository.activeSourceId.filterNotNull()
 
+    val canShuffle: Boolean =
+        request.genre != null ||
+            request.section == HomeSection.RecentlyStarredSongs ||
+            request.downloaded == OfflineListKind.Songs
+
     val albums: Flow<PagingData<Album>> =
         sourceId
             .flatMapLatest { id ->
@@ -173,4 +180,18 @@ class HomeListViewModel(
             }
         }
     }
+
+    fun shuffle() {
+        val genre = request.genre
+        val downloaded = request.downloaded
+        val starred = request.section == HomeSection.RecentlyStarredSongs
+        viewModelScope.launch {
+            val id = sourceId.first()
+            when {
+                genre != null -> playbackController.shuffleGenre(id, genre)
+                downloaded == OfflineListKind.Songs -> playbackController.shuffleDownloaded(id)
+                starred -> playbackController.shuffleStarred(id)
+            }
+        }
+    }
 }

app/src/main/kotlin/com/subtracks/ui/home/HomeScreen.kt

@@ -172,6 +172,7 @@ fun HomeScreen(
     feed: HomeFeed,
     coverArt: (String?, Boolean) -> CoverArtRef?,
     playingSongId: String?,
+    modifier: Modifier = Modifier,
     topInset: Dp = 0.dp,
     bottomInset: Dp = 0.dp,
     onAlbumClick: (Album) -> Unit = {},
@@ -182,7 +183,6 @@ fun HomeScreen(
     onGenreClick: (String) -> Unit = {},
     onDecadeClick: (Long) -> Unit = {},
     onSync: () -> Unit = {},
-    modifier: Modifier = Modifier,
 ) {
     CompositionLocalProvider(LocalContentColor provides MaterialTheme.colorScheme.onBackground) {
         if (feed.loading) {
@@ -295,6 +295,7 @@ fun OfflineHomeScreen(
     songs: List<AlbumSongItem>,
     coverArt: (String?, Boolean) -> CoverArtRef?,
     playingSongId: String?,
+    modifier: Modifier = Modifier,
     topInset: Dp = 0.dp,
     bottomInset: Dp = 0.dp,
     onAlbumClick: (Album) -> Unit = {},
@@ -303,7 +304,6 @@ fun OfflineHomeScreen(
     onSongPlay: (Song) -> Unit = {},
     onLongClick: (MenuTarget) -> Unit = {},
     onMore: (OfflineListKind) -> Unit = {},
-    modifier: Modifier = Modifier,
 ) {
     CompositionLocalProvider(LocalContentColor provides MaterialTheme.colorScheme.onBackground) {
         LazyColumn(

app/src/main/kotlin/com/subtracks/ui/home/HomeViewModel.kt

@@ -25,7 +25,6 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 
@@ -53,11 +52,6 @@ class HomeViewModel(
     private val syncManager: SyncManager,
     private val playbackController: PlaybackController,
 ) : ViewModel() {
-    val syncing: StateFlow<Boolean> =
-        syncManager.status
-            .map { it == SyncStatus.Running }
-            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), false)
-
     val offline: StateFlow<Boolean> =
         sourceRepository.offline.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), false)
 
@@ -141,7 +135,9 @@ class HomeViewModel(
         viewModelScope.playDownloadedList(libraryRepository, playbackController, song)
     }
 
-    fun sync() = syncManager.requestSync()
+    fun sync() {
+        if (syncManager.status.value !is SyncStatus.Running) syncManager.requestSync()
+    }
 
     private data class PlayRows(
         val recentAlbums: List<Album>,

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

@@ -146,6 +146,7 @@ fun AlbumDetailRoute(
 fun AlbumDetailScreen(
     album: Album?,
     songs: List<Song>,
+    modifier: Modifier = Modifier,
     discs: List<Disc> = emptyList(),
     coverArt: (String?, Boolean) -> CoverArtRef?,
     artwork: ArtworkColors?,
@@ -160,7 +161,6 @@ fun AlbumDetailScreen(
     onMore: () -> Unit = {},
     onArtistClick: (() -> Unit)? = null,
     playingSongId: String? = null,
-    modifier: Modifier = Modifier,
 ) {
     val multiDisc = songs.map { it.disc ?: 1L }.distinct().size > 1
     val resources = LocalResources.current

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

@@ -37,6 +37,7 @@ import com.subtracks.ui.components.ListDownloadIndicator
 import com.subtracks.ui.components.LoadingState
 import com.subtracks.ui.components.MenuTarget
 import com.subtracks.ui.components.ResetScrollOnChange
+import com.subtracks.ui.components.ScrollToTopOnRequest
 import com.subtracks.ui.components.rememberViewportFill
 import com.subtracks.ui.theme.PrefetchArtworkSeeds
 
@@ -48,6 +49,7 @@ fun AlbumsContent(
     coverArt: (String?, Boolean) -> CoverArtRef?,
     bottomInset: Dp,
     onAlbumClick: (Album) -> Unit,
+    modifier: Modifier = Modifier,
     onLongClick: (MenuTarget) -> Unit = {},
     filtered: Boolean = false,
     onClearFilters: () -> Unit = {},
@@ -55,7 +57,7 @@ fun AlbumsContent(
     topInset: Dp = 0.dp,
     onSync: () -> Unit = {},
     downloadStatuses: Map<String, ListDownloadStatus> = emptyMap(),
-    modifier: Modifier = Modifier,
+    scrollToTopKey: Any? = null,
 ) {
     when {
         items.itemCount == 0 && items.loadState.refresh is LoadState.Loading -> {
@@ -78,6 +80,7 @@ fun AlbumsContent(
         else -> {
             val gridState = rememberLazyGridState()
             ResetScrollOnChange(resetKey, { items.loadState.refresh }) { gridState.scrollToItem(0) }
+            ScrollToTopOnRequest(scrollToTopKey, gridState)
             val fill = rememberViewportFill(gridState)
             LazyVerticalGrid(
                 state = gridState,

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

@@ -217,6 +217,7 @@ fun ArtistDetailRoute(
 @Composable
 fun ArtistDetailScreen(
     artist: Artist?,
+    modifier: Modifier = Modifier,
     artistName: String = "",
     isAlbumArtist: Boolean = false,
     albums: List<Album>,
@@ -232,7 +233,6 @@ fun ArtistDetailScreen(
     starred: Boolean = false,
     onToggleStar: (() -> Unit)? = null,
     onShuffle: () -> Unit = {},
-    modifier: Modifier = Modifier,
 ) {
     val listState = rememberLazyGridState()
     val fill = rememberViewportFill(listState)

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

@@ -36,6 +36,7 @@ import com.subtracks.ui.components.ListDownloadIndicator
 import com.subtracks.ui.components.LoadingState
 import com.subtracks.ui.components.MenuTarget
 import com.subtracks.ui.components.ResetScrollOnChange
+import com.subtracks.ui.components.ScrollToTopOnRequest
 import com.subtracks.ui.components.rememberViewportFill
 import com.subtracks.ui.theme.PrefetchArtworkSeeds
 
@@ -45,6 +46,7 @@ fun ArtistsContent(
     coverArt: (String?, Boolean) -> CoverArtRef?,
     bottomInset: Dp,
     onArtistClick: (Artist) -> Unit,
+    modifier: Modifier = Modifier,
     onLongClick: (MenuTarget) -> Unit = {},
     filtered: Boolean = false,
     onClearFilters: () -> Unit = {},
@@ -52,7 +54,7 @@ fun ArtistsContent(
     topInset: Dp = 0.dp,
     onSync: () -> Unit = {},
     downloadStatuses: Map<String, ListDownloadStatus> = emptyMap(),
-    modifier: Modifier = Modifier,
+    scrollToTopKey: Any? = null,
 ) {
     when {
         items.itemCount == 0 && items.loadState.refresh is LoadState.Loading -> {
@@ -70,6 +72,7 @@ fun ArtistsContent(
         else -> {
             val listState = rememberLazyListState()
             ResetScrollOnChange(resetKey, { items.loadState.refresh }) { listState.scrollToItem(0) }
+            ScrollToTopOnRequest(scrollToTopKey, listState)
             val fill = rememberViewportFill(listState)
             LazyColumn(
                 state = listState,

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

@@ -40,6 +40,7 @@ import androidx.compose.material.icons.rounded.Person
 import androidx.compose.material.icons.rounded.Remove
 import androidx.compose.material.icons.rounded.Search
 import androidx.compose.material.icons.rounded.Settings
+import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.FilterChip
 import androidx.compose.material3.FilterChipDefaults
@@ -243,6 +244,7 @@ fun LibraryRoute(
     var previousTabName by remember { mutableStateOf(selectedTab.name) }
     val previousTab = LibraryTab.entries.firstOrNull { it.name == previousTabName } ?: LibraryTab.Albums
     val syncing by viewModel.syncing.collectAsStateWithLifecycle()
+    val refreshing by viewModel.refreshing.collectAsStateWithLifecycle()
     val listTab = selectedTab.listTab()
     LaunchedEffect(selectedTab) {
         if (previousTab != selectedTab) {
@@ -296,6 +298,7 @@ fun LibraryRoute(
         selectedTab = selectedTab,
         onTabSelected = { tab -> if (viewModel.selectedTab.value != tab) viewModel.selectTab(tab) },
         syncing = syncing,
+        refreshing = refreshing,
         bottomInset = bottomInset,
         artwork = artwork,
         albums = viewModel.albums,
@@ -386,11 +389,13 @@ fun LibraryScreen(
     onPlaylistClick: (Playlist) -> Unit,
     onSync: () -> Unit,
     onOpenSettings: () -> Unit,
+    modifier: Modifier = Modifier,
     onOpenSearch: () -> Unit = {},
     offline: Boolean = false,
     onExitOffline: () -> Unit = {},
     onItemLongClick: (MenuTarget) -> Unit = {},
     syncing: Boolean = false,
+    refreshing: Boolean = false,
     bottomInset: Dp = 0.dp,
     listQuery: ListQuery = ListQuery(""),
     resetKeys: Map<LibraryTab, Any?> = emptyMap(),
@@ -409,7 +414,6 @@ fun LibraryScreen(
     playlistDownloads: Map<String, ListDownloadStatus> = emptyMap(),
     dismissals: Flow<Unit> = emptyFlow(),
     homeContent: @Composable (topInset: Dp, bottomInset: Dp) -> Unit = { _, _ -> },
-    modifier: Modifier = Modifier,
 ) {
     val pagerState =
         rememberPagerState(
@@ -418,6 +422,7 @@ fun LibraryScreen(
         )
     var showOptions by rememberSaveable { mutableStateOf(false) }
     var searchActive by rememberSaveable { mutableStateOf(false) }
+    var topRequest by remember { mutableIntStateOf(0) }
     val searchFocus = remember { FocusRequester() }
 
     // Search mode is left open so the typed query survives; MainNavigation dismisses the keyboard.
@@ -470,15 +475,16 @@ fun LibraryScreen(
         ) { page ->
             val pageTab = LibraryTab.entries[page]
             val resetKey = resetKeys[pageTab]
+            val scrollToTopKey = if (pageTab == selectedTab) topRequest else null
             val pullToRefreshState = rememberPullToRefreshState()
             PullToRefreshBox(
-                isRefreshing = syncing,
+                isRefreshing = refreshing,
                 onRefresh = onSync,
                 state = pullToRefreshState,
                 indicator = {
                     PullToRefreshDefaults.Indicator(
                         state = pullToRefreshState,
-                        isRefreshing = syncing,
+                        isRefreshing = refreshing,
                         modifier = Modifier.align(Alignment.TopCenter).statusBarsPadding(),
                         containerColor = headerColor,
                         color = artwork?.scheme?.primary ?: MaterialTheme.colorScheme.primary,
@@ -507,6 +513,7 @@ fun LibraryScreen(
                             topInset = listTopInset,
                             onSync = onSync,
                             downloadStatuses = albumDownloads,
+                            scrollToTopKey = scrollToTopKey,
                         )
                     }
 
@@ -526,6 +533,7 @@ fun LibraryScreen(
                             topInset = listTopInset,
                             onSync = onSync,
                             downloadStatuses = artistDownloads,
+                            scrollToTopKey = scrollToTopKey,
                         )
                     }
 
@@ -545,6 +553,7 @@ fun LibraryScreen(
                             topInset = listTopInset,
                             onSync = onSync,
                             downloadStatuses = playlistDownloads,
+                            scrollToTopKey = scrollToTopKey,
                         )
                     }
                 }
@@ -570,11 +579,14 @@ fun LibraryScreen(
             ) {
                 LibraryTabs(
                     pagerState = pagerState,
-                    onTabSelected = onTabSelected,
+                    onTabSelected = { tab ->
+                        if (tab == selectedTab) topRequest++ else onTabSelected(tab)
+                    },
                     onOpenSettings = onOpenSettings,
                     offline = offline,
                     onExitOffline = onExitOffline,
                     artwork = artwork,
+                    syncing = syncing,
                 )
             }
         }
@@ -831,6 +843,7 @@ private fun ListOptionsGlyph(modifier: Modifier = Modifier) {
     }
 }
 
+@Suppress("FrequentlyChangingValue")
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 internal fun LibraryTabs(
@@ -840,6 +853,7 @@ internal fun LibraryTabs(
     offline: Boolean = false,
     onExitOffline: () -> Unit = {},
     artwork: ArtworkColors?,
+    syncing: Boolean = false,
 ) {
     val indicatorStretch = 18.dp
     val density = LocalDensity.current
@@ -931,11 +945,20 @@ internal fun LibraryTabs(
                         }
                     }
                     IconButton(onClick = onOpenSettings) {
+                        Box(contentAlignment = Alignment.Center) {
                             Icon(
                                 imageVector = Icons.Rounded.Settings,
                                 contentDescription = stringResource(R.string.navigation_tabs_settings),
                                 tint = MaterialTheme.colorScheme.onBackground,
                             )
+                            if (syncing) {
+                                CircularProgressIndicator(
+                                    modifier = Modifier.size(32.dp),
+                                    strokeWidth = 2.dp,
+                                    color = MaterialTheme.colorScheme.primary,
+                                )
+                            }
+                        }
                     }
                 }
             }

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

@@ -117,7 +117,12 @@ class LibraryViewModel(
 
     val syncing: StateFlow<Boolean> =
         syncManager.status
-            .map { it == SyncStatus.Running }
+            .map { it is SyncStatus.Running }
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), false)
+
+    val refreshing: StateFlow<Boolean> =
+        syncManager.status
+            .map { it is SyncStatus.Running && !it.silent }
             .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), false)
 
     private val activeSourceId = libraryRepository.activeSourceId.filterNotNull()
@@ -206,7 +211,9 @@ class LibraryViewModel(
         thumbnail: Boolean,
     ): CoverArtRef? = sourceRepository.coverArt(coverArt, thumbnail)
 
-    fun sync() = syncManager.requestSync()
+    fun sync() {
+        if (syncManager.status.value !is SyncStatus.Running) syncManager.requestSync()
+    }
 }
 
 internal fun ListQuery.albumSort(): AlbumSort = AlbumSort.entries.firstOrNull { it.name == sort } ?: AlbumSort.Name

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

@@ -120,6 +120,7 @@ fun PlaylistDetailScreen(
     songs: LazyPagingItems<PlaylistSongItem>,
     coverArt: (String?, Boolean) -> CoverArtRef?,
     artwork: ArtworkColors?,
+    modifier: Modifier = Modifier,
     downloads: Map<String, SongDownload> = emptyMap(),
     downloadStatus: ListDownloadStatus = ListDownloadStatus(),
     offline: Boolean = false,
@@ -131,7 +132,6 @@ fun PlaylistDetailScreen(
     onPlay: () -> Unit = {},
     onMore: () -> Unit = {},
     playingSongId: String? = null,
-    modifier: Modifier = Modifier,
 ) {
     val context = LocalContext.current
     HeroDetailScaffold(

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

@@ -36,6 +36,7 @@ import com.subtracks.ui.components.ListDownloadIndicator
 import com.subtracks.ui.components.LoadingState
 import com.subtracks.ui.components.MenuTarget
 import com.subtracks.ui.components.ResetScrollOnChange
+import com.subtracks.ui.components.ScrollToTopOnRequest
 import com.subtracks.ui.components.rememberViewportFill
 
 @Composable
@@ -44,6 +45,7 @@ fun PlaylistsContent(
     coverArt: (String?, Boolean) -> CoverArtRef?,
     bottomInset: Dp,
     onPlaylistClick: (Playlist) -> Unit,
+    modifier: Modifier = Modifier,
     onLongClick: (MenuTarget) -> Unit = {},
     filtered: Boolean = false,
     onClearFilters: () -> Unit = {},
@@ -51,7 +53,7 @@ fun PlaylistsContent(
     topInset: Dp = 0.dp,
     onSync: () -> Unit = {},
     downloadStatuses: Map<String, ListDownloadStatus> = emptyMap(),
-    modifier: Modifier = Modifier,
+    scrollToTopKey: Any? = null,
 ) {
     when {
         items.itemCount == 0 && items.loadState.refresh is LoadState.Loading -> {
@@ -74,6 +76,7 @@ fun PlaylistsContent(
         else -> {
             val listState = rememberLazyListState()
             ResetScrollOnChange(resetKey, { items.loadState.refresh }) { listState.scrollToItem(0) }
+            ScrollToTopOnRequest(scrollToTopKey, listState)
             val fill = rememberViewportFill(listState)
             LazyColumn(
                 state = listState,

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

@@ -93,6 +93,7 @@ private fun buildVectorPath(vector: ImageVector): Path {
 @Composable
 fun SongRow(
     song: Song,
+    modifier: Modifier = Modifier,
     coverArtId: String? = null,
     coverArt: ((String?, Boolean) -> CoverArtRef?)? = null,
     isPlaying: Boolean = false,
@@ -100,7 +101,6 @@ fun SongRow(
     durationSeconds: Long? = null,
     download: SongDownload? = null,
     trailingContent: (@Composable () -> Unit)? = null,
-    modifier: Modifier = Modifier,
 ) {
     ListItem(
         modifier = modifier,

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

@@ -60,10 +60,10 @@ fun MiniPlayer(
     onExpand: () -> Unit,
     onPlayPause: () -> Unit,
     onNext: () -> Unit,
+    modifier: Modifier = Modifier,
     progressInset: Boolean = false,
     onExpandDrag: (Float) -> Unit = {},
     onExpandRelease: (Float) -> Unit = {},
-    modifier: Modifier = Modifier,
 ) {
     val item = state.item ?: return
     var dragUpPx by remember { mutableFloatStateOf(0f) }

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

@@ -182,9 +182,9 @@ fun NowPlayingRoute(
     onQueue: () -> Unit,
     onViewAlbum: (String) -> Unit,
     onViewArtist: (String) -> Unit,
+    modifier: Modifier = Modifier,
     contextMenuHost: ContextMenuHost? = null,
     setStar: (StarType, String, Boolean) -> Unit,
-    modifier: Modifier = Modifier,
     controller: PlaybackController = koinInject(),
     libraryRepository: LibraryRepository = koinInject(),
     downloadRepository: DownloadRepository = koinInject(),
@@ -286,6 +286,7 @@ fun NowPlayingScreen(
     onPlayPause: () -> Unit,
     onNext: () -> Unit,
     onPrevious: () -> Unit,
+    modifier: Modifier = Modifier,
     onSkipPrevious: () -> Unit = onPrevious,
     onShuffle: () -> Unit = {},
     onRepeat: () -> Unit = {},
@@ -298,7 +299,6 @@ fun NowPlayingScreen(
     thumbnailRef: CoverArtRef? = null,
     previousArt: NowPlayingArt? = null,
     nextArt: NowPlayingArt? = null,
-    modifier: Modifier = Modifier,
 ) {
     val playButtonSize = 90.dp
     val playCircleDiameter = playButtonSize * 20f / 24f

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

@@ -33,6 +33,7 @@ import androidx.compose.material3.TopAppBar
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateListOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
@@ -106,12 +107,14 @@ class QueueViewModel(
     var ready by mutableStateOf(false)
         private set
 
-    var initialIndex by mutableStateOf(0)
+    var initialIndex by mutableIntStateOf(0)
         private set
 
-    var generation by mutableStateOf(0)
+    var generation by mutableIntStateOf(0)
         private set
 
+    private var reorderPending = false
+
     private var nextId = 0L
     private val mutex = Mutex()
 
@@ -248,13 +251,20 @@ class QueueViewModel(
     fun move(
         from: Long,
         to: Long,
-    ) {
+    ): Boolean {
-        if (from == to) return
+        if (from == to) return false
+        if (reorderPending) return false
+        reorderPending = true
         viewModelScope.launch {
+            try {
                 playbackController.move(from, to)
                 mutex.withLock { reconcileLocked() }
+            } finally {
+                reorderPending = false
             }
         }
+        return true
+    }
 
     fun remove(position: Long) {
         viewModelScope.launch {
@@ -330,7 +340,7 @@ fun QueueScreen(
     onPlay: (Long) -> Unit,
     onRemove: (Long) -> Unit,
     onReorder: (Int, Int) -> Unit,
-    onMove: (Long, Long) -> Unit,
+    onMove: (Long, Long) -> Boolean,
     onLoadOlder: () -> Unit,
     onLoadNewer: () -> Unit,
     onUndo: () -> Unit,
@@ -346,7 +356,6 @@ fun QueueScreen(
     val snackbarHostState = remember { SnackbarHostState() }
     val scope = rememberCoroutineScope()
     var dragId by remember { mutableStateOf<Long?>(null) }
-    var dragFrom by remember { mutableStateOf<Long?>(null) }
     val undoLabel = stringResource(R.string.undo)
     val queueReordered = stringResource(R.string.queue_reordered)
     val queueRemoved = stringResource(R.string.queue_removed)
@@ -469,28 +478,14 @@ fun QueueScreen(
                                             null
                                         } else {
                                             Modifier.draggableHandle(
-                                                onDragStarted = {
+                                                onDragStarted = { dragId = row.id },
-                                                    dragId = row.id
-                                                    dragFrom = row.position
-                                                },
                                                 onDragStopped = {
-                                                    val id = dragId
+                                                    dragId?.let { id ->
-                                                    val from = dragFrom
+                                                        rows.dropMoveFor(id)?.let { move ->
-                                                    if (id != null && from != null) {
+                                                            if (onMove(move.from, move.to)) showUndo(queueReordered)
-                                                        val draggedIndex = rows.indexOfFirst { it.id == id }
-                                                        val to =
-                                                            if (draggedIndex < 0) {
-                                                                from
-                                                            } else {
-                                                                dropTarget(rows, draggedIndex, from)
-                                                            }
-                                                        if (to != from) {
-                                                            onMove(from, to)
-                                                            showUndo(queueReordered)
                                                         }
                                                     }
                                                     dragId = null
-                                                    dragFrom = null
                                                 },
                                             )
                                         },
@@ -562,6 +557,20 @@ internal fun dropTarget(
     return (before - if (before > from) 1 else 0) + 1
 }
 
+internal data class QueueMove(
+    val from: Long,
+    val to: Long,
+)
+
+internal fun List<QueueRow>.dropMoveFor(draggedId: Long): QueueMove? {
+    val index = indexOfFirst { it.id == draggedId }
+    if (index < 0) return null
+    val from = this[index].position
+    val to = dropTarget(this, index, from)
+    return if (to == from) null else QueueMove(from, to)
+}
+
+@Suppress("ModifierParameter")
 @Composable
 private fun QueueRowItem(
     row: QueueRow,

app/src/main/kotlin/com/subtracks/ui/search/SearchScreen.kt

@@ -59,7 +59,7 @@ import org.koin.compose.koinInject
 import org.koin.compose.viewmodel.koinViewModel
 
 enum class SearchFilter(
-    @StringRes val label: Int,
+    @param:StringRes val label: Int,
 ) {
     Songs(R.string.search_songs),
     Albums(R.string.resources_album_name),
@@ -125,6 +125,7 @@ fun SearchScreen(
     query: String,
     onQueryChange: (String) -> Unit,
     results: SearchResults,
+    modifier: Modifier = Modifier,
     filters: Set<SearchFilter> = ALL_FILTERS,
     onToggleFilter: (SearchFilter) -> Unit = {},
     coverArt: (String?, Boolean) -> CoverArtRef? = { _, _ -> null },
@@ -135,7 +136,6 @@ fun SearchScreen(
     onPlaylistClick: (Playlist) -> Unit = {},
     onSongClick: (Song) -> Unit = {},
     onLongClick: (MenuTarget) -> Unit = {},
-    modifier: Modifier = Modifier,
 ) {
     val focusRequester = remember { FocusRequester() }
     val backLabel = stringResource(R.string.navigation_back)

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

@@ -90,8 +90,8 @@ fun AddSourceScreen(
     onSave: () -> Unit,
     onDelete: () -> Unit,
     onBack: (() -> Unit)?,
-    dismissals: Flow<Unit> = emptyFlow(),
     modifier: Modifier = Modifier,
+    dismissals: Flow<Unit> = emptyFlow(),
 ) {
     val nameFocus = remember { FocusRequester() }
     val addressFocus = remember { FocusRequester() }

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

@@ -1,6 +1,7 @@
 package com.subtracks.ui.settings
 
 import android.content.res.Resources
+import android.widget.Toast
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
@@ -24,6 +25,10 @@ import androidx.compose.material.icons.rounded.Add
 import androidx.compose.material.icons.rounded.Description
 import androidx.compose.material.icons.rounded.Download
 import androidx.compose.material.icons.rounded.Edit
+import androidx.compose.material.icons.rounded.Favorite
+import androidx.compose.material.icons.rounded.Info
+import androidx.compose.material.icons.rounded.Language
+import androidx.compose.material.icons.rounded.Share
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Button
 import androidx.compose.material3.ExperimentalMaterial3Api
@@ -41,31 +46,45 @@ import androidx.compose.material3.TextButton
 import androidx.compose.material3.TopAppBar
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalResources
+import androidx.compose.ui.platform.LocalUriHandler
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.subtracks.BuildConfig
 import com.subtracks.R
 import com.subtracks.data.model.Source
+import com.subtracks.data.prefs.DEFAULT_SYNC_INTERVAL_MINUTES
 import com.subtracks.data.prefs.StreamQuality
+import com.subtracks.data.prefs.SyncMode
+import com.subtracks.log.Log
 import com.subtracks.ui.components.DismissOnRequest
 import com.subtracks.ui.components.rememberViewportFill
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import org.koin.compose.viewmodel.koinViewModel
 
 private val bitrateOptions = listOf(0, 24, 32, 64, 96, 128, 192, 256, 320)
 private val streamFormats = listOf(null, "mp3", "opus", "ogg", "webm", "aac", "flac")
 
-private enum class SettingsDialog { WifiQuality, MobileQuality, DownloadQuality, SyncConcurrency }
+private const val PROJECT_HOMEPAGE = "https://github.com/austinried/subtracks"
+private const val SUPPORT_URL = "https://ko-fi.com/austinried"
+
+private enum class SettingsDialog { WifiQuality, MobileQuality, DownloadQuality, SyncConcurrency, SyncInterval, SyncMode }
 
 @Composable
 fun SettingsRoute(
@@ -82,32 +101,60 @@ fun SettingsRoute(
     val wifiQuality by viewModel.wifiQuality.collectAsStateWithLifecycle()
     val mobileQuality by viewModel.mobileQuality.collectAsStateWithLifecycle()
     val syncConcurrency by viewModel.syncConcurrency.collectAsStateWithLifecycle()
+    val syncMode by viewModel.syncMode.collectAsStateWithLifecycle()
+    val syncIntervalMinutes by viewModel.syncIntervalMinutes.collectAsStateWithLifecycle()
     val downloadQuality by viewModel.downloadQuality.collectAsStateWithLifecycle()
     val downloadOverMetered by viewModel.downloadOverMetered.collectAsStateWithLifecycle()
     val scrobbling by viewModel.scrobbling.collectAsStateWithLifecycle()
     val offline by viewModel.offline.collectAsStateWithLifecycle()
+    val verboseLogging by viewModel.verboseLogging.collectAsStateWithLifecycle()
+    val context = LocalContext.current
+    val scope = rememberCoroutineScope()
     SettingsScreen(
         sources = sources,
         activeSourceId = activeSourceId,
         wifiQuality = wifiQuality,
         mobileQuality = mobileQuality,
         syncConcurrency = syncConcurrency,
+        syncMode = syncMode,
+        syncInterval = syncIntervalMinutes,
         downloadQuality = downloadQuality,
         downloadOverMetered = downloadOverMetered,
         scrobbling = scrobbling,
         offline = offline,
+        verboseLogging = verboseLogging,
         onSelectSource = viewModel::selectSource,
         onEditServer = onEditServer,
         onWifiQualityChange = viewModel::setWifiQuality,
         onMobileQualityChange = viewModel::setMobileQuality,
         onSyncConcurrencyChange = viewModel::setSyncConcurrency,
+        onSyncModeChange = viewModel::setSyncMode,
+        onSyncIntervalChange = viewModel::setSyncIntervalMinutes,
         onDownloadQualityChange = viewModel::setDownloadQuality,
         onDownloadOverMeteredChange = viewModel::setDownloadOverMetered,
         onScrobblingChange = viewModel::setScrobbling,
         onOfflineChange = viewModel::setOfflineMode,
+        onVerboseLoggingChange = viewModel::setVerboseLogging,
         onAddServer = onAddServer,
         onOpenDownloads = onOpenDownloads,
         onOpenLicenses = onOpenLicenses,
+        onShareLogs = {
+            scope.launch {
+                val result =
+                    runCatching {
+                        val zip = withContext(Dispatchers.IO) { Log.exportZip() }
+                        if (zip != null) Log.share(context, zip)
+                        zip
+                    }
+                val message =
+                    when {
+                        result.isFailure -> R.string.settings_about_share_logs_failed
+                        result.getOrNull() == null -> R.string.settings_about_share_logs_empty
+                        else -> null
+                    }
+                message?.let { Toast.makeText(context, it, Toast.LENGTH_SHORT).show() }
+            }
+        },
         onBack = onBack,
         dismissals = dismissals,
     )
@@ -124,27 +171,35 @@ fun SettingsScreen(
     downloadQuality: StreamQuality,
     downloadOverMetered: Boolean,
     scrobbling: Boolean,
+    modifier: Modifier = Modifier,
     offline: Boolean = false,
+    verboseLogging: Boolean = false,
+    syncMode: SyncMode = SyncMode.WifiOnly,
+    syncInterval: Int = DEFAULT_SYNC_INTERVAL_MINUTES,
     onSelectSource: (Long) -> Unit,
     onEditServer: (Long) -> Unit,
     onWifiQualityChange: (StreamQuality) -> Unit,
     onMobileQualityChange: (StreamQuality) -> Unit,
     onSyncConcurrencyChange: (Int) -> Unit,
+    onSyncModeChange: (SyncMode) -> Unit = {},
+    onSyncIntervalChange: (Int) -> Unit = {},
     onDownloadQualityChange: (StreamQuality) -> Unit,
     onDownloadOverMeteredChange: (Boolean) -> Unit,
     onScrobblingChange: (Boolean) -> Unit,
     onOfflineChange: (Boolean) -> Unit = {},
+    onVerboseLoggingChange: (Boolean) -> Unit = {},
     onAddServer: () -> Unit,
     onOpenDownloads: () -> Unit,
     onOpenLicenses: () -> Unit,
+    onShareLogs: () -> Unit,
     onBack: () -> Unit,
     dismissals: Flow<Unit> = emptyFlow(),
-    modifier: Modifier = Modifier,
 ) {
     var dialog by remember { mutableStateOf<SettingsDialog?>(null) }
     DismissOnRequest(dismissals) { dialog = null }
     val listState = rememberLazyListState()
     val fill = rememberViewportFill(listState)
+    val uriHandler = LocalUriHandler.current
 
     Scaffold(
         modifier = modifier,
@@ -245,6 +300,22 @@ fun SettingsScreen(
                     colors = ListItemDefaults.colors(containerColor = Color.Transparent),
                 )
             }
+            item {
+                ListItem(
+                    headlineContent = { Text(stringResource(R.string.settings_sync_auto_title)) },
+                    supportingContent = { Text(syncModeLabel(LocalResources.current, syncMode)) },
+                    modifier = Modifier.clickable { dialog = SettingsDialog.SyncMode },
+                    colors = ListItemDefaults.colors(containerColor = Color.Transparent),
+                )
+            }
+            item {
+                ListItem(
+                    headlineContent = { Text(stringResource(R.string.sync_interval)) },
+                    supportingContent = { Text(syncIntervalLabel(LocalResources.current, syncInterval)) },
+                    modifier = Modifier.clickable { dialog = SettingsDialog.SyncInterval },
+                    colors = ListItemDefaults.colors(containerColor = Color.Transparent),
+                )
+            }
             item { SectionHeader(stringResource(R.string.settings_music_name)) }
             item {
                 ListItem(
@@ -311,7 +382,55 @@ fun SettingsScreen(
                     colors = ListItemDefaults.colors(containerColor = Color.Transparent),
                 )
             }
+            item { SectionHeader(stringResource(R.string.settings_troubleshooting_name)) }
+            item {
+                ListItem(
+                    headlineContent = { Text(stringResource(R.string.settings_about_actions_share_logs)) },
+                    leadingContent = { Icon(Icons.Rounded.Share, contentDescription = null) },
+                    modifier = Modifier.clickable(onClick = onShareLogs),
+                    colors = ListItemDefaults.colors(containerColor = Color.Transparent),
+                )
+            }
+            item {
+                ListItem(
+                    headlineContent = { Text(stringResource(R.string.settings_about_verbose_logging)) },
+                    supportingContent = { Text(stringResource(R.string.settings_about_verbose_logging_description)) },
+                    trailingContent = {
+                        Switch(
+                            checked = verboseLogging,
+                            onCheckedChange = onVerboseLoggingChange,
+                            colors =
+                                SwitchDefaults.colors(
+                                    uncheckedThumbColor = MaterialTheme.colorScheme.onSurfaceVariant,
+                                    uncheckedTrackColor = MaterialTheme.colorScheme.surfaceVariant,
+                                    uncheckedBorderColor = MaterialTheme.colorScheme.outline,
+                                ),
+                        )
+                    },
+                    modifier = Modifier.clickable { onVerboseLoggingChange(!verboseLogging) },
+                    colors = ListItemDefaults.colors(containerColor = Color.Transparent),
+                )
+            }
             item { SectionHeader(stringResource(R.string.settings_about_name)) }
+            item {
+                ListItem(
+                    headlineContent = { Text(stringResource(R.string.app_name)) },
+                    supportingContent = {
+                        Row(verticalAlignment = Alignment.CenterVertically) {
+                            Text(stringResource(R.string.settings_about_version, BuildConfig.VERSION_NAME))
+                            if (BuildConfig.COMMIT_HASH.isNotEmpty()) {
+                                Spacer(Modifier.width(8.dp))
+                                Text(
+                                    BuildConfig.COMMIT_HASH,
+                                    color = MaterialTheme.colorScheme.outline,
+                                )
+                            }
+                        }
+                    },
+                    leadingContent = { Icon(Icons.Rounded.Info, contentDescription = null) },
+                    colors = ListItemDefaults.colors(containerColor = Color.Transparent),
+                )
+            }
             item {
                 ListItem(
                     headlineContent = { Text(stringResource(R.string.settings_about_actions_licenses)) },
@@ -320,6 +439,30 @@ fun SettingsScreen(
                     colors = ListItemDefaults.colors(containerColor = Color.Transparent),
                 )
             }
+            item {
+                ListItem(
+                    headlineContent = { Text(stringResource(R.string.settings_about_actions_project_homepage)) },
+                    supportingContent = { Text(PROJECT_HOMEPAGE) },
+                    leadingContent = { Icon(Icons.Rounded.Language, contentDescription = null) },
+                    modifier = Modifier.clickable { runCatching { uriHandler.openUri(PROJECT_HOMEPAGE) } },
+                    colors = ListItemDefaults.colors(containerColor = Color.Transparent),
+                )
+            }
+            item {
+                ListItem(
+                    headlineContent = { Text(stringResource(R.string.settings_about_actions_support)) },
+                    supportingContent = { Text(SUPPORT_URL) },
+                    leadingContent = {
+                        Icon(
+                            Icons.Rounded.Favorite,
+                            contentDescription = null,
+                            tint = MaterialTheme.colorScheme.primary,
+                        )
+                    },
+                    modifier = Modifier.clickable { runCatching { uriHandler.openUri(SUPPORT_URL) } },
+                    colors = ListItemDefaults.colors(containerColor = Color.Transparent),
+                )
+            }
             item { Spacer(Modifier.height(fill)) }
         }
     }
@@ -360,6 +503,22 @@ fun SettingsScreen(
             )
         }
 
+        SettingsDialog.SyncInterval -> {
+            SyncIntervalDialog(
+                selected = syncInterval,
+                onSelect = onSyncIntervalChange,
+                onDismiss = { dialog = null },
+            )
+        }
+
+        SettingsDialog.SyncMode -> {
+            SyncModeDialog(
+                selected = syncMode,
+                onSelect = onSyncModeChange,
+                onDismiss = { dialog = null },
+            )
+        }
+
         null -> {
             Unit
         }
@@ -385,11 +544,56 @@ private fun bitrateLabel(
 
 private val syncConcurrencyOptions = listOf(1, 2, 4, 8, 16)
 
+private val syncIntervalOptions = listOf(15, 60, 360, 720, DEFAULT_SYNC_INTERVAL_MINUTES)
+
 private fun concurrencyLabel(
     resources: Resources,
     value: Int,
 ): String = if (value <= 1) resources.getString(R.string.sync_concurrency_sequential) else value.toString()
 
+private fun syncIntervalLabel(
+    resources: Resources,
+    minutes: Int,
+): String =
+    if (minutes >= 60 && minutes % 60 == 0) {
+        resources.getQuantityString(R.plurals.sync_interval_hours, minutes / 60, minutes / 60)
+    } else {
+        resources.getQuantityString(R.plurals.sync_interval_minutes, minutes, minutes)
+    }
+
+@Composable
+private fun SyncIntervalDialog(
+    selected: Int,
+    onSelect: (Int) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val resources = LocalResources.current
+    var draft by remember(selected) { mutableIntStateOf(selected) }
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.sync_interval)) },
+        text = {
+            ChoiceGroup(
+                header = stringResource(R.string.sync_interval_prompt),
+                options = syncIntervalOptions.map { it to syncIntervalLabel(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 ConcurrencyDialog(
     selected: Int,
@@ -397,7 +601,7 @@ private fun ConcurrencyDialog(
     onDismiss: () -> Unit,
 ) {
     val resources = LocalResources.current
-    var draft by remember(selected) { mutableStateOf(selected) }
+    var draft by remember(selected) { mutableIntStateOf(selected) }
     AlertDialog(
         onDismissRequest = onDismiss,
         title = { Text(stringResource(R.string.sync_concurrency)) },
@@ -423,6 +627,51 @@ private fun ConcurrencyDialog(
     )
 }
 
+private val syncModeOptions = SyncMode.entries
+
+private fun syncModeLabel(
+    resources: Resources,
+    mode: SyncMode,
+): String =
+    when (mode) {
+        SyncMode.Off -> resources.getString(R.string.sync_mode_off)
+        SyncMode.WifiOnly -> resources.getString(R.string.sync_mode_wifi)
+        SyncMode.Always -> resources.getString(R.string.sync_mode_always)
+    }
+
+@Composable
+private fun SyncModeDialog(
+    selected: SyncMode,
+    onSelect: (SyncMode) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val resources = LocalResources.current
+    var draft by remember(selected) { mutableStateOf(selected) }
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(R.string.settings_sync_auto_title)) },
+        text = {
+            ChoiceGroup(
+                header = stringResource(R.string.sync_mode_prompt),
+                options = syncModeOptions.map { it to syncModeLabel(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 QualityDialog(
     title: String,

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

@@ -4,7 +4,9 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 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.StreamQuality
+import com.subtracks.data.prefs.SyncMode
 import com.subtracks.data.prefs.UserPreferences
 import com.subtracks.data.repo.SourceRepository
 import com.subtracks.data.source.DEFAULT_FETCH_CONCURRENCY
@@ -48,6 +50,16 @@ class SettingsViewModel(
             .syncConcurrency()
             .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), DEFAULT_FETCH_CONCURRENCY)
 
+    val syncMode: StateFlow<SyncMode> =
+        userPreferences
+            .syncMode()
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), SyncMode.WifiOnly)
+
+    val syncIntervalMinutes: StateFlow<Int> =
+        userPreferences
+            .syncIntervalMinutes()
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), DEFAULT_SYNC_INTERVAL_MINUTES)
+
     val scrobbling: StateFlow<Boolean> =
         userPreferences
             .scrobbling()
@@ -55,10 +67,19 @@ class SettingsViewModel(
 
     val offline: StateFlow<Boolean> = sourceRepository.offline
 
+    val verboseLogging: StateFlow<Boolean> =
+        userPreferences
+            .verboseLogging()
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), false)
+
     fun setOfflineMode(enabled: Boolean) {
         sourceRepository.setOfflineMode(enabled)
     }
 
+    fun setVerboseLogging(enabled: Boolean) {
+        viewModelScope.launch { userPreferences.setVerboseLogging(enabled) }
+    }
+
     fun selectSource(id: Long) {
         viewModelScope.launch { sourceRepository.selectSource(id) }
     }
@@ -83,6 +104,14 @@ class SettingsViewModel(
         viewModelScope.launch { userPreferences.setSyncConcurrency(value) }
     }
 
+    fun setSyncMode(mode: SyncMode) {
+        viewModelScope.launch { userPreferences.setSyncMode(mode) }
+    }
+
+    fun setSyncIntervalMinutes(value: Int) {
+        viewModelScope.launch { userPreferences.setSyncIntervalMinutes(value) }
+    }
+
     fun setScrobbling(enabled: Boolean) {
         viewModelScope.launch { userPreferences.setScrobbling(enabled) }
     }

app/src/main/kotlin/com/subtracks/ui/theme/ArtworkSeedCache.kt

@@ -12,6 +12,7 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.luminance
+import androidx.core.graphics.get
 import androidx.palette.graphics.Palette
 import coil3.SingletonImageLoader
 import coil3.compose.LocalPlatformContext
@@ -202,7 +203,7 @@ object ArtworkSeedCache {
         x: Int,
         y: Int,
     ): Float {
-        val color = Color(bitmap.getPixel(x, y))
+        val color = Color(bitmap[x, y])
         return 0.2126f * color.red + 0.7152f * color.green + 0.0722f * color.blue
     }
 

app/src/main/res/drawable/media3_notification_small_icon.xml

@@ -1,8 +1,10 @@
 <vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
     android:width="24dp"
     android:height="24dp"
     android:viewportWidth="300"
-    android:viewportHeight="300">
+    android:viewportHeight="300"
+    tools:ignore="UnusedResources">
   <group android:translateY="40.25">
     <path
         android:pathData="m23.84,-0c-12.76,0 -23.44,13 -23.65,25.12 -0.42,79.03 0,160.73 0,170.4 0,12.59 9.8,23.99 23.41,23.99l253.58,0c11.4,0 22.66,-12.38 22.66,-22.79L299.84,24.12c0,-10.8 -10.24,-23.81 -21.84,-23.81 -11.6,0 -254.16,-0.31 -254.16,-0.31zM39.05,25.28c0,0 217.71,0.71 223.67,0.71 6.07,0 12.17,6.83 12.17,12.06l0,142.25c0,8.97 -6.97,14.63 -12.48,14.64l-33.42,0.07c-5.32,0.01 -9.93,-7.19 -11.35,-10.61 -1.89,-4.55 -11.08,-25.75 -12.1,-28.1 -0.6,-1.38 -2.9,-2.83 -5.89,-2.83L98.33,153.45c-2.68,0 -4.89,2.87 -5.67,4.71 -1.12,2.66 -9.02,21.39 -11.63,27.57 -2.73,6.46 -4.37,9.06 -11.47,9.06l-30.97,0c-7.44,0 -13.69,-7.17 -13.67,-15.18l0.28,-139.51c0,-6.88 5.54,-14.83 13.85,-14.83z"

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

@@ -13,7 +13,9 @@
     <string name="resources_sort_by_year">حسب السنة</string>
     <string name="search_input_placeholder">بحث</string>
     <string name="settings_about_actions_licenses">الرخص</string>
+    <string name="settings_about_actions_project_homepage">موقع المشروع</string>
     <string name="settings_about_name">حول</string>
+    <string name="settings_about_version">الإصدار %1$s</string>
     <string name="settings_network_name">الشبكة</string>
     <string name="settings_network_values_kbps">%1$s كيلو بايت في الثانية</string>
     <string name="settings_network_values_unlimited_kbps">غير محدود</string>

app/src/main/res/values-b+pt+BR/strings.xml

@@ -10,8 +10,8 @@
     <string name="navigation_tabs_library">Biblioteca</string>
     <string name="navigation_tabs_settings">Configurações</string>
     <plurals name="resources_album_count">
-        <item quantity="one">%1$d album</item>
+        <item quantity="one">%1$d álbum</item>
-        <item quantity="other">%1$d albums</item>
+        <item quantity="other">%1$d álbuns</item>
     </plurals>
     <string name="resources_filter_album">Álbum</string>
     <string name="resources_filter_artist">Artista</string>
@@ -29,7 +29,11 @@
     <string name="resources_sort_by_year">Ano</string>
     <string name="search_input_placeholder">Pesquisar</string>
     <string name="settings_about_actions_licenses">Licenças</string>
+    <string name="settings_about_actions_project_homepage">Página do projeto</string>
+    <string name="settings_about_actions_share_logs">Compartilhar logs</string>
+    <string name="settings_about_actions_support">Apoie o desenvolvedor</string>
     <string name="settings_about_name">Sobre</string>
+    <string name="settings_about_version">Versão %1$s</string>
     <string name="settings_network_name">Rede</string>
     <string name="settings_network_options_offline_mode">Modo off-line</string>
     <string name="settings_network_options_offline_mode_off">Usar a internet para sincronizar as músicas.</string>
@@ -42,7 +46,7 @@
     <string name="settings_servers_fields_password">Senha</string>
     <string name="settings_servers_fields_username">Usuário</string>
     <string name="navigation_tabs_home">Home</string>
-    <string name="resources_album_name">Albums</string>
+    <string name="resources_album_name">Álbuns</string>
     <string name="resources_artist_name">Artists</string>
     <string name="resources_playlist_name">Playlists</string>
 </resources>

app/src/main/res/values-b+zh+Hans/strings.xml

@@ -27,7 +27,11 @@
     <string name="resources_sort_by_year">根据年份</string>
     <string name="search_input_placeholder">搜索</string>
     <string name="settings_about_actions_licenses">许可</string>
+    <string name="settings_about_actions_project_homepage">项目地址</string>
+    <string name="settings_about_actions_share_logs">分享日志</string>
+    <string name="settings_about_actions_support">支持开发者</string>
     <string name="settings_about_name">关于</string>
+    <string name="settings_about_version">版本 %1$s</string>
     <string name="settings_network_name">网络</string>
     <string name="settings_network_options_offline_mode">离线模式</string>
     <string name="settings_network_options_offline_mode_off">使用互联网同步音乐。</string>

app/src/main/res/values-b+zh+Hant/strings.xml

@@ -27,7 +27,11 @@
     <string name="resources_sort_by_year">根據年份</string>
     <string name="search_input_placeholder">搜尋</string>
     <string name="settings_about_actions_licenses">許可</string>
+    <string name="settings_about_actions_project_homepage">專案首頁</string>
+    <string name="settings_about_actions_share_logs">分享日誌</string>
+    <string name="settings_about_actions_support">支援開發者</string>
     <string name="settings_about_name">關於</string>
+    <string name="settings_about_version">版本 %1$s</string>
     <string name="settings_network_name">網路</string>
     <string name="settings_network_options_offline_mode">離線模式</string>
     <string name="settings_network_options_offline_mode_off">使用網際網路同步音樂。</string>

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

@@ -13,7 +13,9 @@
     <string name="resources_sort_by_year">Per any</string>
     <string name="search_input_placeholder">Cercar</string>
     <string name="settings_about_actions_licenses">Llicències</string>
+    <string name="settings_about_actions_project_homepage">Pàgina d\'inici del projecte</string>
     <string name="settings_about_name">Quant a</string>
+    <string name="settings_about_version">versió %1$s</string>
     <string name="settings_network_name">Xarxa</string>
     <string name="settings_network_values_kbps">%1$s kbps</string>
     <string name="settings_network_values_unlimited_kbps">Il·limitat</string>

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

@@ -21,7 +21,10 @@
     <string name="resources_sort_by_year">Roku</string>
     <string name="search_input_placeholder">Hledat</string>
     <string name="settings_about_actions_licenses">Licence</string>
+    <string name="settings_about_actions_project_homepage">Stránka projektu</string>
+    <string name="settings_about_actions_support">Podpořit vývojáře</string>
     <string name="settings_about_name">O aplikaci</string>
+    <string name="settings_about_version">verze %1$s</string>
     <string name="settings_network_name">Síť</string>
     <string name="settings_network_options_stream_format_server_default">Použít nastavení serveru</string>
     <string name="settings_network_values_kbps">%1$skbps</string>

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

@@ -12,7 +12,9 @@
     <string name="resources_sort_by_year">Efter år</string>
     <string name="search_input_placeholder">Søg</string>
     <string name="settings_about_actions_licenses">Licenser</string>
+    <string name="settings_about_actions_project_homepage">Projekt hjemmeside</string>
     <string name="settings_about_name">Omkring</string>
+    <string name="settings_about_version">version %1$s</string>
     <string name="settings_network_name">Netværk</string>
     <string name="settings_network_values_kbps">%1$skbps</string>
     <string name="settings_network_values_unlimited_kbps">Ubegrænset</string>

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

@@ -29,7 +29,11 @@
     <string name="resources_sort_by_year">Nach Jahr</string>
     <string name="search_input_placeholder">Suche</string>
     <string name="settings_about_actions_licenses">Lizenzen</string>
+    <string name="settings_about_actions_project_homepage">Projektseite</string>
+    <string name="settings_about_actions_share_logs">Protokolle teilen</string>
+    <string name="settings_about_actions_support">Den Entwickler unterstützen</string>
     <string name="settings_about_name">Über</string>
+    <string name="settings_about_version">Version %1$s</string>
     <string name="settings_network_name">Netzwerk</string>
     <string name="settings_network_options_offline_mode">Offline Modus</string>
     <string name="settings_network_options_offline_mode_off">Nutze das Internet um Musik zu synchronisieren.</string>

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

@@ -29,7 +29,11 @@
     <string name="resources_sort_by_year">Por Año</string>
     <string name="search_input_placeholder">Buscar</string>
     <string name="settings_about_actions_licenses">Licencias</string>
+    <string name="settings_about_actions_project_homepage">Página de inicio del proyecto</string>
+    <string name="settings_about_actions_share_logs">Compartir registros</string>
+    <string name="settings_about_actions_support">Apoya al desarrollador</string>
     <string name="settings_about_name">Información</string>
+    <string name="settings_about_version">versión %1$s</string>
     <string name="settings_network_name">Sitio</string>
     <string name="settings_network_options_offline_mode">Modo sin conexión</string>
     <string name="settings_network_options_offline_mode_off">Se usa internet para sincronizar música.</string>

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

@@ -28,7 +28,11 @@
     <string name="resources_sort_by_year">Urtearen arabera</string>
     <string name="search_input_placeholder">Bilatu</string>
     <string name="settings_about_actions_licenses">Lizentziak</string>
+    <string name="settings_about_actions_project_homepage">Proiektuaren webgunea</string>
+    <string name="settings_about_actions_share_logs">Partekatu erregistroak</string>
+    <string name="settings_about_actions_support">Lagundu garatzaileari</string>
     <string name="settings_about_name">Honi buruz</string>
+    <string name="settings_about_version">%1$s bertsioa</string>
     <string name="settings_network_name">Sarea</string>
     <string name="navigation_tabs_home">Hasiera</string>
     <string name="resources_album_name">Albumak</string>

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

@@ -29,7 +29,11 @@
     <string name="resources_sort_by_year">Année</string>
     <string name="search_input_placeholder">Recherche</string>
     <string name="settings_about_actions_licenses">Licences</string>
+    <string name="settings_about_actions_project_homepage">Page d\'accueil du projet</string>
+    <string name="settings_about_actions_share_logs">Partager les logs</string>
+    <string name="settings_about_actions_support">Soutenir le développeur</string>
     <string name="settings_about_name">À propos</string>
+    <string name="settings_about_version">version %1$s</string>
     <string name="settings_network_name">Réseau</string>
     <string name="settings_network_options_offline_mode">Mode hors-ligne</string>
     <string name="settings_network_options_offline_mode_off">Se connecter à internet pour synchroniser la musique.</string>

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

@@ -29,7 +29,11 @@
     <string name="resources_sort_by_year">Por ano</string>
     <string name="search_input_placeholder">Buscar</string>
     <string name="settings_about_actions_licenses">Licenzas</string>
+    <string name="settings_about_actions_project_homepage">Web do Proxecto</string>
+    <string name="settings_about_actions_share_logs">Compartir rexistros</string>
+    <string name="settings_about_actions_support">Axuda ao desenvolvemento</string>
     <string name="settings_about_name">Acerca de</string>
+    <string name="settings_about_version">versión %1$s</string>
     <string name="settings_network_name">Rede</string>
     <string name="settings_network_options_offline_mode">Modo sen conexión</string>
     <string name="settings_network_options_offline_mode_off">Usa internet para sincr. música.</string>

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

@@ -24,7 +24,11 @@
     <string name="resources_sort_by_year">Év</string>
     <string name="search_input_placeholder">Keresés</string>
     <string name="settings_about_actions_licenses">Licenszek</string>
+    <string name="settings_about_actions_project_homepage">Projekt weboldal</string>
+    <string name="settings_about_actions_share_logs">Logfájlok megosztása</string>
+    <string name="settings_about_actions_support">Támogasd a fejlesztőt</string>
     <string name="settings_about_name">Az alkalmazásról</string>
+    <string name="settings_about_version">%1$s verzió</string>
     <string name="settings_network_name">Hálózat</string>
     <string name="settings_network_options_offline_mode">Offline mód</string>
     <string name="settings_network_options_stream_format_server_default">Szerver alapértelmezés használata</string>

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

@@ -29,7 +29,11 @@
     <string name="resources_sort_by_year">Per anno</string>
     <string name="search_input_placeholder">Ricerca</string>
     <string name="settings_about_actions_licenses">Licenze</string>
+    <string name="settings_about_actions_project_homepage">Pagina principale del progetto</string>
+    <string name="settings_about_actions_share_logs">Condividi i log</string>
+    <string name="settings_about_actions_support">Sostieni lo sviluppatore</string>
     <string name="settings_about_name">Informazioni</string>
+    <string name="settings_about_version">versione %1$s</string>
     <string name="settings_network_name">Rete</string>
     <string name="settings_network_options_offline_mode">Modalità Offline</string>
     <string name="settings_network_options_offline_mode_off">Usa internet per sincronizzare la musica.</string>

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

@@ -19,4 +19,5 @@
     <string name="resources_album_name">アルバム</string>
     <string name="resources_artist_name">アーティスト</string>
     <string name="resources_playlist_name">プレイリスト</string>
+    <string name="settings_about_actions_project_homepage">ホームページ</string>
 </resources>

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

@@ -27,7 +27,11 @@
     <string name="resources_sort_by_year">년</string>
     <string name="search_input_placeholder">검색</string>
     <string name="settings_about_actions_licenses">저작권</string>
+    <string name="settings_about_actions_project_homepage">프로젝트 홈페이지</string>
+    <string name="settings_about_actions_share_logs">로그 공유</string>
+    <string name="settings_about_actions_support">개발자 지원하기</string>
     <string name="settings_about_name">subtracks에 대하여</string>
+    <string name="settings_about_version">버전: %1$s</string>
     <string name="settings_network_name">네트워크</string>
     <string name="settings_network_options_offline_mode">오프라인 모드</string>
     <string name="settings_network_options_offline_mode_off">노래를 동기화하기 위해 인터넷을 사용합니다.</string>

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

@@ -29,7 +29,11 @@
     <string name="resources_sort_by_year">Etter år</string>
     <string name="search_input_placeholder">Søk</string>
     <string name="settings_about_actions_licenses">Lisenser</string>
+    <string name="settings_about_actions_project_homepage">Prosjekthjemmeside</string>
+    <string name="settings_about_actions_share_logs">Dele logger</string>
+    <string name="settings_about_actions_support">Støtt utvikleren</string>
     <string name="settings_about_name">Om</string>
+    <string name="settings_about_version">versjon %1$s</string>
     <string name="settings_network_name">Nettverk</string>
     <string name="settings_network_options_offline_mode">Offline-modus</string>
     <string name="settings_network_options_offline_mode_off">Bruk Internett til å synkronisere musikk.</string>

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

@@ -13,7 +13,9 @@
     <string name="resources_sort_by_year">ਸਾਲ ਦੁਆਰਾ</string>
     <string name="search_input_placeholder">ਖੋਜੋ</string>
     <string name="settings_about_actions_licenses">ਲਾਇਸੰਸ</string>
+    <string name="settings_about_actions_project_homepage">ਪ੍ਰੋਜੈਕਟ ਹੋਮਪੇਜ</string>
     <string name="settings_about_name">ਬਾਰੇ</string>
+    <string name="settings_about_version">ਸੰਸਕਰਣ %1$s</string>
     <string name="settings_network_name">ਨੈੱਟਵਰਕ</string>
     <string name="settings_network_values_kbps">%1$skbps</string>
     <string name="settings_network_values_unlimited_kbps">ਅਸੀਮਿਤ</string>

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

@@ -21,7 +21,9 @@
     <string name="resources_sort_by_year">Wg roku</string>
     <string name="search_input_placeholder">Szukaj</string>
     <string name="settings_about_actions_licenses">Licencje</string>
+    <string name="settings_about_actions_project_homepage">Strona główna projektu</string>
     <string name="settings_about_name">Informacje o projekcie</string>
+    <string name="settings_about_version">wersja %1$s</string>
     <string name="settings_network_name">Sieć</string>
     <string name="settings_network_options_offline_mode">Tryb offline</string>
     <string name="settings_network_values_kbps">%1$skbps</string>

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

@@ -21,7 +21,10 @@
     <string name="resources_sort_by_year">Por Ano</string>
     <string name="search_input_placeholder">Procurar</string>
     <string name="settings_about_actions_licenses">Licenças</string>
+    <string name="settings_about_actions_project_homepage">Página do Projeto</string>
+    <string name="settings_about_actions_support">Apoie o programador</string>
     <string name="settings_about_name">Acerca</string>
+    <string name="settings_about_version">versão %1$s</string>
     <string name="settings_network_name">Rede</string>
     <string name="settings_network_options_offline_mode">Modo offline</string>
     <string name="settings_network_options_offline_mode_off">Usar a internet para sincronizar música.</string>

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

@@ -31,7 +31,11 @@
     <string name="resources_sort_by_year">По году</string>
     <string name="search_input_placeholder">Поиск</string>
     <string name="settings_about_actions_licenses">Лицензии</string>
+    <string name="settings_about_actions_project_homepage">Сайт проекта</string>
+    <string name="settings_about_actions_share_logs">Поделиться журналами</string>
+    <string name="settings_about_actions_support">Поддержать разработчика</string>
     <string name="settings_about_name">О Subtracks</string>
+    <string name="settings_about_version">версия %1$s</string>
     <string name="settings_network_name">Сеть</string>
     <string name="settings_network_options_offline_mode">Автономный режим</string>
     <string name="settings_network_options_offline_mode_off">Использовать интернет для синхронизации музыки.</string>

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

@@ -29,7 +29,11 @@
     <string name="resources_sort_by_year">Efter år</string>
     <string name="search_input_placeholder">Sök</string>
     <string name="settings_about_actions_licenses">Licenser</string>
+    <string name="settings_about_actions_project_homepage">Projekthemsida</string>
+    <string name="settings_about_actions_share_logs">Dela loggarna</string>
+    <string name="settings_about_actions_support">Stöd utvecklaren</string>
     <string name="settings_about_name">Om</string>
+    <string name="settings_about_version">version %1$s</string>
     <string name="settings_network_name">Nätverk</string>
     <string name="settings_network_options_offline_mode">Offline-läge</string>
     <string name="settings_network_options_offline_mode_off">Använd internet för att uppdatera musik.</string>

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

@@ -29,7 +29,11 @@
     <string name="resources_sort_by_year">ஆண்டு</string>
     <string name="search_input_placeholder">தேடல்</string>
     <string name="settings_about_actions_licenses">உரிமங்கள்</string>
+    <string name="settings_about_actions_project_homepage">திட்ட முகப்புப்பக்கம்</string>
+    <string name="settings_about_actions_share_logs">பதிவுகளைப் பகிரவும்</string>
+    <string name="settings_about_actions_support">டெவலப்பரை ஆதரிக்கவும்</string>
     <string name="settings_about_name">பற்றி</string>
+    <string name="settings_about_version">பதிப்பு %1$s</string>
     <string name="settings_network_name">பிணையம்</string>
     <string name="settings_network_options_offline_mode">இணைப்பில்லாத பயன்முறை</string>
     <string name="settings_network_options_offline_mode_off">இசையை ஒத்திசைக்க இணையத்தைப் பயன்படுத்தவும்.</string>

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

@@ -17,7 +17,6 @@
     <string name="resources_filter_genre">ประเภท</string>
     <string name="resources_filter_starred">ให้ดาว</string>
     <plurals name="resources_song_count">
-        <item quantity="one">%1$d เพลง</item>
         <item quantity="other">%1$d เพลง</item>
     </plurals>
     <string name="resources_sort_by_artist">ศิลปิน</string>
@@ -28,7 +27,11 @@
     <string name="resources_sort_by_year">ปี</string>
     <string name="search_input_placeholder">ค้นหา</string>
     <string name="settings_about_actions_licenses">ใบอนุญาต</string>
+    <string name="settings_about_actions_project_homepage">โฮมเพจของโครงการ</string>
+    <string name="settings_about_actions_share_logs">แบ่งปันล็อกไฟล์</string>
+    <string name="settings_about_actions_support">ให้การสนับสนุนผู้พัฒนา</string>
     <string name="settings_about_name">เกี่ยวกับ</string>
+    <string name="settings_about_version">เวอร์ชั่น %1$s</string>
     <string name="settings_network_name">เคลือข่าย</string>
     <string name="settings_network_options_offline_mode">โหมดอ๊อฟไลน์</string>
     <string name="settings_network_options_offline_mode_off">เปิดใช้อินเตอร์เน็ตเพื่อให้ข้อมูลเพลงเหมือนกัน</string>

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

@@ -29,7 +29,11 @@
     <string name="resources_sort_by_year">Yıla göre</string>
     <string name="search_input_placeholder">Ara</string>
     <string name="settings_about_actions_licenses">Lisanslar</string>
+    <string name="settings_about_actions_project_homepage">Proje Ana Sayfası</string>
+    <string name="settings_about_actions_share_logs">Günlükleri paylaş</string>
+    <string name="settings_about_actions_support">Geliştiriciyi destekleyin</string>
     <string name="settings_about_name">Hakkında</string>
+    <string name="settings_about_version">sürüm %1$s</string>
     <string name="settings_network_name">Ağ</string>
     <string name="settings_network_options_offline_mode">Çevrim dışı mod</string>
     <string name="settings_network_options_offline_mode_off">İnterneti kullanarak müzikleri eşzamanla.</string>

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

@@ -29,7 +29,11 @@
     <string name="resources_sort_by_year">Рік</string>
     <string name="search_input_placeholder">Введіть заголовок/опис</string>
     <string name="settings_about_actions_licenses">Ліцензії</string>
+    <string name="settings_about_actions_project_homepage">Головна сторінка проєкту</string>
+    <string name="settings_about_actions_share_logs">Поділитися журналами</string>
+    <string name="settings_about_actions_support">Підтримайте розробника</string>
     <string name="settings_about_name">Про застосунок</string>
+    <string name="settings_about_version">версія %1$s</string>
     <string name="settings_network_name">Мережа</string>
     <string name="settings_network_options_offline_mode">Автономний режим</string>
     <string name="settings_network_options_offline_mode_off">Використовувати інтернет для синхронізації музики.</string>

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

@@ -10,7 +10,6 @@
     <string name="navigation_tabs_library">Thư viện</string>
     <string name="navigation_tabs_settings">Cài đặt</string>
     <plurals name="resources_album_count">
-        <item quantity="one">%1$d album</item>
         <item quantity="other">%1$d album</item>
     </plurals>
     <string name="resources_filter_album">Theo album</string>
@@ -18,7 +17,6 @@
     <string name="resources_filter_genre">Theo thể loại</string>
     <string name="resources_filter_starred">Theo yêu thích</string>
     <plurals name="resources_song_count">
-        <item quantity="one">%1$d bài hát</item>
         <item quantity="other">%1$d bài hát</item>
     </plurals>
     <string name="resources_sort_by_artist">Nghệ sĩ</string>
@@ -29,7 +27,11 @@
     <string name="resources_sort_by_year">Năm</string>
     <string name="search_input_placeholder">Tìm kiếm</string>
     <string name="settings_about_actions_licenses">Bản quyền</string>
+    <string name="settings_about_actions_project_homepage">Trang chủ dự án</string>
+    <string name="settings_about_actions_share_logs">Chia sẻ log</string>
+    <string name="settings_about_actions_support">Hỗ trợ nhà phát triển</string>
     <string name="settings_about_name">Về ứng dụng</string>
+    <string name="settings_about_version">phiên bản %1$s</string>
     <string name="settings_network_name">Mạng</string>
     <string name="settings_network_options_offline_mode">Chế độ ngoại tuyến</string>
     <string name="settings_network_options_offline_mode_off">Đồng bộ nhạc qua mạng.</string>

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

@@ -1,7 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
-<resources>
+<resources xmlns:tools="http://schemas.android.com/tools">
     <string name="app_name">subtracks</string>
     <string name="download_channel_description">Progress while songs download</string>
+    <string name="sync_notification_channel">Sync</string>
+    <string name="sync_notification_title">Syncing library</string>
+    <string name="sync_notification_text">Keeping your library up to date</string>
 
     <string name="actions_cancel">Cancel</string>
     <string name="actions_delete">Delete</string>
@@ -20,6 +23,7 @@
     <string name="controls_more">More</string>
 
     <string name="navigation_back">Back</string>
+    <string name="scroll_to_top">Scroll to top</string>
     <string name="navigation_tabs_home">Home</string>
     <string name="navigation_tabs_library">Library</string>
     <string name="navigation_tabs_settings">Settings</string>
@@ -56,7 +60,17 @@
     <string name="search_input_placeholder">Search</string>
 
     <string name="settings_about_actions_licenses">Licenses</string>
+    <string name="settings_about_actions_project_homepage">Project homepage</string>
+    <string name="settings_about_actions_share_logs">Share logs</string>
+    <string name="settings_about_actions_support">Support the developer</string>
     <string name="settings_about_name">About</string>
+    <string name="settings_troubleshooting_name">Troubleshooting</string>
+    <string name="settings_about_share_logs_empty">No logs to send yet</string>
+    <string name="settings_about_share_logs_failed">Couldn\'t prepare the logs</string>
+    <string name="settings_about_share_logs_subject">Subtracks logs</string>
+    <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_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>
@@ -124,7 +138,7 @@
     <string name="search">Search</string>
     <string name="search_this_list">Search this list</string>
     <string name="search_songs">Songs</string>
-    <string name="search_min_length">Type at least %1$d characters to search.</string>
+    <string name="search_min_length" tools:ignore="PluralsCandidate">Type at least %1$d characters to search.</string>
     <string name="search_no_results">No results for “%1$s”.</string>
     <string name="sort_by">Sort by</string>
     <string name="sort_ascending">Sort ascending</string>
@@ -190,6 +204,21 @@
     <string name="sync_concurrency">Sync concurrency</string>
     <string name="sync_concurrency_parallel">Parallel server requests while syncing</string>
     <string name="sync_concurrency_sequential">1 (sequential)</string>
+    <string name="settings_sync_auto_title">Sync automatically</string>
+    <string name="sync_mode_off">Off</string>
+    <string name="sync_mode_wifi">Wi-Fi only</string>
+    <string name="sync_mode_always">Always</string>
+    <string name="sync_mode_prompt">When to sync automatically</string>
+    <string name="sync_interval">Automatic sync interval</string>
+    <string name="sync_interval_prompt">How often to sync automatically</string>
+    <plurals name="sync_interval_minutes">
+        <item quantity="one">%1$d minute</item>
+        <item quantity="other">%1$d minutes</item>
+    </plurals>
+    <plurals name="sync_interval_hours">
+        <item quantity="one">%1$d hour</item>
+        <item quantity="other">%1$d hours</item>
+    </plurals>
     <string name="download_quality">Download quality</string>
     <string name="download_over_mobile">Download over mobile data</string>
     <string name="download_network_wifi_and_mobile">Wi-Fi and mobile</string>
@@ -245,7 +274,7 @@
     <string name="error_server_unknown">Unknown error</string>
     <string name="error_server_malformed">Malformed response from the server</string>
     <string name="error_server_truncated">Truncated response from the server</string>
-    <string name="error_library_too_large">Library is too large to sync: it exceeds %1$d rows</string>
+    <string name="error_library_too_large" tools:ignore="PluralsCandidate">Library is too large to sync: it exceeds %1$d rows</string>
     <string name="error_http">HTTP %1$d</string>
 
     <string name="home_section_recently_played_artists">Recently played artists</string>

app/src/main/res/xml/file_paths.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths>
+    <cache-path name="log_dumps" path="log_dumps/" />
+</paths>