@akylas/nativescript-cli 8.7.2

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

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceAndroidDebugBridge = void 0;
+const android_debug_bridge_1 = require("./android-debug-bridge");
+const _ = require("lodash");
+class DeviceAndroidDebugBridge extends android_debug_bridge_1.AndroidDebugBridge {
+    constructor(identifier, $childProcess, $errors, $logger, $staticConfig, $androidDebugBridgeResultHandler) {
+        super($childProcess, $errors, $logger, $staticConfig, $androidDebugBridgeResultHandler);
+        this.identifier = identifier;
+        this.$childProcess = $childProcess;
+        this.$errors = $errors;
+        this.$logger = $logger;
+        this.$staticConfig = $staticConfig;
+        this.$androidDebugBridgeResultHandler = $androidDebugBridgeResultHandler;
+    }
+    sendBroadcastToDevice(action, extras) {
+        return __awaiter(this, void 0, void 0, function* () {
+            extras = extras || {};
+            const broadcastCommand = ["am", "broadcast", "-a", `${action}`];
+            _.each(extras, (value, key) => broadcastCommand.push("-e", key, value));
+            const result = yield this.executeShellCommand(broadcastCommand);
+            this.$logger.trace(`Broadcast result ${result} from ${broadcastCommand}`);
+            const match = result.match(/Broadcast completed: result=(\d+)/);
+            if (match) {
+                return +match[1];
+            }
+            this.$errors.fail("Unable to broadcast to android device:\n%s", result);
+        });
+    }
+    composeCommand(params) {
+        const _super = Object.create(null, {
+            composeCommand: { get: () => super.composeCommand }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.composeCommand.call(this, params, this.identifier);
+        });
+    }
+}
+exports.DeviceAndroidDebugBridge = DeviceAndroidDebugBridge;

package/lib/common/mobile/android/genymotion/genymotion-service.js

