fix: enable debug-brk on real iOS devices and do not make an additional restart in the debug services

Author: DimitarTachev

lib/commands/debug.ts

@@ -1,10 +1,6 @@
-import { CONNECTED_STATUS } from "../common/constants";
-import { isInteractive } from "../common/helpers";
 import { cache } from "../common/decorators";
-import { DebugCommandErrors } from "../constants";
 import { ValidatePlatformCommandBase } from "./command-base";
 import { LiveSyncCommandHelper } from "../helpers/livesync-command-helper";
-import { performanceLog } from "../common/decorators";
 
 export class DebugPlatformCommand extends ValidatePlatformCommandBase implements ICommand {
 	public allowedParameters: ICommandParameter[] = [];
@@ -21,7 +17,6 @@ export class DebugPlatformCommand extends ValidatePlatformCommandBase implements
 		protected $errors: IErrors,
 		private $debugDataService: IDebugDataService,
 		private $liveSyncService: IDebugLiveSyncService,
-		private $prompter: IPrompter,
 		private $liveSyncCommandHelper: ILiveSyncCommandHelper,
 		private $androidBundleValidatorHelper: IAndroidBundleValidatorHelper) {
 		super($options, $platformsData, $platformService, $projectData);
@@ -37,7 +32,11 @@ export class DebugPlatformCommand extends ValidatePlatformCommandBase implements
 
 		const debugOptions = <IDebugOptions>_.cloneDeep(this.$options.argv);
 
-		const selectedDeviceForDebug = await this.getDeviceForDebug();
+		const selectedDeviceForDebug = await this.$devicesService.pickSingleDevice({
+			onlyEmulators: this.$options.emulator,
+			onlyDevices: this.$options.forDevice,
+			deviceId: this.$options.device
+		});
 
 		const debugData = this.$debugDataService.createDebugData(this.$projectData, { device: selectedDeviceForDebug.deviceInfo.identifier });
 
@@ -56,61 +55,6 @@ export class DebugPlatformCommand extends ValidatePlatformCommandBase implements
 		});
 	}
 
