fix: debug doesn't await file trasfer end with socket implementation

Author: KristianDD

lib/definitions/livesync.d.ts

@@ -344,6 +344,7 @@ interface IPlatformLiveSyncService {
 	liveSyncWatchAction(device: Mobile.IDevice, liveSyncInfo: ILiveSyncWatchInfo): Promise<ILiveSyncResultInfo>;
 	refreshApplication(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo): Promise<void>;
 	prepareForLiveSync(device: Mobile.IDevice, data: IProjectDir, liveSyncInfo: ILiveSyncInfo, debugOptions: IDebugOptions): Promise<void>;
+	getDeviceLiveSyncService(device: Mobile.IDevice, projectData: IProjectData): INativeScriptDeviceLiveSyncService;
 }
 
 interface INativeScriptDeviceLiveSyncService extends IDeviceLiveSyncServiceBase {
@@ -376,6 +377,13 @@ interface INativeScriptDeviceLiveSyncService extends IDeviceLiveSyncServiceBase
 	 * @return {Promise<Mobile.ILocalToDevicePathData[]>} Returns the ILocalToDevicePathData of all transfered files
 	 */
 	transferFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string, isFullSync: boolean): Promise<Mobile.ILocalToDevicePathData[]>;
+
+	/**
+	 * Guarantees all remove/update operations have finished
+	 * @param  {ILiveSyncResultInfo} liveSyncInfo Describes the LiveSync operation - for which project directory is the operation and other settings.
+	 * @return {Promise<void>}
+	 */
+	finalizeSync(liveSyncInfo: ILiveSyncResultInfo): Promise<void>;
 }
 
 interface IAndroidNativeScriptDeviceLiveSyncService {

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

@@ -29,16 +29,22 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 		await this.connectLivesyncTool(projectFilesPath, this.data.projectId);
 	}
 
-	public async refreshApplication(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo): Promise<void> {
-		const canExecuteFastSync = !liveSyncInfo.isFullSync && this.canExecuteFastSyncForPaths(liveSyncInfo.modifiedFilesData, projectData, this.device.deviceInfo.platform);
+	public async finalizeSync(liveSyncInfo: ILiveSyncResultInfo) {
+		await this.doSync(liveSyncInfo, false);
+	}
+
+	private async doSync(liveSyncInfo: ILiveSyncResultInfo, doRefresh = false): Promise<IAndroidLivesyncSyncOperationResult> {
+		let result;
+		const operationId = this.livesyncTool.generateOperationIdentifier();
+
+		result = {operationId, didRefresh: true };
 
 		if (liveSyncInfo.modifiedFilesData.length) {
-			const operationIdentifier = this.livesyncTool.generateOperationIdentifier();
 
-			const doSyncPromise = this.livesyncTool.sendDoSyncOperation(canExecuteFastSync, null, operationIdentifier);
+			const doSyncPromise = this.livesyncTool.sendDoSyncOperation(doRefresh, null, operationId);
 
 			const syncInterval : NodeJS.Timer = setInterval(() => {
-				if (this.livesyncTool.isOperationInProgress(operationIdentifier)) {
+				if (this.livesyncTool.isOperationInProgress(operationId)) {
 					this.$logger.info("Sync operation in progress...");
 				}
 			}, AndroidDeviceSocketsLiveSyncService.STATUS_UPDATE_INTERVAL);
@@ -50,14 +56,22 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 			this.$processService.attachToProcessExitSignals(this, clearSyncInterval);
 			doSyncPromise.then(clearSyncInterval, clearSyncInterval);
 
-			const refreshResult = await doSyncPromise;
-
-			if (!canExecuteFastSync || !refreshResult.didRefresh) {
-				await this.device.applicationManager.restartApplication({ appId: liveSyncInfo.deviceAppData.appIdentifier, projectName: projectData.projectName });
-			}
+			result = await doSyncPromise;
 		}
 
+		return result;
+	}
+
+	public async refreshApplication(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo) {
+		const canExecuteFastSync = !liveSyncInfo.isFullSync && this.canExecuteFastSyncForPaths(liveSyncInfo.modifiedFilesData, projectData, this.device.deviceInfo.platform);
+
+		const syncOperationResult = await this.doSync(liveSyncInfo, canExecuteFastSync);
+
 		this.livesyncTool.end();
+
+		if (!canExecuteFastSync || !syncOperationResult.didRefresh) {
+			await this.device.applicationManager.restartApplication({ appId: liveSyncInfo.deviceAppData.appIdentifier, projectName: projectData.projectName });
+		}
 	}
 
 	public async removeFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<void> {

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

@@ -38,4 +38,8 @@ export abstract class DeviceLiveSyncServiceBase {
 
 		return transferredFiles;
 	}
+
+	public async finalizeSync(liveSyncInfo: ILiveSyncResultInfo): Promise<void> {
+		//implement in case a sync point for all remove/create operation is needed
+	}
 }

lib/services/livesync/livesync-service.ts

@@ -164,6 +164,9 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 		};
 
 		try {
+			const platformLiveSyncService = this.getLiveSyncService(liveSyncResultInfo.deviceAppData.platform);
+			const deviceLivesyncService = platformLiveSyncService.getDeviceLiveSyncService(deviceAppData.device, projectData);
+			await deviceLivesyncService.finalizeSync(liveSyncResultInfo);
 			await deviceAppData.device.applicationManager.stopApplication({ appId: applicationId, projectName: projectData.projectName });
 			// Now that we've stopped the application we know it isn't started, so set debugOptions.start to false
 			// so that it doesn't default to true in attachDebugger method