nativescript 8.9.0-dev.2 → 8.9.0-dev.4

package/lib/common/mobile/android/android-application-manager.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.AndroidApplicationManager = void 0;
 const os_1 = require("os");
@@ -40,154 +31,144 @@ class AndroidApplicationManager extends application_manager_base_1.ApplicationMa
         this.PID_CHECK_INTERVAL = 100;
         this.PID_CHECK_TIMEOUT = 10000; // 10 secs
     }
-    getInstalledApplications() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = (yield this.adb.executeShellCommand(["pm", "list", "packages"])) || "";
-            const regex = /package:(.+)/;
-            return result
-                .split(os_1.EOL)
-                .map((packageString) => {
-                const match = packageString.match(regex);
-                return match ? match[1] : null;
-            })
-                .filter((parsedPackage) => parsedPackage !== null);
-        });
+    async getInstalledApplications() {
+        const result = (await this.adb.executeShellCommand(["pm", "list", "packages"])) || "";
+        const regex = /package:(.+)/;
+        return result
+            .split(os_1.EOL)
+            .map((packageString) => {
+            const match = packageString.match(regex);
+            return match ? match[1] : null;
+        })
+            .filter((parsedPackage) => parsedPackage !== null);
     }
-    installApplication(packageFilePath, appIdentifier, buildData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (appIdentifier) {
-                const deviceRootPath = `${constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appIdentifier}`;
-                yield this.adb.executeShellCommand(["rm", "-rf", deviceRootPath]);
-            }
-            const { dir, name, ext } = (0, path_1.parse)(packageFilePath);
-            if (ext === constants_2.AAB_EXTENSION_NAME) {
-                const apksOutputPath = (0, path_1.join)(dir, name) + constants_2.APKS_EXTENSION_NAME;
-                if (!this.hasValidApksFile(packageFilePath, apksOutputPath)) {
-                    yield this.$androidBundleToolService.buildApks({
-                        aabFilePath: packageFilePath,
-                        apksOutputPath,
-                        signingData: buildData,
-                    });
-                }
-                yield this.$androidBundleToolService.installApks({
-                    apksFilePath: apksOutputPath,
-                    deviceId: this.identifier,
+    async installApplication(packageFilePath, appIdentifier, buildData) {
+        if (appIdentifier) {
+            const deviceRootPath = `${constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appIdentifier}`;
+            await this.adb.executeShellCommand(["rm", "-rf", deviceRootPath]);
+        }
+        const { dir, name, ext } = (0, path_1.parse)(packageFilePath);
+        if (ext === constants_2.AAB_EXTENSION_NAME) {
+            const apksOutputPath = (0, path_1.join)(dir, name) + constants_2.APKS_EXTENSION_NAME;
+            if (!this.hasValidApksFile(packageFilePath, apksOutputPath)) {
+                await this.$androidBundleToolService.buildApks({
+                    aabFilePath: packageFilePath,
+                    apksOutputPath,
+                    signingData: buildData,
                 });
             }
-            else {
-                return this.adb.executeCommand(["install", "-r", `${packageFilePath}`]);
-            }
-        });
+            await this.$androidBundleToolService.installApks({
+                apksFilePath: apksOutputPath,
+                deviceId: this.identifier,
+            });
+        }
+        else {
+            return this.adb.executeCommand(["install", "-r", `${packageFilePath}`]);
+        }
     }
     uninstallApplication(appIdentifier) {
         // Need to set the treatErrorsAsWarnings to true because when using tns run command if the application is not installed on the device it will throw error
         return this.adb.executeShellCommand(["pm", "uninstall", `${appIdentifier}`], { treatErrorsAsWarnings: true });
     }
-    startApplication(appData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (appData.waitForDebugger) {
-                yield this.adb.executeShellCommand([
-                    `cat /dev/null > ${constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appData.appId}-debugbreak`,
-                ]);
-            }
-            // If the app is debuggable, the Runtime will update the file when its ready for debugging
-            // and we will be able to take decisions and synchronize the debug experience based on the content
-            yield this.adb.executeShellCommand([
-                `cat /dev/null > ${constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appData.appId}-debugger-started`,
+    async startApplication(appData) {
+        if (appData.waitForDebugger) {
+            await this.adb.executeShellCommand([
+                `cat /dev/null > ${constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appData.appId}-debugbreak`,
             ]);
-            /*
-            Example "pm dump <app_identifier> | grep -A 1 MAIN" output"
-                android.intent.action.MAIN:
-                3b2df03 org.nativescript.cliapp/com.tns.NativeScriptActivity filter 50dd82e
-                Action: "android.intent.action.MAIN"
-                Category: "android.intent.category.LAUNCHER"
-                --
-                intent={act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=org.nativescript.cliapp/com.tns.NativeScriptActivity}
-                realActivity=org.nativescript.cliapp/com.tns.NativeScriptActivity
-                --
-                Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=org.nativescript.cliapp/com.tns.NativeScriptActivity }
-                frontOfTask=true task=TaskRecord{fe592ac #449 A=org.nativescript.cliapp U=0 StackId=1 sz=1}
-            */
-            const appIdentifier = appData.appId;
-            const pmDumpOutput = yield this.adb.executeShellCommand([
-                "pm",
-                "dump",
+        }
+        // If the app is debuggable, the Runtime will update the file when its ready for debugging
+        // and we will be able to take decisions and synchronize the debug experience based on the content
+        await this.adb.executeShellCommand([
+            `cat /dev/null > ${constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appData.appId}-debugger-started`,
+        ]);
+        /*
+        Example "pm dump <app_identifier> | grep -A 1 MAIN" output"
+            android.intent.action.MAIN:
+            3b2df03 org.nativescript.cliapp/com.tns.NativeScriptActivity filter 50dd82e
+            Action: "android.intent.action.MAIN"
+            Category: "android.intent.category.LAUNCHER"
+            --
+            intent={act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=org.nativescript.cliapp/com.tns.NativeScriptActivity}
+            realActivity=org.nativescript.cliapp/com.tns.NativeScriptActivity
+            --
+            Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10200000 cmp=org.nativescript.cliapp/com.tns.NativeScriptActivity }
+            frontOfTask=true task=TaskRecord{fe592ac #449 A=org.nativescript.cliapp U=0 StackId=1 sz=1}
+        */
+        const appIdentifier = appData.appId;
+        const pmDumpOutput = await this.adb.executeShellCommand([
+            "pm",
+            "dump",
+            appIdentifier,
+            "|",
+            "grep",
+            "-A",
+            "1",
+            "MAIN",
+        ]);
+        const activityMatch = this.getFullyQualifiedActivityRegex(appIdentifier);
+        const match = activityMatch.exec(pmDumpOutput);
+        const possibleIdentifier = match && match[0];
+        if (possibleIdentifier) {
+            await this.adb.executeShellCommand([
+                "am",
+                "start",
+                "-n",
+                possibleIdentifier,
+            ]);
+        }
+        else {
+            this.$logger.trace(`Tried starting activity for: ${appIdentifier}, using activity manager but failed.`);
+            await this.adb.executeShellCommand([
+                "monkey",
+                "-p",
                 appIdentifier,
-                "|",
-                "grep",
-                "-A",
+                "-c",
+                "android.intent.category.LAUNCHER",
                 "1",
-                "MAIN",
             ]);
-            const activityMatch = this.getFullyQualifiedActivityRegex(appIdentifier);
-            const match = activityMatch.exec(pmDumpOutput);
-            const possibleIdentifier = match && match[0];
-            if (possibleIdentifier) {
-                yield this.adb.executeShellCommand([
-                    "am",
-                    "start",
-                    "-n",
-                    possibleIdentifier,
-                ]);
+        }
+        await this.onAppLaunch(appData);
+    }
+    async onAppLaunch(appData) {
+        const appIdentifier = appData.appId;
+        if (!this.$options.justlaunch && !appData.justLaunch) {
+            const deviceIdentifier = this.identifier;
+            const processIdentifier = await this.getAppProcessId(deviceIdentifier, appIdentifier);
+            if (processIdentifier) {
+                this.$deviceLogProvider.setApplicationPidForDevice(deviceIdentifier, processIdentifier);
+                this.$deviceLogProvider.setApplicationIdForDevice(deviceIdentifier, appIdentifier);
+                this.$deviceLogProvider.setProjectDirForDevice(deviceIdentifier, appData.projectDir);
+                await this.$logcatHelper.start({
+                    deviceIdentifier: this.identifier,
+                    pid: processIdentifier,
+                    appId: appIdentifier,
+                    onAppRestarted: () => {
+                        // If the app restarts, we update the PID and
+                        // restart log helper.
+                        this.onAppLaunch(appData);
+                    },
+                });
             }
             else {
-                this.$logger.trace(`Tried starting activity for: ${appIdentifier}, using activity manager but failed.`);
-                yield this.adb.executeShellCommand([
-                    "monkey",
-                    "-p",
-                    appIdentifier,
-                    "-c",
-                    "android.intent.category.LAUNCHER",
-                    "1",
-                ]);
+                await this.$logcatHelper.dump(this.identifier);
+                this.$errors.fail(`Unable to find running "${appIdentifier}" application on device "${deviceIdentifier}".`);
             }
-            yield this.onAppLaunch(appData);
-        });
-    }
-    onAppLaunch(appData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const appIdentifier = appData.appId;
-            if (!this.$options.justlaunch && !appData.justLaunch) {
-                const deviceIdentifier = this.identifier;
-                const processIdentifier = yield this.getAppProcessId(deviceIdentifier, appIdentifier);
-                if (processIdentifier) {
-                    this.$deviceLogProvider.setApplicationPidForDevice(deviceIdentifier, processIdentifier);
-                    this.$deviceLogProvider.setApplicationIdForDevice(deviceIdentifier, appIdentifier);
-                    this.$deviceLogProvider.setProjectDirForDevice(deviceIdentifier, appData.projectDir);
-                    yield this.$logcatHelper.start({
-                        deviceIdentifier: this.identifier,
-                        pid: processIdentifier,
-                        appId: appIdentifier,
-                        onAppRestarted: () => {
-                            // If the app restarts, we update the PID and
-                            // restart log helper.
-                            this.onAppLaunch(appData);
-                        },
-                    });
-                }
-                else {
-                    yield this.$logcatHelper.dump(this.identifier);
-                    this.$errors.fail(`Unable to find running "${appIdentifier}" application on device "${deviceIdentifier}".`);
-                }
-            }
-        });
+        }
     }
-    getAppProcessId(deviceIdentifier, appIdentifier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const appIdCheckStartTime = new Date().getTime();
-            let processIdentifier = "";
-            let hasTimedOut = false;
-            while (!processIdentifier && !hasTimedOut) {
-                processIdentifier = yield this.$androidProcessService.getAppProcessId(deviceIdentifier, appIdentifier);
-                if (!processIdentifier) {
-                    this.$logger.trace(`Wasn't able to get pid of the app. Sleeping for "${this.PID_CHECK_INTERVAL}ms".`);
-                    yield (0, helpers_1.sleep)(this.PID_CHECK_INTERVAL);
-                    hasTimedOut =
-                        new Date().getTime() - appIdCheckStartTime > this.PID_CHECK_TIMEOUT;
-                }
+    async getAppProcessId(deviceIdentifier, appIdentifier) {
+        const appIdCheckStartTime = new Date().getTime();
+        let processIdentifier = "";
+        let hasTimedOut = false;
+        while (!processIdentifier && !hasTimedOut) {
+            processIdentifier = await this.$androidProcessService.getAppProcessId(deviceIdentifier, appIdentifier);
+            if (!processIdentifier) {
+                this.$logger.trace(`Wasn't able to get pid of the app. Sleeping for "${this.PID_CHECK_INTERVAL}ms".`);
+                await (0, helpers_1.sleep)(this.PID_CHECK_INTERVAL);
+                hasTimedOut =
+                    new Date().getTime() - appIdCheckStartTime > this.PID_CHECK_TIMEOUT;
             }
-            return processIdentifier;
-        });
+        }
+        return processIdentifier;
     }
     stopApplication(appData) {
         this.$logcatHelper.stop(this.identifier);
@@ -202,25 +183,23 @@ class AndroidApplicationManager extends application_manager_base_1.ApplicationMa
     getDebuggableApps() {
         return this.$androidProcessService.getDebuggableApps(this.identifier);
     }
-    getDebuggableAppViews(appIdentifiers) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const mappedAppIdentifierPorts = yield this.$androidProcessService.getMappedAbstractToTcpPorts(this.identifier, appIdentifiers, constants_1.TARGET_FRAMEWORK_IDENTIFIERS.Cordova), applicationViews = {};
-            yield Promise.all(_.map(mappedAppIdentifierPorts, (port, appIdentifier) => __awaiter(this, void 0, void 0, function* () {
-                applicationViews[appIdentifier] = [];
-                const localAddress = `http://127.0.0.1:${port}/json`;
-                try {
-                    if (port) {
-                        const apps = (yield this.$httpClient.httpRequest(localAddress))
-                            .body;
-                        applicationViews[appIdentifier] = JSON.parse(apps);
-                    }
+    async getDebuggableAppViews(appIdentifiers) {
+        const mappedAppIdentifierPorts = await this.$androidProcessService.getMappedAbstractToTcpPorts(this.identifier, appIdentifiers, constants_1.TARGET_FRAMEWORK_IDENTIFIERS.Cordova), applicationViews = {};
+        await Promise.all(_.map(mappedAppIdentifierPorts, async (port, appIdentifier) => {
+            applicationViews[appIdentifier] = [];
+            const localAddress = `http://127.0.0.1:${port}/json`;
+            try {
+                if (port) {
+                    const apps = (await this.$httpClient.httpRequest(localAddress))
+                        .body;
+                    applicationViews[appIdentifier] = JSON.parse(apps);
                 }
-                catch (err) {
-                    this.$logger.trace(`Error while checking ${localAddress}. Error is: ${err.message}`);
-                }
-            })));
-            return applicationViews;
-        });
+            }
+            catch (err) {
+                this.$logger.trace(`Error while checking ${localAddress}. Error is: ${err.message}`);
+            }
+        }));
+        return applicationViews;
     }
     getFullyQualifiedActivityRegex(appIdentifier) {
         const packageActivitySeparator = "\\/";
@@ -237,11 +216,11 @@ class AndroidApplicationManager extends application_manager_base_1.ApplicationMa
         return isValid;
     }
 }
+exports.AndroidApplicationManager = AndroidApplicationManager;
 __decorate([
     (0, helpers_1.hook)("install")
 ], AndroidApplicationManager.prototype, "installApplication", null);
 __decorate([
     (0, decorators_1.cache)()
 ], AndroidApplicationManager.prototype, "getFullyQualifiedActivityRegex", null);
-exports.AndroidApplicationManager = AndroidApplicationManager;
 //# sourceMappingURL=android-application-manager.js.map

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

@@ -46,6 +46,7 @@ class AndroidDebugBridgeResultHandler {
         }
     }
 }
+exports.AndroidDebugBridgeResultHandler = AndroidDebugBridgeResultHandler;
 AndroidDebugBridgeResultHandler.ANDROID_DEBUG_BRIDGE_ERRORS = [
     {
         name: "device unauthorized",
@@ -328,6 +329,5 @@ AndroidDebugBridgeResultHandler.ANDROID_DEBUG_BRIDGE_ERRORS = [
         resultCode: -7,
     },
 ];
-exports.AndroidDebugBridgeResultHandler = AndroidDebugBridgeResultHandler;
 yok_1.injector.register("androidDebugBridgeResultHandler", AndroidDebugBridgeResultHandler);
 //# sourceMappingURL=android-debug-bridge-result-handler.js.map

package/lib/common/mobile/android/android-debug-bridge.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.AndroidDebugBridge = void 0;
 const path = require("path");
@@ -30,39 +21,35 @@ class AndroidDebugBridge {
         this.$androidDebugBridgeResultHandler = $androidDebugBridgeResultHandler;
         this.adbFilePath = null;
     }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.adbFilePath = yield this.$staticConfig.getAdbFilePath();
-        });
+    async init() {
+        this.adbFilePath = await 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);
-                }
+    async executeCommand(args, options) {
+        let event = "close";
+        const deviceIdentifier = options && options.deviceIdentifier;
+        const command = await 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);
             }
