feat(android): per-plugin build options reaching the plugin gradle build

A plugin's `android.plugins.<name>` entry already reaches `buildAar`; this
makes it reach the gradle build itself, and adds `abiFilters` as the first
option that does:

```js
android: {
  plugins: {
    "@foo/plugin-x": { abiFilters: ["arm64-v8a"] },
  },
}
```

Nothing here is specific to `abiFilters`. What a plugin has native code for
does not depend on what is plugged in, so the list wins over the ABIs
`--filter-plugins-devices-arch` derives from the connected devices and applies
whether or not that flag is set; an empty list passes nothing, opting a single
plugin out of the narrowing. Every other key of the entry reaches the build as
it is written.

The plugin build data now records the options gradle was asked for, under a
single `__buildOptions` entry rather than the `abiFilters`-specific one, since
the plugin sources do not change when an option does: any per-plugin option
added later takes part in the rebuild decision by being listed there. Options
that only change the artifact's name, such as `aarSuffix`, produce a different
file rather than a stale one and stay out of it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: farfromrefug

lib/definitions/project.d.ts

@@ -195,6 +195,15 @@ interface INsConfigAndroidPlugin {
 	 * each other - a suffix tells them apart.
 	 */
 	aarSuffix?: string;
+
+	/**
+	 * The ABIs passed to this plugin's gradle build as `-PabiFilters`, which a
+	 * plugin acts on in its own `include.gradle`. Wins over the ABIs
+	 * `--filter-plugins-devices-arch` derives from the connected devices, and
+	 * applies whether or not that flag is set. An empty array passes nothing,
+	 * which opts this plugin out of the narrowing.
+	 */
+	abiFilters?: string[];
 }
 
 interface INsConfigHooks {

lib/services/android-plugin-build-service.ts

@@ -61,7 +61,13 @@ export class AndroidPluginBuildService implements IAndroidPluginBuildService {
 		private $watchIgnoreListService: IWatchIgnoreListService,
 	) {}
 
-	private static ABI_FILTERS_BUILD_DATA_KEY = "__abiFilters";
+	/**
+	 * The plugin build data entry recording the build options gradle was last
+	 * asked for. The plugin sources do not change when an option does, so every
+	 * per-plugin option that changes what gradle produces belongs in here -
+	 * otherwise the aar built with the old one is kept.
+	 */
+	private static BUILD_OPTIONS_DATA_KEY = "__buildOptions";
 
 	private static MANIFEST_ROOT = {
 		$: {
@@ -239,14 +245,11 @@ export class AndroidPluginBuildService implements IAndroidPluginBuildService {
 			shortPluginName,
 		);
 
-		// the aar of a plugin built for a subset of the ABIs is not the aar of the
-		// same sources built for another subset, so the ABIs take part in the
-		// decision to rebuild - the sources alone would not change when a device
-		// with another ABI joins the run.
-		if (options.abiFilters && options.abiFilters.length) {
+		const buildOptions = this.getArtifactAffectingOptions(options);
+		if (buildOptions) {
 			pluginSourceFileHashesInfo[
-				AndroidPluginBuildService.ABI_FILTERS_BUILD_DATA_KEY
-			] = options.abiFilters.join(",");
+				AndroidPluginBuildService.BUILD_OPTIONS_DATA_KEY
+			] = buildOptions;
 		}
 
 		const shouldBuildAar = await this.shouldBuildAar({
@@ -296,6 +299,28 @@ export class AndroidPluginBuildService implements IAndroidPluginBuildService {
 		return shouldBuildAar;
 	}
 
+	/**
+	 * The build options that change what gradle produces for this plugin, in
+	 * the form they are recorded in the plugin build data. `null` when none of
+	 * them is set, so a project that uses none of them keeps the build data it
+	 * already has.
+	 *
+	 * `abiFilters` is the only one today: the aar of a plugin built for a
+	 * subset of the ABIs is not the aar of the same sources built for another
+	 * subset. Options that only change the *name* of the artifact - `aarSuffix`
+	 * - do not belong here, they produce a different file rather than a stale
+	 * one.
+	 */
+	private getArtifactAffectingOptions(options: IPluginBuildOptions): string {
+		const affectingOptions: { [key: string]: any } = {};
+
+		if (options.abiFilters && options.abiFilters.length) {
+			affectingOptions.abiFilters = options.abiFilters;
+		}
+
+		return _.isEmpty(affectingOptions) ? null : JSON.stringify(affectingOptions);
+	}
+
 	private cleanPluginDir(pluginTempDir: string): void {
 		// In case plugin was already built in the current process, we need to clean the old sources as they may break the new build.
 		this.$fs.deleteDirectory(pluginTempDir);

lib/services/android-project-service.ts

@@ -9,6 +9,7 @@ import { Configurations, LiveSyncPaths } from "../common/constants";
 import { hook } from "../common/helpers";
 import { performanceLog } from ".././common/decorators";
 import {
+	INsConfigAndroidPlugin,
 	IProjectData,
 	IProjectDataService,
 	IValidatePlatformOutput,
@@ -698,12 +699,15 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 			const options: IPluginBuildOptions = {
 				gradlePath: this.$options.gradlePath,
 				gradleArgs: this.$options.gradleArgs,
-				abiFilters: this.getPluginsAbiFilters(),
+				abiFilters: this.getPluginsAbiFilters(pluginConfig),
 				projectDir: projectData.projectDir,
 				pluginName: pluginData.name,
 				platformsAndroidDirPath: pluginPlatformsFolderPath,
 				aarOutputDir: pluginPlatformsFolderPath,
 				tempPluginDirPath: path.join(projectData.platformsDir, "tempPlugin"),
+				// the rest of the plugin's config entry reaches the build as it is
+				// written - `abiFilters` is resolved above only because it falls
+				// back to the devices when the entry does not set it
 				...pluginConfig,
 			};
 
@@ -716,13 +720,21 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 	}
 
 	/**
-	 * The ABIs passed to the gradle build of a plugin built from source. Opt-in
-	 * (`--filter-plugins-devices-arch`): nothing in the gradle files the CLI
-	 * generates for a plugin acts on `abiFilters`, so this is only useful for a
-	 * plugin whose own `include.gradle` reads the property - a long native build
-	 * can then skip the ABIs this run is not going to deploy to.
+	 * The ABIs passed to the gradle build of a plugin built from source. Nothing
+	 * in the gradle files the CLI generates for a plugin acts on `abiFilters`,
+	 * so this is only useful for a plugin whose own `include.gradle` reads the
+	 * property - a long native build can then skip the ABIs it is not asked for.
+	 *
+	 * A list in the plugin's config entry always wins: what a plugin has native
+	 * code for does not depend on what is plugged in. Otherwise the ABIs of the
+	 * devices this run is about to deploy to are used, and only when
+	 * `--filter-plugins-devices-arch` asks for it.
 	 */
-	private getPluginsAbiFilters(): string[] {
+	private getPluginsAbiFilters(pluginConfig: INsConfigAndroidPlugin): string[] {
+		if (pluginConfig.abiFilters) {
+			return pluginConfig.abiFilters;
+		}
+
 		if (!this.$options.filterPluginsDevicesArch) {
 			return null;
 		}

test/services/android-plugin-build-service.ts

@@ -350,6 +350,32 @@ dependencies {
 			assert.isFalse(spawnFromEventCalled);
 		});
 
+		it("records the options that changed what gradle produced", async () => {
+			const config: IPluginBuildOptions = setup({ addManifest: true });
+			config.abiFilters = ["arm64-v8a"];
+
+			await androidBuildPluginService.buildAar(config);
+
+			const buildData = fs.readJson(
+				path.join(tempFolder, shortPluginName, PLUGIN_BUILD_DATA_FILENAME),
+			);
+			assert.deepStrictEqual(
+				buildData["__buildOptions"],
+				JSON.stringify({ abiFilters: ["arm64-v8a"] }),
+			);
+		});
+
+		it("records no build options when none of them is set", async () => {
+			const config: IPluginBuildOptions = setup({ addManifest: true });
+
+			await androidBuildPluginService.buildAar(config);
+
+			const buildData = fs.readJson(
+				path.join(tempFolder, shortPluginName, PLUGIN_BUILD_DATA_FILENAME),
+			);
+			assert.isUndefined(buildData["__buildOptions"]);
+		});
+
 		it("builds aar with the latest runtime gradle versions when no project dir is specified", async () => {
 			const expectedGradleVersion = "4.4";
 			const expectedAndroidVersion = "4.5.6";

test/services/android-project-service.ts

@@ -20,6 +20,7 @@ import {
 	IProjectDir,
 } from "../../lib/common/declarations";
 import { IPluginBuildOptions } from "../../lib/definitions/android-plugin-migrator";
+import { INsConfigAndroidPlugin } from "../../lib/definitions/project";
 
 const createTestInjector = (): IInjector => {
 	const testInjector = new Yok();
@@ -424,7 +425,8 @@ describe("androidProjectService plugins abi filtering", () => {
 
 	const preparePluginNativeCode = async (
 		options: any,
-		devices: any[]
+		devices: any[],
+		pluginsConfig?: IDictionary<INsConfigAndroidPlugin>
 	): Promise<IPluginBuildOptions> => {
 		const testInjector = createTestInjector();
 		let pluginBuildOptions: IPluginBuildOptions = null;
@@ -452,7 +454,11 @@ describe("androidProjectService plugins abi filtering", () => {
 				name: "my-plugin",
 				pluginPlatformsFolderPath: (): string => "pluginPlatformsDir",
 			},
-			<any>{ projectDir: "projectDir", platformsDir: "platformsDir" }
+			<any>{
+				projectDir: "projectDir",
+				platformsDir: "platformsDir",
+				nsConfig: { android: { plugins: pluginsConfig } },
+			}
 		);
 
 		return pluginBuildOptions;
@@ -490,6 +496,46 @@ describe("androidProjectService plugins abi filtering", () => {
 		assert.isNull(options.abiFilters);
 	});
 
+	it("passes the abis from the plugin's config entry", async () => {
+		const options = await preparePluginNativeCode(
+			{ filterPluginsDevicesArch: true },
+			[createDevice("device1", ["x86_64"], true)],
+			{ "my-plugin": { abiFilters: ["arm64-v8a"] } }
+		);
+
+		assert.deepStrictEqual(options.abiFilters, ["arm64-v8a"]);
+	});
+
+	it("passes the abis from the config entry without the option", async () => {
+		const options = await preparePluginNativeCode(
+			{},
+			[createDevice("device1", ["x86_64"], true)],
+			{ "my-plugin": { abiFilters: ["arm64-v8a"] } }
+		);
+
+		assert.deepStrictEqual(options.abiFilters, ["arm64-v8a"]);
+	});
+
+	it("passes no abis when the config entry is an empty list", async () => {
+		const options = await preparePluginNativeCode(
+			{ filterPluginsDevicesArch: true },
+			[createDevice("device1", ["x86_64"], true)],
+			{ "my-plugin": { abiFilters: [] } }
+		);
+
+		assert.deepStrictEqual(options.abiFilters, []);
+	});
+
+	it("ignores the config entry of another plugin", async () => {
+		const options = await preparePluginNativeCode(
+			{ filterPluginsDevicesArch: true },
+			[createDevice("device1", ["x86_64"], true)],
+			{ "other-plugin": { abiFilters: ["arm64-v8a"] } }
+		);
+
+		assert.deepStrictEqual(options.abiFilters, ["x86_64"]);
+	});
+
 	it("passes no abis when no device reports its abis", async () => {
 		const options = await preparePluginNativeCode(
 			{ filterPluginsDevicesArch: true },