nativescript 8.9.0-dev.2 → 8.9.0-dev.3

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,182 +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);
-            // TODO: Add tests and make sure only unique names are returned. Input before groupBy is:
-            // [ { deviceIdentifier: 'SH26BW100473',
-            // 	appIdentifier: 'com.telerik.EmptyNS',
-            // 	framework: 'NativeScript' },
-            // 	{ deviceIdentifier: 'SH26BW100473',
-            // 	appIdentifier: 'com.telerik.EmptyNS',
-            // 	framework: 'Cordova' },
-            // 	{ deviceIdentifier: 'SH26BW100473',
-            // 	appIdentifier: 'chrome',
-            // 	framework: 'Cordova' },
-            // 	{ deviceIdentifier: 'SH26BW100473',
-            // 	appIdentifier: 'chrome',
-            // 	framework: 'Cordova' } ]
-            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* () {
-            // Need to search by processId to check for old Android webviews (@webview_devtools_remote_<processId>).
-            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 {
-                // Search for appIdentifier (@<appIdentifier>_devtools_remote).
-                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* () {
-            // Search for appIdentifier (@<appIdentifier-debug>).
-            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* () {
-            // The result will look like this (without the columns names):
-            // Num       		 RefCount Protocol Flags    Type St Inode  Path
-            // 0000000000000000: 00000002 00000000 00010000 0001 01 189004 @webview_devtools_remote_25512
-            // The Path column is the abstract port.
-            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));
@@ -215,41 +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* () {
-            // Process information will look like this (without the columns names):
-            // USER     PID   PPID  VSIZE   RSS   WCHAN    PC         NAME
-            // u0_a63   25512 1334  1519560 96040 ffffffff f76a8f75 S com.telerik.appbuildertabstest
-            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"])) || "";
-            // Sample output:
-            // 5e2e580b tcp:62503 localabstract:webview_devtools_remote_7985
-            // 5e2e580b tcp:62524 localabstract:webview_devtools_remote_7986
-            // 5e2e580b tcp:63160 localabstract:webview_devtools_remote_7987
-            // 5e2e580b tcp:57577 localabstract:com.telerik.nrel-debug
-            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]) {
@@ -259,14 +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"]));
-            // Process information will look like this (without the columns names):
-            // USER     PID   PPID  VSIZE   RSS   WCHAN    PC         NAME
-            // u0_a63   25512 1334  1519560 96040 ffffffff f76a8f75 S com.telerik.appbuildertabstest
-            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;
@@ -283,9 +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);
-//# sourceMappingURL=android-process-service.js.map

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];
@@ -62,4 +51,3 @@ class DeviceDiscovery extends events_1.EventEmitter {
 }
 exports.DeviceDiscovery = DeviceDiscovery;
 yok_1.injector.register("deviceDiscovery", DeviceDiscovery);
-//# sourceMappingURL=device-discovery.js.map