Merge pull request #106 from telerik/fatme/async-api

Fatme · web-flow · commit f358b1df8cd9 · 2018-06-29T13:56:55.000+03:00
Make ios-sim API async
diff --git a/lib/commands/device-types.ts b/lib/commands/device-types.ts
@@ -3,7 +3,7 @@
 import iphoneSimulatorLibPath = require("./../iphone-simulator");
 
 export class Command implements ICommand {
-	public execute(args: string[]): void {
+	public execute(args: string[]): Promise<void> {
 		var iphoneSimulator = new iphoneSimulatorLibPath.iPhoneSimulator();
 		return iphoneSimulator.printDeviceTypes();
 	}
diff --git a/lib/commands/launch.ts b/lib/commands/launch.ts
@@ -2,7 +2,7 @@ import iphoneSimulatorLibPath = require("./../iphone-simulator");
 import options = require("../options");
 
 export class Command implements ICommand {
-	public execute(args: string[]): string {
+	public execute(args: string[]): Promise<string> {
 		var iphoneSimulator = new iphoneSimulatorLibPath.iPhoneSimulator();
 		return iphoneSimulator.run(args[0], args[1], options);
 	}
diff --git a/lib/commands/notify-post.ts b/lib/commands/notify-post.ts
@@ -1,7 +1,7 @@
 import iphoneSimulatorLibPath = require("./../iphone-simulator");
 
 export class Command implements ICommand {
-	public execute(args: string[]): void {
+	public execute(args: string[]): Promise<void> {
 		var iphoneSimulator = new iphoneSimulatorLibPath.iPhoneSimulator();
 		return iphoneSimulator.sendNotification(args[0], args[1]);
 	}
diff --git a/lib/commands/sdks.ts b/lib/commands/sdks.ts
@@ -3,7 +3,7 @@
 import iphoneSimulatorLibPath = require("./../iphone-simulator");
 
 export class Command implements ICommand {
-	public execute(args: string[]): void {
+	public execute(args: string[]): Promise<void> {
 		var iphoneSimulator = new iphoneSimulatorLibPath.iPhoneSimulator();
 		return iphoneSimulator.printSDKS();
 	}
diff --git a/lib/declarations.ts b/lib/declarations.ts
@@ -2,10 +2,10 @@
 "use strict";
 
 interface IiPhoneSimulator {
-	run(applicationPath: string, applicationIdentifier: string, options: IOptions): string;
-	printDeviceTypes(): void;
-	printSDKS(): void;
-	sendNotification(notification: string, deviceId: string): void;
+	run(applicationPath: string, applicationIdentifier: string, options: IOptions): Promise<string>;
+	printDeviceTypes(): Promise<void>;
+	printSDKS(): Promise<void>;
+	sendNotification(notification: string, deviceId: string): Promise<void>;
 	createSimulator(): ISimulator;
 }
 
@@ -27,34 +27,34 @@ interface IDevice {
 }
 
 interface ISimctl {
-	launch(deviceId: string, applicationIdentifier: string, options: IOptions): string;
-	boot(deviceId: string): void;
-	terminate(deviceId: string, appIdentifier: string): string;
-	install(deviceId: string, applicationPath: string): void;
-	uninstall(deviceId: string, applicationIdentifier: string, opts?: any): void;
-	notifyPost(deviceId: string, notification: string): void;
-	getDevices(): IDevice[];
+	launch(deviceId: string, applicationIdentifier: string, options: IOptions): Promise<string>;
+	boot(deviceId: string): Promise<void>;
+	terminate(deviceId: string, appIdentifier: string): Promise<string>;
+	install(deviceId: string, applicationPath: string): Promise<void>;
+	uninstall(deviceId: string, applicationIdentifier: string, opts?: any): Promise<void>;
+	notifyPost(deviceId: string, notification: string): Promise<void>;
+	getDevices(): Promise<IDevice[]>;
 	getLog(deviceId: string, predicate?: string): any;
-	getAppContainer(deviceId: string, applicationIdentifier: string): string;
+	getAppContainer(deviceId: string, applicationIdentifier: string): Promise<string>;
 }
 
 interface IDictionary<T> {
 	[key: string]: T;
 }
 
 interface ISimulator extends INameGetter {
-	getDevices(): IDevice[];
-	getSdks(): ISdk[];
-	run(applicationPath: string, applicationIdentifier: string, options: IOptions): string;
-	sendNotification(notification: string, deviceId: string): void;
-	getApplicationPath(deviceId: string, applicationIdentifier: string): string;
+	getDevices(): Promise<IDevice[]>;
+	getSdks(): Promise<ISdk[]>;
+	run(applicationPath: string, applicationIdentifier: string, options: IOptions): Promise<string>;
+	sendNotification(notification: string, deviceId: string): Promise<void>;
+	getApplicationPath(deviceId: string, applicationIdentifier: string): Promise<string>;
 	getInstalledApplications(deviceId: string): IApplication[];
-	installApplication(deviceId: string, applicationPath: string): void;
-	uninstallApplication(deviceId: string, appIdentifier: string): void;
-	startApplication(deviceId: string, appIdentifier: string, options: IOptions): string;
-	stopApplication(deviceId: string, appIdentifier: string, bundleExecutable: string): string;
-	getDeviceLogProcess(deviceId: string): any;
-	startSimulator(options: IOptions, device?: IDevice): void;
+	installApplication(deviceId: string, applicationPath: string): Promise<void>;
+	uninstallApplication(deviceId: string, appIdentifier: string): Promise<void>;
+	startApplication(deviceId: string, appIdentifier: string, options: IOptions): Promise<string>;
+	stopApplication(deviceId: string, appIdentifier: string, bundleExecutable: string): Promise<string>;
+	getDeviceLogProcess(deviceId: string): Promise<any>;
+	startSimulator(options: IOptions, device?: IDevice): Promise<void>;
 }
 
 interface INameGetter {
diff --git a/lib/ios-sim.ts b/lib/ios-sim.ts
@@ -52,13 +52,13 @@ Object.defineProperty(publicApi, "getRunningSimulators", {
 		return (...args: any[]) => {
 			let isResolved = false;
 
-			return new Promise<any>((resolve, reject) => {
+			return new Promise<any>(async (resolve, reject) => {
 				const libraryPath = require("./iphone-simulator-xcode-simctl");
 				const simulator = new libraryPath.XCodeSimctlSimulator();
-
-				const tryGetBootedDevices = () => {
+				
+				const tryGetBootedDevices = async () => {
 					try {
-						return simulator.getBootedDevices.apply(simulator, args);
+						return await simulator.getBootedDevices.apply(simulator, args);
 					} catch (err) {
 						if (!isResolved) {
 							isResolved = true;
@@ -67,17 +67,16 @@ Object.defineProperty(publicApi, "getRunningSimulators", {
 					}
 				}
 
-				let result = tryGetBootedDevices();
+				let result = await tryGetBootedDevices();
 				if (result && result.length) {
 					isResolved = true;
 					resolve(result);
 					return;
 				}
 
 				if (!isResolved && (!result || !result.length)) {
-					const timer = setTimeout(() => {
-						result = tryGetBootedDevices();
-
+					const timer = setTimeout(async () => {
+						result = await tryGetBootedDevices();
 						if (!isResolved) {
 							isResolved = true;
 							resolve(result);
diff --git a/lib/iphone-simulator-xcode-simctl.ts b/lib/iphone-simulator-xcode-simctl.ts
@@ -30,12 +30,12 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I
 		this.simctl = new Simctl();
 	}
 
-	public getDevices(): IDevice[] {
+	public getDevices(): Promise<IDevice[]> {
 		return this.simctl.getDevices();
 	}
 
-	public getSdks(): ISdk[] {
-		let devices = this.simctl.getDevices();
+	public async getSdks(): Promise<ISdk[]> {
+		let devices = await this.simctl.getDevices();
 		return _.map(devices, device => {
 			return {
 				displayName: `iOS ${device.runtimeVersion}`,
@@ -44,8 +44,8 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I
 		});
 	}
 
-	public run(applicationPath: string, applicationIdentifier: string, options: IOptions): string {
-		const device = this.getDeviceToRun(options);
+	public async run(applicationPath: string, applicationIdentifier: string, options: IOptions): Promise<string> {
+		const device = await this.getDeviceToRun(options);
 
 		this.startSimulator(options, device);
 		if (!options.skipInstall) {
@@ -55,40 +55,41 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I
 		return this.simctl.launch(device.id, applicationIdentifier, options);
 	}
 
-	public sendNotification(notification: string, deviceId: string): void {
+	public sendNotification(notification: string, deviceId: string): Promise<void> {
 		let device = this.getDeviceFromIdentifier(deviceId);
+
 		if (!device) {
 			errors.fail("Could not find device.");
 		}
 
-		this.simctl.notifyPost(deviceId, notification);
+		return this.simctl.notifyPost(deviceId, notification);
 	}
 
-	public getApplicationPath(deviceId: string, applicationIdentifier: string): string {
+	public getApplicationPath(deviceId: string, applicationIdentifier: string): Promise<string> {
 		return this.simctl.getAppContainer(deviceId, applicationIdentifier);
 	}
 
 	public getInstalledApplications(deviceId: string): IApplication[] {
 		return common.getInstalledApplications(deviceId);
 	}
 
-	public installApplication(deviceId: string, applicationPath: string): void {
+	public installApplication(deviceId: string, applicationPath: string): Promise<void> {
 		return this.simctl.install(deviceId, applicationPath);
 	}
 
-	public uninstallApplication(deviceId: string, appIdentifier: string): void {
+	public uninstallApplication(deviceId: string, appIdentifier: string):  Promise<void> {
 		return this.simctl.uninstall(deviceId, appIdentifier, { skipError: true });
 	}
 
-	public startApplication(deviceId: string, appIdentifier: string, options: IOptions): string {
+	public async startApplication(deviceId: string, appIdentifier: string, options: IOptions): Promise<string> {
 		// simctl launch command does not launch the process immediately and we have to wait a little bit,
 		// just to ensure all related processes and services are alive.
-		const launchResult = this.simctl.launch(deviceId, appIdentifier, options);
+		const launchResult = await this.simctl.launch(deviceId, appIdentifier, options);
 		utils.sleep(0.5);
 		return launchResult;
 	}
 
-	public stopApplication(deviceId: string, appIdentifier: string, bundleExecutable: string): string {
+	public async stopApplication(deviceId: string, appIdentifier: string, bundleExecutable: string): Promise<string> {
 		try {
 			let xcodeMajorVersion: number = null;
 			try {
@@ -103,7 +104,7 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I
 				// Xcode 7.x does not have support for `xcrun simctl terminate` command
 				resultOfTermination = childProcess.execSync(`killall ${bundleExecutable}`, { skipError: true });
 			} else {
-				resultOfTermination = this.simctl.terminate(deviceId, appIdentifier);
+				resultOfTermination = await this.simctl.terminate(deviceId, appIdentifier);
 			}
 
 			// killall command does not terminate the processes immediately and we have to wait a little bit,
@@ -116,9 +117,9 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I
 		}
 	}
 
-	public getDeviceLogProcess(deviceId: string, predicate?: string): child_process.ChildProcess {
+	public async getDeviceLogProcess(deviceId: string, predicate?: string): Promise<child_process.ChildProcess> {
 		if (!this.isDeviceLogOperationStarted) {
-			const device = this.getDeviceFromIdentifier(deviceId);
+			const device = await this.getDeviceFromIdentifier(deviceId);
 			const deviceVersion = device ? device.runtimeVersion : "";
 			const majorVersion = deviceVersion.split(".")[0];
 
@@ -135,8 +136,8 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I
 		return this.deviceLogChildProcess;
 	}
 
-	private getDeviceToRun(options: IOptions, device?: any): IDevice {
-		let devices = _.sortBy(this.simctl.getDevices(), (device) => device.runtimeVersion),
+	private async getDeviceToRun(options: IOptions, device?: any): Promise<IDevice> {
+		let devices = _.sortBy(await this.simctl.getDevices(), (device) => device.runtimeVersion),
 			sdkVersion = options.sdkVersion || options.sdk,
 			deviceIdOrName = options.device;
 
@@ -181,30 +182,30 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I
 		return device.state === 'Booted';
 	}
 
-	private getBootedDevice(): IDevice {
-		let devices = this.simctl.getDevices();
+	private async getBootedDevice(): Promise<IDevice> {
+		let devices = await this.simctl.getDevices();
 		return _.find(devices, device => this.isDeviceBooted(device));
 	}
 
-	private getBootedDevices(): IDevice[] {
-		const devices = this.simctl.getDevices();
+	private async getBootedDevices(): Promise<IDevice[]> {
+		const devices = await this.simctl.getDevices();
 		return _.filter(devices, device => this.isDeviceBooted(device));
 	}
 
-	public startSimulator(options: IOptions, device?: IDevice): void {
+	public async startSimulator(options: IOptions, device?: IDevice): Promise<void> {
 		if (!device && options.device) {
 			this.verifyDevice(options.device);
 		}
 		
-		device = device || this.getDeviceToRun(options);
+		device = device || await this.getDeviceToRun(options);
 
 		// In case the id is undefined, skip verification - we'll start default simulator.
 		if (device && device.id) {
 			this.verifyDevice(device);
 		}
 
 		if (!device || !device.runtimeVersion || !device.fullId) {
-			device = this.getDeviceToRun(options, device);
+			device = await this.getDeviceToRun(options, device);
 		}
 
 		if (!this.isDeviceBooted(device)) {
@@ -214,7 +215,7 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I
 			if (isSimulatorAppRunning) {
 				// In case user closes simulator window but simulator app is still alive
 				if (!haveBootedDevices) {
-					device = this.getDeviceToRun(options);
+					device = await this.getDeviceToRun(options);
 				}
 				this.simctl.boot(device.id);
 			} else {
@@ -229,8 +230,8 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I
 		}
 	}
 
-	private haveBootedDevices(): boolean {
-		const bootedDevices = this.getBootedDevices();
+	private async haveBootedDevices(): Promise<boolean> {
+		const bootedDevices = await this.getBootedDevices();
 		return bootedDevices && bootedDevices.length > 0;
 	}
 
@@ -245,16 +246,16 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I
 		}
 	}
 
-	private verifyDevice(device: IDevice | string): void {
-		const availableDevices = this.getDevices();
+	private async verifyDevice(device: IDevice | string): Promise<void> {
+		const availableDevices = await this.getDevices();
 		const deviceId = (<IDevice>device).id || device;
 		if (!_.find(availableDevices, { id: deviceId }) && !_.find(availableDevices, { name: deviceId })) {
 			errors.fail(`No simulator image available for device identifier '${deviceId}'.`);
 		}
 	}
 
-	private getDeviceFromIdentifier(deviceId: string) {
-		const availableDevices = this.getDevices();
+	private async getDeviceFromIdentifier(deviceId: string) {
+		const availableDevices = await this.getDevices();
 
 		return _.find(availableDevices, { id: deviceId });
 	}
diff --git a/lib/iphone-simulator.ts b/lib/iphone-simulator.ts
@@ -18,21 +18,21 @@ export class iPhoneSimulator implements IiPhoneSimulator {
 		this.simulator = this.createSimulator();
 	}
 
-	public run(applicationPath: string, applicationIdentifier: string, options: IOptions): string {
+	public async run(applicationPath: string, applicationIdentifier: string, options: IOptions): Promise<string> {
 		if (!fs.existsSync(applicationPath)) {
 			errors.fail("Path does not exist ", applicationPath);
 		}
 
 		if (options.device) {
-			const hasSuchDevice = _.find(this.simulator.getDevices(), device => device.name === options.device || device.id === options.device);
+			const hasSuchDevice = _.find(await this.simulator.getDevices(), device => device.name === options.device || device.id === options.device);
 			if (!hasSuchDevice) {
 				errors.fail(`Unable to find device ${options.device}.`);
 			}
 		}
 
 		let sdkVersion = options.sdkVersion || options.sdk;
 		if (sdkVersion) {
-			let runtimeVersions = _.unique(_.map(this.simulator.getDevices(), (device: IDevice) => device.runtimeVersion));
+			let runtimeVersions = _.unique(_.map(await this.simulator.getDevices(), (device: IDevice) => device.runtimeVersion));
 			if (!_.contains(runtimeVersions, sdkVersion)) {
 				errors.fail(`Unable to find sdk ${sdkVersion}. The valid runtime versions are ${runtimeVersions.join(", ")}`);
 			}
@@ -41,13 +41,13 @@ export class iPhoneSimulator implements IiPhoneSimulator {
 		return this.simulator.run(applicationPath, applicationIdentifier, options);
 	}
 
-	public printDeviceTypes(): void {
-		let devices = this.simulator.getDevices();
+	public async printDeviceTypes(): Promise<void> {
+		let devices = await this.simulator.getDevices();
 		_.each(devices, device => console.log(`Device Identifier: ${device.fullId}. ${os.EOL}Runtime version: ${device.runtimeVersion} ${os.EOL}`));
 	}
 
-	public printSDKS(): void {
-		let sdks = this.simulator.getSdks();
+	public async printSDKS(): Promise<void> {
+		let sdks = await this.simulator.getSdks();
 		_.each(sdks, (sdk) => {
 			let output = `    Display Name: ${sdk.displayName} ${os.EOL}    Version: ${sdk.version} ${os.EOL}`;
 			if (sdk.rootPath) {
@@ -57,7 +57,7 @@ export class iPhoneSimulator implements IiPhoneSimulator {
 		});
 	}
 
-	public sendNotification(notification: string, deviceId: string): void {
+	public sendNotification(notification: string, deviceId: string): Promise<void> {
 		if (!notification) {
 			errors.fail("Notification required.");
 		}
diff --git a/lib/simctl.ts b/lib/simctl.ts

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`import iphoneSimulatorLibPath = require("./../iphone-simulator");`
`4`	`4`
`5`	`5`	`export class Command implements ICommand {`
`6`		`- public execute(args: string[]): void {`
	`6`	`+ public execute(args: string[]): Promise<void> {`
`7`	`7`	`var iphoneSimulator = new iphoneSimulatorLibPath.iPhoneSimulator();`
`8`	`8`	`return iphoneSimulator.printDeviceTypes();`
`9`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ import iphoneSimulatorLibPath = require("./../iphone-simulator");`
`2`	`2`	`import options = require("../options");`
`3`	`3`
`4`	`4`	`export class Command implements ICommand {`
`5`		`- public execute(args: string[]): string {`
	`5`	`+ public execute(args: string[]): Promise<string> {`
`6`	`6`	`var iphoneSimulator = new iphoneSimulatorLibPath.iPhoneSimulator();`
`7`	`7`	`return iphoneSimulator.run(args[0], args[1], options);`
`8`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`import iphoneSimulatorLibPath = require("./../iphone-simulator");`
`2`	`2`
`3`	`3`	`export class Command implements ICommand {`
`4`		`- public execute(args: string[]): void {`
	`4`	`+ public execute(args: string[]): Promise<void> {`
`5`	`5`	`var iphoneSimulator = new iphoneSimulatorLibPath.iPhoneSimulator();`
`6`	`6`	`return iphoneSimulator.sendNotification(args[0], args[1]);`
`7`	`7`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,12 +30,12 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I`
`30`	`30`	`this.simctl = new Simctl();`
`31`	`31`	`}`
`32`	`32`
`33`		`- public getDevices(): IDevice[] {`
	`33`	`+ public getDevices(): Promise<IDevice[]> {`
`34`	`34`	`return this.simctl.getDevices();`
`35`	`35`	`}`
`36`	`36`
`37`		`- public getSdks(): ISdk[] {`
`38`		`- let devices = this.simctl.getDevices();`
	`37`	`+ public async getSdks(): Promise<ISdk[]> {`
	`38`	`+ let devices = await this.simctl.getDevices();`
`39`	`39`	`return _.map(devices, device => {`
`40`	`40`	`return {`
`41`	`41`	displayName: `iOS ${device.runtimeVersion}`,
`@@ -44,8 +44,8 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I`
`44`	`44`	`});`
`45`	`45`	`}`
`46`	`46`
`47`		`- public run(applicationPath: string, applicationIdentifier: string, options: IOptions): string {`
`48`		`- const device = this.getDeviceToRun(options);`
	`47`	`+ public async run(applicationPath: string, applicationIdentifier: string, options: IOptions): Promise<string> {`
	`48`	`+ const device = await this.getDeviceToRun(options);`
`49`	`49`
`50`	`50`	`this.startSimulator(options, device);`
`51`	`51`	`if (!options.skipInstall) {`
`@@ -55,40 +55,41 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I`
`55`	`55`	`return this.simctl.launch(device.id, applicationIdentifier, options);`
`56`	`56`	`}`
`57`	`57`
`58`		`- public sendNotification(notification: string, deviceId: string): void {`
	`58`	`+ public sendNotification(notification: string, deviceId: string): Promise<void> {`
`59`	`59`	`let device = this.getDeviceFromIdentifier(deviceId);`
	`60`	`+`
`60`	`61`	`if (!device) {`
`61`	`62`	`errors.fail("Could not find device.");`
`62`	`63`	`}`
`63`	`64`
`64`		`- this.simctl.notifyPost(deviceId, notification);`
	`65`	`+ return this.simctl.notifyPost(deviceId, notification);`
`65`	`66`	`}`
`66`	`67`
`67`		`- public getApplicationPath(deviceId: string, applicationIdentifier: string): string {`
	`68`	`+ public getApplicationPath(deviceId: string, applicationIdentifier: string): Promise<string> {`
`68`	`69`	`return this.simctl.getAppContainer(deviceId, applicationIdentifier);`
`69`	`70`	`}`
`70`	`71`
`71`	`72`	`public getInstalledApplications(deviceId: string): IApplication[] {`
`72`	`73`	`return common.getInstalledApplications(deviceId);`
`73`	`74`	`}`
`74`	`75`
`75`		`- public installApplication(deviceId: string, applicationPath: string): void {`
	`76`	`+ public installApplication(deviceId: string, applicationPath: string): Promise<void> {`
`76`	`77`	`return this.simctl.install(deviceId, applicationPath);`
`77`	`78`	`}`
`78`	`79`
`79`		`- public uninstallApplication(deviceId: string, appIdentifier: string): void {`
	`80`	`+ public uninstallApplication(deviceId: string, appIdentifier: string): Promise<void> {`
`80`	`81`	`return this.simctl.uninstall(deviceId, appIdentifier, { skipError: true });`
`81`	`82`	`}`
`82`	`83`
`83`		`- public startApplication(deviceId: string, appIdentifier: string, options: IOptions): string {`
	`84`	`+ public async startApplication(deviceId: string, appIdentifier: string, options: IOptions): Promise<string> {`
`84`	`85`	`// simctl launch command does not launch the process immediately and we have to wait a little bit,`
`85`	`86`	`// just to ensure all related processes and services are alive.`
`86`		`- const launchResult = this.simctl.launch(deviceId, appIdentifier, options);`
	`87`	`+ const launchResult = await this.simctl.launch(deviceId, appIdentifier, options);`
`87`	`88`	`utils.sleep(0.5);`
`88`	`89`	`return launchResult;`
`89`	`90`	`}`
`90`	`91`
`91`		`- public stopApplication(deviceId: string, appIdentifier: string, bundleExecutable: string): string {`
	`92`	`+ public async stopApplication(deviceId: string, appIdentifier: string, bundleExecutable: string): Promise<string> {`
`92`	`93`	`try {`
`93`	`94`	`let xcodeMajorVersion: number = null;`
`94`	`95`	`try {`
`@@ -103,7 +104,7 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I`
`103`	`104`	// Xcode 7.x does not have support for `xcrun simctl terminate` command
`104`	`105`	resultOfTermination = childProcess.execSync(`killall ${bundleExecutable}`, { skipError: true });
`105`	`106`	`} else {`
`106`		`- resultOfTermination = this.simctl.terminate(deviceId, appIdentifier);`
	`107`	`+ resultOfTermination = await this.simctl.terminate(deviceId, appIdentifier);`
`107`	`108`	`}`
`108`	`109`
`109`	`110`	`// killall command does not terminate the processes immediately and we have to wait a little bit,`
`@@ -116,9 +117,9 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I`
`116`	`117`	`}`
`117`	`118`	`}`
`118`	`119`
`119`		`- public getDeviceLogProcess(deviceId: string, predicate?: string): child_process.ChildProcess {`
	`120`	`+ public async getDeviceLogProcess(deviceId: string, predicate?: string): Promise<child_process.ChildProcess> {`
`120`	`121`	`if (!this.isDeviceLogOperationStarted) {`
`121`		`- const device = this.getDeviceFromIdentifier(deviceId);`
	`122`	`+ const device = await this.getDeviceFromIdentifier(deviceId);`
`122`	`123`	`const deviceVersion = device ? device.runtimeVersion : "";`
`123`	`124`	`const majorVersion = deviceVersion.split(".")[0];`
`124`	`125`
`@@ -135,8 +136,8 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I`
`135`	`136`	`return this.deviceLogChildProcess;`
`136`	`137`	`}`
`137`	`138`
`138`		`- private getDeviceToRun(options: IOptions, device?: any): IDevice {`
`139`		`- let devices = _.sortBy(this.simctl.getDevices(), (device) => device.runtimeVersion),`
	`139`	`+ private async getDeviceToRun(options: IOptions, device?: any): Promise<IDevice> {`
	`140`	`+ let devices = _.sortBy(await this.simctl.getDevices(), (device) => device.runtimeVersion),`
`140`	`141`	`sdkVersion = options.sdkVersion \|\| options.sdk,`
`141`	`142`	`deviceIdOrName = options.device;`
`142`	`143`
`@@ -181,30 +182,30 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I`
`181`	`182`	`return device.state === 'Booted';`
`182`	`183`	`}`
`183`	`184`
`184`		`- private getBootedDevice(): IDevice {`
`185`		`- let devices = this.simctl.getDevices();`
	`185`	`+ private async getBootedDevice(): Promise<IDevice> {`
	`186`	`+ let devices = await this.simctl.getDevices();`
`186`	`187`	`return _.find(devices, device => this.isDeviceBooted(device));`
`187`	`188`	`}`
`188`	`189`
`189`		`- private getBootedDevices(): IDevice[] {`
`190`		`- const devices = this.simctl.getDevices();`
	`190`	`+ private async getBootedDevices(): Promise<IDevice[]> {`
	`191`	`+ const devices = await this.simctl.getDevices();`
`191`	`192`	`return _.filter(devices, device => this.isDeviceBooted(device));`
`192`	`193`	`}`
`193`	`194`
`194`		`- public startSimulator(options: IOptions, device?: IDevice): void {`
	`195`	`+ public async startSimulator(options: IOptions, device?: IDevice): Promise<void> {`
`195`	`196`	`if (!device && options.device) {`
`196`	`197`	`this.verifyDevice(options.device);`
`197`	`198`	`}`
`198`	`199`
`199`		`- device = device \|\| this.getDeviceToRun(options);`
	`200`	`+ device = device \|\| await this.getDeviceToRun(options);`
`200`	`201`
`201`	`202`	`// In case the id is undefined, skip verification - we'll start default simulator.`
`202`	`203`	`if (device && device.id) {`
`203`	`204`	`this.verifyDevice(device);`
`204`	`205`	`}`
`205`	`206`
`206`	`207`	`if (!device \|\| !device.runtimeVersion \|\| !device.fullId) {`
`207`		`- device = this.getDeviceToRun(options, device);`
	`208`	`+ device = await this.getDeviceToRun(options, device);`
`208`	`209`	`}`
`209`	`210`
`210`	`211`	`if (!this.isDeviceBooted(device)) {`
`@@ -214,7 +215,7 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I`
`214`	`215`	`if (isSimulatorAppRunning) {`
`215`	`216`	`// In case user closes simulator window but simulator app is still alive`
`216`	`217`	`if (!haveBootedDevices) {`
`217`		`- device = this.getDeviceToRun(options);`
	`218`	`+ device = await this.getDeviceToRun(options);`
`218`	`219`	`}`
`219`	`220`	`this.simctl.boot(device.id);`
`220`	`221`	`} else {`
`@@ -229,8 +230,8 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I`
`229`	`230`	`}`
`230`	`231`	`}`
`231`	`232`
`232`		`- private haveBootedDevices(): boolean {`
`233`		`- const bootedDevices = this.getBootedDevices();`
	`233`	`+ private async haveBootedDevices(): Promise<boolean> {`
	`234`	`+ const bootedDevices = await this.getBootedDevices();`
`234`	`235`	`return bootedDevices && bootedDevices.length > 0;`
`235`	`236`	`}`
`236`	`237`
`@@ -245,16 +246,16 @@ export class XCodeSimctlSimulator extends IPhoneSimulatorNameGetter implements I`
`245`	`246`	`}`
`246`	`247`	`}`
`247`	`248`
`248`		`- private verifyDevice(device: IDevice \| string): void {`
`249`		`- const availableDevices = this.getDevices();`
	`249`	`+ private async verifyDevice(device: IDevice \| string): Promise<void> {`
	`250`	`+ const availableDevices = await this.getDevices();`
`250`	`251`	`const deviceId = (<IDevice>device).id \|\| device;`
`251`	`252`	`if (!_.find(availableDevices, { id: deviceId }) && !_.find(availableDevices, { name: deviceId })) {`
`252`	`253`	errors.fail(`No simulator image available for device identifier '${deviceId}'.`);
`253`	`254`	`}`
`254`	`255`	`}`
`255`	`256`
`256`		`- private getDeviceFromIdentifier(deviceId: string) {`
`257`		`- const availableDevices = this.getDevices();`
	`257`	`+ private async getDeviceFromIdentifier(deviceId: string) {`
	`258`	`+ const availableDevices = await this.getDevices();`
`258`	`259`
`259`	`260`	`return _.find(availableDevices, { id: deviceId });`
`260`	`261`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,21 +18,21 @@ export class iPhoneSimulator implements IiPhoneSimulator {`
`18`	`18`	`this.simulator = this.createSimulator();`
`19`	`19`	`}`
`20`	`20`
`21`		`- public run(applicationPath: string, applicationIdentifier: string, options: IOptions): string {`
	`21`	`+ public async run(applicationPath: string, applicationIdentifier: string, options: IOptions): Promise<string> {`
`22`	`22`	`if (!fs.existsSync(applicationPath)) {`
`23`	`23`	`errors.fail("Path does not exist ", applicationPath);`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`if (options.device) {`
`27`		`- const hasSuchDevice = _.find(this.simulator.getDevices(), device => device.name === options.device \|\| device.id === options.device);`
	`27`	`+ const hasSuchDevice = _.find(await this.simulator.getDevices(), device => device.name === options.device \|\| device.id === options.device);`
`28`	`28`	`if (!hasSuchDevice) {`
`29`	`29`	errors.fail(`Unable to find device ${options.device}.`);
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`let sdkVersion = options.sdkVersion \|\| options.sdk;`
`34`	`34`	`if (sdkVersion) {`
`35`		`- let runtimeVersions = _.unique(_.map(this.simulator.getDevices(), (device: IDevice) => device.runtimeVersion));`
	`35`	`+ let runtimeVersions = _.unique(_.map(await this.simulator.getDevices(), (device: IDevice) => device.runtimeVersion));`
`36`	`36`	`if (!_.contains(runtimeVersions, sdkVersion)) {`
`37`	`37`	errors.fail(`Unable to find sdk ${sdkVersion}. The valid runtime versions are ${runtimeVersions.join(", ")}`);
`38`	`38`	`}`
`@@ -41,13 +41,13 @@ export class iPhoneSimulator implements IiPhoneSimulator {`
`41`	`41`	`return this.simulator.run(applicationPath, applicationIdentifier, options);`
`42`	`42`	`}`
`43`	`43`
`44`		`- public printDeviceTypes(): void {`
`45`		`- let devices = this.simulator.getDevices();`
	`44`	`+ public async printDeviceTypes(): Promise<void> {`
	`45`	`+ let devices = await this.simulator.getDevices();`
`46`	`46`	_.each(devices, device => console.log(`Device Identifier: ${device.fullId}. ${os.EOL}Runtime version: ${device.runtimeVersion} ${os.EOL}`));
`47`	`47`	`}`
`48`	`48`
`49`		`- public printSDKS(): void {`
`50`		`- let sdks = this.simulator.getSdks();`
	`49`	`+ public async printSDKS(): Promise<void> {`
	`50`	`+ let sdks = await this.simulator.getSdks();`
`51`	`51`	`_.each(sdks, (sdk) => {`
`52`	`52`	let output = ` Display Name: ${sdk.displayName} ${os.EOL} Version: ${sdk.version} ${os.EOL}`;
`53`	`53`	`if (sdk.rootPath) {`
`@@ -57,7 +57,7 @@ export class iPhoneSimulator implements IiPhoneSimulator {`
`57`	`57`	`});`
`58`	`58`	`}`
`59`	`59`
`60`		`- public sendNotification(notification: string, deviceId: string): void {`
	`60`	`+ public sendNotification(notification: string, deviceId: string): Promise<void> {`
`61`	`61`	`if (!notification) {`
`62`	`62`	`errors.fail("Notification required.");`
`63`	`63`	`}`