refactor: refactor gradle related part of android-project-service

* remove the support for targetSdk
* extract the logic to separate services

Author: Fatme

lib/bootstrap.ts

@@ -11,6 +11,9 @@ $injector.require("performanceService", "./services/performance-service");
 $injector.requirePublic("projectService", "./services/project-service");
 $injector.require("androidProjectService", "./services/android-project-service");
 $injector.require("androidPluginBuildService", "./services/android-plugin-build-service");
+$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("iOSEntitlementsService", "./services/ios-entitlements-service");
 $injector.require("iOSExtensionsService", "./services/ios-extensions-service");
 $injector.require("iOSProjectService", "./services/ios-project-service");

lib/definitions/gradle.d.ts

@@ -0,0 +1,24 @@
+interface IGradleCommandService {
+	executeCommand(gradleArgs: string[], options: IGradleCommandOptions): Promise<ISpawnResult>;
+}
+
+interface IGradleCommandOptions { 
+	message?: string;
+	cwd: string;
+	stdio?: string;
+	spawnOptions?: any;
+}
+
+interface IAndroidBuildConfig extends IRelease, IAndroidReleaseOptions, IHasAndroidBundle {
+	buildOutputStdio?: string;
+}
+
+interface IGradleBuildService {
+	buildProject(projectRoot: string, buildConfig: IAndroidBuildConfig): Promise<void>;
+	cleanProject(projectRoot: string, buildConfig: IAndroidBuildConfig): Promise<void>;
+}
+
+interface IGradleBuildArgsService {
+	getBuildTaskArgs(buildConfig: IAndroidBuildConfig): string[];
+	getCleanTaskArgs(buildConfig: IAndroidBuildConfig): string[];
+}

lib/definitions/project.d.ts

@@ -439,10 +439,10 @@ interface IPlatformProjectService extends NodeJS.EventEmitter, IPlatformProjectS
 	/**
 	 * Stops all running processes that might hold a lock on the filesystem.
 	 * Android: Gradle daemon processes are terminated.
-	 * @param {string} projectRoot The root directory of the native project.
+	 * @param {IPlatformData} platformData The data for the specified platform.
 	 * @returns {void}
 	 */
