@akylas/nativescript-cli 8.7.2

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

@@ -0,0 +1,81 @@
+"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");
+const _ = require("lodash");
+const helpers_1 = require("../../common/helpers");
+const yok_1 = require("../../common/yok");
+class AndroidBundleToolService {
+    constructor($childProcess, $sysInfo, $errors) {
+        this.$childProcess = $childProcess;
+        this.$sysInfo = $sysInfo;
+        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}`);
+            }
+        });
+    }
+    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}`);
+            }
+        });
+    }
+    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;
+        });
+    }
+    getJavaPath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.javaPath) {
+                this.javaPath = yield this.$sysInfo.getJavaPath();
+            }
+            return this.javaPath;
+        });
+    }
+}
+exports.AndroidBundleToolService = AndroidBundleToolService;
+yok_1.injector.register("androidBundleToolService", AndroidBundleToolService);

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

@@ -0,0 +1,87 @@
+"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");
+const constants_1 = require("../../common/constants");
+const yok_1 = require("../../common/yok");
+class GradleBuildArgsService {
+    constructor($androidToolsInfo, $hooksService, $analyticsService, $staticConfig, $projectData, $logger) {
+        this.$androidToolsInfo = $androidToolsInfo;
+        this.$hooksService = $hooksService;
+        this.$analyticsService = $analyticsService;
+        this.$staticConfig = $staticConfig;
+        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;
+        });
+    }
+    getCleanTaskArgs(buildData) {
+        const args = this.getBaseTaskArgs(buildData);
+        args.unshift("clean");
+        return args;
+    }
+    getBaseTaskArgs(buildData) {
+        const args = this.getBuildLoggingArgs();
+        const toolsInfo = this.$androidToolsInfo.getToolsInfo({
+            projectDir: buildData.projectDir,
+        });
+        this.$projectData.initializeProjectData(buildData.projectDir);
+        args.push(`--stacktrace`, `-PcompileSdk=android-${toolsInfo.compileSdkVersion}`, `-PtargetSdk=${toolsInfo.targetSdkVersion}`, `-PbuildToolsVersion=${toolsInfo.buildToolsVersion}`, `-PgenerateTypings=${toolsInfo.generateTypings}`, `-PprojectRoot=${this.$projectData.projectDir}`, `-DprojectRoot=${this.$projectData.projectDir}`, `-PappPath=${this.$projectData.getAppDirectoryPath()}`, `-PappBuildPath=${this.$projectData.getBuildRelativeDirectoryPath()}`, `-DappBuildPath=${this.$projectData.getBuildRelativeDirectoryPath()}`, `-PappPath=${this.$projectData.getAppDirectoryPath()}`, `-PappResourcesPath=${this.$projectData.getAppResourcesDirectoryPath()}`);
+        if (buildData.gradleArgs) {
+            const additionalArgs = [];
+            buildData.gradleArgs.forEach((arg) => {
+                additionalArgs.push(...arg.split(" ").map((a) => a.trim()));
+            });
+            args.push(...additionalArgs);
+        }
+        if (buildData.release) {
+            args.push("-Prelease", `-PksPath=${path.resolve(buildData.keyStorePath)}`, `-Palias=${buildData.keyStoreAlias}`, `-Ppassword=${buildData.keyStoreAliasPassword}`, `-PksPassword=${buildData.keyStorePassword}`);
+        }
+        return args;
+    }
+    getBuildLoggingArgs() {
+        const args = [];
+        const logLevel = this.$logger.getLevel();
+        if (logLevel === "TRACE") {
+            args.push("--debug");
+        }
+        else if (logLevel === "INFO") {
+            args.push("--quiet");
+        }
+        return args;
+    }
+    getBuildTaskName(buildData) {
+        let baseTaskName = buildData.androidBundle ? "bundle" : "assemble";
+        if (buildData.gradleFlavor) {
+            baseTaskName +=
+                buildData.gradleFlavor[0].toUpperCase() +
+                    buildData.gradleFlavor.slice(1);
+        }
+        const buildTaskName = buildData.release
+            ? `${baseTaskName}${constants_1.Configurations.Release}`
+            : `${baseTaskName}${constants_1.Configurations.Debug}`;
+        return buildTaskName;
+    }
+}
+exports.GradleBuildArgsService = GradleBuildArgsService;
+yok_1.injector.register("gradleBuildArgsService", GradleBuildArgsService);

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

@@ -0,0 +1,68 @@
+"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");
+const constants = require("../../constants");
+const events_1 = require("events");
+const yok_1 = require("../../common/yok");
+class GradleBuildService extends events_1.EventEmitter {
+    constructor($childProcess, $gradleBuildArgsService, $gradleCommandService, $devicesService) {
+        super();
+        this.$childProcess = $childProcess;
+        this.$gradleBuildArgsService = $gradleBuildArgsService;
+        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(",")}`);
+                }
+            }
+            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));
+        });
+    }
+    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);
+        });
+    }
+}
+exports.GradleBuildService = GradleBuildService;
+yok_1.injector.register("gradleBuildService", GradleBuildService);

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

@@ -0,0 +1,49 @@
+"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");
+class GradleCommandService {
+    constructor($childProcess, $errors, $hostInfo, $logger) {
+        this.$childProcess = $childProcess;
+        this.$errors = $errors;
+        this.$hostInfo = $hostInfo;
+        this.$logger = $logger;
+    }
+    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 result = yield this.executeCommandSafe(gradleExecutable, gradleArgs, 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);
+            }
+        });
+    }
+}
+exports.GradleCommandService = GradleCommandService;
+yok_1.injector.register("gradleCommandService", GradleCommandService);

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

@@ -0,0 +1,173 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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");
+const debug_service_base_1 = require("./debug-service-base");
+const constants_1 = require("../common/constants");
+const decorators_1 = require("../common/decorators");
+const yok_1 = require("../common/yok");
+const _ = require("lodash");
+class AndroidDeviceDebugService extends debug_service_base_1.DebugServiceBase {
+    get platform() {
+        return "android";
+    }
+    constructor(device, $devicesService, $cleanupService, $errors, $logger, $androidProcessService, $staticConfig, $net, $deviceLogProvider) {
+        super(device, $devicesService);
+        this.device = device;
+        this.$devicesService = $devicesService;
+        this.$cleanupService = $cleanupService;
+        this.$errors = $errors;
+        this.$logger = $logger;
+        this.$androidProcessService = $androidProcessService;
+        this.$staticConfig = $staticConfig;
+        this.$net = $net;
+        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();
+                }
+            }
+            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}`,
+            ]);
+        });
+    }
+    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;
+        });
+    }
+    unixSocketForward(local, remote) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield 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);
+            return result;
+        });
+    }
+    printDebugPort(deviceId, port) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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.`);
+            }
+        });
+    }
+    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 #");
+            }
+        });
+    }
+    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);
+        });
+    }
+}
+__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);