ADFA-4128 (10/11): gradle-plugin — generating the proxy app

gradle-plugin/build.gradle.kts

@@ -20,6 +20,7 @@
 import com.itsaky.androidide.build.config.AGP_VERSION_MINIMUM
 import com.itsaky.androidide.build.config.BuildConfig
 import com.itsaky.androidide.build.config.ProjectConfig
+import org.gradle.api.file.SourceDirectorySet
 
 plugins {
 	id("org.jetbrains.kotlin.jvm")
@@ -28,8 +29,40 @@ plugins {
 
 description = "Gradle Plugin for projects that are built with AndroidIDE"
 
+// The functional tests run a real Gradle build against this repo's own plugins, so those
+// have to be staged into build-local maven repos first, and their locations handed to the
+// harness through repos.txt. Wired here rather than in build-logic because a
+// projectsEvaluated sweep silently misses projects under configure-on-demand.
+val mavenLocalStagingProjects = listOf(":logsender", ":logger", ":build-info")
+
 tasks.named<Test>("test") {
 	useJUnitPlatform()
+
+	val stagedRepos =
+		mavenLocalStagingProjects.map { path ->
+			dependsOn("$path:publishAllPublicationsToBuildMavenLocalRepository")
+			project(path)
+				.layout.buildDirectory
+				.dir("maven-local")
+				.get()
+				.asFile.absolutePath
+		}
+	val reposFile =
+		layout.buildDirectory
+			.file("maven-local/repos.txt")
+			.get()
+			.asFile
+
+	// Without these the staged repos are invisible to the input snapshot, so `test` reports
+	// UP-TO-DATE after a republish and the TestKit builds that resolve through repos.txt
+	// never run.
+	inputs.files(stagedRepos).withPropertyName("stagedMavenLocalRepos")
+	outputs.file(reposFile).withPropertyName("stagedMavenLocalReposFile")
+
+	doFirst {
+		reposFile.parentFile.mkdirs()
+		reposFile.writeText(stagedRepos.joinToString(separator = File.pathSeparator))
+	}
 }
 
 configurations {
@@ -52,8 +85,13 @@ dependencies {
 	implementation(projects.gradlePluginConfig)
 	implementation(projects.buildInfo)
 
-	// use the AGP APIs from the minimum supported AGP version
-	add("androidBuildTool", "com.android.tools.build:gradle:${AGP_VERSION_MINIMUM}")
+	// Quick Build (ADFA-4128) needs the ScopedArtifacts API (AGP 7.4+) and the D8 API
+	// shipped inside AGP's builder artifact, so this module compiles against the repo's
+	// AGP instead of AGP_VERSION_MINIMUM. Projects on older AGPs are unaffected at
+	// runtime: QuickBuildPlugin's classes load only when quick build is enabled, and the
+	// other plugins stick to APIs that exist since the minimum supported version - a
+	// claim the minAgpCheck guard below keeps honest by recompiling them against it.
+	add("androidBuildTool", libs.android.gradle.plugin)
 
 	testImplementation(gradleTestKit())
 	testImplementation(libs.tests.junit.jupiter)
@@ -63,6 +101,36 @@ dependencies {
 	testRuntimeOnly(libs.tests.junit.platformLauncher)
 }
 
+// Min-AGP compatibility guard (restored after review). The main compile moved to the repo's
+// AGP for Quick Build (above), which deleted the old red light: an innocent AGP-8-only API
+// in LogSenderPlugin or AndroidIDEGradlePlugin would compile green and then fail every user
+// project on an older AGP at configuration time, with Quick Build off. This source set
+// recompiles the non-Quick-Build sources against AGP_VERSION_MINIMUM so that mistake goes
+// red in `check`. The Quick Build sources are excluded on purpose: they genuinely need the
+// newer AGP and only load when quick build is enabled (AndroidIDEGradlePlugin applies
+// QuickBuildPlugin by name, not by class literal, to keep this compile honest).
+val minAgpCheck: SourceSet =
+	sourceSets.create("minAgpCheck") {
+		java.setSrcDirs(emptyList<String>())
+		resources.setSrcDirs(emptyList<String>())
+	}
+(minAgpCheck.extensions.getByName("kotlin") as SourceDirectorySet).apply {
+	setSrcDirs(listOf("src/main/java"))
+	exclude("**/QuickBuildPlugin.kt", "**/quickbuild/**")
+}
+
+dependencies {
+	"minAgpCheckCompileOnly"(gradleApi())
+	"minAgpCheckCompileOnly"("com.android.tools.build:gradle:$AGP_VERSION_MINIMUM")
+	"minAgpCheckImplementation"(libs.composite.constants)
+	"minAgpCheckImplementation"(projects.gradlePluginConfig)
+	"minAgpCheckImplementation"(projects.buildInfo)
+}
+
+tasks.named("check") {
+	dependsOn(tasks.named("minAgpCheckClasses"))
+}
+
 gradlePlugin {
 	website.set(ProjectConfig.REPO_URL)
 	vcsUrl.set(ProjectConfig.REPO_URL)
@@ -100,3 +168,18 @@ tasks.named<Jar>("jar") {
 	archiveClassifier.set("") // Removes the default "all" classifier
 	archiveVersion.set("")
 }
+
+// Coverage REPORTING only - no verification gate is wired here. This JVM
+// module keeps the default build/jacoco/test.exec location; the report just
+// needs xml enabled (for tooling to read the percentages) and the explicit
+// test dependency so `:gradle-plugin:jacocoTestReport` is runnable on its own.
+// The percentages under-count: the TestKit-driven tests exercise the plugin in
+// a separate Gradle JVM this JaCoCo run does not instrument. Test failures do
+// not block the report: the root build sets ignoreFailures on every Test task.
+tasks.named<JacocoReport>("jacocoTestReport") {
+	dependsOn(tasks.named("test"))
+	reports {
+		xml.required.set(true)
+		html.required.set(true)
+	}
+}

gradle-plugin/src/main/java/com/itsaky/androidide/gradle/AndroidIDEGradlePlugin.kt

@@ -19,6 +19,7 @@ package com.itsaky.androidide.gradle
 import com.itsaky.androidide.tooling.api.GradlePluginConfig.PROPERTY_JDWP_ENABLED
 import com.itsaky.androidide.tooling.api.GradlePluginConfig.PROPERTY_LOG_SENDER_ENABLED
 import com.itsaky.androidide.tooling.api.GradlePluginConfig.PROPERTY_PROFILEABLE_ENABLED
+import com.itsaky.androidide.tooling.api.GradlePluginConfig.PROPERTY_QUICK_BUILD_ENABLED
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.logging.Logging
@@ -31,6 +32,15 @@ import org.gradle.api.logging.Logging
 class AndroidIDEGradlePlugin : Plugin<Project> {
 	companion object {
 		private val logger = Logging.getLogger(AndroidIDEGradlePlugin::class.java)
+
+		/**
+		 * QuickBuildPlugin's FQN, applied reflectively below so this file carries no
+		 * compile-time reference to it: the minAgpCheck guard (see build.gradle.kts)
+		 * recompiles every non-Quick-Build source against AGP_VERSION_MINIMUM, and only
+		 * the Quick Build sources are allowed newer AGP APIs. Pinned to the real class by
+		 * `QuickBuildPluginTest`.
+		 */
+		internal const val QUICK_BUILD_PLUGIN_CLASS = "com.itsaky.androidide.gradle.QuickBuildPlugin"
 	}
 
 	override fun apply(target: Project) {
@@ -53,6 +63,13 @@ class AndroidIDEGradlePlugin : Plugin<Project> {
 			if (isProfileableEnabled) {
 				pluginManager.apply(ProfilerPlugin::class.java)
 			}
+
+			val isQuickBuildEnabled = findProperty(PROPERTY_QUICK_BUILD_ENABLED) == "true"
+			if (isQuickBuildEnabled) {
+				// By name, not ::class: Quick Build classes load (and touch newer AGP APIs)
+				// only when the property enables them - see QUICK_BUILD_PLUGIN_CLASS.
+				pluginManager.apply(Class.forName(QUICK_BUILD_PLUGIN_CLASS))
+			}
 		}
 	}
 }

gradle-plugin/src/main/java/com/itsaky/androidide/gradle/AndroidIDEInitScriptPlugin.kt

@@ -18,11 +18,14 @@
 package com.itsaky.androidide.gradle
 
 import com.itsaky.androidide.buildinfo.BuildInfo
-import org.adfa.constants.ANDROIDIDE_HOME
+import org.adfa.constants.COGO_GRADLE_PLUGIN_JAR_NAME
+import org.adfa.constants.COGO_GRADLE_PLUGIN_PATH
+import org.gradle.api.GradleException
 import org.gradle.api.Plugin
 import org.gradle.api.invocation.Gradle
 import org.gradle.api.logging.Logging
 import java.io.File
+import java.net.URLClassLoader
 
 const val MAX_LOGFILE_COUNT = 2
 
@@ -34,6 +37,32 @@ const val MAX_LOGFILE_COUNT = 2
 class AndroidIDEInitScriptPlugin : Plugin<Gradle> {
 	companion object {
 		private val logger = Logging.getLogger(AndroidIDEInitScriptPlugin::class.java)
+
+		/**
+		 * Picks what to put on the root buildscript classpath so subprojects can resolve
+		 * [BuildInfo.PACKAGE_NAME] by plugin ID: an init script's own classpath does NOT reach
+		 * project plugin resolution, so this injection is the sole mechanism that makes
+		 * `pluginManager.apply(id)` work below. Prefers the jar the IDE ships, else whatever the
+		 * init script was loaded from; empty fails loud, since a missing path is a silent no-op.
+		 */
+		internal fun resolvePluginClasspath(
+			bundledJar: File,
+			initScriptClasspath: List<File>,
+		): List<File> {
+			if (bundledJar.isFile) {
+				return listOf(bundledJar)
+			}
+
+			val fallback = initScriptClasspath.filter(File::exists)
+			if (fallback.isNotEmpty()) {
+				return fallback
+			}
+
+			throw GradleException(
+				"Cannot inject the '${BuildInfo.PACKAGE_NAME}' plugin: no plugin jar at " +
+					"'${bundledJar.absolutePath}' and the init script classpath is empty.",
+			)
+		}
 	}
 
 	override fun apply(target: Gradle) {
@@ -44,14 +73,13 @@ class AndroidIDEInitScriptPlugin : Plugin<Gradle> {
 		}
 
 		target.rootProject { rootProject ->
-			rootProject.buildscript.apply {
-				dependencies.apply {
-					add(
-						"classpath",
-						rootProject.files("$ANDROIDIDE_HOME/plugin/cogo-plugin.jar"),
-					)
-				}
-			}
+			val classpath =
+				resolvePluginClasspath(
+					File(COGO_GRADLE_PLUGIN_PATH, COGO_GRADLE_PLUGIN_JAR_NAME),
+					initScriptClasspath(),
+				)
+			logger.info("Injecting plugin classpath into the root buildscript: {}", classpath)
+			rootProject.buildscript.dependencies.add("classpath", rootProject.files(classpath))
 		}
 
 		target.projectsLoaded { gradle ->
@@ -71,18 +99,20 @@ class AndroidIDEInitScriptPlugin : Plugin<Gradle> {
 		}
 	}
 
+	/** The files this plugin itself was loaded from, i.e. the init script's classpath. */
+	private fun initScriptClasspath(): List<File> {
+		val loader = javaClass.classLoader as? URLClassLoader ?: return emptyList()
+		return loader.urLs.mapNotNull { url -> runCatching { File(url.toURI()) }.getOrNull() }
+	}
+
 	private fun removeDaemonLogs(gradle: Gradle) {
-		// Get the Gradle user home directory
 		val gradleUserHomeDir = gradle.gradleUserHomeDir
-
-		// Get the current Gradle version
 		val currentGradleVersion = gradle.gradleVersion
 		val logsDir = File(gradleUserHomeDir, "daemon/$currentGradleVersion")
 
 		if (logsDir.exists() && logsDir.isDirectory) {
 			logger.lifecycle("Code On the Go clean logs of gradle ($currentGradleVersion) task running....")
 
-			// Filter and iterate over log files, sorted by last modified date
 			logsDir
 				.listFiles()
 				?.filter { it.isFile && it.name.endsWith(".log") }

gradle-plugin/src/main/java/com/itsaky/androidide/gradle/COTGSettingsPlugin.kt

@@ -13,6 +13,11 @@ import org.gradle.api.logging.Logging
 import java.io.File
 import java.net.URI
 
+/**
+ * Supplements the root build's dependency and plugin repositories with CoGo's bundled local Maven
+ * repo, so a project resolves offline. Applied by [AndroidIDEInitScriptPlugin] on settings
+ * evaluation; a test env supplies its own repo paths instead of the device-only bundled one.
+ */
 class COTGSettingsPlugin : Plugin<Settings> {
 	private val logger = Logging.getLogger(COTGSettingsPlugin::class.java)
 
@@ -23,15 +28,22 @@ class COTGSettingsPlugin : Plugin<Settings> {
 		}
 
 		logger.info("Plugin instance: ${System.identityHashCode(this)}")
-		// Add our local maven repo, always.
-		val allLocalRepos = mutableListOf(MAVEN_LOCAL_REPOSITORY)
 
-		// Then check if we need to add additional repos, based on whether
-		// we're in a test environment
 		val (isTestEnv, mavenLocalRepos) = getTestEnvProps(target.startParameter)
-		if (isTestEnv) {
-			allLocalRepos += mavenLocalRepos
-		}
+
+		// The bundled repo lives at a device-only path, so a host test env supplies its own
+		// repos instead - requiring the device path there would fail every host build. A test
+		// env that supplies none is a misconfiguration, and adding zero repositories silently
+		// turns it into an unresolved-dependency failure somewhere far from the cause.
+		val allLocalRepos =
+			if (isTestEnv) {
+				require(mavenLocalRepos.isNotEmpty()) {
+					"$_PROPERTY_IS_TEST_ENV is set but $_PROPERTY_MAVEN_LOCAL_REPOSITORY names no repository"
+				}
+				mavenLocalRepos
+			} else {
+				listOf(MAVEN_LOCAL_REPOSITORY)
+			}
 
 		target.addLocalRepos(allLocalRepos)
 	}