NativeScript · rosen-vladimirov · Aug 3, 2018 · Jul 25, 2018 · Jul 25, 2018 · Jul 25, 2018
diff --git a/.travis.yml b/.travis.yml
@@ -1,6 +1,7 @@
 branches:
   only:
     - master
+    - release
 env:
   global:
   - DATE=$(date +%Y-%m-%d)

diff --git a/PublicAPI.md b/PublicAPI.md
@@ -53,9 +53,11 @@ const tns = require("nativescript");
 * [sysInfo](#sysinfo)
 	* [getSupportedNodeVersionRange](#getsupportednodeversionrange)
 	* [getSystemWarnings](#getsystemwarnings)
-* [devicesService](#devicesService)
-	* [getAvailableEmulators](#getAvailableEmulators)
-	* [startEmulator](#startEmulator)
+* [devicesService](#devicesservice)
+	* [getEmulatorImages](#getemulatorimages)
+	* [startEmulator](#startemulator)
+* [deviceEmitter](#deviceemitter)
+	* [events](#deviceemitterevents)
 
 ## Module projectService
 
@@ -1204,8 +1206,8 @@ tns.sysInfo.getSystemWarnings()
 ## devicesService
 The `devicesService` module allows interaction with devices and emulators. You can get a list of the available emulators or start a specific emulator.
 
-### getAvailableEmulators
-The `getAvailableEmulators` method returns object of all running and available emulators. The result is in the following format: 
+### getEmulators
+The `getEmulators` method returns object of all running and available emulators. The result is in the following format:
 ```JavaScript
 	{
 		android: {
@@ -1223,7 +1225,7 @@ This method accepts platform parameter. If provided only devices by specified pl
 
 * Usage
 ```TypeScript
-tns.devicesService.getAvailableEmulators()
+tns.devicesService.getEmulators()
 	.then(availableEmulatorsOutput => {
 		Object.keys(availableEmulatorsOutput)
 			.forEach(platform => {
@@ -1240,6 +1242,105 @@ tns.devicesService.startEmulator({imageIdentifier: "my emulator imageIdentifier"
 	.then(errors => { });
 ```
 
+## deviceEmitter
+This module is used to emit information for devices, applications on them, etc.
+
+### deviceEmitterEvents
+`deviceEmitter` emits the following events:
+`deviceEmitter` module is used to emit different events related to devices attached to the system.
+You can use `deviceEmitter` to add handles for the following events:
+
+* `deviceFound` - Raised when a new device is attached to the system. The callback function will receive one argument - `deviceInfoData`.
+Sample usage:
+```JavaScript
+tns.deviceEmitter.on("deviceFound", (deviceInfoData) => {
+	console.log("Found device with identifier: " + deviceInfoData.identifier);
+});
+```
+
+* `deviceLost` - Raised when a device is detached from the system. The callback function will receive one argument - `deviceInfoData`.
+Sample usage:
+```JavaScript
+tns.deviceEmitter.on("deviceLost", (deviceInfoData) => {
+	console.log("Detached device with identifier: " + deviceInfoData.identifier);
+});
+```
+
+* `deviceLogData` - Raised when attached device reports any information. This is the output of `adb logcat` for Android devices. For iOS this is the `iOS SysLog`.
+The event is raised for any device that reports data. The callback function has two arguments - `deviceIdentifier` and `reportedData`. <br/><br/>
+Sample usage:
+```JavaScript
+tns.deviceEmitter.on("deviceLogData", (identifier, reportedData) => {
+	console.log("Device " + identifier + " reports: " + reportedData);
+});
+```
+
+* `applicationInstalled` - Raised when application is installed on a device. The callback has two arguments - `deviceIdentifier` and `applicationIdentifier`. <br/><br/>
+Sample usage:
+```JavaScript
+tns.deviceEmitter.on("applicationInstalled", (identifier, applicationIdentifier) => {
+	console.log("Application " + applicationIdentifier  + " has been installed on device with id: " + identifier);
+});
+```
+
+* `applicationUninstalled` - Raised when application is removed from device. The callback has two arguments - `deviceIdentifier` and `applicationIdentifier`. <br/><br/>
+Sample usage:
+```JavaScript
+tns.deviceEmitter.on("applicationUninstalled", (identifier, applicationIdentifier) => {
+	console.log("Application " + applicationIdentifier  + " has been uninstalled from device with id: " + identifier);
+});
+```
+
+* `debuggableAppFound` - Raised when application on a device becomes available for debugging. The callback has one argument - `applicationInfo`. <br/><br/>
+Sample usage:
+```JavaScript
+tns.deviceEmitter.on("debuggableAppFound", (applicationInfo) => {
+	console.log("Application " + applicationInfo.appIdentifier  + " is available for debugging on device with id: " + applicationInfo.deviceIdentifier);
+});
+```
+Sample result for `applicationInfo` will be:
+```JSON
+{
+	"deviceIdentifier": "4df18f307d8a8f1b",
+	"appIdentifier": "com.telerik.Fitness",
+	"framework": "NativeScript",
+	"title": "NativeScript Application"
+}
+```
+
+* `debuggableAppLost` - Raised when application on a device is not available for debugging anymore. The callback has one argument - `applicationInfo`. <br/><br/>
+Sample usage:
+```JavaScript
+tns.deviceEmitter.on("debuggableAppLost", (applicationInfo) => {
+	console.log("Application " + applicationInfo.appIdentifier  + " is not available for debugging anymore on device with id: " + applicationInfo.deviceIdentifier);
+});
+```
+Sample result for `applicationInfo` will be:
+```JSON
+{
+	"deviceIdentifier": "4df18f307d8a8f1b",
+	"appIdentifier": "com.telerik.Fitness",
+	"framework": "NativeScript",
+	"title": "NativeScript Application"
+}
+```
+
+* `emulatorImageFound` - Raised when a new Android Emulator Image or iOS Simulator is created/installed on the system. The callback has a single argument that describes the new image:
+```JavaScript
+tns.deviceEmitter.on("emulatorImageFound", (emulatorImageInfo) => {
+	console.log("Added new emulator image", emulatorImageInfo);
+});
+```
+`emulatorImageInfo` is of type [Moble.IDeviceInfo](https://github.com/telerik/mobile-cli-lib/blob/61cdaaaf7533394afbbe84dd4eee355072ade2de/definitions/mobile.d.ts#L9-L86).
+
+* `emulatorImageLost` - Raised when an Android Emulator Image or iOS Simulator is removed from the system. The callback has a single argument that describes the removed image:
+```JavaScript
+tns.deviceEmitter.on("emulatorImageLost", (emulatorImageInfo) => {
+	console.log("Removed emulator image", emulatorImageInfo);
+});
+```
+`emulatorImageInfo` is of type [Moble.IDeviceInfo](https://github.com/telerik/mobile-cli-lib/blob/61cdaaaf7533394afbbe84dd4eee355072ade2de/definitions/mobile.d.ts#L9-L86).
+
 ## How to add a new method to Public API
 CLI is designed as command line tool and when it is used as a library, it does not give you access to all of the methods. This is mainly implementation detail. Most of the CLI's code is created to work in command line, not as a library, so before adding method to public API, most probably it will require some modification.
 For example the `$options` injected module contains information about all `--` options passed on the terminal. When the CLI is used as a library, the options are not populated. Before adding method to public API, make sure its implementation does not rely on `$options`.

diff --git a/lib/common b/lib/common
diff --git a/lib/constants.ts b/lib/constants.ts
@@ -98,13 +98,6 @@ class ItunesConnectApplicationTypesClass implements IiTunesConnectApplicationTyp
 }
 
 export const ItunesConnectApplicationTypes = new ItunesConnectApplicationTypesClass();
-export class LiveSyncPaths {
-	static SYNC_DIR_NAME = "sync";
-	static REMOVEDSYNC_DIR_NAME = "removedsync";
-	static FULLSYNC_DIR_NAME = "fullsync";
-	static IOS_DEVICE_PROJECT_ROOT_PATH = "Library/Application Support/LiveSync";
-	static IOS_DEVICE_SYNC_ZIP_PATH = "Library/Application Support/LiveSync/sync.zip";
-}
 export const ANGULAR_NAME = "angular";
 export const TYPESCRIPT_NAME = "typescript";
 export const BUILD_OUTPUT_EVENT_NAME = "buildOutput";

diff --git a/lib/definitions/livesync.d.ts b/lib/definitions/livesync.d.ts
@@ -452,8 +452,9 @@ interface IAndroidLivesyncTool {
 
 	/**
 	 * Closes the current socket connection.
+	 * @param error - Optional error for rejecting pending sync operations
 	 */
-	end(): void;
+	end(error?: Error): void;
 }
 
 interface IAndroidLivesyncToolConfiguration {

diff --git a/lib/device-path-provider.ts b/lib/device-path-provider.ts
@@ -1,5 +1,6 @@
 import { fromWindowsRelativePathToUnix } from "./common/helpers";
-import { APP_FOLDER_NAME, LiveSyncPaths } from "./constants";
+import { APP_FOLDER_NAME } from "./constants";
+import { LiveSyncPaths } from "./common/constants";
 import { AndroidDeviceLiveSyncService } from "./services/livesync/android-device-livesync-service";
 import * as path from "path";
 
@@ -23,7 +24,7 @@ export class DevicePathProvider implements IDevicePathProvider {
 				projectRoot = path.join(projectRoot, APP_FOLDER_NAME);
 			}
 		} else if (this.$mobileHelper.isAndroidPlatform(device.deviceInfo.platform)) {
-			projectRoot = `/data/local/tmp/${options.appIdentifier}`;
+			projectRoot = `${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${options.appIdentifier}`;
 			if (!options.getDirname) {
 				const deviceLiveSyncService = this.$injector.resolve<AndroidDeviceLiveSyncService>(AndroidDeviceLiveSyncService, { device });
 				const hashService = deviceLiveSyncService.getDeviceHashService(options.appIdentifier);

diff --git a/lib/services/android-debug-service.ts b/lib/services/android-debug-service.ts
@@ -1,5 +1,6 @@
 import { sleep } from "../common/helpers";
 import { DebugServiceBase } from "./debug-service-base";
+import { LiveSyncPaths } from "../common/constants";
 
 export class AndroidDebugService extends DebugServiceBase implements IPlatformDebugService {
 	private _packageName: string;
@@ -158,22 +159,23 @@ export class AndroidDebugService extends DebugServiceBase implements IPlatformDe
 		await this.device.applicationManager.stopApplication(appData);
 
 		if (debugOptions.debugBrk) {
-			await this.device.adb.executeShellCommand([`cat /dev/null > /data/local/tmp/${appData.appId}-debugbreak`]);
+			await this.device.adb.executeShellCommand([`cat /dev/null > ${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appData.appId}-debugbreak`]);
 		}
 
-		await this.device.adb.executeShellCommand([`cat /dev/null > /data/local/tmp/${appData.appId}-debugger-started`]);
+		await this.device.adb.executeShellCommand([`cat /dev/null > ${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appData.appId}-debugger-started`]);
 
 		await this.device.applicationManager.startApplication(appData);
 
 		await this.waitForDebugger(appData.appId);
 	}
 
 	private async waitForDebugger(packageName: String): Promise<void> {
-		const waitText: string = `0 /data/local/tmp/${packageName}-debugger-started`;
+		const debuggerStartedFilePath = `${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${packageName}-debugger-started`;
+		const waitText: string = `0 ${debuggerStartedFilePath}`;
 		let maxWait = 12;
 		let debuggerStarted: boolean = false;
 		while (maxWait > 0 && !debuggerStarted) {
-			const forwardsResult = await this.device.adb.executeShellCommand(["ls", "-s", `/data/local/tmp/${packageName}-debugger-started`]);
+			const forwardsResult = await this.device.adb.executeShellCommand(["ls", "-s", debuggerStartedFilePath]);
 
 			maxWait--;
 

diff --git a/lib/services/android-project-service.ts b/lib/services/android-project-service.ts
@@ -5,7 +5,7 @@ import * as semver from "semver";
 import * as projectServiceBaseLib from "./platform-project-service-base";
 import { DeviceAndroidDebugBridge } from "../common/mobile/android/device-android-debug-bridge";
 import { attachAwaitDetach, isRecommendedAarFile } from "../common/helpers";
-import { Configurations } from "../common/constants";
+import { Configurations, LiveSyncPaths } from "../common/constants";
 import { SpawnOptions } from "child_process";
 
 export class AndroidProjectService extends projectServiceBaseLib.PlatformProjectServiceBase implements IPlatformProjectService {
@@ -631,7 +631,7 @@ export class AndroidProjectService extends projectServiceBaseLib.PlatformProject
 
 	public async cleanDeviceTempFolder(deviceIdentifier: string, projectData: IProjectData): Promise<void> {
 		const adb = this.$injector.resolve(DeviceAndroidDebugBridge, { identifier: deviceIdentifier });
-		const deviceRootPath = `/data/local/tmp/${projectData.projectId}`;
+		const deviceRootPath = `${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${projectData.projectId}`;
 		await adb.executeShellCommand(["rm", "-rf", deviceRootPath]);
 	}
 

diff --git a/lib/services/livesync/android-device-livesync-service.ts b/lib/services/livesync/android-device-livesync-service.ts
@@ -2,7 +2,7 @@ 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 * as helpers from "../../common/helpers";
-import { LiveSyncPaths } from "../../constants";
+import { LiveSyncPaths } from "../../common/constants";
 import { cache } from "../../common/decorators";
 import * as path from "path";
 import * as net from "net";

diff --git a/lib/services/livesync/android-device-livesync-sockets-service.ts b/lib/services/livesync/android-device-livesync-sockets-service.ts
@@ -2,8 +2,10 @@ 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 { LiveSyncPaths } from "../../common/constants";
 import { AndroidLivesyncTool } from "./android-livesync-tool";
 import * as path from "path";
+import * as temp from "temp";
 
 export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBase implements IAndroidNativeScriptDeviceLiveSyncService, INativeScriptDeviceLiveSyncService {
 	private livesyncTool: IAndroidLivesyncTool;
@@ -17,54 +19,65 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 		private $logger: ILogger,
 		protected device: Mobile.IAndroidDevice,
 		private $options: ICommonOptions,
-		private $processService: IProcessService) {
+		private $processService: IProcessService,
+		private $fs: IFileSystem) {
 		super($platformsData, device);
 		this.livesyncTool = this.$injector.resolve(AndroidLivesyncTool);
 	}
 
 	public async beforeLiveSyncAction(deviceAppData: Mobile.IDeviceAppData): Promise<void> {
 		const platformData = this.$platformsData.getPlatformData(deviceAppData.platform, this.data);
 		const projectFilesPath = path.join(platformData.appDestinationDirectoryPath, APP_FOLDER_NAME);
+		const pathToLiveSyncFile = temp.path({ prefix: "livesync" });
+		this.$fs.writeFile(pathToLiveSyncFile, "");
+		await this.device.fileSystem.putFile(pathToLiveSyncFile, this.getPathToLiveSyncFileOnDevice(deviceAppData.appIdentifier), deviceAppData.appIdentifier);
 		await this.device.applicationManager.startApplication({ appId: deviceAppData.appIdentifier, projectName: this.data.projectName });
 		await this.connectLivesyncTool(projectFilesPath, this.data.projectId);
 	}
 
+	private getPathToLiveSyncFileOnDevice(appIdentifier: string): string {
+		return `${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appIdentifier}-livesync-in-progress`;
+	}
+
 	public async finalizeSync(liveSyncInfo: ILiveSyncResultInfo) {
 		await this.doSync(liveSyncInfo);
 	}
 
-	private async doSync(liveSyncInfo: ILiveSyncResultInfo, {doRefresh = false}: {doRefresh?: boolean} = {}): Promise<IAndroidLivesyncSyncOperationResult> {
+	private async doSync(liveSyncInfo: ILiveSyncResultInfo, { doRefresh = false }: { doRefresh?: boolean } = {}): Promise<IAndroidLivesyncSyncOperationResult> {
 		const operationId = this.livesyncTool.generateOperationIdentifier();
 
-		let result = {operationId, didRefresh: true };
+		let result = { operationId, didRefresh: true };
 
 		if (liveSyncInfo.modifiedFilesData.length) {
 
 			const doSyncPromise = this.livesyncTool.sendDoSyncOperation(doRefresh, null, operationId);
 
-			const syncInterval : NodeJS.Timer = setInterval(() => {
+			const syncInterval: NodeJS.Timer = setInterval(() => {
 				if (this.livesyncTool.isOperationInProgress(operationId)) {
 					this.$logger.info("Sync operation in progress...");
 				}
 			}, AndroidDeviceSocketsLiveSyncService.STATUS_UPDATE_INTERVAL);
 
-			const clearSyncInterval = () => {
+			const actionOnEnd = async () => {
 				clearInterval(syncInterval);
+				await this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(liveSyncInfo.deviceAppData.appIdentifier), liveSyncInfo.deviceAppData.appIdentifier);
 			};
 
-			this.$processService.attachToProcessExitSignals(this, clearSyncInterval);
-			doSyncPromise.then(clearSyncInterval, clearSyncInterval);
+			this.$processService.attachToProcessExitSignals(this, actionOnEnd);
+			doSyncPromise.then(actionOnEnd, actionOnEnd);
 
 			result = await doSyncPromise;
 		}
 
+		await this.device.fileSystem.deleteFile(this.getPathToLiveSyncFileOnDevice(liveSyncInfo.deviceAppData.appIdentifier), liveSyncInfo.deviceAppData.appIdentifier);
+
 		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, {doRefresh: canExecuteFastSync});
+		const syncOperationResult = await this.doSync(liveSyncInfo, { doRefresh: canExecuteFastSync });
 
 		this.livesyncTool.end();
 
@@ -96,28 +109,28 @@ export class AndroidDeviceSocketsLiveSyncService extends DeviceLiveSyncServiceBa
 	}
 
 	private async _transferDirectory(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[], projectFilesPath: string): Promise<Mobile.ILocalToDevicePathData[]> {
-		let transferredLocalToDevicePaths : Mobile.ILocalToDevicePathData[];
+		let transferredLocalToDevicePaths: Mobile.ILocalToDevicePathData[];
 		const deviceHashService = this.getDeviceHashService(deviceAppData.appIdentifier);
 		const currentShasums: IStringDictionary = await deviceHashService.generateHashesFromLocalToDevicePaths(localToDevicePaths);
 		const oldShasums = await deviceHashService.getShasumsFromDevice();
 
 		if (this.$options.force || !oldShasums) {
 			await this.livesyncTool.sendDirectory(projectFilesPath);
 			await deviceHashService.uploadHashFileToDevice(currentShasums);
-			transferredLocalToDevicePaths  = localToDevicePaths;
+			transferredLocalToDevicePaths = localToDevicePaths;
 		} else {
 			const changedShasums = deviceHashService.getChangedShasums(oldShasums, currentShasums);
 			const changedFiles = _.keys(changedShasums);
 			if (changedFiles.length) {
 				await this.livesyncTool.sendFiles(changedFiles);
 				await deviceHashService.uploadHashFileToDevice(currentShasums);
-				transferredLocalToDevicePaths  = localToDevicePaths.filter(localToDevicePathData => changedFiles.indexOf(localToDevicePathData.getLocalPath()) >= 0);
+				transferredLocalToDevicePaths = localToDevicePaths.filter(localToDevicePathData => changedFiles.indexOf(localToDevicePathData.getLocalPath()) >= 0);
 			} else {
-				transferredLocalToDevicePaths  = [];
+				transferredLocalToDevicePaths = [];
 			}
 		}
 
-		return transferredLocalToDevicePaths ;
+		return transferredLocalToDevicePaths;
 	}
 
 	private async connectLivesyncTool(projectFilesPath: string, appIdentifier: string) {

diff --git a/lib/services/livesync/android-livesync-tool.md b/lib/services/livesync/android-livesync-tool.md
@@ -177,8 +177,9 @@ End will close the current liveSync socket. Any sync operations that are still i
 ```TypeScript
 /**
  * Closes the current socket connection.
+ * @param error - Optional error for rejecting pending sync operations
  */
-end(): void;
+end(error? Error): void;
 ```
 
 * Example:
+1 −0		.travis.yml
+4 −4		appbuilder/device-emitter.ts
+1 −1		commands/device/list-devices.ts
+12 −3		constants.ts
+16 −16		definitions/mobile.d.ts
+2 −2		mobile/android/android-application-manager.ts
+45 −25		mobile/android/android-device-file-system.ts
+2 −3		mobile/android/android-device-hash-service.ts
+5 −5		mobile/android/android-emulator-services.ts
+42 −8		mobile/android/android-virtual-device-service.ts
+4 −4		mobile/android/genymotion/genymotion-service.ts
+2 −2		mobile/emulator-helper.ts
+1 −1		mobile/ios/simulator/ios-emulator-services.ts
+9 −5		mobile/mobile-core/android-emulator-discovery.ts
+8 −8		mobile/mobile-core/devices-service.ts
+14 −6		mobile/mobile-core/ios-simulator-discovery.ts
+1 −1		mobile/wp8/wp8-emulator-services.ts
+2 −2		package.json
+163 −129		test/unit-tests/mobile/android-device-file-system.ts
+20 −20		test/unit-tests/mobile/android-emulator-service.ts
+10 −10		test/unit-tests/mobile/android-virtual-device-service.ts
+5 −5		test/unit-tests/mobile/genymotion/genymotion-service.ts
+2 −1		test/unit-tests/mobile/project-files-manager.ts