Initial version of preview command

Author: Fatme

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");
 
@@ -127,6 +129,8 @@ $injector.requirePublicClass("androidLivesyncTool", "./services/livesync/android
 $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("previewSdkService", "./services/livesync/playground/preview-sdk-service");
 $injector.requirePublic("sysInfo", "./sys-info");
 
 $injector.require("iOSNotificationService", "./services/ios-notification-service");

lib/commands/preview.ts

@@ -0,0 +1,26 @@
+export class PreviewCommand implements ICommand {
+	public allowedParameters: ICommandParameter[] = [];
+
+	constructor(private $liveSyncService: ILiveSyncService,
+		private $projectData: IProjectData,
+		private $options: IOptions) { }
+
+	public async execute(args: string[]): Promise<void> {
+		await this.$liveSyncService.liveSync([], {
+			syncToPreviewApp: true,
+			projectDir: this.$projectData.projectDir,
+			skipWatcher: !this.$options.watch,
+			watchAllFiles: this.$options.syncAllFiles,
+			clean: this.$options.clean,
+			bundle: !!this.$options.bundle,
+			release: this.$options.release,
+			env: this.$options.env,
+			timeout: this.$options.timeout
+		});
+	}
+
+	public async canExecute(args: string[]): Promise<boolean> {
+		return true;
+	}
+}
+$injector.registerCommand("preview", PreviewCommand);

lib/common

@@ -159,6 +159,8 @@ interface ILiveSyncInfo extends IProjectDir, IEnvOptions, IBundle, IRelease, IOp
 	 * If not provided, defaults to 10seconds.
 	 */
 	timeout: string;
+
+	syncToPreviewApp?: boolean;
 }
 
 interface IHasUseHotModuleReloadOption {

lib/definitions/livesync.d.ts

@@ -0,0 +1,18 @@
+import { FilePayload, DeviceConnectedMessage } from "nativescript-preview-sdk";
+
+declare global {
+	interface IPreviewAppLiveSyncService {
+		initialSync(data: IPreviewAppLiveSyncData): Promise<void>;
+		syncFiles(data: IPreviewAppLiveSyncData, filesToSync: string[]): Promise<void>;
+		stopLiveSync(): Promise<void>;
+	}
+
+	interface IPreviewAppLiveSyncData extends IProjectDataComposition, IAppFilesUpdaterOptionsComposition, IEnvOptions { }
+
+	interface IPreviewSdkService extends NodeJS.EventEmitter {
+		connectedDevices: DeviceConnectedMessage[];
+		initialize(): void;
+		applyChanges(files: FilePayload[]): Promise<void>;
+		stop(): void;
+	}
+}

lib/definitions/preview-app-livesync.d.ts

@@ -37,13 +37,13 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 		private $debugDataService: IDebugDataService,
 		private $analyticsService: IAnalyticsService,
 		private $usbLiveSyncService: DeprecatedUsbLiveSyncService,
+		private $previewAppLiveSyncService: IPreviewAppLiveSyncService,
 		private $injector: IInjector) {
 		super();
 	}
 
 	public async liveSync(deviceDescriptors: ILiveSyncDeviceInfo[], liveSyncData: ILiveSyncInfo): Promise<void> {
 		const projectData = this.$projectDataService.getProjectData(liveSyncData.projectDir);
-		await this.$pluginsService.ensureAllDependenciesAreInstalled(projectData);
 		await this.liveSyncOperation(deviceDescriptors, liveSyncData, projectData);
 	}
 
