fix: sync all files when the app state does not support HOT updates in order to avoid multiple HMR syncs after restart

Author: DimitarTachev

lib/controllers/run-controller.ts

@@ -144,10 +144,10 @@ export class RunController extends EventEmitter implements IRunController {
 		return this.$liveSyncProcessDataService.getDeviceDescriptors(data.projectDir);
 	}
 
-	protected async refreshApplication(projectData: IProjectData, liveSyncResultInfo: ILiveSyncResultInfo, filesChangeEventData: IFilesChangeEventData, deviceDescriptor: ILiveSyncDeviceDescriptor): Promise<IRestartApplicationInfo> {
+	protected async refreshApplication(projectData: IProjectData, liveSyncResultInfo: ILiveSyncResultInfo, filesChangeEventData: IFilesChangeEventData, deviceDescriptor: ILiveSyncDeviceDescriptor, fullSyncAction?: () => Promise<void>): Promise<IRestartApplicationInfo> {
 		const result = deviceDescriptor.debuggingEnabled ?
 			await this.refreshApplicationWithDebug(projectData, liveSyncResultInfo, filesChangeEventData, deviceDescriptor) :
-			await this.refreshApplicationWithoutDebug(projectData, liveSyncResultInfo, filesChangeEventData, deviceDescriptor);
+			await this.refreshApplicationWithoutDebug(projectData, liveSyncResultInfo, filesChangeEventData, deviceDescriptor, undefined, fullSyncAction);
 
 		const device = liveSyncResultInfo.deviceAppData.device;
 
@@ -181,14 +181,15 @@ export class RunController extends EventEmitter implements IRunController {
 	}
 
 	@performanceLog()
-	protected async refreshApplicationWithoutDebug(projectData: IProjectData, liveSyncResultInfo: ILiveSyncResultInfo, filesChangeEventData: IFilesChangeEventData, deviceDescriptor: ILiveSyncDeviceDescriptor, settings?: IRefreshApplicationSettings): Promise<IRestartApplicationInfo> {
+	protected async refreshApplicationWithoutDebug(projectData: IProjectData, liveSyncResultInfo: ILiveSyncResultInfo, filesChangeEventData: IFilesChangeEventData, deviceDescriptor: ILiveSyncDeviceDescriptor, settings?: IRefreshApplicationSettings, fullSyncAction?: () => Promise<void>): Promise<IRestartApplicationInfo> {
 		const result = { didRestart: false };
 		const platform = liveSyncResultInfo.deviceAppData.platform;
 		const applicationIdentifier = projectData.projectIdentifiers[platform.toLowerCase()];
 		const platformLiveSyncService = this.$liveSyncServiceResolver.resolveLiveSyncService(platform);
 
 		try {
-			let shouldRestart = filesChangeEventData && (filesChangeEventData.hasNativeChanges || !filesChangeEventData.hasOnlyHotUpdateFiles);
+			const isFullSync = filesChangeEventData && (filesChangeEventData.hasNativeChanges || !filesChangeEventData.hasOnlyHotUpdateFiles);
+			let shouldRestart = isFullSync;
 			if (!shouldRestart) {
 				shouldRestart = await platformLiveSyncService.shouldRestart(projectData, liveSyncResultInfo);
 			}
@@ -197,6 +198,12 @@ export class RunController extends EventEmitter implements IRunController {
 				shouldRestart = !await platformLiveSyncService.tryRefreshApplication(projectData, liveSyncResultInfo);
 			}
 
+			if (!isFullSync && shouldRestart && fullSyncAction) {
+				this.$logger.trace(`Syncing all files as the current app state does not support hot updates.`);
+				liveSyncResultInfo.didRecover = true;
+				await fullSyncAction();
+			}
+
 			if (shouldRestart) {
 				this.emit(DEBUGGER_DETACHED_EVENT_NAME, { deviceIdentifier: liveSyncResultInfo.deviceAppData.device.deviceInfo.identifier });
 				await platformLiveSyncService.restartApplication(projectData, liveSyncResultInfo);
@@ -393,16 +400,21 @@ export class RunController extends EventEmitter implements IRunController {
 					}
 
 					const watchAction = async (): Promise<void> => {
-						let liveSyncResultInfo = await platformLiveSyncService.liveSyncWatchAction(device, watchInfo);
-						await this.refreshApplication(projectData, liveSyncResultInfo, data, deviceDescriptor);
+						const liveSyncResultInfo = await platformLiveSyncService.liveSyncWatchAction(device, watchInfo);
+						const fullSyncAction = async () => {
+							watchInfo.filesToSync = allAppFiles;
+							const fullLiveSyncResultInfo = await platformLiveSyncService.liveSyncWatchAction(device, watchInfo);
+							// IMPORTANT: keep the same instance as we rely on side effects
+							_.assign(liveSyncResultInfo, fullLiveSyncResultInfo);
+						};
+
+						await this.refreshApplication(projectData, liveSyncResultInfo, data, deviceDescriptor, fullSyncAction);
 
 						if (!liveSyncResultInfo.didRecover && isInHMRMode) {
 							const status = await this.$hmrStatusService.getHmrStatus(device.deviceInfo.identifier, data.hmrData.hash);
 							// error or timeout
 							if (status !== HmrConstants.HMR_SUCCESS_STATUS) {
-								watchInfo.filesToSync = data.hmrData.fallbackFiles;
-								liveSyncResultInfo = await platformLiveSyncService.liveSyncWatchAction(device, watchInfo);
-								// We want to force a restart of the application.
+								await fullSyncAction();
 								liveSyncResultInfo.isFullSync = true;
 								await this.refreshApplication(projectData, liveSyncResultInfo, data, deviceDescriptor);
 							}

lib/services/livesync/android-livesync-service.ts

@@ -25,21 +25,6 @@ export class AndroidLiveSyncService extends PlatformLiveSyncServiceBase implemen
 
 	@performanceLog()
 	public async liveSyncWatchAction(device: Mobile.IDevice, liveSyncInfo: ILiveSyncWatchInfo): Promise<IAndroidLiveSyncResultInfo> {
-		let result = await this.liveSyncWatchActionCore(device, liveSyncInfo);
-
-		// When we use hmr, there is only one case when result.didRefresh is false.
-		// This is the case when the app has crashed and is in ErrorActivity.
-		// As the app might not have time to apply the patches, we will send the whole bundle.js(fallbackFiles)
-		if (liveSyncInfo.useHotModuleReload && !result.didRefresh && liveSyncInfo.hmrData && liveSyncInfo.hmrData.hash) {
-			liveSyncInfo.filesToSync = liveSyncInfo.hmrData.fallbackFiles;
-			result = await this.liveSyncWatchActionCore(device, liveSyncInfo);
-			result.didRecover = true;
-		}
-
-		return result;
-	}
-
-	private async liveSyncWatchActionCore(device: Mobile.IDevice, liveSyncInfo: ILiveSyncWatchInfo): Promise<IAndroidLiveSyncResultInfo> {
 		const liveSyncResult = await super.liveSyncWatchAction(device, liveSyncInfo);
 		const result = await this.finalizeSync(device, liveSyncInfo.projectData, liveSyncResult);
 

lib/services/livesync/ios-device-livesync-service.ts

@@ -76,7 +76,7 @@ export class IOSDeviceLiveSyncService extends DeviceLiveSyncServiceBase implemen
 			shouldRestart = true;
 		} else {
 			const canExecuteFastSync = this.canExecuteFastSyncForPaths(liveSyncInfo, localToDevicePaths, projectData, deviceAppData.platform);
-			const isRefreshConnectionSetup = this.canRefreshWithNotification(projectData, liveSyncInfo) || (!this.device.isOnlyWiFiConnected && await this.setupSocketIfNeeded(projectData));
+			const isRefreshConnectionSetup = this.canRefreshWithNotification(projectData, liveSyncInfo) || (!this.device.isOnlyWiFiConnected && this.socket);
 			if (!canExecuteFastSync || !isRefreshConnectionSetup) {
 				shouldRestart = true;
 			}
@@ -137,6 +137,8 @@ export class IOSDeviceLiveSyncService extends DeviceLiveSyncServiceBase implemen
 			waitForDebugger: liveSyncInfo.waitForDebugger,
 			projectDir: projectData.projectDir
 		});
+		// enable HOT updates
+		await this.setupSocketIfNeeded(projectData);
 	}
 
 	private async reloadPage(): Promise<void> {