Playground

config/config.json

@@ -4,5 +4,7 @@
 	"CI_LOGGER": false,
 	"ANDROID_DEBUG_UI_MAC": "Google Chrome",
 	"USE_POD_SANDBOX": false,
-	"DISABLE_HOOKS": false
+	"DISABLE_HOOKS": false,
+	"UPLOAD_PLAYGROUND_FILES_ENDPOINT": "https://play.nativescript.org/api/files" ,
+	"SHORTEN_URL_ENDPOINT": "https://play.nativescript.org/api/shortenurl?longUrl=%s"
 }

docs/man_pages/project/testing/preview.md

@@ -0,0 +1,15 @@
+<% if (isJekyll) { %>---
+title: tns preview
+position: 1
+---<% } %>
+# tns preview
+
+
+Usage | Synopsis
+---|---
+Produces a QR code for deployment in the Preview app. | `tns preview`
+
+Enjoy NativeScript without any local setup. All you need is a couple of companion apps installed on your devices. When you save changes to the project, the changes are automatically synchronized to Preview app on your device.
+
+### Options
+`--bundle` - Specifies that a bundler (e.g. webpack) should be used if one is present. If no value is passed will default to `webpack`

lib/bootstrap.ts

@@ -50,6 +50,8 @@ $injector.requireCommand("run|*all", "./commands/run");
 $injector.requireCommand("run|ios", "./commands/run");
 $injector.requireCommand("run|android", "./commands/run");
 
+$injector.requireCommand("preview", "./commands/preview");
+
 $injector.requireCommand("debug|ios", "./commands/debug");
 $injector.requireCommand("debug|android", "./commands/debug");
 
@@ -120,13 +122,18 @@ $injector.requireCommand("platform|clean", "./commands/platform-clean");
 $injector.require("bundleValidatorHelper", "./helpers/bundle-validator-helper");
 $injector.require("liveSyncCommandHelper", "./helpers/livesync-command-helper");
 $injector.require("deployCommandHelper", "./helpers/deploy-command-helper");
+$injector.require("previewCommandHelper", "./helpers/preview-command-helper");
 
 $injector.requirePublicClass("localBuildService", "./services/local-build-service");
 $injector.requirePublicClass("liveSyncService", "./services/livesync/livesync-service");
 $injector.requirePublicClass("androidLivesyncTool", "./services/livesync/android-livesync-tool");
 $injector.require("androidLiveSyncService", "./services/livesync/android-livesync-service");
 $injector.require("iOSLiveSyncService", "./services/livesync/ios-livesync-service");
 $injector.require("usbLiveSyncService", "./services/livesync/livesync-service"); // The name is used in https://github.com/NativeScript/nativescript-dev-typescript
+$injector.require("previewAppLiveSyncService", "./services/livesync/playground/preview-app-livesync-service");
+$injector.require("previewAppPluginsService", "./services/livesync/playground/preview-app-plugins-service");
+$injector.require("previewSdkService", "./services/livesync/playground/preview-sdk-service");
+$injector.require("playgroundQrCodeGenerator", "./services/livesync/playground/qr-code-generator");
 $injector.requirePublic("sysInfo", "./sys-info");
 
 $injector.require("iOSNotificationService", "./services/ios-notification-service");
@@ -171,3 +178,4 @@ $injector.require("iOSLogParserService", "./services/ios-log-parser-service");
 $injector.require("iOSDebuggerPortService", "./services/ios-debugger-port-service");
 
 $injector.require("pacoteService", "./services/pacote-service");
+$injector.require("qrCodeTerminalService", "./services/qr-code-terminal-service");

lib/commands/add-platform.ts

