@akylas/nativescript-cli 8.7.2

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

@@ -0,0 +1,167 @@
+"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.AndroidDebugBridge = void 0;
+const path = require("path");
+const decorators_1 = require("../../decorators");
+const os_1 = require("os");
+const helpers_1 = require("../../helpers");
+const yok_1 = require("../../yok");
+class AndroidDebugBridge {
+    constructor($childProcess, $errors, $logger, $staticConfig, $androidDebugBridgeResultHandler) {
+        this.$childProcess = $childProcess;
+        this.$errors = $errors;
+        this.$logger = $logger;
+        this.$staticConfig = $staticConfig;
+        this.$androidDebugBridgeResultHandler = $androidDebugBridgeResultHandler;
+        this.adbFilePath = null;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.adbFilePath = yield this.$staticConfig.getAdbFilePath();
+        });
+    }
+    executeCommand(args, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let event = "close";
+            const deviceIdentifier = options && options.deviceIdentifier;
+            const command = yield this.composeCommand(args, deviceIdentifier);
+            let treatErrorsAsWarnings = false;
+            let childProcessOptions = undefined;
+            if (options) {
+                event = options.fromEvent || event;
+                treatErrorsAsWarnings = options.treatErrorsAsWarnings;
+                childProcessOptions = options.childProcessOptions;
+                if (options.returnChildProcess) {
+                    return this.$childProcess.spawn(command.command, command.args);
+                }
+            }
+            const result = yield this.$childProcess.spawnFromEvent(command.command, command.args, event, childProcessOptions, { throwError: false });
+            const errors = this.$androidDebugBridgeResultHandler.checkForErrors(result);
+            if (errors && errors.length > 0) {
+                this.$androidDebugBridgeResultHandler.handleErrors(errors, treatErrorsAsWarnings);
+            }
+            return result.stdout === undefined || result.stdout === null
+                ? result
+                : result.stdout;
+        });
+    }
+    getPropertyValue(deviceId, propertyName) {
+        return this.$childProcess.execFile(this.adbFilePath, [
+            "-s",
+            deviceId,
+            "shell",
+            "getprop",
+            propertyName,
+        ]);
+    }
+    getDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.executeCommand(["devices"], {
+                returnChildProcess: true,
+            });
+            return new Promise((resolve, reject) => {
+                let adbData = "";
+                let errorData = "";
+                let isSettled = false;
+                result.stdout.on("data", (data) => {
+                    adbData += data.toString();
+                });
+                result.stderr.on("data", (data) => {
+                    errorData += (data || "").toString();
+                });
+                result.on("error", (error) => {
+                    if (reject && !isSettled) {
+                        isSettled = true;
+                        reject(error);
+                    }
+                });
+                result.on("close", (exitCode) => __awaiter(this, void 0, void 0, function* () {
+                    if (errorData && !isSettled) {
+                        isSettled = true;
+                        reject(errorData);
+                        return;
+                    }
+                    if (!isSettled) {
+                        isSettled = true;
+                        const adbDevices = adbData
+                            .split(os_1.EOL)
+                            .filter((line) => !!line &&
+                            line.indexOf("List of devices attached") === -1 &&
+                            line.indexOf("* daemon ") === -1 &&
+                            line.indexOf("adb server") === -1);
+                        resolve(adbDevices);
+                    }
+                }));
+            });
+        });
+    }
+    getDevicesSafe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let adbDevices = [];
+            try {
+                adbDevices = yield this.getDevices();
+            }
+            catch (err) {
+                this.$logger.trace(`Getting adb devices failed with error: ${err}`);
+            }
+            return adbDevices;
+        });
+    }
+    composeCommand(params, identifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const command = yield this.$staticConfig.getAdbFilePath();
+            let deviceIdentifier = [];
+            if (identifier) {
+                deviceIdentifier = ["-s", `${identifier}`];
+            }
+            const args = deviceIdentifier.concat(params);
+            return { command, args };
+        });
+    }
+    executeShellCommand(args, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            args.unshift("shell");
+            const result = yield this.executeCommand(args, options);
+            return result;
+        });
+    }
+    pushFile(localFilePath, deviceFilePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fileDirectory = (0, helpers_1.fromWindowsRelativePathToUnix)(path.dirname(deviceFilePath));
+            yield this.executeShellCommand(["mkdir", "-p", fileDirectory]);
+            yield this.executeCommand(["push", localFilePath, deviceFilePath]);
+            yield this.executeShellCommand(["chmod", "0777", fileDirectory]);
+        });
+    }
+    removeFile(deviceFilePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.executeShellCommand(["rm", "-rf", deviceFilePath]);
+        });
+    }
+}
+__decorate([
+    (0, decorators_1.cache)()
+], AndroidDebugBridge.prototype, "init", null);
+__decorate([
+    (0, decorators_1.invokeInit)()
+], AndroidDebugBridge.prototype, "getPropertyValue", null);
+__decorate([
+    (0, decorators_1.invokeInit)()
+], AndroidDebugBridge.prototype, "getDevices", null);
+exports.AndroidDebugBridge = AndroidDebugBridge;
+yok_1.injector.register("adb", AndroidDebugBridge);

