nativescript 8.9.0-alpha.3 → 8.9.0-dev.1

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

@@ -1,13 +1,4 @@
 "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");
@@ -27,111 +18,99 @@ class AndroidEmulatorServices {
         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),
-            };
-        });
+    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),
+        };
     }
-    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 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);
     }
-    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 getRunningEmulatorName(emulatorId) {
+        let result = await this.$androidVirtualDeviceService.getRunningEmulatorName(emulatorId);
+        if (!result) {
+            result = await 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;
-        });
+    async getRunningEmulatorImageIdentifier(emulatorId) {
+        let result = await this.$androidVirtualDeviceService.getRunningEmulatorImageIdentifier(emulatorId);
+        if (!result) {
+            result = await 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) || []),
-            };
-        });
+    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) || []),
+        };
     }
     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) {
+    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)) {
                 return {
-                    runningEmulator: null,
-                    errors: [constants_1.AndroidVirtualDevice.UNABLE_TO_START_EMULATOR_MESSAGE],
+                    runningEmulator: newEmulator,
+                    errors: [],
                     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,
+            };
+        }
     }
     spawnEmulator(emulator) {
         let pathToEmulatorExecutable = null;
@@ -169,36 +148,32 @@ class AndroidEmulatorServices {
         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],
-            };
+    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: [],
+                };
+            }
+            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],
+        };
     }
-    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;
-        });
+    async isEmulatorBootCompleted(emulatorId) {
+        const output = await this.$adb.getPropertyValue(emulatorId, "dev.bootcomplete");
+        const matches = output.match("1");
+        return matches && matches.length > 0;
     }
 }
 exports.AndroidEmulatorServices = AndroidEmulatorServices;

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

@@ -15,27 +15,29 @@ class AndroidIniFileParser {
         const encoding = this.getAvdEncoding(iniFilePath);
         const contents = this.$fs.readText(iniFilePath, encoding).split("\n");
         return _.reduce(contents, (result, line) => {
+            var _a, _b;
             const parsedLine = line.split("=");
-            const key = parsedLine[0];
+            const key = (_a = parsedLine[0]) === null || _a === void 0 ? void 0 : _a.trim();
+            const value = (_b = parsedLine[1]) === null || _b === void 0 ? void 0 : _b.trim();
             switch (key) {
                 case "target":
-                    result.target = parsedLine[1];
+                    result.target = value;
                     result.targetNum = this.readTargetNum(result.target);
                     break;
                 case "path":
                 case "AvdId":
-                    result[_.lowerFirst(key)] = parsedLine[1];
+                    result[_.lowerFirst(key)] = value;
                     break;
                 case "hw.device.name":
-                    result.device = parsedLine[1];
+                    result.device = value;
                     break;
                 case "avd.ini.displayname":
-                    result.displayName = parsedLine[1];
+                    result.displayName = value;
                     break;
                 case "abi.type":
                 case "skin.name":
                 case "sdcard.size":
-                    result[key.split(".")[0]] = parsedLine[1];
+                    result[key.split(".")[0]] = value;
                     break;
             }
             return result;

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

@@ -36,7 +36,7 @@ class AndroidLogFilter {
         return consoleLogMessage;
     }
 }
+exports.AndroidLogFilter = AndroidLogFilter;
 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

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AndroidVirtualDeviceService = void 0;
 const net = require("net");
@@ -39,44 +30,38 @@ class AndroidVirtualDeviceService {
         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;
-        });
+    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,
+        };
     }
-    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;
+    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]);
             }
             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];
@@ -140,62 +125,56 @@ class AndroidVirtualDeviceService {
             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) {
-                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] : [];
+    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());
             }
             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());
-                }
+                canExecute = !!(await this.$sysInfo.getJavaVersionFromPath());
             }
-            return canExecute;
-        });
+        }
+        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;
-        });
+    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;
     }
     get pathToAvdManagerExecutable() {
         let avdManagerPath = null;
@@ -341,6 +320,7 @@ class AndroidVirtualDeviceService {
         }
     }
 }
+exports.AndroidVirtualDeviceService = AndroidVirtualDeviceService;
 __decorate([
     (0, decorators_1.cache)()
 ], AndroidVirtualDeviceService.prototype, "pathToEmulatorExecutable", null);
@@ -359,5 +339,4 @@ __decorate([
 __decorate([
     (0, decorators_1.cache)()
 ], AndroidVirtualDeviceService.prototype, "getConfigurationError", null);
-exports.AndroidVirtualDeviceService = AndroidVirtualDeviceService;
 yok_1.injector.register("androidVirtualDeviceService", AndroidVirtualDeviceService);

package/lib/common/mobile/android/device-android-debug-bridge.js

@@ -1,13 +1,4 @@
 "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.DeviceAndroidDebugBridge = void 0;
 const android_debug_bridge_1 = require("./android-debug-bridge");
@@ -22,27 +13,20 @@ class DeviceAndroidDebugBridge extends android_debug_bridge_1.AndroidDebugBridge
         this.$staticConfig = $staticConfig;
         this.$androidDebugBridgeResultHandler = $androidDebugBridgeResultHandler;
     }
-    sendBroadcastToDevice(action, extras) {
-        return __awaiter(this, void 0, void 0, function* () {
-            extras = extras || {};
-            const broadcastCommand = ["am", "broadcast", "-a", `${action}`];
-            _.each(extras, (value, key) => broadcastCommand.push("-e", key, value));
-            const result = yield this.executeShellCommand(broadcastCommand);
-            this.$logger.trace(`Broadcast result ${result} from ${broadcastCommand}`);
-            const match = result.match(/Broadcast completed: result=(\d+)/);
-            if (match) {
-                return +match[1];
-            }
-            this.$errors.fail("Unable to broadcast to android device:\n%s", result);
-        });
+    async sendBroadcastToDevice(action, extras) {
+        extras = extras || {};
+        const broadcastCommand = ["am", "broadcast", "-a", `${action}`];
+        _.each(extras, (value, key) => broadcastCommand.push("-e", key, value));
+        const result = await this.executeShellCommand(broadcastCommand);
+        this.$logger.trace(`Broadcast result ${result} from ${broadcastCommand}`);
+        const match = result.match(/Broadcast completed: result=(\d+)/);
+        if (match) {
+            return +match[1];
+        }
+        this.$errors.fail("Unable to broadcast to android device:\n%s", result);
     }
-    composeCommand(params) {
-        const _super = Object.create(null, {
-            composeCommand: { get: () => super.composeCommand }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            return _super.composeCommand.call(this, params, this.identifier);
-        });
+    async composeCommand(params) {
+        return super.composeCommand(params, this.identifier);
     }
 }
 exports.DeviceAndroidDebugBridge = DeviceAndroidDebugBridge;