nativescript 8.9.0-dev.0 → 8.9.0-dev.2

package/lib/common/mobile/android/android-emulator-services.js

@@ -1,4 +1,13 @@
 "use strict";
+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.AndroidEmulatorServices = void 0;
 const constants_1 = require("../../constants");
@@ -18,99 +27,111 @@ class AndroidEmulatorServices {
         this.$logger = $logger;
         this.$utils = $utils;
     }
-    async getEmulatorImages() {
-        const adbDevicesOutput = await this.$adb.getDevicesSafe();
-        const avdAvailableEmulatorsOutput = await this.$androidVirtualDeviceService.getEmulatorImages(adbDevicesOutput);
-        const genyAvailableDevicesOutput = await this.$androidGenymotionService.getEmulatorImages(adbDevicesOutput);
-        const devices = _.concat(avdAvailableEmulatorsOutput.devices, genyAvailableDevicesOutput.devices).filter((item) => !!item);
-        return {
-            devices,
-            errors: avdAvailableEmulatorsOutput.errors.concat(genyAvailableDevicesOutput.errors),
-        };
+    getEmulatorImages() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adbDevicesOutput = yield this.$adb.getDevicesSafe();
+            const avdAvailableEmulatorsOutput = yield this.$androidVirtualDeviceService.getEmulatorImages(adbDevicesOutput);
+            const genyAvailableDevicesOutput = yield this.$androidGenymotionService.getEmulatorImages(adbDevicesOutput);
+            const devices = _.concat(avdAvailableEmulatorsOutput.devices, genyAvailableDevicesOutput.devices).filter((item) => !!item);
+            return {
+                devices,
+                errors: avdAvailableEmulatorsOutput.errors.concat(genyAvailableDevicesOutput.errors),
+            };
+        });
     }
-    async getRunningEmulatorIds() {
-        const adbDevicesOutput = await this.$adb.getDevicesSafe();
-        const avds = await this.$androidVirtualDeviceService.getRunningEmulatorIds(adbDevicesOutput);
-        const genies = await this.$androidGenymotionService.getRunningEmulatorIds(adbDevicesOutput);
-        return avds.concat(genies);
+    getRunningEmulatorIds() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adbDevicesOutput = yield this.$adb.getDevicesSafe();
+            const avds = yield this.$androidVirtualDeviceService.getRunningEmulatorIds(adbDevicesOutput);
+            const genies = yield this.$androidGenymotionService.getRunningEmulatorIds(adbDevicesOutput);
+            return avds.concat(genies);
+        });
     }
-    async getRunningEmulatorName(emulatorId) {
-        let result = await this.$androidVirtualDeviceService.getRunningEmulatorName(emulatorId);
-        if (!result) {
-            result = await this.$androidGenymotionService.getRunningEmulatorName(emulatorId);
-        }
-        return result;
+    getRunningEmulatorName(emulatorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = yield this.$androidVirtualDeviceService.getRunningEmulatorName(emulatorId);
+            if (!result) {
+                result = yield this.$androidGenymotionService.getRunningEmulatorName(emulatorId);
+            }
+            return result;
+        });
     }
-    async getRunningEmulatorImageIdentifier(emulatorId) {
-        let result = await this.$androidVirtualDeviceService.getRunningEmulatorImageIdentifier(emulatorId);
-        if (!result) {
-            result = await this.$androidGenymotionService.getRunningEmulatorImageIdentifier(emulatorId);
-        }
-        return result;
+    getRunningEmulatorImageIdentifier(emulatorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = yield this.$androidVirtualDeviceService.getRunningEmulatorImageIdentifier(emulatorId);
+            if (!result) {
+                result = yield this.$androidGenymotionService.getRunningEmulatorImageIdentifier(emulatorId);
+            }
+            return result;
+        });
     }
