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

package/lib/common/mobile/mobile-core/android-process-service.js

@@ -5,6 +5,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AndroidProcessService = void 0;
 const os_1 = require("os");
@@ -23,140 +32,182 @@ class AndroidProcessService {
         this._devicesAdbs = {};
         this._forwardedLocalPorts = {};
     }
-    async forwardFreeTcpToAbstractPort(portForwardInputData) {
-        const adb = await this.setupForPortForwarding(portForwardInputData);
-        return this.forwardPort(portForwardInputData, adb);
-    }
-    async mapAbstractToTcpPort(deviceIdentifier, appIdentifier, framework) {
-        const adb = await this.setupForPortForwarding({
-            deviceIdentifier,
-            appIdentifier,
+    forwardFreeTcpToAbstractPort(portForwardInputData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adb = yield this.setupForPortForwarding(portForwardInputData);
+            return this.forwardPort(portForwardInputData, adb);
         });
-        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];
+    }
+    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}.`;
             if (!processId) {
-                return;
+                this.$errors.fail(applicationNotStartedErrorMessage);
             }
-            const abstractPort = await this.getAbstractPortForApplication(adb, processId, appIdentifier, abstractPortsInformation, framework);
+            const abstractPortsInformation = yield this.getAbstractPortsInformation(adb);
+            const abstractPort = yield this.getAbstractPortForApplication(adb, processId, appIdentifier, abstractPortsInformation, framework);
             if (!abstractPort) {
-                return;
+                this.$errors.fail(applicationNotStartedErrorMessage);
             }
-            const localPort = await this.getAlreadyMappedPort(adb, deviceIdentifier, abstractPort, adbForwardList);
-            if (localPort) {
-                localPorts[appIdentifier] = localPort;
+            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 });
             }
-        }));
-        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}`,
-            ],
+            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;
         });
-        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];
+    }
+    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);
             }
-        }
-        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));
-        }
+            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 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,
+                };
+            }
+            return null;
+        });
+    }
+    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));
+            }
+        });
     }
     getCordovaPortInformation(abstractPortsInformation, appIdentifier, processId) {
         return (this.getPortInformation(abstractPortsInformation, `${appIdentifier}_devtools_remote`) || this.getPortInformation(abstractPortsInformation, processId));
@@ -164,27 +215,41 @@ class AndroidProcessService {
     getNativeScriptPortInformation(abstractPortsInformation, appIdentifier) {
         return this.getPortInformation(abstractPortsInformation, `${appIdentifier}-debug`);
     }
-    async getAbstractPortsInformation(adb) {
-        return adb.executeShellCommand(["cat", "/proc/net/unix"]);
+    getAbstractPortsInformation(adb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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];
     }
-    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);
+    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;
         });
-        return result;
     }
-    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);
+    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);
+        });
     }
     getAdb(deviceIdentifier) {
         if (!this._devicesAdbs[deviceIdentifier]) {
@@ -194,9 +259,14 @@ class AndroidProcessService {
         }
         return this._devicesAdbs[deviceIdentifier];
     }
-    async getApplicationIdentifierFromPid(adb, pid, psData) {
-        psData = psData || (await adb.executeShellCommand(["ps"]));
-        return this.getFirstMatchingGroupFromMultilineResult(psData, new RegExp(`\\s+${pid}(?:\\s+\\d+){3}\\s+.*\\s+(.*?)$`));
+    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+(.*?)$`));
+        });
     }
     getFirstMatchingGroupFromMultilineResult(input, regex) {
         let result;
@@ -213,8 +283,9 @@ 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,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceDiscovery = void 0;
 const events_1 = require("events");
@@ -10,8 +19,10 @@ class DeviceDiscovery extends events_1.EventEmitter {
         super(...arguments);
         this.devices = {};
     }
-    async startLookingForDevices() {
-        return;
+    startLookingForDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
     }
     getDevice(deviceIdentifier) {
         const device = this.devices[deviceIdentifier];
@@ -51,3 +62,4 @@ class DeviceDiscovery extends events_1.EventEmitter {
 }
 exports.DeviceDiscovery = DeviceDiscovery;
 yok_1.injector.register("deviceDiscovery", DeviceDiscovery);
+//# sourceMappingURL=device-discovery.js.map