feat: support aab in run and deploy

Author: DimitarTachev

lib/bootstrap.ts

@@ -14,6 +14,7 @@ $injector.require("androidPluginBuildService", "./services/android-plugin-build-
 $injector.require("gradleCommandService", "./services/android/gradle-command-service");
 $injector.require("gradleBuildService", "./services/android/gradle-build-service");
 $injector.require("gradleBuildArgsService", "./services/android/gradle-build-args-service");
+$injector.require("androidBundleToolService", "./services/android/android-bundle-tool-service");
 $injector.require("iOSEntitlementsService", "./services/ios-entitlements-service");
 $injector.require("iOSNativeTargetService", "./services/ios-native-target-service");
 $injector.require("iOSExtensionsService", "./services/ios-extensions-service");

lib/commands/debug.ts

@@ -16,7 +16,6 @@ export class DebugPlatformCommand extends ValidatePlatformCommandBase implements
 		private $debugDataService: IDebugDataService,
 		private $debugController: IDebugController,
 		private $liveSyncCommandHelper: ILiveSyncCommandHelper,
-		private $androidBundleValidatorHelper: IAndroidBundleValidatorHelper,
 		private $migrateController: IMigrateController) {
 		super($options, $platformsDataService, $platformValidationService, $projectData);
 		$cleanupService.setShouldDispose(false);
@@ -57,8 +56,6 @@ export class DebugPlatformCommand extends ValidatePlatformCommandBase implements
 			await this.$migrateController.validate({ projectDir: this.$projectData.projectDir, platforms: [this.platform] });
 		}
 
-		this.$androidBundleValidatorHelper.validateNoAab();
-
 		if (!this.$platformValidationService.isPlatformSupportedForOS(this.platform, this.$projectData)) {
 			this.$errors.fail(`Applications for platform ${this.platform} can not be built on this OS`);
 		}

lib/commands/deploy.ts

@@ -18,7 +18,6 @@ export class DeployOnDeviceCommand extends ValidatePlatformCommandBase implement
 		private $mobileHelper: Mobile.IMobileHelper,
 		$platformsDataService: IPlatformsDataService,
 		private $deployCommandHelper: DeployCommandHelper,
-		private $androidBundleValidatorHelper: IAndroidBundleValidatorHelper,
 		private $markingModeService: IMarkingModeService,
 		private $migrateController: IMigrateController) {
 		super($options, $platformsDataService, $platformValidationService, $projectData);
@@ -40,7 +39,6 @@ export class DeployOnDeviceCommand extends ValidatePlatformCommandBase implement
 			await this.$migrateController.validate({ projectDir: this.$projectData.projectDir, platforms: [platform] });
 		}
 
-		this.$androidBundleValidatorHelper.validateNoAab();
 		if (!args || !args.length || args.length > 1) {
 			return false;
 		}

lib/commands/run.ts

