feat: Validate Javac version with Android runtime version

In NativeScript 4.1.0 we add support for Java 10. However, older versions of the Android runtime cannot work with Java 10, so verification for the current environment and local builds depends on the current Android runtime version.
In order to handle this, add projectDir parameter to the API. In case it is passed, we'll check if Android Runtime version is specified in the package.json and we'll verify if it is supported for the current Java version.

Author: rosen-vladimirov

README.md

@@ -137,7 +137,7 @@ Library that helps identifying if the environment can be used for development of
 		const pythonInfo = await sysInfo.getPythonInfo();
 		console.log("python info: ", pythonInfo );
 
-		const sysInfoData = await sysInfo.getSysInfo();
+		const sysInfoData = await sysInfo.getSysInfo({ projectDir: "/Users/username/myProject" });
 		console.log("sysInfo: ", sysInfoData);
 
 		const gitPath = await sysInfo.getGitPath();
@@ -454,12 +454,13 @@ Library that helps identifying if the environment can be used for development of
 	import { androidToolsInfo } from "nativescript-doctor"
 
 	function main() {
+		const projectDir = "/Users/username/myProject";
 		console.log("path to adb from android home: ", await androidToolsInfo.getPathToAdbFromAndroidHome());
 		console.log("path to emulator executable: ", androidToolsInfo.getPathToEmulatorExecutable());
 		console.log("android tools info: ", androidToolsInfo.getToolsInfo());
 		console.log("ANROID_HOME validation errors: ", await androidToolsInfo.validateAndroidHomeEnvVariable());
 		console.log("android tools info validation errors: ", await androidToolsInfo.validateInfo());
-		console.log("javac validation errors: ", await androidToolsInfo.validateJavacVersion(await sysInfo.getJavaCompilerVersion()));
+		console.log("javac validation errors: ", await androidToolsInfo.validateJavacVersion(await sysInfo.getJavaCompilerVersion(), projectDir));
 	}
 
 	main();
@@ -478,16 +479,20 @@ Library that helps identifying if the environment can be used for development of
 
 		/**
 		 * Checks if the Android tools are valid.
+		 * @param {string} projectDir @optional The project directory. Used to determine the Android Runtime version and validate the Java compiler version against it.
+		 * If it is not passed or the project does not have Android runtime, this validation is skipped.
 		 * @return {NativeScriptDoctor.IWarning[]} An array of errors from the validation checks. If there are no errors will return [].
 		 */
-		validateInfo(): NativeScriptDoctor.IWarning[];
+		validateInfo(projectDir?: string): NativeScriptDoctor.IWarning[];
 
 		/**
 		 * Checks if the current javac version is valid.
 		 * @param {string} installedJavaVersion The version of javac to check.
+		 * @param {string} projectDir @optional The project directory. Used to determine the Android Runtime version and validate the Java compiler version against it.
+		 * If it is not passed or the project does not have Android runtime, this validation is skipped.
 		 * @return {NativeScriptDoctor.IWarning[]} An array of errors from the validation checks. If there are no errors will return [].
 		 */
