feat: introduce debugController

Author: Fatme

lib/bootstrap.ts

@@ -41,9 +41,7 @@ $injector.require("platformValidationService", "./services/platform/platform-val
 
 $injector.require("buildArtefactsService", "./services/build-artefacts-service");
 
-$injector.require("deviceDebugAppService", "./services/device/device-debug-app-service");
 $injector.require("deviceInstallAppService", "./services/device/device-install-app-service");
-$injector.require("deviceRefreshAppService", "./services/device/device-refresh-app-service");
 
 $injector.require("runEmitter", "./emitters/run-emitter");
 $injector.require("previewAppEmitter", "./emitters/preview-app-emitter");
@@ -53,6 +51,7 @@ $injector.require("prepareController", "./controllers/prepare-controller");
 $injector.require("buildController", "./controllers/build-controller");
 $injector.require("deployController", "./controllers/deploy-controller");
 $injector.require("runController", "./controllers/run-controller");
+$injector.require("debugController", "./controllers/debug-controller");
 $injector.require("previewAppController", "./controllers/preview-app-controller");
 
 $injector.require("prepareDataService", "./services/prepare-data-service");

lib/commands/debug.ts

@@ -1,7 +1,6 @@
 import { cache } from "../common/decorators";
 import { ValidatePlatformCommandBase } from "./command-base";
 import { LiveSyncCommandHelper } from "../helpers/livesync-command-helper";
-import { DeviceDebugAppService } from "../services/device/device-debug-app-service";
 
 export class DebugPlatformCommand extends ValidatePlatformCommandBase implements ICommand {
 	public allowedParameters: ICommandParameter[] = [];
@@ -17,7 +16,7 @@ export class DebugPlatformCommand extends ValidatePlatformCommandBase implements
 		protected $logger: ILogger,
 		protected $errors: IErrors,
 		private $debugDataService: IDebugDataService,
-		private $deviceDebugAppService: DeviceDebugAppService,
+		private $debugController: IDebugController,
 		private $liveSyncCommandHelper: ILiveSyncCommandHelper,
 		private $androidBundleValidatorHelper: IAndroidBundleValidatorHelper) {
 		super($options, $platformsDataService, $platformValidationService, $projectData);
@@ -31,8 +30,6 @@ export class DebugPlatformCommand extends ValidatePlatformCommandBase implements
 			skipDeviceDetectionInterval: true
 		});
 