-    async startEmulator(options) {
-        const output = await this.startEmulatorCore(options);
-        let bootToCompleteOutput = null;
-        if (output && output.runningEmulator) {
-            bootToCompleteOutput = await this.waitForEmulatorBootToComplete(output.runningEmulator, output.endTimeEpoch, options.timeout);
-        }
-        return {
-            errors: ((output && output.errors) || []).concat((bootToCompleteOutput && bootToCompleteOutput.errors) || []),
-        };
+    startEmulator(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const output = yield this.startEmulatorCore(options);
+            let bootToCompleteOutput = null;
+            if (output && output.runningEmulator) {
+                bootToCompleteOutput = yield this.waitForEmulatorBootToComplete(output.runningEmulator, output.endTimeEpoch, options.timeout);
+            }
+            return {
+                errors: ((output && output.errors) || []).concat((bootToCompleteOutput && bootToCompleteOutput.errors) || []),
+            };
+        });
     }
     detach(deviceInfo) {
         this.$androidVirtualDeviceService.detach(deviceInfo);
     }
-    async startEmulatorCore(options) {
-        const timeout = options.timeout || constants_1.AndroidVirtualDevice.TIMEOUT_SECONDS;
-        const endTimeEpoch = (0, helpers_1.getCurrentEpochTime)() + this.$utils.getMilliSecondsTimeout(timeout);
-        const availableEmulators = (await this.getEmulatorImages()).devices;
-        let emulator = this.$emulatorHelper.getEmulatorByStartEmulatorOptions(options, availableEmulators);
-        if (!emulator &&
-            !options.emulatorIdOrName &&
-            !options.imageIdentifier &&
-            !options.emulator) {
-            emulator = this.getBestFit(availableEmulators);
-        }
-        if (!emulator) {
-            return {
-                runningEmulator: null,
-                errors: [
-                    `No emulator image available for device identifier '${options.emulatorIdOrName || options.imageIdentifier}'.`,
-                ],
-                endTimeEpoch,
-            };
-        }
-        if (emulator.errorHelp) {
-            return {
-                runningEmulator: null,
-                errors: [emulator.errorHelp],
-                endTimeEpoch,
-            };
-        }
-        this.spawnEmulator(emulator);
-        const isInfiniteWait = this.$utils.getMilliSecondsTimeout(timeout) === 0;
-        let hasTimeLeft = (0, helpers_1.getCurrentEpochTime)() < endTimeEpoch;
-        while (hasTimeLeft || isInfiniteWait) {
-            const emulators = (await this.getEmulatorImages()).devices;
-            const newEmulator = _.find(emulators, (e) => e.imageIdentifier === emulator.imageIdentifier);
-            if (newEmulator && this.$emulatorHelper.isEmulatorRunning(newEmulator)) {
+    startEmulatorCore(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const timeout = options.timeout || constants_1.AndroidVirtualDevice.TIMEOUT_SECONDS;
+            const endTimeEpoch = (0, helpers_1.getCurrentEpochTime)() + this.$utils.getMilliSecondsTimeout(timeout);
+            const availableEmulators = (yield this.getEmulatorImages()).devices;
+            let emulator = this.$emulatorHelper.getEmulatorByStartEmulatorOptions(options, availableEmulators);
+            if (!emulator &&
+                !options.emulatorIdOrName &&
+                !options.imageIdentifier &&
+                !options.emulator) {
+                emulator = this.getBestFit(availableEmulators);
+            }
+            if (!emulator) {
                 return {
-                    runningEmulator: newEmulator,
-                    errors: [],
+                    runningEmulator: null,
+                    errors: [
+                        `No emulator image available for device identifier '${options.emulatorIdOrName || options.imageIdentifier}'.`,
+                    ],
                     endTimeEpoch,
                 };
             }
-            await (0, helpers_1.sleep)(10000);
-            hasTimeLeft = (0, helpers_1.getCurrentEpochTime)() < endTimeEpoch;
-        }
-        if (!hasTimeLeft && !isInfiniteWait) {
-            return {
-                runningEmulator: null,
-                errors: [constants_1.AndroidVirtualDevice.UNABLE_TO_START_EMULATOR_MESSAGE],
-                endTimeEpoch,
-            };
-        }
+            if (emulator.errorHelp) {
+                return {
+                    runningEmulator: null,
+                    errors: [emulator.errorHelp],
+                    endTimeEpoch,
+                };
+            }
+            this.spawnEmulator(emulator);
+            const isInfiniteWait = this.$utils.getMilliSecondsTimeout(timeout) === 0;
+            let hasTimeLeft = (0, helpers_1.getCurrentEpochTime)() < endTimeEpoch;
+            while (hasTimeLeft || isInfiniteWait) {
+                const emulators = (yield this.getEmulatorImages()).devices;
+                const newEmulator = _.find(emulators, (e) => e.imageIdentifier === emulator.imageIdentifier);
+                if (newEmulator && this.$emulatorHelper.isEmulatorRunning(newEmulator)) {
+                    return {
+                        runningEmulator: newEmulator,
+                        errors: [],
+                        endTimeEpoch,
+                    };
+                }
+                yield (0, helpers_1.sleep)(10000); // the emulator definitely takes its time to wake up
+                hasTimeLeft = (0, helpers_1.getCurrentEpochTime)() < endTimeEpoch;
+            }
+            if (!hasTimeLeft && !isInfiniteWait) {
+                return {
+                    runningEmulator: null,
+                    errors: [constants_1.AndroidVirtualDevice.UNABLE_TO_START_EMULATOR_MESSAGE],
+                    endTimeEpoch,
+                };
+            }
+        });
     }
     spawnEmulator(emulator) {
         let pathToEmulatorExecutable = null;
@@ -148,33 +169,38 @@ class AndroidEmulatorServices {
         const bestVersion = best && best.version && semver.coerce(best.version);
         return bestVersion && semver.gte(bestVersion, minVersion) ? best : null;
     }
-    async waitForEmulatorBootToComplete(emulator, endTimeEpoch, timeout) {
-        this.$logger.info("Waiting for emulator device initialization...", {
-            [constants_2.LoggerConfigData.skipNewLine]: true,
-        });
-        const isInfiniteWait = this.$utils.getMilliSecondsTimeout(timeout || constants_1.AndroidVirtualDevice.TIMEOUT_SECONDS) === 0;
-        while ((0, helpers_1.getCurrentEpochTime)() < endTimeEpoch || isInfiniteWait) {
-            const isEmulatorBootCompleted = await this.isEmulatorBootCompleted(emulator.identifier);
-            if (isEmulatorBootCompleted) {
-                this.$logger.info(os_1.EOL, { [constants_2.LoggerConfigData.skipNewLine]: true });
-                return {
-                    runningEmulator: emulator,
-                    errors: [],
-                };
+    waitForEmulatorBootToComplete(emulator, endTimeEpoch, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.info("Waiting for emulator device initialization...", {
+                [constants_2.LoggerConfigData.skipNewLine]: true,
+            });
+            const isInfiniteWait = this.$utils.getMilliSecondsTimeout(timeout || constants_1.AndroidVirtualDevice.TIMEOUT_SECONDS) === 0;
+            while ((0, helpers_1.getCurrentEpochTime)() < endTimeEpoch || isInfiniteWait) {
+                const isEmulatorBootCompleted = yield this.isEmulatorBootCompleted(emulator.identifier);
+                if (isEmulatorBootCompleted) {
+                    this.$logger.info(os_1.EOL, { [constants_2.LoggerConfigData.skipNewLine]: true });
+                    return {
+                        runningEmulator: emulator,
+                        errors: [],
+                    };
+                }
+                this.$logger.info(".", { [constants_2.LoggerConfigData.skipNewLine]: true });
+                yield (0, helpers_1.sleep)(10000);
             }
-            this.$logger.info(".", { [constants_2.LoggerConfigData.skipNewLine]: true });
-            await (0, helpers_1.sleep)(10000);
-        }
-        return {
-            runningEmulator: null,
-            errors: [constants_1.AndroidVirtualDevice.UNABLE_TO_START_EMULATOR_MESSAGE],
-        };
+            return {
+                runningEmulator: null,
+                errors: [constants_1.AndroidVirtualDevice.UNABLE_TO_START_EMULATOR_MESSAGE],
+            };
+        });
     }
-    async isEmulatorBootCompleted(emulatorId) {
-        const output = await this.$adb.getPropertyValue(emulatorId, "dev.bootcomplete");
-        const matches = output.match("1");
-        return matches && matches.length > 0;
+    isEmulatorBootCompleted(emulatorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const output = yield this.$adb.getPropertyValue(emulatorId, "dev.bootcomplete");
+            const matches = output.match("1");
+            return matches && matches.length > 0;
+        });
     }
 }
 exports.AndroidEmulatorServices = AndroidEmulatorServices;
 yok_1.injector.register("androidEmulatorServices", AndroidEmulatorServices);
