Fixed first time debug with livesync

Tsvetan Raikov · Tsvetan Raikov · commit 31eaf6c435c6 · 2016-07-26T17:13:19.000+03:00
diff --git a/lib/commands/debug.ts b/lib/commands/debug.ts
@@ -1,14 +1,37 @@
 ﻿export class DebugPlatformCommand implements ICommand {
 	constructor(private debugService: IDebugService,
 		private $devicesService: Mobile.IDevicesService,
-		private $usbLiveSyncService: ILiveSyncService,
+		private $injector: IInjector,
 		private $logger: ILogger,
+		private $childProcess: IChildProcess,
+		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
+		private $config: IConfiguration,
 		protected $options: IOptions) { }
 
 	execute(args: string[]): IFuture<void> {
-		if (!this.$options.rebuild) {
-			this.$options.debug = true;
-			return this.$usbLiveSyncService.liveSync(this.$devicesService.platform);
+		if (!this.$options.rebuild && !this.$options.start) {
+			this.$config.debugLivesync = true;
+			let usbLiveSyncService: ILiveSyncService = this.$injector.resolve("usbLiveSyncService");
+			let liveSyncServiceBase: any = this.$injector.resolve("liveSyncServiceBase");
+			let liveSyncProvider: ILiveSyncProvider = this.$injector.resolve("liveSyncProvider");
+
+			liveSyncServiceBase.on("sync", (device: Mobile.IDevice, data: ILiveSyncData) => {
+				let platformLiveSyncService: IPlatformLiveSyncService = this.$injector.resolve(liveSyncProvider.platformSpecificLiveSyncServices[data.platform.toLowerCase()], { _device: device });
+				let projectData: IProjectData = this.$injector.resolve("projectData");
+				let appId = device.isEmulator ? projectData.projectName : data.appIdentifier;
+				if (data.platform === this.$devicePlatformsConstants.iOS) {
+					platformLiveSyncService.debugService.debugStop().wait();
+				}
+				device.applicationManager.stopApplication(appId).wait();
+				platformLiveSyncService.debugService.debug().wait();
+			});
+
+			liveSyncServiceBase.on("syncAfterInstall", (device: Mobile.IDevice, data: ILiveSyncData) => {
+				let platformLiveSyncService: IPlatformLiveSyncService = this.$injector.resolve(liveSyncProvider.platformSpecificLiveSyncServices[data.platform.toLowerCase()], { _device: device });
+				platformLiveSyncService.debugService.debug().wait();
+			});
+
+			return usbLiveSyncService.liveSync(this.$devicesService.platform);
 		}
 		return this.debugService.debug();
 	}
@@ -38,21 +61,27 @@
 export class DebugIOSCommand extends DebugPlatformCommand {
 	constructor($iOSDebugService: IDebugService,
 		$devicesService: Mobile.IDevicesService,
-		$usbLiveSyncService: ILiveSyncService,
+		$injector: IInjector,
 		$logger: ILogger,
+		$childProcess: IChildProcess,
+		$devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
+		$config: IConfiguration,
 		$options: IOptions) {
-		super($iOSDebugService, $devicesService, $usbLiveSyncService, $logger, $options);
+		super($iOSDebugService, $devicesService, $injector, $logger, $childProcess, $devicePlatformsConstants, $config, $options);
 	}
 }
 $injector.registerCommand("debug|ios", DebugIOSCommand);
 
 export class DebugAndroidCommand extends DebugPlatformCommand {
 	constructor($androidDebugService: IDebugService,
 		$devicesService: Mobile.IDevicesService,
-		$usbLiveSyncService: ILiveSyncService,
+		$injector: IInjector,
 		$logger: ILogger,
+		$childProcess: IChildProcess,
+	    $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
+		$config: IConfiguration,
 		$options: IOptions) {
-		super($androidDebugService, $devicesService, $usbLiveSyncService, $logger, $options);
+		super($androidDebugService, $devicesService, $injector, $logger, $childProcess, $devicePlatformsConstants, $config, $options);
 	}
 }
 $injector.registerCommand("debug|android", DebugAndroidCommand);
diff --git a/lib/common b/lib/common
@@ -1 +1 @@
-Subproject commit 6bf76a4043c90009a6cb2bfe6bf033db333cbd0c
+Subproject commit afa6b2d503fc92d298d1a186d957536c84e4872d
diff --git a/lib/config.ts b/lib/config.ts
@@ -10,6 +10,7 @@ export class Configuration extends ConfigBase implements IConfiguration { // Use
 	USE_PROXY = false;
 	ANDROID_DEBUG_UI: string = null;
 	USE_POD_SANDBOX: boolean = true;
+	debugLivesync: boolean = false;
 
 	/*don't require logger and everything that has logger as dependency in config.js due to cyclic dependency*/
 	constructor(protected $fs: IFileSystem) {
diff --git a/lib/declarations.ts b/lib/declarations.ts
@@ -38,6 +38,7 @@ interface IStaticConfig extends Config.IStaticConfig { }
 interface IConfiguration extends Config.IConfig {
 	ANDROID_DEBUG_UI: string;
 	USE_POD_SANDBOX: boolean;
+	debugLivesync: boolean;
 }
 
 interface IApplicationPackage {
diff --git a/lib/definitions/debug.d.ts b/lib/definitions/debug.d.ts
@@ -1,5 +1,6 @@
 interface IDebugService {
 	debug(shouldBreak?: boolean): IFuture<void>;
 	debugStart(): IFuture<void>;
+	debugStop?(): IFuture<void>
 	platform: string;
 }
diff --git a/lib/definitions/platform.d.ts b/lib/definitions/platform.d.ts
@@ -11,6 +11,7 @@ interface IPlatformService {
 	buildForDeploy(platform: string, buildConfig?: IBuildConfig): IFuture<void>;
 	installOnDevice(platform: string, buildConfig?: IBuildConfig): IFuture<void>;
 	deployOnDevice(platform: string, buildConfig?: IBuildConfig): IFuture<void>;
+	startOnDevice(platform: string): IFuture<void>;
 	deployOnEmulator(platform: string, buildConfig?: IBuildConfig): IFuture<void>;
 	validatePlatformInstalled(platform: string): void;
 	validatePlatform(platform: string): void;
diff --git a/lib/device-sockets/ios/socket-proxy-factory.ts b/lib/device-sockets/ios/socket-proxy-factory.ts
@@ -7,6 +7,7 @@ import * as helpers from "../../common/helpers";
 
 export class SocketProxyFactory implements ISocketProxyFactory {
 	constructor(private $logger: ILogger,
+		private $config: IConfiguration,
 		private $projectData: IProjectData,
 		private $projectDataService: IProjectDataService,
 		private $options: IOptions) { }
@@ -98,15 +99,19 @@ export class SocketProxyFactory implements ISocketProxyFactory {
 
 			frontendSocket.on("end", () => {
 				this.$logger.info('Frontend socket closed!');
-				process.exit(0);
+				if (!(this.$config.debugLivesync && this.$options.watch)) {
+					process.exit(0);
+				}
 			});
 
 			socketFactory((backendSocket: net.Socket) => {
 				this.$logger.info("Backend socket created.");
 
 				backendSocket.on("end", () => {
 					this.$logger.info("Backend socket closed!");
-					process.exit(0);
+					if (!(this.$config.debugLivesync && this.$options.watch)) {
+						process.exit(0);
+					}
 				});
 
 				backendSocket.pipe(frontendSocket);
diff --git a/lib/services/ios-debug-service.ts b/lib/services/ios-debug-service.ts
@@ -2,6 +2,7 @@ import * as iOSDevice from "../common/mobile/ios/device/ios-device";
 import * as net from "net";
 import * as path from "path";
 import * as semver from "semver";
+import {ChildProcess} from "child_process";
 import byline = require("byline");
 
 const inspectorBackendPort = 18181;
@@ -13,6 +14,7 @@ const TIMEOUT_SECONDS = 90;
 
 class IOSDebugService implements IDebugService {
 	constructor(
+		private $config: IConfiguration,
 		private $platformService: IPlatformService,
 		private $iOSEmulatorServices: Mobile.IEmulatorPlatformServices,
 		private $devicesService: Mobile.IDevicesService,
@@ -31,6 +33,8 @@ class IOSDebugService implements IDebugService {
 		private $iOSSocketRequestExecutor: IiOSSocketRequestExecutor,
 		private $socketProxyFactory: ISocketProxyFactory) { }
 
+	private _lldbProcess: ChildProcess;
+
 	public get platform(): string {
 		return "ios";
 	}
@@ -70,6 +74,16 @@ class IOSDebugService implements IDebugService {
 		}).future<void>()();
 	}
 
+	public debugStop(): IFuture<void> {
+		return (() => {
+			if (this._lldbProcess) {
+				this._lldbProcess.stdin.write("process detach\n");
+				this._lldbProcess.kill();
+				this._lldbProcess = undefined;
+			}
+		}).future<void>()();
+	}
+
 	private emulatorDebugBrk(shouldBreak?: boolean): IFuture<void> {
 		return (() => {
 			let platformData = this.$platformsData.getPlatformData(this.platform);
@@ -81,16 +95,17 @@ class IOSDebugService implements IDebugService {
 			let args = shouldBreak ? "--nativescript-debug-brk" : "--nativescript-debug-start";
 			let child_process = this.$iOSEmulatorServices.runApplicationOnEmulator(emulatorPackage.packageName, {
 				waitForDebugger: true, captureStdin: true,
-				args: args, appId: this.$projectData.projectId
+				args: args, appId: this.$projectData.projectId,
+				skipInstall: this.$config.debugLivesync
 			}).wait();
 			let lineStream = byline(child_process.stdout);
 
 			lineStream.on('data', (line: NodeBuffer) => {
 				let lineText = line.toString();
 				if (lineText && _.startsWith(lineText, this.$projectData.projectId)) {
 					let pid = _.trimStart(lineText, this.$projectData.projectId + ": ");
-
-					this.$childProcess.exec(`lldb -p ${pid} -o "process continue"`);
+					this._lldbProcess = this.$childProcess.spawn("lldb", [ "-p", pid]);
+					this._lldbProcess.stdin.write("process continue\n");
 				} else {
 					process.stdout.write(line + "\n");
 				}
@@ -119,9 +134,14 @@ class IOSDebugService implements IDebugService {
 					return this.emulatorDebugBrk(shouldBreak).wait();
 				}
 				// we intentionally do not wait on this here, because if we did, we'd miss the AppLaunching notification
-				let deploy = this.$platformService.deployOnDevice(this.platform);
+				let action: IFuture<void>;
+				if (this.$config.debugLivesync) {
+					action = this.$platformService.startOnDevice(this.platform);
+				} else {
+					action = this.$platformService.deployOnDevice(this.platform);
+				}
 				this.debugBrkCore(device, shouldBreak).wait();
-				deploy.wait();
+				action.wait();
 			}).future<void>()()).wait();
 		}).future<void>()();
 	}
diff --git a/lib/services/livesync/android-livesync-service.ts b/lib/services/livesync/android-livesync-service.ts
@@ -20,10 +20,11 @@ class AndroidLiveSyncService extends PlatformLiveSyncServiceBase<Mobile.IAndroid
 		super(_device, $liveSyncProvider);
 	}
 
+	public get debugService(): IDebugService {
+		return this.$androidDebugService;
+	}
+
 	public restartApplication(deviceAppData: Mobile.IDeviceAppData): IFuture<void> {
-		if (this.$options.debug) {
-			return this.$androidDebugService.debug();
-		}
 		return (() => {
 			this.device.adb.executeShellCommand(["chmod", "777", deviceAppData.deviceProjectRootPath, `/data/local/tmp/${deviceAppData.appIdentifier}`]).wait();
 
diff --git a/lib/services/livesync/ios-livesync-service.ts b/lib/services/livesync/ios-livesync-service.ts
@@ -16,10 +16,15 @@ class IOSLiveSyncService extends PlatformLiveSyncServiceBase<Mobile.IiOSDevice>
 		private $logger: ILogger,
 		private $options: IOptions,
 		private $iOSDebugService: IDebugService,
+		private $childProcess: IChildProcess,
 		$liveSyncProvider: ILiveSyncProvider) {
 		super(_device, $liveSyncProvider);
 	}
 
+	public get debugService(): IDebugService {
+		return this.$iOSDebugService;
+	}
+
 	public afterInstallApplicationAction(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): IFuture<boolean> {
  		return (() => {
  			return this.$options.watch;
@@ -33,12 +38,8 @@ class IOSLiveSyncService extends PlatformLiveSyncServiceBase<Mobile.IiOSDevice>
 	}
 
 	protected restartApplication(deviceAppData: Mobile.IDeviceAppData): IFuture<void> {
-		if (this.$options.debug) {
-			return this.$iOSDebugService.debug();
-		} else {
-			let projectData: IProjectData = this.$injector.resolve("projectData");
-			return this.device.applicationManager.restartApplication(deviceAppData.appIdentifier, projectData.projectName);
-		}
+		let projectData: IProjectData = this.$injector.resolve("projectData");
+		return this.device.applicationManager.restartApplication(deviceAppData.appIdentifier, projectData.projectName);
 	}
 
 	protected reloadPage(deviceAppData: Mobile.IDeviceAppData): IFuture<void> {
diff --git a/lib/services/livesync/livesync-service-base.ts b/lib/services/livesync/livesync-service-base.ts
@@ -6,10 +6,11 @@ import * as temp from "temp";
 import * as minimatch from "minimatch";
 import * as constants from "../../common/constants";
 import * as util from "util";
+import { EventEmitter } from "events";
 
 let gaze = require("gaze");
 
-class LiveSyncServiceBase implements ILiveSyncServiceBase {
+class LiveSyncServiceBase extends EventEmitter implements ILiveSyncServiceBase {
 	private showFullLiveSyncInformation: boolean = false;
 	private fileHashes: IDictionary<string>;
 
@@ -25,7 +26,9 @@ class LiveSyncServiceBase implements ILiveSyncServiceBase {
 		private $projectFilesProvider: IProjectFilesProvider,
 		private $liveSyncProvider: ILiveSyncProvider,
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
+		private $iOSDebugService: IDebugService,
 		private $dispatcher: IFutureDispatcher) {
+		super();
 		this.fileHashes = Object.create(null);
 	}
 
@@ -196,7 +199,9 @@ class LiveSyncServiceBase implements ILiveSyncServiceBase {
 					shouldRefreshApplication = platformLiveSyncService.afterInstallApplicationAction(deviceAppData, localToDevicePaths).wait();
 
 					if (device.applicationManager.canStartApplication() && !shouldRefreshApplication) {
-						device.applicationManager.startApplication(appIdentifier).wait();
+						if (!this.emit("syncAfterInstall", device, data)) {
+							device.applicationManager.startApplication(appIdentifier).wait();
+						}
 					}
 					wasInstalled = false;
 				}
@@ -212,9 +217,12 @@ class LiveSyncServiceBase implements ILiveSyncServiceBase {
 					}
 
 					this.$logger.info("Applying changes...");
-					platformLiveSyncService.refreshApplication(deviceAppData, localToDevicePaths, data.forceExecuteFullSync || !wasInstalled).wait();
+					if (!this.emit("sync", device, data)) {
+						platformLiveSyncService.refreshApplication(deviceAppData, localToDevicePaths, data.forceExecuteFullSync || !wasInstalled).wait();
+					}
 					this.$logger.info(`Successfully synced application ${data.appIdentifier} on device ${device.deviceInfo.identifier}.`);
 				}
+
 			}).future<void>()();
 		};
 
diff --git a/lib/services/platform-service.ts b/lib/services/platform-service.ts
@@ -462,6 +462,12 @@ export class PlatformService implements IPlatformService {
 	public deployOnDevice(platform: string, buildConfig?: IBuildConfig): IFuture<void> {
 		return (() => {
 			this.installOnDevice(platform, buildConfig).wait();
+			this.startOnDevice(platform).wait();
+		}).future<void>()();
+	}
+
+	public startOnDevice(platform: string): IFuture<void> {
+		return (() => {
 			let action = (device: Mobile.IDevice) => device.applicationManager.startApplication(this.$projectData.projectId);
 			this.$devicesService.execute(action, this.getCanExecuteAction(platform)).wait();
 		}).future<void>()();
diff --git a/package.json b/package.json
@@ -46,7 +46,7 @@
     "glob": "^7.0.3",
     "iconv-lite": "0.4.11",
     "inquirer": "0.9.0",
-    "ios-sim-portable": "~1.1.0",
+    "ios-sim-portable": "~1.2.0",
     "lockfile": "1.0.1",
     "lodash": "4.13.1",
     "log4js": "0.6.26",

Original file line number	Diff line number	Diff line change
`@@ -38,6 +38,7 @@ interface IStaticConfig extends Config.IStaticConfig { }`
`38`	`38`	`interface IConfiguration extends Config.IConfig {`
`39`	`39`	`ANDROID_DEBUG_UI: string;`
`40`	`40`	`USE_POD_SANDBOX: boolean;`
	`41`	`+ debugLivesync: boolean;`
`41`	`42`	`}`
`42`	`43`
`43`	`44`	`interface IApplicationPackage {`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`interface IDebugService {`
`2`	`2`	`debug(shouldBreak?: boolean): IFuture<void>;`
`3`	`3`	`debugStart(): IFuture<void>;`
	`4`	`+ debugStop?(): IFuture<void>`
`4`	`5`	`platform: string;`
`5`	`6`	`}`