@@ -0,0 +1,211 @@
+"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.AndroidGenymotionService = void 0;
+const constants_1 = require("../../../constants");
+const helpers_1 = require("../../../helpers");
+const os_1 = require("os");
+const path = require("path");
+const _ = require("lodash");
+const os_2 = require("os");
+const decorators_1 = require("../../../decorators");
+const constants_2 = require("../../../../constants");
+const yok_1 = require("../../../yok");
+class AndroidGenymotionService {
+    constructor($adb, $childProcess, $devicePlatformsConstants, $emulatorHelper, $fs, $logger, $virtualBoxService) {
+        this.$adb = $adb;
+        this.$childProcess = $childProcess;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$emulatorHelper = $emulatorHelper;
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$virtualBoxService = $virtualBoxService;
+    }
+    getEmulatorImages(adbDevicesOutput) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const availableEmulatorsOutput = yield this.getEmulatorImagesCore();
+            const runningEmulatorIds = yield this.getRunningEmulatorIds(adbDevicesOutput);
+            const runningEmulators = yield (0, helpers_1.settlePromises)(_.map(runningEmulatorIds, (emulatorId) => this.getRunningEmulatorData(emulatorId, availableEmulatorsOutput.devices)));
+            const devices = availableEmulatorsOutput.devices.map((emulator) => this.$emulatorHelper.getEmulatorByImageIdentifier(emulator.imageIdentifier, runningEmulators) || emulator);
+            return {
+                devices,
+                errors: availableEmulatorsOutput.errors,
+            };
+        });
+    }
+    getRunningEmulatorIds(adbDevicesOutput) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = yield Promise.all(_(adbDevicesOutput)
+                .filter((r) => !r.match(constants_1.AndroidVirtualDevice.RUNNING_AVD_EMULATOR_REGEX))
+                .map((row) => __awaiter(this, void 0, void 0, function* () {
+                const match = row.match(/^(.+?)\s+device$/);
+                if (match && match[1]) {
+                    const emulatorId = match[1];
+                    const result = (yield this.isGenymotionEmulator(emulatorId))
+                        ? emulatorId
+                        : undefined;
+                    return Promise.resolve(result);
+                }
+                return Promise.resolve(undefined);
+            }))
+                .value());
+            return _(results)
+                .filter((r) => !!r)
+                .map((r) => r.toString())
+                .value();
+        });
+    }
+    get pathToEmulatorExecutable() {
+        const searchPaths = this.playerSearchPaths[process.platform];
+        const searchPath = _.find(searchPaths, (sPath) => this.$fs.exists(sPath));
+        return searchPath || "player";
+    }
+    startEmulatorArgs(imageIdentifier) {
+        return ["--vm-name", imageIdentifier];
+    }
+    getEmulatorImagesCore() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const output = yield this.$virtualBoxService.listVms();
+            if (output.error) {
+                return { devices: [], errors: output.error ? [output.error] : [] };
+            }
+            const devices = yield this.parseListVmsOutput(output.vms);
+            return { devices, errors: [] };
+        });
+    }
+    getRunningEmulatorName(emulatorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const output = yield this.$adb.getPropertyValue(emulatorId, "ro.product.model");
+            this.$logger.trace(output);
+            return _.first(output.split(os_1.EOL)).trim();
+        });
+    }
+    getRunningEmulatorImageIdentifier(emulatorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adbDevices = yield this.$adb.getDevicesSafe();
+            const emulatorImages = (yield this.getEmulatorImages(adbDevices)).devices;
+            const emulator = yield this.getRunningEmulatorData(emulatorId, emulatorImages);
+            return emulator ? emulator.imageIdentifier : null;
+        });
+    }
+    getRunningEmulatorData(runningEmulatorId, availableEmulators) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const emulatorName = yield this.getRunningEmulatorName(runningEmulatorId);
+            const runningEmulator = this.$emulatorHelper.getEmulatorByIdOrName(emulatorName, availableEmulators);
+            if (!runningEmulator) {
+                return null;
+            }
+            this.$emulatorHelper.setRunningAndroidEmulatorProperties(runningEmulatorId, runningEmulator);
+            return runningEmulator;
+        });
+    }
+    get playerSearchPaths() {
+        return {
+            darwin: [
+                "/Applications/Genymotion.app/Contents/MacOS/player.app/Contents/MacOS/player",
+                "/Applications/Genymotion.app/Contents/MacOS/player",
+            ],
+            linux: [path.join((0, os_2.homedir)(), "genymotion", "player")],
+            win32: [
+                `${process.env["PROGRAMFILES"]}\\Genymobile\\Genymotion\\player.exe`,
+                `${process.env["PROGRAMFILES(X86)"]}\\Genymobile\\Genymotion\\player.exe`,
+            ],
+        };
+    }
+    parseListVmsOutput(vms) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const configurationError = yield this.getConfigurationError();
+            const devices = [];
+            for (const vm of vms) {
+                try {
+                    const output = yield this.$virtualBoxService.enumerateGuestProperties(vm.id);
+                    if (output &&
+                        output.properties &&
+                        output.properties.indexOf("genymotion") !== -1) {
+                        devices.push(this.convertToDeviceInfo(output.properties, vm.id, vm.name, output.error, configurationError));
+                    }
+                }
+                catch (err) {
+                    this.$logger.trace(`Error while parsing vm ${vm.id}`);
+                }
+            }
+            return devices;
+        });
+    }
+    convertToDeviceInfo(output, id, name, error, configurationError) {
+        return {
+            identifier: null,
+            imageIdentifier: id,
+            displayName: name,
+            model: name,
+            version: this.getSdkVersion(output),
+            vendor: constants_1.AndroidVirtualDevice.GENYMOTION_VENDOR_NAME,
+            status: constants_1.NOT_RUNNING_EMULATOR_STATUS,
+            errorHelp: [configurationError, error].filter((item) => !!item).join(os_1.EOL) || null,
+            isTablet: false,
+            type: constants_1.DeviceTypes.Emulator,
+            connectionTypes: [constants_2.DeviceConnectionType.Local],
+            platform: this.$devicePlatformsConstants.Android,
+        };
+    }
+    getSdkVersion(output) {
+        const androidApiLevelRow = output
+            .split("\n")
+            .filter((row) => !!row)
+            .find((row) => row.indexOf("Name: android_version") !== -1);
+        return androidApiLevelRow.split(", ")[1].split("value: ")[1];
+    }
+    isGenymotionEmulator(emulatorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const manufacturer = yield this.$adb.getPropertyValue(emulatorId, "ro.product.manufacturer");
+            if (manufacturer && manufacturer.match(/^Genymotion/i)) {
+                return true;
+            }
+            const buildProduct = yield this.$adb.getPropertyValue(emulatorId, "ro.build.product");
+            if (buildProduct && _.includes(buildProduct.toLowerCase(), "vbox")) {
+                return true;
+            }
+            return false;
+        });
+    }
+    getConfigurationPlatformSpecficErrorMessage() {
+        const searchPaths = this.playerSearchPaths[process.platform];
+        return `Unable to find the Genymotion player in the following location${searchPaths.length > 1 ? "s" : ""}:
+${searchPaths.join(os_1.EOL)}
+In case you have installed Genymotion in a different location, please add the path to player executable to your PATH environment variable.`;
+    }
+    getConfigurationError() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.$childProcess.trySpawnFromCloseEvent(this.pathToEmulatorExecutable, [], {}, { throwError: false });
+            if (result &&
+                result.stderr &&
+                result.stderr.indexOf(constants_1.AndroidVirtualDevice.GENYMOTION_DEFAULT_STDERR_STRING) === -1) {
+                this.$logger.trace("Configuration error for Genymotion", result);
+                return this.getConfigurationPlatformSpecficErrorMessage();
+            }
+            return null;
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], AndroidGenymotionService.prototype, "getConfigurationPlatformSpecficErrorMessage", null);
+__decorate([
+    (0, decorators_1.cache)()
+], AndroidGenymotionService.prototype, "getConfigurationError", null);
+exports.AndroidGenymotionService = AndroidGenymotionService;
+yok_1.injector.register("androidGenymotionService", AndroidGenymotionService);

