grain.social/grain-android
1 collaborator
- 1 collaborator
0
1
import org.gradle.testing.jacoco.plugins.JacocoTaskExtension
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
import java.io.FileInputStream
import java.util.Properties
plugins {
alias(libs.plugins.android.application)
alias(libs.plugins.kotlin.compose)
alias(libs.plugins.kotlin.serialization)
alias(libs.plugins.ksp)
alias(libs.plugins.hilt)
jacoco
}
// Firebase config for push, kept out of the repo like the upload key. Absent
// on a fresh clone and on CI, in which case the plugin is skipped and the app
// builds without push rather than failing — PushManager checks at runtime
// whether Firebase actually initialized and no-ops when it didn't.
//
// It lives under src/release because the debug variant's application id carries
// a `.debug` suffix, and the plugin fails outright on a config with no client
// for the id being built. Scoping it to release leaves debug with no config at
// all, which the WARN strategy below turns from an error into a line of build
// output — debug builds get no push, which is what they got before Firebase
// existed here.
val googleServicesFile = file("src/release/google-services.json")
if (googleServicesFile.exists()) {
apply(plugin = "com.google.gms.google-services")
extensions.configure<com.google.gms.googleservices.GoogleServicesPlugin.GoogleServicesPluginConfig>(
"googleServices",
) {
missingGoogleServicesStrategy =
com.google.gms.googleservices.GoogleServicesPlugin.MissingGoogleServicesStrategy.WARN
}
}
// Upload-key credentials, kept out of the repo. Absent on a fresh clone and on
// CI, in which case release builds are simply left unsigned rather than failing.
val keystorePropertiesFile = rootProject.file("keystore.properties")
val keystoreProperties = Properties().apply {
if (keystorePropertiesFile.exists()) {
FileInputStream(keystorePropertiesFile).use { load(it) }
}
}
// Whether this build is being made to measure coverage. See buildTypes.debug.
val coverageBuild = providers.gradleProperty("coverage").isPresent
android {
namespace = "social.grain"
compileSdk = 37
defaultConfig {
applicationId = "social.grain"
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
minSdk = 26
targetSdk = 36
// Must increase on every upload, including builds that never ship.
versionCode = 15
versionName = "0.8.0"
vectorDrawables.useSupportLibrary = true
// The grain-serve a build talks to. The client ID, the OAuth redirect
// scheme (the host reversed) and the proxy target all follow it, so
// `oauthScheme`, which the manifest registers, has to match it.
buildConfigField("String", "SERVER_URL", "\"https://grain.social\"")
manifestPlaceholders["oauthScheme"] = "social.grain"
}
signingConfigs {
create("release") {
if (keystoreProperties.isNotEmpty()) {
storeFile = rootProject.file(keystoreProperties.getProperty("storeFile"))
storePassword = keystoreProperties.getProperty("storePassword")
keyAlias = keystoreProperties.getProperty("keyAlias")
keyPassword = keystoreProperties.getProperty("keyPassword")
}
}
}
buildTypes {
debug {
applicationIdSuffix = ".debug"
// A debug install sits beside a release one and registers the same
// `grain://oauth` callback, so the system's "open with" chooser
// lists both. Two entries reading "Grain" is a coin flip that sends
// a sign-in back to the wrong app; this is what tells them apart.
manifestPlaceholders["appLabel"] = "Grain debug"
// Coverage is measured on debug: it is the only variant the tests
// run against, and JaCoCo's instrumentation and R8 are a bad pair —
// release shrinks away the very code the report wants to name.
//
// Off unless `-Pcoverage` is passed, because
// `enableAndroidTestCoverage` instruments the *app* APK, not just
// the test one — leaving it on puts the JaCoCo runtime and a probe
// in every branch of the debug build that `just emulator` installs
// for the two-minute iteration loop. `just coverage` passes the
// flag. Toggling it recompiles, which is the price of not paying
// for coverage on every unrelated install.
//
// `enableUnitTestCoverage` is deliberately *not* set: see the
// JacocoTaskExtension block below for why the JVM half is measured
// with the agent instead.
enableAndroidTestCoverage = coverageBuild
}
// A debug build against next.grain.social, the grain-serve deploy
// beside production, installed beside the other two.
create("next") {
initWith(getByName("debug"))
applicationIdSuffix = ".next"
matchingFallbacks += listOf("debug")
manifestPlaceholders["appLabel"] = "Grain next"
manifestPlaceholders["oauthScheme"] = "social.grain.next"
buildConfigField("String", "SERVER_URL", "\"https://next.grain.social\"")
}
release {
manifestPlaceholders["appLabel"] = "@string/app_name"
// This is the *upload* key, not the app signing key. Google holds
// the latter under Play App Signing and re-signs each release, so
// losing this one is recoverable through Play support.
signingConfig = signingConfigs.getByName("release").takeIf {
keystoreProperties.isNotEmpty()
}
isMinifyEnabled = true
isShrinkResources = true
proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
}
}
compileOptions {
sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17
}
buildFeatures {
compose = true
buildConfig = true
}
packaging {
resources.excludes += "/META-INF/{AL2.0,LGPL2.1}"
}
testOptions {
unitTests {
// android.jar's stubs throw by default, so a unit test that only
// brushes past `android.util.Log` on an error path fails for that
// and nothing else. Returning defaults keeps those paths testable
// off a device; anything that needs a real Android behaviour still
// belongs in androidTest.
isReturnDefaultValues = true
// Robolectric reads the merged manifest and the resource table, so
// a unit test can inflate a theme and read a string the same way
// the app does.
isIncludeAndroidResources = true
}
}
// The runtime AGP packages into the instrumented APK. Pinned to the same
// version as the `jacoco` block below so the `.ec` files it writes are
// readable by the report task.
testCoverage {
jacocoVersion = libs.versions.jacoco.get()
}
}
jacoco {
toolVersion = libs.versions.jacoco.get()
}
/**
* Coverage for the JVM half, measured with the JaCoCo agent rather than AGP's
* `enableUnitTestCoverage`.
*
* That flag instruments the class files ahead of time, and the unit tests here
* run under Robolectric — which loads the app's classes in its own sandbox
* classloader, re-instrumenting them on the way in. The probes survive but
* report to a copy of the JaCoCo runtime living inside the sandbox, which
* nothing ever dumps: every Robolectric test contributed exactly nothing to the
* report, silently, while the handful of plain-JVM tests still showed up.
*
* The agent transforms whatever the JVM defines, sandbox classloader included,
* and keeps its runtime in the system loader where the dump can find it.
*/
tasks.withType<Test>().configureEach {
extensions.configure(JacocoTaskExtension::class.java) {
isEnabled = coverageBuild
// Robolectric's loader defines classes with no source location, which
// the agent skips by default — and skipping them is the same silent
// empty report by another route.
isIncludeNoLocationClasses = true
excludes = listOf("jdk.internal.*")
}
}
// AGP 9 compiles Kotlin itself, so the JVM target moves out of the removed
// android.kotlinOptions block and onto the Kotlin extension.
kotlin {
compilerOptions {
jvmTarget.set(JvmTarget.JVM_17)
}
}
dependencies {
implementation(libs.androidx.core.ktx)
implementation(libs.androidx.lifecycle.runtime.ktx)
implementation(libs.androidx.lifecycle.viewmodel.compose)
implementation(libs.androidx.activity.compose)
implementation(platform(libs.androidx.compose.bom))
implementation(libs.androidx.ui)
implementation(libs.androidx.ui.graphics)
implementation(libs.androidx.ui.tooling.preview)
implementation(libs.androidx.material3)
// NavigationSuiteScaffold picks the bottom bar / nav rail / drawer for the
// window it finds itself in; `adaptive` supplies currentWindowAdaptiveInfo.
implementation(libs.androidx.material3.adaptive.navigation.suite)
implementation(libs.androidx.adaptive)
// The ~50 icon core set only. `material-icons-extended` is frozen at 1.7.8
// and carries thousands of vectors this app never draws; the two dozen it
// does use that aren't here are vendored in ui/icons + res/drawable.
implementation(libs.androidx.material.icons.core)
debugImplementation(libs.androidx.ui.tooling)
implementation(libs.androidx.navigation.compose)
implementation(libs.androidx.browser)
implementation(libs.androidx.exifinterface)
implementation(libs.androidx.camera.core)
implementation(libs.androidx.camera.camera2)
implementation(libs.androidx.camera.lifecycle)
implementation(libs.androidx.camera.compose)
implementation(libs.h3)
// MapLibre, drawing grain's own Protomaps basemap — the same tiles as
// grain.social, no API key and no Play services. See assets/basemap.
implementation(libs.maplibre.compose)
implementation(platform(libs.firebase.bom))
implementation(libs.firebase.messaging)
implementation(libs.hilt.android)
implementation(libs.hilt.navigation.compose)
ksp(libs.hilt.compiler)
implementation(libs.kotlinx.serialization.json)
implementation(libs.okhttp)
implementation(libs.okhttp.logging)
implementation(libs.coil.compose)
implementation(libs.coil.network.okhttp)
testImplementation(libs.junit)
testImplementation(libs.kotlinx.coroutines.test)
testImplementation(libs.robolectric)
testImplementation(libs.androidx.test.core)
testImplementation(libs.androidx.junit)
testImplementation(platform(libs.androidx.compose.bom))
testImplementation(libs.androidx.ui.test.junit4)
testImplementation(libs.androidx.ui.test.manifest)
androidTestImplementation(libs.androidx.junit)
androidTestImplementation(libs.androidx.test.runner)
androidTestImplementation(platform(libs.androidx.compose.bom))
androidTestImplementation(libs.androidx.ui.test.junit4)
debugImplementation(libs.androidx.ui.test.manifest)
}
// MARK: - Coverage
//
// Neither half of the test suite writes a report — only raw execution data, of
// two different kinds in two different places: an `.exec` the JaCoCo agent
// dumps from the JVM tests, and an `.ec` per connected device from the
// instrumented run. This task is what merges them.
//
// Both are optional inputs, deliberately. `testDebugUnitTest` alone produces an
// honest report — the screens run under Robolectric, so the JVM half covers
// nearly everything — and a clean tree with neither file gives a 0% report
// rather than a build failure.
val coverageExclusions = listOf(
// Android's own generated resource and manifest plumbing.
"**/R.class", "**/R$*.class", "**/BuildConfig.*", "**/Manifest*.*",
// Hilt/Dagger. KSP emits a component, a module wrapper and a factory per
// injection site; counting them scores the annotation processor, not us.
"**/*_Factory*.*", "**/*_MembersInjector*.*", "**/*_HiltModules*.*",
"**/Dagger*.*", "**/Hilt_*.*", "**/*_Hilt*.*", "**/hilt_aggregated_deps/**",
"**/*_GeneratedInjector*.*", "**/*_ComponentTreeDeps*.*",
// The aggregating sentinels Hilt emits into its own package rather than
// ours; they carry no name of ours to match the patterns above.
"dagger/hilt/internal/**",
// kotlinx.serialization's generated `$serializer` objects — machine-written
// encode/decode loops whose branches no test will ever walk exhaustively.
"**/*\$\$serializer.*",
// Compose lifts every non-capturing lambda in a file into one synthetic
// ComposableSingletons class. It is generated, and it is enormous.
"**/ComposableSingletons*.*",
// @Preview functions exist to be looked at in Studio, not run.
"**/Previews*.*",
)
// AGP 9 compiles Kotlin itself rather than delegating to a separate
// `compileDebugKotlin`, so the classes land under `intermediates`, not the
// `tmp/kotlin-classes/debug` that every pre-9 JaCoCo recipe on the internet
// points at. Both are listed: the stale path simply contributes nothing on
// AGP 9, and keeps this working if a future version moves back.
val coverageClassDirs = listOf(
"tmp/kotlin-classes/debug",
"intermediates/classes/debug/transformDebugClassesWithAsm/dirs",
"intermediates/javac/debug/classes",
)
/**
* What both coverage tasks measure, applied to each of them.
*
* Shared so the gate and the report can never disagree: a rule that fails on a
* number the report doesn't show is a rule nobody can act on.
*
* The ordering is the subtle half. Neither task *depends* on a test task —
* both read whatever execution data is on disk, which is what lets one run
* grade the JVM half and another the merged pair. But when a test task is in
* the same invocation, which is the normal way to run these, it has to go
* first: without this the report came out grading the previous run, and Gradle
* failed the build outright once the gate was added beside it.
*/
fun JacocoReportBase.useGrainCoverageData() {
// The classes being measured have to be compiled before anything measures
// them. `matching` rather than a name, so a build that never configures the
// task isn't broken by referring to it.
dependsOn(tasks.matching { it.name == "transformDebugClassesWithAsm" })
mustRunAfter(
tasks.matching {
it.name == "testDebugUnitTest" || it.name == "connectedDebugAndroidTest"
},
)
classDirectories.setFrom(
files(coverageClassDirs.map { dir ->
fileTree(layout.buildDirectory.dir(dir)) { exclude(coverageExclusions) }
}),
)
sourceDirectories.setFrom(files("src/main/java"))
// Globbed rather than named. The instrumented run writes its `.ec` under a
// directory named for the device it ran on, so the path is not knowable
// until a device exists.
executionData.setFrom(
fileTree(layout.buildDirectory) {
include(
// The agent's own output, for the JVM half.
"jacoco/*.exec",
// Where AGP files it when `enableUnitTestCoverage` is on, kept
// so a report still merges cleanly if that is ever turned back on.
"outputs/unit_test_code_coverage/**/*.exec",
"outputs/code_coverage/**/*.ec",
)
},
)
}
tasks.register<JacocoReport>("coverageReport") {
group = "verification"
description = "Merges unit-test and instrumented coverage into one HTML/XML report."
useGrainCoverageData()
reports {
html.required = true
xml.required = true
csv.required = false
}
doLast {
val report = reports.html.outputLocation.get().asFile.resolve("index.html")
logger.lifecycle("Coverage report: file://$report")
}
}
/**
* The gate. Fails the build when line coverage drops below the bar.
*
* Line rather than branch: branch coverage sits around 60%, and most of what it
* counts in a Compose codebase is the null checks and default-argument masks
* the compiler writes, not decisions anyone made. Gating on that would be
* gating on the compiler.
*/
tasks.register<JacocoCoverageVerification>("coverageVerification") {
group = "verification"
description = "Fails when line coverage falls below the agreed floor."
useGrainCoverageData()
// JacocoCoverageVerification ships an `onlyIf` that skips the whole task
// when it finds no execution data, which turns "the tests never ran" into a
// passing gate — the one failure a gate exists to catch. Replaced with a
// check that says so instead.
setOnlyIf("always, so a missing run fails rather than skips") { true }
doFirst {
check(!executionData.isEmpty) {
"No coverage execution data under ${layout.buildDirectory.get()}. " +
"Run the tests with -Pcoverage first — a gate that passes " +
"because nothing ran is worse than no gate at all."
}
}
violationRules {
rule {
limit {
counter = "LINE"
value = "COVEREDRATIO"
// The JVM half alone measures 81%. The bar is the target rather
// than the high-water mark: a point of slack absorbs a screen
// landing before its test without turning the gate into
// something people learn to re-run.
minimum = "0.80".toBigDecimal()
}
}
}
}