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

package/lib/common/mobile/mobile-core/android-device-discovery.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.AndroidDeviceDiscovery = void 0;
 const device_discovery_1 = require("./device-discovery");
@@ -22,69 +13,59 @@ class AndroidDeviceDiscovery extends device_discovery_1.DeviceDiscovery {
         this.$mobileHelper = $mobileHelper;
         this._devices = [];
     }
-    createAndAddDevice(adbDeviceInfo) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._devices.push(adbDeviceInfo);
-            const device = this.$injector.resolve(android_device_1.AndroidDevice, { identifier: adbDeviceInfo.identifier, status: adbDeviceInfo.status });
-            yield device.init();
-            this.addDevice(device);
-        });
+    async createAndAddDevice(adbDeviceInfo) {
+        this._devices.push(adbDeviceInfo);
+        const device = this.$injector.resolve(android_device_1.AndroidDevice, { identifier: adbDeviceInfo.identifier, status: adbDeviceInfo.status });
+        await device.init();
+        this.addDevice(device);
     }
     deleteAndRemoveDevice(deviceIdentifier) {
         _.remove(this._devices, (d) => d.identifier === deviceIdentifier);
         this.removeDevice(deviceIdentifier);
     }
-    startLookingForDevices(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (options &&
-                options.platform &&
-                !this.$mobileHelper.isAndroidPlatform(options.platform)) {
-                return;
-            }
-            yield this.ensureAdbServerStarted();
-            yield this.checkForDevices();
-        });
+    async startLookingForDevices(options) {
+        if (options &&
+            options.platform &&
+            !this.$mobileHelper.isAndroidPlatform(options.platform)) {
+            return;
+        }
+        await this.ensureAdbServerStarted();
+        await this.checkForDevices();
     }
-    checkForDevices() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const devices = yield this.$adb.getDevices();
-            yield this.checkCurrentData(devices);
-        });
+    async checkForDevices() {
+        const devices = await this.$adb.getDevices();
+        await this.checkCurrentData(devices);
     }
-    checkCurrentData(result) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentDevices = result.map((element) => {
-                const data = element.split("\t");
-                const identifier = data[0];
-                const status = data[1];
-                return {
-                    identifier: identifier,
-                    status: status,
-                };
-            });
-            _(this._devices)
-                .reject((d) => (_.find(currentDevices, (device) => device.identifier === d.identifier && device.status === d.status)))
-                .each((d) => this.deleteAndRemoveDevice(d.identifier));
-            yield Promise.all(_(currentDevices)
-                .reject((d) => (_.find(this._devices, (device) => device.identifier === d.identifier &&
-                device.status === d.status)))
-                .map((d) => this.createAndAddDevice(d))
-                .value());
+    async checkCurrentData(result) {
+        const currentDevices = result.map((element) => {
+            const data = element.split("\t");
+            const identifier = data[0];
+            const status = data[1];
+            return {
+                identifier: identifier,
+                status: status,
+            };
         });
+        _(this._devices)
+            .reject((d) => (_.find(currentDevices, (device) => device.identifier === d.identifier && device.status === d.status)))
+            .each((d) => this.deleteAndRemoveDevice(d.identifier));
+        await Promise.all(_(currentDevices)
+            .reject((d) => (_.find(this._devices, (device) => device.identifier === d.identifier &&
+            device.status === d.status)))
+            .map((d) => this.createAndAddDevice(d))
+            .value());
     }
-    ensureAdbServerStarted() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isStarted) {
-                this.isStarted = true;
-                try {
-                    return yield this.$adb.executeCommand(["start-server"]);
-                }
-                catch (err) {
-                    this.isStarted = false;
-                    throw err;
-                }
+    async ensureAdbServerStarted() {
+        if (!this.isStarted) {
+            this.isStarted = true;
+            try {
+                return await this.$adb.executeCommand(["start-server"]);
             }
-        });
+            catch (err) {
+                this.isStarted = false;
+                throw err;
+            }
+        }
     }
 }
 exports.AndroidDeviceDiscovery = AndroidDeviceDiscovery;

package/lib/common/mobile/mobile-core/android-emulator-discovery.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.AndroidEmulatorDiscovery = void 0;
 const events_1 = require("events");
@@ -21,29 +12,27 @@ class AndroidEmulatorDiscovery extends events_1.EventEmitter {
         this.$mobileHelper = $mobileHelper;
         this._emulators = {};
     }