package/lib/common/mobile/android/android-device-file-system.js

@@ -0,0 +1,176 @@
+"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.AndroidDeviceFileSystem = void 0;
+const path = require("path");
+const _ = require("lodash");
+const semver = require("semver");
+const android_device_hash_service_1 = require("./android-device-hash-service");
+const helpers_1 = require("../../helpers");
+const constants_1 = require("../../constants");
+class AndroidDeviceFileSystem {
+    constructor(adb, $fs, $logger, $mobileHelper, $tempService, $injector) {
+        this.adb = adb;
+        this.$fs = $fs;
+        this.$logger = $logger;
+        this.$mobileHelper = $mobileHelper;
+        this.$tempService = $tempService;
+        this.$injector = $injector;
+        this._deviceHashServices = Object.create(null);
+    }
+    listFiles(devicePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let listCommandArgs = ["ls", "-a", devicePath];
+            if (appIdentifier) {
+                listCommandArgs = ["run-as", appIdentifier].concat(listCommandArgs);
+            }
+            return this.adb.executeShellCommand(listCommandArgs);
+        });
+    }
+    getFile(deviceFilePath, appIdentifier, outputPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stdout = !outputPath;
+            if (stdout) {
+                outputPath = yield this.$tempService.path({
+                    prefix: "sync",
+                    suffix: ".tmp",
+                });
+            }
+            yield this.adb.executeCommand(["pull", deviceFilePath, outputPath]);
+            if (stdout) {
+                yield new Promise((resolve, reject) => {
+                    const readStream = this.$fs.createReadStream(outputPath);
+                    readStream.pipe(process.stdout);
+                    readStream.on("end", () => {
+                        resolve();
+                    });
+                    readStream.on("error", (err) => {
+                        reject(err);
+                    });
+                });
+            }
+        });
+    }
+    getFileContent(deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.adb.executeShellCommand(["cat", deviceFilePath]);
+            return result;
+        });
+    }
+    putFile(localFilePath, deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adb.pushFile(localFilePath, deviceFilePath);
+        });
+    }
+    transferFiles(deviceAppData, localToDevicePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const directoriesToChmod = [];
+            const transferredFiles = [];
+            const action = (localToDevicePathData) => __awaiter(this, void 0, void 0, function* () {
+                const fstat = this.$fs.getFsStats(localToDevicePathData.getLocalPath());
+                if (fstat.isFile()) {
+                    const devicePath = localToDevicePathData.getDevicePath();
+                    yield this.adb.pushFile(localToDevicePathData.getLocalPath(), devicePath);
+                    transferredFiles.push(localToDevicePathData);
+                }
+                else if (fstat.isDirectory()) {
+                    const dirToChmod = localToDevicePathData.getDevicePath();
+                    directoriesToChmod.push(dirToChmod);
+                }
+            });
+            yield (0, helpers_1.executeActionByChunks)(localToDevicePaths, constants_1.DEFAULT_CHUNK_SIZE, action);
+            const dirsChmodAction = (directoryToChmod) => this.adb.executeShellCommand(["chmod", "0777", directoryToChmod]);
+            yield (0, helpers_1.executeActionByChunks)(_.uniq(directoriesToChmod), constants_1.DEFAULT_CHUNK_SIZE, dirsChmodAction);
+            return transferredFiles;
+        });
+    }
+    transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const minAndroidWithoutAdbPushDir = "9.0.0";
+            const isAdbPushDirSupported = semver.lt(semver.coerce(deviceAppData.device.deviceInfo.version), minAndroidWithoutAdbPushDir);
+            const deviceProjectDir = yield deviceAppData.getDeviceProjectRootPath();
+            let transferredLocalToDevicePaths = [];
+            if (isAdbPushDirSupported) {
+                yield this.adb.pushFile(projectFilesPath, deviceProjectDir);
+                transferredLocalToDevicePaths = localToDevicePaths;
+            }
+            else {
+                transferredLocalToDevicePaths = yield this.pushFiles(localToDevicePaths);
+            }
+            if (transferredLocalToDevicePaths.length) {
+                const filesToChmodOnDevice = transferredLocalToDevicePaths.map((localToDevicePath) => localToDevicePath.getDevicePath());
+                yield this.chmodFiles(deviceProjectDir, filesToChmodOnDevice);
+            }
+            return transferredLocalToDevicePaths;
+        });
+    }
+    chmodFiles(deviceProjectRoot, filesToChmodOnDevice) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const commandsDeviceFilePath = this.$mobileHelper.buildDevicePath(deviceProjectRoot, "nativescript.commands.sh");
+            yield this.createFileOnDevice(commandsDeviceFilePath, `chmod 0777 ${filesToChmodOnDevice.join(" ")}`);
+            yield this.adb.executeShellCommand([commandsDeviceFilePath]);
+        });
+    }
+    pushFiles(localToDevicePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.trace("Changed hashes are:", localToDevicePaths);
+            const transferredFiles = [];
+            const transferFileAction = (localToDevicePathData) => __awaiter(this, void 0, void 0, function* () {
+                transferredFiles.push(localToDevicePathData);
+                yield this.transferFile(localToDevicePathData.getLocalPath(), localToDevicePathData.getDevicePath());
+            });
+            yield (0, helpers_1.executeActionByChunks)(localToDevicePaths, constants_1.DEFAULT_CHUNK_SIZE, transferFileAction);
+            return transferredFiles;
+        });
+    }
+    transferFile(localPath, devicePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.trace(`Transfering ${localPath} to ${devicePath}`);
+            const stats = this.$fs.getFsStats(localPath);
+            if (stats.isDirectory()) {
+                yield this.adb.executeShellCommand(["mkdir", path.dirname(devicePath)]);
+            }
+            else {
+                yield this.adb.pushFile(localPath, devicePath);
+            }
+        });
+    }
+    createFileOnDevice(deviceFilePath, fileContent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hostTmpDir = yield this.$tempService.mkdirSync("application-");
+            const commandsFileHostPath = path.join(hostTmpDir, "temp.commands.file");
+            this.$fs.writeFile(commandsFileHostPath, fileContent);
+            yield this.transferFile(commandsFileHostPath, deviceFilePath);
+            yield this.adb.executeShellCommand(["chmod", "0777", deviceFilePath]);
+        });
+    }
+    deleteFile(deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adb.executeShellCommand(["rm", "-rf", deviceFilePath]);
+        });
+    }
+    updateHashesOnDevice(hashes, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceHashService = this.getDeviceHashService(appIdentifier);
+            yield deviceHashService.uploadHashFileToDevice(hashes);
+        });
+    }
+    getDeviceHashService(appIdentifier) {
+        if (!this._deviceHashServices[appIdentifier]) {
+            this._deviceHashServices[appIdentifier] = this.$injector.resolve(android_device_hash_service_1.AndroidDeviceHashService, {
+                adb: this.adb,
+                appIdentifier,
+            });
+        }
+        return this._deviceHashServices[appIdentifier];
+    }
+}
+exports.AndroidDeviceFileSystem = AndroidDeviceFileSystem;

