Speed up android livesync

Author: Fatme

lib/common

@@ -39,6 +39,7 @@ export const CONFIG_NS_APP_RESOURCES_ENTRY = "appResourcesPath";
 export const CONFIG_NS_APP_ENTRY = "appPath";
 export const DEPENDENCIES_JSON_NAME = "dependencies.json";
 export const APK_EXTENSION_NAME = ".apk";
+export const HASHES_FILE_NAME = ".nshashes";
 
 export class PackageVersion {
 	static NEXT = "next";

lib/constants.ts

@@ -1,5 +1,27 @@
 interface IFilesHashService {
 	generateHashes(files: string[]): Promise<IStringDictionary>;
+	/**
+	 * Generate hashes for all prepared files (all files from app folder under platforms folder).
+	 * @param platformData - Current platform's data
+	 * @returns {Promise<IStringDictionary>}
+	 * A map with key file's path and value - file's hash
+	 */
+	generateHashesForProject(platformData: IPlatformData): Promise<IStringDictionary>;
+	/**
+	 * @param hashesFileDirectory - Path to directory containing the hash file.
+	 * @returns {IStringDictionary}
+	 * In case .nshashes file exists (under `hashesFileDirectory` directory), returns its content
+	 * In case .nshashes file does not exist (under `hashesFileDirectory` directory), returns {}
+	 */
+	getGeneratedHashes(hashesFileDirectory: string): IStringDictionary;
+	/**
+	 * Generates hashes for all prepared files (all files from app folder under platforms folder)
+	 * and saves them in .nshashes file under `hashFileDirectory` directory.
+	 * @param platformData - Current platform's data
+	 * @param hashesFileDirectory - Path to directory containing the hash file.
+	 * @returns {Promise<void>}
+	 */
+	saveHashesForProject(platformData: IPlatformData, hashesFileDirectory: string): Promise<void>;
 	getChanges(files: string[], oldHashes: IStringDictionary): Promise<IStringDictionary>;
 	hasChangesInShasums(oldHashes: IStringDictionary, newHashes: IStringDictionary): boolean;
 }

lib/definitions/files-hash-service.d.ts

@@ -30,7 +30,8 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 		private $npm: INodePackageManager,
 		private $androidPluginBuildService: IAndroidPluginBuildService,
 		private $platformEnvironmentRequirements: IPlatformEnvironmentRequirements,
-		private $androidResourcesMigrationService: IAndroidResourcesMigrationService) {
+		private $androidResourcesMigrationService: IAndroidResourcesMigrationService,
+		private $filesHashService: IFilesHashService) {
 		super($fs, $projectDataService);
 		this.isAndroidStudioTemplate = false;
 	}
@@ -340,6 +341,8 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 				message: "Gradle build..."
 			})
 		);
