@akylas/nativescript-cli 8.8.2 → 8.8.3

package/lib/services/android/android-bundle-tool-service.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AndroidBundleToolService = void 0;
 const path_1 = require("path");
@@ -21,60 +12,52 @@ class AndroidBundleToolService {
         this.$errors = $errors;
         this.aabToolPath = (0, path_1.resolve)((0, path_1.join)(__dirname, "../../../vendor/aab-tool/bundletool.jar"));
     }
-    buildApks(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!(0, helpers_1.hasValidAndroidSigning)(options.signingData)) {
-                this.$errors.fail(`Unable to build "apks" without a full signing information.`);
-            }
-            const aabToolResult = yield this.execBundleTool([
-                "build-apks",
-                "--bundle",
-                options.aabFilePath,
-                "--output",
-                options.apksOutputPath,
-                "--ks",
-                options.signingData.keyStorePath,
-                "--ks-pass",
-                `pass:${options.signingData.keyStorePassword}`,
-                "--ks-key-alias",
-                options.signingData.keyStoreAlias,
-                "--key-pass",
-                `pass:${options.signingData.keyStoreAliasPassword}`,
-            ]);
-            if (aabToolResult.exitCode !== 0 && aabToolResult.stderr) {
-                this.$errors.fail(`Unable to build "apks" from the provided "aab". Error: ${aabToolResult.stderr}`);
-            }
-        });
+    async buildApks(options) {
+        if (!(0, helpers_1.hasValidAndroidSigning)(options.signingData)) {
+            this.$errors.fail(`Unable to build "apks" without a full signing information.`);
+        }
+        const aabToolResult = await this.execBundleTool([
+            "build-apks",
+            "--bundle",
+            options.aabFilePath,
+            "--output",
+            options.apksOutputPath,
+            "--ks",
+            options.signingData.keyStorePath,
+            "--ks-pass",
+            `pass:${options.signingData.keyStorePassword}`,
+            "--ks-key-alias",
+            options.signingData.keyStoreAlias,
+            "--key-pass",
+            `pass:${options.signingData.keyStoreAliasPassword}`,
+        ]);
+        if (aabToolResult.exitCode !== 0 && aabToolResult.stderr) {
+            this.$errors.fail(`Unable to build "apks" from the provided "aab". Error: ${aabToolResult.stderr}`);
+        }
     }
-    installApks(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const aabToolResult = yield this.execBundleTool([
-                "install-apks",
-                "--apks",
-                options.apksFilePath,
-                "--device-id",
-                options.deviceId,
-            ]);
-            if (aabToolResult.exitCode !== 0 && aabToolResult.stderr) {
-                this.$errors.fail(`Unable to install "apks" on device "${options.deviceId}". Error: ${aabToolResult.stderr}`);
-            }
-        });
+    async installApks(options) {
+        const aabToolResult = await this.execBundleTool([
+            "install-apks",
+            "--apks",
+            options.apksFilePath,
+            "--device-id",
+            options.deviceId,
+        ]);
+        if (aabToolResult.exitCode !== 0 && aabToolResult.stderr) {
+            this.$errors.fail(`Unable to install "apks" on device "${options.deviceId}". Error: ${aabToolResult.stderr}`);
+        }
     }
-    execBundleTool(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const javaPath = yield this.getJavaPath();
-            const defaultArgs = ["-jar", this.aabToolPath];
-            const result = yield this.$childProcess.trySpawnFromCloseEvent(javaPath, _.concat(defaultArgs, args));
-            return result;
-        });
+    async execBundleTool(args) {
+        const javaPath = await this.getJavaPath();
+        const defaultArgs = ["-jar", this.aabToolPath];
+        const result = await this.$childProcess.trySpawnFromCloseEvent(javaPath, _.concat(defaultArgs, args));
+        return result;
     }
-    getJavaPath() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.javaPath) {
-                this.javaPath = yield this.$sysInfo.getJavaPath();
-            }
-            return this.javaPath;
-        });
+    async getJavaPath() {
+        if (!this.javaPath) {
+            this.javaPath = await this.$sysInfo.getJavaPath();
+        }
+        return this.javaPath;
     }
 }
 exports.AndroidBundleToolService = AndroidBundleToolService;

package/lib/services/android/gradle-build-args-service.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GradleBuildArgsService = void 0;
 const path = require("path");
@@ -22,18 +13,16 @@ class GradleBuildArgsService {
         this.$projectData = $projectData;
         this.$logger = $logger;
     }
