Speed up android livesync

lib/constants.ts

@@ -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/definitions/files-hash-service.d.ts

@@ -1,5 +1,21 @@
 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>;
+	/**
+	 * 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<IStringDictionary>;
+	saveHashes(hashes: IStringDictionary, hashesFileDirectory: string): void;
 	getChanges(files: string[], oldHashes: IStringDictionary): Promise<IStringDictionary>;
 	hasChangesInShasums(oldHashes: IStringDictionary, newHashes: IStringDictionary): boolean;
 }

lib/definitions/livesync.d.ts

@@ -154,6 +154,13 @@ interface ILiveSyncInfo extends IProjectDir, IEnvOptions, IBundle, IRelease, IOp
 	 */
 	clean?: boolean;
 
+	/**
+	 * Defines if initial sync will be forced.
+	 * In case it is true, transfers all project's directory on device
+	 * In case it is false, transfers only changed files.
+	 */
+	force?: boolean;
+
 	/**
 	 * Defines the timeout in seconds {N} CLI will wait to find the inspector socket port from device's logs.
 	 * If not provided, defaults to 10seconds.
@@ -330,6 +337,8 @@ interface ILiveSyncWatchInfo extends IProjectDataComposition, IHasUseHotModuleRe
 	filesToSync: string[];
 	isReinstalled: boolean;
 	syncAllFiles: boolean;
+	liveSyncDeviceInfo: ILiveSyncDeviceInfo;
+	force?: boolean;
 }
 
 interface ILiveSyncResultInfo extends IHasUseHotModuleReloadOption {
@@ -344,6 +353,13 @@ interface IFullSyncInfo extends IProjectDataComposition, IHasUseHotModuleReloadO
 	device: Mobile.IDevice;
 	watch: boolean;
 	syncAllFiles: boolean;
+	liveSyncDeviceInfo: ILiveSyncDeviceInfo;
+	force?: boolean;
+}
+
+interface ITransferFilesOptions {
+	isFullSync: boolean;
+	force?: boolean;
 }
 
 interface IPlatformLiveSyncService {
@@ -383,7 +399,7 @@ interface INativeScriptDeviceLiveSyncService extends IDeviceLiveSyncServiceBase
 	 * @param  {boolean} isFullSync Indicates if the operation is part of a fullSync
 	 * @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[]>;
+	transferFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string, projectData: IProjectData, liveSyncDeviceInfo: ILiveSyncDeviceInfo, options: ITransferFilesOptions): Promise<Mobile.ILocalToDevicePathData[]>;
 }
 
 interface IAndroidNativeScriptDeviceLiveSyncService extends INativeScriptDeviceLiveSyncService {

lib/helpers/livesync-command-helper.ts

@@ -115,7 +115,8 @@ export class LiveSyncCommandHelper implements ILiveSyncCommandHelper {
 			release: this.$options.release,
 			env: this.$options.env,
 			timeout: this.$options.timeout,
-			useHotModuleReload: this.$options.hmr
+			useHotModuleReload: this.$options.hmr,
+			force: this.$options.force
 		};
 
 		await this.$liveSyncService.liveSync(deviceDescriptors, liveSyncInfo);

lib/services/android-project-service.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/files-hash-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,19 @@ 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<IStringDictionary> {
+		const hashes = await this.generateHashesForProject(platformData);
+		this.saveHashes(hashes, hashesFileDirectory);
+		return hashes;
+	}
+
 	public async getChanges(files: string[], oldHashes: IStringDictionary): Promise<IStringDictionary> {
 		const newHashes = await this.generateHashes(files);
 		return this.getChangesInShasums(oldHashes, newHashes);
@@ -33,6 +48,11 @@ export class FilesHashService implements IFilesHashService {
 		return !!_.keys(this.getChangesInShasums(oldHashes, newHashes)).length;
 	}
 
+	public saveHashes(hashes: IStringDictionary, hashesFileDirectory: string): void {
+		const hashesFilePath = path.join(hashesFileDirectory, HASHES_FILE_NAME);
+		this.$fs.writeJson(hashesFilePath, hashes);
+	}
+
 	private getChangesInShasums(oldHashes: IStringDictionary, newHashes: IStringDictionary): IStringDictionary {
 		return _.omitBy(newHashes, (hash: string, pathToFile: string) => !!_.find(oldHashes, (oldHash: string, oldPath: string) => pathToFile === oldPath && hash === oldHash));
 	}

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

@@ -0,0 +1,85 @@
+import { DeviceLiveSyncServiceBase } from './device-livesync-service-base';
+import { AndroidDeviceHashService } from "../../common/mobile/android/android-device-hash-service";
+
+export abstract class AndroidDeviceLiveSyncServiceBase extends DeviceLiveSyncServiceBase {
+	private deviceHashServices: IDictionary<Mobile.IAndroidDeviceHashService>;
+
+	constructor(protected $injector: IInjector,
+		protected $platformsData: IPlatformsData,
+		protected $filesHashService: IFilesHashService,
+		protected $logger: ILogger,
+		protected device: Mobile.IAndroidDevice) {
+			super($platformsData, device);
+			this.deviceHashServices = {};
+	}
+
+	public abstract async transferFilesOnDevice(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<void>;
+	public abstract async transferDirectoryOnDevice(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<void>;
+
+	public getDeviceHashService(appIdentifier: string): Mobile.IAndroidDeviceHashService {
+		const key = `${this.device.deviceInfo.identifier}${appIdentifier}`;
+		if (!this.deviceHashServices[key]) {
+			const deviceHashService = this.$injector.resolve(AndroidDeviceHashService, { adb: this.device.adb, appIdentifier });
+			this.deviceHashServices[key] = deviceHashService;
+		}
+
+		return this.deviceHashServices[key];
+	}
+
+	public async transferFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string, projectData: IProjectData, liveSyncDeviceInfo: ILiveSyncDeviceInfo, options: ITransferFilesOptions): Promise<Mobile.ILocalToDevicePathData[]> {
+		const transferredFiles = await this.transferFilesCore(deviceAppData, localToDevicePaths, projectFilesPath, options);
+		await this.updateHashes(deviceAppData, localToDevicePaths, projectData, liveSyncDeviceInfo);
+		return transferredFiles;
+	}
+
+	private async transferFilesCore(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string, options: ITransferFilesOptions): Promise<Mobile.ILocalToDevicePathData[]> {
+		if (options.force && options.isFullSync) {
+			const hashFileDevicePath = this.getDeviceHashService(deviceAppData.appIdentifier).hashFileDevicePath;
+			await this.device.fileSystem.deleteFile(hashFileDevicePath, deviceAppData.appIdentifier);
+			this.$logger.trace("Before transfer directory on device ", localToDevicePaths);
+			await this.transferDirectoryOnDevice(deviceAppData, localToDevicePaths, projectFilesPath);
+			return localToDevicePaths;
+		}
+
+		const localToDevicePathsToTransfer = await this.getLocalToDevicePathsToTransfer(deviceAppData, localToDevicePaths, options);
+		this.$logger.trace("Files to transfer: ", localToDevicePathsToTransfer);
+		await this.transferFilesOnDevice(deviceAppData, localToDevicePathsToTransfer);
+		return localToDevicePathsToTransfer;
+	}
+
+	private async getLocalToDevicePathsToTransfer(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], options: ITransferFilesOptions): Promise<Mobile.ILocalToDevicePathData[]> {
+		if (options.force || !options.isFullSync) {
+			return localToDevicePaths;
+		}
+
+		const changedLocalToDevicePaths = await this.getChangedLocalToDevicePaths(deviceAppData.appIdentifier, localToDevicePaths);
+		return changedLocalToDevicePaths;
+	}
+
+	private async getChangedLocalToDevicePaths(appIdentifier: string, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<Mobile.ILocalToDevicePathData[]> {
+		const deviceHashService = this.getDeviceHashService(appIdentifier);
+		const currentHashes = await deviceHashService.generateHashesFromLocalToDevicePaths(localToDevicePaths);
+		const oldHashes = (await deviceHashService.getShasumsFromDevice()) || {};
+		const changedHashes = deviceHashService.getChangedShasums(oldHashes, currentHashes);
+		const changedFiles = _.keys(changedHashes);
+		const changedLocalToDevicePaths = localToDevicePaths.filter(localToDevicePathData => changedFiles.indexOf(localToDevicePathData.getLocalPath()) >= 0);
+		return changedLocalToDevicePaths;
+	}
+
+	private async updateHashes(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectData: IProjectData, liveSyncDeviceInfo: ILiveSyncDeviceInfo): Promise<void> {
+		const hashes = await this.updateHashesOnDevice(deviceAppData, localToDevicePaths, projectData, liveSyncDeviceInfo);
+		this.updateLocalHashes(hashes, deviceAppData, projectData, liveSyncDeviceInfo);
+	}
+
+	private async updateHashesOnDevice(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectData: IProjectData, liveSyncDeviceInfo: ILiveSyncDeviceInfo): Promise<IStringDictionary> {
+		const deviceHashService = this.getDeviceHashService(deviceAppData.appIdentifier);
+		const currentHashes = await deviceHashService.generateHashesFromLocalToDevicePaths(localToDevicePaths);
+		await deviceHashService.uploadHashFileToDevice(currentHashes);
+		return currentHashes;
+	}
+
+	private updateLocalHashes(hashes: IStringDictionary, deviceAppData: Mobile.IDeviceAppData, projectData: IProjectData, liveSyncDeviceInfo: ILiveSyncDeviceInfo): void {
+		const hashFilePath = liveSyncDeviceInfo.outputPath || this.$platformsData.getPlatformData(deviceAppData.platform, projectData).deviceBuildOutputPath;
+		this.$filesHashService.saveHashes(hashes, hashFilePath);
+	}
+}

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

@@ -1,23 +1,29 @@
-import { DeviceAndroidDebugBridge } from "../../common/mobile/android/device-android-debug-bridge";
-import { AndroidDeviceHashService } from "../../common/mobile/android/android-device-hash-service";
-import { DeviceLiveSyncServiceBase } from "./device-livesync-service-base";
+import { AndroidDeviceLiveSyncServiceBase } from "./android-device-livesync-service-base";
 import * as helpers from "../../common/helpers";
 import { LiveSyncPaths } from "../../common/constants";
-import { cache } from "../../common/decorators";
 import * as path from "path";
 import * as net from "net";
 
-export class AndroidDeviceLiveSyncService extends DeviceLiveSyncServiceBase implements IAndroidNativeScriptDeviceLiveSyncService, INativeScriptDeviceLiveSyncService {
+export class AndroidDeviceLiveSyncService extends AndroidDeviceLiveSyncServiceBase implements IAndroidNativeScriptDeviceLiveSyncService, INativeScriptDeviceLiveSyncService {
 	private port: number;
 
-	constructor(
-		private $mobileHelper: Mobile.IMobileHelper,
+	constructor(private $mobileHelper: Mobile.IMobileHelper,
 		private $devicePathProvider: IDevicePathProvider,
-		private $injector: IInjector,
+		$injector: IInjector,
 		private $androidProcessService: Mobile.IAndroidProcessService,
 		protected $platformsData: IPlatformsData,
-		protected device: Mobile.IAndroidDevice) {
-		super($platformsData, device);
+		protected device: Mobile.IAndroidDevice,
+		$filesHashService: IFilesHashService,
+		$logger: ILogger) {
+			super($injector, $platformsData, $filesHashService, $logger, device);
+	}
+
+	public async transferFilesOnDevice(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<void> {
+		await this.device.fileSystem.transferFiles(deviceAppData, localToDevicePaths);
+	}
+
+	public async transferDirectoryOnDevice(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<void> {
+		await this.device.fileSystem.transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath);
 	}
 
 	public async refreshApplication(projectData: IProjectData, liveSyncInfo: ILiveSyncResultInfo): Promise<void> {
@@ -116,12 +122,6 @@ export class AndroidDeviceLiveSyncService extends DeviceLiveSyncServiceBase impl
 		await this.getDeviceHashService(deviceAppData.appIdentifier).removeHashes(localToDevicePaths);
 	}
 
-	@cache()
-	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 awaitRuntimeReloadSuccessMessage(): Promise<boolean> {
 		return new Promise<boolean>((resolve, reject) => {
 			let isResolved = false;