@akylas/nativescript-cli 8.7.2

package/lib/common/mobile/ios/simulator/ios-simulator-file-system.js

@@ -0,0 +1,81 @@
+"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.IOSSimulatorFileSystem = void 0;
+const path = require("path");
+const shelljs = require("shelljs");
+const _ = require("lodash");
+class IOSSimulatorFileSystem {
+    constructor(iosSim, $fs, $logger) {
+        this.iosSim = iosSim;
+        this.$fs = $fs;
+        this.$logger = $logger;
+    }
+    listFiles(devicePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.iosSim.listFiles(devicePath);
+        });
+    }
+    getFile(deviceFilePath, appIdentifier, outputFilePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (outputFilePath) {
+                shelljs.cp("-f", deviceFilePath, outputFilePath);
+            }
+        });
+    }
+    getFileContent(deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = this.$fs.readText(deviceFilePath);
+            return result;
+        });
+    }
+    putFile(localFilePath, deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            shelljs.cp("-f", localFilePath, deviceFilePath);
+        });
+    }
+    deleteFile(deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            shelljs.rm("-rf", deviceFilePath);
+        });
+    }
+    transferFiles(deviceAppData, localToDevicePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(_.map(localToDevicePaths, (localToDevicePathData) => this.transferFile(localToDevicePathData.getLocalPath(), localToDevicePathData.getDevicePath())));
+            return localToDevicePaths;
+        });
+    }
+    transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const destinationPath = yield deviceAppData.getDeviceProjectRootPath();
+            this.$logger.trace(`Transferring from ${projectFilesPath} to ${destinationPath}`);
+            const sourcePath = path.join(projectFilesPath, "*");
+            shelljs.cp("-Rf", sourcePath, destinationPath);
+            return localToDevicePaths;
+        });
+    }
+    transferFile(localFilePath, deviceFilePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.trace(`Transferring from ${localFilePath} to ${deviceFilePath}`);
+            if (this.$fs.getFsStats(localFilePath).isDirectory()) {
+                this.$fs.ensureDirectoryExists(deviceFilePath);
+            }
+            else {
+                this.$fs.ensureDirectoryExists(path.dirname(deviceFilePath));
+                shelljs.cp("-f", localFilePath, deviceFilePath);
+            }
+        });
+    }
+    updateHashesOnDevice(hashes, appIdentifier) {
+        return;
+    }
+}
+exports.IOSSimulatorFileSystem = IOSSimulatorFileSystem;

package/lib/common/mobile/ios/simulator/ios-simulator-log-provider.js

@@ -0,0 +1,69 @@
+"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.IOSSimulatorLogProvider = void 0;
+const events_1 = require("events");
+const _ = require("lodash");
+const yok_1 = require("../../../yok");
+class IOSSimulatorLogProvider extends events_1.EventEmitter {
+    constructor($iOSSimResolver, $logger, $devicePlatformsConstants, $deviceLogProvider) {
+        super();
+        this.$iOSSimResolver = $iOSSimResolver;
+        this.$logger = $logger;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$deviceLogProvider = $deviceLogProvider;
+        this.simulatorsLoggingEnabled = {};
+        this.simulatorsLogProcess = {};
+        this.shouldDispose = true;
+    }
+    setShouldDispose(shouldDispose) {
+        this.shouldDispose = shouldDispose;
+    }
+    startLogProcess(deviceId, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.simulatorsLoggingEnabled[deviceId]) {
+                const deviceLogChildProcess = yield this.$iOSSimResolver.iOSSim.getDeviceLogProcess(deviceId, options ? options.predicate : null);
+                const action = (data) => {
+                    const message = data.toString();
+                    this.$deviceLogProvider.logData(message, this.$devicePlatformsConstants.iOS, deviceId);
+                };
+                if (deviceLogChildProcess) {
+                    deviceLogChildProcess.once("close", () => {
+                        this.simulatorsLoggingEnabled[deviceId] = false;
+                    });
+                    deviceLogChildProcess.once("error", (err) => {
+                        this.$logger.trace(`Error is thrown for device with identifier ${deviceId}. More info: ${err.message}.`);
+                        this.simulatorsLoggingEnabled[deviceId] = false;
+                    });
+                }
+                if (deviceLogChildProcess.stdout) {
+                    deviceLogChildProcess.stdout.on("data", action.bind(this));
+                }
+                if (deviceLogChildProcess.stderr) {
+                    deviceLogChildProcess.stderr.on("data", action.bind(this));
+                }
+                this.simulatorsLoggingEnabled[deviceId] = true;
+                this.simulatorsLogProcess[deviceId] = deviceLogChildProcess;
+            }
+        });
+    }
+    dispose(signal) {
+        if (this.shouldDispose) {
+            _.each(this.simulatorsLogProcess, (logProcess, deviceId) => {
+                if (logProcess) {
+                    logProcess.kill(signal);
+                }
+            });
+        }
+    }
+}
+exports.IOSSimulatorLogProvider = IOSSimulatorLogProvider;
+yok_1.injector.register("iOSSimulatorLogProvider", IOSSimulatorLogProvider);

