Getting started improvements

When build or run command is executed, checks if the environment is properly configured for executing local builds. If it is not properly configured, {N} CLI shows a prompt and user is able to choice if to run setup script or use cloud builds.

If cloud builds option is selected, {N} CLI installs the nativescript-cloud extension and prints that user can use the $ tns login command to log in with his/her account and then $ tns cloud run/build android/ios command to build his/her app in the cloud.

If setup script option is selected, {N} CLI runs the setup script to try and automatically configure the environment. If the environment is not properly configured after executing the setup script, {N} CLI shows a prompt and user is able to choice if to use cloud builds or manually setup the environment. If the manually setup option is selected, {N} CLI prints: "To be able to build for android/ios, verify that your environment is configured according to the system requirements described at https://docs.nativescript.org/start/ns-setup-os-x.}"

Author: Fatme

lib/android-tools-info.ts

@@ -1,17 +1,14 @@
 import * as path from "path";
 import * as semver from "semver";
-import { EOL } from "os";
 import { cache } from "./common/decorators";
-import { appendZeroesToVersion } from './common/helpers';
+import { androidToolsInfo } from "nativescript-doctor";
 
 export class AndroidToolsInfo implements IAndroidToolsInfo {
 	private static ANDROID_TARGET_PREFIX = "android";
 	private static SUPPORTED_TARGETS = ["android-17", "android-18", "android-19", "android-21", "android-22", "android-23", "android-24", "android-25", "android-26", "android-27"];
 	private static MIN_REQUIRED_COMPILE_TARGET = 22;
 	private static REQUIRED_BUILD_TOOLS_RANGE_PREFIX = ">=23";
 	private static VERSION_REGEX = /((\d+\.){2}\d+)/;
-	private static MIN_JAVA_VERSION = "1.8.0";
-	private static MAX_JAVA_VERSION = "1.9.0";
 
 	private showWarningsAsErrors: boolean;
 	private toolsInfo: IAndroidToolsInfoData;
@@ -20,10 +17,8 @@ export class AndroidToolsInfo implements IAndroidToolsInfo {
 		return process.env["ANDROID_HOME"];
 	}
 
-	constructor(private $childProcess: IChildProcess,
-		private $errors: IErrors,
+	constructor(private $errors: IErrors,
 		private $fs: IFileSystem,
-		private $hostInfo: IHostInfo,
 		private $logger: ILogger,
 		private $options: IOptions,
 		protected $staticConfig: Config.IStaticConfig) { }
@@ -50,39 +45,8 @@ export class AndroidToolsInfo implements IAndroidToolsInfo {
 		this.showWarningsAsErrors = options && options.showWarningsAsErrors;
 		const toolsInfoData = this.getToolsInfo();
 		const 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 \`\$ ${this.getPathToSdkManagementTool()}\` to manage your Android SDK versions.`);
-			detectedErrors = true;
-		}
-
-		if (!toolsInfoData.buildToolsVersion) {
-			const buildToolsRange = this.getBuildToolsRange();
-			const versionRangeMatches = buildToolsRange.match(/^.*?([\d\.]+)\s+.*?([\d\.]+)$/);
-			let message = `You can install any version in the following range: '${buildToolsRange}'.`;
-
-			// Improve message in case buildToolsRange is something like: ">=22.0.0 <=22.0.0" - same numbers on both sides
-			if (versionRangeMatches && versionRangeMatches[1] && versionRangeMatches[2] && versionRangeMatches[1] === versionRangeMatches[2]) {
-				message = `You have to install version ${versionRangeMatches[1]}.`;
-			}
-
-			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.';
-			}
 
-			this.printMessage("You need to have the Android SDK Build-tools installed on your system. " + message, invalidBuildToolsAdditionalMsg);
-			detectedErrors = true;
-		}
-
-		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.';
-			}
-			this.printMessage(`You need to have Android SDK ${AndroidToolsInfo.MIN_REQUIRED_COMPILE_TARGET} or later and the latest Android Support Repository installed on your system.`, invalidSupportLibAdditionalMsg);
-			detectedErrors = true;
-		}
+		detectedErrors = androidToolsInfo.validateInfo().map(warning => this.printMessage(warning.warning)).length > 0;
 
 		if (options && options.validateTargetSdk) {
 			const targetSdk = toolsInfoData.targetSdkVersion;
@@ -104,44 +68,20 @@ export class AndroidToolsInfo implements IAndroidToolsInfo {
 	}
 
 	public validateJavacVersion(installedJavacVersion: string, options?: { showWarningsAsErrors: boolean }): boolean {
-		let hasProblemWithJavaVersion = false;
 		if (options) {
 			this.showWarningsAsErrors = options.showWarningsAsErrors;
 		}
 
-		const 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.$staticConfig.SYS_REQUIREMENTS_LINK;
-
-		const matchingVersion = appendZeroesToVersion(installedJavacVersion || "", 3).match(AndroidToolsInfo.VERSION_REGEX);
-		const installedJavaCompilerVersion = matchingVersion && matchingVersion[1];
-		if (installedJavaCompilerVersion) {
-			if (semver.lt(installedJavaCompilerVersion, AndroidToolsInfo.MIN_JAVA_VERSION)) {
-				hasProblemWithJavaVersion = true;
-				this.printMessage(`Javac version ${installedJavacVersion} is not supported. You have to install at least ${AndroidToolsInfo.MIN_JAVA_VERSION}.`, additionalMessage);
-			} else if (semver.gte(installedJavaCompilerVersion, AndroidToolsInfo.MAX_JAVA_VERSION)) {
-				hasProblemWithJavaVersion = true;
-				this.printMessage(`Javac version ${installedJavacVersion} is not supported. You have to install version ${AndroidToolsInfo.MIN_JAVA_VERSION}.`, additionalMessage);
-			}
-		} else {
-			hasProblemWithJavaVersion = true;
-			this.printMessage("Error executing command 'javac'. Make sure you have installed The Java Development Kit (JDK) and set JAVA_HOME environment variable.", additionalMessage);
-		}
-
-		return hasProblemWithJavaVersion;
+		return androidToolsInfo.validateJavacVersion(installedJavacVersion).map(warning => this.printMessage(warning.warning)).length > 0;
 	}
 
 	public async getPathToAdbFromAndroidHome(): Promise<string> {
-		if (this.androidHome) {
-			const pathToAdb = path.join(this.androidHome, "platform-tools", "adb");
-			try {
-				await this.$childProcess.execFile(pathToAdb, ["help"]);
-				return pathToAdb;
-			} catch (err) {
-				// adb does not exist, so ANDROID_HOME is not set correctly
-				// try getting default adb path (included in CLI package)
-				this.$logger.trace(`Error while executing '${pathToAdb} help'. Error is: ${err.message}`);
-			}
+		try {
+			return androidToolsInfo.getPathToAdbFromAndroidHome();
+		} catch (err) {
+			// adb does not exist, so ANDROID_HOME is not set correctly
+			// try getting default adb path (included in CLI package)
+			this.$logger.trace(`Error while executing '${path.join(this.androidHome, "platform-tools", "adb")} help'. Error is: ${err.message}`);
 		}
 
 		return null;
@@ -153,43 +93,7 @@ export class AndroidToolsInfo implements IAndroidToolsInfo {
 			this.showWarningsAsErrors = options.showWarningsAsErrors;
 		}
 
-		const expectedDirectoriesInAndroidHome = ["build-tools", "tools", "platform-tools", "extras"];
-		let androidHomeValidationResult = true;
-
-		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.");
-			androidHomeValidationResult = 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.");
-			androidHomeValidationResult = false;
-		}
-
-		return androidHomeValidationResult;
-	}
-
-	@cache()
-	private getPathToSdkManagementTool(): string {
-		const sdkManagerName = "sdkmanager";
-		let sdkManagementToolPath = 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}`);
-
-			sdkManagementToolPath = pathToExecutable.replace(this.androidHome, this.$hostInfo.isWindows ? "%ANDROID_HOME%" : "$ANDROID_HOME");
-		}
-
-		return sdkManagementToolPath;
+		return androidToolsInfo.validateAndroidHomeEnvVariable().map(warning => this.printMessage(warning.warning)).length > 0;
 	}
 
 	private shouldGenerateTypings(): boolean {

lib/bootstrap.ts

@@ -148,3 +148,4 @@ $injector.requirePublic("extensibilityService", "./services/extensibility-servic
 $injector.require("nodeModulesDependenciesBuilder", "./tools/node-modules/node-modules-dependencies-builder");
 $injector.require("subscriptionService", "./services/subscription-service");
 $injector.require("terminalSpinnerService", "./services/terminal-spinner-service");
+$injector.require("platformEnvironmentRequirements", "./services/platform-environment-requirements");

lib/commands/build.ts

@@ -7,7 +7,9 @@ export class BuildCommandBase {
 		protected $platformsData: IPlatformsData,
 		protected $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		protected $platformService: IPlatformService,
-		private $bundleValidatorHelper: IBundleValidatorHelper) {
+		private $bundleValidatorHelper: IBundleValidatorHelper,
+		private $platformEnvironmentRequirements: IPlatformEnvironmentRequirements) {
+			super($projectData, $errors, $options);
 		this.$projectData.initializeProjectData();
 	}
 
@@ -44,7 +46,13 @@ export class BuildCommandBase {
 		}
 	}
 
-	protected validatePlatform(platform: string): void {
+	protected async canExecuteCore(platform: string): Promise<boolean> {
+		const result = await this.$platformEnvironmentRequirements.checkEnvironmentRequirements({ platform: platform, cloudCommandName: "build" });
+		this.validatePlatform(platform);
+		return result;
+	}
+
+	private validatePlatform(platform: string): void {
 		if (!this.$platformService.isPlatformSupportedForOS(platform, this.$projectData)) {
 			this.$errors.fail(`Applications for platform ${platform} can not be built on this OS`);
 		}
@@ -62,17 +70,17 @@ export class BuildIosCommand extends BuildCommandBase implements ICommand {
 		$platformsData: IPlatformsData,
 		$devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		$platformService: IPlatformService,
-		$bundleValidatorHelper: IBundleValidatorHelper) {
-		super($options, $errors, $projectData, $platformsData, $devicePlatformsConstants, $platformService, $bundleValidatorHelper);
+		$bundleValidatorHelper: IBundleValidatorHelper,
+		$platformEnvironmentRequirements: IPlatformEnvironmentRequirements) {
+			super($options, $errors, $projectData, $platformsData, $devicePlatformsConstants, $platformService, $bundleValidatorHelper, $platformEnvironmentRequirements);
 	}
 
 	public async execute(args: string[]): Promise<void> {
 		return this.executeCore([this.$platformsData.availablePlatforms.iOS]);
 	}
 
-	public canExecute(args: string[]): Promise<boolean> {
-		super.validatePlatform(this.$devicePlatformsConstants.iOS);
-		return args.length === 0 && this.$platformService.validateOptions(this.$options.provision, this.$options.teamId, this.$projectData, this.$platformsData.availablePlatforms.iOS);
+	public async canExecute(args: string[]): Promise<boolean> {
+		return await super.canExecuteCore(this.$devicePlatformsConstants.iOS) && args.length === 0 && this.$platformService.validateOptions(this.$options.provision, this.$options.teamId, this.$projectData, this.$platformsData.availablePlatforms.iOS);
 	}
 }
 
@@ -87,16 +95,18 @@ export class BuildAndroidCommand extends BuildCommandBase implements ICommand {
 		$platformsData: IPlatformsData,
 		$devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		$platformService: IPlatformService,
-		$bundleValidatorHelper: IBundleValidatorHelper) {
-		super($options, $errors, $projectData, $platformsData, $devicePlatformsConstants, $platformService, $bundleValidatorHelper);
+		$bundleValidatorHelper: IBundleValidatorHelper,
+		$platformEnvironmentRequirements: IPlatformEnvironmentRequirements) {
+			super($options, $errors, $projectData, $platformsData, $devicePlatformsConstants, $platformService, $bundleValidatorHelper, $platformEnvironmentRequirements);
 	}
 
 	public async execute(args: string[]): Promise<void> {
 		return this.executeCore([this.$platformsData.availablePlatforms.Android]);
 	}
 
 	public async canExecute(args: string[]): Promise<boolean> {
-		super.validatePlatform(this.$devicePlatformsConstants.Android);
+		await super.canExecuteCore(this.$devicePlatformsConstants.Android);
+
 		if (this.$options.release && (!this.$options.keyStorePath || !this.$options.keyStorePassword || !this.$options.keyStoreAlias || !this.$options.keyStoreAliasPassword)) {
 			this.$errors.fail(ANDROID_RELEASE_BUILD_ERROR_MESSAGE);
 		}

lib/commands/run.ts

@@ -9,14 +9,17 @@ export class RunCommandBase implements ICommand {
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		private $errors: IErrors,
 		private $hostInfo: IHostInfo,
-		private $liveSyncCommandHelper: ILiveSyncCommandHelper) { }
+		private $liveSyncCommandHelper: ILiveSyncCommandHelper,
+		private $platformEnvironmentRequirements: IPlatformEnvironmentRequirements) { }
 
 	public allowedParameters: ICommandParameter[] = [];
 	public async execute(args: string[]): Promise<void> {
 		return this.$liveSyncCommandHelper.executeCommandLiveSync(this.platform);
 	}
 
 	public async canExecute(args: string[]): Promise<boolean> {
+		await this.$platformEnvironmentRequirements.checkEnvironmentRequirements({platform: this.platform, cloudCommandName: "run"});
+
 		if (args.length) {
 			this.$errors.fail(ERROR_NO_VALID_SUBCOMMAND_FORMAT, "run");
 		}

lib/common

@@ -365,3 +365,12 @@ interface IDeployPlatformInfo extends IPlatform, IAppFilesUpdaterOptionsComposit
 interface IUpdateAppOptions extends IOptionalFilesToSync, IOptionalFilesToRemove {
 	beforeCopyAction: (sourceFiles: string[]) => void;
 }
+
+interface IPlatformEnvironmentRequirements {
+	checkEnvironmentRequirements(input: ICheckEnvironmentRequirementsInput): Promise<boolean>;
+}
+
+interface ICheckEnvironmentRequirementsInput {
+	platform: string;
+	cloudCommandName: string;
+}

lib/definitions/platform.d.ts

@@ -53,17 +53,38 @@ class DoctorService implements IDoctorService {
 		return hasWarnings;
 	}
 
+	public async runSetupScript(): Promise<ISpawnResult> {
+		this.$logger.out("Running the setup script to try and automatically configure your environment.");
+
+		if (this.$hostInfo.isDarwin) {
+			return this.runSetupScriptCore(DoctorService.DarwinSetupScriptLocation, []);
+		}
+
+		if (this.$hostInfo.isWindows) {
+			return this.runSetupScriptCore(DoctorService.WindowsSetupScriptExecutable, DoctorService.WindowsSetupScriptArguments);
+		}
+	}
+
+	public async canExecuteLocalBuild(platform?: string): Promise<boolean> {
+		let infos = await doctor.getInfos();
+		if (platform) {
+			infos = this.filterInfosByPlatform(infos, platform);
+		}
+		this.printInfosCore(infos);
+
+		const warnings = this.filterInfosByType(infos, constants.WARNING_TYPE_NAME);
+		return warnings.length === 0;
+	}
+
 	private async promptForDocs(link: string): Promise<void> {
 		if (await this.$prompter.confirm("Do you want to visit the official documentation?", () => helpers.isInteractive())) {
 			this.$opener.open(link);
 		}
 	}
 
-	private async promptForHelpCore(link: string, commandName: string, commandArguments: string[]): Promise<void> {
-		await this.promptForDocs(link);
-
+	private async promptForSetupScript(executablePath: string, setupScriptArgs: string[]): Promise<void> {
 		if (await this.$prompter.confirm("Do you want to run the setup script?", () => helpers.isInteractive())) {
-			await this.$childProcess.spawnFromEvent(commandName, commandArguments, "close", { stdio: "inherit" });
+			await this.runSetupScriptCore(executablePath, setupScriptArgs);
 		}
 	}
 
@@ -77,6 +98,15 @@ class DoctorService implements IDoctorService {
 		}
 	}
 
+	private async promptForHelpCore(link: string, setupScriptExecutablePath: string, setupScriptArgs: string[]): Promise<void> {
+		await this.promptForDocs(link);
+		await this.promptForSetupScript(setupScriptExecutablePath, setupScriptArgs);
+	}
+
+	private async runSetupScriptCore(executablePath: string, setupScriptArgs: string[]): Promise<ISpawnResult> {
+		return this.$childProcess.spawnFromEvent(executablePath, setupScriptArgs, "close", { stdio: "inherit" });
+	}
+
 	private printPackageManagerTip() {
 		if (this.$hostInfo.isWindows) {
 			this.$logger.out("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);
@@ -98,7 +128,15 @@ class DoctorService implements IDoctorService {
 				const spinner = this.$terminalSpinnerService.createSpinner();
 				spinner.text = `${info.message.yellow} ${EOL} ${info.additionalInformation} ${EOL}`;
 				spinner.fail();
-		});
+			});
+	}
+
+	private filterInfosByPlatform(infos: NativeScriptDoctor.IInfo[], platform: string): NativeScriptDoctor.IInfo[] {
+		return infos.filter(info => _.includes(info.platforms, platform));
+	}
+
+	private filterInfosByType(infos: NativeScriptDoctor.IInfo[], type: string): NativeScriptDoctor.IInfo[] {
+		return infos.filter(info => info.type === type);
 	}
 }
 $injector.register("doctorService", DoctorService);