@@ -8,7 +8,6 @@ export class RunCommandBase implements ICommand {
 	public platform: string;
 	constructor(
 		private $analyticsService: IAnalyticsService,
-		private $androidBundleValidatorHelper: IAndroidBundleValidatorHelper,
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		private $errors: IErrors,
 		private $hostInfo: IHostInfo,
@@ -34,7 +33,6 @@ export class RunCommandBase implements ICommand {
 			this.platform = this.$devicePlatformsConstants.Android;
 		}
 
-		this.$androidBundleValidatorHelper.validateNoAab();
 		this.$projectData.initializeProjectData();
 		const platforms = this.platform ? [this.platform] : [this.$devicePlatformsConstants.Android, this.$devicePlatformsConstants.iOS];
 

lib/common/child-process.ts

@@ -157,8 +157,8 @@ export class ChildProcess extends EventEmitter implements IChildProcess {
 
 	public async trySpawnFromCloseEvent(command: string, args: string[], options?: any, spawnFromEventOptions?: ISpawnFromEventOptions): Promise<ISpawnResult> {
 		try {
-			const childProcess = await this.spawnFromEvent(command, args, "close", options, spawnFromEventOptions);
-			return childProcess;
+			const childProcessResult = await this.spawnFromEvent(command, args, "close", options, spawnFromEventOptions);
+			return childProcessResult;
 		} catch (err) {
 			this.$logger.trace(`Error from trySpawnFromCloseEvent method. More info: ${err}`);
 			return Promise.resolve({ stderr: err && err.message ? err.message : err, stdout: null, exitCode: -1 });

lib/common/declarations.d.ts

@@ -1001,6 +1001,11 @@ interface ISysInfo {
  	 * @return {Promise<string>} Returns the currently installed version of Xcode or null if Xcode is not installed or executed on Linux or Windows.
  	 */
 	getXcodeVersion(): Promise<string>;
+	/**
+	 * Returns the currently installed Java path based on JAVA_HOME and PATH..
+	 * @return {Promise<string>} The currently installed Java path.
+	 */
+	getJavaPath(): Promise<string>;
 	/**
 	 * Returns the currently installed Cocoapods version.
 	 * @return {Promise<string>} Returns the currently installed Cocoapods version. It will return null if Cocoapods is not installed.

lib/common/definitions/mobile.d.ts

@@ -321,9 +321,9 @@ declare global {
 		interface IDeviceApplicationManager extends NodeJS.EventEmitter {
 			getInstalledApplications(): Promise<string[]>;
 			isApplicationInstalled(appIdentifier: string): Promise<boolean>;
-			installApplication(packageFilePath: string, appIdentifier?: string): Promise<void>;
+			installApplication(packageFilePath: string, appIdentifier?: string, buildData?: IBuildData): Promise<void>;
 			uninstallApplication(appIdentifier: string): Promise<void>;
-			reinstallApplication(appIdentifier: string, packageFilePath: string): Promise<void>;
+			reinstallApplication(appIdentifier: string, packageFilePath: string, buildData?: IBuildData): Promise<void>;
 			startApplication(appData: IStartApplicationData): Promise<void>;
 			stopApplication(appData: IApplicationData): Promise<void>;
 			restartApplication(appData: IStartApplicationData): Promise<void>;

lib/common/mobile/android/android-application-manager.ts

@@ -3,13 +3,17 @@ import { ApplicationManagerBase } from "../application-manager-base";
 import { TARGET_FRAMEWORK_IDENTIFIERS, LiveSyncPaths } from "../../constants";
 import { hook, sleep, regExpEscape } from "../../helpers";
 import { cache } from "../../decorators";
+import { parse, join } from "path";
+import { AAB_EXTENSION_NAME, APKS_EXTENSION_NAME } from "../../../constants";
 
 export class AndroidApplicationManager extends ApplicationManagerBase {
 	public PID_CHECK_INTERVAL = 100;
 	public PID_CHECK_TIMEOUT = 10000; // 10 secs
 
 	constructor(private adb: Mobile.IDeviceAndroidDebugBridge,
 		private identifier: string,
+		private $androidBundleToolService: IAndroidBundleToolService,
+		private $fs: IFileSystem,
 		private $options: IOptions,
 		private $logcatHelper: Mobile.ILogcatHelper,
 		private $androidProcessService: Mobile.IAndroidProcessService,
@@ -33,13 +37,29 @@ export class AndroidApplicationManager extends ApplicationManagerBase {
 	}
 
 	@hook('install')
-	public async installApplication(packageFilePath: string, appIdentifier?: string): Promise<void> {
+	public async installApplication(packageFilePath: string, appIdentifier?: string, buildData?: IAndroidBuildData): Promise<void> {
 		if (appIdentifier) {
 			const deviceRootPath = `${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appIdentifier}`;
 			await this.adb.executeShellCommand(["rm", "-rf", deviceRootPath]);
 		}
 
-		return this.adb.executeCommand(["install", "-r", `${packageFilePath}`]);
+		const { dir, name, ext } = parse(packageFilePath);
+		if (ext === AAB_EXTENSION_NAME) {
+			const apksOutputPath = join(dir, name) + APKS_EXTENSION_NAME;
+			if (!this.hasValidApksFile(packageFilePath, apksOutputPath)) {
+				await this.$androidBundleToolService.buildApks({
+					aabFilePath: packageFilePath,
+					apksOutputPath,
+					signingData: <IAndroidSigningData>buildData
+				});
+			}
+			await this.$androidBundleToolService.installApks({
+				apksFilePath: apksOutputPath,
+				deviceId: this.identifier
+			});
+		} else {
+			return this.adb.executeCommand(["install", "-r", `${packageFilePath}`]);
+		}
 	}
 
 	public uninstallApplication(appIdentifier: string): Promise<void> {
@@ -155,4 +175,15 @@ export class AndroidApplicationManager extends ApplicationManagerBase {
 
 		return new RegExp(`${regExpEscape(appIdentifier)}${packageActivitySeparator}${fullJavaClassName}`, `m`);
 	}
+
+	private hasValidApksFile(aabFilaPath: string, apksFilePath: string): boolean {
+		let isValid = false;
+		if (this.$fs.exists(apksFilePath)) {
+			const lastUpdatedApks = this.$fs.getFsStats(apksFilePath).ctime.getTime();
+			const lastUpdatedAab = this.$fs.getFsStats(aabFilaPath).ctime.getTime();
+			isValid = lastUpdatedApks >= lastUpdatedAab;
+		}
+
+		return isValid;
+	}
 }

lib/common/mobile/application-manager-base.ts

@@ -18,14 +18,14 @@ export abstract class ApplicationManagerBase extends EventEmitter implements Mob
 		}
 	}
 
-	public async reinstallApplication(appIdentifier: string, packageFilePath: string): Promise<void> {
+	public async reinstallApplication(appIdentifier: string, packageFilePath: string, buildData?: IBuildData): Promise<void> {
 		const isApplicationInstalled = await this.isApplicationInstalled(appIdentifier);
 
 		if (isApplicationInstalled) {
 			await this.uninstallApplication(appIdentifier);
 		}
 
-		await this.installApplication(packageFilePath, appIdentifier);
+		await this.installApplication(packageFilePath, appIdentifier, buildData);
 	}
 
 	public async restartApplication(appData: Mobile.IApplicationData): Promise<void> {
@@ -83,7 +83,7 @@ export abstract class ApplicationManagerBase extends EventEmitter implements Mob
 		}
 	}
 
-	public abstract async installApplication(packageFilePath: string, appIdentifier?: string): Promise<void>;
+	public abstract async installApplication(packageFilePath: string, appIdentifier?: string, buildData?: IBuildData): Promise<void>;
 	public abstract async uninstallApplication(appIdentifier: string): Promise<void>;
 	public abstract async startApplication(appData: Mobile.IApplicationData): Promise<void>;
 	public abstract async stopApplication(appData: Mobile.IApplicationData): Promise<void>;

lib/common/test/unit-tests/android-application-manager.ts

@@ -1,13 +1,16 @@
 import { AndroidApplicationManager } from "../../mobile/android/android-application-manager";
 import { Yok } from "../../yok";
 import { assert } from "chai";
-import { CommonLoggerStub, LogcatHelperStub, AndroidProcessServiceStub, DeviceLogProviderStub, ErrorsStub } from "./stubs";
+import { AndroidBundleToolServiceStub, CommonLoggerStub, HooksServiceStub, LogcatHelperStub, AndroidProcessServiceStub, DeviceLogProviderStub, ErrorsStub } from "./stubs";
+import { FileSystemStub } from "../../../../test/stubs";
 const invalidIdentifier = "invalid.identifier";
 const validDeviceIdentifier = "device.identifier";
 const validIdentifier = "org.nativescript.testApp";
 const validStartOptions = { appId: validIdentifier, projectName: "", projectDir: "" };
+const validSigning: any = { keyStoreAlias: "string", keyStorePath: "string", keyStoreAliasPassword: "string", keyStorePassword: "string" };
 
 class AndroidDebugBridgeStub {
+	public calledInstallApplication = false;
 	public calledStopApplication = false;
 	public startedWithActivityManager = false;
 	public validIdentifierPassed = false;
@@ -42,6 +45,12 @@ class AndroidDebugBridgeStub {
 			frontOfTask=true task=TaskRecord{fe592ac #449 A=org.nativescript.testApp U=0 StackId=1 sz=1}"
 	];
 
+	public async executeCommand(args: string[], options?: any): Promise<any> {
+		if (args[0] === "install") {
+			this.calledInstallApplication = true;
+		}
+	}
+
 	public async executeShellCommand(args: string[]): Promise<any> {
 		if (args && args.length > 0) {
 			if (args[0].startsWith("cat")) {
@@ -111,9 +120,11 @@ function createTestInjector(options?: {
 	testInjector.register("identifier", validDeviceIdentifier);
 	testInjector.register("logcatHelper", LogcatHelperStub);
 	testInjector.register("androidProcessService", AndroidProcessServiceStub);
+	testInjector.register("androidBundleToolService", AndroidBundleToolServiceStub);
+	testInjector.register("fs", FileSystemStub);
 	testInjector.register("httpClient", {});
 	testInjector.register("deviceLogProvider", DeviceLogProviderStub);
-	testInjector.register("hooksService", {});
+	testInjector.register("hooksService", HooksServiceStub);
 	return testInjector;
 }
 
@@ -140,6 +151,7 @@ describe("android-application-manager", () => {
 	}
 
 	describe("startApplication", () => {
+
 		it("fires up the right application", async () => {
 			setup();
 			for (let i = 0; i < androidDebugBridge.getInputLength(); i++) {
@@ -244,6 +256,55 @@ describe("android-application-manager", () => {
 		});
 	});
 
+	describe("installApplication", () => {
+		afterEach(function () {
+			androidDebugBridge.calledInstallApplication = false;
+			const bundleToolService = testInjector.resolve<AndroidBundleToolServiceStub>("androidBundleToolService");
+			bundleToolService.isBuildApksCalled = false;
+			bundleToolService.isInstallApksCalled = false;
+		});
+
+		it("should install apk using adb", async () => {
+			const bundleToolService = testInjector.resolve<AndroidBundleToolServiceStub>("androidBundleToolService");
+
+			await androidApplicationManager.installApplication("myApp.apk");
+
+			assert.isFalse(bundleToolService.isBuildApksCalled);
+			assert.isFalse(bundleToolService.isInstallApksCalled);
+			assert.isTrue(androidDebugBridge.calledInstallApplication);
+		});
+
+		it("should install aab using bundletool", async () => {
+			const bundleToolService = testInjector.resolve<AndroidBundleToolServiceStub>("androidBundleToolService");
+
+			await androidApplicationManager.installApplication("myApp.aab");
+
+			assert.isTrue(bundleToolService.isBuildApksCalled);
+			assert.isTrue(bundleToolService.isInstallApksCalled);
+			assert.isFalse(androidDebugBridge.calledInstallApplication);
+		});
+
+		it("should skip aab build when already built", async () => {
+			const fsStub = testInjector.resolve<FileSystemStub>("fs");
+			const bundleToolService = testInjector.resolve<AndroidBundleToolServiceStub>("androidBundleToolService");
+
+			await androidApplicationManager.installApplication("myApp.aab", "my.app", validSigning);
+
+			assert.isTrue(bundleToolService.isBuildApksCalled);
+			assert.isTrue(bundleToolService.isInstallApksCalled);
+			assert.isFalse(androidDebugBridge.calledInstallApplication);
+
+			fsStub.fsStatCache["myApp.aab"] = fsStub.fsStatCache["myApp.apks"];
+			bundleToolService.isBuildApksCalled = false;
+			bundleToolService.isInstallApksCalled = false;
+			await androidApplicationManager.installApplication("myApp.aab", "my.app", validSigning);
+
+			assert.isFalse(bundleToolService.isBuildApksCalled);
+			assert.isTrue(bundleToolService.isInstallApksCalled);
+			assert.isFalse(androidDebugBridge.calledInstallApplication);
+		});
+	});
+
 	describe("stopApplication", () => {
 		it("should stop the logcat helper", async () => {
 			setup();