package/lib/common/mobile/local-to-device-path-data-factory.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalToDevicePathDataFactory = void 0;
+const helpers = require("../helpers");
+const path = require("path");
+const yok_1 = require("../yok");
+class LocalToDevicePathData {
+    constructor(filePath, localProjectRootPath, onDeviceFileName, deviceProjectRootPath) {
+        this.filePath = filePath;
+        this.localProjectRootPath = localProjectRootPath;
+        this.onDeviceFileName = onDeviceFileName;
+        this.deviceProjectRootPath = deviceProjectRootPath;
+    }
+    getLocalPath() {
+        return this.filePath;
+    }
+    getDevicePath() {
+        if (!this.devicePath) {
+            const devicePath = path.join(this.deviceProjectRootPath, path.dirname(this.getRelativeToProjectBasePath()), this.onDeviceFileName);
+            this.devicePath = helpers.fromWindowsRelativePathToUnix(devicePath);
+        }
+        return this.devicePath;
+    }
+    getRelativeToProjectBasePath() {
+        if (!this.relativeToProjectBasePath) {
+            this.relativeToProjectBasePath = path.relative(this.localProjectRootPath, this.filePath);
+        }
+        return this.relativeToProjectBasePath;
+    }
+}
+class LocalToDevicePathDataFactory {
+    create(filePath, localProjectRootPath, onDeviceFileName, deviceProjectRootPath) {
+        return new LocalToDevicePathData(filePath, localProjectRootPath, onDeviceFileName, deviceProjectRootPath);
+    }
+}
+exports.LocalToDevicePathDataFactory = LocalToDevicePathDataFactory;
+yok_1.injector.register("localToDevicePathDataFactory", LocalToDevicePathDataFactory);

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogFilter = void 0;
+const yok_1 = require("../yok");
+class LogFilter {
+    constructor($devicePlatformsConstants, $injector, $loggingLevels) {
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$injector = $injector;
+        this.$loggingLevels = $loggingLevels;
+        this._loggingLevel = this.$loggingLevels.info;
+    }
+    get loggingLevel() {
+        return this._loggingLevel;
+    }
+    set loggingLevel(logLevel) {
+        if (this.verifyLogLevel(logLevel)) {
+            this._loggingLevel = logLevel;
+        }
+    }
+    filterData(platform, data, loggingOptions = {}) {
+        loggingOptions = loggingOptions || {};
+        const deviceLogFilter = this.getDeviceLogFilterInstance(platform);
+        loggingOptions.logLevel = loggingOptions.logLevel || this.loggingLevel;
+        if (deviceLogFilter) {
+            return deviceLogFilter.filterData(data, loggingOptions);
+        }
+        return data;
+    }
+    getDeviceLogFilterInstance(platform) {
+        if (platform) {
+            if (platform.toLowerCase() ===
+                this.$devicePlatformsConstants.iOS.toLowerCase() ||
+                platform.toLowerCase() ===
+                    this.$devicePlatformsConstants.visionOS.toLowerCase()) {
+                return this.$injector.resolve("iOSLogFilter");
+            }
+            else if (platform.toLowerCase() ===
+                this.$devicePlatformsConstants.Android.toLowerCase()) {
+                return this.$injector.resolve("androidLogFilter");
+            }
+        }
+        return null;
+    }
+    verifyLogLevel(logLevel) {
+        const upperCaseLogLevel = (logLevel || "").toUpperCase();
+        return (upperCaseLogLevel === this.$loggingLevels.info.toUpperCase() ||
+            upperCaseLogLevel === this.$loggingLevels.full.toUpperCase());
+    }
+}
+exports.LogFilter = LogFilter;
+yok_1.injector.register("logFilter", LogFilter);

package/lib/common/mobile/logging-levels.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggingLevels = void 0;
+const yok_1 = require("../yok");
+class LoggingLevels {
+    constructor() {
+        this.info = "INFO";
+        this.full = "FULL";
+    }
+}
+exports.LoggingLevels = LoggingLevels;
+yok_1.injector.register("loggingLevels", LoggingLevels);

package/lib/common/mobile/mobile-core/android-device-discovery.js