-            // If adb -s <invalid device id> install <smth> is executed the childProcess won't get any response
-            // because the adb will be waiting for valid device and will not send close or exit event.
-            // For example `adb -s <invalid device id> install <smth>` throws error 'error: device \'030939f508e6c773\' not found\r\n' exitCode 4294967295
-            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);
-            }
-            // Some adb commands returns array of strings instead of object with stdout and stderr. (adb start-server)
-            return result.stdout === undefined || result.stdout === null
-                ? result
-                : result.stdout;
-        });
+        }
+        // If adb -s <invalid device id> install <smth> is executed the childProcess won't get any response
+        // because the adb will be waiting for valid device and will not send close or exit event.
+        // For example `adb -s <invalid device id> install <smth>` throws error 'error: device \'030939f508e6c773\' not found\r\n' exitCode 4294967295
+        const result = await 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);
+        }
+        // Some adb commands returns array of strings instead of object with stdout and stderr. (adb start-server)
+        return result.stdout === undefined || result.stdout === null
+            ? result
+            : result.stdout;
     }
     getPropertyValue(deviceId, propertyName) {
         return this.$childProcess.execFile(this.adbFilePath, [
@@ -73,92 +60,81 @@ class AndroidDebugBridge {
             propertyName,
         ]);
     }
-    getDevices() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield this.executeCommand(["devices"], {
-                returnChildProcess: true,
+    async getDevices() {
+        const result = await 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();
             });
-            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);
-                    }
-                }));
+            result.stderr.on("data", (data) => {
+                errorData += (data || "").toString();
+            });
+            result.on("error", (error) => {
+                if (reject && !isSettled) {
+                    isSettled = true;
+                    reject(error);
+                }
+            });
+            result.on("close", async (exitCode) => {
+                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;
-        });
+    async getDevicesSafe() {
+        let adbDevices = [];
+        try {
+            adbDevices = await 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 };
-        });
+    async composeCommand(params, identifier) {
+        const command = await 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;
-        });
+    async executeShellCommand(args, options) {
+        args.unshift("shell");
+        const result = await 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));
-            // starting from API level 28, the push command is returning an error if the directory does not exist
-            yield this.executeShellCommand(["mkdir", "-p", fileDirectory]);
-            yield this.executeCommand(["push", localFilePath, deviceFilePath]);
-            yield this.executeShellCommand(["chmod", "0777", fileDirectory]);
-        });
+    async pushFile(localFilePath, deviceFilePath) {
+        const fileDirectory = (0, helpers_1.fromWindowsRelativePathToUnix)(path.dirname(deviceFilePath));
+        // starting from API level 28, the push command is returning an error if the directory does not exist
+        await this.executeShellCommand(["mkdir", "-p", fileDirectory]);
+        await this.executeCommand(["push", localFilePath, deviceFilePath]);
+        await this.executeShellCommand(["chmod", "0777", fileDirectory]);
     }
-    removeFile(deviceFilePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.executeShellCommand(["rm", "-rf", deviceFilePath]);
-        });
+    async removeFile(deviceFilePath) {
+        await this.executeShellCommand(["rm", "-rf", deviceFilePath]);
     }
 }
+exports.AndroidDebugBridge = AndroidDebugBridge;
 __decorate([
     (0, decorators_1.cache)()
 ], AndroidDebugBridge.prototype, "init", null);
@@ -168,6 +144,5 @@ __decorate([
 __decorate([
     (0, decorators_1.invokeInit)()
 ], AndroidDebugBridge.prototype, "getDevices", null);
-exports.AndroidDebugBridge = AndroidDebugBridge;
 yok_1.injector.register("adb", AndroidDebugBridge);
 //# sourceMappingURL=android-debug-bridge.js.map