nativescript 8.9.0-dev.2 → 8.9.0-dev.3

package/lib/common/mobile/mobile-core/devices-service.js

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DevicesService = void 0;
 const assert = require("assert");
@@ -63,111 +54,101 @@ class DevicesService extends events_1.EventEmitter {
             this.$iOSSimulatorDiscovery,
         ];
     }
-    pickSingleDevice(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (options.onlyDevices && options.onlyEmulators) {
-                this.$errors.fail(constants_1.DebugCommandErrors.UNABLE_TO_USE_FOR_DEVICE_AND_EMULATOR);
-            }
-            if (options.deviceId) {
-                const device = yield this.getDevice(options.deviceId);
-                return device;
+    async pickSingleDevice(options) {
+        if (options.onlyDevices && options.onlyEmulators) {
+            this.$errors.fail(constants_1.DebugCommandErrors.UNABLE_TO_USE_FOR_DEVICE_AND_EMULATOR);
+        }
+        if (options.deviceId) {
+            const device = await this.getDevice(options.deviceId);
+            return device;
+        }
+        const availableDevicesAndEmulators = this.getDeviceInstances().filter((d) => d.deviceInfo.status === constants_2.CONNECTED_STATUS &&
+            (!this.platform ||
+                d.deviceInfo.platform.toLowerCase() === this.platform.toLowerCase()));
+        const selectedDevices = availableDevicesAndEmulators.filter((d) => options.onlyEmulators
+            ? d.isEmulator
+            : options.onlyDevices
+                ? !d.isEmulator
+                : true);
+        if (selectedDevices.length > 1) {
+            if ((0, helpers_1.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;
             }
-            // Now let's take data for each device:
-            const availableDevicesAndEmulators = this.getDeviceInstances().filter((d) => d.deviceInfo.status === constants_2.CONNECTED_STATUS &&
-                (!this.platform ||
-                    d.deviceInfo.platform.toLowerCase() === this.platform.toLowerCase()));
-            const selectedDevices = availableDevicesAndEmulators.filter((d) => options.onlyEmulators
-                ? d.isEmulator
-                : options.onlyDevices
-                    ? !d.isEmulator
-                    : true);
-            if (selectedDevices.length > 1) {
-                if ((0, helpers_1.isInteractive)()) {
-                    const choices = selectedDevices.map((e) => `${e.deviceInfo.identifier} - ${e.deviceInfo.displayName}`);
-                    const selectedDeviceString = yield 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;
+                if (options.onlyEmulators || options.onlyDevices) {
+                    selectedInstance = _.last(sortedInstances);
                 }
                 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;
-                    if (options.onlyEmulators || options.onlyDevices) {
-                        // 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);
+                    if (emulators.length) {
+                        selectedInstance = _.last(emulators);
                     }
                     else {
-                        if (emulators.length) {
-                            selectedInstance = _.last(emulators);
-                        }
-                        else {
-                            selectedInstance = _.last(devices);
-                        }
+                        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;
                 }
+                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.fail(constants_1.DebugCommandErrors.NO_DEVICES_EMULATORS_FOUND_FOR_OPTIONS);
-        });
+        }
+        else if (selectedDevices.length === 1) {
+            return _.head(selectedDevices);
+        }
+        this.$errors.fail(constants_1.DebugCommandErrors.NO_DEVICES_EMULATORS_FOUND_FOR_OPTIONS);
     }
-    getEmulatorImages(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = Object.create(null);
-            if (this.$hostInfo.isDarwin &&
-                (!options ||
-                    !options.platform ||
-                    this.$mobileHelper.isiOSPlatform(options.platform))) {
-                result.ios = yield this.$iOSEmulatorServices.getEmulatorImages();
-            }
-            if (!options ||
+    async getEmulatorImages(options) {
+        const result = Object.create(null);
+        if (this.$hostInfo.isDarwin &&
+            (!options ||
                 !options.platform ||
-                this.$mobileHelper.isAndroidPlatform(options.platform)) {
-                result.android = yield this.$androidEmulatorServices.getEmulatorImages();
-            }
-            return result;
-        });
+                this.$mobileHelper.isiOSPlatform(options.platform))) {
+            result.ios = await this.$iOSEmulatorServices.getEmulatorImages();
+        }
+        if (!options ||
+            !options.platform ||
+            this.$mobileHelper.isAndroidPlatform(options.platform)) {
+            result.android = await this.$androidEmulatorServices.getEmulatorImages();
+        }
+        return result;
     }
-    startEmulator(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!options || (!options.imageIdentifier && !options.emulatorIdOrName)) {
-                return ["Missing mandatory image identifier or name option."];
-            }
-            const availableEmulatorsOutput = yield this.getEmulatorImages({
-                platform: options.platform,
-            });
-            const emulators = this.$emulatorHelper.getEmulatorsFromAvailableEmulatorsOutput(availableEmulatorsOutput);
-            const errors = this.$emulatorHelper.getErrorsFromAvailableEmulatorsOutput(availableEmulatorsOutput);
-            let emulator = null;
-            if (options.imageIdentifier) {
-                emulator = this.$emulatorHelper.getEmulatorByImageIdentifier(options.imageIdentifier, emulators);
-            }
-            else if (options.emulatorIdOrName) {
-                emulator = this.$emulatorHelper.getEmulatorByIdOrName(options.emulatorIdOrName, emulators);
-            }
-            if (!emulator) {
-                const additionalErrors = errors && errors.length ? errors : [];
-                return [
-                    `Unable to find emulator with provided options: ${options}`,
-                    ...additionalErrors,
-                ];
-            }
-            // emulator is already running
-            if (emulator.status === constants.RUNNING_EMULATOR_STATUS) {
-                return null;
-            }
-            options.emulator = emulator;
-            const emulatorService = this.resolveEmulatorServices(emulator.platform);
-            const result = yield emulatorService.startEmulator(options);
-            return result.errors && result.errors.length ? result.errors : null;
+    async startEmulator(options) {
+        if (!options || (!options.imageIdentifier && !options.emulatorIdOrName)) {
+            return ["Missing mandatory image identifier or name option."];
+        }
+        const availableEmulatorsOutput = await this.getEmulatorImages({
+            platform: options.platform,
         });
+        const emulators = this.$emulatorHelper.getEmulatorsFromAvailableEmulatorsOutput(availableEmulatorsOutput);
+        const errors = this.$emulatorHelper.getErrorsFromAvailableEmulatorsOutput(availableEmulatorsOutput);
+        let emulator = null;
+        if (options.imageIdentifier) {
+            emulator = this.$emulatorHelper.getEmulatorByImageIdentifier(options.imageIdentifier, emulators);
+        }
+        else if (options.emulatorIdOrName) {
+            emulator = this.$emulatorHelper.getEmulatorByIdOrName(options.emulatorIdOrName, emulators);
+        }
+        if (!emulator) {
+            const additionalErrors = errors && errors.length ? errors : [];
+            return [
+                `Unable to find emulator with provided options: ${options}`,
+                ...additionalErrors,
+            ];
+        }
+        if (emulator.status === constants.RUNNING_EMULATOR_STATUS) {
+            return null;
+        }
+        options.emulator = emulator;
+        const emulatorService = this.resolveEmulatorServices(emulator.platform);
+        const result = await emulatorService.startEmulator(options);
+        return result.errors && result.errors.length ? result.errors : null;
     }
     get platform() {
         return this._platform;
@@ -192,11 +173,9 @@ class DevicesService extends events_1.EventEmitter {
         return !!(this.$mobileHelper.isiOSPlatform(device.deviceInfo.platform) &&
             device.isEmulator);
     }
-    /* tslint:disable:no-unused-variable */
     setLogLevel(logLevel, deviceIdentifier) {
         this.$deviceLogProvider.setLogLevel(logLevel, deviceIdentifier);
     }
-    /* tslint:enable:no-unused-variable */
     isAppInstalledOnDevices(deviceIdentifiers, appId, projectName, projectDir) {
         this.$logger.trace(`Called isInstalledOnDevices for identifiers ${deviceIdentifiers}. AppIdentifier is ${appId}.`);
         return _.map(deviceIdentifiers, (deviceIdentifier) => this.isApplicationInstalledOnDevice(deviceIdentifier, {
@@ -213,11 +192,9 @@ class DevicesService extends events_1.EventEmitter {
             return device;
         });
     }
-    getInstalledApplications(deviceIdentifier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const device = yield this.getDevice(deviceIdentifier);
-            return device.applicationManager.getInstalledApplications();
-        });
+    async getInstalledApplications(deviceIdentifier) {
+        const device = await this.getDevice(deviceIdentifier);
+        return device.applicationManager.getInstalledApplications();
     }
     addDeviceDiscovery(deviceDiscovery) {
         this._otherDeviceDiscoveries.push(deviceDiscovery);
@@ -270,69 +247,62 @@ class DevicesService extends events_1.EventEmitter {
         delete this._availableEmulators[emulator.imageIdentifier];
         this.emit(constants.EmulatorDiscoveryNames.EMULATOR_IMAGE_LOST, emulator);
     }
-    /**
-     * Starts looking for devices. Any found devices are pushed to "_devices" variable.
-     */
-    detectCurrentlyAttachedDevices(deviceInitOpts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const options = this.getDeviceLookingOptions(deviceInitOpts);
-            for (const deviceDiscovery of this._allDeviceDiscoveries) {
-                try {
-                    yield deviceDiscovery.startLookingForDevices(options);
-                }
-                catch (err) {
-                    this.$logger.trace("Error while checking for devices.", err);
-                }
-            }
-        });
-    }
-    detectCurrentlyAvailableEmulators() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.$androidEmulatorDiscovery.startLookingForDevices();
-            }
-            catch (err) {
-                this.$logger.trace(`Error while checking for Android emulators. ${err}`);
-            }
+    async detectCurrentlyAttachedDevices(deviceInitOpts) {
+        const options = this.getDeviceLookingOptions(deviceInitOpts);
+        for (const deviceDiscovery of this._allDeviceDiscoveries) {
             try {
-                yield this.$iOSSimulatorDiscovery.checkForAvailableSimulators();
+                await deviceDiscovery.startLookingForDevices(options);
             }
             catch (err) {
-                this.$logger.trace(`Error while checking for iOS simulators. ${err}`);
+                this.$logger.trace("Error while checking for devices.", err);
             }
-        });
+        }
+    }
+    async detectCurrentlyAvailableEmulators() {
+        try {
+            await this.$androidEmulatorDiscovery.startLookingForDevices();
+        }
+        catch (err) {
+            this.$logger.trace(`Error while checking for Android emulators. ${err}`);
+        }
+        try {
+            await this.$iOSSimulatorDiscovery.checkForAvailableSimulators();
+        }
+        catch (err) {
+            this.$logger.trace(`Error while checking for iOS simulators. ${err}`);
+        }
     }
     startDeviceDetectionInterval(deviceInitOpts = {}) {
         if (!this.deviceDetectionInterval) {
             let isDeviceDetectionIntervalInProgress = false;
-            this.deviceDetectionInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            this.deviceDetectionInterval = setInterval(async () => {
                 if (isDeviceDetectionIntervalInProgress) {
                     return;
                 }
                 isDeviceDetectionIntervalInProgress = true;
-                yield this.detectCurrentlyAttachedDevices(deviceInitOpts);
+                await this.detectCurrentlyAttachedDevices(deviceInitOpts);
                 try {
                     const trustedDevices = _.filter(this._devices, (device) => device.deviceInfo.status === constants.CONNECTED_STATUS);
-                    yield (0, helpers_1.settlePromises)(_.map(trustedDevices, (device) => device.applicationManager.checkForApplicationUpdates()));
+                    await (0, helpers_1.settlePromises)(_.map(trustedDevices, (device) => device.applicationManager.checkForApplicationUpdates()));
                 }
                 catch (err) {
                     this.$logger.trace("Error checking for application updates on devices.", err);
                 }
                 isDeviceDetectionIntervalInProgress = false;
-            }), deviceInitOpts.detectionInterval || DevicesService.DEVICE_LOOKING_INTERVAL);
+            }, deviceInitOpts.detectionInterval || DevicesService.DEVICE_LOOKING_INTERVAL);
             this.deviceDetectionInterval.unref();
         }
     }
     startEmulatorDetectionInterval(opts = {}) {
         let isEmulatorDetectionIntervalRunning = false;
-        this.emulatorDetectionInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+        this.emulatorDetectionInterval = setInterval(async () => {
             if (isEmulatorDetectionIntervalRunning) {
                 return;
             }
             isEmulatorDetectionIntervalRunning = true;
-            yield this.detectCurrentlyAvailableEmulators();
+            await this.detectCurrentlyAvailableEmulators();
             isEmulatorDetectionIntervalRunning = false;
-        }), opts.detectionInterval || DevicesService.EMULATOR_IMAGES_DETECTION_INTERVAL);
+        }, opts.detectionInterval || DevicesService.EMULATOR_IMAGES_DETECTION_INTERVAL);
         this.emulatorDetectionInterval.unref();
     }
     stopDeviceDetectionInterval() {
@@ -345,11 +315,6 @@ class DevicesService extends events_1.EventEmitter {
             clearInterval(this.emulatorDetectionInterval);
         }
     }