-    startLookingForDevices(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (options &&
-                options.platform &&
-                !this.$mobileHelper.isAndroidPlatform(options.platform)) {
-                return;
-            }
-            const availableEmulatorsOutput = yield this.$androidEmulatorServices.getEmulatorImages();
-            const currentEmulators = availableEmulatorsOutput.devices;
-            const cachedEmulators = _.values(this._emulators);
-            const lostEmulators = _(cachedEmulators)
-                .reject((e) => _.some(currentEmulators, (emulator) => emulator && e && emulator.imageIdentifier === e.imageIdentifier))
-                .value();
-            const foundEmulators = _(currentEmulators)
-                .reject((e) => _.some(cachedEmulators, (emulator) => emulator && e && emulator.imageIdentifier === e.imageIdentifier))
-                .value();
-            if (lostEmulators.length) {
-                this.raiseOnEmulatorImagesLost(lostEmulators);
-            }
-            if (foundEmulators.length) {
-                this.raiseOnEmulatorImagesFound(foundEmulators);
-            }
-        });
+    async startLookingForDevices(options) {
+        if (options &&
+            options.platform &&
+            !this.$mobileHelper.isAndroidPlatform(options.platform)) {
+            return;
+        }
+        const availableEmulatorsOutput = await this.$androidEmulatorServices.getEmulatorImages();
+        const currentEmulators = availableEmulatorsOutput.devices;
+        const cachedEmulators = _.values(this._emulators);
+        const lostEmulators = _(cachedEmulators)
+            .reject((e) => _.some(currentEmulators, (emulator) => emulator && e && emulator.imageIdentifier === e.imageIdentifier))
+            .value();
+        const foundEmulators = _(currentEmulators)
+            .reject((e) => _.some(cachedEmulators, (emulator) => emulator && e && emulator.imageIdentifier === e.imageIdentifier))
+            .value();
+        if (lostEmulators.length) {
+            this.raiseOnEmulatorImagesLost(lostEmulators);
+        }
+        if (foundEmulators.length) {
+            this.raiseOnEmulatorImagesFound(foundEmulators);
+        }
     }
     getDevices() {
         return _.values(this._emulators);

package/lib/common/mobile/mobile-core/android-process-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.AndroidProcessService = void 0;
 const os_1 = require("os");
@@ -32,162 +23,140 @@ class AndroidProcessService {
         this._devicesAdbs = {};
         this._forwardedLocalPorts = {};
     }
-    forwardFreeTcpToAbstractPort(portForwardInputData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const adb = yield this.setupForPortForwarding(portForwardInputData);
-            return this.forwardPort(portForwardInputData, adb);
-        });
+    async forwardFreeTcpToAbstractPort(portForwardInputData) {
+        const adb = await this.setupForPortForwarding(portForwardInputData);
+        return this.forwardPort(portForwardInputData, adb);
     }