-    getBuildTaskArgs(buildData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const args = this.getBaseTaskArgs(buildData);
-            args.unshift(this.getBuildTaskName(buildData));
-            if (yield this.$analyticsService.isEnabled(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME)) {
-                args.push("-PgatherAnalyticsData=true");
-            }
-            yield this.$hooksService.executeBeforeHooks("build-task-args", {
-                hookArgs: { args },
-            });
-            return args;
+    async getBuildTaskArgs(buildData) {
+        const args = this.getBaseTaskArgs(buildData);
+        args.unshift(this.getBuildTaskName(buildData));
+        if (await this.$analyticsService.isEnabled(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME)) {
+            args.push("-PgatherAnalyticsData=true");
+        }
+        await this.$hooksService.executeBeforeHooks("build-task-args", {
+            hookArgs: { args },
         });
+        return args;
     }
     getCleanTaskArgs(buildData) {
         const args = this.getBaseTaskArgs(buildData);

package/lib/services/android/gradle-build-service.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GradleBuildService = void 0;
 const helpers_1 = require("../../common/helpers");
@@ -22,46 +13,42 @@ class GradleBuildService extends events_1.EventEmitter {
         this.$gradleCommandService = $gradleCommandService;
         this.$devicesService = $devicesService;
     }
-    buildProject(projectRoot, buildData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const buildTaskArgs = yield this.$gradleBuildArgsService.getBuildTaskArgs(buildData);
-            if (buildData.buildFilterDevicesArch) {
-                let devices = this.$devicesService.getDevicesForPlatform(buildData.platform);
-                if (buildData.emulator) {
-                    devices = devices.filter((d) => d.isEmulator);
-                }
-                const abis = devices
-                    .map((d) => d.deviceInfo.abis.filter((a) => !!a && a.length)[0])
-                    .filter((a) => !!a);
-                if (abis.length > 0 &&
-                    buildTaskArgs.findIndex((b) => b.startsWith("-PabiFilters")) === -1) {
-                    buildTaskArgs.push(`-PabiFilters=${abis.join(",")}`);
-                }
+    async buildProject(projectRoot, buildData) {
+        const buildTaskArgs = await this.$gradleBuildArgsService.getBuildTaskArgs(buildData);
+        if (buildData.buildFilterDevicesArch) {
+            let devices = this.$devicesService.getDevicesForPlatform(buildData.platform);
+            if (buildData.emulator) {
+                devices = devices.filter((d) => d.isEmulator);
             }
-            const spawnOptions = {
-                emitOptions: { eventName: constants.BUILD_OUTPUT_EVENT_NAME },
-                throwError: true,
-            };
-            const gradleCommandOptions = {
-                cwd: projectRoot,
-                message: "Gradle build...",
-                stdio: buildData.buildOutputStdio,
-                gradlePath: buildData.gradlePath,
-                spawnOptions,
-            };
-            yield (0, helpers_1.attachAwaitDetach)(constants.BUILD_OUTPUT_EVENT_NAME, this.$childProcess, (data) => this.emit(constants.BUILD_OUTPUT_EVENT_NAME, data), this.$gradleCommandService.executeCommand(buildTaskArgs, gradleCommandOptions));
-        });
+            const abis = devices
+                .map((d) => d.deviceInfo.abis.filter((a) => !!a && a.length)[0])
+                .filter((a) => !!a);
+            if (abis.length > 0 &&
+                buildTaskArgs.findIndex((b) => b.startsWith("-PabiFilters")) === -1) {
+                buildTaskArgs.push(`-PabiFilters=${abis.join(",")}`);
+            }
+        }
+        const spawnOptions = {
+            emitOptions: { eventName: constants.BUILD_OUTPUT_EVENT_NAME },
+            throwError: true,
+        };
+        const gradleCommandOptions = {
+            cwd: projectRoot,
+            message: "Gradle build...",
+            stdio: buildData.buildOutputStdio,
+            gradlePath: buildData.gradlePath,
+            spawnOptions,
+        };
+        await (0, helpers_1.attachAwaitDetach)(constants.BUILD_OUTPUT_EVENT_NAME, this.$childProcess, (data) => this.emit(constants.BUILD_OUTPUT_EVENT_NAME, data), this.$gradleCommandService.executeCommand(buildTaskArgs, gradleCommandOptions));
     }
-    cleanProject(projectRoot, buildData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const cleanTaskArgs = this.$gradleBuildArgsService.getCleanTaskArgs(buildData);
-            const gradleCommandOptions = {
-                cwd: projectRoot,
-                message: "Gradle clean...",
-                gradlePath: buildData.gradlePath,
-            };
-            yield this.$gradleCommandService.executeCommand(cleanTaskArgs, gradleCommandOptions);
-        });
+    async cleanProject(projectRoot, buildData) {
+        const cleanTaskArgs = this.$gradleBuildArgsService.getCleanTaskArgs(buildData);
+        const gradleCommandOptions = {
+            cwd: projectRoot,
+            message: "Gradle clean...",
+            gradlePath: buildData.gradlePath,
+        };
+        await this.$gradleCommandService.executeCommand(cleanTaskArgs, gradleCommandOptions);
     }
 }
 exports.GradleBuildService = GradleBuildService;

