Merge pull request #36 from NativeScript/vladimirov/validate-java-by-runtime

feat: Validate Javac version with Android runtime 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());
+	}
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nativescript-doctor",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Library that helps identifying if the environment can be used for development of {N} apps.",
   "main": "lib/index.js",
   "types": "./typings/nativescript-doctor.d.ts",