+
+		await this.$filesHashService.saveHashesForProject(this._platformData, this._platformData.deviceBuildOutputPath);
 	}
 
 	private getGradleBuildOptions(settings: IAndroidBuildOptionsSettings, projectData: IProjectData): Array<string> {

lib/services/android-project-service.ts

@@ -1,5 +1,7 @@
 import { executeActionByChunks } from "../common/helpers";
 import { DEFAULT_CHUNK_SIZE } from "../common/constants";
+import { APP_FOLDER_NAME, HASHES_FILE_NAME } from "../constants";
+import * as path from "path";
 
 export class FilesHashService implements IFilesHashService {
 	constructor(private $fs: IFileSystem,
@@ -24,6 +26,29 @@ export class FilesHashService implements IFilesHashService {
 		return result;
 	}
 
+	public async generateHashesForProject(platformData: IPlatformData): Promise<IStringDictionary> {
+		const appFilesPath = path.join(platformData.appDestinationDirectoryPath, APP_FOLDER_NAME);
+		const files = this.$fs.enumerateFilesInDirectorySync(appFilesPath);
+		const hashes = await this.generateHashes(files);
+		return hashes;
+	}
+
+	public async saveHashesForProject(platformData: IPlatformData, hashesFileDirectory: string): Promise<void> {
+		const hashes = await this.generateHashesForProject(platformData);
+		const hashesFilePath = path.join(hashesFileDirectory, HASHES_FILE_NAME);
+		this.$fs.writeJson(hashesFilePath, hashes);
+	}
+
+	public getGeneratedHashes(hashesFileDirectory: string): IStringDictionary {
+		let result = {};
+		const hashesFilePath = path.join(hashesFileDirectory, HASHES_FILE_NAME);
+		if (this.$fs.exists(hashesFilePath)) {
+			result = this.$fs.readJson(hashesFilePath);
+		}
+
+		return result;
+	}
+
 	public async getChanges(files: string[], oldHashes: IStringDictionary): Promise<IStringDictionary> {
 		const newHashes = await this.generateHashes(files);
 		return this.getChangesInShasums(oldHashes, newHashes);

lib/services/files-hash-service.ts

@@ -117,6 +117,11 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 		return transferredFiles;
 	}
 
+	public getDeviceHashService(appIdentifier: string): Mobile.IAndroidDeviceHashService {
+		const adb = this.$injector.resolve(DeviceAndroidDebugBridge, { identifier: this.device.deviceInfo.identifier });
+		return this.$injector.resolve(AndroidDeviceHashService, { adb, appIdentifier });
+	}
+
 	private async _transferFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<Mobile.ILocalToDevicePathData[]> {
 		await this.livesyncTool.sendFiles(localToDevicePaths.map(localToDevicePathData => localToDevicePathData.getLocalPath()));
 
@@ -132,19 +137,24 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 	private async _transferDirectory(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<Mobile.ILocalToDevicePathData[]> {
 		let transferredLocalToDevicePaths: Mobile.ILocalToDevicePathData[];
 		const deviceHashService = this.getDeviceHashService(deviceAppData.appIdentifier);
-		const currentShasums: IStringDictionary = await deviceHashService.generateHashesFromLocalToDevicePaths(localToDevicePaths);
-		const oldShasums = await deviceHashService.getShasumsFromDevice();
+		const currentHashes = await deviceHashService.generateHashesFromLocalToDevicePaths(localToDevicePaths);
+		const oldHashes = await deviceHashService.getShasumsFromDevice();
+		console.log("!!!!! OLD HASHES!!!!!!");
+		console.log(oldHashes);
 
-		if (this.$options.force || !oldShasums) {
+		if (this.$options.force || !oldHashes) {
+			console.log("!!!!!!!!! NO OLD HASHES!!!!! THIS SHOULD NOT HAPPEN!!!!!!!");
 			await this.livesyncTool.sendDirectory(projectFilesPath);
-			await deviceHashService.uploadHashFileToDevice(currentShasums);
+			await deviceHashService.uploadHashFileToDevice(currentHashes);
 			transferredLocalToDevicePaths = localToDevicePaths;
 		} else {
-			const changedShasums = deviceHashService.getChangedShasums(oldShasums, currentShasums);
+			const changedShasums = deviceHashService.getChangedShasums(oldHashes, currentHashes);
+			console.log("CHANGEDSHASUMS!!!!!!!!!!!!!!!");
+			console.log(changedShasums);
 			const changedFiles = _.keys(changedShasums);
 			if (changedFiles.length) {
 				await this.livesyncTool.sendFiles(changedFiles);
-				await deviceHashService.uploadHashFileToDevice(currentShasums);
+				await deviceHashService.uploadHashFileToDevice(currentHashes);
 				transferredLocalToDevicePaths = localToDevicePaths.filter(localToDevicePathData => changedFiles.indexOf(localToDevicePathData.getLocalPath()) >= 0);
 			} else {
 				transferredLocalToDevicePaths = [];
@@ -165,9 +175,4 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 			});
 		}
 	}
-
-	public getDeviceHashService(appIdentifier: string): Mobile.IAndroidDeviceHashService {
-		const adb = this.$injector.resolve(DeviceAndroidDebugBridge, { identifier: this.device.deviceInfo.identifier });
-		return this.$injector.resolve(AndroidDeviceHashService, { adb, appIdentifier });
-	}
 }

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

@@ -41,7 +41,8 @@ export class PlatformService extends EventEmitter implements IPlatformService {
 		private $projectChangesService: IProjectChangesService,
 		private $analyticsService: IAnalyticsService,
 		private $terminalSpinnerService: ITerminalSpinnerService,
-		private $pacoteService: IPacoteService
+		private $pacoteService: IPacoteService,
+		private $filesHashService: IFilesHashService
 	) {
 		super();
 	}
@@ -488,8 +489,18 @@ export class PlatformService extends EventEmitter implements IPlatformService {
 
 		await platformData.platformProjectService.cleanDeviceTempFolder(device.deviceInfo.identifier, projectData);
 
+		const isApplicationInstalled = await this.isApplicationInstalled(device, projectData);
+
 		await device.applicationManager.reinstallApplication(projectData.projectId, packageFile);
 
+		await this.updateHashesOnDevice({
+			device,
+			isApplicationInstalled,
+			appIdentifier: projectData.projectId,
+			outputFilePath,
+			platformData
+		});
+
 		if (!buildConfig.release) {
 			const deviceFilePath = await this.getDeviceBuildInfoFilePath(device, projectData);
 			const options = buildConfig;
@@ -503,6 +514,32 @@ export class PlatformService extends EventEmitter implements IPlatformService {
 		this.$logger.out(`Successfully installed on device with identifier '${device.deviceInfo.identifier}'.`);
 	}
 
+	private async updateHashesOnDevice(data: { device: Mobile.IDevice, isApplicationInstalled: boolean, appIdentifier: string, outputFilePath: string, platformData: IPlatformData }): Promise<void> {
+		const { device, isApplicationInstalled, appIdentifier, platformData, outputFilePath } = data;
+
+		if (!this.$mobileHelper.isAndroidPlatform(platformData.normalizedPlatformName)) {
+			return;
+		}
+
+		let hashes = null;
+		if (isApplicationInstalled) {
+			hashes = await this.$filesHashService.generateHashesForProject(platformData);
+		} else {
+			hashes = this.$filesHashService.getGeneratedHashes(outputFilePath || platformData.deviceBuildOutputPath);
+		}
+
+		await device.fileSystem.updateHashesOnDevice(hashes, appIdentifier);
+	}
+
+	private async isApplicationInstalled(device: Mobile.IDevice, projectData: IProjectData): Promise<boolean> {
+		let result = false;
+		if (this.$mobileHelper.isAndroidPlatform) {
+			result = await device.applicationManager.isApplicationInstalled(projectData.projectId);
+		}
+
+		return result;
+	}
+
 	public async deployPlatform(deployInfo: IDeployPlatformInfo): Promise<void> {
 		await this.preparePlatform({
 			platform: deployInfo.platform,