@akylas/nativescript-cli 8.7.2

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

@@ -0,0 +1,205 @@
+"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");
+const helpers_1 = require("../../helpers");
+const os_1 = require("os");
+const _ = require("lodash");
+const constants_2 = require("../../../constants");
+const yok_1 = require("../../yok");
+const semver = require("semver");
+class AndroidEmulatorServices {
+    constructor($androidGenymotionService, $androidVirtualDeviceService, $adb, $childProcess, $emulatorHelper, $logger, $utils) {
+        this.$androidGenymotionService = $androidGenymotionService;
+        this.$androidVirtualDeviceService = $androidVirtualDeviceService;
+        this.$adb = $adb;
+        this.$childProcess = $childProcess;
+        this.$emulatorHelper = $emulatorHelper;
+        this.$logger = $logger;
+        this.$utils = $utils;
+    }
+    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),
+            };
+        });
+    }
+    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);
+        });
+    }
+    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;
+        });
+    }
+    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;
+        });
+    }
+    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);
+    }
+    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: 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 = (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);
+                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;
+        let startEmulatorArgs = null;
+        if (emulator.vendor === constants_1.AndroidVirtualDevice.AVD_VENDOR_NAME) {
+            pathToEmulatorExecutable = this.$androidVirtualDeviceService
+                .pathToEmulatorExecutable;
+            startEmulatorArgs = this.$androidVirtualDeviceService.startEmulatorArgs(emulator.imageIdentifier);
+        }
+        else if (emulator.vendor === constants_1.AndroidVirtualDevice.GENYMOTION_VENDOR_NAME) {
+            pathToEmulatorExecutable = this.$androidGenymotionService
+                .pathToEmulatorExecutable;
+            startEmulatorArgs = this.$androidGenymotionService.startEmulatorArgs(emulator.imageIdentifier);
+        }
+        this.$logger.info(`Starting Android emulator with image ${emulator.imageIdentifier}`);
+        const childProcess = this.$childProcess.spawn(pathToEmulatorExecutable, startEmulatorArgs, { stdio: "ignore", detached: true });
+        childProcess.unref();
+        childProcess.on("error", (err) => {
+            this.$logger.trace(`Error when starting emulator. More info: ${err}`);
+        });
+    }
+    getBestFit(emulators) {
+        let best = null;
+        for (const emulator of emulators) {
+            const currentVersion = emulator.version && semver.coerce(emulator.version);
+            const currentBestVersion = best && best.version && semver.coerce(best.version);
+            if (!best ||
+                (currentVersion &&
+                    currentBestVersion &&
+                    semver.gt(currentVersion, currentBestVersion))) {
+                best = emulator;
+            }
+        }
+        const minVersion = semver.coerce(constants_1.AndroidVirtualDevice.MIN_ANDROID_VERSION);
+        const bestVersion = best && best.version && semver.coerce(best.version);
+        return bestVersion && semver.gte(bestVersion, minVersion) ? best : null;
+    }
+    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);
+            }
+            return {
+                runningEmulator: null,
+                errors: [constants_1.AndroidVirtualDevice.UNABLE_TO_START_EMULATOR_MESSAGE],
+            };
+        });
+    }
+    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);

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidIniFileParser = void 0;
+const constants_1 = require("../../constants");
+const _ = require("lodash");
+const yok_1 = require("../../yok");
+class AndroidIniFileParser {
+    constructor($fs) {
+        this.$fs = $fs;
+    }
+    parseIniFile(iniFilePath) {
+        if (!this.$fs.exists(iniFilePath)) {
+            return null;
+        }
+        const encoding = this.getAvdEncoding(iniFilePath);
+        const contents = this.$fs.readText(iniFilePath, encoding).split("\n");
+        return _.reduce(contents, (result, line) => {
+            const parsedLine = line.split("=");
+            const key = parsedLine[0];
+            switch (key) {
+                case "target":
+                    result.target = parsedLine[1];
+                    result.targetNum = this.readTargetNum(result.target);
+                    break;
+                case "path":
+                case "AvdId":
+                    result[_.lowerFirst(key)] = parsedLine[1];
+                    break;
+                case "hw.device.name":
+                    result.device = parsedLine[1];
+                    break;
+                case "avd.ini.displayname":
+                    result.displayName = parsedLine[1];
+                    break;
+                case "abi.type":
+                case "skin.name":
+                case "sdcard.size":
+                    result[key.split(".")[0]] = parsedLine[1];
+                    break;
+            }
+            return result;
+        }, Object.create(null));
+    }
+    getAvdEncoding(avdName) {
+        let encoding = "utf8";
+        let contents = this.$fs.readText(avdName, "ascii");
+        if (contents.length > 0) {
+            contents = contents.split("\n", 1)[0];
+            if (contents.length > 0) {
+                const matches = contents.match(constants_1.AndroidVirtualDevice.ENCODING_MASK);
+                if (matches) {
+                    encoding = matches[1];
+                }
+            }
+        }
+        return encoding;
+    }
+    readTargetNum(target) {
+        const platform = target.replace("android-", "");
+        let platformNumber = +platform;
+        if (isNaN(platformNumber)) {
+            const googlePlatform = target.split(":")[2];
+            if (googlePlatform) {
+                platformNumber = +googlePlatform;
+            }
+            else if (platform === "L") {
+                platformNumber = 20;
+            }
+            else if (platform === "MNC") {
+                platformNumber = 22;
+            }
+        }
+        return platformNumber;
+    }
+}
+exports.AndroidIniFileParser = AndroidIniFileParser;
+yok_1.injector.register("androidIniFileParser", AndroidIniFileParser);

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidLogFilter = void 0;
+const yok_1 = require("../../yok");
+const os_1 = require("os");
+class AndroidLogFilter {
+    constructor($loggingLevels) {
+        this.$loggingLevels = $loggingLevels;
+    }
+    filterData(data, loggingOptions = {}) {
+        const specifiedLogLevel = (loggingOptions.logLevel || "").toUpperCase();
+        if (specifiedLogLevel === this.$loggingLevels.info) {
+            const log = this.getConsoleLogFromLine(data, loggingOptions.applicationPid);
+            if (log) {
+                if (log.tag) {
+                    return (`${log.tag === "JS" ? "" : `${log.tag}: `}${log.message}` + os_1.EOL);
+                }
+                else {
+                    return log.message + os_1.EOL;
+                }
+            }
+            return null;
+        }
+        return data + os_1.EOL;
+    }
+    getConsoleLogFromLine(lineText, pid) {
+        if (pid && lineText.indexOf(pid) === -1) {
+            return null;
+        }
+        let consoleLogMessage;
+        const match = lineText.match(AndroidLogFilter.API_LEVEL_23_LINE_REGEX) ||
+            lineText.match(AndroidLogFilter.LINE_REGEX);
+        if (match) {
+            consoleLogMessage = { tag: match[1].trim(), message: match[2] };
+        }
+        return consoleLogMessage;
+    }
+}
+AndroidLogFilter.LINE_REGEX = /.\/(.+?)\s*\(\s*\d+?\): (.*)/;
+AndroidLogFilter.API_LEVEL_23_LINE_REGEX = /.+?\s+?(?:[A-Z]\s+?)([A-Za-z \.]+?)\s*?\: (.*)/;
+exports.AndroidLogFilter = AndroidLogFilter;
+yok_1.injector.register("androidLogFilter", AndroidLogFilter);