+//# sourceMappingURL=android-emulator-services.js.map

package/lib/common/mobile/android/android-ini-file-parser.js

@@ -12,6 +12,8 @@ class AndroidIniFileParser {
         if (!this.$fs.exists(iniFilePath)) {
             return null;
         }
+        // avd files can have different encoding, defined on the first line.
+        // find which one it is (if any) and use it to correctly read the file contents
         const encoding = this.getAvdEncoding(iniFilePath);
         const contents = this.$fs.readText(iniFilePath, encoding).split("\n");
         return _.reduce(contents, (result, line) => {
@@ -44,6 +46,8 @@ class AndroidIniFileParser {
         }, Object.create(null));
     }
     getAvdEncoding(avdName) {
+        // avd files can have different encoding, defined on the first line.
+        // find which one it is (if any) and use it to correctly read the file contents
         let encoding = "utf8";
         let contents = this.$fs.readText(avdName, "ascii");
         if (contents.length > 0) {
@@ -57,18 +61,22 @@ class AndroidIniFileParser {
         }
         return encoding;
     }
+    // Android L is not written as a number in the .ini files, and we need to convert it
     readTargetNum(target) {
         const platform = target.replace("android-", "");
         let platformNumber = +platform;
         if (isNaN(platformNumber)) {
+            // this may be a google image
             const googlePlatform = target.split(":")[2];
             if (googlePlatform) {
                 platformNumber = +googlePlatform;
             }
             else if (platform === "L") {
+                // Android SDK 20 preview
                 platformNumber = 20;
             }
             else if (platform === "MNC") {
+                // Android M preview
                 platformNumber = 22;
             }
         }
@@ -77,3 +85,4 @@ class AndroidIniFileParser {
 }
 exports.AndroidIniFileParser = AndroidIniFileParser;
 yok_1.injector.register("androidIniFileParser", AndroidIniFileParser);
+//# sourceMappingURL=android-ini-file-parser.js.map

package/lib/common/mobile/android/android-log-filter.js

@@ -36,7 +36,11 @@ class AndroidLogFilter {
         return consoleLogMessage;
     }
 }
-exports.AndroidLogFilter = AndroidLogFilter;
+//sample line is "I/Web Console(    4438): Received Event: deviceready at file:///storage/emulated/0/Icenium/com.telerik.TestApp/js/index.js:48"
 AndroidLogFilter.LINE_REGEX = /.\/(.+?)\s*\(\s*\d+?\): (.*)/;
+// sample line is "11-23 12:39:07.310  1584  1597 I art     : Background sticky concurrent mark sweep GC freed 21966(1780KB) AllocSpace objects, 4(80KB) LOS objects, 77% free, 840KB/3MB, paused 4.018ms total 158.629ms"
+// or '12-28 10:45:08.020  3329  3329 W chromium: [WARNING:data_reduction_proxy_settings.cc(328)] SPDY proxy OFF at startup'
 AndroidLogFilter.API_LEVEL_23_LINE_REGEX = /.+?\s+?(?:[A-Z]\s+?)([A-Za-z \.]+?)\s*?\: (.*)/;
+exports.AndroidLogFilter = AndroidLogFilter;
 yok_1.injector.register("androidLogFilter", AndroidLogFilter);
+//# sourceMappingURL=android-log-filter.js.map

package/lib/common/mobile/android/android-virtual-device-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.AndroidVirtualDeviceService = void 0;
 const net = require("net");
@@ -30,38 +39,44 @@ class AndroidVirtualDeviceService {
         this.mapEmulatorIdToImageIdentifier = {};
         this.androidHome = process.env.ANDROID_HOME;
     }
-    async getEmulatorImages(adbDevicesOutput) {
-        const availableEmulatorsOutput = await this.getEmulatorImagesCore();
-        const avds = availableEmulatorsOutput.devices;
-        const runningEmulatorIds = await this.getRunningEmulatorIds(adbDevicesOutput);
-        const runningEmulators = await (0, helpers_1.settlePromises)(_.map(runningEmulatorIds, (emulatorId) => this.getRunningEmulatorData(emulatorId, avds)));
-        const devices = availableEmulatorsOutput.devices.map((emulator) => this.$emulatorHelper.getEmulatorByImageIdentifier(emulator.imageIdentifier, runningEmulators) || emulator);
-        return {
-            devices,
-            errors: availableEmulatorsOutput.errors,
-        };
+    getEmulatorImages(adbDevicesOutput) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const availableEmulatorsOutput = yield this.getEmulatorImagesCore();
+            const avds = availableEmulatorsOutput.devices;
+            const runningEmulatorIds = yield this.getRunningEmulatorIds(adbDevicesOutput);
+            const runningEmulators = yield (0, helpers_1.settlePromises)(_.map(runningEmulatorIds, (emulatorId) => this.getRunningEmulatorData(emulatorId, avds)));
+            const devices = availableEmulatorsOutput.devices.map((emulator) => this.$emulatorHelper.getEmulatorByImageIdentifier(emulator.imageIdentifier, runningEmulators) || emulator);
+            return {
+                devices,
+                errors: availableEmulatorsOutput.errors,
+            };
+        });
     }