package/lib/services/android/gradle-command-service.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GradleCommandService = void 0;
 const yok_1 = require("../../common/yok");
@@ -19,34 +10,30 @@ class GradleCommandService {
         this.$hostInfo = $hostInfo;
         this.$logger = $logger;
     }
-    executeCommand(gradleArgs, options) {
+    async executeCommand(gradleArgs, options) {
         var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const { message, cwd, stdio, spawnOptions } = options;
-            this.$logger.info(message);
-            const childProcessOptions = {
-                cwd,
-                stdio: stdio || "inherit",
-                shell: this.$hostInfo.isWindows,
-            };
-            const gradleExecutable = (_a = options.gradlePath) !== null && _a !== void 0 ? _a : (this.$hostInfo.isWindows ? "gradlew.bat" : "./gradlew");
-            const sanitizedGradleArgs = this.$hostInfo.isWindows
-                ? gradleArgs.map((arg) => (0, helpers_1.quoteString)(arg))
-                : gradleArgs;
-            const result = yield this.executeCommandSafe(gradleExecutable, sanitizedGradleArgs, childProcessOptions, spawnOptions);
-            return result;
-        });
+        const { message, cwd, stdio, spawnOptions } = options;
+        this.$logger.info(message);
+        const childProcessOptions = {
+            cwd,
+            stdio: stdio || "inherit",
+            shell: this.$hostInfo.isWindows,
+        };
+        const gradleExecutable = (_a = options.gradlePath) !== null && _a !== void 0 ? _a : (this.$hostInfo.isWindows ? "gradlew.bat" : "./gradlew");
+        const sanitizedGradleArgs = this.$hostInfo.isWindows
+            ? gradleArgs.map((arg) => (0, helpers_1.quoteString)(arg))
+            : gradleArgs;
+        const result = await this.executeCommandSafe(gradleExecutable, sanitizedGradleArgs, childProcessOptions, spawnOptions);
+        return result;
     }
-    executeCommandSafe(gradleExecutable, gradleArgs, childProcessOptions, spawnOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const result = yield this.$childProcess.spawnFromEvent(gradleExecutable, gradleArgs, "close", childProcessOptions, spawnOptions);
-                return result;
-            }
-            catch (err) {
-                this.$errors.fail(err.message);
-            }
-        });
+    async executeCommandSafe(gradleExecutable, gradleArgs, childProcessOptions, spawnOptions) {
+        try {
+            const result = await this.$childProcess.spawnFromEvent(gradleExecutable, gradleArgs, "close", childProcessOptions, spawnOptions);
+            return result;
+        }
+        catch (err) {
+            this.$errors.fail(err.message);
+        }
     }
 }
 exports.GradleCommandService = GradleCommandService;

package/lib/services/android-device-debug-service.js

@@ -5,15 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AndroidDeviceDebugService = void 0;
 const helpers_1 = require("../common/helpers");
@@ -39,135 +30,117 @@ class AndroidDeviceDebugService extends debug_service_base_1.DebugServiceBase {
         this.$deviceLogProvider = $deviceLogProvider;
         this.deviceIdentifier = device.deviceInfo.identifier;
     }
