Move https://github.com/NativeScript/nativescript-android-livesync-lib to {N} CLI and fix lint errors

Author: Fatme

lib/definitions/livesync-global.d.ts

@@ -0,0 +1,8 @@
+import * as stream from "stream";
+
+declare global {
+	interface IDuplexSocket extends stream.Duplex {
+		uid?: string;
+	}
+}
+

lib/definitions/livesync.d.ts

@@ -377,6 +377,70 @@ interface IAndroidNativeScriptDeviceLiveSyncService {
 	getDeviceHashService(appIdentifier: string): Mobile.IAndroidDeviceHashService;
 }
 
+interface ILivesyncTool {
+	/**
+	 * Creates new socket connection.
+	 * @param configuration - The configuration to the socket connection.
+	 * @returns {Promise<void>}
+	 */
+	connect(configuration: ILivesyncToolConfiguration): Promise<void>;
+	/**
+	 * Sends a file through the socket.
+	 * @param filePath - The full path to the file.
+	 * @returns {Promise<void>}
+	 */
+	sendFile(filePath: string): Promise<void>;
+	/**
+	 * Sends files through the socket.
+	 * @param filePaths - Array of files that will be send by the socket.
+	 * @returns {Promise<void>}
+	 */
+	sendFiles(filePaths: string[]): Promise<void>;
+	/**
+	 * Sends all files from directory by the socket.
+	 * @param directoryPath - The path to the directory which files will be send by the socket.
+	 * @returns {Promise<void>}
+	 */
+	sendDirectory(directoryPath: string): Promise<void>;
+	/**
+	 * Removes file
+	 * @param filePath - The full path to the file.
+	 * @returns {Promise<boolean>}
+	 */
+	removeFile(filePath: string): Promise<boolean>;
+	/**
+	 * Removes files 
+	 * @param filePaths - Array of files that will be removed.
+	 * @returns {Promise<boolean[]>}
+	 */
+	removeFiles(filePaths: string[]): Promise<boolean[]>;
+	/**
+	 * Sends doSyncOperation that will be handeled by the runtime.
+	 * @param operationId - The identifier of the operation
+	 * @param timeout - The timeout in miliseconds
+	 * @returns {Promise<void>}
+	 */
+	sendDoSyncOperation(operationId: string, timeout?: number): Promise<void>;
+	/**
+	 * Generates new operation identifier.
+	 */
+	generateOperationIdentifier(): string;
+	/**
+	 * Checks if the current operation is in progress.
+	 * @param operationId - The identifier of the operation.
+	 */
+	isOperationInProgress(operationId: string): boolean;
+	end(): void;
+}
+
+interface ILivesyncToolConfiguration {
+	appIdentifier: string;
+	deviceIdentifier: string;
+	appPlatformsPath: string; // path to platforms/android/app/src/main/assets/app/
+	localHostAddress?: string;
+	errorHandler?: any;
+}
+
 interface IDeviceProjectRootOptions {
 	appIdentifier: string;
 	getDirname?: boolean;

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

@@ -2,13 +2,11 @@ import { DeviceAndroidDebugBridge } from "../../common/mobile/android/device-and
 import { AndroidDeviceHashService } from "../../common/mobile/android/android-device-hash-service";
 import { DeviceLiveSyncServiceBase } from "./device-livesync-service-base";
 import { APP_FOLDER_NAME } from "../../constants";
+import { LivesyncTool } from "./livesync-library";
 import * as path from "path";
 
-const LivesyncTool = require("nativescript-android-livesync-lib");
-
 export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBase implements IAndroidNativeScriptDeviceLiveSyncService, INativeScriptDeviceLiveSyncService {
-	private port: number;
-	private livesyncTool: any;
+	private livesyncTool: ILivesyncTool;
 
 	constructor(
 		private data: IProjectData,
@@ -19,7 +17,7 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 		protected device: Mobile.IAndroidDevice,
 		private $options: ICommonOptions) {
 		super($platformsData, device);
-		this.livesyncTool = new LivesyncTool();
+		this.livesyncTool = this.$injector.resolve(LivesyncTool);
 	}
 
 	public async beforeLiveSyncAction(deviceAppData: Mobile.IDeviceAppData): Promise<void> {
@@ -33,24 +31,24 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 		const canExecuteFastSync = !liveSyncInfo.isFullSync && !_.some(liveSyncInfo.modifiedFilesData,
 			(localToDevicePath: Mobile.ILocalToDevicePathData) => !this.canExecuteFastSync(localToDevicePath.getLocalPath(), projectData, this.device.deviceInfo.platform));
 
-		if(liveSyncInfo.modifiedFilesData.length) {
-			const operationUid = this.livesyncTool.generateOperationUid();
-			const doSyncPromise = this.livesyncTool.sendDoSyncOperation(operationUid);
+		if (liveSyncInfo.modifiedFilesData.length) {
+			const operationIdentifier = this.livesyncTool.generateOperationIdentifier();
+			const doSyncPromise = this.livesyncTool.sendDoSyncOperation(operationIdentifier);
 
 			//TODO clear interval on exit sygnals/stopLivesync
 			const syncInterval : NodeJS.Timer = setInterval(() => {
-				if(this.livesyncTool.isOperationInProgress(operationUid)){
+				if (this.livesyncTool.isOperationInProgress(operationIdentifier)) {
 					this.$logger.info("Sync operation in progress...");
 				}
 			}, 10000);
 
 			const clearSyncInterval = () => {
 				clearInterval(syncInterval);
-			}
+			};
 			doSyncPromise.then(clearSyncInterval, clearSyncInterval);
 			await doSyncPromise;
 
-			if(!canExecuteFastSync){
+			if (!canExecuteFastSync) {
 				await this.device.applicationManager.restartApplication({ appId: liveSyncInfo.deviceAppData.appIdentifier, projectName: projectData.projectName });
 			}
 		}
@@ -59,7 +57,7 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 	}
 
 	public async removeFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<void> {
-		await this.livesyncTool.removeFilesArray(_.map(localToDevicePaths, (element: any) => { return element.filePath }));
+		await this.livesyncTool.removeFiles(_.map(localToDevicePaths, (element: any) => { return element.filePath; }));
 	}
 
 	public async transferFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string, isFullSync: boolean): Promise<Mobile.ILocalToDevicePathData[]> {
@@ -75,7 +73,7 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 	}
 
 	private async _transferFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<Mobile.ILocalToDevicePathData[]> {
-		await this.livesyncTool.sendFilesArray(localToDevicePaths.map(localToDevicePathData => localToDevicePathData.getLocalPath()));
+		await this.livesyncTool.sendFiles(localToDevicePaths.map(localToDevicePathData => localToDevicePathData.getLocalPath()));
 
 		return localToDevicePaths;
 	}
@@ -86,18 +84,18 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 		const currentShasums: IStringDictionary = await deviceHashService.generateHashesFromLocalToDevicePaths(localToDevicePaths);
 		const oldShasums = await deviceHashService.getShasumsFromDevice();
 
-		if(this.$options.force || !oldShasums) {
+		if (this.$options.force || !oldShasums) {
 			await this.livesyncTool.sendDirectory(projectFilesPath);
 			await deviceHashService.uploadHashFileToDevice(currentShasums);
 			transferedFiles = localToDevicePaths;
 		} else {
 			const changedShasums = deviceHashService.getChnagedShasums(oldShasums, currentShasums);
 			const changedFiles = _.map(changedShasums, (hash: string, pathToFile: string) => pathToFile);
-			if(changedFiles.length){
-				await this.livesyncTool.sendFilesArray(changedFiles);
+			if (changedFiles.length) {
+				await this.livesyncTool.sendFiles(changedFiles);
 				await deviceHashService.uploadHashFileToDevice(currentShasums);
 				transferedFiles = localToDevicePaths.filter(localToDevicePathData => {
-					if(changedFiles.indexOf(localToDevicePathData.getLocalPath()) >= 0){
+					if (changedFiles.indexOf(localToDevicePathData.getLocalPath()) >= 0) {
 						return true;
 					}
 				});
@@ -110,13 +108,10 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 	}
 
 	private async connectLivesyncTool(projectFilesPath: string, appIdentifier: string) {
-		const adbPath = await this.$staticConfig.getAdbFilePath();
 		await this.livesyncTool.connect({
-			fullApplicationName: appIdentifier,
-			port: this.port,
+			appIdentifier,
 			deviceIdentifier: this.device.deviceInfo.identifier,
-			baseDir: projectFilesPath,
-			adbPath: adbPath
+			appPlatformsPath: projectFilesPath
 		});
 	}
 

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

@@ -15,10 +15,10 @@ export class AndroidLiveSyncService extends PlatformLiveSyncServiceBase implemen
 	}
 
 	protected _getDeviceLiveSyncService(device: Mobile.IDevice, data: IProjectDir, frameworkVersion: string): INativeScriptDeviceLiveSyncService {
-		if(semver.gte(frameworkVersion, "4.2.0")){
+		if (semver.gte(frameworkVersion, "4.2.0")) {
 			return this.$injector.resolve<INativeScriptDeviceLiveSyncService>(AndroidDeviceSocketsLiveSyncService, { device, data });
 		}
-		
+
 		return this.$injector.resolve<INativeScriptDeviceLiveSyncService>(AndroidDeviceLiveSyncService, { device, data });
 	}