-    /**
-     * Returns device that matches an identifier.
-     * The identifier is expected to be the same as the running device declares it (emulator-5554 for android or GUID for ios).
-     * @param identifier running emulator or device identifier
-     */
     getDeviceByIdentifier(identifier) {
         const searchedDevice = _.find(this.getDeviceInstances(), (device) => {
             if (this.$mobileHelper.isApplePlatform(device.deviceInfo.platform) &&
@@ -365,112 +330,81 @@ class DevicesService extends events_1.EventEmitter {
         }
         return searchedDevice;
     }
-    /**
-     * Starts looking for running devices. All found devices are pushed to _devices variable.
-     */
-    startLookingForDevices(deviceInitOpts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.$logger.trace("startLookingForDevices; platform is %s", this._platform);
-            if (this._platform) {
-                return this.detectCurrentlyAttachedDevices(deviceInitOpts);
-            }
-            yield this.detectCurrentlyAttachedDevices(deviceInitOpts);
-            yield this.detectCurrentlyAvailableEmulators();
-            yield this.startDeviceDetectionInterval(deviceInitOpts);
-        });
+    async startLookingForDevices(deviceInitOpts) {
+        this.$logger.trace("startLookingForDevices; platform is %s", this._platform);
+        if (this._platform) {
+            return this.detectCurrentlyAttachedDevices(deviceInitOpts);
+        }
+        await this.detectCurrentlyAttachedDevices(deviceInitOpts);
+        await this.detectCurrentlyAvailableEmulators();
+        await this.startDeviceDetectionInterval(deviceInitOpts);
     }
-    /**
-     * Returns device depending on the passed index.
-     * The index refers to assigned number to listed devices by tns device command.
-     * @param index assigned device number
-     */
     getDeviceByIndex(index) {
         this.validateIndex(index - 1);
         return this.getDeviceInstances()[index - 1];
     }
-    /**
-     * Returns running device for specified --device <DeviceId>.
-     * Method expects running devices.
-     * @param deviceOption parameter passed by the user to --device flag. Can be name, identifier or imageIdentifier.
-     */
-    getDevice(deviceOption) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let device = null;
-            if (!device) {
-                device = _.find(this.getDeviceInstances(), (d) => (d.deviceInfo.identifier &&
-                    d.deviceInfo.identifier === deviceOption) ||
-                    (d.deviceInfo.displayName &&
-                        d.deviceInfo.displayName === deviceOption) ||
-                    (d.deviceInfo.imageIdentifier &&
-                        d.deviceInfo.imageIdentifier === deviceOption));
-            }
-            if (!device && helpers.isNumberWithoutExponent(deviceOption)) {
-                device = this.getDeviceByIndex(parseInt(deviceOption, 10));
-            }
-            if (!device) {
-                this.$errors.fail(this.$messages.Devices
-                    .NotFoundDeviceByIdentifierErrorMessageWithIdentifier, deviceOption, this.$staticConfig.CLIENT_NAME.toLowerCase());
-            }
-            return device;
-        });
+    async getDevice(deviceOption) {
+        let device = null;
+        if (!device) {
+            device = _.find(this.getDeviceInstances(), (d) => (d.deviceInfo.identifier &&
+                d.deviceInfo.identifier === deviceOption) ||
+                (d.deviceInfo.displayName &&
+                    d.deviceInfo.displayName === deviceOption) ||
+                (d.deviceInfo.imageIdentifier &&
+                    d.deviceInfo.imageIdentifier === deviceOption));
+        }
+        if (!device && helpers.isNumberWithoutExponent(deviceOption)) {
+            device = this.getDeviceByIndex(parseInt(deviceOption, 10));
+        }
+        if (!device) {
+            this.$errors.fail(this.$messages.Devices
+                .NotFoundDeviceByIdentifierErrorMessageWithIdentifier, deviceOption, this.$staticConfig.CLIENT_NAME.toLowerCase());
+        }
+        return device;
     }
