ADFA-4128 (11/11): app + bench — wiring Quick Build into the IDE and the benchmark harness

app/build.gradle.kts

@@ -3,6 +3,7 @@
 import com.itsaky.androidide.build.config.BuildConfig
 import com.itsaky.androidide.desugaring.utils.JavaIOReplacements.applyJavaIOReplacements
 import com.itsaky.androidide.plugins.AndroidIDEAssetsPlugin
+import com.itsaky.androidide.plugins.tasks.AddFileToAssetsTask
 import org.adfa.constants.GRADLE_API_NAME_JAR_BR
 import org.adfa.constants.GRADLE_API_NAME_JAR_ZIP
 import org.adfa.constants.GRADLE_DISTRIBUTION_ARCHIVE_NAME
@@ -204,6 +205,46 @@ android {
 	}
 }
 
+// DoD coverage gate. Two path traps are baked in below; both fail silently rather
+// than erroring, so each is spelled out here to stop the next measurement repeating one.
+//
+// executionData: the root build attaches the jacoco agent to every Test task, but for an
+// Android module the exec lands under outputs/unit_test_code_coverage/<variant>UnitTest/,
+// not build/jacoco/. A report pointed at build/jacoco/ SKIPs and measures nothing.
+//
+// classDirectories: :app runs transformV8DebugClassesWithAsm, so the bytecode the tests
+// executed is NOT tmp/kotlin-classes/v8Debug. That path is right for the quickbuild
+// modules (they run no ASM transform) and wrong here: measured 2026-09-10 it makes 138
+// classes report "Execution data ... does not match" and count as fully uncovered, which
+// reads as a real coverage hole rather than a misconfiguration. The transformed dirs
+// below give 0 mismatches.
+tasks.register<JacocoReport>("jacocoTestReport") {
+	group = "verification"
+	description = "JaCoCo line+branch coverage for the v8Debug unit tests."
+	dependsOn("testV8DebugUnitTest")
+
+	reports {
+		xml.required.set(true)
+		html.required.set(true)
+	}
+
+	classDirectories.setFrom(
+		fileTree(
+			layout.buildDirectory.dir(
+				"intermediates/classes/v8Debug/transformV8DebugClassesWithAsm/dirs",
+			),
+		) {
+			exclude("**/BuildConfig*")
+		},
+	)
+	sourceDirectories.setFrom(files("src/main/java"))
+	executionData.setFrom(
+		layout.buildDirectory.file(
+			"outputs/unit_test_code_coverage/v8DebugUnitTest/testV8DebugUnitTest.exec",
+		),
+	)
+}
+
 // Sentry gradle plugin config (crash reporting to GlitchTip).
 sentry {
 	includeProguardMapping = false
@@ -404,6 +445,7 @@ dependencies {
 	implementation(projects.floatingWindow)
 	implementation(projects.gitCore)
 	implementation(projects.profiler)
+	implementation(projects.quickbuild.core)
 
 	// This is to build the tooling-api-impl project before the app is built
 	// So we always copy the latest JAR file to assets
@@ -457,6 +499,69 @@ dependencies {
 	coreLibraryDesugaring(libs.desugar.jdk.libs.v215)
 }
 
+// Quick Build (ADFA-4128): stage the runtime AAR + daemon (jar + runtime classpath)
+// into APK assets, mirroring the LogSender AAR flow in AndroidIDEAssetsPlugin. The
+// artifacts are extracted to <ANDROIDIDE_HOME>/quickbuild/ at session start
+// (QuickBuildArtifactStager).
+evaluationDependsOn(":quickbuild:runtime")
+evaluationDependsOn(":quickbuild:daemon")
+
+val quickBuildDaemonZip =
+	tasks.register<Zip>("quickBuildDaemonZip") {
+		archiveFileName.set("quickbuild-daemon.zip")
+		destinationDirectory.set(layout.buildDirectory.dir("intermediates/quickbuild"))
+		val daemonProject = rootProject.project(":quickbuild:daemon")
+		dependsOn(daemonProject.tasks.named("daemonJar"))
+		from(daemonProject.tasks.named("daemonJar"))
+		// The daemon jar's manifest Class-Path names these by file name; they must sit
+		// next to the jar after extraction.
+		from(daemonProject.configurations.named("runtimeClasspath"))
+		// Compose compiler plugin, version-matched to the daemon's compiler; the stable
+		// name is the contract EnvironmentQuickBuildPaths.composeCompilerPlugin reads.
+		from(daemonProject.configurations.named("composeCompilerPlugin")) {
+			rename { "compose-compiler-plugin.jar" }
+		}
+	}
+
+androidComponents.onVariants { variant ->
+	val variantName = variant.name.replaceFirstChar(Char::uppercaseChar)
+	val flavorName = variant.flavorName!!
+
+	val copyRuntimeAar =
+		tasks.register<AddFileToAssetsTask>("copy${variantName}QuickBuildRuntimeAar") {
+			val runtimeProject = rootProject.project(":quickbuild:runtime")
+			dependsOn(
+				runtimeProject.tasks.named(
+					"assemble${flavorName.replaceFirstChar(Char::uppercaseChar)}Release",
+				),
+			)
+			inputFile.set(
+				runtimeProject.layout.buildDirectory.file(
+					"outputs/aar/quickbuild-runtime-$flavorName-release.aar",
+				),
+			)
+			baseAssetsPath.set("data/common")
+			// Flavor-agnostic asset name: the runtime AAR is pure Java, both flavors
+			// produce identical bits, and the stager doesn't need to care.
+			fileName.set("quickbuild-runtime.aar")
+		}
+	variant.sources.assets?.addGeneratedSourceDirectory(
+		copyRuntimeAar,
+		AddFileToAssetsTask::outputDirectory,
+	)
+
+	val copyDaemonZip =
+		tasks.register<AddFileToAssetsTask>("copy${variantName}QuickBuildDaemonZip") {
+			dependsOn(quickBuildDaemonZip)
+			inputFile.set(quickBuildDaemonZip.flatMap { it.archiveFile })
+			baseAssetsPath.set("data/common")
+		}
+	variant.sources.assets?.addGeneratedSourceDirectory(
+		copyDaemonZip,
+		AddFileToAssetsTask::outputDirectory,
+	)
+}
+
 tasks.register("downloadDocDb") {
 	doLast {
 		val githubRepo = "appdevforall/OfflineDocumentationTools"

app/src/androidTest/kotlin/com/itsaky/androidide/OrderedTestSuite.kt

@@ -5,7 +5,10 @@ import org.junit.runners.Suite
 
 @RunWith(Suite::class)
 @Suite.SuiteClasses(
-    CleanupTest::class,
-    EndToEndTest::class,
+	CleanupTest::class,
+	EndToEndTest::class,
+	QuickBuildPipelineTest::class,
+	QuickBuildSmokeTest::class,
+	QuickBuildFlagOffTest::class,
 )
 class OrderedTestSuite

app/src/androidTest/kotlin/com/itsaky/androidide/QuickBuildFlagOffTest.kt

@@ -0,0 +1,92 @@
+package com.itsaky.androidide
+
+import androidx.test.core.app.ActivityScenario
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.itsaky.androidide.activities.SplashActivity
+import com.itsaky.androidide.activities.editor.EditorHandlerActivity
+import com.itsaky.androidide.app.configuration.IJdkDistributionProvider
+import com.itsaky.androidide.helper.isExperimentsFlagSet
+import com.itsaky.androidide.helper.setExperimentsFlagForTest
+import com.itsaky.androidide.helper.waitForMainHomeOrEditorUi
+import com.itsaky.androidide.screens.QuickBuildScreen.assertQuickBuildButtonAbsent
+import com.itsaky.androidide.screens.QuickBuildScreen.assertQuickBuildButtonShown
+import com.itsaky.androidide.utils.EditorActivityActions
+import com.kaspersky.kaspresso.testcases.api.testcase.TestCase
+import org.junit.Test
+import org.junit.runner.RunWith
+
+private const val TOOLBAR_TIMEOUT_MS = 15_000L
+
+/**
+ * The shipping-state gate for Quick Build (ADFA-4128, manual test T13): with no
+ * `CodeOnTheGo.exp` flag file on the device, the feature must be invisible.
+ *
+ * The gate is a single read of [com.itsaky.androidide.utils.FeatureFlags.isExperimentsEnabled]
+ * at [EditorActivityActions.register], so this drives that decision directly instead of
+ * restarting the process: flip the flag, re-register, rebuild the toolbar, look. That also
+ * makes the test honest about what it covers - the registration site, not the process-start
+ * caching around it.
+ *
+ * Both directions run in one test on purpose. An absence assertion alone passes when the
+ * accessibility selector rots or the toolbar simply never rendered, so the flag-on step
+ * ahead of it is load-bearing, not decoration.
+ *
+ * Runs after [QuickBuildSmokeTest] in [OrderedTestSuite], which leaves the editor open on a
+ * synced project - this test needs a populated editor toolbar and creates no project of its
+ * own.
+ */
+@RunWith(AndroidJUnit4::class)
+class QuickBuildFlagOffTest : TestCase() {
+	private var hadExperimentsFlag = false
+
+	@Test
+	fun test_noExperimentsFlagHidesQuickBuild() =
+		before {
+			// A dev device may legitimately have experiments enabled; restore whatever
+			// state this test found.
+			hadExperimentsFlag = isExperimentsFlagSet()
+			IJdkDistributionProvider.getInstance().loadDistributions()
+		}.after {
+			setExperimentsFlagForTest(hadExperimentsFlag)
+			// Leave the toolbar matching the restored flag so a later test does not
+			// inherit this one's registry.
+			runCatching { rebuildEditorToolbar() }
+		}.run {
+			step("Launch app") {
+				ActivityScenario.launch(SplashActivity::class.java)
+				waitForMainHomeOrEditorUi(device.uiDevice)
+			}
+
+			step("Experiments on: the toolbar carries Quick Build") {
+				setExperimentsFlagForTest(true)
+				rebuildEditorToolbar()
+				assertQuickBuildButtonShown(TOOLBAR_TIMEOUT_MS)
+			}
+
+			step("Experiments off: the toolbar drops Quick Build") {
+				setExperimentsFlagForTest(false)
+				rebuildEditorToolbar()
+				assertQuickBuildButtonAbsent(TOOLBAR_TIMEOUT_MS)
+			}
+		}
+
+	/**
+	 * Re-runs action registration and repopulates the toolbar, which is what an editor
+	 * launch does. On the main thread: both touch the actions registry and the toolbar
+	 * views.
+	 */
+	private fun rebuildEditorToolbar() {
+		val instrumentation = InstrumentationRegistry.getInstrumentation()
+		val activity = resumedEditorActivity()
+		instrumentation.runOnMainSync {
+			EditorActivityActions.register(activity)
+			activity.prepareOptionsMenu()
+		}
+		instrumentation.waitForIdleSync()
+	}
+
+	private fun resumedEditorActivity(): EditorHandlerActivity =
+		device.activities.getResumed() as? EditorHandlerActivity
+			?: error("Resumed activity is not the editor; this test needs an open project")
+}