package/lib/common/mobile/android/android-device-hash-service.js

@@ -0,0 +1,133 @@
+"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.AndroidDeviceHashService = void 0;
+const path = require("path");
+const _ = require("lodash");
+const decorators_1 = require("../../decorators");
+const helpers_1 = require("../../helpers");
+const constants_1 = require("../../constants");
+class AndroidDeviceHashService {
+    constructor(adb, appIdentifier, $fs, $mobileHelper, $tempService) {
+        this.adb = adb;
+        this.appIdentifier = appIdentifier;
+        this.$fs = $fs;
+        this.$mobileHelper = $mobileHelper;
+        this.$tempService = $tempService;
+    }
+    get hashFileDevicePath() {
+        return this.$mobileHelper.buildDevicePath(constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME, this.appIdentifier, AndroidDeviceHashService.HASH_FILE_NAME);
+    }
+    doesShasumFileExistsOnDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lsResult = yield this.adb.executeShellCommand([
+                "ls",
+                this.hashFileDevicePath,
+            ]);
+            return !!(lsResult && lsResult.trim() === this.hashFileDevicePath);
+        });
+    }
+    getShasumsFromDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hashFileLocalPath = yield this.downloadHashFileFromDevice();
+            if (this.$fs.exists(hashFileLocalPath)) {
+                return this.$fs.readJson(hashFileLocalPath);
+            }
+            return null;
+        });
+    }
+    uploadHashFileToDevice(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hashFileLocalPath = yield this.getHashFileLocalPath();
+            this.$fs.writeJson(hashFileLocalPath, data);
+            yield this.adb.pushFile(hashFileLocalPath, this.hashFileDevicePath);
+        });
+    }
+    updateHashes(localToDevicePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const oldShasums = (yield this.getShasumsFromDevice()) || {};
+            yield this.generateHashesFromLocalToDevicePaths(localToDevicePaths, oldShasums);
+            yield this.uploadHashFileToDevice(oldShasums);
+        });
+    }
+    generateHashesFromLocalToDevicePaths(localToDevicePaths, initialShasums = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const action = (localToDevicePathData) => __awaiter(this, void 0, void 0, function* () {
+                const localPath = localToDevicePathData.getLocalPath();
+                if (this.$fs.getFsStats(localPath).isFile()) {
+                    initialShasums[localPath] = yield this.$fs.getFileShasum(localPath);
+                }
+            });
+            yield (0, helpers_1.executeActionByChunks)(localToDevicePaths, constants_1.DEFAULT_CHUNK_SIZE, action);
+            return initialShasums;
+        });
+    }
+    getDevicePaths(localToDevicePaths) {
+        return _.map(localToDevicePaths, (localToDevicePathData) => {
+            return `"${localToDevicePathData.getDevicePath()}"`;
+        });
+    }
+    getChangedShasums(oldShasums, currentShasums) {
+        if (!oldShasums) {
+            return currentShasums;
+        }
+        return _.omitBy(currentShasums, (hash, pathToFile) => !!oldShasums[pathToFile] && oldShasums[pathToFile] === hash);
+    }
+    removeHashes(localToDevicePaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const oldShasums = yield this.getShasumsFromDevice();
+            if (oldShasums) {
+                const fileToShasumDictionary = _.omit(oldShasums, localToDevicePaths.map((ldp) => ldp.getLocalPath()));
+                yield this.uploadHashFileToDevice(fileToShasumDictionary);
+                return true;
+            }
+            return false;
+        });
+    }
+    getHashFileLocalPath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return path.join(yield this.getTempDir(), AndroidDeviceHashService.HASH_FILE_NAME);
+        });
+    }
+    getTempDir() {
+        return this.$tempService.mkdirSync(`android-device-hash-service-${this.appIdentifier}`);
+    }
+    downloadHashFileFromDevice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hashFileLocalPath = yield this.getHashFileLocalPath();
+            if (!this.$fs.exists(hashFileLocalPath)) {
+                yield this.adb.executeCommand([
+                    "pull",
+                    this.hashFileDevicePath,
+                    yield this.getTempDir(),
+                ]);
+            }
+            return hashFileLocalPath;
+        });
+    }
+}
+AndroidDeviceHashService.HASH_FILE_NAME = "hashes";
+__decorate([
+    (0, decorators_1.cache)()
+], AndroidDeviceHashService.prototype, "hashFileDevicePath", null);
+__decorate([
+    (0, decorators_1.cache)()
+], AndroidDeviceHashService.prototype, "getHashFileLocalPath", null);
+__decorate([
+    (0, decorators_1.cache)()
+], AndroidDeviceHashService.prototype, "getTempDir", null);
+exports.AndroidDeviceHashService = AndroidDeviceHashService;

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