@@ -318,16 +318,22 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 
 	@hook("liveSync")
 	private async liveSyncOperation(deviceDescriptors: ILiveSyncDeviceInfo[], liveSyncData: ILiveSyncInfo, projectData: IProjectData): Promise<void> {
-		// In case liveSync is called for a second time for the same projectDir.
-		const isAlreadyLiveSyncing = this.liveSyncProcessesInfo[projectData.projectDir] && !this.liveSyncProcessesInfo[projectData.projectDir].isStopped;
+		let deviceDescriptorsForInitialSync: ILiveSyncDeviceInfo[] = [];
 
-		// Prevent cases where liveSync is called consecutive times with the same device, for example [ A, B, C ] and then [ A, B, D ] - we want to execute initialSync only for D.
-		const currentlyRunningDeviceDescriptors = this.getLiveSyncDeviceDescriptors(projectData.projectDir);
-		const deviceDescriptorsForInitialSync = isAlreadyLiveSyncing ? _.differenceBy(deviceDescriptors, currentlyRunningDeviceDescriptors, deviceDescriptorPrimaryKey) : deviceDescriptors;
+		if (!liveSyncData.syncToPreviewApp) {
+			await this.$pluginsService.ensureAllDependenciesAreInstalled(projectData);
+			// In case liveSync is called for a second time for the same projectDir.
+			const isAlreadyLiveSyncing = this.liveSyncProcessesInfo[projectData.projectDir] && !this.liveSyncProcessesInfo[projectData.projectDir].isStopped;
+
+			// Prevent cases where liveSync is called consecutive times with the same device, for example [ A, B, C ] and then [ A, B, D ] - we want to execute initialSync only for D.
+			const currentlyRunningDeviceDescriptors = this.getLiveSyncDeviceDescriptors(projectData.projectDir);
+			deviceDescriptorsForInitialSync = isAlreadyLiveSyncing ? _.differenceBy(deviceDescriptors, currentlyRunningDeviceDescriptors, deviceDescriptorPrimaryKey) : deviceDescriptors;
+		}
 
 		this.setLiveSyncProcessInfo(liveSyncData.projectDir, deviceDescriptors);
 
-		if (!liveSyncData.skipWatcher && this.liveSyncProcessesInfo[projectData.projectDir].deviceDescriptors.length) {
+		const shouldStartWatcher = liveSyncData.syncToPreviewApp || (!liveSyncData.skipWatcher && this.liveSyncProcessesInfo[projectData.projectDir].deviceDescriptors.length);
+		if (shouldStartWatcher) {
 			// Should be set after prepare
 			this.$usbLiveSyncService.isInitialized = true;
 			await this.startWatcher(projectData, liveSyncData, deviceDescriptors);
@@ -448,6 +454,27 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 	}
 
 	private async initialSync(projectData: IProjectData, liveSyncData: ILiveSyncInfo, deviceDescriptors: ILiveSyncDeviceInfo[]): Promise<void> {
+		if (liveSyncData.syncToPreviewApp) {
+			await this.initialSyncToPreviewApp(projectData, liveSyncData);
+		} else {
+			await this.initialCableSync(projectData, liveSyncData, deviceDescriptors);
+		}
+	}
+
+	private async initialSyncToPreviewApp(projectData: IProjectData, liveSyncData: ILiveSyncInfo) {
+		this.addActionToChain(projectData.projectDir, async () => {
+			await this.$previewAppLiveSyncService.initialSync({
+				appFilesUpdaterOptions: {
+					bundle: liveSyncData.bundle,
+					release: liveSyncData.release
+				},
+				env: liveSyncData.env,
+				projectData
+			});
+		});
+	}
+
+	private async initialCableSync(projectData: IProjectData, liveSyncData: ILiveSyncInfo, deviceDescriptors: ILiveSyncDeviceInfo[]): Promise<void> {
 		const preparedPlatforms: string[] = [];
 		const rebuiltInformation: ILiveSyncBuildInfo[] = [];
 
@@ -552,82 +579,95 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 
 			const startSyncFilesTimeout = () => {
 				timeoutTimer = setTimeout(async () => {
-					// Push actions to the queue, do not start them simultaneously
-					await this.addActionToChain(projectData.projectDir, async () => {
-						if (filesToSync.length || filesToRemove.length) {
-							try {
-								const currentFilesToSync = _.cloneDeep(filesToSync);
-								filesToSync.splice(0, filesToSync.length);
-
-								const currentFilesToRemove = _.cloneDeep(filesToRemove);
-								filesToRemove = [];
-
-								const allModifiedFiles = [].concat(currentFilesToSync).concat(currentFilesToRemove);
-
-								const preparedPlatforms: string[] = [];
-								const rebuiltInformation: ILiveSyncBuildInfo[] = [];
-
-								const latestAppPackageInstalledSettings = this.getDefaultLatestAppPackageInstalledSettings();
-
-								await this.$devicesService.execute(async (device: Mobile.IDevice) => {
-									const liveSyncProcessInfo = this.liveSyncProcessesInfo[projectData.projectDir];
-									const deviceBuildInfoDescriptor = _.find(liveSyncProcessInfo.deviceDescriptors, dd => dd.identifier === device.deviceInfo.identifier);
-
-									const appInstalledOnDeviceResult = await this.ensureLatestAppPackageIsInstalledOnDevice({
-										device,
-										preparedPlatforms,
-										rebuiltInformation,
-										projectData,
-										deviceBuildInfoDescriptor,
-										liveSyncData,
-										settings: latestAppPackageInstalledSettings,
-										modifiedFiles: allModifiedFiles,
-										filesToRemove: currentFilesToRemove,
-										filesToSync: currentFilesToSync,
-										bundle: liveSyncData.bundle,
-										release: liveSyncData.release,
-										env: liveSyncData.env,
-										skipModulesNativeCheck: !liveSyncData.watchAllFiles
-									}, { skipNativePrepare: deviceBuildInfoDescriptor.skipNativePrepare });
-
-									const service = this.getLiveSyncService(device.deviceInfo.platform);
-									const settings: ILiveSyncWatchInfo = {
-										projectData,
-										filesToRemove: currentFilesToRemove,
-										filesToSync: currentFilesToSync,
-										isReinstalled: appInstalledOnDeviceResult.appInstalled,
-										syncAllFiles: liveSyncData.watchAllFiles,
-										useHotModuleReload: liveSyncData.useHotModuleReload
-									};
-
-									const liveSyncResultInfo = await service.liveSyncWatchAction(device, settings);
-									await this.refreshApplication(projectData, liveSyncResultInfo, deviceBuildInfoDescriptor.debugOptions, deviceBuildInfoDescriptor.outputPath);
+					if (liveSyncData.syncToPreviewApp) {
+						await this.addActionToChain(projectData.projectDir, async () => {
+							await this.$previewAppLiveSyncService.syncFiles({
+								appFilesUpdaterOptions: {
+									bundle: liveSyncData.bundle,
+									release: liveSyncData.release
 								},
-									(device: Mobile.IDevice) => {
+								env: liveSyncData.env,
+								projectData: projectData
+							}, filesToSync);
+						});
+					} else {
+						// Push actions to the queue, do not start them simultaneously
+						await this.addActionToChain(projectData.projectDir, async () => {
+							if (filesToSync.length || filesToRemove.length) {
+								try {
+									const currentFilesToSync = _.cloneDeep(filesToSync);
+									filesToSync.splice(0, filesToSync.length);
+
+									const currentFilesToRemove = _.cloneDeep(filesToRemove);
+									filesToRemove = [];
+
+									const allModifiedFiles = [].concat(currentFilesToSync).concat(currentFilesToRemove);
+
+									const preparedPlatforms: string[] = [];
+									const rebuiltInformation: ILiveSyncBuildInfo[] = [];
+
+									const latestAppPackageInstalledSettings = this.getDefaultLatestAppPackageInstalledSettings();
+
+									await this.$devicesService.execute(async (device: Mobile.IDevice) => {
 										const liveSyncProcessInfo = this.liveSyncProcessesInfo[projectData.projectDir];
-										return liveSyncProcessInfo && _.some(liveSyncProcessInfo.deviceDescriptors, deviceDescriptor => deviceDescriptor.identifier === device.deviceInfo.identifier);
-									}
-								);
-							} catch (err) {
-								const allErrors = (<Mobile.IDevicesOperationError>err).allErrors;
-
-								if (allErrors && _.isArray(allErrors)) {
-									for (const deviceError of allErrors) {
-										this.$logger.warn(`Unable to apply changes for device: ${deviceError.deviceIdentifier}. Error is: ${deviceError.message}.`);
-
-										this.emit(LiveSyncEvents.liveSyncError, {
-											error: deviceError,
-											deviceIdentifier: deviceError.deviceIdentifier,
-											projectDir: projectData.projectDir,
-											applicationIdentifier: projectData.projectId
-										});
-
-										await this.stopLiveSync(projectData.projectDir, [deviceError.deviceIdentifier], { shouldAwaitAllActions: false });
+										const deviceBuildInfoDescriptor = _.find(liveSyncProcessInfo.deviceDescriptors, dd => dd.identifier === device.deviceInfo.identifier);
+
+										const appInstalledOnDeviceResult = await this.ensureLatestAppPackageIsInstalledOnDevice({
+											device,
+											preparedPlatforms,
+											rebuiltInformation,
+											projectData,
+											deviceBuildInfoDescriptor,
+											liveSyncData,
+											settings: latestAppPackageInstalledSettings,
+											modifiedFiles: allModifiedFiles,
+											filesToRemove: currentFilesToRemove,
+											filesToSync: currentFilesToSync,
+											bundle: liveSyncData.bundle,
+											release: liveSyncData.release,
+											env: liveSyncData.env,
+											skipModulesNativeCheck: !liveSyncData.watchAllFiles
+										}, { skipNativePrepare: deviceBuildInfoDescriptor.skipNativePrepare });
+
+										const service = this.getLiveSyncService(device.deviceInfo.platform);
+										const settings: ILiveSyncWatchInfo = {
+											projectData,
+											filesToRemove: currentFilesToRemove,
+											filesToSync: currentFilesToSync,
+											isReinstalled: appInstalledOnDeviceResult.appInstalled,
+											syncAllFiles: liveSyncData.watchAllFiles,
+											useHotModuleReload: liveSyncData.useHotModuleReload
+										};
+
+										const liveSyncResultInfo = await service.liveSyncWatchAction(device, settings);
+										await this.refreshApplication(projectData, liveSyncResultInfo, deviceBuildInfoDescriptor.debugOptions, deviceBuildInfoDescriptor.outputPath);
+									},
+										(device: Mobile.IDevice) => {
+											const liveSyncProcessInfo = this.liveSyncProcessesInfo[projectData.projectDir];
+											return liveSyncProcessInfo && _.some(liveSyncProcessInfo.deviceDescriptors, deviceDescriptor => deviceDescriptor.identifier === device.deviceInfo.identifier);
+										}
+									);
+								} catch (err) {
+									const allErrors = (<Mobile.IDevicesOperationError>err).allErrors;
+
+									if (allErrors && _.isArray(allErrors)) {
+										for (const deviceError of allErrors) {
+											this.$logger.warn(`Unable to apply changes for device: ${deviceError.deviceIdentifier}. Error is: ${deviceError.message}.`);
+
+											this.emit(LiveSyncEvents.liveSyncError, {
+												error: deviceError,
+												deviceIdentifier: deviceError.deviceIdentifier,
+												projectDir: projectData.projectDir,
+												applicationIdentifier: projectData.projectId
+											});
+
+											await this.stopLiveSync(projectData.projectDir, [deviceError.deviceIdentifier], { shouldAwaitAllActions: false });
+										}
 									}
 								}
 							}
-						}
-					});
+						});
+					}
 				}, 250);
 
 				this.liveSyncProcessesInfo[liveSyncData.projectDir].timer = timeoutTimer;
@@ -683,6 +723,11 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 			this.liveSyncProcessesInfo[liveSyncData.projectDir].timer = timeoutTimer;
 
 			this.$processService.attachToProcessExitSignals(this, () => {
+				if (liveSyncData.syncToPreviewApp) {
+					// Do not await here, we are in process exit's handler.
+					this.$previewAppLiveSyncService.stopLiveSync();
+				}
+
 				_.keys(this.liveSyncProcessesInfo).forEach(projectDir => {
 					// Do not await here, we are in process exit's handler.
 					/* tslint:disable:no-floating-promises */

lib/services/livesync/livesync-service.ts

@@ -0,0 +1,9 @@
+export class PreviewSdkEventNames {
+	public static DEVICE_CONNECTED = "onDeviceConnected";
+	public static CHANGE_EVENT_NAME = "change";
+}
+
+export class PubnubKeys {
+	public static PUBLISH_KEY = "pub-c-78911a3d-9dc9-4316-96e5-83e6fd17263f";
+	public static SUBSCRIBE_KEY = "sub-c-2c059576-47a1-11e7-b66e-0619f8945a4f";
+}