fix: build the platform when there are native changes on initial sync and add unit tests for that functionality

Author: Fatme

.vscode/launch.json

@@ -15,7 +15,7 @@
 			"program": "${workspaceRoot}/lib/nativescript-cli.js",
 
 			// example commands
-			"args": [ "test", "ios", "--path", "${workspaceRoot}/scratch/webpackApp", "--bundle"]
+			"args": [ "create", "cliapp", "--path", "${workspaceRoot}/scratch"]
 			// "args": [ "test", "android", "--justlaunch"]
 			// "args": [ "platform", "add", "android@1.3.0", "--path", "cliapp"]
 			// "args": [ "platform", "remove", "android", "--path", "cliapp"]

lib/commands/preview.ts

@@ -26,7 +26,6 @@ export class PreviewCommand implements ICommand {
 
 		await this.$previewAppLiveSyncService.initialize({
 			projectDir: this.$projectData.projectDir,
-			bundle: !!this.$options.bundle,
 			useHotModuleReload: this.$options.hmr,
 			env: this.$options.env
 		});

lib/constants.ts

@@ -139,8 +139,8 @@ export const POST_INSTALL_COMMAND_NAME = "post-install-cli";
 export const ANDROID_RELEASE_BUILD_ERROR_MESSAGE = "When producing a release build, you need to specify all --key-store-* options.";
 export const CACACHE_DIRECTORY_NAME = "_cacache";
 
-export const FILES_CHANGE_EVENT_NAME = "filesChangeEventData";
-export const INITIAL_SYNC_EVENT_NAME = "initialSyncEventData";
+export const FILES_CHANGE_EVENT_NAME = "filesChangeEvent";
+export const INITIAL_SYNC_EVENT_NAME = "initialSyncEvent";
 
 export class DebugCommandErrors {
 	public static UNABLE_TO_USE_FOR_DEVICE_AND_EMULATOR = "The options --for-device and --emulator cannot be used simultaneously. Please use only one of them.";

lib/controllers/main-controller.ts

@@ -31,11 +31,13 @@ export class MainController extends EventEmitter {
 		private $workflowDataService: WorkflowDataService
 	) { super(); }
 
-	public async preparePlatform(platform: string, projectDir: string, options: IOptions): Promise<void> {
+	public async preparePlatform(platform: string, projectDir: string, options: IOptions): Promise<boolean> {
 		const { nativePlatformData, projectData, addPlatformData, preparePlatformData } = this.$workflowDataService.createWorkflowData(platform, projectDir, options);
 
 		await this.$addPlatformService.addPlatformIfNeeded(nativePlatformData, projectData, addPlatformData);
-		await this.$preparePlatformService.preparePlatform(nativePlatformData, projectData, preparePlatformData);
+		const result = await this.$preparePlatformService.preparePlatform(nativePlatformData, projectData, preparePlatformData);
+
+		return result;
 	}
 
 	public async buildPlatform(platform: string, projectDir: string, options: IOptions | any): Promise<string> {
@@ -74,34 +76,40 @@ export class MainController extends EventEmitter {
 			await this.$addPlatformService.addPlatformIfNeeded(nativePlatformData, projectData, addPlatformData);
 		}
 
-		// TODO: Consider to handle correctly the descriptors when livesync is executed for second time for the same projectDir
+		const currentRunOnDevicesData = this.$runOnDevicesDataService.getDataForProject(projectData.projectDir);
+		const isAlreadyLiveSyncing = currentRunOnDevicesData && !currentRunOnDevicesData.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 deviceDescriptorsForInitialSync = isAlreadyLiveSyncing ? _.differenceBy(deviceDescriptors, currentRunOnDevicesData.deviceDescriptors, "identifier") : deviceDescriptors;
 
-		this.$runOnDevicesDataService.persistData(projectDir, deviceDescriptors);
+		this.$runOnDevicesDataService.persistData(projectDir, deviceDescriptors, platforms);
 
 		const shouldStartWatcher = !liveSyncInfo.skipWatcher && (liveSyncInfo.syncToPreviewApp || this.$runOnDevicesDataService.hasDeviceDescriptors(projectDir));
 		if (shouldStartWatcher) {
-			this.handleRunOnDeviceEvents(projectDir);
+			this.handleRunOnDeviceError(projectDir);
 
 			this.$platformWatcherService.on(INITIAL_SYNC_EVENT_NAME, async (data: IInitialSyncEventData) => {
-				await this.$runOnDevicesController.syncInitialDataOnDevice(data, projectData, liveSyncInfo, deviceDescriptors);
+				await this.$runOnDevicesController.syncInitialDataOnDevices(data, projectData, liveSyncInfo, deviceDescriptorsForInitialSync);
 			});
 			this.$platformWatcherService.on(FILES_CHANGE_EVENT_NAME, async (data: IFilesChangeEventData) => {
-				await this.$runOnDevicesController.syncChangedDataOnDevice(data, projectData, liveSyncInfo, deviceDescriptors);
+				await this.$runOnDevicesController.syncChangedDataOnDevices(data, projectData, liveSyncInfo, deviceDescriptors);
 			});
 
 			for (const platform of platforms) {
 				const { nativePlatformData, preparePlatformData } = this.$workflowDataService.createWorkflowData(platform, projectDir, liveSyncInfo);
 				await this.$platformWatcherService.startWatchers(nativePlatformData, projectData, preparePlatformData);
 			}
+		} else {
+			for (const platform of platforms) {
+				const hasNativeChanges = await this.preparePlatform(platform, projectDir, <any>liveSyncInfo);
+				await this.$runOnDevicesController.syncInitialDataOnDevices({ platform, hasNativeChanges }, projectData, liveSyncInfo, deviceDescriptorsForInitialSync);
+			}
 		}
 
-		// TODO: Consider how to handle --justlaunch
-
 		this.attachDeviceLostHandler();
 	}
 
 	public async stopRunOnDevices(projectDir: string, deviceIdentifiers?: string[], stopOptions?: { shouldAwaitAllActions: boolean }): Promise<void> {
-		const liveSyncProcessInfo = this.$runOnDevicesDataService.getData(projectDir);
+		const liveSyncProcessInfo = this.$runOnDevicesDataService.getDataForProject(projectDir);
 		if (liveSyncProcessInfo && !liveSyncProcessInfo.isStopped) {
 			// In case we are coming from error during livesync, the current action is the one that erred (but we are still executing it),
 			// so we cannot await it as this will cause infinite loop.
@@ -112,15 +120,22 @@ export class MainController extends EventEmitter {
 			const removedDeviceIdentifiers = _.remove(liveSyncProcessInfo.deviceDescriptors, descriptor => _.includes(deviceIdentifiersToRemove, descriptor.identifier))
 				.map(descriptor => descriptor.identifier);
 
+			// Handle the case when no more devices left for any of the persisted platforms
+			_.each(liveSyncProcessInfo.platforms, platform => {
+				const devices = this.$devicesService.getDevicesForPlatform(platform);
+				if (!devices || !devices.length) {
+					this.$platformWatcherService.stopWatchers(projectDir, platform);
+				}
+			});
+
 			// In case deviceIdentifiers are not passed, we should stop the whole LiveSync.
 			if (!deviceIdentifiers || !deviceIdentifiers.length || !liveSyncProcessInfo.deviceDescriptors || !liveSyncProcessInfo.deviceDescriptors.length) {
 				if (liveSyncProcessInfo.timer) {
 					clearTimeout(liveSyncProcessInfo.timer);
 				}
 
-				_.each(liveSyncProcessInfo.deviceDescriptors, deviceDescriptor => {
-					const device = this.$devicesService.getDeviceByIdentifier(deviceDescriptor.identifier);
-					this.$platformWatcherService.stopWatchers(projectDir, device.deviceInfo.platform);
+				_.each(liveSyncProcessInfo.platforms, platform => {
+					this.$platformWatcherService.stopWatchers(projectDir, platform);
 				});
 
 				liveSyncProcessInfo.isStopped = true;
@@ -131,12 +146,6 @@ export class MainController extends EventEmitter {
 
 				liveSyncProcessInfo.deviceDescriptors = [];
 
-				if (liveSyncProcessInfo.syncToPreviewApp) {
-					// await this.$previewAppLiveSyncService.stopLiveSync();
-					// this.$previewAppLiveSyncService.removeAllListeners();
-				}
-
-				// Kill typescript watcher
 				const projectData = this.$projectDataService.getProjectData(projectDir);
 				await this.$hooksService.executeAfterHooks('watch', {
 					hookArgs: {
@@ -158,22 +167,12 @@ export class MainController extends EventEmitter {
 		return this.$runOnDevicesDataService.getDeviceDescriptors(projectDir);
 	}
 
-	private handleRunOnDeviceEvents(projectDir: string): void {
-		this.$runOnDevicesController.on(RunOnDeviceEvents.runOnDeviceError, async data => {
+	private handleRunOnDeviceError(projectDir: string): void {
+		this.$runOnDevicesEmitter.on(RunOnDeviceEvents.runOnDeviceError, async data => {
 			await this.stopRunOnDevices(projectDir, [data.deviceIdentifier], { shouldAwaitAllActions: false });
 		});
 	}
 
-	// TODO: expose previewOnDevice() method { }
-	// TODO: enableDebugging -> mainController
-	// TODO: disableDebugging -> mainController
-	// TODO: attachDebugger -> mainController
-	// mainController.runOnDevices(), runOnDevicesController.on("event", () => {})
-
-	// debugOnDevicesController.enableDebugging()
-	// debugOnDevicesController.disableDebugging()
-	// debugOnDevicesController.attachDebugger
-
 	private async initializeSetup(projectData: IProjectData): Promise<void> {
 		try {
 			await this.$pluginsService.ensureAllDependenciesAreInstalled(projectData);

lib/controllers/run-on-devices-controller.ts

@@ -8,6 +8,7 @@ import { RunOnDevicesDataService } from "../services/run-on-devices-data-service
 import { RunOnDevicesEmitter } from "../run-on-devices-emitter";
 import { WorkflowDataService } from "../services/workflow/workflow-data-service";
 import { HmrConstants } from "../common/constants";
+import { PreparePlatformService } from "../services/platform/prepare-platform-service";
 
 export class RunOnDevicesController extends EventEmitter {
 	constructor(
@@ -20,29 +21,32 @@ export class RunOnDevicesController extends EventEmitter {
 		public $hooksService: IHooksService,
 		private $liveSyncServiceResolver: LiveSyncServiceResolver,
 		private $logger: ILogger,
+		private $preparePlatformService: PreparePlatformService,
 		private $runOnDevicesDataService: RunOnDevicesDataService,
 		private $runOnDevicesEmitter: RunOnDevicesEmitter,
 		private $workflowDataService: WorkflowDataService
 	) { super(); }
 
-	public async syncInitialDataOnDevice(data: IInitialSyncEventData, projectData: IProjectData, liveSyncInfo: ILiveSyncInfo, deviceDescriptors: ILiveSyncDeviceInfo[]): Promise<void> {
+	public async syncInitialDataOnDevices(data: IInitialSyncEventData, projectData: IProjectData, liveSyncInfo: ILiveSyncInfo, deviceDescriptors: ILiveSyncDeviceInfo[]): Promise<void> {
 		const deviceAction = async (device: Mobile.IDevice) => {
 			const deviceDescriptor = _.find(deviceDescriptors, dd => dd.identifier === device.deviceInfo.identifier);
 			const { nativePlatformData: platformData, buildPlatformData } = this.$workflowDataService.createWorkflowData(device.deviceInfo.platform, projectData.projectDir, liveSyncInfo);
 
 			try {
 				const outputPath = deviceDescriptor.outputPath || platformData.getBuildOutputPath(buildPlatformData);
-				const packageFilePath = await this.$buildPlatformService.buildPlatformIfNeeded(platformData, projectData, buildPlatformData, outputPath);
+				const packageFilePath = data.hasNativeChanges ?
+					await this.$buildPlatformService.buildPlatform(platformData, projectData, buildPlatformData) :
+					await this.$buildPlatformService.buildPlatformIfNeeded(platformData, projectData, buildPlatformData, outputPath);
 
 				await this.$deviceInstallAppService.installOnDeviceIfNeeded(device, platformData, projectData, buildPlatformData, packageFilePath, outputPath);
 
 				const platformLiveSyncService = this.$liveSyncServiceResolver.resolveLiveSyncService(platformData.platformNameLowerCase);
 				const { force, useHotModuleReload, skipWatcher } = liveSyncInfo;
 				const liveSyncResultInfo = await platformLiveSyncService.fullSync({ force, useHotModuleReload, projectData, device, watch: !skipWatcher, liveSyncDeviceInfo: deviceDescriptor });
 
-				const refreshInfo = await this.$deviceRefreshAppService.refreshApplicationWithoutDebug(projectData, liveSyncResultInfo, deviceDescriptor);
+				const refreshInfo = await this.$deviceRefreshAppService.refreshApplication(projectData, liveSyncResultInfo, deviceDescriptor);
 
-				this.$runOnDevicesEmitter.emitRunOnDeviceExecutedEvent(projectData, liveSyncResultInfo.deviceAppData.device, {
+				this.$runOnDevicesEmitter.emitRunOnDeviceExecutedEvent(projectData, device, {
 					syncedFiles: liveSyncResultInfo.modifiedFilesData.map(m => m.getLocalPath()),
 					isFullSync: liveSyncResultInfo.isFullSync
 				});
@@ -58,22 +62,20 @@ export class RunOnDevicesController extends EventEmitter {
 				this.$logger.warn(`Unable to apply changes on device: ${device.deviceInfo.identifier}. Error is: ${err.message}.`);
 
 				this.$runOnDevicesEmitter.emitRunOnDeviceErrorEvent(projectData, device, err);
-
-				// TODO: Consider to call here directly stopRunOnDevices
 			}
 		};
 
 		await this.addActionToChain(projectData.projectDir, () => this.$devicesService.execute(deviceAction, (device: Mobile.IDevice) => device.deviceInfo.platform.toLowerCase() === data.platform.toLowerCase() && _.some(deviceDescriptors, deviceDescriptor => deviceDescriptor.identifier === device.deviceInfo.identifier)));
 	}
 
-	public async syncChangedDataOnDevice(data: IFilesChangeEventData, projectData: IProjectData, liveSyncInfo: ILiveSyncInfo, deviceDescriptors: ILiveSyncDeviceInfo[]): Promise<void> {
+	public async syncChangedDataOnDevices(data: IFilesChangeEventData, projectData: IProjectData, liveSyncInfo: ILiveSyncInfo, deviceDescriptors: ILiveSyncDeviceInfo[]): Promise<void> {
 		const deviceAction = async (device: Mobile.IDevice) => {
 			const deviceDescriptor = _.find(deviceDescriptors, dd => dd.identifier === device.deviceInfo.identifier);
-			const { nativePlatformData, buildPlatformData } = this.$workflowDataService.createWorkflowData(device.deviceInfo.platform, projectData.projectDir, liveSyncInfo);
+			const { nativePlatformData, preparePlatformData, buildPlatformData } = this.$workflowDataService.createWorkflowData(device.deviceInfo.platform, projectData.projectDir, liveSyncInfo);
 
 			try {
 				if (data.hasNativeChanges) {
-					// TODO: Consider to handle nativePluginsChange here (aar rebuilt)
+					await this.$preparePlatformService.prepareNativePlatform(nativePlatformData, projectData, preparePlatformData);
 					await this.$buildPlatformService.buildPlatform(nativePlatformData, projectData, buildPlatformData);
 				}
 
@@ -123,13 +125,13 @@ export class RunOnDevicesController extends EventEmitter {
 		};
 
 		await this.addActionToChain(projectData.projectDir, () => this.$devicesService.execute(deviceAction, (device: Mobile.IDevice) => {
-			const liveSyncProcessInfo = this.$runOnDevicesDataService.getData(projectData.projectDir);
+			const liveSyncProcessInfo = this.$runOnDevicesDataService.getDataForProject(projectData.projectDir);
 			return (data.platform.toLowerCase() === device.deviceInfo.platform.toLowerCase()) && liveSyncProcessInfo && _.some(liveSyncProcessInfo.deviceDescriptors, deviceDescriptor => deviceDescriptor.identifier === device.deviceInfo.identifier);
 		}));
 	}
 
 	private async refreshApplication(projectData: IProjectData, liveSyncResultInfo: ILiveSyncResultInfo, deviceDescriptor: ILiveSyncDeviceInfo) {
-		const refreshInfo = await this.$deviceRefreshAppService.refreshApplicationWithoutDebug(projectData, liveSyncResultInfo, deviceDescriptor);
+		const refreshInfo = await this.$deviceRefreshAppService.refreshApplication(projectData, liveSyncResultInfo, deviceDescriptor);
 
 		this.$runOnDevicesEmitter.emitRunOnDeviceExecutedEvent(projectData, liveSyncResultInfo.deviceAppData.device, {
 			syncedFiles: liveSyncResultInfo.modifiedFilesData.map(m => m.getLocalPath()),
@@ -142,7 +144,7 @@ export class RunOnDevicesController extends EventEmitter {
 	}
 
 	private async addActionToChain<T>(projectDir: string, action: () => Promise<T>): Promise<T> {
-		const liveSyncInfo = this.$runOnDevicesDataService.getData(projectDir);
+		const liveSyncInfo = this.$runOnDevicesDataService.getDataForProject(projectDir);
 		if (liveSyncInfo) {
 			liveSyncInfo.actionsChain = liveSyncInfo.actionsChain.then(async () => {
 				if (!liveSyncInfo.isStopped) {

lib/declarations.d.ts

@@ -433,10 +433,6 @@ interface IOpener {
 	open(target: string, appname: string): void;
 }
 
-interface IBundle {
-	bundle: boolean;
-}
-
 interface IBundleString {
 	bundle: string;
 }

lib/definitions/livesync.d.ts

@@ -8,6 +8,7 @@ declare global {
 		deviceDescriptors: ILiveSyncDeviceInfo[];
 		currentSyncAction: Promise<any>;
 		syncToPreviewApp: boolean;
+		platforms: string[];
 	}
 
 	interface IOptionalOutputPath {

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

@@ -18,7 +18,7 @@ declare global {
 		filesToRemove?: string[];
 	}
 
-	interface IPreviewAppLiveSyncData extends IProjectDir, IHasUseHotModuleReloadOption, IBundle, IEnvOptions { }
+	interface IPreviewAppLiveSyncData extends IProjectDir, IHasUseHotModuleReloadOption, IEnvOptions { }
 
 	interface IPreviewSdkService extends EventEmitter {
 		getQrCodeUrl(options: IGetQrCodeUrlOptions): string;

lib/helpers/bundle-validator-helper.ts

@@ -15,19 +15,17 @@ export class BundleValidatorHelper extends VersionValidatorHelper implements IBu
 	}
 
 	public validate(minSupportedVersion?: string): void {
-		if (this.$options.bundle) {
-			const bundlePluginName = this.bundlersMap[this.$options.bundle];
-			const bundlerVersionInDependencies = this.$projectData.dependencies && this.$projectData.dependencies[bundlePluginName];
-			const bundlerVersionInDevDependencies = this.$projectData.devDependencies && this.$projectData.devDependencies[bundlePluginName];
-			if (!bundlePluginName || (!bundlerVersionInDependencies && !bundlerVersionInDevDependencies)) {
-				this.$errors.failWithoutHelp(BundleValidatorMessages.MissingBundlePlugin);
-			}
+		const bundlePluginName = this.bundlersMap["webpack"];
+		const bundlerVersionInDependencies = this.$projectData.dependencies && this.$projectData.dependencies[bundlePluginName];
+		const bundlerVersionInDevDependencies = this.$projectData.devDependencies && this.$projectData.devDependencies[bundlePluginName];
+		if (!bundlePluginName || (!bundlerVersionInDependencies && !bundlerVersionInDevDependencies)) {
+			this.$errors.failWithoutHelp(BundleValidatorMessages.MissingBundlePlugin);
+		}
 
-			const currentVersion = bundlerVersionInDependencies || bundlerVersionInDevDependencies;
-			const shouldThrowError = minSupportedVersion && this.isValidVersion(currentVersion) && this.isVersionLowerThan(currentVersion, minSupportedVersion);
-			if (shouldThrowError) {
-					this.$errors.failWithoutHelp(util.format(BundleValidatorMessages.NotSupportedVersion, minSupportedVersion));
-			}
+		const currentVersion = bundlerVersionInDependencies || bundlerVersionInDevDependencies;
+		const shouldThrowError = minSupportedVersion && this.isValidVersion(currentVersion) && this.isVersionLowerThan(currentVersion, minSupportedVersion);
+		if (shouldThrowError) {
+				this.$errors.failWithoutHelp(util.format(BundleValidatorMessages.NotSupportedVersion, minSupportedVersion));
 		}
 	}
 }

lib/helpers/livesync-command-helper.ts

@@ -1,8 +1,6 @@
 import { BuildPlatformService } from "../services/platform/build-platform-service";
 import { MainController } from "../controllers/main-controller";
 
-// import { LiveSyncEvents } from "../constants";
-
 export class LiveSyncCommandHelper implements ILiveSyncCommandHelper {
 	public static MIN_SUPPORTED_WEBPACK_VERSION_WITH_HMR = "0.17.0";