nativescript 8.9.0-dev.1 → 8.9.0-dev.2

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

@@ -5,6 +5,15 @@ 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");
@@ -54,101 +63,111 @@ class DevicesService extends events_1.EventEmitter {
             this.$iOSSimulatorDiscovery,
         ];
     }
-    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;
+    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);
             }
-            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);
+            if (options.deviceId) {
+                const device = yield this.getDevice(options.deviceId);
+                return device;
+            }
+            // 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 {
-                    if (emulators.length) {
-                        selectedInstance = _.last(emulators);
+                    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);
                     }
                     else {
-                        selectedInstance = _.last(devices);
+                        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;
                 }
-                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);
+        });
     }
-    async getEmulatorImages(options) {
-        const result = Object.create(null);
-        if (this.$hostInfo.isDarwin &&
-            (!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 ||
                 !options.platform ||
-                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;
+                this.$mobileHelper.isAndroidPlatform(options.platform)) {
+                result.android = yield this.$androidEmulatorServices.getEmulatorImages();
+            }
+            return result;
+        });
     }
-    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,
+    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;
         });
-        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;
@@ -173,9 +192,11 @@ 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, {
@@ -192,9 +213,11 @@ class DevicesService extends events_1.EventEmitter {
             return device;
         });
     }
-    async getInstalledApplications(deviceIdentifier) {
-        const device = await this.getDevice(deviceIdentifier);
-        return device.applicationManager.getInstalledApplications();
+    getInstalledApplications(deviceIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield this.getDevice(deviceIdentifier);
+            return device.applicationManager.getInstalledApplications();
+        });
     }
     addDeviceDiscovery(deviceDiscovery) {
         this._otherDeviceDiscoveries.push(deviceDiscovery);
@@ -247,62 +270,69 @@ class DevicesService extends events_1.EventEmitter {
         delete this._availableEmulators[emulator.imageIdentifier];
         this.emit(constants.EmulatorDiscoveryNames.EMULATOR_IMAGE_LOST, emulator);
     }
-    async detectCurrentlyAttachedDevices(deviceInitOpts) {
-        const options = this.getDeviceLookingOptions(deviceInitOpts);
-        for (const deviceDiscovery of this._allDeviceDiscoveries) {
+    /**
+     * 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 {
-                await deviceDiscovery.startLookingForDevices(options);
+                yield this.$androidEmulatorDiscovery.startLookingForDevices();
             }
             catch (err) {
-                this.$logger.trace("Error while checking for devices.", err);
+                this.$logger.trace(`Error while checking for Android emulators. ${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}`);
-        }
+            try {
+                yield 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(async () => {
+            this.deviceDetectionInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
                 if (isDeviceDetectionIntervalInProgress) {
                     return;
                 }
                 isDeviceDetectionIntervalInProgress = true;
-                await this.detectCurrentlyAttachedDevices(deviceInitOpts);
+                yield this.detectCurrentlyAttachedDevices(deviceInitOpts);
                 try {
                     const trustedDevices = _.filter(this._devices, (device) => device.deviceInfo.status === constants.CONNECTED_STATUS);
-                    await (0, helpers_1.settlePromises)(_.map(trustedDevices, (device) => device.applicationManager.checkForApplicationUpdates()));
+                    yield (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(async () => {
+        this.emulatorDetectionInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             if (isEmulatorDetectionIntervalRunning) {
                 return;
             }
             isEmulatorDetectionIntervalRunning = true;
-            await this.detectCurrentlyAvailableEmulators();
+            yield this.detectCurrentlyAvailableEmulators();
             isEmulatorDetectionIntervalRunning = false;
-        }, opts.detectionInterval || DevicesService.EMULATOR_IMAGES_DETECTION_INTERVAL);
+        }), opts.detectionInterval || DevicesService.EMULATOR_IMAGES_DETECTION_INTERVAL);
         this.emulatorDetectionInterval.unref();
     }
     stopDeviceDetectionInterval() {
@@ -315,6 +345,11 @@ 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) &&
@@ -330,81 +365,112 @@ class DevicesService extends events_1.EventEmitter {
         }
         return searchedDevice;
     }
-    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);
+    /**
+     * 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);
+        });
     }
+    /**
+     * 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];
     }
-    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;
+    /**
+     * 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 executeOnDevice(action, canExecute) {
-        if (!canExecute || canExecute(this._device)) {
-            return {
-                deviceIdentifier: this._device.deviceInfo.identifier,
-                result: await action(this._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 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),
-                    });
+    /**
+     * 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);
                 }
             }
-            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);
+            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);
             }
-        }
-        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;
+            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, async (deviceIdentifier) => {
+        return _.map(deviceIdentifiers, (deviceIdentifier) => __awaiter(this, void 0, void 0, function* () {
             const device = this.getDeviceByIdentifier(deviceIdentifier);
             let identifier;
             if (typeof appId === "string") {
@@ -419,110 +485,141 @@ class DevicesService extends events_1.EventEmitter {
                 projectName,
                 projectDir,
             });
-        });
+        }));
     }
-    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);
+    /**
+     * 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);
             }
             else {
-                if (!this.$hostInfo.isDarwin &&
-                    this._platform &&
-                    this.$mobileHelper.isiOSPlatform(this._platform)) {
-                    this.$errors.fail(message);
+                const message = constants.ERROR_NO_DEVICES;
+                if (options && options.allowNoDevices) {
+                    this.$logger.info(message);
                 }
                 else {
-                    return this.executeCore(action, canExecute);
+                    if (!this.$hostInfo.isDarwin &&
+                        this._platform &&
+                        this.$mobileHelper.isiOSPlatform(this._platform)) {
+                        this.$errors.fail(message);
+                    }
+                    else {
+                        return this.executeCore(action, canExecute);
+                    }
                 }
             }
-        }
+        });
     }
-    async startEmulatorIfNecessary(deviceInitOpts) {
-        if (deviceInitOpts && deviceInitOpts.deviceId && deviceInitOpts.emulator) {
-            this.$errors.fail(`--device and --emulator are incompatible options.
+    /**
+     * 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.
 			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);
             }
-            catch (err) {
-                this.$logger.trace("Error while checking for devices.", err);
+            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);
+                }
             }
+        });
+    }
+    _startEmulatorIfNecessary(data) {
+        return __awaiter(this, void 0, void 0, function* () {
             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);
-                }
+            //if no --device is passed and no devices are found, the default emulator is started
+            if (!data.deviceId && _.isEmpty(deviceInstances)) {
+                return this.startEmulatorCore(data);
             }
-            try {
-                await this._startEmulatorIfNecessary(deviceInitOpts);
+            //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);
+                    }
+                }
             }
-            catch (err) {
-                const errorMessage = this.getEmulatorError(err, deviceInitOpts.platform);
-                this.$errors.fail(errorMessage);
+            // 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);
+                }
             }
-        }
-    }
-    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) {
+            // 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);
                 }
             }
-        }
-        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);
+        });
+    }
+    /**
+     * 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);
             }
-        }
-        if (data.emulator && deviceInstances.length) {
-            const runningDeviceInstance = _.some(deviceInstances, (value) => value.isEmulator);
-            if (!runningDeviceInstance) {
-                return this.startEmulatorCore(data);
+            try {
+                yield this._deviceInitializePromise;
             }
-        }
-    }
-    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;
-        }
+            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;
+            }
+        });
     }
     getPlatformsFromDeviceDescriptors(deviceDescriptors) {
         const platforms = _(deviceDescriptors)
@@ -532,89 +629,93 @@ class DevicesService extends events_1.EventEmitter {
             .value();
         return platforms;
     }
-    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);
+    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);
                 }
+                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 {
-                await this.startLookingForDevices(deviceLookingOptions);
-                const devices = this.getDeviceInstances();
-                const platforms = _(devices)
-                    .map((device) => device.deviceInfo.platform)
-                    .filter((pl) => {
-                    try {
-                        return !!this.$mobileHelper.validatePlatformName(pl);
+                // platform and deviceId are not specified
+                if (deviceInitOpts.skipInferPlatform) {
+                    if (deviceInitOpts.skipDeviceDetectionInterval) {
+                        yield this.detectCurrentlyAttachedDevices(deviceLookingOptions);
                     }
-                    catch (err) {
-                        this.$logger.warn(err.message);
-                        return null;
+                    else {
+                        deviceInitOpts.shouldReturnImmediateResult = true;
+                        yield this.startLookingForDevices(deviceLookingOptions);
                     }
-                })
-                    .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"));
+                    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"));
+                    }
                 }
             }
-        }
-        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) {
@@ -634,24 +735,30 @@ class DevicesService extends events_1.EventEmitter {
     getDeviceByDeviceOption() {
         return this._device;
     }
-    async mapAbstractToTcpPort(deviceIdentifier, appIdentifier, framework) {
-        return this.$androidProcessService.mapAbstractToTcpPort(deviceIdentifier, appIdentifier, framework);
+    mapAbstractToTcpPort(deviceIdentifier, appIdentifier, framework) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.$androidProcessService.mapAbstractToTcpPort(deviceIdentifier, appIdentifier, framework);
+        });
     }
     getDebuggableApps(deviceIdentifiers) {
         return _.map(deviceIdentifiers, (deviceIdentifier) => this.getDebuggableAppsCore(deviceIdentifier));
     }
-    async getDebuggableViews(deviceIdentifier, appIdentifier) {
-        const device = this.getDeviceByIdentifier(deviceIdentifier), debuggableViewsPerApp = await device.applicationManager.getDebuggableAppViews([appIdentifier]);
-        return debuggableViewsPerApp && debuggableViewsPerApp[appIdentifier];
+    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];
+        });
     }
     getDebuggableAppsCore(deviceIdentifier) {
         const device = this.getDeviceByIdentifier(deviceIdentifier);
         return device.applicationManager.getDebuggableApps();
     }
-    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);
+    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);
+        });
     }
     filterDevicesByPlatform() {
         return _.filter(this.getDeviceInstances(), (device) => {
@@ -679,52 +786,63 @@ class DevicesService extends events_1.EventEmitter {
         }
         return null;
     }
-    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,
+    /**
+     * 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);
+            }
         });
-        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);
-        }
     }
-    async executeCore(action, canExecute) {
-        if (this._device) {
-            return [await this.executeOnDevice(action, canExecute)];
-        }
-        return this.executeOnAllConnectedDevices(action, canExecute);
+    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 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,
-        };
+    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,
+            };
+        });
     }
     getDeviceLookingOptions(deviceInitOpts = {}) {
         const { shouldReturnImmediateResult, emulator } = deviceInitOpts;
@@ -747,7 +865,6 @@ 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([
@@ -801,4 +918,6 @@ __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