-    mapAbstractToTcpPort(deviceIdentifier, appIdentifier, framework) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const adb = yield this.setupForPortForwarding({
-                deviceIdentifier,
-                appIdentifier,
-            });
-            const processId = (yield this.getProcessIds(adb, [appIdentifier]))[appIdentifier];
-            const applicationNotStartedErrorMessage = `The application is not started on the device with identifier ${deviceIdentifier}.`;
+    async mapAbstractToTcpPort(deviceIdentifier, appIdentifier, framework) {
+        const adb = await this.setupForPortForwarding({
+            deviceIdentifier,
+            appIdentifier,
+        });
+        const processId = (await this.getProcessIds(adb, [appIdentifier]))[appIdentifier];
+        const applicationNotStartedErrorMessage = `The application is not started on the device with identifier ${deviceIdentifier}.`;
+        if (!processId) {
+            this.$errors.fail(applicationNotStartedErrorMessage);
+        }
+        const abstractPortsInformation = await this.getAbstractPortsInformation(adb);
+        const abstractPort = await this.getAbstractPortForApplication(adb, processId, appIdentifier, abstractPortsInformation, framework);
+        if (!abstractPort) {
+            this.$errors.fail(applicationNotStartedErrorMessage);
+        }
+        const forwardedTcpPort = await this.forwardPort({
+            deviceIdentifier,
+            appIdentifier,
+            abstractPort: `localabstract:${abstractPort}`,
+        }, adb);
+        return forwardedTcpPort && forwardedTcpPort.toString();
+    }
+    async getMappedAbstractToTcpPorts(deviceIdentifier, appIdentifiers, framework) {
+        const adb = this.getAdb(deviceIdentifier), abstractPortsInformation = await this.getAbstractPortsInformation(adb), processIds = await this.getProcessIds(adb, appIdentifiers), adbForwardList = await adb.executeCommand(["forward", "--list"]), localPorts = {};
+        await Promise.all(_.map(appIdentifiers, async (appIdentifier) => {
+            localPorts[appIdentifier] = null;
+            const processId = processIds[appIdentifier];
             if (!processId) {
-                this.$errors.fail(applicationNotStartedErrorMessage);
+                return;
             }
-            const abstractPortsInformation = yield this.getAbstractPortsInformation(adb);
-            const abstractPort = yield this.getAbstractPortForApplication(adb, processId, appIdentifier, abstractPortsInformation, framework);
+            const abstractPort = await this.getAbstractPortForApplication(adb, processId, appIdentifier, abstractPortsInformation, framework);
             if (!abstractPort) {
-                this.$errors.fail(applicationNotStartedErrorMessage);
-            }
-            const forwardedTcpPort = yield this.forwardPort({
-                deviceIdentifier,
-                appIdentifier,
-                abstractPort: `localabstract:${abstractPort}`,
-            }, adb);
-            return forwardedTcpPort && forwardedTcpPort.toString();
-        });
-    }
-    getMappedAbstractToTcpPorts(deviceIdentifier, appIdentifiers, framework) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const adb = this.getAdb(deviceIdentifier), abstractPortsInformation = yield this.getAbstractPortsInformation(adb), processIds = yield this.getProcessIds(adb, appIdentifiers), adbForwardList = yield adb.executeCommand(["forward", "--list"]), localPorts = {};
-            yield Promise.all(_.map(appIdentifiers, (appIdentifier) => __awaiter(this, void 0, void 0, function* () {
-                localPorts[appIdentifier] = null;
-                const processId = processIds[appIdentifier];
-                if (!processId) {
-                    return;
-                }
-                const abstractPort = yield this.getAbstractPortForApplication(adb, processId, appIdentifier, abstractPortsInformation, framework);
-                if (!abstractPort) {
-                    return;
-                }
-                const localPort = yield this.getAlreadyMappedPort(adb, deviceIdentifier, abstractPort, adbForwardList);
-                if (localPort) {
-                    localPorts[appIdentifier] = localPort;
-                }
-            })));
-            return localPorts;
-        });
-    }
-    getDebuggableApps(deviceIdentifier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const adb = this.getAdb(deviceIdentifier);
-            const androidWebViewPortInformation = (yield this.getAbstractPortsInformation(adb)).split(os_1.EOL);
-            const portInformation = yield Promise.all(_.map(androidWebViewPortInformation, (line) => __awaiter(this, void 0, void 0, function* () {
-                return (yield this.getApplicationInfoFromWebViewPortInformation(adb, deviceIdentifier, line)) ||
-                    (yield this.getNativeScriptApplicationInformation(adb, deviceIdentifier, line));
-            })));
-            return _(portInformation)
-                .filter((deviceAppInfo) => !!deviceAppInfo)
-                .groupBy((element) => element.framework)
-                .map((group) => _.uniqBy(group, (g) => g.appIdentifier))
-                .flatten()
-                .value();
-        });
-    }
-    getAppProcessId(deviceIdentifier, appIdentifier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const adb = this.getAdb(deviceIdentifier);
-            const processId = (yield this.getProcessIds(adb, [appIdentifier]))[appIdentifier];
-            return processId ? processId.toString() : null;
-        });
-    }
-    forwardPort(portForwardInputData, adb) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let localPort = yield this.getAlreadyMappedPort(adb, portForwardInputData.deviceIdentifier, portForwardInputData.abstractPort);
-            if (!localPort) {
-                localPort = yield this.$net.getFreePort();
-                yield adb.executeCommand(["forward", `tcp:${localPort}`, portForwardInputData.abstractPort], { deviceIdentifier: portForwardInputData.deviceIdentifier });
-            }
-            this._forwardedLocalPorts[portForwardInputData.deviceIdentifier] = localPort;
-            yield this.$cleanupService.addCleanupCommand({
-                command: yield this.$staticConfig.getAdbFilePath(),
-                args: [
-                    "-s",
-                    portForwardInputData.deviceIdentifier,
-                    "forward",
-                    "--remove",
-                    `tcp:${localPort}`,
-                ],
-            });
-            return localPort && +localPort;
-        });
-    }
-    setupForPortForwarding(portForwardInputData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const adb = this.getAdb(portForwardInputData.deviceIdentifier);
-            return adb;
-        });
-    }
-    getApplicationInfoFromWebViewPortInformation(adb, deviceIdentifier, information) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const processIdRegExp = /@webview_devtools_remote_(.+)/g;
-            const processIdMatches = processIdRegExp.exec(information);
-            let cordovaAppIdentifier;
-            if (processIdMatches) {
-                const processId = processIdMatches[1];
-                cordovaAppIdentifier = yield this.getApplicationIdentifierFromPid(adb, processId);
-            }
-            else {
-                const chromeAppIdentifierRegExp = /@(.+)_devtools_remote\s?/g;
-                const chromeAppIdentifierMatches = chromeAppIdentifierRegExp.exec(information);
-                if (chromeAppIdentifierMatches && chromeAppIdentifierMatches.length > 0) {
-                    cordovaAppIdentifier = chromeAppIdentifierMatches[1];
-                }
-            }
-            if (cordovaAppIdentifier) {
-                return {
-                    deviceIdentifier: deviceIdentifier,
-                    appIdentifier: cordovaAppIdentifier,
-                    framework: constants_1.TARGET_FRAMEWORK_IDENTIFIERS.Cordova,
-                };
+                return;
             }
