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

package/lib/common/mobile/android/android-application-manager.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.AndroidApplicationManager = void 0;
 const os_1 = require("os");
@@ -29,128 +38,156 @@ class AndroidApplicationManager extends application_manager_base_1.ApplicationMa
         this.$deviceLogProvider = $deviceLogProvider;
         this.$errors = $errors;
         this.PID_CHECK_INTERVAL = 100;
-        this.PID_CHECK_TIMEOUT = 10000;
+        this.PID_CHECK_TIMEOUT = 10000; // 10 secs
     }
-    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);
+    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 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,
+    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,
                 });
             }
-            await this.$androidBundleToolService.installApks({
-                apksFilePath: apksOutputPath,
-                deviceId: this.identifier,
-            });
-        }
-        else {
-            return this.adb.executeCommand(["install", "-r", `${packageFilePath}`]);
-        }
+            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 });
     }
-    async startApplication(appData) {
-        if (appData.waitForDebugger) {
-            await this.adb.executeShellCommand([
-                `cat /dev/null > ${constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appData.appId}-debugbreak`,
-            ]);
-        }
-        await this.adb.executeShellCommand([
-            `cat /dev/null > ${constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appData.appId}-debugger-started`,
-        ]);
-        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,
+    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`,
             ]);
-        }
-        else {
-            this.$logger.trace(`Tried starting activity for: ${appIdentifier}, using activity manager but failed.`);
-            await this.adb.executeShellCommand([
-                "monkey",
-                "-p",
+            /*
+            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",
                 appIdentifier,
-                "-c",
-                "android.intent.category.LAUNCHER",
+                "|",
+                "grep",
+                "-A",
                 "1",
+                "MAIN",
             ]);
-        }
-        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: () => {
-                        this.onAppLaunch(appData);
-                    },
-                });
+            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,
+                ]);
             }
             else {
-                await this.$logcatHelper.dump(this.identifier);
-                this.$errors.fail(`Unable to find running "${appIdentifier}" application on device "${deviceIdentifier}".`);
+                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",
+                ]);
             }
-        }
+            yield this.onAppLaunch(appData);
+        });
     }
-    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;
+    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}".`);
+                }
             }
-        }
-        return processIdentifier;
+        });
+    }
+    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;
+                }
+            }
+            return processIdentifier;
+        });
     }
     stopApplication(appData) {
         this.$logcatHelper.stop(this.identifier);
@@ -165,23 +202,25 @@ class AndroidApplicationManager extends application_manager_base_1.ApplicationMa
     getDebuggableApps() {
         return this.$androidProcessService.getDebuggableApps(this.identifier);
     }
-    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);
+    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);
+                    }
                 }
-            }
-            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 = "\\/";
@@ -198,10 +237,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,7 +46,6 @@ class AndroidDebugBridgeResultHandler {
         }
     }
 }
-exports.AndroidDebugBridgeResultHandler = AndroidDebugBridgeResultHandler;
 AndroidDebugBridgeResultHandler.ANDROID_DEBUG_BRIDGE_ERRORS = [
     {
         name: "device unauthorized",
@@ -329,4 +328,6 @@ 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,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.AndroidDebugBridge = void 0;
 const path = require("path");
@@ -21,31 +30,39 @@ class AndroidDebugBridge {
         this.$androidDebugBridgeResultHandler = $androidDebugBridgeResultHandler;
         this.adbFilePath = null;
     }
-    async init() {
-        this.adbFilePath = await this.$staticConfig.getAdbFilePath();
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.adbFilePath = yield this.$staticConfig.getAdbFilePath();
+        });
     }
-    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);
+    executeCommand(args, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let event = "close";
+            const deviceIdentifier = options && options.deviceIdentifier;
+            const command = yield this.composeCommand(args, deviceIdentifier);
+            let treatErrorsAsWarnings = false;
+            let childProcessOptions = undefined;
+            if (options) {
+                event = options.fromEvent || event;
+                treatErrorsAsWarnings = options.treatErrorsAsWarnings;
+                childProcessOptions = options.childProcessOptions;
+                if (options.returnChildProcess) {
+                    return this.$childProcess.spawn(command.command, command.args);
+                }
             }
-        }
-        const result = 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);
-        }
-        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 = 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;
+        });
     }
     getPropertyValue(deviceId, propertyName) {
         return this.$childProcess.execFile(this.adbFilePath, [
@@ -56,80 +73,92 @@ class AndroidDebugBridge {
             propertyName,
         ]);
     }
-    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();
+    getDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.executeCommand(["devices"], {
+                returnChildProcess: true,
             });
-            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);
-                }
+            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);
+                    }
+                }));
             });
         });
     }
-    async getDevicesSafe() {
-        let adbDevices = [];
-        try {
-            adbDevices = await this.getDevices();
-        }
-        catch (err) {
-            this.$logger.trace(`Getting adb devices failed with error: ${err}`);
-        }
-        return 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 composeCommand(params, identifier) {
-        const command = await this.$staticConfig.getAdbFilePath();
-        let deviceIdentifier = [];
-        if (identifier) {
-            deviceIdentifier = ["-s", `${identifier}`];
-        }
-        const args = deviceIdentifier.concat(params);
-        return { command, args };
+    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 executeShellCommand(args, options) {
-        args.unshift("shell");
-        const result = await this.executeCommand(args, options);
-        return result;
+    executeShellCommand(args, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            args.unshift("shell");
+            const result = yield this.executeCommand(args, options);
+            return result;
+        });
     }
-    async pushFile(localFilePath, deviceFilePath) {
-        const fileDirectory = (0, helpers_1.fromWindowsRelativePathToUnix)(path.dirname(deviceFilePath));
-        await this.executeShellCommand(["mkdir", "-p", fileDirectory]);
-        await this.executeCommand(["push", localFilePath, deviceFilePath]);
-        await this.executeShellCommand(["chmod", "0777", fileDirectory]);
+    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 removeFile(deviceFilePath) {
-        await this.executeShellCommand(["rm", "-rf", deviceFilePath]);
+    removeFile(deviceFilePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.executeShellCommand(["rm", "-rf", deviceFilePath]);
+        });
     }
 }
-exports.AndroidDebugBridge = AndroidDebugBridge;
 __decorate([
     (0, decorators_1.cache)()
 ], AndroidDebugBridge.prototype, "init", null);
@@ -139,4 +168,6 @@ __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