-		const debugOptions = <IDebugOptions>_.cloneDeep(this.$options.argv);
-
 		const selectedDeviceForDebug = await this.$devicesService.pickSingleDevice({
 			onlyEmulators: this.$options.emulator,
 			onlyDevices: this.$options.forDevice,
@@ -42,11 +39,12 @@ export class DebugPlatformCommand extends ValidatePlatformCommandBase implements
 		const debugData = this.$debugDataService.createDebugData(this.$projectData, { device: selectedDeviceForDebug.deviceInfo.identifier });
 
 		if (this.$options.start) {
-			await this.$deviceDebugAppService.printDebugInformation(await this.$debugService.debug(debugData, debugOptions));
+			const debugOptions = <IDebugOptions>_.cloneDeep(this.$options.argv);
+			await this.$debugController.printDebugInformation(await this.$debugService.debug(debugData, debugOptions));
 			return;
 		}
 
-		await this.$liveSyncCommandHelper.executeLiveSyncOperation([selectedDeviceForDebug], this.platform, {
+		await this.$liveSyncCommandHelper.executeLiveSyncOperationWithDebug([selectedDeviceForDebug], this.platform, {
 			deviceDebugMap: {
 				[selectedDeviceForDebug.deviceInfo.identifier]: true
 			},

lib/commands/run.ts

@@ -13,7 +13,7 @@ export class RunCommandBase implements ICommand {
 		private $errors: IErrors,
 		private $hostInfo: IHostInfo,
 		private $liveSyncCommandHelper: ILiveSyncCommandHelper,
-		private $projectData: IProjectData,
+		private $projectData: IProjectData
 	) { }
 
 	public allowedParameters: ICommandParameter[] = [];

lib/services/device/device-debug-app-service.ts renamed to lib/controllers/debug-controller.ts

@@ -1,17 +1,50 @@
-import { performanceLog } from "../../common/decorators";
-import { RunEmitter } from "../../emitters/run-emitter";
+import { performanceLog } from "../common/decorators";
 import { EOL } from "os";
+import { RunController } from "./run-controller";
+
+export class DebugController extends RunController implements IDebugController {
 
-export class DeviceDebugAppService {
 	constructor(
+		$analyticsService: IAnalyticsService,
+		$buildDataService: IBuildDataService,
+		$buildController: IBuildController,
 		private $debugDataService: IDebugDataService,
 		private $debugService: IDebugService,
-		private $devicesService: Mobile.IDevicesService,
-		private $errors: IErrors,
-		private $logger: ILogger,
-		private $projectDataService: IProjectDataService,
-		private $runEmitter: RunEmitter
-	) { }
+		$deviceInstallAppService: IDeviceInstallAppService,
+		$devicesService: Mobile.IDevicesService,
+		$errors: IErrors,
+		$hmrStatusService: IHmrStatusService,
+		$hooksService: IHooksService,
+		$liveSyncServiceResolver: ILiveSyncServiceResolver,
+		$logger: ILogger,
+		$platformsDataService: IPlatformsDataService,
+		$pluginsService: IPluginsService,
+		$prepareController: IPrepareController,
+		$prepareDataService: IPrepareDataService,
+		$prepareNativePlatformService: IPrepareNativePlatformService,
+		$projectDataService: IProjectDataService,
+		$runEmitter: IRunEmitter
+	) {
+		super(
+			$analyticsService,
+			$buildDataService,
+			$buildController,
+			$deviceInstallAppService,
+			$devicesService,
+			$errors,
+			$hmrStatusService,
+			$hooksService,
+			$liveSyncServiceResolver,
+			$logger,
+			$platformsDataService,
+			$pluginsService,
+			$prepareController,
+			$prepareDataService,
+			$prepareNativePlatformService,
+			$projectDataService,
+			$runEmitter
+		);
+	}
 
 	@performanceLog()
 	public async enableDebugging(projectData: IProjectData, deviceDescriptor: ILiveSyncDeviceInfo, refreshInfo: IRestartApplicationInfo): Promise<IDebugInformation> {
@@ -64,6 +97,17 @@ export class DeviceDebugAppService {
 		return debugInformation;
 	}
 
+	// IMPORTANT: This method overrides the refresh logic of runController as enables debugging for provided deviceDescriptor
+	public async refreshApplication(projectData: IProjectData, liveSyncResultInfo: ILiveSyncResultInfo, deviceDescriptor: ILiveSyncDeviceInfo): Promise<IRestartApplicationInfo> {
+		liveSyncResultInfo.waitForDebugger = deviceDescriptor.debugOptions && deviceDescriptor.debugOptions.debugBrk;
+
+		const refreshInfo = await super.refreshApplication(projectData, liveSyncResultInfo, deviceDescriptor);
+
+		await this.enableDebugging(projectData, deviceDescriptor, refreshInfo);
+
+		return refreshInfo;
+	}
+
 	@performanceLog()
 	private async enableDebuggingCoreWithoutWaitingCurrentAction(deviceOption: IEnableDebuggingDeviceOptions, deviceDescriptor: ILiveSyncDeviceInfo, debuggingAdditionalOptions: IDebuggingAdditionalOptions): Promise<IDebugInformation> {
 		if (!deviceDescriptor) {
@@ -99,4 +143,4 @@ export class DeviceDebugAppService {
 		return debugInformation;
 	}
 }
-$injector.register("deviceDebugAppService", DeviceDebugAppService);
+$injector.register("debugController", DebugController);

lib/controllers/run-controller.ts

@@ -1,33 +1,29 @@
-import { EventEmitter } from "events";
-import { LiveSyncServiceResolver } from "../resolvers/livesync-service-resolver";
 import { HmrConstants, DeviceDiscoveryEventNames } from "../common/constants";
 import { PREPARE_READY_EVENT_NAME, TrackActionNames } from "../constants";
-import { cache } from "../common/decorators";
+import { cache, performanceLog } from "../common/decorators";
 
-export class RunController extends EventEmitter {
+export class RunController implements IRunController {
 	private processesInfo: IDictionary<IRunOnDeviceProcessInfo> = {};
 
 	constructor(
 		private $analyticsService: IAnalyticsService,
 		private $buildDataService: IBuildDataService,
 		private $buildController: IBuildController,
-		private $deviceDebugAppService: IDeviceDebugAppService,
 		private $deviceInstallAppService: IDeviceInstallAppService,
-		private $deviceRefreshAppService: IDeviceRefreshAppService,
-		private $devicesService: Mobile.IDevicesService,
-		private $errors: IErrors,
+		protected $devicesService: Mobile.IDevicesService,
+		protected $errors: IErrors,
 		private $hmrStatusService: IHmrStatusService,
 		public $hooksService: IHooksService,
-		private $liveSyncServiceResolver: LiveSyncServiceResolver,
-		private $logger: ILogger,
+		private $liveSyncServiceResolver: ILiveSyncServiceResolver,
+		protected $logger: ILogger,
 		private $platformsDataService: IPlatformsDataService,
 		private $pluginsService: IPluginsService,
 		private $prepareController: IPrepareController,
 		private $prepareDataService: IPrepareDataService,
 		private $prepareNativePlatformService: IPrepareNativePlatformService,
-		private $projectDataService: IProjectDataService,
-		private $runEmitter: IRunEmitter
-	) { super(); }
+		protected $projectDataService: IProjectDataService,
+		protected $runEmitter: IRunEmitter
+	) { }
 
 	public async run(runData: IRunData): Promise<void> {
 		const { projectDir, liveSyncInfo, deviceDescriptors } = runData;
@@ -115,6 +111,40 @@ export class RunController extends EventEmitter {
 		return currentDescriptors || [];
 	}
 
+	@performanceLog()
+	protected async refreshApplication(projectData: IProjectData, liveSyncResultInfo: ILiveSyncResultInfo, deviceDescriptor: ILiveSyncDeviceInfo, settings?: IRefreshApplicationSettings): Promise<IRestartApplicationInfo> {
+		const result = { didRestart: false };
+		const platform = liveSyncResultInfo.deviceAppData.platform;
+		const applicationIdentifier = projectData.projectIdentifiers[platform.toLowerCase()];
+		const platformLiveSyncService = this.$liveSyncServiceResolver.resolveLiveSyncService(platform);
+
+		try {
+			let shouldRestart = await platformLiveSyncService.shouldRestart(projectData, liveSyncResultInfo);
+			if (!shouldRestart) {
+				shouldRestart = !await platformLiveSyncService.tryRefreshApplication(projectData, liveSyncResultInfo);
+			}
+
+			if (shouldRestart) {
+				this.$runEmitter.emitDebuggerDetachedEvent(liveSyncResultInfo.deviceAppData.device);
+				await platformLiveSyncService.restartApplication(projectData, liveSyncResultInfo);
+				result.didRestart = true;
+			}
+		} catch (err) {
+			this.$logger.info(`Error while trying to start application ${applicationIdentifier} on device ${liveSyncResultInfo.deviceAppData.device.deviceInfo.identifier}. Error is: ${err.message || err}`);
+			const msg = `Unable to start application ${applicationIdentifier} on device ${liveSyncResultInfo.deviceAppData.device.deviceInfo.identifier}. Try starting it manually.`;
+			this.$logger.warn(msg);
+			if (!settings || !settings.shouldSkipEmitLiveSyncNotification) {
+				this.$runEmitter.emitRunNotificationEvent(projectData, liveSyncResultInfo.deviceAppData.device, msg);
+			}
+
+			if (settings && settings.shouldCheckDeveloperDiscImage && (err.message || err) === "Could not find developer disk image") {
+				this.$runEmitter.emitUserInteractionNeededEvent(projectData, liveSyncResultInfo.deviceAppData.device, deviceDescriptor);
+			}
+		}
+
+		return result;
+	}
+
 	private getDeviceDescriptorsForInitialSync(projectDir: string, deviceDescriptors: ILiveSyncDeviceInfo[]) {
 		const currentRunData = this.processesInfo[projectDir];
 		const isAlreadyLiveSyncing = currentRunData && !currentRunData.isStopped;
@@ -178,17 +208,13 @@ export class RunController extends EventEmitter {
 				const { force, useHotModuleReload, skipWatcher } = liveSyncInfo;
 				const liveSyncResultInfo = await platformLiveSyncService.fullSync({ force, useHotModuleReload, projectData, device, watch: !skipWatcher, liveSyncDeviceInfo: deviceDescriptor });
 
-				const refreshInfo = await this.$deviceRefreshAppService.refreshApplication(projectData, liveSyncResultInfo, deviceDescriptor);
+				await this.refreshApplication(projectData, liveSyncResultInfo, deviceDescriptor);
 
 				this.$runEmitter.emitRunExecutedEvent(projectData, device, {
 					syncedFiles: liveSyncResultInfo.modifiedFilesData.map(m => m.getLocalPath()),
 					isFullSync: liveSyncResultInfo.isFullSync
 				});
 
-				if (liveSyncResultInfo && deviceDescriptor.debuggingEnabled) {
-					await this.$deviceDebugAppService.enableDebugging(projectData, deviceDescriptor, refreshInfo);
-				}
-
 				this.$logger.info(`Successfully synced application ${liveSyncResultInfo.deviceAppData.appIdentifier} on device ${liveSyncResultInfo.deviceAppData.device.deviceInfo.identifier}.`);
 
 				this.$runEmitter.emitRunStartedEvent(projectData, device);
@@ -236,6 +262,11 @@ export class RunController extends EventEmitter {
 
 				await this.refreshApplication(projectData, liveSyncResultInfo, deviceDescriptor);
 
+				this.$runEmitter.emitRunExecutedEvent(projectData, liveSyncResultInfo.deviceAppData.device, {
+					syncedFiles: liveSyncResultInfo.modifiedFilesData.map(m => m.getLocalPath()),
+					isFullSync: liveSyncResultInfo.isFullSync
+				});
+
 				if (!liveSyncResultInfo.didRecover && isInHMRMode) {
 					const status = await this.$hmrStatusService.getHmrStatus(device.deviceInfo.identifier, data.hmrData.hash);
 					if (status === HmrConstants.HMR_ERROR_STATUS) {
@@ -244,6 +275,11 @@ export class RunController extends EventEmitter {
 						// We want to force a restart of the application.
 						liveSyncResultInfo.isFullSync = true;
 						await this.refreshApplication(projectData, liveSyncResultInfo, deviceDescriptor);
+
+						this.$runEmitter.emitRunExecutedEvent(projectData, liveSyncResultInfo.deviceAppData.device, {
+							syncedFiles: liveSyncResultInfo.modifiedFilesData.map(m => m.getLocalPath()),
+							isFullSync: liveSyncResultInfo.isFullSync
+						});
 					}
 				}
 
@@ -266,19 +302,6 @@ export class RunController extends EventEmitter {
 		}));
 	}
 
-	private async refreshApplication(projectData: IProjectData, liveSyncResultInfo: ILiveSyncResultInfo, deviceDescriptor: ILiveSyncDeviceInfo) {
-		const refreshInfo = await this.$deviceRefreshAppService.refreshApplication(projectData, liveSyncResultInfo, deviceDescriptor);
-
-		this.$runEmitter.emitRunExecutedEvent(projectData, liveSyncResultInfo.deviceAppData.device, {
-			syncedFiles: liveSyncResultInfo.modifiedFilesData.map(m => m.getLocalPath()),
-			isFullSync: liveSyncResultInfo.isFullSync
-		});
-
-		if (liveSyncResultInfo && deviceDescriptor.debuggingEnabled) {
-			await this.$deviceDebugAppService.enableDebugging(projectData, deviceDescriptor, refreshInfo);
-		}
-	}
-
 	private async addActionToChain<T>(projectDir: string, action: () => Promise<T>): Promise<T> {
 		const liveSyncInfo = this.processesInfo[projectDir];
 		if (liveSyncInfo) {

lib/definitions/debug.d.ts

@@ -107,7 +107,7 @@ interface IDebugDataService {
 	 * @param {IOptions} options The options based on which debugData will be created
 	 * @returns {IDebugData} Data describing the required information for starting debug process.
 	 */
-	createDebugData(projectData: IProjectData, options: IDeviceIdentifier): IDebugData;
+	 createDebugData(projectData: IProjectData, options: IDeviceIdentifier): IDebugData;
 }
 
 /**
@@ -154,3 +154,10 @@ interface IDeviceDebugService extends IPlatform, NodeJS.EventEmitter {
 interface IDebugResultInfo {
 	debugUrl: string;
 }
+
+interface IDebugController extends IRunController {
+	// TODO: add disableDebugging method
+	enableDebugging(projectData: IProjectData, deviceDescriptor: ILiveSyncDeviceInfo, refreshInfo: IRestartApplicationInfo): Promise<IDebugInformation>;
+	attachDebugger(settings: IAttachDebuggerOptions): Promise<IDebugInformation>;
+	printDebugInformation(debugInformation: IDebugInformation, fireDebuggerAttachedEvent?: boolean): IDebugInformation;
+}

lib/definitions/deploy.d.ts

@@ -0,0 +1,3 @@
+interface IDeployController {
+	deploy(data: IRunData): Promise<void>;
+}

lib/definitions/livesync.d.ts

@@ -468,6 +468,7 @@ declare global {
 		 * @returns {Promise<void>}
 		 */
 		executeLiveSyncOperation(devices: Mobile.IDevice[], platform: string, additionalOptions?: ILiveSyncCommandHelperAdditionalOptions): Promise<void>;
+		executeLiveSyncOperationWithDebug(devices: Mobile.IDevice[], platform: string, additionalOptions?: ILiveSyncCommandHelperAdditionalOptions): Promise<void>;
 		getPlatformsForOperation(platform: string): string[];
 
 		/**
@@ -486,4 +487,7 @@ declare global {
 		executeCommandLiveSync(platform?: string, additionalOptions?: ILiveSyncCommandHelperAdditionalOptions): Promise<void>;
 	}
 
+	interface ILiveSyncServiceResolver {
+		resolveLiveSyncService(platform: string): IPlatformLiveSyncService;
+	}
 }

lib/definitions/run.d.ts

@@ -5,7 +5,9 @@ interface IRunData {
 }
 
 interface IRunController {
-
+	run(runData: IRunData): Promise<void>;
+	stop(projectDir: string, deviceIdentifiers?: string[], stopOptions?: { shouldAwaitAllActions: boolean }): Promise<void>;
+	getDeviceDescriptors(projectDir: string): ILiveSyncDeviceInfo[];
 }
 
 interface IRunEmitter {
@@ -24,13 +26,3 @@ interface IDeviceInstallAppService {
 	installOnDeviceIfNeeded(device: Mobile.IDevice, buildData: IBuildData, packageFile?: string): Promise<void>;
 	shouldInstall(device: Mobile.IDevice, buildData: IBuildData): Promise<boolean>;
 }
-
-interface IDeviceRefreshAppService {
-	refreshApplication(projectData: IProjectData, liveSyncResultInfo: ILiveSyncResultInfo, deviceDescriptor: ILiveSyncDeviceInfo, settings?: IRefreshApplicationSettings): Promise<IRestartApplicationInfo>;
-}
-
-interface IDeviceDebugAppService {
-	enableDebugging(projectData: IProjectData, deviceDescriptor: ILiveSyncDeviceInfo, refreshInfo: IRestartApplicationInfo): Promise<IDebugInformation>;
-	attachDebugger(settings: IAttachDebuggerOptions): Promise<IDebugInformation>;
-	printDebugInformation(debugInformation: IDebugInformation, fireDebuggerAttachedEvent: boolean): IDebugInformation;
-}