-    debug(debugData, debugOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._packageName = debugData.applicationIdentifier;
-            const result = yield this.debugCore(debugData.applicationIdentifier, debugOptions);
-            if (debugOptions.start && !debugOptions.justlaunch) {
-                const pid = yield this.$androidProcessService.getAppProcessId(this.deviceIdentifier, debugData.applicationIdentifier);
-                if (pid) {
-                    this.$deviceLogProvider.setApplicationPidForDevice(this.deviceIdentifier, pid);
-                    this.$deviceLogProvider.setProjectDirForDevice(this.device.deviceInfo.identifier, debugData.projectDir);
-                    const device = yield this.$devicesService.getDevice(this.deviceIdentifier);
-                    yield device.openDeviceLogStream();
-                }
+    async debug(debugData, debugOptions) {
+        this._packageName = debugData.applicationIdentifier;
+        const result = await this.debugCore(debugData.applicationIdentifier, debugOptions);
+        if (debugOptions.start && !debugOptions.justlaunch) {
+            const pid = await this.$androidProcessService.getAppProcessId(this.deviceIdentifier, debugData.applicationIdentifier);
+            if (pid) {
+                this.$deviceLogProvider.setApplicationPidForDevice(this.deviceIdentifier, pid);
+                this.$deviceLogProvider.setProjectDirForDevice(this.device.deviceInfo.identifier, debugData.projectDir);
+                const device = await this.$devicesService.getDevice(this.deviceIdentifier);
+                await device.openDeviceLogStream();
             }
-            return result;
-        });
+        }
+        return result;
     }
     debugStop() {
         return this.removePortForwarding();
     }
-    removePortForwarding(packageName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const port = yield this.getForwardedDebugPort(this.device.deviceInfo.identifier, packageName || this._packageName);
-            return this.device.adb.executeCommand([
-                "forward",
-                "--remove",
-                `tcp:${port}`,
-            ]);
-        });
+    async removePortForwarding(packageName) {
+        const port = await this.getForwardedDebugPort(this.device.deviceInfo.identifier, packageName || this._packageName);
+        return this.device.adb.executeCommand([
+            "forward",
+            "--remove",
+            `tcp:${port}`,
+        ]);
     }
-    getForwardedDebugPort(deviceId, packageName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let port = -1;
-            const forwardsResult = yield this.device.adb.executeCommand([
-                "forward",
-                "--list",
-            ]);
-            const unixSocketName = `${packageName}-inspectorServer`;
-            const regexp = new RegExp(`(?:${deviceId} tcp:)([\\d]+)(?= localabstract:${unixSocketName})`, "g");
-            const match = regexp.exec(forwardsResult);
-            if (match) {
-                port = parseInt(match[1]);
-            }
-            else {
-                port = yield this.$net.getAvailablePortInRange(40000);
-                yield this.unixSocketForward(port, `${unixSocketName}`);
-            }
-            yield this.$cleanupService.addCleanupCommand({
-                command: yield this.$staticConfig.getAdbFilePath(),
-                args: ["-s", deviceId, "forward", "--remove", `tcp:${port}`],
-            });
-            return port;
+    async getForwardedDebugPort(deviceId, packageName) {
+        let port = -1;
+        const forwardsResult = await this.device.adb.executeCommand([
+            "forward",
+            "--list",
+        ]);
+        const unixSocketName = `${packageName}-inspectorServer`;
+        const regexp = new RegExp(`(?:${deviceId} tcp:)([\\d]+)(?= localabstract:${unixSocketName})`, "g");
+        const match = regexp.exec(forwardsResult);
+        if (match) {
+            port = parseInt(match[1]);
+        }
+        else {
+            port = await this.$net.getAvailablePortInRange(40000);
+            await this.unixSocketForward(port, `${unixSocketName}`);
+        }
+        await this.$cleanupService.addCleanupCommand({
+            command: await this.$staticConfig.getAdbFilePath(),
+            args: ["-s", deviceId, "forward", "--remove", `tcp:${port}`],
         });
+        return port;
     }
-    unixSocketForward(local, remote) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.device.adb.executeCommand([
-                "forward",
-                `tcp:${local}`,
-                `localabstract:${remote}`,
-            ]);
-        });
+    async unixSocketForward(local, remote) {
+        await this.device.adb.executeCommand([
+            "forward",
+            `tcp:${local}`,
+            `localabstract:${remote}`,
+        ]);
     }
