@akylas/nativescript-cli 8.8.2 → 8.8.3

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

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AndroidDeviceFileSystem = void 0;
 const path = require("path");
@@ -26,142 +17,118 @@ class AndroidDeviceFileSystem {
         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);
-        });
+    async listFiles(devicePath, appIdentifier) {
+        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",
+    async getFile(deviceFilePath, appIdentifier, outputPath) {
+        const stdout = !outputPath;
+        if (stdout) {
+            outputPath = await this.$tempService.path({
+                prefix: "sync",
+                suffix: ".tmp",
+            });
+        }
+        await this.adb.executeCommand(["pull", deviceFilePath, outputPath]);
+        if (stdout) {
+            await new Promise((resolve, reject) => {
+                const readStream = this.$fs.createReadStream(outputPath);
+                readStream.pipe(process.stdout);
+                readStream.on("end", () => {
+                    resolve();
                 });
-            }
-            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);
-                    });
+                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;
-        });
+    async getFileContent(deviceFilePath, appIdentifier) {
+        const result = await 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);
-        });
+    async putFile(localFilePath, deviceFilePath, appIdentifier) {
+        await 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);
+    async transferFiles(deviceAppData, localToDevicePaths) {
+        const directoriesToChmod = [];
+        const transferredFiles = [];
+        const action = async (localToDevicePathData) => {
+            const fstat = this.$fs.getFsStats(localToDevicePathData.getLocalPath());
+            if (fstat.isFile()) {
+                const devicePath = localToDevicePathData.getDevicePath();
+                await this.adb.pushFile(localToDevicePathData.getLocalPath(), devicePath);
+                transferredFiles.push(localToDevicePathData);
             }
-            if (transferredLocalToDevicePaths.length) {
-                const filesToChmodOnDevice = transferredLocalToDevicePaths.map((localToDevicePath) => localToDevicePath.getDevicePath());
-                yield this.chmodFiles(deviceProjectDir, filesToChmodOnDevice);
+            else if (fstat.isDirectory()) {
+                const dirToChmod = localToDevicePathData.getDevicePath();
+                directoriesToChmod.push(dirToChmod);
             }
-            return transferredLocalToDevicePaths;
-        });
+        };
+        await (0, helpers_1.executeActionByChunks)(localToDevicePaths, constants_1.DEFAULT_CHUNK_SIZE, action);
+        const dirsChmodAction = (directoryToChmod) => this.adb.executeShellCommand(["chmod", "0777", directoryToChmod]);
+        await (0, helpers_1.executeActionByChunks)(_.uniq(directoriesToChmod), constants_1.DEFAULT_CHUNK_SIZE, dirsChmodAction);
+        return transferredFiles;
     }
-    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]);
-        });
+    async transferDirectory(deviceAppData, localToDevicePaths, projectFilesPath) {
+        const minAndroidWithoutAdbPushDir = "9.0.0";
+        const isAdbPushDirSupported = semver.lt(semver.coerce(deviceAppData.device.deviceInfo.version), minAndroidWithoutAdbPushDir);
+        const deviceProjectDir = await deviceAppData.getDeviceProjectRootPath();
+        let transferredLocalToDevicePaths = [];
+        if (isAdbPushDirSupported) {
+            await this.adb.pushFile(projectFilesPath, deviceProjectDir);
+            transferredLocalToDevicePaths = localToDevicePaths;
+        }
+        else {
+            transferredLocalToDevicePaths = await this.pushFiles(localToDevicePaths);
+        }
+        if (transferredLocalToDevicePaths.length) {
+            const filesToChmodOnDevice = transferredLocalToDevicePaths.map((localToDevicePath) => localToDevicePath.getDevicePath());
+            await this.chmodFiles(deviceProjectDir, filesToChmodOnDevice);
+        }
+        return transferredLocalToDevicePaths;
     }
-    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;
-        });
+    async chmodFiles(deviceProjectRoot, filesToChmodOnDevice) {
+        const commandsDeviceFilePath = this.$mobileHelper.buildDevicePath(deviceProjectRoot, "nativescript.commands.sh");
+        await this.createFileOnDevice(commandsDeviceFilePath, `chmod 0777 ${filesToChmodOnDevice.join(" ")}`);
+        await this.adb.executeShellCommand([commandsDeviceFilePath]);
     }
-    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);
-            }
-        });
+    async pushFiles(localToDevicePaths) {
+        this.$logger.trace("Changed hashes are:", localToDevicePaths);
+        const transferredFiles = [];
+        const transferFileAction = async (localToDevicePathData) => {
+            transferredFiles.push(localToDevicePathData);
+            await this.transferFile(localToDevicePathData.getLocalPath(), localToDevicePathData.getDevicePath());
+        };
+        await (0, helpers_1.executeActionByChunks)(localToDevicePaths, constants_1.DEFAULT_CHUNK_SIZE, transferFileAction);
+        return transferredFiles;
+    }
+    async transferFile(localPath, devicePath) {
+        this.$logger.trace(`Transfering ${localPath} to ${devicePath}`);
+        const stats = this.$fs.getFsStats(localPath);
+        if (stats.isDirectory()) {
+            await this.adb.executeShellCommand(["mkdir", path.dirname(devicePath)]);
+        }
+        else {
+            await 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]);
-        });
+    async createFileOnDevice(deviceFilePath, fileContent) {
+        const hostTmpDir = await this.$tempService.mkdirSync("application-");
+        const commandsFileHostPath = path.join(hostTmpDir, "temp.commands.file");
+        this.$fs.writeFile(commandsFileHostPath, fileContent);
+        await this.transferFile(commandsFileHostPath, deviceFilePath);
+        await this.adb.executeShellCommand(["chmod", "0777", deviceFilePath]);
     }
