nativescript 8.9.0-dev.1 → 8.9.0-dev.2

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

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AndroidDeviceFileSystem = void 0;
 const path = require("path");
@@ -17,118 +26,145 @@ class AndroidDeviceFileSystem {
         this.$injector = $injector;
         this._deviceHashServices = Object.create(null);
     }
-    async listFiles(devicePath, appIdentifier) {
-        let listCommandArgs = ["ls", "-a", devicePath];
-        if (appIdentifier) {
-            listCommandArgs = ["run-as", appIdentifier].concat(listCommandArgs);
-        }
-        return this.adb.executeShellCommand(listCommandArgs);
+    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 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();
+    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",
                 });
-                readStream.on("error", (err) => {
-                    reject(err);
+            }
+            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);
+                    });
                 });
-            });
-        }
+            }
+        });
     }
-    async getFileContent(deviceFilePath, appIdentifier) {
-        const result = await this.adb.executeShellCommand(["cat", deviceFilePath]);
-        return result;
+    getFileContent(deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.adb.executeShellCommand(["cat", deviceFilePath]);
+            return result;
+        });
     }
-    async putFile(localFilePath, deviceFilePath, appIdentifier) {
-        await this.adb.pushFile(localFilePath, deviceFilePath);
+    putFile(localFilePath, deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adb.pushFile(localFilePath, deviceFilePath);
+        });
     }
-    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);
+    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* () {
+            // starting from Android 9, adb push is throwing an exception when there are subfolders
+            // the check could be removed when we start supporting only runtime versions with sockets
+            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 if (fstat.isDirectory()) {
-                const dirToChmod = localToDevicePathData.getDevicePath();
-                directoriesToChmod.push(dirToChmod);
+            else {
+                transferredLocalToDevicePaths = yield this.pushFiles(localToDevicePaths);
             }
-        };
-        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;
-    }
-    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;
+            if (transferredLocalToDevicePaths.length) {
+                const filesToChmodOnDevice = transferredLocalToDevicePaths.map((localToDevicePath) => localToDevicePath.getDevicePath());
+                yield this.chmodFiles(deviceProjectDir, filesToChmodOnDevice);
+            }
+            return transferredLocalToDevicePaths;
+        });
     }
-    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]);
+    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 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;
+    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 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);
-        }
+    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 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]);
+    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);
+            // copy it to the device
+            yield this.transferFile(commandsFileHostPath, deviceFilePath);
+            yield this.adb.executeShellCommand(["chmod", "0777", deviceFilePath]);
+        });
     }
-    async deleteFile(deviceFilePath, appIdentifier) {
-        await this.adb.executeShellCommand(["rm", "-rf", deviceFilePath]);
+    deleteFile(deviceFilePath, appIdentifier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.adb.executeShellCommand(["rm", "-rf", deviceFilePath]);
+        });
     }
-    async updateHashesOnDevice(hashes, appIdentifier) {
-        const deviceHashService = this.getDeviceHashService(appIdentifier);
-        await deviceHashService.uploadHashFileToDevice(hashes);
+    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]) {
@@ -141,3 +177,4 @@ class AndroidDeviceFileSystem {
     }
 }
 exports.AndroidDeviceFileSystem = AndroidDeviceFileSystem;
+//# sourceMappingURL=android-device-file-system.js.map

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

@@ -5,6 +5,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AndroidDeviceHashService = void 0;
 const path = require("path");
