ADFA-4128: qb 10 review fixes — explicit-intent rewrite, loud AAR injection, min-AGP guard

Review finding 1 (renamed services/receivers silently break explicit intents) → services and
receivers now keep their real manifest names, per the design doc's own no-proxy path: the
appComponentFactory instantiates the manifest name through the payload loader (like the
Application), Android has no service/receiver alias to compensate a rename with, and neither
kind uses the activity-only getClassLoader injection. They stay recorded in setup.json (null
proxyClass) so the restart rule still sees them; resolver-skipped library components stay out,
as before. Covered by QuickBuildManifestTransformerTest ("services keep their real manifest
names so explicit start-service intents still resolve", "receivers keep their real name...",
"project-owned services stay recorded...", plus the rewritten skip/numbering tests). Docs
updated in step (component-proxying-design.md, quickbuild/README.md, ComponentInfo.kt,
live-reload-alternatives.md).

Review finding 3 (fail-quiet runtime-AAR injection) → the injection path now goes through
QuickBuildPlugin.requireRuntimeConfiguration, which throws a GradleException naming the
variant and the unrecognized AGP variant type instead of silently producing a proxy APK that
crashes at launch; the .flat-overlay caller keeps its documented graceful degrade. Covered by
QuickBuildPluginTest ("requireRuntimeConfiguration fails the build loudly on an unrecognized
variant type", "runtimeConfigurationOrNull degrades to null for the resources overlay path").

Review finding 2 (deleted min-AGP guard) → restored as a minAgpCheck source set wired into
`check`: it recompiles every non-Quick-Build plugin source against AGP_VERSION_MINIMUM, so an
AGP-8-only API in LogSenderPlugin/AndroidIDEGradlePlugin goes red again. Quick Build sources
are excluded (they genuinely need the newer AGP and load only when enabled); to keep that
exclusion compilable, AndroidIDEGradlePlugin applies QuickBuildPlugin by name, pinned to the
real class by QuickBuildPluginTest ("the reflective quick build plugin name resolves to the
real class"). The guard task itself is the red light for build-file regressions. This restore
is the conservative option; dropping the guard again can be re-proposed separately with
rationale if the team prefers compile-against-latest only.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Kj9YeCDHGp9DU8LPtfWJ7W

Author: fryanpan

gradle-plugin/build.gradle.kts

@@ -17,8 +17,10 @@
 
 @file:Suppress("UnstableApiUsage")
 
+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")
@@ -81,7 +83,8 @@ dependencies {
 	// 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.
+	// 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())
@@ -92,6 +95,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)

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

@@ -32,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) {
@@ -57,7 +66,9 @@ class AndroidIDEGradlePlugin : Plugin<Project> {
 
 			val isQuickBuildEnabled = findProperty(PROPERTY_QUICK_BUILD_ENABLED) == "true"
 			if (isQuickBuildEnabled) {
-				pluginManager.apply(QuickBuildPlugin::class.java)
+				// 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/QuickBuildPlugin.kt

@@ -71,6 +71,42 @@ class QuickBuildPlugin : Plugin<Project> {
 		 * jar dependency. AGP-internal like the constant above, so the raw string is used directly.
 		 */
 		internal const val CLASSES_JAR_ARTIFACT_TYPE = "android-classes-jar"
+
+		/**
+		 * The variant's runtime-classpath [Configuration], reached through AGP-internal variant
+		 * types, or null when the variant is neither known impl - i.e. an AGP this plugin has not
+		 * been taught about.
+		 *
+		 * @param variant the variant AGP handed to `onVariants`, possibly analytics-wrapped.
+		 * @return the runtime classpath configuration, or null for an unrecognized variant type.
+		 */
+		internal fun runtimeConfigurationOrNull(variant: ApplicationVariant): Configuration? =
+			when (variant) {
+				is ApplicationVariantImpl -> variant.variantDependencies.runtimeClasspath
+				is AnalyticsEnabledApplicationVariant -> runtimeConfigurationOrNull(variant.delegate)
+				else -> null
+			}
+
+		/**
+		 * [runtimeConfigurationOrNull] for the runtime-AAR injection, which must never fail quiet:
+		 * without the injected AAR the proxy APK still names [APP_COMPONENT_FACTORY] in its
+		 * manifest, so the app dies at launch with ClassNotFoundException, on device, far from the
+		 * cause. An AGP whose variant impl this lookup does not recognize therefore fails the
+		 * build here, where the message can say what actually broke.
+		 *
+		 * @param variant the variant AGP handed to `onVariants`, possibly analytics-wrapped.
+		 * @return the runtime classpath configuration, never null.
+		 * @throws GradleException when the variant type is unrecognized.
+		 */
+		internal fun requireRuntimeConfiguration(variant: ApplicationVariant): Configuration =
+			runtimeConfigurationOrNull(variant)
+				?: throw GradleException(
+					"Quick Build cannot inject its runtime into variant '${variant.name}': " +
+						"unrecognized AGP variant type '${variant.javaClass.name}'. Without the " +
+						"runtime AAR the proxy app would crash at launch, so the build stops " +
+						"here; this AGP version needs QuickBuildPlugin.runtimeConfigurationOrNull " +
+						"taught about its variant type. Use a Standard Run meanwhile.",
+				)
 	}
 
 	override fun apply(target: Project) {
@@ -143,9 +179,9 @@ class QuickBuildPlugin : Plugin<Project> {
 			project.path,
 		)
 
-		variant.withRuntimeConfiguration {
-			dependencies.add(project.dependencies.create(project.fileTree(runtimeAar)))
-		}
+		requireRuntimeConfiguration(variant)
+			.dependencies
+			.add(project.dependencies.create(project.fileTree(runtimeAar)))
 
 		val buildDirectory = project.layout.buildDirectory
 		val variantDir = "quickbuild/${variant.name}"
@@ -200,9 +236,9 @@ class QuickBuildPlugin : Plugin<Project> {
 				task.proxySources.set(generate.flatMap { it.proxySources })
 				task.manifestInfoFile.set(generate.flatMap { it.manifestInfoFile })
 				task.compileClasspath.from(variant.compileClasspath)
-				// Components are proxied uniformly, including ones whose class arrives on
-				// the RUNTIME-only classpath (CoGo's injected LogSender service): javac
-				// needs the superclass, so the injected AAR joins the proxy classpath.
+				// A proxied component's class can arrive on the RUNTIME-only classpath
+				// (CoGo's injected LogSender AAR carries the LogSenderInstaller provider):
+				// javac needs the superclass, so the injected AAR joins the proxy classpath.
 				task.runtimeAar.addRuntimeAars(project, runtimeAar)
 				task.bootClasspath.from(bootClasspath)
 				task.minApiLevel.set(payloadMinApi)
@@ -324,14 +360,6 @@ class QuickBuildPlugin : Plugin<Project> {
 		}
 	}
 
-	private fun ApplicationVariant.withRuntimeConfiguration(action: Configuration.() -> Unit) {
-		if (this is ApplicationVariantImpl) {
-			variantDependencies.runtimeClasspath.action()
-		} else if (this is AnalyticsEnabledApplicationVariant) {
-			delegate.withRuntimeConfiguration(action)
-		}
-	}
-
 	/**
 	 * Every dependency's classes as jars: a lenient `ArtifactView` over the variant's COMPILE
 	 * configuration filtered to [CLASSES_JAR_ARTIFACT_TYPE].
@@ -365,9 +393,10 @@ class QuickBuildPlugin : Plugin<Project> {
 		variant: ApplicationVariant,
 		project: Project,
 	): FileCollection {
-		var configuration: Configuration? = null
-		variant.withRuntimeConfiguration { configuration = this }
-		val resolvedConfiguration = configuration ?: return project.files()
+		// Graceful here, unlike the runtime-AAR injection: missing .flat overlays only
+		// degrade resource relinks, and the injection above already failed the build for
+		// any variant type this cannot resolve.
+		val resolvedConfiguration = runtimeConfigurationOrNull(variant) ?: return project.files()
 		return resolvedConfiguration.incoming
 			.artifactView { view ->
 				view.attributes {

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

@@ -30,15 +30,16 @@ enum class ComponentType(
 /**
  * One component of the user's merged manifest, paired with the proxy generated for it.
  *
- * The custom Application appears here with a null [proxyClass]: nothing addresses it by manifest
- * name, so it keeps the user FQN and the runtime's instantiateApplication routes it through the
- * payload loader.
+ * The custom Application, services and receivers appear here with a null [proxyClass]: they keep
+ * the user FQN in the manifest and the runtime's instantiate hooks route them through the payload
+ * loader by that real name. For the Application nothing addresses it by manifest name anyway; for
+ * services and receivers the real name IS the addressing - see
+ * [QuickBuildManifestTransformer.transformComponents].
  *
- * @property type which manifest element this came from; the Application is the only type that
- *   gets no proxy.
+ * @property type which manifest element this came from.
  * @property userClass fully-qualified user class.
  * @property proxyClass fully-qualified generated proxy class that replaces it in the
- *   manifest, or null for the Application entry.
+ *   manifest, or null for the Application, service and receiver entries.
  * @property isLauncher whether an activity declares the MAIN/LAUNCHER intent filter.
  */
 data class ProxiedComponent(
@@ -64,8 +65,8 @@ data class UnproxiedComponent(
  * The rewritten manifest plus what the rewrite did to each component.
  *
  * @property document the transformed manifest, mutated in place from the parsed input.
- * @property components every proxied component, in manifest order per type, plus the proxy-less
- *   Application entry when the manifest declares one.
+ * @property components every recorded component, in manifest order per type - proxied or (for
+ *   services, receivers and the Application) kept under its real name with a null proxyClass.
  * @property unproxied components left under their real name, for the caller to log.
  */
 class ManifestTransformResult(
@@ -83,8 +84,9 @@ class ManifestTransformResult(
 }
 
 /**
- * Rewrites a merged Android manifest into the proxy-app manifest: each component's android:name
- * becomes a generated proxy FQN and the `<application>` gains the quick-build runtime's
+ * Rewrites a merged Android manifest into the proxy-app manifest: each activity's and provider's
+ * android:name becomes a generated proxy FQN, services and receivers keep their real name (see
+ * [transformComponents] for why), and the `<application>` gains the quick-build runtime's
  * android:appComponentFactory, everything else verbatim. Components [proxiability] rejects keep
  * their real name and land in [ManifestTransformResult.unproxied]; an attribute the proxy app
  * cannot host yet (android:process, isolated services, multiprocess providers) fails the build.
@@ -148,8 +150,23 @@ class QuickBuildManifestTransformer(
 		val components = mutableListOf<ProxiedComponent>()
 		val unproxied = mutableListOf<UnproxiedComponent>()
 		components += transformActivities(application, manifestPackage, unproxied)
-		components += transformComponents(application, ComponentType.SERVICE, manifestPackage, unproxied, "isolatedProcess")
-		components += transformComponents(application, ComponentType.RECEIVER, manifestPackage, unproxied)
+		components +=
+			transformComponents(
+				application,
+				ComponentType.SERVICE,
+				manifestPackage,
+				unproxied,
+				unsupportedAttribute = "isolatedProcess",
+				proxied = false,
+			)
+		components +=
+			transformComponents(
+				application,
+				ComponentType.RECEIVER,
+				manifestPackage,
+				unproxied,
+				proxied = false,
+			)
 		components += transformComponents(application, ComponentType.PROVIDER, manifestPackage, unproxied, "multiprocess")
 		applicationComponent(application, manifestPackage)?.let { components += it }
 
@@ -262,18 +279,34 @@ class QuickBuildManifestTransformer(
 	}
 
 	/**
-	 * Renames every proxiable component of one non-activity kind to its proxy.
+	 * Renames every proxiable component of one non-activity kind to its proxy - or, when
+	 * [proxied] is false, records it under its real name without renaming.
 	 *
 	 * Activities keep [transformActivities] to themselves: only they carry alias handling.
 	 *
+	 * Services and receivers pass [proxied] = false, because renaming them silently breaks
+	 * explicit-component addressing and Android has no `<service>`/`<receiver>` alias to
+	 * compensate with (activities get exactly that alias in [transformActivities]):
+	 * `startService(Intent(ctx, SyncService::class.java))` resolves the real class name against
+	 * the manifest, finds nothing, and no-ops with only a logcat warning; an AlarmManager
+	 * `PendingIntent.getBroadcast` aimed at a renamed receiver is simply never delivered.
+	 * Keeping the real name costs nothing: the runtime's appComponentFactory instantiates the
+	 * manifest name through the payload loader, exactly as the custom Application already does,
+	 * and neither kind uses the one thing only a proxy can inject (the activity proxies'
+	 * getClassLoader override).
+	 *
 	 * @param application the `<application>` element, mutated in place.
 	 * @param type the kind to rewrite; its [ComponentType.jsonName] is also the manifest tag.
 	 * @param manifestPackage the manifest's package, for expanding android:name shorthand.
-	 * @param unproxied accumulator for components [skipProxy] rejects.
+	 * @param unproxied accumulator for components [skipProxy] rejects; a rejected component is
+	 *   also left out of the returned list, keeping library-owned components (whose classes
+	 *   never travel in the payload) invisible to the deploy policy's restart rule.
 	 * @param unsupportedAttribute an android attribute the proxy app cannot host when it is
 	 *   `"true"` (a service's isolatedProcess, a provider's multiprocess), or null for a kind
 	 *   with none.
-	 * @return the proxied components, in manifest order; skipped ones are absent.
+	 * @param proxied whether this kind is renamed to a generated proxy; false keeps the real
+	 *   name (written fully qualified) and records a null proxyClass.
+	 * @return the recorded components, in manifest order; skipped ones are absent.
 	 * @throws IllegalArgumentException if a component declares [unsupportedAttribute].
 	 */
 	private fun transformComponents(
@@ -282,6 +315,7 @@ class QuickBuildManifestTransformer(
 		manifestPackage: String,
 		unproxied: MutableList<UnproxiedComponent>,
 		unsupportedAttribute: String? = null,
+		proxied: Boolean = true,
 	): List<ProxiedComponent> {
 		val tag = type.jsonName
 		var proxyIndex = 0
@@ -299,6 +333,17 @@ class QuickBuildManifestTransformer(
 			if (skipProxy(userClass, unproxied)) {
 				return@mapIndexedNotNull null
 			}
+			if (!proxied) {
+				// Keep the user class but write it fully qualified, for the same reason as
+				// applicationComponent: the runtime resolves this name against the payload
+				// dex, so shorthand left verbatim is fragile.
+				element.setAttributeNS(ANDROID_NS, "android:name", userClass)
+				return@mapIndexedNotNull ProxiedComponent(
+					type = type,
+					userClass = userClass,
+					proxyClass = null,
+				)
+			}
 			val proxyClass = "$proxyPackage.${proxySimpleName(proxyIndex, type)}"
 			proxyIndex++
 			element.setAttributeNS(ANDROID_NS, "android:name", proxyClass)

gradle-plugin/src/test/java/com/itsaky/androidide/gradle/QuickBuildPluginTest.kt

@@ -0,0 +1,60 @@
+package com.itsaky.androidide.gradle
+
+import com.android.build.api.variant.ApplicationVariant
+import com.google.common.truth.Truth.assertThat
+import org.gradle.api.GradleException
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import java.lang.reflect.Proxy
+
+/**
+ * JVM-pure coverage for [QuickBuildPlugin]'s AGP-internal seams; the full plugin runs only
+ * inside a real Gradle build ([QuickBuildProxyAppBuildTest]).
+ */
+class QuickBuildPluginTest {
+	/**
+	 * An [ApplicationVariant] that is neither of the AGP variant impls the plugin knows -
+	 * the shape a future AGP hands over when its internals change. A JDK dynamic proxy
+	 * rather than a stub class, so no AGP-internal type is subclassed here either.
+	 */
+	private fun unknownVariantType(): ApplicationVariant =
+		Proxy.newProxyInstance(
+			ApplicationVariant::class.java.classLoader,
+			arrayOf(ApplicationVariant::class.java),
+		) { _, method, _ ->
+			when (method.name) {
+				"getName" -> "demoDebug"
+				else -> throw UnsupportedOperationException(method.name)
+			}
+		} as ApplicationVariant
+
+	@Test
+	fun `requireRuntimeConfiguration fails the build loudly on an unrecognized variant type`() {
+		// The injection path must never fail quiet: a proxy APK built without the runtime
+		// AAR still names QuickBuildAppComponentFactory in its manifest, so it dies at
+		// launch with ClassNotFoundException on device, far from the cause.
+		val error =
+			assertThrows<GradleException> {
+				QuickBuildPlugin.requireRuntimeConfiguration(unknownVariantType())
+			}
+
+		assertThat(error).hasMessageThat().contains("demoDebug")
+		assertThat(error).hasMessageThat().contains("runtime")
+		assertThat(error).hasMessageThat().contains("Standard Run")
+	}
+
+	@Test
+	fun `runtimeConfigurationOrNull degrades to null for the resources overlay path`() {
+		// The .flat-overlay caller may stay graceful - missing overlays only degrade
+		// resource relinks - which is exactly why the injection path above must not.
+		assertThat(QuickBuildPlugin.runtimeConfigurationOrNull(unknownVariantType())).isNull()
+	}
+
+	@Test
+	fun `the reflective quick build plugin name resolves to the real class`() {
+		// AndroidIDEGradlePlugin applies QuickBuildPlugin by name so the minAgpCheck guard
+		// can compile it without the Quick Build sources; this pins the string to the class.
+		assertThat(Class.forName(AndroidIDEGradlePlugin.QUICK_BUILD_PLUGIN_CLASS))
+			.isEqualTo(QuickBuildPlugin::class.java)
+	}
+}