05 Xpense

Gradle and the Build System

Xpense Dev Retrospective

What Gradle Actually Does

Writing Kotlin files and XML layouts doesn't produce an APK by itself. Something has to compile every file, process every resource, pull in every dependency, sign the result, and package all of it into one installable file. That something is Gradle.

The Real Structure

Xpense is a single-module project. settings.gradle.kts names the project and includes exactly one module:

rootProject.name = "Xpense"
include(":app")

The top-level build.gradle.kts only declares which plugins exist in the project, without applying them yet:

plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.ksp) apply false
}

The actual work happens in app/build.gradle.kts, where the plugins get applied for real and every setting specific to Xpense lives.

SDK Versions

minSdk 26 means Xpense won't even install on a phone older than Android 8.0. compileSdk 36 is which SDK version the code compiles against. targetSdk 36 is what the app tells Android it was built and tested for, which affects which OS behavior changes actually apply at runtime.

KSP, Not kapt

Room needs an annotation processor to generate the actual database code behind the DAOs at compile time. Xpense uses KSP (Kotlin Symbol Processing) for that, not the older kapt.

implementation("androidx.room:room-runtime:2.7.2")
ksp("androidx.room:room-compiler:2.7.2")
implementation("androidx.room:room-ktx:2.7.2")
implementation("com.google.code.gson:gson:2.10.1")
implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.11.0")

Room's Schema Export

Room can dump a JSON snapshot of the database schema on every build, which is what makes writing correct Migration objects possible later instead of guessing.

ksp {
    arg("room.schemaLocation", "$projectDir/schemas")
}

buildFeatures and the BuildConfig Surprise

AboutActivity reads BuildConfig.VERSION_NAME to show the app version. That used to be generated automatically for free. AGP 9.2.1, which Xpense is on, turns it off by default.

buildFeatures {
    buildConfig = true
}

Without that line, referencing BuildConfig.VERSION_NAME just fails to compile. It isn't a rare edge case, it's the default on any recent AGP version.

Debug and Release Are Genuinely Different Apps

Minification and What proguard-rules.pro Actually Protects

Release builds run R8, which strips unused code and renames classes to shrink the APK. Left unchecked, this can break reflection-based libraries like Room and Gson, which is exactly what proguard rules exist to prevent.

-keepattributes Signature
-keepattributes *Annotation*
-keep class com.hassanbukhari.xpense.data.BackupData { *; }
-keep class com.hassanbukhari.xpense.data.Expense { *; }
-keep class com.hassanbukhari.xpense.data.Category { *; }
-keep class com.hassanbukhari.xpense.data.*_Impl { *; }

-keep,allowobfuscation,allowshrinking class com.google.gson.reflect.TypeToken
-keep,allowobfuscation,allowshrinking class * extends com.google.gson.reflect.TypeToken

The first block keeps the data classes and Room's generated *_Impl classes intact, since Room and Gson both rely on reflecting over field names, and a renamed field silently breaks serialization instead of throwing an obvious error. The last two lines exist because of something that actually went wrong in production, R8 was silently stripping Gson's TypeToken generic signatures, which broke the legacy JSON migration. That story gets its own post later in this series.

Signing Config, Kept Out of the Repo

signingConfigs {
    create("release") {
        val keystorePropertiesFile = rootProject.file("keystore.properties")
        val keystoreProperties = Properties()
        if (keystorePropertiesFile.exists()) {
            keystoreProperties.load(FileInputStream(keystorePropertiesFile))
            storeFile = rootProject.file(keystoreProperties["storeFile"] as String)
            storePassword = keystoreProperties["storePassword"] as String
            keyAlias = keystoreProperties["keyAlias"] as String
            keyPassword = keystoreProperties["keyPassword"] as String
        }
    }
}

Closing

Gradle turns all of this into the actual APK. Next up, how the screens themselves are described in the first place: Layouts and XML UI.