package/lib/common/mobile/android/genymotion/virtualbox-service.js

@@ -0,0 +1,121 @@
+"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.VirtualBoxService = void 0;
+const path = require("path");
+const os_1 = require("os");
+const _ = require("lodash");
+const decorators_1 = require("../../../decorators");
+const helpers_1 = require("../../../helpers");
+const yok_1 = require("../../../yok");
+class VirtualBoxService {
+    constructor($childProcess, $fs, $hostInfo, $logger) {
+        this.$childProcess = $childProcess;
+        this.$fs = $fs;
+        this.$hostInfo = $hostInfo;
+        this.$logger = $logger;
+    }
+    listVms() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = null;
+            let vms = [];
+            const vBoxManagePath = yield this.getvBoxManagePath();
+            if (vBoxManagePath) {
+                result = yield this.$childProcess.trySpawnFromCloseEvent(vBoxManagePath, [
+                    "list",
+                    "vms",
+                ]);
+                if (result && result.stdout) {
+                    vms = result.stdout
+                        .split(os_1.EOL)
+                        .filter((row) => !!row)
+                        .map((row) => {
+                        const [rawName, rawId] = row.split('" ');
+                        const id = rawId.substr(1, rawId.length - 2);
+                        const name = rawName.substr(1, rawName.length - 1);
+                        return { id, name };
+                    });
+                }
+            }
+            return { vms, error: result && result.stderr };
+        });
+    }
+    enumerateGuestProperties(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let result = null;
+            const vBoxManagePath = yield this.getvBoxManagePath();
+            if (vBoxManagePath) {
+                result = yield this.$childProcess.trySpawnFromCloseEvent(vBoxManagePath, [
+                    "guestproperty",
+                    "enumerate",
+                    id,
+                ]);
+            }
+            return {
+                properties: result && result.stdout,
+                error: result && result.stderr,
+            };
+        });
+    }
+    getvBoxManageSearchPaths() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const searchPaths = {
+                darwin: ["/usr/local/bin"],
+                linux: ["/opt", "/opt/local", "/usr", "/usr/local", "~"],
+                win32: [
+                    `${process.env["PROGRAMFILES"]}\\Oracle\\VirtualBox`,
+                    `${process.env["PROGRAMFILES(X86)"]}\\Oracle\\VirtualBox`,
+                ],
+            };
+            if (this.$hostInfo.isWindows) {
+                let searchPath = null;
+                try {
+                    const result = yield (0, helpers_1.getWinRegPropertyValue)("\\Software\\Oracle\\VirtualBox", "InstallDir");
+                    searchPath = result && result.value ? result.value : null;
+                }
+                catch (err) {
+                    this.$logger.trace(`Error while trying to get InstallDir property for \\Software\\Oracle\\VirtualBox. More info: ${err}.`);
+                }
+                if (searchPath && !_.includes(searchPaths["win32"], searchPath)) {
+                    searchPaths["win32"].unshift(searchPath);
+                }
+            }
+            return searchPaths;
+        });
+    }
+    get vBoxManageExecutableNames() {
+        return {
+            darwin: "VBoxManage",
+            linux: "VBoxManage",
+            win32: "VBoxManage.exe",
+        };
+    }
+    getvBoxManagePath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const searchPaths = (yield this.getvBoxManageSearchPaths())[process.platform];
+            const result = searchPaths
+                .map((searchPath) => path.join(searchPath, this.vBoxManageExecutableNames[process.platform]))
+                .find((searchPath) => this.$fs.exists(searchPath));
+            return result;
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], VirtualBoxService.prototype, "getvBoxManagePath", null);
+exports.VirtualBoxService = VirtualBoxService;
+yok_1.injector.register("virtualBoxService", VirtualBoxService);