-	@performanceLog()
-	public async getDeviceForDebug(): Promise<Mobile.IDevice> {
-		if (this.$options.forDevice && this.$options.emulator) {
-			this.$errors.fail(DebugCommandErrors.UNABLE_TO_USE_FOR_DEVICE_AND_EMULATOR);
-		}
-
-		if (this.$options.device) {
-			const device = await this.$devicesService.getDevice(this.$options.device);
-			return device;
-		}
-
-		// Now let's take data for each device:
-		const availableDevicesAndEmulators = this.$devicesService.getDeviceInstances()
-			.filter(d => d.deviceInfo.status === CONNECTED_STATUS && (!this.platform || d.deviceInfo.platform.toLowerCase() === this.platform.toLowerCase()));
-
-		const selectedDevices = availableDevicesAndEmulators.filter(d => this.$options.emulator ? d.isEmulator : (this.$options.forDevice ? !d.isEmulator : true));
-
-		if (selectedDevices.length > 1) {
-			if (isInteractive()) {
-				const choices = selectedDevices.map(e => `${e.deviceInfo.identifier} - ${e.deviceInfo.displayName}`);
-
-				const selectedDeviceString = await this.$prompter.promptForChoice("Select device for debugging", choices);
-
-				const selectedDevice = _.find(selectedDevices, d => `${d.deviceInfo.identifier} - ${d.deviceInfo.displayName}` === selectedDeviceString);
-				return selectedDevice;
-			} else {
-				const sortedInstances = _.sortBy(selectedDevices, e => e.deviceInfo.version);
-				const emulators = sortedInstances.filter(e => e.isEmulator);
-				const devices = sortedInstances.filter(d => !d.isEmulator);
-				let selectedInstance: Mobile.IDevice;
-
-				if (this.$options.emulator || this.$options.forDevice) {
-					// When --emulator or --forDevice is passed, the instances are already filtered
-					// So we are sure we have exactly the type we need and we can safely return the last one (highest OS version).
-					selectedInstance = _.last(sortedInstances);
-				} else {
-					if (emulators.length) {
-						selectedInstance = _.last(emulators);
-					} else {
-						selectedInstance = _.last(devices);
-					}
-				}
-
-				this.$logger.warn(`Multiple devices/emulators found. Starting debugger on ${selectedInstance.deviceInfo.identifier}. ` +
-					"If you want to debug on specific device/emulator, you can specify it with --device option.");
-
-				return selectedInstance;
-			}
-		} else if (selectedDevices.length === 1) {
-			return _.head(selectedDevices);
-		}
-
-		this.$errors.failWithoutHelp(DebugCommandErrors.NO_DEVICES_EMULATORS_FOUND_FOR_OPTIONS);
-	}
-
 	public async canExecute(args: string[]): Promise<ICanExecuteCommandOutput> {
 		this.$androidBundleValidatorHelper.validateNoAab();
 

lib/commands/test.ts

@@ -1,24 +1,5 @@
 import * as helpers from "../common/helpers";
 
-function RunTestCommandFactory(platform: string) {
-	return function RunTestCommand(
-		$options: IOptions,
-		$testExecutionService: ITestExecutionService,
-		$projectData: IProjectData,
-		$analyticsService: IAnalyticsService,
-		$platformEnvironmentRequirements: IPlatformEnvironmentRequirements) {
-		$projectData.initializeProjectData();
-		$analyticsService.setShouldDispose($options.justlaunch || !$options.watch);
-		const projectFilesConfig = helpers.getProjectFilesConfig({ isReleaseBuild: $options.release });
-		this.execute = (args: string[]): Promise<void> => $testExecutionService.startTestRunner(platform, $projectData, projectFilesConfig);
-		this.canExecute = (args: string[]): Promise<boolean> => canExecute({ $platformEnvironmentRequirements, $projectData, $options, platform });
-		this.allowedParameters = [];
-	};
-}
-
-$injector.registerCommand("dev-test|android", RunTestCommandFactory('android'));
-$injector.registerCommand("dev-test|ios", RunTestCommandFactory('iOS'));
-
 function RunKarmaTestCommandFactory(platform: string) {
 	return function RunKarmaTestCommand($options: IOptions, $testExecutionService: ITestExecutionService, $projectData: IProjectData, $analyticsService: IAnalyticsService, $platformEnvironmentRequirements: IPlatformEnvironmentRequirements) {
 		$projectData.initializeProjectData();

lib/common/appbuilder/services/livesync/ios-livesync-service.ts

@@ -51,7 +51,7 @@ export class IOSLiveSyncService implements IDeviceLiveSyncService {
 			this.$logger.trace(`Transferring from ${sourcePath} to ${destinationPath}`);
 			shell.cp("-Rf", path.join(sourcePath, "*"), destinationPath);
 
-			await this.device.applicationManager.restartApplication({ appId: deviceAppData.appIdentifier, projectName: "" });
+			await this.device.applicationManager.restartApplication({ appId: deviceAppData.appIdentifier, projectName: "", waitForDebugger: false, enableDebugging: false });
 		} else {
 			await this.device.fileSystem.deleteFile("/Documents/AppBuilder/ServerInfo.plist", deviceAppData.appIdentifier);
 			const notification = this.$project.projectData.Framework === constants.TARGET_FRAMEWORK_IDENTIFIERS.NativeScript ? "com.telerik.app.refreshApp" : "com.telerik.app.refreshWebView";

lib/common/commands/device/run-application.ts

@@ -15,7 +15,7 @@ export class RunApplicationOnDeviceCommand implements ICommand {
 			this.$errors.failWithoutHelp("More than one device found. Specify device explicitly with --device option. To discover device ID, use $%s device command.", this.$staticConfig.CLIENT_NAME.toLowerCase());
 		}
 
-		await this.$devicesService.execute(async (device: Mobile.IDevice) => await device.applicationManager.startApplication({ appId: args[0], projectName: args[1] }));
+		await this.$devicesService.execute(async (device: Mobile.IDevice) => await device.applicationManager.startApplication({ appId: args[0], projectName: args[1], waitForDebugger: false, enableDebugging: false }));
 	}
 }
 

lib/common/definitions/mobile.d.ts

@@ -111,12 +111,8 @@ declare module Mobile {
 	}
 
 	interface IiOSDevice extends IDevice {
-		getLiveSyncSocket(appId: string): Promise<any>;
-		destroyLiveSyncSocket(appId: string): void;
-
-		getDebugSocket(appId: string): Promise<any>;
+		getDebugSocket(appId: string, projectName: string): Promise<any>;
 		destroyDebugSocket(appId: string): void;
-
 		openDeviceLogStream(options?: IiOSLogStreamOptions): Promise<void>;
 		destroyAllSockets(): void;
 	}
@@ -221,12 +217,6 @@ declare module Mobile {
 		 * @param {string} projectName The project name of the currently running application for which we need the logs.
 		 */
 		setProjectNameForDevice(deviceIdentifier: string, projectName: string): void;
-
-		/**
-		 * Disables logs on the specified device and does not print any logs on the console.
-		 * @param {string} deviceIdentifier The unique identifier of the device.
-		 */
-		muteLogsForDevice(deviceIdentifier: string): void;
 	}
 
 	/**
@@ -248,10 +238,6 @@ declare module Mobile {
 		 */
 		projectName?: string;
 
-		/**
-		 * Specifies if the logs will be printed on the console.
-		 */
-		muteLogs?: boolean;
 	}
 
 	/**
@@ -311,19 +297,28 @@ declare module Mobile {
 		justLaunch?: boolean;
 	}
 
+	interface IStartApplicationData extends IApplicationData {
+		waitForDebugger: boolean;
+		enableDebugging: boolean;
+	}
+
 	interface IInstallAppData extends IApplicationData {
 		packagePath: string;
 	}
 
+	interface IRunningAppInfo {
+		pid: string;
+	}
+
 	interface IDeviceApplicationManager extends NodeJS.EventEmitter {
 		getInstalledApplications(): Promise<string[]>;
 		isApplicationInstalled(appIdentifier: string): Promise<boolean>;
 		installApplication(packageFilePath: string, appIdentifier?: string): Promise<void>;
 		uninstallApplication(appIdentifier: string): Promise<void>;
 		reinstallApplication(appIdentifier: string, packageFilePath: string): Promise<void>;
-		startApplication(appData: IApplicationData): Promise<void>;
+		startApplication(appData: IStartApplicationData): Promise<IRunningAppInfo>;
 		stopApplication(appData: IApplicationData): Promise<void>;
-		restartApplication(appData: IApplicationData): Promise<void>;
+		restartApplication(appData: IStartApplicationData): Promise<IRunningAppInfo>;
 		checkForApplicationUpdates(): Promise<void>;
 		isLiveSyncSupported(appIdentifier: string): Promise<boolean>;
 		getApplicationInfo(applicationIdentifier: string): Promise<Mobile.IApplicationInfo>;
@@ -550,6 +545,27 @@ declare module Mobile {
 		 * @returns {Promise<string[]>} - Returns array of errors.
 		 */
 		startEmulator(options?: IStartEmulatorOptions): Promise<string[]>;
+
+		/**
+		 * Returns a single device based on the specified options. If more than one devices are matching,
+		 * prompts the user for a manual choice or returns the first one for non interactive terminals.
+		 */
+		pickSingleDevice(options: IPickSingleDeviceOptions): Promise<Mobile.IDevice>
+	}
+
+	interface IPickSingleDeviceOptions {
+		/**
+		 * Pick from the connected emulators only
+		 */
+		onlyEmulators: boolean;
+		/**
+		 * Pick from the connected real devices only
+		 */
+		onlyDevices: boolean;
+		/**
+		 * Pick a specific device
+		 */
+		deviceId: string;
 	}
 
 	interface IListEmulatorsOptions {
@@ -941,14 +957,6 @@ declare module Mobile {
 		 * @returns {net.Socket} Returns instance of net.Socket when connection is successful, otherwise undefined is returned.
 		 */
 		connectToPort(connectToPortData: IConnectToPortData): Promise<any>;
-
-		/**
-		 * Runs an application on emulator
-		 * @param app The path to executable .app
-		 * @param emulatorOptions Emulator options that can be passed
-		 * @returns {Promise<any>} Returns the appId with the process of the running application on the simulator. For example: org.nativescript.myapp 55434
-		 */
-		runApplicationOnEmulator(app: string, emulatorOptions?: IRunApplicationOnEmulatorOptions): Promise<any>;
 	}
 
 	interface IEmulatorSettingsService {
@@ -1251,9 +1259,9 @@ interface IIOSDeviceOperations extends IDisposable, NodeJS.EventEmitter {
 
 	deleteFiles(deleteArray: IOSDeviceLib.IDeleteFileData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
 
-	start(startArray: IOSDeviceLib.IDdiApplicationData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
+	start(startArray: IOSDeviceLib.IIOSApplicationData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
 
-	stop(stopArray: IOSDeviceLib.IDdiApplicationData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
+	stop(stopArray: IOSDeviceLib.IIOSApplicationData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
 
 	postNotification(postNotificationArray: IOSDeviceLib.IPostNotificationData[], errorHandler?: DeviceOperationErrorHandler): Promise<IOSDeviceResponse>;
 

lib/common/mobile/android/android-application-manager.ts

@@ -47,7 +47,15 @@ export class AndroidApplicationManager extends ApplicationManagerBase {
 		return this.adb.executeShellCommand(["pm", "uninstall", `${appIdentifier}`], { treatErrorsAsWarnings: true });
 	}
 
-	public async startApplication(appData: Mobile.IApplicationData): Promise<void> {
+	public async startApplication(appData: Mobile.IStartApplicationData): Promise<Mobile.IRunningAppInfo> {
+		if (appData.waitForDebugger) {
+			await this.adb.executeShellCommand([`cat /dev/null > ${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appData.appId}-debugbreak`]);
+		}
+
+		if (appData.enableDebugging) {
+			await this.adb.executeShellCommand([`cat /dev/null > ${LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appData.appId}-debugger-started`]);
+		}
+
 		/*
 		Example "pm dump <app_identifier> | grep -A 1 MAIN" output"
 			android.intent.action.MAIN:
@@ -74,9 +82,9 @@ export class AndroidApplicationManager extends ApplicationManagerBase {
 			await this.adb.executeShellCommand(["monkey", "-p", appIdentifier, "-c", "android.intent.category.LAUNCHER", "1"]);
 		}
 
+		const deviceIdentifier = this.identifier;
+		const processIdentifier = await this.getAppProcessId(deviceIdentifier, appIdentifier);
 		if (!this.$options.justlaunch && !appData.justLaunch) {
-			const deviceIdentifier = this.identifier;
-			const processIdentifier = await this.getAppProcessId(deviceIdentifier, appIdentifier);
 			if (processIdentifier) {
 				this.$deviceLogProvider.setApplicationPidForDevice(deviceIdentifier, processIdentifier);
 				await this.$logcatHelper.start({
@@ -88,6 +96,10 @@ export class AndroidApplicationManager extends ApplicationManagerBase {
 				this.$errors.failWithoutHelp(`Unable to find running "${appIdentifier}" application on device "${deviceIdentifier}".`);
 			}
 		}
+
+		return {
+			pid: processIdentifier
+		};
 	}
 
 	private async getAppProcessId(deviceIdentifier: string, appIdentifier: string) {

lib/common/mobile/application-manager-base.ts

@@ -21,9 +21,10 @@ export abstract class ApplicationManagerBase extends EventEmitter implements Mob
 		await this.installApplication(packageFilePath, appIdentifier);
 	}
 
-	public async restartApplication(appData: Mobile.IApplicationData): Promise<void> {
+	public async restartApplication(appData: Mobile.IApplicationData): Promise<Mobile.IRunningAppInfo> {
 		await this.stopApplication(appData);
-		await this.startApplication(appData);
+		const appInfo = await this.startApplication(appData);
+		return appInfo;
 	}
 
 	public async isApplicationInstalled(appIdentifier: string): Promise<boolean> {
@@ -80,7 +81,7 @@ export abstract class ApplicationManagerBase extends EventEmitter implements Mob
 
 	public abstract async installApplication(packageFilePath: string, appIdentifier?: string): Promise<void>;
 	public abstract async uninstallApplication(appIdentifier: string): Promise<void>;
-	public abstract async startApplication(appData: Mobile.IApplicationData): Promise<void>;
+	public abstract async startApplication(appData: Mobile.IApplicationData): Promise<Mobile.IRunningAppInfo>;
 	public abstract async stopApplication(appData: Mobile.IApplicationData): Promise<void>;
 	public abstract async getInstalledApplications(): Promise<string[]>;
 	public abstract async getApplicationInfo(applicationIdentifier: string): Promise<Mobile.IApplicationInfo>;

lib/common/mobile/device-log-provider-base.ts

@@ -26,10 +26,6 @@ export abstract class DeviceLogProviderBase extends EventEmitter implements Mobi
 		this.setLogLevel(logLevel, deviceIdentifier);
 	}
 
-	public muteLogsForDevice(deviceIdentifier: string): void {
-		this.setDeviceLogOptionsProperty(deviceIdentifier, (deviceLogOptions: Mobile.IDeviceLogOptions) => deviceLogOptions.muteLogs, true);
-	}
-
 	protected getApplicationPidForDevice(deviceIdentifier: string): string {
 		return this.devicesLogOptions[deviceIdentifier] && this.devicesLogOptions[deviceIdentifier].applicationPid;
 	}

lib/common/mobile/device-log-provider.ts

@@ -11,7 +11,7 @@ export class DeviceLogProvider extends DeviceLogProviderBase {
 		const loggingOptions = this.getDeviceLogOptionsForDevice(deviceIdentifier);
 		const data = this.$logFilter.filterData(platform, lineText, loggingOptions);
 		if (data) {
-			this.logDataCore(data, loggingOptions);
+			this.logDataCore(data);
 			this.emit(DEVICE_LOG_EVENT_NAME, lineText, deviceIdentifier, platform);
 		}
 	}
@@ -20,10 +20,8 @@ export class DeviceLogProvider extends DeviceLogProviderBase {
 		this.$logFilter.loggingLevel = logLevel.toUpperCase();
 	}
 
-	private logDataCore(data: string, loggingOptions: Mobile.IDeviceLogOptions): void {
-		if (!loggingOptions || (loggingOptions && !loggingOptions.muteLogs)) {
-			this.$logger.write(data);
-		}
+	private logDataCore(data: string): void {
+		this.$logger.write(data);
 	}
 }
 $injector.register("deviceLogProvider", DeviceLogProvider);