@@ -0,0 +1,164 @@
+"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.AndroidDevice = void 0;
+const device_android_debug_bridge_1 = require("./device-android-debug-bridge");
+const applicationManagerPath = require("./android-application-manager");
+const fileSystemPath = require("./android-device-file-system");
+const constants = require("../../constants");
+const _ = require("lodash");
+const decorators_1 = require("../../decorators");
+const constants_1 = require("../../../constants");
+class AndroidDevice {
+    constructor(identifier, status, $androidEmulatorServices, $logger, $devicePlatformsConstants, $logcatHelper, $injector) {
+        this.identifier = identifier;
+        this.status = status;
+        this.$androidEmulatorServices = $androidEmulatorServices;
+        this.$logger = $logger;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$logcatHelper = $logcatHelper;
+        this.$injector = $injector;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.adb = this.$injector.resolve(device_android_debug_bridge_1.DeviceAndroidDebugBridge, {
+                identifier: this.identifier,
+            });
+            this.applicationManager = this.$injector.resolve(applicationManagerPath.AndroidApplicationManager, { adb: this.adb, identifier: this.identifier });
+            this.fileSystem = this.$injector.resolve(fileSystemPath.AndroidDeviceFileSystem, { adb: this.adb });
+            let details = yield this.getDeviceDetails(["getprop"]);
+            if (!details || !details.name) {
+                details = yield this.getDeviceDetails(["cat", "/system/build.prop"]);
+            }
+            this.$logger.trace(details);
+            const adbStatusInfo = AndroidDevice.ADB_DEVICE_STATUS_INFO[this.status];
+            const type = yield this.getType();
+            let version = details.release;
+            if (version && version.toLowerCase() === "q") {
+                version = "10.0.0";
+            }
+            this.deviceInfo = {
+                identifier: this.identifier,
+                displayName: details.name,
+                model: details.model,
+                abis: [
+                    ...details["cpu.abilist64"].split(","),
+                    ...details["cpu.abilist32"].split(","),
+                ],
+                version,
+                vendor: details.brand,
+                platform: this.$devicePlatformsConstants.Android,
+                status: adbStatusInfo ? adbStatusInfo.deviceStatus : this.status,
+                errorHelp: adbStatusInfo ? adbStatusInfo.errorHelp : "Unknown status",
+                isTablet: this.getIsTablet(details),
+                type,
+                connectionTypes: [constants_1.DeviceConnectionType.Local],
+            };
+            this.deviceInfo.connectionTypes = this.isEmulator
+                ? [constants_1.DeviceConnectionType.Local]
+                : [constants_1.DeviceConnectionType.USB];
+            if (this.isEmulator) {
+                this.deviceInfo.displayName =
+                    yield this.$androidEmulatorServices.getRunningEmulatorName(this.identifier);
+                this.deviceInfo.imageIdentifier =
+                    yield this.$androidEmulatorServices.getRunningEmulatorImageIdentifier(this.identifier);
+            }
+            this.$logger.trace(this.deviceInfo);
+        });
+    }
+    get isEmulator() {
+        return this.deviceInfo.type === constants.DeviceTypes.Emulator;
+    }
+    get isOnlyWiFiConnected() {
+        return false;
+    }
+    openDeviceLogStream() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.deviceInfo.status === constants.CONNECTED_STATUS) {
+                yield this.$logcatHelper.start({
+                    deviceIdentifier: this.identifier,
+                    keepSingleProcess: true,
+                });
+            }
+        });
+    }
+    detach() {
+        if (this.isEmulator) {
+            this.$androidEmulatorServices.detach(this.deviceInfo);
+        }
+    }
+    getDeviceDetails(shellCommandArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parsedDetails = {};
+            this.$logger.trace(`Trying to get information for Android device. Command is: ${shellCommandArgs}`);
+            try {
+                const details = yield this.adb.executeShellCommand(shellCommandArgs);
+                details.split(/\r?\n|\r/).forEach((value) => {
+                    const match = /(?:\[?ro\.build\.version|ro\.product|ro\.build)\.(.+?)]?(?:\:|=)(?:\s*?\[)?(.*?)]?$/.exec(value);
+                    if (match) {
+                        parsedDetails[match[1]] = match[2];
+                    }
+                });
+            }
+            catch (err) {
+                this.$logger.trace(`Error while getting details from Android device. Command is: ${shellCommandArgs}. Error is: ${err}`);
+            }
+            this.$logger.trace(parsedDetails);
+            return parsedDetails;
+        });
+    }
+    getIsTablet(details) {
+        return (details &&
+            (_.startsWith(details.release, "3.") ||
+                _.includes((details.characteristics || "").toLowerCase(), "tablet")));
+    }
+    getType() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const runningEmulatorIds = yield this.$androidEmulatorServices.getRunningEmulatorIds();
+            if (_.find(runningEmulatorIds, (emulatorId) => emulatorId === this.identifier)) {
+                return constants.DeviceTypes.Emulator;
+            }
+            return constants.DeviceTypes.Device;
+        });
+    }
+}
+AndroidDevice.ADB_DEVICE_STATUS_INFO = {
+    device: {
+        errorHelp: null,
+        deviceStatus: constants.CONNECTED_STATUS,
+    },
+    offline: {
+        errorHelp: "The device instance is not connected to adb or is not responding.",
+        deviceStatus: constants.UNREACHABLE_STATUS,
+    },
+    unauthorized: {
+        errorHelp: "Allow USB Debugging on your device.",
+        deviceStatus: constants.UNREACHABLE_STATUS,
+    },
+    recovery: {
+        errorHelp: "Your device is in recovery mode. This mode is used to recover your phone when it is broken or to install custom roms.",
+        deviceStatus: constants.UNREACHABLE_STATUS,
+    },
+    "no permissions": {
+        errorHelp: "Insufficient permissions to communicate with the device.",
+        deviceStatus: constants.UNREACHABLE_STATUS,
+    },
+};
+__decorate([
+    (0, decorators_1.cache)()
+], AndroidDevice.prototype, "init", null);
+exports.AndroidDevice = AndroidDevice;