-    /**
-     * Method runs action for a --device (value), specified by the user.
-     * @param action action to be executed if canExecute returns true
-     * @param canExecute predicate to decide whether the command can be ran
-     */
-    executeOnDevice(action, canExecute) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!canExecute || canExecute(this._device)) {
-                return {
-                    deviceIdentifier: this._device.deviceInfo.identifier,
-                    result: yield action(this._device),
-                };
-            }
-        });
+    async executeOnDevice(action, canExecute) {
+        if (!canExecute || canExecute(this._device)) {
+            return {
+                deviceIdentifier: this._device.deviceInfo.identifier,
+                result: await action(this._device),
+            };
+        }
     }
-    /**
-     * Executes passed action for each found device.
-     * @param action action to be executed if canExecute returns true
-     * @param canExecute predicate to decide whether the command can be ran
-     */
-    executeOnAllConnectedDevices(action, canExecute) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const devices = this.filterDevicesByPlatform();
-            const sortedDevices = _.sortBy(devices, (device) => device.deviceInfo.platform);
-            const result = [];
-            const errors = [];
-            for (const device of sortedDevices) {
-                try {
-                    if (!canExecute || canExecute(device)) {
-                        result.push({
-                            deviceIdentifier: device.deviceInfo.identifier,
-                            result: yield action(device),
-                        });
-                    }
-                }
-                catch (err) {
-                    err.deviceIdentifier = device.deviceInfo.identifier;
-                    this.$logger.trace(`Error while executing action on device ${device.deviceInfo.identifier}. The error is`, err);
-                    errors.push(err);
+    async executeOnAllConnectedDevices(action, canExecute) {
+        const devices = this.filterDevicesByPlatform();
+        const sortedDevices = _.sortBy(devices, (device) => device.deviceInfo.platform);
+        const result = [];
+        const errors = [];
+        for (const device of sortedDevices) {
+            try {
+                if (!canExecute || canExecute(device)) {
+                    result.push({
+                        deviceIdentifier: device.deviceInfo.identifier,
+                        result: await action(device),
+                    });
                 }
             }
-            if (errors.length) {
-                let preErrorMsg = "";
-                if (errors.length > 1) {
-                    preErrorMsg = "Multiple errors were thrown:" + os_1.EOL;
-                }
-                const errorMessage = `${preErrorMsg}${errors
-                    .map((e) => e.message || e)
-                    .join(os_1.EOL)}`;
-                this.$errors.fail(errorMessage);
+            catch (err) {
+                err.deviceIdentifier = device.deviceInfo.identifier;
+                this.$logger.trace(`Error while executing action on device ${device.deviceInfo.identifier}. The error is`, err);
+                errors.push(err);
             }
-            return result;
-        });
+        }
+        if (errors.length) {
+            let preErrorMsg = "";
+            if (errors.length > 1) {
+                preErrorMsg = "Multiple errors were thrown:" + os_1.EOL;
+            }
+            const errorMessage = `${preErrorMsg}${errors
+                .map((e) => e.message || e)
+                .join(os_1.EOL)}`;
+            this.$errors.fail(errorMessage);
+        }
+        return result;
     }
     deployOnDevices(deviceIdentifiers, packagePath, appId, projectName, projectDir) {
         this.$logger.trace(`Called deployOnDevices for identifiers ${deviceIdentifiers} for packageFile: ${packagePath}. Application identifier is ${appId}. Project Name is: ${projectName}`);
-        return _.map(deviceIdentifiers, (deviceIdentifier) => __awaiter(this, void 0, void 0, function* () {
+        return _.map(deviceIdentifiers, async (deviceIdentifier) => {
             const device = this.getDeviceByIdentifier(deviceIdentifier);
             let identifier;
             if (typeof appId === "string") {
@@ -485,141 +419,110 @@ class DevicesService extends events_1.EventEmitter {
                 projectName,
                 projectDir,
             });
-        }));
+        });
     }
-    /**
-     * Runs the passed action if the predicate "canExecute" returns true
-     * @param action action to be executed if canExecute returns true.
-     * @param canExecute predicate to decide whether the command can be ran
-     * @param options all possible options that can be passed to the command.
-     */
-    execute(action, canExecute, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            assert.ok(this._isInitialized, "Devices services not initialized!");
-            if (this.hasDevices) {
-                if (this.$hostInfo.isDarwin &&
-                    this._platform &&
-                    this.$mobileHelper.isiOSPlatform(this._platform) &&
-                    this.$options.emulator &&
-                    !this.isOnlyiOSSimultorRunning()) {
-                    // Executes the command only on iOS simulator
-                    const originalCanExecute = canExecute;
-                    canExecute = (dev) => this.isiOSSimulator(dev) &&
-                        (!originalCanExecute || !!originalCanExecute(dev));
-                }
-                return this.executeCore(action, canExecute);
+    async execute(action, canExecute, options) {
+        assert.ok(this._isInitialized, "Devices services not initialized!");
+        if (this.hasDevices) {
+            if (this.$hostInfo.isDarwin &&
+                this._platform &&
+                this.$mobileHelper.isiOSPlatform(this._platform) &&
+                this.$options.emulator &&
+                !this.isOnlyiOSSimultorRunning()) {
+                const originalCanExecute = canExecute;
+                canExecute = (dev) => this.isiOSSimulator(dev) &&
+                    (!originalCanExecute || !!originalCanExecute(dev));
+            }
+            return this.executeCore(action, canExecute);
+        }
+        else {
+            const message = constants.ERROR_NO_DEVICES;
+            if (options && options.allowNoDevices) {
+                this.$logger.info(message);
             }
             else {
-                const message = constants.ERROR_NO_DEVICES;
-                if (options && options.allowNoDevices) {
-                    this.$logger.info(message);
+                if (!this.$hostInfo.isDarwin &&
+                    this._platform &&
+                    this.$mobileHelper.isiOSPlatform(this._platform)) {
+                    this.$errors.fail(message);
                 }
                 else {
-                    if (!this.$hostInfo.isDarwin &&
-                        this._platform &&
-                        this.$mobileHelper.isiOSPlatform(this._platform)) {
-                        this.$errors.fail(message);
-                    }
-                    else {
-                        return this.executeCore(action, canExecute);
-                    }
+                    return this.executeCore(action, canExecute);
                 }
             }
-        });
+        }
     }
-    /**
-     * Starts emulator or simulator if necessary depending on --device or --emulator flags.
-     * If no options are passed runs default emulator/simulator if no devices are connected.
-     * @param deviceInitOpts mainly contains information about --emulator and --deviceId flags.
-     */
-    startEmulatorIfNecessary(deviceInitOpts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (deviceInitOpts && deviceInitOpts.deviceId && deviceInitOpts.emulator) {
-                this.$errors.fail(`--device and --emulator are incompatible options.
+    async startEmulatorIfNecessary(deviceInitOpts) {
+        if (deviceInitOpts && deviceInitOpts.deviceId && deviceInitOpts.emulator) {
+            this.$errors.fail(`--device and --emulator are incompatible options.
 			If you are trying to run on specific emulator, use "${this.$staticConfig.CLIENT_NAME} run --device <DeviceID>`);
+        }
+        if (deviceInitOpts &&
+            deviceInitOpts.platform &&
+            !deviceInitOpts.skipEmulatorStart) {
+            this._platform = deviceInitOpts.platform;
+            try {
+                await this.startLookingForDevices(deviceInitOpts);
             }
-            if (deviceInitOpts &&
-                deviceInitOpts.platform &&
-                !deviceInitOpts.skipEmulatorStart) {
-                // are there any running devices
-                this._platform = deviceInitOpts.platform;
-                try {
-                    yield this.startLookingForDevices(deviceInitOpts);
-                }
-                catch (err) {
-                    this.$logger.trace("Error while checking for devices.", err);
-                }
-                const deviceInstances = this.getDeviceInstances();
-                if (!deviceInitOpts.deviceId && _.isEmpty(deviceInstances)) {
-                    if (!this.$hostInfo.isDarwin &&
-                        this.$mobileHelper.isApplePlatform(deviceInitOpts.platform)) {
-                        this.$errors.fail(constants.ERROR_NO_DEVICES_CANT_USE_IOS_SIMULATOR);
-                    }
-                }
-                try {
-                    yield this._startEmulatorIfNecessary(deviceInitOpts);
-                }
-                catch (err) {
-                    const errorMessage = this.getEmulatorError(err, deviceInitOpts.platform);
-                    this.$errors.fail(errorMessage);
-                }
+            catch (err) {
+                this.$logger.trace("Error while checking for devices.", err);
             }
-        });
-    }
-    _startEmulatorIfNecessary(data) {
-        return __awaiter(this, void 0, void 0, function* () {
             const deviceInstances = this.getDeviceInstances();
-            //if no --device is passed and no devices are found, the default emulator is started
-            if (!data.deviceId && _.isEmpty(deviceInstances)) {
-                return this.startEmulatorCore(data);
-            }
-            //check if --device(value) is running, if it's not or it's not the same as is specified, start with name from --device(value)
-            if (data.deviceId) {
-                if (!helpers.isNumberWithoutExponent(data.deviceId)) {
-                    const activeDeviceInstance = _.find(deviceInstances, (device) => device.deviceInfo.identifier === data.deviceId);
-                    if (!activeDeviceInstance) {
-                        return this.startEmulatorCore(data);
-                    }
+            if (!deviceInitOpts.deviceId && _.isEmpty(deviceInstances)) {
+                if (!this.$hostInfo.isDarwin &&
+                    this.$mobileHelper.isApplePlatform(deviceInitOpts.platform)) {
+                    this.$errors.fail(constants.ERROR_NO_DEVICES_CANT_USE_IOS_SIMULATOR);
                 }
             }
-            // make sure if the target platform is visionOS we don't try to run it on an already running iOS simulator...
-            if (data.platform === this.$devicePlatformsConstants.visionOS &&
-                deviceInstances.length) {
-                const runningDeviceInstance = deviceInstances.find((device) => device.deviceInfo.platform === this.$devicePlatformsConstants.visionOS);
-                if (!runningDeviceInstance) {
-                    return this.startEmulatorCore(data);
-                }
+            try {
+                await this._startEmulatorIfNecessary(deviceInitOpts);
             }
-            // if only emulator flag is passed and no other emulators are running, start default emulator
-            if (data.emulator && deviceInstances.length) {
-                const runningDeviceInstance = _.some(deviceInstances, (value) => value.isEmulator);
-                if (!runningDeviceInstance) {
-                    return this.startEmulatorCore(data);
-                }
+            catch (err) {
+                const errorMessage = this.getEmulatorError(err, deviceInitOpts.platform);
+                this.$errors.fail(errorMessage);
             }
-        });
+        }
     }
-    /**
-     * Takes care of gathering information about all running devices.
-     * Sets "_isInitialized" to true after infomation is present.
-     * Method expects running devices.
-     * @param data mainly contains information about --emulator and --deviceId flags.
-     */
-    initialize(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._deviceInitializePromise) {
-                this._deviceInitializePromise = this.initializeCore(data);
+    async _startEmulatorIfNecessary(data) {
+        const deviceInstances = this.getDeviceInstances();
+        if (!data.deviceId && _.isEmpty(deviceInstances)) {
+            return this.startEmulatorCore(data);
+        }
+        if (data.deviceId) {
+            if (!helpers.isNumberWithoutExponent(data.deviceId)) {
+                const activeDeviceInstance = _.find(deviceInstances, (device) => device.deviceInfo.identifier === data.deviceId);
+                if (!activeDeviceInstance) {
+                    return this.startEmulatorCore(data);
+                }
             }
-            try {
-                yield this._deviceInitializePromise;
+        }
+        if (data.platform === this.$devicePlatformsConstants.visionOS &&
+            deviceInstances.length) {
+            const runningDeviceInstance = deviceInstances.find((device) => device.deviceInfo.platform ===
+                this.$devicePlatformsConstants.visionOS);
+            if (!runningDeviceInstance) {
+                return this.startEmulatorCore(data);
             }
-            catch (err) {
-                // In case the initalization fails, we want to allow calling `initlialize` again with other arguments for example, so remove the cached promise value.
-                this.$logger.trace(`Error while initializing devicesService: ${err}`);
-                this._deviceInitializePromise = null;
-                throw err;
+        }
+        if (data.emulator && deviceInstances.length) {
+            const runningDeviceInstance = _.some(deviceInstances, (value) => value.isEmulator);
+            if (!runningDeviceInstance) {
+                return this.startEmulatorCore(data);
             }
-        });
+        }
+    }
+    async initialize(data) {
+        if (!this._deviceInitializePromise) {
+            this._deviceInitializePromise = this.initializeCore(data);
+        }
+        try {
+            await this._deviceInitializePromise;
+        }
+        catch (err) {
+            this.$logger.trace(`Error while initializing devicesService: ${err}`);
+            this._deviceInitializePromise = null;
+            throw err;
+        }
     }
     getPlatformsFromDeviceDescriptors(deviceDescriptors) {
         const platforms = _(deviceDescriptors)
@@ -629,93 +532,89 @@ class DevicesService extends events_1.EventEmitter {
             .value();
         return platforms;
     }
-    initializeCore(deviceInitOpts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._isInitialized) {
-                return;
-            }
-            if (!this.$options.json) {
-                this.$logger.info("Searching for devices...");
-            }
-            deviceInitOpts = deviceInitOpts || {};
-            this._data = deviceInitOpts;
-            if (!deviceInitOpts.skipEmulatorStart) {
-                // TODO: Remove from here as it calls startLookingForDevices, so we double the calls to specific device detection services
-                yield this.startEmulatorIfNecessary(deviceInitOpts);
-            }
-            const platform = deviceInitOpts.platform;
-            const deviceOption = deviceInitOpts.deviceId;
-            const deviceLookingOptions = {
-                emulator: deviceInitOpts.emulator,
-                platform: deviceInitOpts.platform,
-                shouldReturnImmediateResult: deviceInitOpts.shouldReturnImmediateResult,
-                detectionInterval: deviceInitOpts.detectionInterval,
-                fullDiscovery: deviceInitOpts.fullDiscovery,
-            };
-            if (platform && deviceOption) {
-                this._platform = this.$mobileHelper.validatePlatformName(deviceInitOpts.platform);
-                yield this.startLookingForDevices(deviceLookingOptions);
-                this._device = yield this.getDevice(deviceOption);
-                if (this._device.deviceInfo.platform !== this._platform) {
-                    this.$errors.fail(constants.ERROR_CANNOT_RESOLVE_DEVICE);
+    async initializeCore(deviceInitOpts) {
+        if (this._isInitialized) {
+            return;
+        }
+        if (!this.$options.json) {
+            this.$logger.info("Searching for devices...");
+        }
+        deviceInitOpts = deviceInitOpts || {};
+        this._data = deviceInitOpts;
+        if (!deviceInitOpts.skipEmulatorStart) {
+            await this.startEmulatorIfNecessary(deviceInitOpts);
+        }
+        const platform = deviceInitOpts.platform;
+        const deviceOption = deviceInitOpts.deviceId;
+        const deviceLookingOptions = {
+            emulator: deviceInitOpts.emulator,
+            platform: deviceInitOpts.platform,
+            shouldReturnImmediateResult: deviceInitOpts.shouldReturnImmediateResult,
+            detectionInterval: deviceInitOpts.detectionInterval,
+            fullDiscovery: deviceInitOpts.fullDiscovery,
+        };
+        if (platform && deviceOption) {
+            this._platform = this.$mobileHelper.validatePlatformName(deviceInitOpts.platform);
+            await this.startLookingForDevices(deviceLookingOptions);
+            this._device = await this.getDevice(deviceOption);
+            if (this._device.deviceInfo.platform !== this._platform) {
+                this.$errors.fail(constants.ERROR_CANNOT_RESOLVE_DEVICE);
+            }
+            this.$logger.warn("Your application will be deployed only on the device specified by the provided index or identifier.");
+        }
+        else if (!platform && deviceOption) {
+            await this.startLookingForDevices(deviceLookingOptions);
+            this._device = await this.getDevice(deviceOption);
+            this._platform = this._device.deviceInfo.platform;
+        }
+        else if (platform && !deviceOption) {
+            this._platform = this.$mobileHelper.validatePlatformName(platform);
+            await this.startLookingForDevices(deviceLookingOptions);
+        }
+        else {
+            if (deviceInitOpts.skipInferPlatform) {
+                if (deviceInitOpts.skipDeviceDetectionInterval) {
+                    await this.detectCurrentlyAttachedDevices(deviceLookingOptions);
+                }
+                else {
+                    deviceInitOpts.shouldReturnImmediateResult = true;
+                    await this.startLookingForDevices(deviceLookingOptions);
                 }
-                this.$logger.warn("Your application will be deployed only on the device specified by the provided index or identifier.");
-            }
-            else if (!platform && deviceOption) {
-                yield this.startLookingForDevices(deviceLookingOptions);
-                this._device = yield this.getDevice(deviceOption);
-                this._platform = this._device.deviceInfo.platform;
-            }
-            else if (platform && !deviceOption) {
-                this._platform = this.$mobileHelper.validatePlatformName(platform);
-                yield this.startLookingForDevices(deviceLookingOptions);
             }
             else {
-                // platform and deviceId are not specified
-                if (deviceInitOpts.skipInferPlatform) {
-                    if (deviceInitOpts.skipDeviceDetectionInterval) {
-                        yield this.detectCurrentlyAttachedDevices(deviceLookingOptions);
+                await this.startLookingForDevices(deviceLookingOptions);
+                const devices = this.getDeviceInstances();
+                const platforms = _(devices)
+                    .map((device) => device.deviceInfo.platform)
+                    .filter((pl) => {
+                    try {
+                        return !!this.$mobileHelper.validatePlatformName(pl);
                     }
-                    else {
-                        deviceInitOpts.shouldReturnImmediateResult = true;
-                        yield this.startLookingForDevices(deviceLookingOptions);
+                    catch (err) {
+                        this.$logger.warn(err.message);
+                        return null;
                     }
+                })
+                    .uniq()
+                    .value();
+                if (platforms.length === 1) {
+                    this._platform = platforms[0];
+                }
+                else if (platforms.length === 0) {
+                    this.$errors.fail(constants.ERROR_NO_DEVICES);
                 }
                 else {
-                    yield this.startLookingForDevices(deviceLookingOptions);
-                    const devices = this.getDeviceInstances();
-                    const platforms = _(devices)
-                        .map((device) => device.deviceInfo.platform)
-                        .filter((pl) => {
-                        try {
-                            return !!this.$mobileHelper.validatePlatformName(pl);
-                        }
-                        catch (err) {
-                            this.$logger.warn(err.message);
-                            return null;
-                        }
-                    })
-                        .uniq()
-                        .value();
-                    if (platforms.length === 1) {
-                        this._platform = platforms[0];
-                    }
-                    else if (platforms.length === 0) {
-                        this.$errors.fail(constants.ERROR_NO_DEVICES);
-                    }
-                    else {
-                        this.$errors.fail("Multiple device platforms detected (%s). Specify platform or device on command line.", helpers.formatListOfNames(platforms, "and"));
-                    }
+                    this.$errors.fail("Multiple device platforms detected (%s). Specify platform or device on command line.", helpers.formatListOfNames(platforms, "and"));
                 }
             }
-            if (!this.$hostInfo.isDarwin &&
-                this._platform &&
-                this.$mobileHelper.isiOSPlatform(this._platform) &&
-                this.$options.emulator) {
-                this.$errors.fail(constants.ERROR_CANT_USE_SIMULATOR);
-            }
-            this._isInitialized = true;
-        });
+        }
+        if (!this.$hostInfo.isDarwin &&
+            this._platform &&
+            this.$mobileHelper.isiOSPlatform(this._platform) &&
+            this.$options.emulator) {
+            this.$errors.fail(constants.ERROR_CANT_USE_SIMULATOR);
+        }
+        this._isInitialized = true;
     }
     get hasDevices() {
         if (!this._platform) {
@@ -735,30 +634,24 @@ class DevicesService extends events_1.EventEmitter {
     getDeviceByDeviceOption() {
         return this._device;
     }
-    mapAbstractToTcpPort(deviceIdentifier, appIdentifier, framework) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.$androidProcessService.mapAbstractToTcpPort(deviceIdentifier, appIdentifier, framework);
-        });
+    async mapAbstractToTcpPort(deviceIdentifier, appIdentifier, framework) {
+        return this.$androidProcessService.mapAbstractToTcpPort(deviceIdentifier, appIdentifier, framework);
     }
     getDebuggableApps(deviceIdentifiers) {
         return _.map(deviceIdentifiers, (deviceIdentifier) => this.getDebuggableAppsCore(deviceIdentifier));
     }
-    getDebuggableViews(deviceIdentifier, appIdentifier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const device = this.getDeviceByIdentifier(deviceIdentifier), debuggableViewsPerApp = yield device.applicationManager.getDebuggableAppViews([appIdentifier]);
-            return debuggableViewsPerApp && debuggableViewsPerApp[appIdentifier];
-        });
+    async getDebuggableViews(deviceIdentifier, appIdentifier) {
+        const device = this.getDeviceByIdentifier(deviceIdentifier), debuggableViewsPerApp = await device.applicationManager.getDebuggableAppViews([appIdentifier]);
+        return debuggableViewsPerApp && debuggableViewsPerApp[appIdentifier];
     }
     getDebuggableAppsCore(deviceIdentifier) {
         const device = this.getDeviceByIdentifier(deviceIdentifier);
         return device.applicationManager.getDebuggableApps();
     }
-    deployOnDevice(device, appData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield device.applicationManager.reinstallApplication(appData.appId, appData.packagePath);
-            this.$logger.info(`Successfully deployed on device with identifier '${device.deviceInfo.identifier}'.`);
-            yield device.applicationManager.tryStartApplication(appData);
-        });
+    async deployOnDevice(device, appData) {
+        await device.applicationManager.reinstallApplication(appData.appId, appData.packagePath);
+        this.$logger.info(`Successfully deployed on device with identifier '${device.deviceInfo.identifier}'.`);
+        await device.applicationManager.tryStartApplication(appData);
     }
     filterDevicesByPlatform() {
         return _.filter(this.getDeviceInstances(), (device) => {
@@ -786,63 +679,52 @@ class DevicesService extends events_1.EventEmitter {
         }
         return null;
     }
-    /**
-     * Starts emulator for platform and makes sure started devices/emulators/simulators are in _devices array before finishing.
-     * @param platform (optional) platform to start emulator/simulator for
-     * @param emulatorIdOrName (optional) emulator/simulator image identifier or name
-     */
-    startEmulatorCore(deviceInitOpts = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { deviceId } = deviceInitOpts;
-            const platform = deviceInitOpts.platform || this._platform;
-            const emulatorServices = this.resolveEmulatorServices(platform);
-            if (!emulatorServices) {
-                this.$errors.fail("Unable to detect platform for which to start emulator.");
-            }
-            const result = yield emulatorServices.startEmulator({
-                emulatorIdOrName: deviceId,
-                imageIdentifier: deviceId,
-                platform: platform,
-                sdk: this._data && this._data.sdk,
-            });
-            if (result && result.errors && result.errors.length) {
-                this.$errors.fail(result.errors.join("\n"));
-            }
-            const deviceLookingOptions = this.getDeviceLookingOptions(deviceInitOpts);
-            if (this.$mobileHelper.isAndroidPlatform(platform)) {
-                yield this.$androidDeviceDiscovery.startLookingForDevices(deviceLookingOptions);
-            }
-            else if (this.$mobileHelper.isiOSPlatform(platform) &&
-                this.$hostInfo.isDarwin) {
-                yield this.$iOSSimulatorDiscovery.startLookingForDevices(deviceLookingOptions);
-            }
+    async startEmulatorCore(deviceInitOpts = {}) {
+        const { deviceId } = deviceInitOpts;
+        const platform = deviceInitOpts.platform || this._platform;
+        const emulatorServices = this.resolveEmulatorServices(platform);
+        if (!emulatorServices) {
+            this.$errors.fail("Unable to detect platform for which to start emulator.");
+        }
+        const result = await emulatorServices.startEmulator({
+            emulatorIdOrName: deviceId,
+            imageIdentifier: deviceId,
+            platform: platform,
+            sdk: this._data && this._data.sdk,
         });
+        if (result && result.errors && result.errors.length) {
+            this.$errors.fail(result.errors.join("\n"));
+        }
+        const deviceLookingOptions = this.getDeviceLookingOptions(deviceInitOpts);
+        if (this.$mobileHelper.isAndroidPlatform(platform)) {
+            await this.$androidDeviceDiscovery.startLookingForDevices(deviceLookingOptions);
+        }
+        else if (this.$mobileHelper.isiOSPlatform(platform) &&
+            this.$hostInfo.isDarwin) {
+            await this.$iOSSimulatorDiscovery.startLookingForDevices(deviceLookingOptions);
+        }
     }
-    executeCore(action, canExecute) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._device) {
-                return [yield this.executeOnDevice(action, canExecute)];
-            }
-            return this.executeOnAllConnectedDevices(action, canExecute);
-        });
+    async executeCore(action, canExecute) {
+        if (this._device) {
+            return [await this.executeOnDevice(action, canExecute)];
+        }
+        return this.executeOnAllConnectedDevices(action, canExecute);
     }
-    isApplicationInstalledOnDevice(deviceIdentifier, appData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let isInstalled = false;
-            const device = this.getDeviceByIdentifier(deviceIdentifier);
-            try {
-                isInstalled = yield device.applicationManager.isApplicationInstalled(appData.appId);
-                yield device.applicationManager.tryStartApplication(appData);
-            }
-            catch (err) {
-                this.$logger.trace("Error while checking is application installed. Error is: ", err);
-            }
-            return {
-                appIdentifier: appData.appId,
-                deviceIdentifier,
-                isInstalled,
-            };
-        });
+    async isApplicationInstalledOnDevice(deviceIdentifier, appData) {
+        let isInstalled = false;
+        const device = this.getDeviceByIdentifier(deviceIdentifier);
+        try {
+            isInstalled = await device.applicationManager.isApplicationInstalled(appData.appId);
+            await device.applicationManager.tryStartApplication(appData);
+        }
+        catch (err) {
+            this.$logger.trace("Error while checking is application installed. Error is: ", err);
+        }
+        return {
+            appIdentifier: appData.appId,
+            deviceIdentifier,
+            isInstalled,
+        };
     }
     getDeviceLookingOptions(deviceInitOpts = {}) {
         const { shouldReturnImmediateResult, emulator } = deviceInitOpts;
@@ -865,6 +747,7 @@ class DevicesService extends events_1.EventEmitter {
             `To list available ${emulatorName.toLowerCase()} images, run '${this.$staticConfig.CLIENT_NAME.toLowerCase()} device <Platform> --available-devices'.`);
     }
 }
+exports.DevicesService = DevicesService;
 DevicesService.DEVICE_LOOKING_INTERVAL = 200;
 DevicesService.EMULATOR_IMAGES_DETECTION_INTERVAL = 60 * 1000;
 __decorate([
@@ -918,6 +801,4 @@ __decorate([
 __decorate([
     (0, decorators_1.exported)("devicesService")
 ], DevicesService.prototype, "getDebuggableViews", null);
-exports.DevicesService = DevicesService;
 yok_1.injector.register("devicesService", DevicesService);
-//# sourceMappingURL=devices-service.js.map