-	stopServices(projectRoot: string): Promise<ISpawnResult>;
+	stopServices(platformData: IPlatformData): Promise<ISpawnResult>;
 
 	/**
 	 * Removes build artifacts specific to the platform

lib/services/android-project-service.ts

@@ -4,9 +4,7 @@ import * as constants from "../constants";
 import * as semver from "semver";
 import * as projectServiceBaseLib from "./platform-project-service-base";
 import { DeviceAndroidDebugBridge } from "../common/mobile/android/device-android-debug-bridge";
-import { attachAwaitDetach } from "../common/helpers";
 import { Configurations, LiveSyncPaths } from "../common/constants";
-import { SpawnOptions } from "child_process";
 import { performanceLog } from ".././common/decorators";
 
 export class AndroidProjectService extends projectServiceBaseLib.PlatformProjectServiceBase implements IPlatformProjectService {
@@ -18,18 +16,18 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 	private isAndroidStudioTemplate: boolean;
 
 	constructor(private $androidToolsInfo: IAndroidToolsInfo,
-		private $childProcess: IChildProcess,
 		private $errors: IErrors,
 		$fs: IFileSystem,
-		private $hostInfo: IHostInfo,
 		private $logger: ILogger,
 		$projectDataService: IProjectDataService,
 		private $injector: IInjector,
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		private $androidPluginBuildService: IAndroidPluginBuildService,
 		private $platformEnvironmentRequirements: IPlatformEnvironmentRequirements,
 		private $androidResourcesMigrationService: IAndroidResourcesMigrationService,
-		private $filesHashService: IFilesHashService) {
+		private $filesHashService: IFilesHashService,
+		private $gradleCommandService: IGradleCommandService,
+		private $gradleBuildService: IGradleBuildService) {
 		super($fs, $projectDataService);
 		this.isAndroidStudioTemplate = false;
 	}
@@ -277,76 +275,13 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 
 	@performanceLog()
 	public async buildProject(projectRoot: string, projectData: IProjectData, buildConfig: IBuildConfig): Promise<void> {
-		let task;
-		const gradleArgs = this.getGradleBuildOptions(buildConfig, projectData);
-		const baseTask = buildConfig.androidBundle ? "bundle" : "assemble";
 		const platformData = this.getPlatformData(projectData);
-		const outputPath = buildConfig.androidBundle ? platformData.bundleBuildOutputPath : platformData.getBuildOutputPath(buildConfig);
-		if (this.$logger.getLevel() === "TRACE") {
-			gradleArgs.unshift("--stacktrace");
-			gradleArgs.unshift("--debug");
-		}
-		if (buildConfig.release) {
-			task = `${baseTask}Release`;
-		} else {
-			task = `${baseTask}Debug`;
-		}
-
-		gradleArgs.unshift(task);
-
-		const handler = (data: any) => {
-			this.emit(constants.BUILD_OUTPUT_EVENT_NAME, data);
-		};
-
-		await attachAwaitDetach(constants.BUILD_OUTPUT_EVENT_NAME,
-			this.$childProcess,
-			handler,
-			this.executeCommand({
-				projectRoot: this.getPlatformData(projectData).projectRoot,
-				gradleArgs,
-				childProcessOpts: { stdio: buildConfig.buildOutputStdio || "inherit" },
-				spawnFromEventOptions: { emitOptions: { eventName: constants.BUILD_OUTPUT_EVENT_NAME }, throwError: true },
-				message: "Gradle build..."
-			})
-		);
+		await this.$gradleBuildService.buildProject(platformData.projectRoot, buildConfig);
 
+		const outputPath = buildConfig.androidBundle ? platformData.bundleBuildOutputPath : platformData.getBuildOutputPath(buildConfig);
 		await this.$filesHashService.saveHashesForProject(this._platformData, outputPath);
 	}
 
-	private getGradleBuildOptions(settings: IAndroidBuildOptionsSettings, projectData: IProjectData): Array<string> {
-		const configurationFilePath = this.getPlatformData(projectData).configurationFilePath;
-
-		const buildOptions: Array<string> = this.getBuildOptions(configurationFilePath);
-
-		if (settings.release) {
-			buildOptions.push("-Prelease");
-			buildOptions.push(`-PksPath=${path.resolve(settings.keyStorePath)}`);
-			buildOptions.push(`-Palias=${settings.keyStoreAlias}`);
-			buildOptions.push(`-Ppassword=${settings.keyStoreAliasPassword}`);
-			buildOptions.push(`-PksPassword=${settings.keyStorePassword}`);
-		}
-
-		return buildOptions;
-	}
-
-	private getBuildOptions(configurationFilePath?: string): Array<string> {
-		this.$androidToolsInfo.validateInfo({ showWarningsAsErrors: true, validateTargetSdk: true });
-
-		const androidToolsInfo = this.$androidToolsInfo.getToolsInfo();
-		const compileSdk = androidToolsInfo.compileSdkVersion;
-		const targetSdk = this.getTargetFromAndroidManifest(configurationFilePath) || compileSdk;
-		const buildToolsVersion = androidToolsInfo.buildToolsVersion;
-		const generateTypings = androidToolsInfo.generateTypings;
-		const buildOptions = [
-			`-PcompileSdk=android-${compileSdk}`,
-			`-PtargetSdk=${targetSdk}`,
-			`-PbuildToolsVersion=${buildToolsVersion}`,
-			`-PgenerateTypings=${generateTypings}`
-		];
-
-		return buildOptions;
-	}
-
 	public async buildForDeploy(projectRoot: string, projectData: IProjectData, buildConfig?: IBuildConfig): Promise<void> {
 		return this.buildProject(projectRoot, projectData, buildConfig);
 	}
@@ -456,25 +391,19 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 		return nativescript && (nativescript.android || (nativescript.platforms && nativescript.platforms.android));
 	}
 
-	public stopServices(projectRoot: string): Promise<ISpawnResult> {
-		return this.executeCommand({
-			projectRoot,
-			gradleArgs: ["--stop", "--quiet"],
-			childProcessOpts: { stdio: "pipe" },
-			message: "Gradle stop services..."
+	public async stopServices(platformData: IPlatformData): Promise<ISpawnResult> {
+		const result = await this.$gradleCommandService.executeCommand(["--stop", "--quiet"], {
+			cwd: platformData.projectRoot,
+			message: "Gradle stop services...",
+			stdio: "pipe"
 		});
+
+		return result;
 	}
 
 	public async cleanProject(projectRoot: string, projectData: IProjectData): Promise<void> {
-		if (this.$androidToolsInfo.getToolsInfo().androidHomeEnvVar) {
-			const gradleArgs = this.getGradleBuildOptions({ release: false }, projectData);
-			gradleArgs.unshift("clean");
-			await this.executeCommand({
-				projectRoot,
-				gradleArgs,
-				message: "Gradle clean..."
-			});
-		}
+		// TODO: Check why there isn't a clean release build and a clean release aab build
+		await this.$gradleBuildService.cleanProject(projectRoot, { release: false });
 	}
 
 	public async cleanDeviceTempFolder(deviceIdentifier: string, projectData: IProjectData): Promise<void> {
@@ -494,10 +423,6 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 		shell.cp(cpArg, paths, projectRoot);
 	}
 
-	private async spawn(command: string, args: string[], opts?: any, spawnOpts?: ISpawnFromEventOptions): Promise<ISpawnResult> {
-		return this.$childProcess.spawnFromEvent(command, args, "close", opts || { stdio: "inherit" }, spawnOpts);
-	}
-
 	private validatePackageName(packageName: string): void {
 		//Make the package conform to Java package types
 		//Enforce underscore limitation
@@ -522,49 +447,6 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 		}
 	}
 
-	private getTargetFromAndroidManifest(configurationFilePath: string): string {
-		let versionInManifest: string;
-		if (this.$fs.exists(configurationFilePath)) {
-			const targetFromAndroidManifest: string = this.$fs.readText(configurationFilePath);
-			if (targetFromAndroidManifest) {
-				const match = targetFromAndroidManifest.match(/.*?android:targetSdkVersion=\"(.*?)\"/);
-				if (match && match[1]) {
-					versionInManifest = match[1];
-				}
-			}
-		}
-
-		return versionInManifest;
-	}
-
-	private async executeCommand(opts: { projectRoot: string, gradleArgs: any, childProcessOpts?: SpawnOptions, spawnFromEventOptions?: ISpawnFromEventOptions, message: string }): Promise<ISpawnResult> {
-		if (this.$androidToolsInfo.getToolsInfo().androidHomeEnvVar) {
-			const { projectRoot, gradleArgs, message, spawnFromEventOptions } = opts;
-			const gradlew = this.$hostInfo.isWindows ? "gradlew.bat" : "./gradlew";
-
-			if (this.$logger.getLevel() === "INFO") {
-				gradleArgs.push("--quiet");
-			}
-
-			this.$logger.info(message);
-
-			const childProcessOpts = opts.childProcessOpts || {};
-			childProcessOpts.cwd = childProcessOpts.cwd || projectRoot;
-			childProcessOpts.stdio = childProcessOpts.stdio || "inherit";
-			let commandResult;
-			try {
-				commandResult = await this.spawn(gradlew,
-					gradleArgs,
-					childProcessOpts,
-					spawnFromEventOptions);
-			} catch (err) {
-				this.$errors.failWithoutHelp(err.message);
-			}
-
-			return commandResult;
-		}
-	}
-
 	private isAndroidStudioCompatibleTemplate(projectData: IProjectData, frameworkVersion?: string): boolean {
 		const currentPlatformData: IDictionary<any> = this.$projectDataService.getNSValue(projectData.projectDir, constants.TNS_ANDROID_RUNTIME_NAME);
 		const platformVersion = (currentPlatformData && currentPlatformData[constants.VERSION_STRING]) || frameworkVersion;

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

@@ -0,0 +1,65 @@
+import * as path from "path";
+import { Configurations } from "../../common/constants";
+
+export class GradleBuildArgsService implements IGradleBuildArgsService {
+	constructor(private $androidToolsInfo: IAndroidToolsInfo,
+		private $logger: ILogger) { }
+
+	public getBuildTaskArgs(buildConfig: IAndroidBuildConfig): string[] {
+		const args = this.getBaseTaskArgs(buildConfig);
+		args.unshift(this.getBuildTaskName(buildConfig));
+
+		return args;
+	}
+
+	public getCleanTaskArgs(buildConfig: IAndroidBuildConfig): string[] {
+		const args = this.getBaseTaskArgs(buildConfig);
+		args.unshift("clean");
+
+		return args;
+	}
+
+	private getBaseTaskArgs(buildConfig: IAndroidBuildConfig): string[] {
+		const args = this.getBuildLoggingArgs();
+
+		const toolsInfo = this.$androidToolsInfo.getToolsInfo();
+		args.push(
+			`-PcompileSdk=android-${toolsInfo.compileSdkVersion}`,
+			`-PbuildToolsVersion=${toolsInfo.buildToolsVersion}`,
+			`-PgenerateTypings=${toolsInfo.generateTypings}`
+		);
+
+		if (buildConfig.release) {
+			args.push(
+				"-Prelease",
+				`-PksPath=${path.resolve(buildConfig.keyStorePath)}`,
+				`-Palias=${buildConfig.keyStoreAlias}`,
+				`-Ppassword=${buildConfig.keyStoreAliasPassword}`,
+				`-PksPassword=${buildConfig.keyStorePassword}`
+			);
+		}
+
+		return args;
+	}
+
+	private getBuildLoggingArgs(): string[] {
+		const args = [];
+
+		const logLevel = this.$logger.getLevel();
+		if (logLevel === "TRACE") {
+			args.push("--stacktrace", "--debug");
+		} else if (logLevel === "INFO") {
+			args.push("--quiet");
+		}
+
+		return args;
+	}
+
+	private getBuildTaskName(buildConfig: IAndroidBuildConfig): string {
+		const baseTaskName = buildConfig.androidBundle ? "bundle" : "assemble";
+		const buildTaskName = buildConfig.release ? `${baseTaskName}${Configurations.Release}` : `${baseTaskName}${Configurations.Debug}`;
+
+		return buildTaskName;
+	}
+}
+$injector.register("gradleBuildArgsService", GradleBuildArgsService);

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

@@ -0,0 +1,30 @@
+import { attachAwaitDetach } from "../../common/helpers";
+import * as constants from "../../constants";
+import { EventEmitter } from "events";
+
+export class GradleBuildService extends EventEmitter implements IGradleBuildService {
+	constructor(
+		private $childProcess: IChildProcess,
+		private $gradleBuildArgsService: IGradleBuildArgsService,
+		private $gradleCommandService: IGradleCommandService,
+	) { super(); }
+
+	public async buildProject(projectRoot: string, buildConfig: IAndroidBuildConfig): Promise<void> {
+		const buildTaskArgs = this.$gradleBuildArgsService.getBuildTaskArgs(buildConfig);
+		const spawnOptions = { emitOptions: { eventName: constants.BUILD_OUTPUT_EVENT_NAME }, throwError: true };
+		const gradleCommandOptions = { cwd: projectRoot, message: "Gradle build...", stdio: buildConfig.buildOutputStdio, spawnOptions };
+
+		await attachAwaitDetach(constants.BUILD_OUTPUT_EVENT_NAME,
+			this.$childProcess,
+			(data: any) => this.emit(constants.BUILD_OUTPUT_EVENT_NAME, data),
+			this.$gradleCommandService.executeCommand(buildTaskArgs, gradleCommandOptions)
+		);
+	}
+
+	public async cleanProject(projectRoot: string, buildConfig: IAndroidBuildConfig): Promise<void> {
+		const cleanTaskArgs = this.$gradleBuildArgsService.getCleanTaskArgs(buildConfig);
+		const gradleCommandOptions = { cwd: projectRoot, message: "Gradle clean..." };
+		await this.$gradleCommandService.executeCommand(cleanTaskArgs, gradleCommandOptions);
+	}
+}
+$injector.register("gradleBuildService", GradleBuildService);

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

@@ -0,0 +1,31 @@
+export class GradleCommandService implements IGradleCommandService {
+	constructor(
+		private $childProcess: IChildProcess,
+		private $errors: IErrors,
+		private $hostInfo: IHostInfo,
+		private $logger: ILogger
+	) { }
+
+	public async executeCommand(gradleArgs: string[], options: IGradleCommandOptions): Promise<ISpawnResult> {
+		const { message, cwd, stdio = "inherit", spawnOptions } = options;
+		this.$logger.info(message);
+
+		const childProcessOptions = { cwd, stdio };
+		const gradleExecutable = this.$hostInfo.isWindows ? "gradlew.bat" : "./gradlew";
+
+		const result = await this.executeCommandSafe(gradleExecutable, gradleArgs, childProcessOptions, spawnOptions);
+
+		return result;
+	}
+
+	private async executeCommandSafe(gradleExecutable: string, gradleArgs: string[], childProcessOptions: any, spawnOptions: any) {
+		try {
+			const result = await this.$childProcess.spawnFromEvent(gradleExecutable, gradleArgs, "close", childProcessOptions, spawnOptions);
+
+			return result;
+		} catch (err) {
+			this.$errors.failWithoutHelp(err.message);
+		}
+	}
+}
+$injector.register("gradleCommandService", GradleCommandService);