-    deleteFile(deviceFilePath, appIdentifier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.adb.executeShellCommand(["rm", "-rf", deviceFilePath]);
-        });
+    async deleteFile(deviceFilePath, appIdentifier) {
+        await 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);
-        });
+    async updateHashesOnDevice(hashes, appIdentifier) {
+        const deviceHashService = this.getDeviceHashService(appIdentifier);
+        await deviceHashService.uploadHashFileToDevice(hashes);
     }
     getDeviceHashService(appIdentifier) {
         if (!this._deviceHashServices[appIdentifier]) {

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

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AndroidDeviceHashService = void 0;
 const path = require("path");
@@ -32,49 +23,39 @@ class AndroidDeviceHashService {
     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);
-        });
+    async doesShasumFileExistsOnDevice() {
+        const lsResult = await 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;
-        });
+    async getShasumsFromDevice() {
+        const hashFileLocalPath = await 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);
-        });
+    async uploadHashFileToDevice(data) {
+        const hashFileLocalPath = await this.getHashFileLocalPath();
+        this.$fs.writeJson(hashFileLocalPath, data);
+        await 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);
-        });
+    async updateHashes(localToDevicePaths) {
+        const oldShasums = (await this.getShasumsFromDevice()) || {};
+        await this.generateHashesFromLocalToDevicePaths(localToDevicePaths, oldShasums);
+        await 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;
-        });
+    async generateHashesFromLocalToDevicePaths(localToDevicePaths, initialShasums = {}) {
+        const action = async (localToDevicePathData) => {
+            const localPath = localToDevicePathData.getLocalPath();
+            if (this.$fs.getFsStats(localPath).isFile()) {
+                initialShasums[localPath] = await this.$fs.getFileShasum(localPath);
+            }
+        };
+        await (0, helpers_1.executeActionByChunks)(localToDevicePaths, constants_1.DEFAULT_CHUNK_SIZE, action);
+        return initialShasums;
     }
     getDevicePaths(localToDevicePaths) {
         return _.map(localToDevicePaths, (localToDevicePathData) => {
@@ -87,39 +68,34 @@ class AndroidDeviceHashService {
         }
         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;
-        });
+    async removeHashes(localToDevicePaths) {
+        const oldShasums = await this.getShasumsFromDevice();
+        if (oldShasums) {
+            const fileToShasumDictionary = _.omit(oldShasums, localToDevicePaths.map((ldp) => ldp.getLocalPath()));
+            await 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);
-        });
+    async getHashFileLocalPath() {
+        return path.join(await 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;
-        });
+    async downloadHashFileFromDevice() {
+        const hashFileLocalPath = await this.getHashFileLocalPath();
+        if (!this.$fs.exists(hashFileLocalPath)) {
+            await this.adb.executeCommand([
+                "pull",
+                this.hashFileDevicePath,
+                await this.getTempDir(),
+            ]);
+        }
+        return hashFileLocalPath;
     }
 }
+exports.AndroidDeviceHashService = AndroidDeviceHashService;
 AndroidDeviceHashService.HASH_FILE_NAME = "hashes";
 __decorate([
     (0, decorators_1.cache)()
@@ -130,4 +106,3 @@ __decorate([
 __decorate([
     (0, decorators_1.cache)()
 ], AndroidDeviceHashService.prototype, "getTempDir", null);
-exports.AndroidDeviceHashService = AndroidDeviceHashService;

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

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AndroidDevice = void 0;
 const device_android_debug_bridge_1 = require("./device-android-debug-bridge");
@@ -33,52 +24,50 @@ class AndroidDevice {
         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);
+    async init() {
+        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 = await this.getDeviceDetails(["getprop"]);
+        if (!details || !details.name) {
+            details = await this.getDeviceDetails(["cat", "/system/build.prop"]);
+        }
+        this.$logger.trace(details);
+        const adbStatusInfo = AndroidDevice.ADB_DEVICE_STATUS_INFO[this.status];
+        const type = await 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 =
+                await this.$androidEmulatorServices.getRunningEmulatorName(this.identifier);
+            this.deviceInfo.imageIdentifier =
+                await this.$androidEmulatorServices.getRunningEmulatorImageIdentifier(this.identifier);
+        }
+        this.$logger.trace(this.deviceInfo);
     }
     get isEmulator() {
         return this.deviceInfo.type === constants.DeviceTypes.Emulator;
@@ -86,56 +75,51 @@ class AndroidDevice {
     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,
-                });
-            }
-        });
+    async openDeviceLogStream() {
+        if (this.deviceInfo.status === constants.CONNECTED_STATUS) {
+            await 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;
-        });
+    async getDeviceDetails(shellCommandArgs) {
+        const parsedDetails = {};
+        this.$logger.trace(`Trying to get information for Android device. Command is: ${shellCommandArgs}`);
+        try {
+            const details = await 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;
-        });
+    async getType() {
+        const runningEmulatorIds = await this.$androidEmulatorServices.getRunningEmulatorIds();
+        if (_.find(runningEmulatorIds, (emulatorId) => emulatorId === this.identifier)) {
+            return constants.DeviceTypes.Emulator;
+        }
+        return constants.DeviceTypes.Device;
     }
 }
+exports.AndroidDevice = AndroidDevice;
 AndroidDevice.ADB_DEVICE_STATUS_INFO = {
     device: {
         errorHelp: null,
@@ -161,4 +145,3 @@ AndroidDevice.ADB_DEVICE_STATUS_INFO = {
 __decorate([
     (0, decorators_1.cache)()
 ], AndroidDevice.prototype, "init", null);
-exports.AndroidDevice = AndroidDevice;