Fix debugStop

Author: Dimitar Kerezov

PublicAPI.md

@@ -552,6 +552,8 @@ After calling the method once, you can add new devices to the same LiveSync oper
 
 > NOTE: In case a consecutive call to `liveSync` method requires change in the pattern for watching files (i.e. `liveSyncData.syncAllFiles` option has changed), current watch operation will be stopped and a new one will be started.
 
+> NOTE: In case `debugggingEnabled` is set to `true` in a deviceDescriptor, debugging will initially be enabled for that device and a debugger will be attached after a successful livesync operation.
+
 * Definition
 ```TypeScript
 /**
@@ -623,6 +625,92 @@ tns.liveSyncService.stopLiveSync(projectDir, deviceIdentifiers)
 	});
 ```
 
+### enableDebugging
+Enables debugging during a LiveSync operation. This method will try to attach a debugger to the application. Note that `userInteractionNeeded` event may be raised. Additional details about the arguments can be seen [here](https://github.com/NativeScript/nativescript-cli/blob/master/lib/definitions/livesync.d.ts).
+
+* Definition
+```TypeScript
+/**
+* Enables debugging for the specified devices
+* @param {IEnableDebuggingDeviceOptions[]} deviceOpts Settings used for enabling debugging for each device.
+* @param {IDebuggingAdditionalOptions} enableDebuggingOptions Settings used for enabling debugging.
+* @returns {Promise<void>[]} Array of promises for each device.
+*/
+enableDebugging(deviceOpts: IEnableDebuggingDeviceOptions[], enableDebuggingOptions: IDebuggingAdditionalOptions): Promise<void>[];
+```
+
+* Usage
+```JavaScript
+const projectDir = "/tmp/myProject";
+const liveSyncData = { projectDir };
+const devices = [androidDeviceDescriptor, iOSDeviceDescriptor];
+tns.liveSyncService.liveSync(devices, liveSyncData)
+	.then(() => {
+		console.log("LiveSync operation started.");
+		devices.forEach(device => {
+			tns.liveSyncService.enableDebugging([{
+				deviceIdentifier: device.identifier
+			}], { projectDir });
+		});
+	});
+```
+
+### attachDebugger
+Attaches a debugger to the specified device. Additional details about the argument can be seen [here](https://github.com/NativeScript/nativescript-cli/blob/master/lib/definitions/livesync.d.ts).
+
+* Definition
+```TypeScript
+/**
+* Attaches a debugger to the specified device.
+* @param {IAttachDebuggerOptions} settings Settings used for controling the attaching process.
+* @returns {Promise<void>}
+*/
+attachDebugger(settings: IAttachDebuggerOptions): Promise<void>;
+```
+
+* Usage
+```JavaScript
+tns.liveSyncService.on("userInteractionNeeded", data => {
+	console.log("Please restart the app manually");
+	return tns.liveSyncService.attachDebugger(data);
+});
+```
+
+### disableDebugging
+Disables debugging during a LiveSync operation. This method will try to detach a debugger from the application. Additional details about the arguments can be seen [here](https://github.com/NativeScript/nativescript-cli/blob/master/lib/definitions/livesync.d.ts).
+
+* Definition
+```TypeScript
+/**
+* Disables debugging for the specified devices
+* @param {IDisableDebuggingDeviceOptions[]} deviceOptions Settings used for disabling debugging for each device.
+* @param {IDebuggingAdditionalOptions} debuggingAdditionalOptions Settings used for disabling debugging.
+* @returns {Promise<void>[]} Array of promises for each device.
+*/
+disableDebugging(deviceOptions: IDisableDebuggingDeviceOptions[], debuggingAdditionalOptions: IDebuggingAdditionalOptions): Promise<void>[];
+```
+
+* Usage
+```JavaScript
+const projectDir = "/tmp/myProject";
+const liveSyncData = { projectDir };
+const devices = [androidDeviceDescriptor, iOSDeviceDescriptor];
+tns.liveSyncService.liveSync(devices, liveSyncData)
+	.then(() => {
+		console.log("LiveSync operation started.");
+		devices.forEach(device => {
+			tns.liveSyncService.enableDebugging([{
+				deviceIdentifier: device.identifier
+			}], { projectDir });
+			setTimeout(() => {
+				tns.liveSyncService.disableDebugging([{
+								deviceIdentifier: device.identifier
+							}], { projectDir });
+			}, 1000 * 30);
+		});
+	});
+```
+
 ### Events
 `liveSyncService` raises several events in order to provide information for current state of the operation.
 * liveSyncStarted - raised whenever CLI starts a LiveSync operation for specific device. When `liveSync` method is called, the initial LiveSync operation will emit `liveSyncStarted` for each specified device. After that the event will be emitted only in case when liveSync method is called again with different device instances. The event is raised with the following data:
@@ -718,6 +806,16 @@ tns.liveSyncService.on("notify", data => {
 });
 ```
 
+* userInteractionNeeded - raised whenever CLI needs to restart an application but cannot so the user has to restart it manually. The event is raised with an object, which can later be passed to `attachDebugger` method of `liveSyncService`:
+
+Example:
+```JavaScript
+tns.liveSyncService.on("userInteractionNeeded", data => {
+	console.log("Please restart the app manually");
+	return tns.liveSyncService.attachDebugger(data);
+});
+```
+
 ## 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`.

lib/commands/debug.ts

@@ -6,8 +6,8 @@ import { DebugCommandErrors } from "../constants";
 export class DebugPlatformCommand implements ICommand {
 	public allowedParameters: ICommandParameter[] = [];
 
-	constructor(private debugService: IPlatformDebugService,
-		private platform: string,
+	constructor(private platform: string,
+		private $debugService: IDebugService,
 		protected $devicesService: Mobile.IDevicesService,
 		protected $platformService: IPlatformService,
 		protected $projectData: IProjectData,
@@ -31,7 +31,7 @@ export class DebugPlatformCommand implements ICommand {
 		debugData.deviceIdentifier = selectedDeviceForDebug.deviceInfo.identifier;
 
 		if (this.$options.start) {
-			return this.$liveSyncService.printDebugInformation(await this.debugService.debug(debugData, debugOptions));
+			return this.$liveSyncService.printDebugInformation(await this.$debugService.debug(debugData, debugOptions));
 		}
 
 		await this.$devicesService.detectCurrentlyAttachedDevices({ shouldReturnImmediateResult: false, platform: this.platform });
@@ -125,7 +125,7 @@ export class DebugIOSCommand implements ICommand {
 
 	@cache()
 	private get debugPlatformCommand(): DebugPlatformCommand {
-		return this.$injector.resolve<DebugPlatformCommand>(DebugPlatformCommand, { debugService: this.$iOSDebugService, platform: this.platform });
+		return this.$injector.resolve<DebugPlatformCommand>(DebugPlatformCommand, { platform: this.platform });
 	}
 
 	public allowedParameters: ICommandParameter[] = [];
@@ -137,7 +137,6 @@ export class DebugIOSCommand implements ICommand {
 		private $injector: IInjector,
 		private $projectData: IProjectData,
 		private $platformsData: IPlatformsData,
-		private $iOSDebugService: IDebugService,
 		$iosDeviceOperations: IIOSDeviceOperations) {
 		this.$projectData.initializeProjectData();
 		// Do not dispose ios-device-lib, so the process will remain alive and the debug application (NativeScript Inspector or Chrome DevTools) will be able to connect to the socket.
@@ -168,7 +167,7 @@ export class DebugAndroidCommand implements ICommand {
 
 	@cache()
 	private get debugPlatformCommand(): DebugPlatformCommand {
-		return this.$injector.resolve<DebugPlatformCommand>(DebugPlatformCommand, { debugService: this.$androidDebugService, platform: this.platform });
+		return this.$injector.resolve<DebugPlatformCommand>(DebugPlatformCommand, { platform: this.platform });
 	}
 
 	public allowedParameters: ICommandParameter[] = [];
@@ -179,8 +178,7 @@ export class DebugAndroidCommand implements ICommand {
 		private $options: IOptions,
 		private $injector: IInjector,
 		private $projectData: IProjectData,
-		private $platformsData: IPlatformsData,
-		private $androidDebugService: IDebugService) {
+		private $platformsData: IPlatformsData) {
 		this.$projectData.initializeProjectData();
 	}
 

lib/common

@@ -110,8 +110,13 @@ interface IDebugServiceBase extends NodeJS.EventEmitter {
 	debug(debugData: IDebugData, debugOptions: IDebugOptions): Promise<string>;
 }
 
-interface IDebugService {
-	getDebugService(platform: string): IPlatformDebugService;
+interface IDebugService extends IDebugServiceBase {
+	/**
+	 * Stops debug operation for a specific device.
+	 * @param {string} deviceIdentifier Identifier of the device fo which debugging will be stopped.
+	 * @returns {Promise<void>}
+	 */
+	debugStop(deviceIdentifier: string): Promise<void>;
 }
 
 /**

lib/definitions/debug.d.ts

@@ -203,12 +203,27 @@ interface IDebugLiveSyncService extends ILiveSyncService {
 	printDebugInformation(information: string): void;
 
 	/**
-	 * Enables debugging for a specified device
+	 * Enables debugging for the specified devices
 	 * @param {IEnableDebuggingDeviceOptions[]} deviceOpts Settings used for enabling debugging for each device.
 	 * @param {IDebuggingAdditionalOptions} enableDebuggingOptions Settings used for enabling debugging.
-	 * @returns {Promise<void>[]}
+	 * @returns {Promise<void>[]} Array of promises for each device.
 	 */
 	enableDebugging(deviceOpts: IEnableDebuggingDeviceOptions[], enableDebuggingOptions: IDebuggingAdditionalOptions): Promise<void>[];
+
+	/**
+	 * Disables debugging for the specified devices
+	 * @param {IDisableDebuggingDeviceOptions[]} deviceOptions Settings used for disabling debugging for each device.
+	 * @param {IDebuggingAdditionalOptions} debuggingAdditionalOptions Settings used for disabling debugging.
+	 * @returns {Promise<void>[]} Array of promises for each device.
+	 */
+	disableDebugging(deviceOptions: IDisableDebuggingDeviceOptions[], debuggingAdditionalOptions: IDebuggingAdditionalOptions): Promise<void>[];
+
+	/**
+	 * Attaches a debugger to the specified device.
+	 * @param {IAttachDebuggerOptions} settings Settings used for controling the attaching process.
+	 * @returns {Promise<void>}
+	 */
+	attachDebugger(settings: IAttachDebuggerOptions): Promise<void>;
 }
 
 /**

lib/definitions/livesync.d.ts

@@ -2,47 +2,37 @@ import { sleep } from "../common/helpers";
 import { DebugServiceBase } from "./debug-service-base";
 
 export class AndroidDebugService extends DebugServiceBase implements IPlatformDebugService {
-	private _device: Mobile.IAndroidDevice = null;
-
+	private _packageName: string;
 	public get platform() {
 		return "android";
 	}
 
-	private get device(): Mobile.IAndroidDevice {
-		return this._device;
-	}
-
-	private set device(newDevice) {
-		this._device = newDevice;
-	}
-
-	constructor(protected $devicesService: Mobile.IDevicesService,
+	constructor(protected device: Mobile.IAndroidDevice,
+		protected $devicesService: Mobile.IDevicesService,
 		private $errors: IErrors,
 		private $logger: ILogger,
 		private $androidDeviceDiscovery: Mobile.IDeviceDiscovery,
 		private $androidProcessService: Mobile.IAndroidProcessService,
 		private $net: INet) {
-		super($devicesService);
+		super(device, $devicesService);
 	}
 
 	public async debug(debugData: IDebugData, debugOptions: IDebugOptions): Promise<string> {
+		this._packageName = debugData.applicationIdentifier;
 		return debugOptions.emulator
 			? this.debugOnEmulator(debugData, debugOptions)
 			: this.debugOnDevice(debugData, debugOptions);
 	}
 
 	public async debugStart(debugData: IDebugData, debugOptions: IDebugOptions): Promise<void> {
 		await this.$devicesService.initialize({ platform: this.platform, deviceId: debugData.deviceIdentifier });
-		let action = (device: Mobile.IAndroidDevice): Promise<void> => {
-			this.device = device;
-			return this.debugStartCore(debugData.applicationIdentifier, debugOptions);
-		};
+		const action = (device: Mobile.IAndroidDevice): Promise<void> => this.debugStartCore(debugData.applicationIdentifier, debugOptions);
 
 		await this.$devicesService.execute(action, this.getCanExecuteAction(debugData.deviceIdentifier));
 	}
 
-	public async debugStop(): Promise<void> {
-		return;
+	public debugStop(): Promise<void> {
+		return this.removePortForwarding();
 	}
 
 	protected getChromeDebugUrl(debugOptions: IDebugOptions, port: number): string {
@@ -61,6 +51,11 @@ export class AndroidDebugService extends DebugServiceBase implements IPlatformDe
 		return this.debugOnDevice(debugData, debugOptions);
 	}
 
+	private async removePortForwarding(packageName?: string): Promise<void> {
+		const port = await this.getForwardedLocalDebugPortForPackageName(this.device.deviceInfo.identifier, packageName || this._packageName);
+		return this.device.adb.executeCommand(["forward", "--remove", `tcp:${port}`]);
+	}
+
 	private async getForwardedLocalDebugPortForPackageName(deviceId: string, packageName: string): Promise<number> {
 		let port = -1;
 		let forwardsResult = await this.device.adb.executeCommand(["forward", "--list"]);
@@ -103,14 +98,12 @@ export class AndroidDebugService extends DebugServiceBase implements IPlatformDe
 	}
 
 	private async debugCore(device: Mobile.IAndroidDevice, packageFile: string, packageName: string, debugOptions: IDebugOptions): Promise<string> {
-		this.device = device;
-
 		await this.printDebugPort(device.deviceInfo.identifier, packageName);
 
 		if (debugOptions.start) {
 			return await this.attachDebugger(device.deviceInfo.identifier, packageName, debugOptions);
 		} else if (debugOptions.stop) {
-			await this.detachDebugger(packageName);
+			await this.removePortForwarding();
 			return null;
 		} else {
 			await this.debugStartCore(packageName, debugOptions);
@@ -128,18 +121,11 @@ export class AndroidDebugService extends DebugServiceBase implements IPlatformDe
 			this.$errors.failWithoutHelp(`The application ${packageName} does not appear to be running on ${deviceId} or is not built with debugging enabled.`);
 		}
 
-		const startDebuggerCommand = ["am", "broadcast", "-a", `\"${packageName}-debug\"`, "--ez", "enable", "true"];
-		await this.device.adb.executeShellCommand(startDebuggerCommand);
-
 		const port = await this.getForwardedLocalDebugPortForPackageName(deviceId, packageName);
 
 		return this.getChromeDebugUrl(debugOptions, port);
 	}
 
-	private detachDebugger(packageName: string): Promise<void> {
-		return this.device.adb.executeShellCommand(["am", "broadcast", "-a", `${packageName}-debug`, "--ez", "enable", "false"]);
-	}
-
 	private async debugStartCore(packageName: string, debugOptions: IDebugOptions): Promise<void> {
 		// Arguments passed to executeShellCommand must be in array ([]), but it turned out adb shell "arg with intervals" still works correctly.
 		// As we need to redirect output of a command on the device, keep using only one argument.
@@ -188,4 +174,4 @@ export class AndroidDebugService extends DebugServiceBase implements IPlatformDe
 	}
 }
 
-$injector.register("androidDebugService", AndroidDebugService);
+$injector.register("androidDebugService", AndroidDebugService, false);

lib/services/android-debug-service.ts

@@ -1,7 +1,12 @@
 import { EventEmitter } from "events";
 
 export abstract class DebugServiceBase extends EventEmitter implements IPlatformDebugService {
-	constructor(protected $devicesService: Mobile.IDevicesService) { super(); }
+	constructor(
+		protected device: Mobile.IDevice,
+		protected $devicesService: Mobile.IDevicesService
+	) {
+		super();
+	}
 
 	public abstract get platform(): string;