feat(android): optionally pass the device ABIs to plugin builds

`--filter-plugins-devices-arch` passes the same `-PabiFilters` the app build
gets to the gradle build of every plugin built from source.

Nothing in the gradle files the CLI generates for a plugin acts on the
property, and this deliberately does not add such a block: what a plugin's
native sources need per ABI is the plugin's business. It is there for a plugin
whose own `include.gradle` reads `abiFilters` - a plugin with a long native
build (an NDK/CMake one, say) can then build only the ABIs this run is about
to deploy to instead of all four.

Off by default. A narrowed aar is a partial artifact and the aar cache is
keyed by the plugin sources, which do not change when a device with another
ABI joins, so the ABIs are now part of the plugin build data the rebuild
decision reads.

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

Author: farfromrefug

docs/man_pages/project/testing/debug-android.md

@@ -39,6 +39,7 @@ Attach the debug tools to a running app in the native emulator | `$ ns debug and
     *   `--env.hiddenSourceMap` - creates sources maps in the root folder (useful for Crashlytics usage with bundled app in release).
 * `--aab` - Specifies that the command will produce and deploy an Android App Bundle.
 * `--no-filter-devices-arch` - If set, builds every ABI instead of only the ones the connected devices report. The narrowing only applies when the app's gradle configuration acts on the `abiFilters` property, and `ns build` never narrows.
+* `--filter-plugins-devices-arch` - If set, the ABIs of the connected devices are also passed to the gradle build of every plugin built from source. Nothing in the gradle files the CLI generates for a plugin acts on them - this is for a plugin whose own `include.gradle` reads the `abiFilters` property to shorten a long native build.
 * `--force` - If set, skips the application compatibility checks and forces `npm i` to ensure all dependencies are installed. Otherwise, the command will check the application compatibility with the current CLI version and could fail requiring `ns migrate`.
 
 <% if(isHtml) { %>

docs/man_pages/project/testing/run-android.md

@@ -44,6 +44,7 @@ Start a default emulator if none are running, or run application on all connecte
     *   `--env.hiddenSourceMap` - creates sources maps in the root folder (useful for Crashlytics usage with bundled app in release).
 * `--aab` - Specifies that the command will produce and deploy an Android App Bundle.
 * `--no-filter-devices-arch` - If set, builds every ABI instead of only the ones the connected devices report. The narrowing only applies when the app's gradle configuration acts on the `abiFilters` property, and `ns build` never narrows.
+* `--filter-plugins-devices-arch` - If set, the ABIs of the connected devices are also passed to the gradle build of every plugin built from source. Nothing in the gradle files the CLI generates for a plugin acts on them - this is for a plugin whose own `include.gradle` reads the `abiFilters` property to shorten a long native build.
 * `--force` - If set, skips the application compatibility checks and forces `npm i` to ensure all dependencies are installed. Otherwise, the command will check the application compatibility with the current CLI version and could fail requiring `ns migrate`.
 
 <% if(isHtml) { %>

lib/declarations.d.ts

@@ -577,6 +577,14 @@ interface IAndroidOptions extends IEmbedOptions {
 	 * `--no-filter-devices-arch` to always build every ABI.
 	 */
 	filterDevicesArch: boolean;
+
+	/**
+	 * When true, the same ABIs are passed to the gradle build of every plugin
+	 * that is built from source. Off by default - the CLI's own plugin gradle
+	 * files ignore the property, only a plugin acting on it in its
+	 * `include.gradle` gains anything from it.
+	 */
+	filterPluginsDevicesArch: boolean;
 	gradlePath: string;
 	gradleArgs: string;
 }

lib/definitions/android-plugin-migrator.d.ts

@@ -12,6 +12,7 @@ interface IAndroidBuildOptions {
 	tempPluginDirPath: string;
 	gradlePath?: string;
 	gradleArgs?: string;
+	abiFilters?: string[];
 }
 
 interface IAndroidPluginBuildService {
@@ -49,4 +50,13 @@ interface IBuildAndroidPluginData extends Partial<IProjectDir> {
 	 * Optional custom Gradle arguments.
 	 */
 	gradleArgs?: string;
+
+	/**
+	 * The ABIs the build this plugin is prepared for is about to deploy to,
+	 * passed to the plugin build as `-PabiFilters`. Nothing in the gradle files
+	 * the CLI generates for a plugin acts on it - it is there for a plugin whose
+	 * own `include.gradle` reads the property to skip the ABIs the build does
+	 * not need.
+	 */
+	abiFilters?: string[];
 }

lib/options.ts

@@ -224,6 +224,11 @@ export class Options {
 				default: true,
 				hasSensitiveValue: false,
 			},
+			filterPluginsDevicesArch: {
+				type: OptionType.Boolean,
+				default: false,
+				hasSensitiveValue: false,
+			},
 			gradlePath: { type: OptionType.String, hasSensitiveValue: false },
 			gradleArgs: { type: OptionType.String, hasSensitiveValue: false },
 			hostProjectPath: { type: OptionType.String, hasSensitiveValue: false },

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

@@ -61,6 +61,8 @@ export class AndroidPluginBuildService implements IAndroidPluginBuildService {
 		private $watchIgnoreListService: IWatchIgnoreListService,
 	) {}
 
+	private static ABI_FILTERS_BUILD_DATA_KEY = "__abiFilters";
+
 	private static MANIFEST_ROOT = {
 		$: {
 			"xmlns:android": "http://schemas.android.com/apk/res/android",
@@ -233,6 +235,16 @@ 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) {
+			pluginSourceFileHashesInfo[
+				AndroidPluginBuildService.ABI_FILTERS_BUILD_DATA_KEY
+			] = options.abiFilters.join(",");
+		}
+
 		const shouldBuildAar = await this.shouldBuildAar({
 			manifestFilePath,
 			androidSourceDirectories,
@@ -264,6 +276,7 @@ export class AndroidPluginBuildService implements IAndroidPluginBuildService {
 			await this.buildPlugin({
 				gradlePath: options.gradlePath,
 				gradleArgs: options.gradleArgs,
+				abiFilters: options.abiFilters,
 				pluginDir: pluginTempDir,
 				pluginName: options.pluginName,
 				projectDir: options.projectDir,
@@ -821,6 +834,19 @@ export class AndroidPluginBuildService implements IAndroidPluginBuildService {
 			localArgs.push(pluginBuildSettings.gradleArgs);
 		}
 
+		// nothing in the gradle files generated here acts on `abiFilters` - it is
+		// passed for a plugin whose own include.gradle reads it to narrow a long
+		// native build down. An explicit `-PabiFilters` in the gradle args wins.
+		if (
+			pluginBuildSettings.abiFilters &&
+			pluginBuildSettings.abiFilters.length &&
+			(pluginBuildSettings.gradleArgs || "").indexOf("-PabiFilters") === -1
+		) {
+			localArgs.push(
+				`-PabiFilters=${pluginBuildSettings.abiFilters.join(",")}`
+			);
+		}
+
 		if (this.$logger.getLevel() === "INFO") {
 			localArgs.push("--quiet");
 		}

lib/services/android-project-service.ts

@@ -49,6 +49,7 @@ import { injector } from "../common/yok";
 import { INotConfiguredEnvOptions } from "../common/definitions/commands";
 import { AndroidPrepareData } from "../data/prepare-data";
 import { IProjectChangesInfo } from "../definitions/project-changes";
+import { getDevicesAbis } from "./android/devices-abis";
 
 interface NativeDependency {
 	name: string;
@@ -695,6 +696,7 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 			const options: IPluginBuildOptions = {
 				gradlePath: this.$options.gradlePath,
 				gradleArgs: this.$options.gradleArgs,
+				abiFilters: this.getPluginsAbiFilters(),
 				projectDir: projectData.projectDir,
 				pluginName: pluginData.name,
 				platformsAndroidDirPath: pluginPlatformsFolderPath,
@@ -710,6 +712,27 @@ 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.
+	 */
+	private getPluginsAbiFilters(): string[] {
+		if (!this.$options.filterPluginsDevicesArch) {
+			return null;
+		}
+
+		const abis = getDevicesAbis(
+			this.$devicesService,
+			this.$devicePlatformsConstants.Android,
+			{ device: this.$options.device, emulator: this.$options.emulator }
+		);
+
+		return abis.length ? abis : null;
+	}
+
 	public async processConfigurationFilesFromAppResources(): Promise<void> {
 		return;
 	}

lib/services/android/devices-abis.ts

@@ -0,0 +1,23 @@
+import * as _ from "lodash";
+
+/**
+ * The ABIs of the devices a build is about to be deployed to - the first (most
+ * preferred) ABI of every device, deduplicated. `device`/`emulator` narrow the
+ * set down the same way they narrow the run itself.
+ */
+export function getDevicesAbis(
+	$devicesService: Mobile.IDevicesService,
+	platform: string,
+	filter: { device?: string; emulator?: boolean } = {}
+): string[] {
+	let devices = $devicesService.getDevicesForPlatform(platform);
+	if (filter.device) {
+		devices = devices.filter((d) => d.deviceInfo.identifier === filter.device);
+	} else if (filter.emulator) {
+		devices = devices.filter((d) => d.isEmulator);
+	}
+
+	return _.uniq(
+		devices.map((d) => (d.deviceInfo.abis || [])[0]).filter((abi) => !!abi)
+	);
+}

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

@@ -9,6 +9,7 @@ import {
 import { IAndroidBuildData } from "../../definitions/build";
 import { IChildProcess } from "../../common/declarations";
 import { injector } from "../../common/yok";
+import { getDevicesAbis } from "./devices-abis";
 import * as _ from "lodash";
 
 export class GradleBuildService
@@ -75,22 +76,10 @@ export class GradleBuildService
 			return;
 		}
 
-		let devices = this.$devicesService.getDevicesForPlatform(
-			buildData.platform
-		);
-		if (buildData.device) {
-			devices = devices.filter(
-				(d) => d.deviceInfo.identifier === buildData.device
-			);
-		} else if (buildData.emulator) {
-			devices = devices.filter((d) => d.isEmulator);
-		}
-
-		const abis = _.uniq(
-			devices
-				.map((d) => (d.deviceInfo.abis || [])[0])
-				.filter((abi) => !!abi)
-		);
+		const abis = getDevicesAbis(this.$devicesService, buildData.platform, {
+			device: buildData.device,
+			emulator: buildData.emulator,
+		});
 
 		if (abis.length) {
 			buildTaskArgs.push(`-PabiFilters=${abis.join(",")}`);

test/services/android-project-service.ts

@@ -19,6 +19,7 @@ import {
 	IFileSystem,
 	IProjectDir,
 } from "../../lib/common/declarations";
+import { IPluginBuildOptions } from "../../lib/definitions/android-plugin-migrator";
 
 const createTestInjector = (): IInjector => {
 	const testInjector = new Yok();
@@ -410,3 +411,91 @@ describe("androidProjectService", () => {
 		});
 	});
 });
+
+describe("androidProjectService plugins abi filtering", () => {
+	const createDevice = (
+		identifier: string,
+		abis: string[],
+		isEmulator = false
+	): any => ({
+		deviceInfo: { identifier, abis, platform: "android" },
+		isEmulator,
+	});
+
+	const preparePluginNativeCode = async (
+		options: any,
+		devices: any[]
+	): Promise<IPluginBuildOptions> => {
+		const testInjector = createTestInjector();
+		let pluginBuildOptions: IPluginBuildOptions = null;
+		testInjector.register("androidPluginBuildService", {
+			buildAar: async (opts: IPluginBuildOptions): Promise<boolean> => {
+				pluginBuildOptions = opts;
+				return false;
+			},
+			migrateIncludeGradle: (): boolean => false,
+		});
+		testInjector.register("options", {
+			hostProjectModuleName: "app",
+			...options,
+		});
+		testInjector.register("devicesService", {
+			getDevicesForPlatform: (): any[] => devices,
+		});
+		testInjector.register("devicePlatformsConstants", { Android: "Android" });
+
+		const androidProjectService: IPlatformProjectService = testInjector.resolve(
+			"androidProjectService"
+		);
+		await androidProjectService.preparePluginNativeCode(
+			<any>{
+				name: "my-plugin",
+				pluginPlatformsFolderPath: (): string => "pluginPlatformsDir",
+			},
+			<any>{ projectDir: "projectDir", platformsDir: "platformsDir" }
+		);
+
+		return pluginBuildOptions;
+	};
+
+	it("passes the abis of the connected devices when the option is set", async () => {
+		const options = await preparePluginNativeCode(
+			{ filterPluginsDevicesArch: true },
+			[
+				createDevice("device1", ["arm64-v8a", "armeabi-v7a"]),
+				createDevice("emulator1", ["x86_64", "x86"], true),
+			]
+		);
+
+		assert.deepStrictEqual(options.abiFilters, ["arm64-v8a", "x86_64"]);
+	});
+
+	it("passes the abi of the selected device only", async () => {
+		const options = await preparePluginNativeCode(
+			{ filterPluginsDevicesArch: true, device: "device1" },
+			[
+				createDevice("device1", ["arm64-v8a"]),
+				createDevice("emulator1", ["x86_64"], true),
+			]
+		);
+
+		assert.deepStrictEqual(options.abiFilters, ["arm64-v8a"]);
+	});
+
+	it("passes no abis when the option is not set", async () => {
+		const options = await preparePluginNativeCode({}, [
+			createDevice("device1", ["arm64-v8a"]),
+		]);
+
+		assert.isNull(options.abiFilters);
+	});
+
+	it("passes no abis when no device reports its abis", async () => {
+		const options = await preparePluginNativeCode(
+			{ filterPluginsDevicesArch: true },
+			[createDevice("device1", [])]
+		);
+
+		assert.isNull(options.abiFilters);
+	});
+});