-    debugCore(appId, debugOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = { debugUrl: null };
-            if (debugOptions.stop) {
-                yield this.removePortForwarding();
-                return result;
-            }
-            yield this.validateRunningApp(this.deviceIdentifier, appId);
-            if (debugOptions.debugBrk) {
-                yield this.waitForDebugServer(appId);
-            }
-            const debugPort = yield this.getForwardedDebugPort(this.deviceIdentifier, appId);
-            yield this.printDebugPort(this.deviceIdentifier, debugPort);
-            result.debugUrl = this.getChromeDebugUrl(debugOptions, debugPort);
+    async debugCore(appId, debugOptions) {
+        const result = { debugUrl: null };
+        if (debugOptions.stop) {
+            await this.removePortForwarding();
             return result;
-        });
+        }
+        await this.validateRunningApp(this.deviceIdentifier, appId);
+        if (debugOptions.debugBrk) {
+            await this.waitForDebugServer(appId);
+        }
+        const debugPort = await this.getForwardedDebugPort(this.deviceIdentifier, appId);
+        await this.printDebugPort(this.deviceIdentifier, debugPort);
+        result.debugUrl = this.getChromeDebugUrl(debugOptions, debugPort);
+        return result;
     }
-    printDebugPort(deviceId, port) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.$logger.info("device: " + deviceId + " debug port: " + port + "\n");
-        });
+    async printDebugPort(deviceId, port) {
+        this.$logger.info("device: " + deviceId + " debug port: " + port + "\n");
     }
-    validateRunningApp(deviceId, packageName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!(yield this.isAppRunning(packageName, deviceId))) {
-                this.$errors.fail(`The application ${packageName} does not appear to be running on ${deviceId} or is not built with debugging enabled. Try starting the application manually.`);
-            }
-        });
+    async validateRunningApp(deviceId, packageName) {
+        if (!(await this.isAppRunning(packageName, deviceId))) {
+            this.$errors.fail(`The application ${packageName} does not appear to be running on ${deviceId} or is not built with debugging enabled. Try starting the application manually.`);
+        }
     }
-    waitForDebugServer(appId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const debuggerStartedFilePath = `${constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appId}-debugger-started`;
-            const waitText = `0 ${debuggerStartedFilePath}`;
-            let maxWait = 12;
-            let debuggerStarted = false;
-            while (maxWait > 0 && !debuggerStarted) {
-                const forwardsResult = yield this.device.adb.executeShellCommand([
-                    "ls",
-                    "-s",
-                    debuggerStartedFilePath,
-                ]);
-                maxWait--;
-                debuggerStarted = forwardsResult.indexOf(waitText) === -1;
-                if (!debuggerStarted) {
-                    yield (0, helpers_1.sleep)(500);
-                }
-            }
-            if (debuggerStarted) {
-                this.$logger.info("# NativeScript Debugger started #");
-            }
-            else {
-                this.$logger.warn("# NativeScript Debugger did not start in time #");
+    async waitForDebugServer(appId) {
+        const debuggerStartedFilePath = `${constants_1.LiveSyncPaths.ANDROID_TMP_DIR_NAME}/${appId}-debugger-started`;
+        const waitText = `0 ${debuggerStartedFilePath}`;
+        let maxWait = 12;
+        let debuggerStarted = false;
+        while (maxWait > 0 && !debuggerStarted) {
+            const forwardsResult = await this.device.adb.executeShellCommand([
+                "ls",
+                "-s",
+                debuggerStartedFilePath,
+            ]);
+            maxWait--;
+            debuggerStarted = forwardsResult.indexOf(waitText) === -1;
+            if (!debuggerStarted) {
+                await (0, helpers_1.sleep)(500);
             }
-        });
+        }
+        if (debuggerStarted) {
+            this.$logger.info("# NativeScript Debugger started #");
+        }
+        else {
+            this.$logger.warn("# NativeScript Debugger did not start in time #");
+        }
     }
-    isAppRunning(appIdentifier, deviceIdentifier) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const debuggableApps = yield this.$androidProcessService.getDebuggableApps(deviceIdentifier);
-            return !!_.find(debuggableApps, (a) => a.appIdentifier === appIdentifier);
-        });
+    async isAppRunning(appIdentifier, deviceIdentifier) {
+        const debuggableApps = await this.$androidProcessService.getDebuggableApps(deviceIdentifier);
+        return !!_.find(debuggableApps, (a) => a.appIdentifier === appIdentifier);
     }
 }
+exports.AndroidDeviceDebugService = AndroidDeviceDebugService;
 __decorate([
     (0, decorators_1.performanceLog)()
 ], AndroidDeviceDebugService.prototype, "debug", null);
 __decorate([
     (0, decorators_1.performanceLog)()
 ], AndroidDeviceDebugService.prototype, "debugCore", null);
-exports.AndroidDeviceDebugService = AndroidDeviceDebugService;
 yok_1.injector.register("androidDeviceDebugService", AndroidDeviceDebugService, false);