nativescript 8.9.0-dev.0 → 8.9.0-dev.2

package/lib/services/android-device-debug-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.AndroidDeviceDebugService = void 0;
 const helpers_1 = require("../common/helpers");
@@ -30,117 +39,141 @@ class AndroidDeviceDebugService extends debug_service_base_1.DebugServiceBase {
         this.$deviceLogProvider = $deviceLogProvider;
         this.deviceIdentifier = device.deviceInfo.identifier;
     }
-    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();
+    debug(debugData, debugOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._packageName = debugData.applicationIdentifier;
+            const result = yield this.debugCore(debugData.applicationIdentifier, debugOptions);
+            // TODO: extract this logic outside the debug service
+            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();
+                }
             }
-        }
-        return result;
+            return result;
+        });
     }
     debugStop() {
         return this.removePortForwarding();
     }
-    async removePortForwarding(packageName) {
-        const port = await this.getForwardedDebugPort(this.device.deviceInfo.identifier, packageName || this._packageName);
-        return this.device.adb.executeCommand([
-            "forward",
-            "--remove",
-            `tcp:${port}`,
-        ]);
+    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 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}`],
+    // TODO: Remove this method and reuse logic from androidProcessService
+    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`;
+            //matches 123a188909e6czzc tcp:40001 localabstract:org.nativescript.testUnixSockets-debug
+            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;
         });
-        return port;
     }
-    async unixSocketForward(local, remote) {
-        await this.device.adb.executeCommand([
-            "forward",
-            `tcp:${local}`,
-            `localabstract:${remote}`,
-        ]);
+    // TODO: Remove this method and reuse logic from androidProcessService
+    unixSocketForward(local, remote) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.device.adb.executeCommand([
+                "forward",
+                `tcp:${local}`,
+                `localabstract:${remote}`,
+            ]);
+        });
     }
-    async debugCore(appId, debugOptions) {
-        const result = { debugUrl: null };
-        if (debugOptions.stop) {
-            await this.removePortForwarding();
+    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);
             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;
+        });
     }
-    async printDebugPort(deviceId, port) {
-        this.$logger.info("device: " + deviceId + " debug port: " + port + "\n");
+    printDebugPort(deviceId, port) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$logger.info("device: " + deviceId + " debug port: " + port + "\n");
+        });
     }
-    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.`);
-        }
+    // TODO: extract this logic outside the debug service
+    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 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);
+    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 #");
             }
-        }
-        if (debuggerStarted) {
-            this.$logger.info("# NativeScript Debugger started #");
-        }
-        else {
-            this.$logger.warn("# NativeScript Debugger did not start in time #");
-        }
+            else {
+                this.$logger.warn("# NativeScript Debugger did not start in time #");
+            }
+        });
     }
-    async isAppRunning(appIdentifier, deviceIdentifier) {
-        const debuggableApps = await this.$androidProcessService.getDebuggableApps(deviceIdentifier);
-        return !!_.find(debuggableApps, (a) => a.appIdentifier === appIdentifier);
+    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);
+        });
     }
 }
-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);
+//# sourceMappingURL=android-device-debug-service.js.map