-		validateJavacVersion(installedJavaVersion: string): NativeScriptDoctor.IWarning[];
+		validateJavacVersion(installedJavaVersion: string, projectDir?: string): NativeScriptDoctor.IWarning[];
 
 		/**
 		 * Returns the path to the adb which is located in ANDROID_HOME.

lib/android-tools-info.ts

@@ -38,7 +38,7 @@ export class AndroidToolsInfo implements NativeScriptDoctor.IAndroidToolsInfo {
 		return this.toolsInfo;
 	}
 
-	public validateInfo(): NativeScriptDoctor.IWarning[] {
+	public validateInfo(projectDir?: string): NativeScriptDoctor.IWarning[] {
 		const errors: NativeScriptDoctor.IWarning[] = [];
 		const toolsInfoData = this.getToolsInfo();
 		const isAndroidHomeValid = this.isAndroidHomeValid();
@@ -88,7 +88,7 @@ export class AndroidToolsInfo implements NativeScriptDoctor.IAndroidToolsInfo {
 		return errors;
 	}
 
-	public validateJavacVersion(installedJavaCompilerVersion: string): NativeScriptDoctor.IWarning[] {
+	public validateJavacVersion(installedJavaCompilerVersion: string, projectDir?: string): NativeScriptDoctor.IWarning[] {
 		const errors: NativeScriptDoctor.IWarning[] = [];
 
 		let additionalMessage = "You will not be able to build your projects for Android." + EOL
@@ -100,8 +100,31 @@ export class AndroidToolsInfo implements NativeScriptDoctor.IAndroidToolsInfo {
 		if (installedJavaCompilerSemverVersion) {
 			let warning: string = null;
 
+			const supportedVersions: IDictionary<string> = {
+				"^10.0.0": "4.1.0-2018.5.18.1"
+			};
+
 			if (semver.lt(installedJavaCompilerSemverVersion, AndroidToolsInfo.MIN_JAVA_VERSION)) {
 				warning = `Javac version ${installedJavaCompilerVersion} is not supported. You have to install at least ${AndroidToolsInfo.MIN_JAVA_VERSION}.`;
+			} else {
+				const runtimeVersion = this.getAndroidRuntimeVersionFromProjectDir(projectDir);
+				if (runtimeVersion) {
+					// get the item from the dictionary that corresponds to our current Javac version:
+					let runtimeMinVersion: string = null;
+					Object.keys(supportedVersions)
+						.forEach(javacRange => {
+							if (semver.satisfies(installedJavaCompilerSemverVersion, javacRange)) {
+								runtimeMinVersion = supportedVersions[javacRange];
+							}
+						});
+
+					if (runtimeMinVersion && semver.lt(runtimeVersion, runtimeMinVersion)) {
+						warning = `The Java compiler version ${installedJavaCompilerVersion} is not compatible with the current Android runtime version ${runtimeVersion}. ` +
+							`In order to use this Javac version, you need to update your Android runtime or downgrade your Java compiler version.`;
+						additionalMessage = "You will not be able to build your projects for Android." + EOL +
+							"To be able to build for Android, downgrade your Java compiler version or update your Android runtime.";
+					}
+				}
 			}
 
 			if (warning) {
@@ -320,4 +343,36 @@ export class AndroidToolsInfo implements NativeScriptDoctor.IAndroidToolsInfo {
 		const errors = this.validateAndroidHomeEnvVariable();
 		return !errors && !errors.length;
 	}
+
+	private getAndroidRuntimeVersionFromProjectDir(projectDir: string): string {
+		let runtimeVersion: string = null;
+		if (projectDir && this.fs.exists(projectDir)) {
+			const pathToPackageJson = path.join(projectDir, Constants.PACKAGE_JSON);
+
+			if (this.fs.exists(pathToPackageJson)) {
+				const content = this.fs.readJson<INativeScriptProjectPackageJson>(pathToPackageJson);
+				runtimeVersion = content && content.nativescript && content.nativescript["tns-android"] && content.nativescript["tns-android"].version;
+			}
+		}
+
+		if (runtimeVersion) {
+			// Check if the version is not "next" or "rc", i.e. tag from npm
+			if (!semver.valid(runtimeVersion)) {
+				try {
+					const npmViewOutput = this.childProcess.execSync(`npm view ${Constants.ANDROID_RUNTIME} dist-tags --json`);
+					const jsonNpmViewOutput = JSON.parse(npmViewOutput);
+					runtimeVersion = jsonNpmViewOutput[runtimeVersion] || runtimeVersion;
+				} catch (err) {
+					// Maybe there's no npm here
+				}
+			}
+		}
+
+		if (runtimeVersion && !semver.valid(runtimeVersion)) {
+			// If we got here, something terribly wrong happened.
+			throw new Error(`The determined Android runtime version ${runtimeVersion} based on project directory ${projectDir} is not valid. Unable to verify if the current system is setup for Android development.`);
+		}
+
+		return runtimeVersion;
+	}
 }

lib/constants.ts

@@ -9,4 +9,9 @@ export class Constants {
 	};
 	public static INFO_TYPE_NAME = "info";
 	public static WARNING_TYPE_NAME = "warning";
+
+	public static PACKAGE_JSON = "package.json";
+	public static NATIVESCRIPT_KEY = "nativescript";
+	public static ANDROID_RUNTIME = "tns-android";
+	public static VERSION_PROPERTY_NAME = "version";
 }

lib/declarations.d.ts

@@ -66,3 +66,16 @@ interface IHiveIds {
 interface IDictionary<T> {
 	[key: string]: T
 }
+
+interface IVersion {
+	version: string;
+}
+
+interface INativeScriptNode {
+	["tns-android"]: IVersion;
+	["tns-ios"]: IVersion;
+}
+
+interface INativeScriptProjectPackageJson {
+	nativescript: INativeScriptNode;
+}

lib/doctor.ts

@@ -16,11 +16,11 @@ export class Doctor implements NativeScriptDoctor.IDoctor {
 		private sysInfo: NativeScriptDoctor.ISysInfo,
 		private androidToolsInfo: NativeScriptDoctor.IAndroidToolsInfo) { }
 
-	public async canExecuteLocalBuild(platform: string): Promise<boolean> {
+	public async canExecuteLocalBuild(platform: string, projectDir?: string): Promise<boolean> {
 		this.validatePlatform(platform);
 
 		if (platform.toLowerCase() === Constants.ANDROID_PLATFORM_NAME.toLowerCase()) {
-			return await this.androidLocalBuildRequirements.checkRequirements();
+			return await this.androidLocalBuildRequirements.checkRequirements(projectDir);
 		} else if (platform.toLowerCase() === Constants.IOS_PLATFORM_NAME.toLowerCase()) {
 			return await this.iOSLocalBuildRequirements.checkRequirements();
 		}
@@ -33,7 +33,7 @@ export class Doctor implements NativeScriptDoctor.IDoctor {
 		const sysInfoData = await this.sysInfo.getSysInfo(config);
 
 		if (!config || !config.platform || config.platform === Constants.ANDROID_PLATFORM_NAME) {
-			result = result.concat(this.getAndroidInfos(sysInfoData));
+			result = result.concat(this.getAndroidInfos(sysInfoData, config && config.projectDir));
 		}
 
 		if (!config || !config.platform || config.platform === Constants.IOS_PLATFORM_NAME) {
@@ -58,7 +58,7 @@ export class Doctor implements NativeScriptDoctor.IDoctor {
 			.map(item => this.convertInfoToWarning(item));
 	}
 
-	private getAndroidInfos(sysInfoData: NativeScriptDoctor.ISysInfoData): NativeScriptDoctor.IInfo[] {
+	private getAndroidInfos(sysInfoData: NativeScriptDoctor.ISysInfoData, projectDir?: string): NativeScriptDoctor.IInfo[] {
 		let result: NativeScriptDoctor.IInfo[] = [];
 
 		result = result.concat(
@@ -92,7 +92,7 @@ export class Doctor implements NativeScriptDoctor.IDoctor {
 				platforms: [Constants.ANDROID_PLATFORM_NAME]
 			}),
 			this.processValidationErrors({
-				warnings: this.androidToolsInfo.validateJavacVersion(sysInfoData.javacVersion),
+				warnings: this.androidToolsInfo.validateJavacVersion(sysInfoData.javacVersion, projectDir),
 				infoMessage: "Javac is installed and is configured properly.",
 				platforms: [Constants.ANDROID_PLATFORM_NAME]
 			}),

lib/local-build-requirements/android-local-build-requirements.ts

@@ -2,11 +2,13 @@ export class AndroidLocalBuildRequirements {
 	constructor(private androidToolsInfo: NativeScriptDoctor.IAndroidToolsInfo,
 		private sysInfo: NativeScriptDoctor.ISysInfo) { }
 
-	public async checkRequirements(): Promise<boolean> {
+	public async checkRequirements(projectDir?: string): Promise<boolean> {
 		const androidToolsInfo = await this.androidToolsInfo.validateInfo();
+		const javacVersion =  await this.sysInfo.getJavaCompilerVersion();
 		if (androidToolsInfo.length ||
-			!await this.sysInfo.getJavaCompilerVersion() ||
-			!await this.sysInfo.getAdbVersion()) {
+			!javacVersion ||
+			!await this.sysInfo.getAdbVersion() ||
+			!await this.androidToolsInfo.validateJavacVersion(javacVersion, projectDir)) {
 			return false;
 		}
 

lib/wrappers/child-process.ts

@@ -76,6 +76,10 @@ export class ChildProcess {
 		});
 	}
 
+	public execSync(command: string, options?: childProcess.ExecSyncOptions): string {
+		return childProcess.execSync(command, options).toString();
+	}
+
 	public execFile(command: string, args: string[]): Promise<any> {
 		return new Promise<any>((resolve, reject) => {
 			childProcess.execFile(command, args, (error, stdout) => {

lib/wrappers/file-system.ts

@@ -17,4 +17,9 @@ export class FileSystem {
 	public readDirectory(path: string): string[] {
 		return fs.readdirSync(path);
 	}
+
+	public readJson<T>(path: string, options?: { encoding?: null; flag?: string; }): T {
+		const content = fs.readFileSync(path, options);
+		return JSON.parse(content.toString());
+	}
 }