-    async getRunningEmulatorIds(adbDevicesOutput) {
-        const emulatorIds = _.reduce(adbDevicesOutput, (result, device) => {
-            const rx = device.match(constants_1.AndroidVirtualDevice.RUNNING_AVD_EMULATOR_REGEX);
-            if (rx && rx[1]) {
-                result.push(rx[1]);
+    getRunningEmulatorIds(adbDevicesOutput) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const emulatorIds = _.reduce(adbDevicesOutput, (result, device) => {
+                const rx = device.match(constants_1.AndroidVirtualDevice.RUNNING_AVD_EMULATOR_REGEX);
+                if (rx && rx[1]) {
+                    result.push(rx[1]);
+                }
+                return result;
+            }, []);
+            return emulatorIds;
+        });
+    }
+    getRunningEmulatorName(emulatorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const imageIdentifier = yield this.getRunningEmulatorImageIdentifier(emulatorId);
+            const iniFilePath = path.join(this.pathToAvdHomeDir, `${imageIdentifier}.ini`);
+            const iniFileInfo = this.$androidIniFileParser.parseIniFile(iniFilePath);
+            let result = imageIdentifier;
+            if (iniFileInfo && iniFileInfo.path) {
+                const configIniFileInfo = this.$androidIniFileParser.parseIniFile(path.join(iniFileInfo.path, constants_1.AndroidVirtualDevice.CONFIG_INI_FILE_NAME));
+                result =
+                    (configIniFileInfo && configIniFileInfo.displayName) || imageIdentifier;
             }
             return result;
-        }, []);
-        return emulatorIds;
-    }
-    async getRunningEmulatorName(emulatorId) {
-        const imageIdentifier = await this.getRunningEmulatorImageIdentifier(emulatorId);
-        const iniFilePath = path.join(this.pathToAvdHomeDir, `${imageIdentifier}.ini`);
-        const iniFileInfo = this.$androidIniFileParser.parseIniFile(iniFilePath);
-        let result = imageIdentifier;
-        if (iniFileInfo && iniFileInfo.path) {
-            const configIniFileInfo = this.$androidIniFileParser.parseIniFile(path.join(iniFileInfo.path, constants_1.AndroidVirtualDevice.CONFIG_INI_FILE_NAME));
-            result =
-                (configIniFileInfo && configIniFileInfo.displayName) || imageIdentifier;
-        }
-        return result;
+        });
     }
     startEmulatorArgs(imageIdentifier) {
         return ["-avd", imageIdentifier];
@@ -69,6 +84,9 @@ class AndroidVirtualDeviceService {
     get pathToEmulatorExecutable() {
         const emulatorExecutableName = "emulator";
         if (this.androidHome) {
+            // Check https://developer.android.com/studio/releases/sdk-tools.html (25.3.0)
+            // Since this version of SDK tools, the emulator is a separate package.
+            // However the emulator executable still exists in the "tools" dir.
             const pathToEmulatorFromAndroidStudio = path.join(this.androidHome, emulatorExecutableName, emulatorExecutableName);
             const realFilePath = this.$hostInfo.isWindows
                 ? `${pathToEmulatorFromAndroidStudio}.exe`
@@ -108,6 +126,17 @@ class AndroidVirtualDeviceService {
             client.on("data", (data) => {
                 output += data.toString();
                 const imageIdentifier = this.getImageIdentifierFromClientOutput(output);
+                // old output should look like:
+                // Android Console: type 'help' for a list of commands
+                // OK
+                // <Name of image>
+                // OK
+                // new output should look like:
+                // Android Console: type 'help' for a list of commands
+                // OK
+                // a\u001b[K\u001b[Dav\u001b[K\u001b[D\u001b[Davd\u001b...
+                // <Name of image>
+                // OK
                 if (imageIdentifier && !isResolved) {
                     this.mapEmulatorIdToImageIdentifier[emulatorId] = imageIdentifier;
                     this.clearNetConnection(client, timer);
@@ -125,56 +154,64 @@ class AndroidVirtualDeviceService {
             delete this.mapEmulatorIdToImageIdentifier[deviceInfo.identifier];
         }
     }
-    async getEmulatorImagesCore() {
-        let result = null;
-        let devices = [];
-        let errors = [];
-        const canExecuteAvdManagerCommand = await this.canExecuteAvdManagerCommand();
-        if (!canExecuteAvdManagerCommand) {
-            errors = [
-                "Unable to execute avdmanager, ensure JAVA_HOME is set and points to correct directory",
-            ];
-        }
-        if (canExecuteAvdManagerCommand) {
-            const sanitizedPathToAvdManagerExecutable = this.$hostInfo.isWindows
-                ? (0, helpers_1.quoteString)(this.pathToAvdManagerExecutable)
-                : this.pathToAvdManagerExecutable;
-            result = await this.$childProcess.trySpawnFromCloseEvent(sanitizedPathToAvdManagerExecutable, ["list", "avds"], { shell: this.$hostInfo.isWindows });
-        }
-        else if (this.pathToAndroidExecutable &&
-            this.$fs.exists(this.pathToAndroidExecutable)) {
-            result = await this.$childProcess.trySpawnFromCloseEvent(this.pathToAndroidExecutable, ["list", "avd"]);
-        }
-        if (result && result.stdout) {
-            devices = this.parseListAvdsOutput(result.stdout);
-            errors = result && result.stderr ? [result.stderr] : [];
-        }
-        else {
-            devices = this.listAvdsFromDirectory();
-        }
-        return { devices, errors };
-    }
-    async canExecuteAvdManagerCommand() {
-        let canExecute = false;
-        if (this.pathToAvdManagerExecutable &&
-            this.$fs.exists(this.pathToAvdManagerExecutable)) {
-            if (process.env.JAVA_HOME) {
-                canExecute = !!(await this.$sysInfo.getJavaVersionFromJavaHome());
+    getEmulatorImagesCore() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = null;
+            let devices = [];
+            let errors = [];
+            const canExecuteAvdManagerCommand = yield this.canExecuteAvdManagerCommand();
+            if (!canExecuteAvdManagerCommand) {
+                errors = [
+                    "Unable to execute avdmanager, ensure JAVA_HOME is set and points to correct directory",
+                ];
+            }
+            if (canExecuteAvdManagerCommand) {
+                const sanitizedPathToAvdManagerExecutable = this.$hostInfo.isWindows
+                    ? (0, helpers_1.quoteString)(this.pathToAvdManagerExecutable)
+                    : this.pathToAvdManagerExecutable;
+                result = yield this.$childProcess.trySpawnFromCloseEvent(sanitizedPathToAvdManagerExecutable, ["list", "avds"], { shell: this.$hostInfo.isWindows });
+            }
+            else if (this.pathToAndroidExecutable &&
+                this.$fs.exists(this.pathToAndroidExecutable)) {
+                result = yield this.$childProcess.trySpawnFromCloseEvent(this.pathToAndroidExecutable, ["list", "avd"]);
+            }
+            if (result && result.stdout) {
+                devices = this.parseListAvdsOutput(result.stdout);
+                errors = result && result.stderr ? [result.stderr] : [];
             }
             else {
-                canExecute = !!(await this.$sysInfo.getJavaVersionFromPath());
+                devices = this.listAvdsFromDirectory();
             }
-        }
-        return canExecute;
+            return { devices, errors };
+        });
     }
-    async getRunningEmulatorData(runningEmulatorId, availableEmulators) {
-        const imageIdentifier = await this.getRunningEmulatorImageIdentifier(runningEmulatorId);
-        const runningEmulator = this.$emulatorHelper.getEmulatorByImageIdentifier(imageIdentifier, availableEmulators);
-        if (!runningEmulator) {
-            return null;
-        }
-        this.$emulatorHelper.setRunningAndroidEmulatorProperties(runningEmulatorId, runningEmulator);
-        return runningEmulator;
+    canExecuteAvdManagerCommand() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let canExecute = false;
+            if (this.pathToAvdManagerExecutable &&
+                this.$fs.exists(this.pathToAvdManagerExecutable)) {
+                if (process.env.JAVA_HOME) {
+                    // In case JAVA_HOME is set, but it points to incorrect directory (i.e. there's no java in $JAVA_HOME/bin/java), avdmanager will fail
+                    // no matter if you have correct java in PATH.
+                    canExecute = !!(yield this.$sysInfo.getJavaVersionFromJavaHome());
+                }
+                else {
+                    canExecute = !!(yield this.$sysInfo.getJavaVersionFromPath());
+                }
+            }
+            return canExecute;
+        });
+    }
+    getRunningEmulatorData(runningEmulatorId, availableEmulators) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const imageIdentifier = yield this.getRunningEmulatorImageIdentifier(runningEmulatorId);
+            const runningEmulator = this.$emulatorHelper.getEmulatorByImageIdentifier(imageIdentifier, availableEmulators);
+            if (!runningEmulator) {
+                return null;
+            }
+            this.$emulatorHelper.setRunningAndroidEmulatorProperties(runningEmulatorId, runningEmulator);
+            return runningEmulator;
+        });
     }
     get pathToAvdManagerExecutable() {
         let avdManagerPath = null;
@@ -230,6 +267,13 @@ class AndroidVirtualDeviceService {
         const avdOutput = output.split(constants_1.AndroidVirtualDevice.AVAILABLE_AVDS_MESSAGE);
         const availableDevices = avdOutput && avdOutput[1] && avdOutput[1].trim();
         if (availableDevices) {
+            // In some cases `avdmanager list avds` command prints:
+            //	`The following Android Virtual Devices could not be loaded:
+            //	Name: Pixel_2_XL_API_28
+            //	Path: /Users/<username>/.android/avd/Pixel_2_XL_API_28.avd
+            //	Error: Google pixel_2_xl no longer exists as a device`
+            // These devices sometimes are valid so try to parse them.
+            // Also these devices are printed at the end of the output and are separated with 2 new lines from the valid devices output.
             const parts = availableDevices.split(/(?:\r?\n){2}/);
             const items = [parts[0], parts[1]].filter((item) => !!item);
             for (const item of items) {
@@ -246,6 +290,7 @@ class AndroidVirtualDeviceService {
     }
     getAvdManagerDeviceInfo(output) {
         const avdManagerDeviceInfo = Object.create(null);
+        // Split by `\n`, not EOL as the avdmanager and android executables print results with `\n` only even on Windows
         _.reduce(output.split("\n"), (result, row) => {
             const [key, value] = row.split(": ").map((part) => part.trim());
             switch (key) {
@@ -292,6 +337,7 @@ class AndroidVirtualDeviceService {
         };
     }
     getImageIdentifierFromClientOutput(output) {
+        // The lines should be trimmed after the split because the output has \r\n and when using split(EOL) on mac each line ends with \r.
         const lines = _.map(output.split(os_1.EOL), (line) => line.trim());
         const firstIndexOfOk = _.indexOf(lines, "OK");
         if (firstIndexOfOk < 0) {
@@ -320,7 +366,6 @@ class AndroidVirtualDeviceService {
         }
     }
 }
-exports.AndroidVirtualDeviceService = AndroidVirtualDeviceService;
 __decorate([
     (0, decorators_1.cache)()
 ], AndroidVirtualDeviceService.prototype, "pathToEmulatorExecutable", null);
@@ -339,4 +384,6 @@ __decorate([
 __decorate([
     (0, decorators_1.cache)()
 ], AndroidVirtualDeviceService.prototype, "getConfigurationError", null);
+exports.AndroidVirtualDeviceService = AndroidVirtualDeviceService;
 yok_1.injector.register("androidVirtualDeviceService", AndroidVirtualDeviceService);
+//# sourceMappingURL=android-virtual-device-service.js.map