package/lib/common/mobile/android/android-virtual-device-service.js

@@ -0,0 +1,360 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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");
+const path = require("path");
+const os_1 = require("os");
+const _ = require("lodash");
+const os_2 = require("os");
+const constants_1 = require("../../constants");
+const decorators_1 = require("../../decorators");
+const helpers_1 = require("../../helpers");
+const constants_2 = require("../../../constants");
+const yok_1 = require("../../yok");
+class AndroidVirtualDeviceService {
+    constructor($androidIniFileParser, $childProcess, $devicePlatformsConstants, $emulatorHelper, $fs, $hostInfo, $sysInfo, $logger) {
+        this.$androidIniFileParser = $androidIniFileParser;
+        this.$childProcess = $childProcess;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$emulatorHelper = $emulatorHelper;
+        this.$fs = $fs;
+        this.$hostInfo = $hostInfo;
+        this.$sysInfo = $sysInfo;
+        this.$logger = $logger;
+        this.mapEmulatorIdToImageIdentifier = {};
+        this.androidHome = process.env.ANDROID_HOME;
+    }
+    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,
+            };
+        });
+    }
+    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;
+        });
+    }
+    startEmulatorArgs(imageIdentifier) {
+        return ["-avd", imageIdentifier];
+    }
+    get pathToEmulatorExecutable() {
+        const emulatorExecutableName = "emulator";
+        if (this.androidHome) {
+            const pathToEmulatorFromAndroidStudio = path.join(this.androidHome, emulatorExecutableName, emulatorExecutableName);
+            const realFilePath = this.$hostInfo.isWindows
+                ? `${pathToEmulatorFromAndroidStudio}.exe`
+                : pathToEmulatorFromAndroidStudio;
+            if (this.$fs.exists(realFilePath)) {
+                return pathToEmulatorFromAndroidStudio;
+            }
+            return path.join(this.androidHome, "tools", emulatorExecutableName);
+        }
+        return emulatorExecutableName;
+    }
+    getRunningEmulatorImageIdentifier(emulatorId) {
+        if (this.mapEmulatorIdToImageIdentifier[emulatorId]) {
+            return Promise.resolve(this.mapEmulatorIdToImageIdentifier[emulatorId]);
+        }
+        const match = emulatorId.match(/^emulator-(\d+)/);
+        const portNumber = match && match[1];
+        if (!portNumber) {
+            return Promise.resolve(null);
+        }
+        return new Promise((resolveBase) => {
+            let isResolved = false;
+            let output = "";
+            const resolve = (result) => {
+                if (!isResolved) {
+                    isResolved = true;
+                    resolveBase(result);
+                }
+            };
+            const client = net.connect(portNumber, () => {
+                client.write(`avd name${os_1.EOL}`);
+            });
+            const timer = setTimeout(() => {
+                this.clearNetConnection(client, timer);
+                resolve(null);
+            }, 5000);
+            client.on("data", (data) => {
+                output += data.toString();
+                const imageIdentifier = this.getImageIdentifierFromClientOutput(output);
+                if (imageIdentifier && !isResolved) {
+                    this.mapEmulatorIdToImageIdentifier[emulatorId] = imageIdentifier;
+                    this.clearNetConnection(client, timer);
+                    resolve(imageIdentifier);
+                }
+            });
+            client.on("error", (error) => {
+                this.$logger.trace(`Error while checking emulator identifier for ${emulatorId}. More info: ${error}.`);
+                resolve(null);
+            });
+        });
+    }
+    detach(deviceInfo) {
+        if (this.mapEmulatorIdToImageIdentifier[deviceInfo.identifier]) {
+            delete this.mapEmulatorIdToImageIdentifier[deviceInfo.identifier];
+        }
+    }
+    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) {
+                result = yield this.$childProcess.trySpawnFromCloseEvent(this.pathToAvdManagerExecutable, ["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 {
+                devices = this.listAvdsFromDirectory();
+            }
+            return { devices, errors };
+        });
+    }
+    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) {
+                    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;
+        if (this.androidHome) {
+            avdManagerPath = path.join(this.androidHome, "tools", "bin", this.getExecutableName("avdmanager"));
+        }
+        return avdManagerPath;
+    }
+    get pathToAndroidExecutable() {
+        let androidPath = null;
+        if (this.androidHome) {
+            androidPath = path.join(this.androidHome, "tools", this.getExecutableName("android"));
+        }
+        return androidPath;
+    }
+    get pathToAvdHomeDir() {
+        const searchPaths = [
+            process.env.ANDROID_AVD_HOME,
+            path.join((0, os_2.homedir)(), constants_1.AndroidVirtualDevice.ANDROID_DIR_NAME, constants_1.AndroidVirtualDevice.AVD_DIR_NAME),
+        ];
+        return searchPaths.find((p) => p && this.$fs.exists(p));
+    }
+    getConfigurationError() {
+        const pathToEmulatorExecutable = this.$hostInfo.isWindows
+            ? `${this.pathToEmulatorExecutable}.exe`
+            : this.pathToEmulatorExecutable;
+        if (!this.$fs.exists(pathToEmulatorExecutable)) {
+            return "Unable to find the path to emulator executable and will not be able to start the emulator. Searched paths: [$ANDROID_HOME/tools/emulator, $ANDROID_HOME/emulator/emulator]";
+        }
+        return null;
+    }
+    getExecutableName(executable) {
+        if (this.$hostInfo.isWindows) {
+            return `${executable}.bat`;
+        }
+        return executable;
+    }
+    listAvdsFromDirectory() {
+        let devices = [];
+        if (this.pathToAvdHomeDir && this.$fs.exists(this.pathToAvdHomeDir)) {
+            const entries = this.$fs.readDirectory(this.pathToAvdHomeDir);
+            devices = _.filter(entries, (e) => e.match(constants_1.AndroidVirtualDevice.AVD_FILES_MASK) !== null)
+                .map((e) => e.match(constants_1.AndroidVirtualDevice.AVD_FILES_MASK)[1])
+                .map((avdName) => path.join(this.pathToAvdHomeDir, `${avdName}.avd`))
+                .map((avdPath) => this.getInfoFromAvd(avdPath))
+                .filter((avdInfo) => !!avdInfo)
+                .map((avdInfo) => this.convertAvdToDeviceInfo(avdInfo));
+        }
+        return devices;
+    }
+    parseListAvdsOutput(output) {
+        let devices = [];
+        const avdOutput = output.split(constants_1.AndroidVirtualDevice.AVAILABLE_AVDS_MESSAGE);
+        const availableDevices = avdOutput && avdOutput[1] && avdOutput[1].trim();
+        if (availableDevices) {
+            const parts = availableDevices.split(/(?:\r?\n){2}/);
+            const items = [parts[0], parts[1]].filter((item) => !!item);
+            for (const item of items) {
+                const result = item
+                    .split(constants_1.AndroidVirtualDevice.AVD_LIST_DELIMITER)
+                    .map((singleDeviceOutput) => this.getAvdManagerDeviceInfo(singleDeviceOutput.trim()))
+                    .map((avdManagerDeviceInfo) => this.getInfoFromAvd(avdManagerDeviceInfo.path))
+                    .filter((avdInfo) => !!avdInfo)
+                    .map((avdInfo) => this.convertAvdToDeviceInfo(avdInfo));
+                devices = devices.concat(result);
+            }
+        }
+        return devices;
+    }
+    getAvdManagerDeviceInfo(output) {
+        const avdManagerDeviceInfo = Object.create(null);
+        _.reduce(output.split("\n"), (result, row) => {
+            const [key, value] = row.split(": ").map((part) => part.trim());
+            switch (key) {
+                case "Name":
+                case "Device":
+                case "Path":
+                case "Target":
+                case "Skin":
+                case "Sdcard":
+                    result[key.toLowerCase()] = value;
+                    break;
+            }
+            return result;
+        }, avdManagerDeviceInfo || {});
+        return avdManagerDeviceInfo;
+    }
+    getInfoFromAvd(avdFilePath) {
+        const configIniFilePath = path.join(avdFilePath, constants_1.AndroidVirtualDevice.CONFIG_INI_FILE_NAME);
+        const configIniFileInfo = this.$androidIniFileParser.parseIniFile(configIniFilePath);
+        const iniFilePath = this.getIniFilePath(configIniFileInfo, avdFilePath);
+        const iniFileInfo = this.$androidIniFileParser.parseIniFile(iniFilePath);
+        _.extend(configIniFileInfo, iniFileInfo);
+        if (configIniFileInfo && !configIniFileInfo.avdId) {
+            configIniFileInfo.avdId = path
+                .basename(avdFilePath)
+                .replace(constants_1.AndroidVirtualDevice.AVD_FILE_EXTENSION, "");
+        }
+        return configIniFileInfo;
+    }
+    convertAvdToDeviceInfo(avdInfo) {
+        return {
+            identifier: null,
+            imageIdentifier: avdInfo.avdId || avdInfo.displayName,
+            displayName: avdInfo.displayName || avdInfo.avdId || avdInfo.device,
+            model: avdInfo.device,
+            version: this.$emulatorHelper.mapAndroidApiLevelToVersion[avdInfo.target],
+            vendor: constants_1.AndroidVirtualDevice.AVD_VENDOR_NAME,
+            status: constants_1.NOT_RUNNING_EMULATOR_STATUS,
+            errorHelp: this.getConfigurationError(),
+            isTablet: false,
+            type: constants_1.DeviceTypes.Emulator,
+            connectionTypes: [constants_2.DeviceConnectionType.Local],
+            platform: this.$devicePlatformsConstants.Android,
+        };
+    }
+    getImageIdentifierFromClientOutput(output) {
+        const lines = _.map(output.split(os_1.EOL), (line) => line.trim());
+        const firstIndexOfOk = _.indexOf(lines, "OK");
+        if (firstIndexOfOk < 0) {
+            return null;
+        }
+        const secondIndexOfOk = _.indexOf(lines, "OK", firstIndexOfOk + 1);
+        if (secondIndexOfOk < 0) {
+            return null;
+        }
+        return lines[secondIndexOfOk - 1].trim();
+    }
+    getIniFilePath(configIniFileInfo, avdFilePath) {
+        let result = avdFilePath.replace(constants_1.AndroidVirtualDevice.AVD_FILE_EXTENSION, constants_1.AndroidVirtualDevice.INI_FILE_EXTENSION);
+        if (configIniFileInfo && configIniFileInfo.avdId) {
+            result = path.join(path.dirname(avdFilePath), `${configIniFileInfo.avdId}${constants_1.AndroidVirtualDevice.INI_FILE_EXTENSION}`);
+        }
+        return result;
+    }
+    clearNetConnection(client, timer) {
+        if (client) {
+            client.removeAllListeners();
+            client.destroy();
+        }
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], AndroidVirtualDeviceService.prototype, "pathToEmulatorExecutable", null);
+__decorate([
+    (0, decorators_1.cache)()
+], AndroidVirtualDeviceService.prototype, "canExecuteAvdManagerCommand", null);
+__decorate([
+    (0, decorators_1.cache)()
+], AndroidVirtualDeviceService.prototype, "pathToAvdManagerExecutable", null);
+__decorate([
+    (0, decorators_1.cache)()
+], AndroidVirtualDeviceService.prototype, "pathToAndroidExecutable", null);
+__decorate([
+    (0, decorators_1.cache)()
+], AndroidVirtualDeviceService.prototype, "pathToAvdHomeDir", null);
+__decorate([
+    (0, decorators_1.cache)()
+], AndroidVirtualDeviceService.prototype, "getConfigurationError", null);
+exports.AndroidVirtualDeviceService = AndroidVirtualDeviceService;
+yok_1.injector.register("androidVirtualDeviceService", AndroidVirtualDeviceService);