-            return null;
-        });
-    }
-    getNativeScriptApplicationInformation(adb, deviceIdentifier, information) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const nativeScriptAppIdentifierRegExp = /@(.+)-(debug|inspectorServer)/g;
-            const nativeScriptAppIdentifierMatches = nativeScriptAppIdentifierRegExp.exec(information);
-            if (nativeScriptAppIdentifierMatches &&
-                nativeScriptAppIdentifierMatches.length > 0) {
-                const appIdentifier = nativeScriptAppIdentifierMatches[1];
-                return {
-                    deviceIdentifier: deviceIdentifier,
-                    appIdentifier: appIdentifier,
-                    framework: constants_1.TARGET_FRAMEWORK_IDENTIFIERS.NativeScript,
-                };
+            const localPort = await this.getAlreadyMappedPort(adb, deviceIdentifier, abstractPort, adbForwardList);
+            if (localPort) {
+                localPorts[appIdentifier] = localPort;
             }
-            return null;
+        }));
+        return localPorts;
+    }
+    async getDebuggableApps(deviceIdentifier) {
+        const adb = this.getAdb(deviceIdentifier);
+        const androidWebViewPortInformation = (await this.getAbstractPortsInformation(adb)).split(os_1.EOL);
+        const portInformation = await Promise.all(_.map(androidWebViewPortInformation, async (line) => (await this.getApplicationInfoFromWebViewPortInformation(adb, deviceIdentifier, line)) ||
+            (await this.getNativeScriptApplicationInformation(adb, deviceIdentifier, line))));
+        return _(portInformation)
+            .filter((deviceAppInfo) => !!deviceAppInfo)
+            .groupBy((element) => element.framework)
+            .map((group) => _.uniqBy(group, (g) => g.appIdentifier))
+            .flatten()
+            .value();
+    }
+    async getAppProcessId(deviceIdentifier, appIdentifier) {
+        const adb = this.getAdb(deviceIdentifier);
+        const processId = (await this.getProcessIds(adb, [appIdentifier]))[appIdentifier];
+        return processId ? processId.toString() : null;
+    }
+    async forwardPort(portForwardInputData, adb) {
+        let localPort = await this.getAlreadyMappedPort(adb, portForwardInputData.deviceIdentifier, portForwardInputData.abstractPort);
+        if (!localPort) {
+            localPort = await this.$net.getFreePort();
+            await adb.executeCommand(["forward", `tcp:${localPort}`, portForwardInputData.abstractPort], { deviceIdentifier: portForwardInputData.deviceIdentifier });
+        }
+        this._forwardedLocalPorts[portForwardInputData.deviceIdentifier] = localPort;
+        await this.$cleanupService.addCleanupCommand({
+            command: await this.$staticConfig.getAdbFilePath(),
+            args: [
+                "-s",
+                portForwardInputData.deviceIdentifier,
+                "forward",
+                "--remove",
+                `tcp:${localPort}`,
+            ],
         });
-    }
-    getAbstractPortForApplication(adb, processId, appIdentifier, abstractPortsInformation, framework) {
-        return __awaiter(this, void 0, void 0, function* () {
-            framework = framework || "";
-            switch (framework.toLowerCase()) {
-                case constants_1.TARGET_FRAMEWORK_IDENTIFIERS.Cordova.toLowerCase():
-                    return this.getCordovaPortInformation(abstractPortsInformation, appIdentifier, processId);
-                case constants_1.TARGET_FRAMEWORK_IDENTIFIERS.NativeScript.toLowerCase():
-                    return this.getNativeScriptPortInformation(abstractPortsInformation, appIdentifier);
-                default:
-                    return (this.getCordovaPortInformation(abstractPortsInformation, appIdentifier, processId) ||
-                        this.getNativeScriptPortInformation(abstractPortsInformation, appIdentifier));
+        return localPort && +localPort;
+    }
+    async setupForPortForwarding(portForwardInputData) {
+        const adb = this.getAdb(portForwardInputData.deviceIdentifier);
+        return adb;
+    }
+    async getApplicationInfoFromWebViewPortInformation(adb, deviceIdentifier, information) {
+        const processIdRegExp = /@webview_devtools_remote_(.+)/g;
+        const processIdMatches = processIdRegExp.exec(information);
+        let cordovaAppIdentifier;
+        if (processIdMatches) {
+            const processId = processIdMatches[1];
+            cordovaAppIdentifier = await this.getApplicationIdentifierFromPid(adb, processId);
+        }
+        else {
+            const chromeAppIdentifierRegExp = /@(.+)_devtools_remote\s?/g;
+            const chromeAppIdentifierMatches = chromeAppIdentifierRegExp.exec(information);
+            if (chromeAppIdentifierMatches && chromeAppIdentifierMatches.length > 0) {
+                cordovaAppIdentifier = chromeAppIdentifierMatches[1];
             }
-        });
+        }
+        if (cordovaAppIdentifier) {
+            return {
+                deviceIdentifier: deviceIdentifier,
+                appIdentifier: cordovaAppIdentifier,
+                framework: constants_1.TARGET_FRAMEWORK_IDENTIFIERS.Cordova,
+            };
+        }
+        return null;
+    }
+    async getNativeScriptApplicationInformation(adb, deviceIdentifier, information) {
+        const nativeScriptAppIdentifierRegExp = /@(.+)-(debug|inspectorServer)/g;
+        const nativeScriptAppIdentifierMatches = nativeScriptAppIdentifierRegExp.exec(information);
+        if (nativeScriptAppIdentifierMatches &&
+            nativeScriptAppIdentifierMatches.length > 0) {
+            const appIdentifier = nativeScriptAppIdentifierMatches[1];
+            return {
+                deviceIdentifier: deviceIdentifier,
+                appIdentifier: appIdentifier,
+                framework: constants_1.TARGET_FRAMEWORK_IDENTIFIERS.NativeScript,
+            };
+        }
+        return null;
+    }
+    async getAbstractPortForApplication(adb, processId, appIdentifier, abstractPortsInformation, framework) {
+        framework = framework || "";
+        switch (framework.toLowerCase()) {
+            case constants_1.TARGET_FRAMEWORK_IDENTIFIERS.Cordova.toLowerCase():
+                return this.getCordovaPortInformation(abstractPortsInformation, appIdentifier, processId);
+            case constants_1.TARGET_FRAMEWORK_IDENTIFIERS.NativeScript.toLowerCase():
+                return this.getNativeScriptPortInformation(abstractPortsInformation, appIdentifier);
+            default:
+                return (this.getCordovaPortInformation(abstractPortsInformation, appIdentifier, processId) ||
+                    this.getNativeScriptPortInformation(abstractPortsInformation, appIdentifier));
+        }
     }
     getCordovaPortInformation(abstractPortsInformation, appIdentifier, processId) {
         return (this.getPortInformation(abstractPortsInformation, `${appIdentifier}_devtools_remote`) || this.getPortInformation(abstractPortsInformation, processId));
@@ -195,33 +164,27 @@ class AndroidProcessService {
     getNativeScriptPortInformation(abstractPortsInformation, appIdentifier) {
         return this.getPortInformation(abstractPortsInformation, `${appIdentifier}-debug`);
     }
-    getAbstractPortsInformation(adb) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return adb.executeShellCommand(["cat", "/proc/net/unix"]);
-        });
+    async getAbstractPortsInformation(adb) {
+        return adb.executeShellCommand(["cat", "/proc/net/unix"]);
     }
     getPortInformation(abstractPortsInformation, searchedInfo) {
         const processRegExp = new RegExp(`\\w+:\\s+(?:\\w+\\s+){1,6}@(.*?${searchedInfo})$`, "gm");
         const match = processRegExp.exec(abstractPortsInformation);
         return match && match[1];
     }
-    getProcessIds(adb, appIdentifiers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = {};
-            const processIdInformation = yield adb.executeShellCommand(["ps"]);
-            _.each(appIdentifiers, (appIdentifier) => {
-                const processIdRegExp = new RegExp(`^\\w*\\s*(\\d+).*?${appIdentifier}$`);
-                result[appIdentifier] = this.getFirstMatchingGroupFromMultilineResult(processIdInformation, processIdRegExp);
-            });
-            return result;
+    async getProcessIds(adb, appIdentifiers) {
+        const result = {};
+        const processIdInformation = await adb.executeShellCommand(["ps"]);
+        _.each(appIdentifiers, (appIdentifier) => {
+            const processIdRegExp = new RegExp(`^\\w*\\s*(\\d+).*?${appIdentifier}$`);
+            result[appIdentifier] = this.getFirstMatchingGroupFromMultilineResult(processIdInformation, processIdRegExp);
         });
+        return result;
     }
-    getAlreadyMappedPort(adb, deviceIdentifier, abstractPort, adbForwardList) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const allForwardedPorts = adbForwardList || (yield adb.executeCommand(["forward", "--list"])) || "";
-            const regex = new RegExp(`${deviceIdentifier}\\s+?tcp:(\\d+?)\\s+?.*?${abstractPort}$`);
-            return this.getFirstMatchingGroupFromMultilineResult(allForwardedPorts, regex);
-        });
+    async getAlreadyMappedPort(adb, deviceIdentifier, abstractPort, adbForwardList) {
+        const allForwardedPorts = adbForwardList || (await adb.executeCommand(["forward", "--list"])) || "";
+        const regex = new RegExp(`${deviceIdentifier}\\s+?tcp:(\\d+?)\\s+?.*?${abstractPort}$`);
+        return this.getFirstMatchingGroupFromMultilineResult(allForwardedPorts, regex);
     }
     getAdb(deviceIdentifier) {
         if (!this._devicesAdbs[deviceIdentifier]) {
@@ -231,11 +194,9 @@ class AndroidProcessService {
         }
         return this._devicesAdbs[deviceIdentifier];
     }
-    getApplicationIdentifierFromPid(adb, pid, psData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            psData = psData || (yield adb.executeShellCommand(["ps"]));
-            return this.getFirstMatchingGroupFromMultilineResult(psData, new RegExp(`\\s+${pid}(?:\\s+\\d+){3}\\s+.*\\s+(.*?)$`));
-        });
+    async getApplicationIdentifierFromPid(adb, pid, psData) {
+        psData = psData || (await adb.executeShellCommand(["ps"]));
+        return this.getFirstMatchingGroupFromMultilineResult(psData, new RegExp(`\\s+${pid}(?:\\s+\\d+){3}\\s+.*\\s+(.*?)$`));
     }
     getFirstMatchingGroupFromMultilineResult(input, regex) {
         let result;
@@ -252,8 +213,8 @@ class AndroidProcessService {
         return result;
     }
 }
+exports.AndroidProcessService = AndroidProcessService;
 __decorate([
     (0, decorators_1.exported)("androidProcessService")
 ], AndroidProcessService.prototype, "getAppProcessId", null);
-exports.AndroidProcessService = AndroidProcessService;
 yok_1.injector.register("androidProcessService", AndroidProcessService);

package/lib/common/mobile/mobile-core/device-discovery.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.DeviceDiscovery = void 0;
 const events_1 = require("events");
@@ -19,10 +10,8 @@ class DeviceDiscovery extends events_1.EventEmitter {
         super(...arguments);
         this.devices = {};
     }
-    startLookingForDevices() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
+    async startLookingForDevices() {
+        return;
     }
     getDevice(deviceIdentifier) {
         const device = this.devices[deviceIdentifier];