@@ -1,31 +1,37 @@
-export class AddPlatformCommand implements ICommand {
+import { ValidatePlatformCommandBase } from "./command-base";
+
+export class AddPlatformCommand extends ValidatePlatformCommandBase implements ICommand {
 	public allowedParameters: ICommandParameter[] = [];
 
-	constructor(private $options: IOptions,
-		private $platformService: IPlatformService,
-		private $projectData: IProjectData,
-		private $platformsData: IPlatformsData,
+	constructor($options: IOptions,
+		$platformService: IPlatformService,
+		$projectData: IProjectData,
+		$platformsData: IPlatformsData,
 		private $errors: IErrors) {
-		this.$projectData.initializeProjectData();
+			super($options, $platformsData, $platformService, $projectData);
+			this.$projectData.initializeProjectData();
 	}
 
 	public async execute(args: string[]): Promise<void> {
 		await this.$platformService.addPlatforms(args, this.$options.platformTemplate, this.$projectData, this.$options, this.$options.frameworkPath);
 	}
 
-	public async canExecute(args: string[]): Promise<boolean> {
+	public async canExecute(args: string[]): Promise<ICanExecuteCommandOutput> {
 		if (!args || args.length === 0) {
 			this.$errors.fail("No platform specified. Please specify a platform to add");
 		}
 
+		let canExecute = true;
 		for (const arg of args) {
 			this.$platformService.validatePlatform(arg, this.$projectData);
-			const platformData = this.$platformsData.getPlatformData(arg, this.$projectData);
-			const platformProjectService = platformData.platformProjectService;
-			await platformProjectService.validate(this.$projectData);
+			const output = await super.canExecuteCommandBase(arg);
+			canExecute = canExecute && output.canExecute;
 		}
 
-		return true;
+		return {
+			canExecute,
+			suppressCommandHelp: !canExecute
+		};
 	}
 }
 

lib/commands/build.ts

@@ -1,13 +1,15 @@
 import { ANDROID_RELEASE_BUILD_ERROR_MESSAGE } from "../constants";
+import { ValidatePlatformCommandBase } from "./command-base";
 
-export class BuildCommandBase {
-	constructor(protected $options: IOptions,
+export abstract class BuildCommandBase extends ValidatePlatformCommandBase {
+	constructor($options: IOptions,
 		protected $errors: IErrors,
-		protected $projectData: IProjectData,
-		protected $platformsData: IPlatformsData,
+		$projectData: IProjectData,
+		$platformsData: IPlatformsData,
 		protected $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
-		protected $platformService: IPlatformService,
+		$platformService: IPlatformService,
 		private $bundleValidatorHelper: IBundleValidatorHelper) {
+			super($options, $platformsData, $platformService, $projectData);
 			this.$projectData.initializeProjectData();
 	}
 
@@ -43,16 +45,29 @@ export class BuildCommandBase {
 		}
 	}
 
-	protected async validatePlatform(platform: string): Promise<void> {
+	protected 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`);
 		}
 
 		this.$bundleValidatorHelper.validate();
+	}
+
+	protected async validateArgs(args: string[], platform: string): Promise<ICanExecuteCommandOutput> {
+		const canExecute = await this.validateArgsCore(args, platform);
+		return {
+			canExecute,
+			suppressCommandHelp: false
+		};
+	}
 
-		const platformData = this.$platformsData.getPlatformData(platform, this.$projectData);
-		const platformProjectService = platformData.platformProjectService;
-		await platformProjectService.validate(this.$projectData);
+	private async validateArgsCore(args: string[], platform: string): Promise<boolean> {
+		if (args.length !== 0) {
+			return false;
+		}
+
+		const result = await this.$platformService.validateOptions(this.$options.provision, this.$options.teamId, this.$projectData, platform);
+		return result;
 	}
 }
 
@@ -73,9 +88,17 @@ export class BuildIosCommand extends BuildCommandBase implements ICommand {
 		return this.executeCore([this.$platformsData.availablePlatforms.iOS]);
 	}
 
-	public async canExecute(args: string[]): Promise<boolean> {
-		await 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 | ICanExecuteCommandOutput> {
+		const platform = this.$devicePlatformsConstants.iOS;
+
+		super.validatePlatform(platform);
+
+		let result = await super.canExecuteCommandBase(platform);
+		if (result.canExecute) {
+			result = await super.validateArgs(args, platform);
+		}
+
+		return result;
 	}
 }
 
@@ -98,13 +121,20 @@ export class BuildAndroidCommand extends BuildCommandBase implements ICommand {
 		return this.executeCore([this.$platformsData.availablePlatforms.Android]);
 	}
 
-	public async canExecute(args: string[]): Promise<boolean> {
-		await super.validatePlatform(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);
+	public async canExecute(args: string[]): Promise<boolean | ICanExecuteCommandOutput> {
+		const platform = this.$devicePlatformsConstants.Android;
+		super.validatePlatform(platform);
+
+		let result = await super.canExecuteCommandBase(platform);
+		if (result.canExecute) {
+			if (this.$options.release && (!this.$options.keyStorePath || !this.$options.keyStorePassword || !this.$options.keyStoreAlias || !this.$options.keyStoreAliasPassword)) {
+				this.$errors.fail(ANDROID_RELEASE_BUILD_ERROR_MESSAGE);
+			}
+
+			result = await super.validateArgs(args, platform);
 		}
 
-		return args.length === 0 && await this.$platformService.validateOptions(this.$options.provision, this.$options.teamId, this.$projectData, this.$platformsData.availablePlatforms.Android);
+		return result;
 	}
 }
 

lib/commands/clean-app.ts

@@ -1,16 +1,18 @@
-export class CleanAppCommandBase implements ICommand {
+import { ValidatePlatformCommandBase } from "./command-base";
+
+export class CleanAppCommandBase extends ValidatePlatformCommandBase implements ICommand {
 	public allowedParameters: ICommandParameter[] = [];
 
 	protected platform: string;
 
-	constructor(protected $options: IOptions,
-		protected $projectData: IProjectData,
-		protected $platformService: IPlatformService,
+	constructor($options: IOptions,
+		$projectData: IProjectData,
+		$platformService: IPlatformService,
 		protected $errors: IErrors,
 		protected $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
-		protected $platformsData: IPlatformsData) {
-
-		this.$projectData.initializeProjectData();
+		$platformsData: IPlatformsData) {
+			super($options, $platformsData, $platformService, $projectData);
+			this.$projectData.initializeProjectData();
 	}
 
 	public async execute(args: string[]): Promise<void> {
@@ -27,15 +29,13 @@ export class CleanAppCommandBase implements ICommand {
 		return this.$platformService.cleanDestinationApp(platformInfo);
 	}
 
-	public async canExecute(args: string[]): Promise<boolean> {
+	public async canExecute(args: string[]): Promise<ICanExecuteCommandOutput> {
 		if (!this.$platformService.isPlatformSupportedForOS(this.platform, this.$projectData)) {
 			this.$errors.fail(`Applications for platform ${this.platform} can not be built on this OS`);
 		}
 
-		const platformData = this.$platformsData.getPlatformData(this.platform, this.$projectData);
-		const platformProjectService = platformData.platformProjectService;
-		await platformProjectService.validate(this.$projectData);
-		return true;
+		const result = await super.canExecuteCommandBase(this.platform);
+		return result;
 	}
 }
 

lib/commands/command-base.ts

@@ -0,0 +1,34 @@
+export abstract class ValidatePlatformCommandBase {
+	constructor(protected $options: IOptions,
+		protected $platformsData: IPlatformsData,
+		protected $platformService: IPlatformService,
+		protected $projectData: IProjectData) { }
+
+	abstract allowedParameters: ICommandParameter[];
+	abstract execute(args: string[]): Promise<void>;
+
+	public async canExecuteCommandBase(platform: string, options?: ICanExecuteCommandOptions): Promise<ICanExecuteCommandOutput> {
+		options = options || {};
+		const validatePlatformOutput = await this.validatePlatformBase(platform, options.notConfiguredEnvOptions);
+		const canExecute = this.canExecuteCommand(validatePlatformOutput);
+		let result = { canExecute, suppressCommandHelp: !canExecute };
+
+		if (canExecute && options.validateOptions) {
+			const validateOptionsOutput = await this.$platformService.validateOptions(this.$options.provision, this.$options.teamId, this.$projectData, platform);
+			result = { canExecute: validateOptionsOutput, suppressCommandHelp: false };
+		}
+
+		return result;
+	}
+
+	private async validatePlatformBase(platform: string, notConfiguredEnvOptions: INotConfiguredEnvOptions): Promise<IValidatePlatformOutput> {
+		const platformData = this.$platformsData.getPlatformData(platform, this.$projectData);
+		const platformProjectService = platformData.platformProjectService;
+		const result = await platformProjectService.validate(this.$projectData, this.$options, notConfiguredEnvOptions);
+		return result;
+	}
+
+	private canExecuteCommand(validatePlatformOutput: IValidatePlatformOutput): boolean {
+		return validatePlatformOutput && validatePlatformOutput.checkEnvironmentRequirementsOutput && validatePlatformOutput.checkEnvironmentRequirementsOutput.canExecute;
+	}
+}