Fix getting info for Android tools (#2611)

* Fix getting info for Android tools

Due to changes in Android SDK, we have to update the checks in CLI. While gathering system information, we check the android executable, which is no longer returning correct results.

We use the android executable to find information about installed Android SDKs and to construct correct paths based on ANDROID_HOME. Fix this by listing directories inside ANDROID_HOME and find the information about installed SDKs from there.
Fix messages pointing to `android` executable to point to `sdkmanager` (in case it exists).

In order to fix this, we rely on the emulator executable, which is the real thing we need as it is the one that allows us to work with Android Emulators (this is changed in mobile-cli-lib).
Fix sys-info checks and get correct path to emulator according to latest changes.

* Fix `emulate android --available-devices`

The command `tns emulate android --available-devices` should list the available Android Virtual Devices on the current machine.
It uses `android list avd` command which is no longer available. The alternative is to use the new `$ANDROID_HOME/tools/bin/avdmanager` executable or use the way we already have in the mobile-cli-lib - parse the `.ini` files of each device.
Use the methods from `androidEmulatorServices` so the code will work with both old and new SDKs.

* Fix getting installed Android SDKs

Author: rosen-vladimirov

lib/android-tools-info.ts

@@ -1,6 +1,6 @@
 import * as path from "path";
 import * as semver from "semver";
-import {EOL} from "os";
+import { EOL } from "os";
 
 export class AndroidToolsInfo implements IAndroidToolsInfo {
 	private static ANDROID_TARGET_PREFIX = "android";
@@ -15,69 +15,15 @@ export class AndroidToolsInfo implements IAndroidToolsInfo {
 	private selectedCompileSdk: number;
 	private installedTargetsCache: string[] = null;
 	private androidHome = process.env["ANDROID_HOME"];
-	private pathToAndroidExecutable: string;
-	private _androidExecutableName: string;
-	private get androidExecutableName(): string {
-		if (!this._androidExecutableName) {
-			this._androidExecutableName = "android";
-			if (this.$hostInfo.isWindows) {
-				this._androidExecutableName += ".bat";
-			}
-		}
-
-		return this._androidExecutableName;
-	}
 
 	constructor(private $childProcess: IChildProcess,
 		private $errors: IErrors,
 		private $fs: IFileSystem,
 		private $hostInfo: IHostInfo,
 		private $logger: ILogger,
 		private $options: IOptions,
-		private $adb: Mobile.IAndroidDebugBridge,
 		protected $staticConfig: Config.IStaticConfig) { }
 
-	public getPathToAndroidExecutable(options?: { showWarningsAsErrors: boolean }): IFuture<string> {
-		return ((): string => {
-			if (options) {
-				this.showWarningsAsErrors = options.showWarningsAsErrors;
-			}
-			if (!this.pathToAndroidExecutable) {
-				if (this.validateAndroidHomeEnvVariable(this.androidHome)) {
-					let androidPath = path.join(this.androidHome, "tools", this.androidExecutableName);
-					if (!this.trySetAndroidPath(androidPath).wait() && !this.trySetAndroidPath(this.androidExecutableName).wait()) {
-						this.printMessage(`Unable to find "${this.androidExecutableName}" executable file. Make sure you have set ANDROID_HOME environment variable correctly.`);
-					}
-				} else {
-					this.$logger.trace("ANDROID_HOME environment variable is not set correctly.");
-				}
-			}
-
-			return this.pathToAndroidExecutable;
-		}).future<string>()();
-	}
-
-	private trySetAndroidPath(androidPath: string): IFuture<boolean> {
-		return ((): boolean => {
-			let isAndroidPathCorrect = true;
-			try {
-				let result = this.$adb.executeCommand(["--help"], { returnChildProcess: true }).wait();
-				if (result && result.stdout) {
-					this.$logger.trace(result.stdout);
-					this.pathToAndroidExecutable = androidPath;
-				} else {
-					this.$logger.trace(`Unable to find android executable from '${androidPath}'.`);
-					isAndroidPathCorrect = false;
-				}
-			} catch (err) {
-				this.$logger.trace(`Error occurred while checking androidExecutable from '${androidPath}'. ${err.message}`);
-				isAndroidPathCorrect = false;
-			}
-
-			return isAndroidPathCorrect;
-		}).future<boolean>()();
-	}
-
 	public getToolsInfo(): IFuture<IAndroidToolsInfoData> {
 		return ((): IAndroidToolsInfoData => {
 			if (!this.toolsInfo) {
@@ -101,10 +47,10 @@ export class AndroidToolsInfo implements IAndroidToolsInfo {
 			let detectedErrors = false;
 			this.showWarningsAsErrors = options && options.showWarningsAsErrors;
 			let toolsInfoData = this.getToolsInfo().wait();
-			let isAndroidHomeValid = this.validateAndroidHomeEnvVariable(toolsInfoData.androidHomeEnvVar);
+			let isAndroidHomeValid = this.validateAndroidHomeEnvVariable();
 			if (!toolsInfoData.compileSdkVersion) {
 				this.printMessage(`Cannot find a compatible Android SDK for compilation. To be able to build for Android, install Android SDK ${AndroidToolsInfo.MIN_REQUIRED_COMPILE_TARGET} or later.`,
-					"Run `$ android` to manage your Android SDK versions.");
+					`Run \`\$ ${this.getPathToSdkManagementTool()}\` to manage your Android SDK versions.`);
 				detectedErrors = true;
 			}
 
@@ -118,7 +64,7 @@ export class AndroidToolsInfo implements IAndroidToolsInfo {
 					message = `You have to install version ${versionRangeMatches[1]}.`;
 				}
 
-				let invalidBuildToolsAdditionalMsg = 'Run `android` from your command-line to install required `Android Build Tools`.';
+				let invalidBuildToolsAdditionalMsg = `Run \`\$ ${this.getPathToSdkManagementTool()}\` from your command-line to install required \`Android Build Tools\`.`;
 				if (!isAndroidHomeValid) {
 					invalidBuildToolsAdditionalMsg += ' In case you already have them installed, make sure `ANDROID_HOME` environment variable is set correctly.';
 				}
@@ -128,7 +74,7 @@ export class AndroidToolsInfo implements IAndroidToolsInfo {
 			}
 
 			if (!toolsInfoData.supportRepositoryVersion) {
-				let invalidSupportLibAdditionalMsg = 'Run `$ android`  to manage the Android Support Repository.';
+				let invalidSupportLibAdditionalMsg = `Run \`\$ ${this.getPathToSdkManagementTool()}\` to manage the Android Support Repository.`;
 				if (!isAndroidHomeValid) {
 					invalidSupportLibAdditionalMsg += ' In case you already have it installed, make sure `ANDROID_HOME` environment variable is set correctly.';
 				}
@@ -198,6 +144,54 @@ export class AndroidToolsInfo implements IAndroidToolsInfo {
 		}).future<string>()();
 	}
 
+	private _cachedAndroidHomeValidationResult: boolean = null;
+	public validateAndroidHomeEnvVariable(options?: { showWarningsAsErrors: boolean }): boolean {
+		if (this._cachedAndroidHomeValidationResult === null) {
+			if (options) {
+				this.showWarningsAsErrors = options.showWarningsAsErrors;
+			}
+
+			this._cachedAndroidHomeValidationResult = true;
+			let expectedDirectoriesInAndroidHome = ["build-tools", "tools", "platform-tools", "extras"];
+			if (!this.androidHome || !this.$fs.exists(this.androidHome)) {
+				this.printMessage("The ANDROID_HOME environment variable is not set or it points to a non-existent directory. You will not be able to perform any build-related operations for Android.",
+					"To be able to perform Android build-related operations, set the `ANDROID_HOME` variable to point to the root of your Android SDK installation directory.");
+				this._cachedAndroidHomeValidationResult = false;
+			} else if (!_.some(expectedDirectoriesInAndroidHome.map(dir => this.$fs.exists(path.join(this.androidHome, dir))))) {
+				this.printMessage("The ANDROID_HOME environment variable points to incorrect directory. You will not be able to perform any build-related operations for Android.",
+					"To be able to perform Android build-related operations, set the `ANDROID_HOME` variable to point to the root of your Android SDK installation directory, " +
+					"where you will find `tools` and `platform-tools` directories.");
+				this._cachedAndroidHomeValidationResult = false;
+			}
+		}
+
+		return this._cachedAndroidHomeValidationResult;
+	}
+
+	private _cachedPathToSdkManagementTool: string;
+	private getPathToSdkManagementTool(): string {
+		if (!this._cachedPathToSdkManagementTool) {
+			const sdkmanagerName = "sdkmanager";
+			this._cachedPathToSdkManagementTool = sdkmanagerName;
+
+			const isAndroidHomeValid = this.validateAndroidHomeEnvVariable();
+
+			if (isAndroidHomeValid) {
+				// In case ANDROID_HOME is correct, check if sdkmanager exists and if not it means the SDK has not been updated.
+				// In this case user shoud use `android` from the command-line instead of sdkmanager.
+				const pathToSdkmanager = path.join(this.androidHome, "tools", "bin", sdkmanagerName);
+				const pathToAndroidExecutable = path.join(this.androidHome, "tools", "android");
+				const pathToExecutable = this.$fs.exists(pathToSdkmanager) ? pathToSdkmanager : pathToAndroidExecutable;
+
+				this.$logger.trace(`Path to Android SDK Management tool is: ${pathToExecutable}`);
+
+				this._cachedPathToSdkManagementTool = pathToExecutable.replace(this.androidHome, this.$hostInfo.isWindows ? "%ANDROID_HOME%" : "$ANDROID_HOME");
+			}
+		}
+
+		return this._cachedPathToSdkManagementTool;
+	}
+
 	private shouldGenerateTypings(): boolean {
 		return this.$options.androidTypings;
 	}
@@ -343,45 +337,25 @@ export class AndroidToolsInfo implements IAndroidToolsInfo {
 		return (() => {
 			if (!this.installedTargetsCache) {
 				try {
-					let pathToAndroidExecutable = this.getPathToAndroidExecutable().wait();
-					if (pathToAndroidExecutable) {
-						let result = this.$childProcess.spawnFromEvent(pathToAndroidExecutable, ["list", "targets"], "close", {}, { throwError: false }).wait();
-						if (result && result.stdout) {
-							this.$logger.trace(result.stdout);
-							this.installedTargetsCache = [];
-							result.stdout.replace(/id: \d+ or "(.+)"/g, (m: string, p1: string) => (this.installedTargetsCache.push(p1), m));
-						}
+					this.installedTargetsCache = [];
+					const pathToInstalledTargets = path.join(this.androidHome, "platforms");
+					if (this.$fs.exists(pathToInstalledTargets)) {
+						this.installedTargetsCache = this.$fs.readDirectory(pathToInstalledTargets);
+						this.$logger.trace("Installed Android Targets are: ", this.installedTargetsCache);
 					}
+
+					this.$logger.trace("Installed Android Targets are: ", this.installedTargetsCache);
 				} catch (err) {
 					this.$logger.trace("Unable to get Android targets. Error is: " + err);
 				}
 			}
+
 			return this.installedTargetsCache;
 		}).future<string[]>()();
 	}
 
 	private getMaxSupportedVersion(): number {
 		return this.parseAndroidSdkString(_.last(AndroidToolsInfo.SUPPORTED_TARGETS.sort()));
 	}
-
-	private _cachedAndroidHomeValidationResult: boolean = null;
-	private validateAndroidHomeEnvVariable(androidHomeEnvVar: string): boolean {
-		if (this._cachedAndroidHomeValidationResult === null) {
-			this._cachedAndroidHomeValidationResult = true;
-			let expectedDirectoriesInAndroidHome = ["build-tools", "tools", "platform-tools", "extras"];
-			if (!androidHomeEnvVar || !this.$fs.exists(androidHomeEnvVar)) {
-				this.printMessage("The ANDROID_HOME environment variable is not set or it points to a non-existent directory. You will not be able to perform any build-related operations for Android.",
-					"To be able to perform Android build-related operations, set the `ANDROID_HOME` variable to point to the root of your Android SDK installation directory.");
-				this._cachedAndroidHomeValidationResult = false;
-			} else if (!_.some(expectedDirectoriesInAndroidHome.map(dir => this.$fs.exists(path.join(androidHomeEnvVar, dir))))) {
-				this.printMessage("The ANDROID_HOME environment variable points to incorrect directory. You will not be able to perform any build-related operations for Android.",
-					"To be able to perform Android build-related operations, set the `ANDROID_HOME` variable to point to the root of your Android SDK installation directory, " +
-					"where you will find `tools` and `platform-tools` directories.");
-				this._cachedAndroidHomeValidationResult = false;
-			}
-		}
-
-		return this._cachedAndroidHomeValidationResult;
-	}
 }
 $injector.register("androidToolsInfo", AndroidToolsInfo);

lib/common

@@ -176,12 +176,11 @@ interface IAndroidToolsInfo {
 	validateJavacVersion(installedJavaVersion: string, options?: { showWarningsAsErrors: boolean }): IFuture<boolean>;
 
 	/**
-	 * Returns the path to `android` executable. It should be `$ANDROID_HOME/tools/android`.
-	 * In case ANDROID_HOME is not defined, check if `android` is part of $PATH.
+	 * Validates if ANDROID_HOME environment variable is set correctly.
 	 * @param {any} options Defines if the warning messages should treated as error.
-	 * @return {string} Path to the `android` executable.
+	 * @returns {boolean} true in case ANDROID_HOME is correctly set, false otherwise.
 	 */
-	getPathToAndroidExecutable(options?: { showWarningsAsErrors: boolean }): IFuture<string>;
+	validateAndroidHomeEnvVariable(options?: { showWarningsAsErrors: boolean }): boolean;
 
 	/**
 	 * Gets the path to `adb` executable from ANDROID_HOME. It should be `$ANDROID_HOME/platform-tools/adb` in case it exists.

lib/declarations.ts

@@ -92,8 +92,7 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 			this.validatePackageName(this.$projectData.projectId);
 			this.validateProjectName(this.$projectData.projectName);
 
-			// this call will fail in case `android` is not set correctly.
-			this.$androidToolsInfo.getPathToAndroidExecutable({ showWarningsAsErrors: true }).wait();
+			this.$androidToolsInfo.validateAndroidHomeEnvVariable({ showWarningsAsErrors: true });
 			let javaCompilerVersion = this.$sysInfo.getJavaCompilerVersion().wait();
 			this.$androidToolsInfo.validateJavacVersion(javaCompilerVersion, { showWarningsAsErrors: true }).wait();
 		}).future<void>()();

lib/services/android-project-service.ts

@@ -47,7 +47,7 @@ class DoctorService implements IDoctorService {
 				result = true;
 			}
 
-			if (!sysInfo.androidInstalled) {
+			if (!sysInfo.emulatorInstalled) {
 				this.$logger.warn("WARNING: The Android SDK is not installed or is not configured properly.");
 				this.$logger.out("You will not be able to build your projects for Android and run them in the native emulator." + EOL
 					+ "To be able to build for Android and run apps in the native emulator, verify that you have" + EOL