@@ -23,39 +32,51 @@ class AndroidDeviceHashService {
     get hashFileDevicePath() {
         return this.$mobileHelper.buildDevicePath(constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME, this.appIdentifier, AndroidDeviceHashService.HASH_FILE_NAME);
     }
-    async doesShasumFileExistsOnDevice() {
-        const lsResult = await this.adb.executeShellCommand([
-            "ls",
-            this.hashFileDevicePath,
-        ]);
-        return !!(lsResult && lsResult.trim() === this.hashFileDevicePath);
+    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 getShasumsFromDevice() {
-        const hashFileLocalPath = await this.downloadHashFileFromDevice();
-        if (this.$fs.exists(hashFileLocalPath)) {
-            return this.$fs.readJson(hashFileLocalPath);
-        }
-        return null;
+    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 uploadHashFileToDevice(data) {
-        const hashFileLocalPath = await this.getHashFileLocalPath();
-        this.$fs.writeJson(hashFileLocalPath, data);
-        await this.adb.pushFile(hashFileLocalPath, this.hashFileDevicePath);
+    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 updateHashes(localToDevicePaths) {
-        const oldShasums = (await this.getShasumsFromDevice()) || {};
-        await this.generateHashesFromLocalToDevicePaths(localToDevicePaths, oldShasums);
-        await this.uploadHashFileToDevice(oldShasums);
+    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 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;
+    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()) {
+                    // TODO: Use relative to project path for key
+                    // This will speed up livesync on the same device for the same project on different PCs.
+                    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) => {
@@ -68,34 +89,39 @@ class AndroidDeviceHashService {
         }
         return _.omitBy(currentShasums, (hash, pathToFile) => !!oldShasums[pathToFile] && oldShasums[pathToFile] === hash);
     }
-    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;
+    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 getHashFileLocalPath() {
-        return path.join(await this.getTempDir(), AndroidDeviceHashService.HASH_FILE_NAME);
+    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}`);
     }
-    async downloadHashFileFromDevice() {
-        const hashFileLocalPath = await this.getHashFileLocalPath();
-        if (!this.$fs.exists(hashFileLocalPath)) {
-            await this.adb.executeCommand([
-                "pull",
-                this.hashFileDevicePath,
-                await this.getTempDir(),
-            ]);
-        }
-        return hashFileLocalPath;
+    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;
+        });
     }
 }
-exports.AndroidDeviceHashService = AndroidDeviceHashService;
 AndroidDeviceHashService.HASH_FILE_NAME = "hashes";
 __decorate([
     (0, decorators_1.cache)()
@@ -106,3 +132,5 @@ __decorate([
 __decorate([
     (0, decorators_1.cache)()
 ], AndroidDeviceHashService.prototype, "getTempDir", null);
+exports.AndroidDeviceHashService = AndroidDeviceHashService;
+//# sourceMappingURL=android-device-hash-service.js.map

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

@@ -5,6 +5,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AndroidDevice = void 0;
 const device_android_debug_bridge_1 = require("./device-android-debug-bridge");
@@ -24,44 +33,48 @@ class AndroidDevice {
         this.$logcatHelper = $logcatHelper;
         this.$injector = $injector;
     }
-    async init() {
-        this.adb = this.$injector.resolve(device_android_debug_bridge_1.DeviceAndroidDebugBridge, {
-            identifier: this.identifier,
+    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) {
+                // In older CLI versions we are calling cat /system/build.prop to get details.
+                // Keep this logic for compatibility and possibly for devices for which getprop is not working
+                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,
+                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);
         });
-        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,
-            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;
@@ -69,51 +82,61 @@ class AndroidDevice {
     get isOnlyWiFiConnected() {
         return false;
     }
-    async openDeviceLogStream() {
-        if (this.deviceInfo.status === constants.CONNECTED_STATUS) {
-            await this.$logcatHelper.start({
-                deviceIdentifier: this.identifier,
-                keepSingleProcess: true,
-            });
-        }
+    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);
         }
     }
-    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;
+    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) => {
+                    // sample line is "ro.build.version.release=4.4" in /system/build.prop
+                    // sample line from getprop is:  [ro.build.version.release]: [6.0]
+                    // NOTE: some props do not have value: [ro.build.version.base_os]: []
+                    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) {
+        //version 3.x.x (also known as Honeycomb) is a tablet only version
         return (details &&
             (_.startsWith(details.release, "3.") ||
                 _.includes((details.characteristics || "").toLowerCase(), "tablet")));
     }
-    async getType() {
-        const runningEmulatorIds = await this.$androidEmulatorServices.getRunningEmulatorIds();
-        if (_.find(runningEmulatorIds, (emulatorId) => emulatorId === this.identifier)) {
-            return constants.DeviceTypes.Emulator;
-        }
-        return constants.DeviceTypes.Device;
+    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;
+        });
     }
 }
-exports.AndroidDevice = AndroidDevice;
+// http://stackoverflow.com/questions/31178195/what-does-adb-device-status-mean
 AndroidDevice.ADB_DEVICE_STATUS_INFO = {
     device: {
         errorHelp: null,
@@ -139,3 +162,5 @@ AndroidDevice.ADB_DEVICE_STATUS_INFO = {
 __decorate([
     (0, decorators_1.cache)()
 ], AndroidDevice.prototype, "init", null);
+exports.AndroidDevice = AndroidDevice;
+//# sourceMappingURL=android-device.js.map