Add the new checks for Android SDK Tools

Author: TsvetanMilanov

lib/android-tools-info.ts

@@ -1,9 +1,10 @@
-import * as path from "path";
-import * as semver from "semver";
-import { EOL } from "os";
 import { ChildProcess } from "./wrappers/child-process";
 import { FileSystem } from "./wrappers/file-system";
 import { HostInfo } from "./host-info";
+import { Constants } from "./constants";
+import { EOL } from "os";
+import * as semver from "semver";
+import * as path from "path";
 
 export class AndroidToolsInfo implements NativeScriptDoctor.IAndroidToolsInfo {
 	private static ANDROID_TARGET_PREFIX = "android";
@@ -15,6 +16,7 @@ export class AndroidToolsInfo implements NativeScriptDoctor.IAndroidToolsInfo {
 
 	private toolsInfo: NativeScriptDoctor.IAndroidToolsInfoData;
 	private androidHome = process.env["ANDROID_HOME"];
+	private pathToEmulatorExecutable: string;
 
 	constructor(private childProcess: ChildProcess,
 		private fs: FileSystem,
@@ -34,13 +36,16 @@ export class AndroidToolsInfo implements NativeScriptDoctor.IAndroidToolsInfo {
 		return this.toolsInfo;
 	}
 
-	public validateInfo(): string[] {
-		const errors: string[] = [];
+	public validateInfo(): NativeScriptDoctor.IWarning[] {
+		const errors: NativeScriptDoctor.IWarning[] = [];
 		const toolsInfoData = this.getToolsInfo();
 		const isAndroidHomeValid = this.validateAndroidHomeEnvVariable();
 		if (!toolsInfoData.compileSdkVersion) {
-			errors.push(`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 \`\$ ${this.getPathToSdkManagementTool()}\` to manage your Android SDK versions.`);
+			errors.push({
+				warning: `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.`,
+				additionalInformation: `Run \`\$ ${this.getPathToSdkManagementTool()}\` to manage your Android SDK versions.`,
+				platforms: [Constants.ANDROID_PLATFORM_NAME]
+			});
 		}
 
 		if (!toolsInfoData.buildToolsVersion) {
@@ -58,33 +63,50 @@ export class AndroidToolsInfo implements NativeScriptDoctor.IAndroidToolsInfo {
 				invalidBuildToolsAdditionalMsg += ' In case you already have them installed, make sure `ANDROID_HOME` environment variable is set correctly.';
 			}
 
-			errors.push("You need to have the Android SDK Build-tools installed on your system. " + message, invalidBuildToolsAdditionalMsg);
+			errors.push({
+				warning: "You need to have the Android SDK Build-tools installed on your system. " + message,
+				additionalInformation: invalidBuildToolsAdditionalMsg,
+				platforms: [Constants.ANDROID_PLATFORM_NAME]
+			});
 		}
 
 		if (!toolsInfoData.supportRepositoryVersion) {
 			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.';
 			}
-			errors.push(`You need to have Android SDK ${AndroidToolsInfo.MIN_REQUIRED_COMPILE_TARGET} or later and the latest Android Support Repository installed on your system.`, invalidSupportLibAdditionalMsg);
+
+			errors.push({
+				warning: `You need to have Android SDK ${AndroidToolsInfo.MIN_REQUIRED_COMPILE_TARGET} or later and the latest Android Support Repository installed on your system.`,
+				additionalInformation: invalidSupportLibAdditionalMsg,
+				platforms: [Constants.ANDROID_PLATFORM_NAME]
+			});
 		}
 
 		return errors;
 	}
 
-	public validateJavacVersion(installedJavaVersion: string): string[] {
-		const errors: string[] = [];
+	public validateJavacVersion(installedJavaVersion: string): NativeScriptDoctor.IWarning[] {
+		const errors: NativeScriptDoctor.IWarning[] = [];
 
 		let additionalMessage = "You will not be able to build your projects for Android." + EOL
 			+ "To be able to build for Android, verify that you have installed The Java Development Kit (JDK) and configured it according to system requirements as" + EOL +
 			" described in " + this.getSystemRequirementsLink();
 		let matchingVersion = (installedJavaVersion || "").match(AndroidToolsInfo.VERSION_REGEX);
 		if (matchingVersion && matchingVersion[1]) {
 			if (semver.lt(matchingVersion[1], AndroidToolsInfo.MIN_JAVA_VERSION)) {
-				errors.push(`Javac version ${installedJavaVersion} is not supported. You have to install at least ${AndroidToolsInfo.MIN_JAVA_VERSION}.`, additionalMessage);
+				errors.push({
+					warning: `Javac version ${installedJavaVersion} is not supported. You have to install at least ${AndroidToolsInfo.MIN_JAVA_VERSION}.`,
+					additionalInformation: additionalMessage,
+					platforms: [Constants.ANDROID_PLATFORM_NAME]
+				});
 			}
 		} else {
-			errors.push("Error executing command 'javac'. Make sure you have installed The Java Development Kit (JDK) and set JAVA_HOME environment variable.", additionalMessage);
+			errors.push({
+				warning: "Error executing command 'javac'. Make sure you have installed The Java Development Kit (JDK) and set JAVA_HOME environment variable.",
+				additionalInformation: additionalMessage,
+				platforms: [Constants.ANDROID_PLATFORM_NAME]
+			});
 		}
 
 		return errors;
@@ -104,22 +126,51 @@ export class AndroidToolsInfo implements NativeScriptDoctor.IAndroidToolsInfo {
 		return null;
 	}
 
-	public validateAndroidHomeEnvVariable(): string[] {
-		const errors: string[] = [];
+	public validateAndroidHomeEnvVariable(): NativeScriptDoctor.IWarning[] {
+		const errors: NativeScriptDoctor.IWarning[] = [];
 		const expectedDirectoriesInAndroidHome = ["build-tools", "tools", "platform-tools", "extras"];
 
 		if (!this.androidHome || !this.fs.exists(this.androidHome)) {
-			errors.push("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.");
+			errors.push({
+				warning: "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.",
+				additionalInformation: "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.",
+				platforms: [Constants.ANDROID_PLATFORM_NAME]
+			});
 		} else if (expectedDirectoriesInAndroidHome.map(dir => this.fs.exists(path.join(this.androidHome, dir))).length === 0) {
-			errors.push("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.");
+			errors.push({
+				warning: "The ANDROID_HOME environment variable points to incorrect directory. You will not be able to perform any build-related operations for Android.",
+				additionalInformation: "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.",
+				platforms: [Constants.ANDROID_PLATFORM_NAME]
+			});
 		}
 
 		return errors;
 	}
 
+	public getPathToEmulatorExecutable(): string {
+		if (!this.pathToEmulatorExecutable) {
+			const emulatorExecutableName = "emulator";
+
+			this.pathToEmulatorExecutable = emulatorExecutableName;
+
+			if (this.androidHome) {
+				// Check https://developer.android.com/studio/releases/sdk-tools.html (25.3.0)
+				// Since this version of SDK tools, the emulator is a separate package.
+				// However the emulator executable still exists in the "tools" dir.
+				const pathToEmulatorFromAndroidStudio = path.join(this.androidHome, emulatorExecutableName, emulatorExecutableName);
+
+				if (this.fs.exists(pathToEmulatorFromAndroidStudio)) {
+					this.pathToEmulatorExecutable = pathToEmulatorFromAndroidStudio;
+				} else {
+					this.pathToEmulatorExecutable = path.join(this.androidHome, "tools", emulatorExecutableName);
+				}
+			}
+		}
+
+		return this.pathToEmulatorExecutable;
+	}
+
 	private getPathToSdkManagementTool(): string {
 		const sdkmanagerName = "sdkmanager";
 		let sdkManagementToolPath = sdkmanagerName;
@@ -217,7 +268,7 @@ export class AndroidToolsInfo implements NativeScriptDoctor.IAndroidToolsInfo {
 		const sortedAndroidToolsInfo = AndroidToolsInfo.SUPPORTED_TARGETS.sort();
 
 		sortedAndroidToolsInfo.forEach(s => {
-			if (installedTargets.includes(s)) {
+			if (installedTargets.indexOf(s) >= 0) {
 				latestValidAndroidTarget = s;
 			}
 		});

lib/doctor.ts

@@ -13,7 +13,8 @@ export class Doctor implements NativeScriptDoctor.IDoctor {
 		private helpers: Helpers,
 		private hostInfo: HostInfo,
 		private iOSLocalBuildRequirements: IosLocalBuildRequirements,
-		private sysInfo: NativeScriptDoctor.ISysInfo) { }
+		private sysInfo: NativeScriptDoctor.ISysInfo,
+		private androidToolsInfo: NativeScriptDoctor.IAndroidToolsInfo) { }
 
 	public async canExecuteLocalBuild(platform: string): Promise<boolean> {
 		this.validatePlatform(platform);
@@ -28,30 +29,47 @@ export class Doctor implements NativeScriptDoctor.IDoctor {
 	}
 
 	public async getWarnings(): Promise<NativeScriptDoctor.IWarning[]> {
-		const result: NativeScriptDoctor.IWarning[] = [];
+		let result: NativeScriptDoctor.IWarning[] = [];
 		const sysInfoData = await this.sysInfo.getSysInfo();
 
+		const androidHomeValidationErrors = this.androidToolsInfo.validateAndroidHomeEnvVariable();
+		if (androidHomeValidationErrors.length > 0) {
+			result = result.concat(androidHomeValidationErrors);
+		}
+
 		if (!sysInfoData.adbVer) {
 			result.push({
 				warning: "WARNING: adb from the Android SDK is not installed or is not configured properly. ",
-				additionalInformation: "For Android-related operations, the AppBuilder CLI will use a built-in version of adb." + EOL
+				additionalInformation: "For Android-related operations, the NativeScript CLI will use a built-in version of adb." + EOL
 				+ "To avoid possible issues with the native Android emulator, Genymotion or connected" + EOL
 				+ "Android devices, verify that you have installed the latest Android SDK and" + EOL
-				+ "its dependencies as described in http://developer.android.com/sdk/index.html#Requirements" + EOL,
+				+ "its dependencies as described in http://developer.android.com/sdk/index.html#Requirements" + EOL
+				+ this.getPackageManagerTip(),
 				platforms: [Constants.ANDROID_PLATFORM_NAME]
 			});
 		}
 
-		if (!sysInfoData.androidInstalled) {
+		if (!sysInfoData.isAndroidSdkConfiguredCorrectly) {
 			result.push({
 				warning: "WARNING: The Android SDK is not installed or is not configured properly.",
 				additionalInformation: "You will not be able to run your apps in the native emulator. To be able to run apps" + EOL
 				+ "in the native Android emulator, verify that you have installed the latest Android SDK " + EOL
-				+ "and its dependencies as described in http://developer.android.com/sdk/index.html#Requirements" + EOL,
+				+ "and its dependencies as described in http://developer.android.com/sdk/index.html#Requirements" + EOL
+				+ this.getPackageManagerTip(),
 				platforms: [Constants.ANDROID_PLATFORM_NAME]
 			});
 		}
 
+		const androidToolsInfoValidationErrors = this.androidToolsInfo.validateInfo();
+		if (androidToolsInfoValidationErrors.length > 0) {
+			result = result.concat(androidToolsInfoValidationErrors);
+		}
+
+		const javacValidationErrors = this.androidToolsInfo.validateJavacVersion(sysInfoData.javacVersion);
+		if (javacValidationErrors.length > 0) {
+			result = result.concat(javacValidationErrors);
+		}
+
 		if (this.hostInfo.isDarwin) {
 			if (!sysInfoData.xcodeVer) {
 				result.push({
@@ -153,4 +171,12 @@ export class Doctor implements NativeScriptDoctor.IDoctor {
 			throw new Error(`Platform ${platform} is not supported.The supported platforms are: ${Constants.SUPPORTED_PLATFORMS.join(", ")} `);
 		}
 	}
+
+	private getPackageManagerTip(): string {
+		if (this.hostInfo.isWindows) {
+			return "TIP: To avoid setting up the necessary environment variables, you can use the chocolatey package manager to install the Android SDK and its dependencies." + EOL;
+		} else if (this.hostInfo.isDarwin) {
+			return "TIP: To avoid setting up the necessary environment variables, you can use the Homebrew package manager to install the Android SDK and its dependencies." + EOL;
+		}
+	}
 }

lib/index.ts

@@ -2,6 +2,7 @@ import { ChildProcess } from "./wrappers/child-process";
 import { FileSystem } from "./wrappers/file-system";
 import { SysInfo } from "./sys-info";
 import { HostInfo } from "./host-info";
+import { AndroidToolsInfo } from "./android-tools-info";
 import { WinReg } from "./winreg";
 import { Helpers } from "./helpers";
 import { Doctor } from "./doctor";
@@ -14,19 +15,21 @@ const winReg = new WinReg();
 const hostInfo = new HostInfo(winReg);
 const fileSystem = new FileSystem();
 const helpers = new Helpers();
+const androidToolsInfo = new AndroidToolsInfo(childProcess, fileSystem, hostInfo);
 
-const sysInfo: NativeScriptDoctor.ISysInfo = new SysInfo(childProcess, fileSystem, helpers, hostInfo, winReg);
+const sysInfo: NativeScriptDoctor.ISysInfo = new SysInfo(childProcess, fileSystem, helpers, hostInfo, winReg, androidToolsInfo);
 
 const androidLocalBuildRequirements = new AndroidLocalBuildRequirements(sysInfo);
 const iOSLocalBuildRequirements = new IosLocalBuildRequirements(sysInfo, hostInfo);
 
-const doctor: NativeScriptDoctor.IDoctor = new Doctor(androidLocalBuildRequirements, helpers, hostInfo, iOSLocalBuildRequirements, sysInfo);
+const doctor: NativeScriptDoctor.IDoctor = new Doctor(androidLocalBuildRequirements, helpers, hostInfo, iOSLocalBuildRequirements, sysInfo, androidToolsInfo);
 
 const setShouldCacheSysInfo = sysInfo.setShouldCacheSysInfo.bind(sysInfo);
 
 export {
 	sysInfo,
 	doctor,
 	constants,
-	setShouldCacheSysInfo
+	setShouldCacheSysInfo,
+	androidToolsInfo
 };

lib/sys-info.ts

@@ -42,12 +42,14 @@ export class SysInfo implements NativeScriptDoctor.ISysInfo {
 	private xcprojInfoCache: NativeScriptDoctor.IXcprojInfo;
 	private isCocoaPodsUpdateRequiredCache: boolean = null;
 	private shouldCache: boolean = true;
+	private isAndroidSdkConfiguredCorrectlyCache: boolean = null;
 
 	constructor(private childProcess: ChildProcess,
 		private fileSystem: FileSystem,
 		private helpers: Helpers,
 		private hostInfo: HostInfo,
-		private winReg: WinReg) { }
+		private winReg: WinReg,
+		private androidToolsInfo: NativeScriptDoctor.IAndroidToolsInfo) { }
 
 	public getJavaVersion(): Promise<string> {
 		return this.getValueForProperty(() => this.javaVerCache, async (): Promise<string> => {
@@ -158,29 +160,31 @@ export class SysInfo implements NativeScriptDoctor.ISysInfo {
 
 	public getAdbVersion(): Promise<string> {
 		return this.getValueForProperty(() => this.adbVerCache, async (): Promise<string> => {
-			const output = await this.execCommand("adb version");
+			const output = await this.execCommand(`${await this.androidToolsInfo.getPathToAdbFromAndroidHome()} version`);
 			return output ? this.getVersionFromString(output) : null;
 		});
 	}
 
-	// `android -h` returns exit code 1 on successful invocation (Mac OS X for now, possibly Linux).
 	public isAndroidInstalled(): Promise<boolean> {
 		return this.getValueForProperty(() => this.androidInstalledCache, async (): Promise<boolean> => {
-			let pathToAndroid = "android";
-			if (this.hostInfo.isWindows) {
-				pathToAndroid = `${pathToAndroid}.bat`;
+			try {
+				const errors = this.androidToolsInfo.validateAndroidHomeEnvVariable();
+				return errors.length === 0;
+			} catch (err) {
+				return false;
 			}
+		});
+	}
 
+	public async isAndroidSdkConfiguredCorrectly(): Promise<boolean> {
+		return this.getValueForProperty(() => this.isAndroidSdkConfiguredCorrectlyCache, async (): Promise<boolean> => {
 			try {
-				// On mac android -h returns exit code 1. That's why we need to ignore the error.
-				const output = await this.childProcess.spawnFromEvent(pathToAndroid, ["-h"], "close", { ignoreError: true });
-				if (output) {
-					output.stdout = output.stdout || '';
-					return output.stdout.indexOf("android") >= 0;
-				}
+				await this.childProcess.execFile(this.androidToolsInfo.getPathToEmulatorExecutable(), ['-help']);
 			} catch (err) {
-				return null;
+				return false;
 			}
+
+			return true;
 		});
 	}
 
@@ -240,6 +244,7 @@ export class SysInfo implements NativeScriptDoctor.ISysInfo {
 			result.isCocoaPodsWorkingCorrectly = await this.isCocoaPodsWorkingCorrectly();
 			result.nativeScriptCliVersion = await this.getNativeScriptCliVersion();
 			result.isCocoaPodsUpdateRequired = await this.isCocoaPodsUpdateRequired();
+			result.isAndroidSdkConfiguredCorrectly = await this.isAndroidSdkConfiguredCorrectly();
 
 			return result;
 		});