@@ -0,0 +1,91 @@
+"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");
+const android_device_1 = require("../android/android-device");
+const yok_1 = require("../../yok");
+const _ = require("lodash");
+class AndroidDeviceDiscovery extends device_discovery_1.DeviceDiscovery {
+    constructor($injector, $adb, $mobileHelper) {
+        super();
+        this.$injector = $injector;
+        this.$adb = $adb;
+        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);
+        });
+    }
+    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();
+        });
+    }
+    checkForDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield this.$adb.getDevices();
+            yield 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());
+        });
+    }
+    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;
+                }
+            }
+        });
+    }
+}
+exports.AndroidDeviceDiscovery = AndroidDeviceDiscovery;
+yok_1.injector.register("androidDeviceDiscovery", AndroidDeviceDiscovery);

package/lib/common/mobile/mobile-core/android-emulator-discovery.js

@@ -0,0 +1,65 @@
+"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");
+const constants_1 = require("../../constants");
+const _ = require("lodash");
+const yok_1 = require("../../yok");
+class AndroidEmulatorDiscovery extends events_1.EventEmitter {
+    constructor($androidEmulatorServices, $mobileHelper) {
+        super();
+        this.$androidEmulatorServices = $androidEmulatorServices;
+        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);
+            }
+        });
+    }
+    getDevices() {
+        return _.values(this._emulators);
+    }
+    raiseOnEmulatorImagesFound(emulators) {
+        _.forEach(emulators, (emulator) => {
+            this._emulators[emulator.imageIdentifier] = emulator;
+            this.emit(constants_1.EmulatorDiscoveryNames.EMULATOR_IMAGE_FOUND, emulator);
+        });
+    }
+    raiseOnEmulatorImagesLost(emulators) {
+        _.forEach(emulators, (emulator) => {
+            delete this._emulators[emulator.imageIdentifier];
+            this.emit(constants_1.EmulatorDiscoveryNames.EMULATOR_IMAGE_LOST, emulator);
+        });
+    }
+}
+exports.AndroidEmulatorDiscovery = AndroidEmulatorDiscovery;
+yok_1.injector.register("androidEmulatorDiscovery", AndroidEmulatorDiscovery);

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

@@ -0,0 +1,259 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidProcessService = void 0;
+const os_1 = require("os");
+const device_android_debug_bridge_1 = require("../android/device-android-debug-bridge");
+const constants_1 = require("../../constants");
+const decorators_1 = require("../../decorators");
+const yok_1 = require("../../yok");
+const _ = require("lodash");
+class AndroidProcessService {
+    constructor($errors, $cleanupService, $injector, $net, $staticConfig) {
+        this.$errors = $errors;
+        this.$cleanupService = $cleanupService;
+        this.$injector = $injector;
+        this.$net = $net;
+        this.$staticConfig = $staticConfig;
+        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);
+        });
+    }
+    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) {
+                this.$errors.fail(applicationNotStartedErrorMessage);
+            }
+            const abstractPortsInformation = yield this.getAbstractPortsInformation(adb);
+            const abstractPort = yield 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 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,
+                };
+            }
+            return null;
+        });
+    }
+    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));
+            }
+        });
+    }
+    getCordovaPortInformation(abstractPortsInformation, appIdentifier, processId) {
+        return (this.getPortInformation(abstractPortsInformation, `${appIdentifier}_devtools_remote`) || this.getPortInformation(abstractPortsInformation, processId));
+    }
+    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"]);
+        });
+    }
+    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;
+        });
+    }
+    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);
+        });
+    }
+    getAdb(deviceIdentifier) {
+        if (!this._devicesAdbs[deviceIdentifier]) {
+            this._devicesAdbs[deviceIdentifier] = this.$injector.resolve(device_android_debug_bridge_1.DeviceAndroidDebugBridge, {
+                identifier: deviceIdentifier,
+            });
+        }
+        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+(.*?)$`));
+        });
+    }
+    getFirstMatchingGroupFromMultilineResult(input, regex) {
+        let result;
+        _((input || "").split("\n"))
+            .map((line) => line.trim())
+            .filter((line) => !!line)
+            .each((line) => {
+            const matches = line.match(regex);
+            if (matches && matches[1]) {
+                result = matches[1];
+                return false;
+            }
+        });
+        return result;
+    }
+}
+__decorate([
+    (0, decorators_1.exported)("androidProcessService")
+], AndroidProcessService.prototype, "getAppProcessId", null);
+exports.AndroidProcessService = AndroidProcessService;
+yok_1.injector.register("androidProcessService", AndroidProcessService);