package/lib/common/mobile/android/logcat-helper.js

@@ -0,0 +1,165 @@
+"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.LogcatHelper = void 0;
+const byline = require("byline");
+const semver = require("semver");
+const yok_1 = require("../../yok");
+const device_android_debug_bridge_1 = require("./device-android-debug-bridge");
+class LogcatHelper {
+    constructor($deviceLogProvider, $devicePlatformsConstants, $logger, $injector, $devicesService) {
+        this.$deviceLogProvider = $deviceLogProvider;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$logger = $logger;
+        this.$injector = $injector;
+        this.$devicesService = $devicesService;
+        this.mapDevicesLoggingData = Object.create(null);
+    }
+    start(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceIdentifier = options.deviceIdentifier;
+            if (deviceIdentifier && !this.mapDevicesLoggingData[deviceIdentifier]) {
+                this.mapDevicesLoggingData[deviceIdentifier] = {
+                    loggingProcess: null,
+                    lineStream: null,
+                    keepSingleProcess: options.keepSingleProcess,
+                    appStartTrackingProcess: null,
+                    rawLineStream: null,
+                };
+                const logcatStream = yield this.getLogcatStream(deviceIdentifier, options.pid);
+                const lineStream = byline(logcatStream.stdout);
+                this.mapDevicesLoggingData[deviceIdentifier].loggingProcess =
+                    logcatStream;
+                this.mapDevicesLoggingData[deviceIdentifier].lineStream = lineStream;
+                logcatStream.stderr.on("data", (data) => {
+                    this.$logger.trace("ADB logcat stderr: " + data.toString());
+                });
+                logcatStream.on("close", (code) => {
+                    try {
+                        this.forceStop(deviceIdentifier);
+                        if (code !== 0) {
+                            this.$logger.trace("ADB process exited with code " + code.toString());
+                        }
+                    }
+                    catch (err) {
+                    }
+                });
+                lineStream.on("data", (lineBuffer) => {
+                    const lines = (lineBuffer.toString() || "").split("\n");
+                    for (const line of lines) {
+                        this.$deviceLogProvider.logData(line, this.$devicePlatformsConstants.Android, deviceIdentifier);
+                    }
+                });
+                const appStartTrackingStream = yield this.getAppStartTrackingLogcatStream(deviceIdentifier, options.appId);
+                this.mapDevicesLoggingData[deviceIdentifier].appStartTrackingProcess =
+                    appStartTrackingStream;
+                const rawLineStream = byline(appStartTrackingStream.stdout);
+                this.mapDevicesLoggingData[deviceIdentifier].rawLineStream =
+                    rawLineStream;
+                rawLineStream.on("data", (lineBuffer) => {
+                    var _a, _b;
+                    if (!((_a = this.mapDevicesLoggingData[deviceIdentifier]) === null || _a === void 0 ? void 0 : _a.loggingProcess))
+                        return;
+                    const lines = (lineBuffer.toString() || "").split("\n");
+                    for (let line of lines) {
+                        if (line.includes("START") &&
+                            line.includes(options.appId) &&
+                            !line.includes(options.pid)) {
+                            this.forceStop(deviceIdentifier);
+                            (_b = options.onAppRestarted) === null || _b === void 0 ? void 0 : _b.call(options);
+                        }
+                    }
+                });
+            }
+        });
+    }
+    dump(deviceIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adb = this.$injector.resolve(device_android_debug_bridge_1.DeviceAndroidDebugBridge, { identifier: deviceIdentifier });
+            const logcatDumpStream = yield adb.executeCommand(["logcat", "-d"], {
+                returnChildProcess: true,
+            });
+            const lineStream = byline(logcatDumpStream.stdout);
+            lineStream.on("data", (line) => {
+                const lineText = line.toString();
+                this.$logger.trace(lineText);
+            });
+            logcatDumpStream.on("close", (code) => {
+                logcatDumpStream.removeAllListeners();
+                lineStream.removeAllListeners();
+            });
+        });
+    }
+    stop(deviceIdentifier) {
+        if (this.mapDevicesLoggingData[deviceIdentifier] &&
+            !this.mapDevicesLoggingData[deviceIdentifier].keepSingleProcess) {
+            this.forceStop(deviceIdentifier);
+        }
+    }
+    forceStop(deviceIdentifier) {
+        var _a, _b, _c, _d, _e;
+        const loggingData = this.mapDevicesLoggingData[deviceIdentifier];
+        (_a = loggingData.loggingProcess) === null || _a === void 0 ? void 0 : _a.removeAllListeners();
+        (_b = loggingData.loggingProcess) === null || _b === void 0 ? void 0 : _b.kill("SIGINT");
+        (_c = loggingData.lineStream) === null || _c === void 0 ? void 0 : _c.removeAllListeners();
+        (_d = loggingData.appStartTrackingProcess) === null || _d === void 0 ? void 0 : _d.kill("SIGINT");
+        (_e = loggingData.lineStream) === null || _e === void 0 ? void 0 : _e.removeAllListeners();
+        delete this.mapDevicesLoggingData[deviceIdentifier];
+    }
+    isLogcatPidSupported(deviceIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield this.$devicesService.getDevice(deviceIdentifier);
+            const minAndroidWithLogcatPidSupport = "7.0.0";
+            return (!!device.deviceInfo.version &&
+                semver.gte(semver.coerce(device.deviceInfo.version), minAndroidWithLogcatPidSupport));
+        });
+    }
+    getLogcatStream(deviceIdentifier, pid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isLogcatPidSupported = yield this.isLogcatPidSupported(deviceIdentifier);
+            const adb = this.$injector.resolve(device_android_debug_bridge_1.DeviceAndroidDebugBridge, { identifier: deviceIdentifier });
+            const logcatCommand = ["logcat", "-T", "1"];
+            const acceptedTags = [
+                "chromium",
+                '"Web Console"',
+                "JS",
+                "System.err",
+                "TNS.Native",
+                "TNS.Java",
+            ];
+            if (pid && isLogcatPidSupported) {
+                logcatCommand.push(`--pid=${pid}`);
+                acceptedTags.forEach((tag) => {
+                    logcatCommand.push("-s", tag);
+                });
+            }
+            const logcatStream = yield adb.executeCommand(logcatCommand, {
+                returnChildProcess: true,
+            });
+            return logcatStream;
+        });
+    }
+    getAppStartTrackingLogcatStream(deviceIdentifier, appId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adb = this.$injector.resolve(device_android_debug_bridge_1.DeviceAndroidDebugBridge, { identifier: deviceIdentifier });
+            const logcatCommand = [`logcat`, `-b`, `system`, `-T`, `1`];
+            if (appId) {
+                logcatCommand.push(`--regex=START.*${appId}`);
+            }
+            const appStartTrackingStream = yield adb.executeCommand(logcatCommand, {
+                returnChildProcess: true,
+            });
+            return appStartTrackingStream;
+        });
+    }
+}
+exports.LogcatHelper = LogcatHelper;
+yok_1.injector.register("logcatHelper", LogcatHelper);