nativescript 9.1.0-alpha.16 → 9.1.0-alpha.17

package/lib/services/analytics/google-analytics-provider.d.ts

@@ -0,0 +1,22 @@
+import { IStaticConfig, IConfiguration } from "../../declarations";
+import { IAnalyticsSettingsService, IProxyService, Server } from "../../common/declarations";
+import { IGoogleAnalyticsProvider } from "./analytics";
+import { IGoogleAnalyticsData } from "../../common/definitions/google-analytics";
+export declare class GoogleAnalyticsProvider implements IGoogleAnalyticsProvider {
+    private clientId;
+    private $staticConfig;
+    private $analyticsSettingsService;
+    private $logger;
+    private $proxyService;
+    private $config;
+    private $httpClient;
+    private analyticsLoggingService;
+    private currentCommand;
+    constructor(clientId: string, $staticConfig: IStaticConfig, $analyticsSettingsService: IAnalyticsSettingsService, $logger: ILogger, $proxyService: IProxyService, $config: IConfiguration, $httpClient: Server.IHttpClient, analyticsLoggingService: IFileLogService);
+    trackHit(trackInfo: IGoogleAnalyticsData): Promise<void>;
+    private track;
+    private getEvent;
+    private getCustomDimensionParams;
+    private toEventName;
+    private truncate;
+}

package/lib/services/analytics/google-analytics-provider.js

@@ -1,35 +1,40 @@
 "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;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GoogleAnalyticsProvider = void 0;
 const uuid_1 = require("uuid");
-const ua = require("universal-analytics");
 const constants_1 = require("../../common/constants");
-const decorators_1 = require("../../common/decorators");
 const enums_1 = require("../../common/enums");
 const _ = require("lodash");
 const yok_1 = require("../../common/yok");
 const detached_process_enums_1 = require("../../detached-processes/detached-process-enums");
 const google_analytics_custom_dimensions_1 = require("../../common/services/analytics/google-analytics-custom-dimensions");
+const GA4_COLLECT_URL = "https://www.google-analytics.com/mp/collect";
+const MAX_EVENT_NAME_LENGTH = 40;
+const MAX_PARAM_VALUE_LENGTH = 100;
+const GA4_PARAM_NAMES = {
+    [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.cliVersion]: "cli_version",
+    [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.projectType]: "project_type",
+    [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.clientID]: "client_uuid",
+    [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.sessionID]: "session_id",
+    [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.client]: "client",
+    [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.nodeVersion]: "node_version",
+    [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.isShared]: "is_shared",
+};
 class GoogleAnalyticsProvider {
-    constructor(clientId, $staticConfig, $analyticsSettingsService, $logger, $proxyService, $config, analyticsLoggingService) {
+    constructor(clientId, $staticConfig, $analyticsSettingsService, $logger, $proxyService, $config, $httpClient, analyticsLoggingService) {
         this.clientId = clientId;
         this.$staticConfig = $staticConfig;
         this.$analyticsSettingsService = $analyticsSettingsService;
         this.$logger = $logger;
         this.$proxyService = $proxyService;
         this.$config = $config;
+        this.$httpClient = $httpClient;
         this.analyticsLoggingService = analyticsLoggingService;
     }
     async trackHit(trackInfo) {
         const sessionId = (0, uuid_1.v4)();
         try {
-            await this.track(this.$config.GA_TRACKING_ID, trackInfo, sessionId);
+            await this.track(trackInfo, sessionId);
         }
         catch (e) {
             this.analyticsLoggingService.logData({
@@ -39,41 +44,69 @@ class GoogleAnalyticsProvider {
             this.$logger.trace("Analytics exception: ", e);
         }
     }
-    getVisitor(gaTrackingId, proxy) {
+    async track(trackInfo, sessionId) {
+        const { GA_MEASUREMENT_ID, GA_API_SECRET } = this.$config;
+        if (!GA_MEASUREMENT_ID || !GA_API_SECRET) {
+            this.analyticsLoggingService.logData({
+                message: "Google Analytics is not configured (missing measurement id or api secret), skipping hit.",
+            });
+            return;
+        }
+        const event = this.getEvent(trackInfo, sessionId);
+        if (!event) {
+            return;
+        }
+        const proxySettings = await this.$proxyService.getCache();
+        const url = `${GA4_COLLECT_URL}?measurement_id=${encodeURIComponent(GA_MEASUREMENT_ID)}&api_secret=${encodeURIComponent(GA_API_SECRET)}`;
         this.analyticsLoggingService.logData({
-            message: `Initializing Google Analytics visitor for id: ${gaTrackingId} with clientId: ${this.clientId}.`,
+            message: `Sending Google Analytics event '${event.name}' for clientId: ${this.clientId}.`,
         });
-        const visitor = ua({
-            tid: gaTrackingId,
-            cid: this.clientId,
+        await this.$httpClient.httpRequest({
+            url,
+            method: "POST",
             headers: {
+                "Content-Type": "application/json",
                 ["User-Agent"]: this.$analyticsSettingsService.getUserAgentString(`tnsCli/${this.$staticConfig.version}`),
             },
-            requestOptions: {
-                proxy,
-            },
-            https: true,
-        });
+            body: JSON.stringify({
+                client_id: this.clientId,
+                non_personalized_ads: true,
+                events: [event],
+            }),
+        }, proxySettings);
         this.analyticsLoggingService.logData({
-            message: `Successfully initialized Google Analytics visitor for id: ${gaTrackingId} with clientId: ${this.clientId}.`,
+            message: `Tracked Google Analytics event '${event.name}'.`,
         });
-        return visitor;
     }
-    async track(gaTrackingId, trackInfo, sessionId) {
-        const proxySettings = await this.$proxyService.getCache();
-        const proxy = proxySettings && proxySettings.proxy;
-        const visitor = this.getVisitor(gaTrackingId, proxy);
-        await this.setCustomDimensions(visitor, trackInfo.customDimensions, sessionId);
+    getEvent(trackInfo, sessionId) {
+        const params = this.getCustomDimensionParams(trackInfo.customDimensions, sessionId);
         switch (trackInfo.googleAnalyticsDataType) {
-            case enums_1.GoogleAnalyticsDataType.Page:
-                await this.trackPageView(visitor, trackInfo);
-                break;
-            case enums_1.GoogleAnalyticsDataType.Event:
-                await this.trackEvent(visitor, trackInfo);
-                break;
+            case enums_1.GoogleAnalyticsDataType.Page: {
+                const pageviewData = trackInfo;
+                this.currentCommand = pageviewData.path;
+                return {
+                    name: "command",
+                    params: _.assign(params, {
+                        command_name: this.truncate(pageviewData.path),
+                    }),
+                };
+            }
+            case enums_1.GoogleAnalyticsDataType.Event: {
+                const eventData = trackInfo;
+                return {
+                    name: this.toEventName(eventData.action),
+                    params: _.omitBy(_.assign(params, {
+                        event_category: this.truncate(eventData.category),
+                        event_label: this.truncate(eventData.label),
+                        value: eventData.value,
+                        command_name: this.truncate(this.currentCommand),
+                    }), _.isNil),
+                };
+            }
         }
+        return null;
     }
-    async setCustomDimensions(visitor, customDimensions, sessionId) {
+    getCustomDimensionParams(customDimensions, sessionId) {
         const defaultValues = {
             [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.cliVersion]: this.$staticConfig.version,
             [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.nodeVersion]: process.version,
@@ -83,59 +116,27 @@ class GoogleAnalyticsProvider {
             [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.sessionID]: sessionId,
             [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.client]: constants_1.AnalyticsClients.Unknown,
         };
-        customDimensions = _.merge(defaultValues, customDimensions);
-        _.each(customDimensions, (value, key) => {
-            this.analyticsLoggingService.logData({
-                message: `Setting custom dimension ${key} to value ${value}`,
-            });
-            visitor.set(key, value);
+        const params = {
+            engagement_time_msec: 1,
+        };
+        _.each(_.merge(defaultValues, customDimensions), (value, key) => {
+            if (_.isNil(value)) {
+                return;
+            }
+            params[GA4_PARAM_NAMES[key] || key] = this.truncate(value);
         });
+        return params;
     }
-    trackEvent(visitor, trackInfo) {
-        return new Promise((resolve, reject) => {
-            visitor.event(trackInfo.category, trackInfo.action, trackInfo.label, trackInfo.value, { p: this.currentPage }, (err) => {
-                if (err) {
-                    this.analyticsLoggingService.logData({
-                        message: `Unable to track event with category: '${trackInfo.category}', action: '${trackInfo.action}', label: '${trackInfo.label}', ` +
-                            `value: '${trackInfo.value}' attached page: ${this.currentPage}. Error is: ${err}.`,
-                        type: detached_process_enums_1.FileLogMessageType.Error,
-                    });
-                    reject(err);
-                    return;
-                }
-                this.analyticsLoggingService.logData({
-                    message: `Tracked event with category: '${trackInfo.category}', action: '${trackInfo.action}', label: '${trackInfo.label}', value: '${trackInfo.value}' attached page: ${this.currentPage}.`,
-                });
-                resolve();
-            });
-        });
+    toEventName(action) {
+        const name = (action || "")
+            .replace(/[^A-Za-z0-9_]/g, "_")
+            .replace(/^[^A-Za-z]+/, "")
+            .slice(0, MAX_EVENT_NAME_LENGTH);
+        return name || "cli_event";
     }
-    trackPageView(visitor, trackInfo) {
-        return new Promise((resolve, reject) => {
-            this.currentPage = trackInfo.path;
-            const pageViewData = {
-                dp: trackInfo.path,
-                dt: trackInfo.title,
-            };
-            visitor.pageview(pageViewData, (err) => {
-                if (err) {
-                    this.analyticsLoggingService.logData({
-                        message: `Unable to track pageview with path '${trackInfo.path}' and title: '${trackInfo.title}' Error is: ${err}.`,
-                        type: detached_process_enums_1.FileLogMessageType.Error,
-                    });
-                    reject(err);
-                    return;
-                }
-                this.analyticsLoggingService.logData({
-                    message: `Tracked pageview with path '${trackInfo.path}' and title: '${trackInfo.title}'.`,
-                });
-                resolve();
-            });
-        });
+    truncate(value) {
+        return _.isNil(value) ? value : `${value}`.slice(0, MAX_PARAM_VALUE_LENGTH);
     }
 }
 exports.GoogleAnalyticsProvider = GoogleAnalyticsProvider;
-__decorate([
-    (0, decorators_1.cache)()
-], GoogleAnalyticsProvider.prototype, "getVisitor", null);
 yok_1.injector.register("googleAnalyticsProvider", GoogleAnalyticsProvider);

package/lib/services/analytics-settings-service.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/services/android/android-bundle-tool-service.d.ts

@@ -0,0 +1,27 @@
+import { IChildProcess, IErrors, IFileSystem, ISettingsService, ISysInfo, Server } from "../../common/declarations";
+import { IAndroidBundleToolService, IBuildApksOptions, IInstallApksOptions } from "../../definitions/android-bundle-tool-service";
+import { ITerminalSpinnerService } from "../../definitions/terminal-spinner-service";
+export declare class AndroidBundleToolService implements IAndroidBundleToolService {
+    private $childProcess;
+    private $sysInfo;
+    private $errors;
+    private $fs;
+    private $httpClient;
+    private $lockService;
+    private $logger;
+    private $settingsService;
+    private $terminalSpinnerService;
+    private static LOCK_OPTIONS;
+    private javaPath;
+    private bundleToolPathPromise;
+    constructor($childProcess: IChildProcess, $sysInfo: ISysInfo, $errors: IErrors, $fs: IFileSystem, $httpClient: Server.IHttpClient, $lockService: ILockService, $logger: ILogger, $settingsService: ISettingsService, $terminalSpinnerService: ITerminalSpinnerService);
+    buildApks(options: IBuildApksOptions): Promise<void>;
+    installApks(options: IInstallApksOptions): Promise<void>;
+    private execBundleTool;
+    private getJavaPath;
+    private getBundleToolPath;
+    private resolveBundleToolPath;
+    private isExpectedJar;
+    private downloadBundleTool;
+    private formatProgress;
+}

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

@@ -4,13 +4,19 @@ exports.AndroidBundleToolService = void 0;
 const path_1 = require("path");
 const _ = require("lodash");
 const helpers_1 = require("../../common/helpers");
+const constants_1 = require("../../constants");
 const yok_1 = require("../../common/yok");
 class AndroidBundleToolService {
-    constructor($childProcess, $sysInfo, $errors) {
+    constructor($childProcess, $sysInfo, $errors, $fs, $httpClient, $lockService, $logger, $settingsService, $terminalSpinnerService) {
         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"));
+        this.$fs = $fs;
+        this.$httpClient = $httpClient;
+        this.$lockService = $lockService;
+        this.$logger = $logger;
+        this.$settingsService = $settingsService;
+        this.$terminalSpinnerService = $terminalSpinnerService;
     }
     async buildApks(options) {
         if (!(0, helpers_1.hasValidAndroidSigning)(options.signingData)) {
@@ -49,7 +55,7 @@ class AndroidBundleToolService {
     }
     async execBundleTool(args) {
         const javaPath = await this.getJavaPath();
-        const defaultArgs = ["-jar", this.aabToolPath];
+        const defaultArgs = ["-jar", await this.getBundleToolPath()];
         const result = await this.$childProcess.trySpawnFromCloseEvent(javaPath, _.concat(defaultArgs, args));
         return result;
     }
@@ -59,6 +65,99 @@ class AndroidBundleToolService {
         }
         return this.javaPath;
     }
+    getBundleToolPath() {
+        this.bundleToolPathPromise =
+            this.bundleToolPathPromise || this.resolveBundleToolPath();
+        return this.bundleToolPathPromise;
+    }
+    async resolveBundleToolPath() {
+        const customPath = process.env[constants_1.BUNDLETOOL_PATH_ENV_VAR];
+        if (customPath) {
+            if (!this.$fs.exists(customPath)) {
+                this.$errors.fail(`${constants_1.BUNDLETOOL_PATH_ENV_VAR} is set to "${customPath}", but no file exists there.`);
+            }
+            this.$logger.trace(`Using bundletool from ${constants_1.BUNDLETOOL_PATH_ENV_VAR}: ${customPath}`);
+            return customPath;
+        }
+        const cacheDir = (0, path_1.join)(this.$settingsService.getProfileDir(), constants_1.BUNDLETOOL_CACHE_DIRNAME);
+        const jarPath = (0, path_1.join)(cacheDir, `bundletool-all-${constants_1.BUNDLETOOL_VERSION}.jar`);
+        this.$fs.ensureDirectoryExists(cacheDir);
+        if (await this.isExpectedJar(jarPath)) {
+            return jarPath;
+        }
+        return this.$lockService.executeActionWithLock(async () => {
+            if (await this.isExpectedJar(jarPath)) {
+                return jarPath;
+            }
+            await this.downloadBundleTool(jarPath);
+            return jarPath;
+        }, (0, path_1.join)(cacheDir, `bundletool-${constants_1.BUNDLETOOL_VERSION}.lock`), AndroidBundleToolService.LOCK_OPTIONS);
+    }
+    async isExpectedJar(jarPath) {
+        if (!this.$fs.exists(jarPath)) {
+            return false;
+        }
+        const shasum = await this.$fs.getFileShasum(jarPath, {
+            algorithm: "sha256",
+        });
+        if (shasum === constants_1.BUNDLETOOL_SHA256) {
+            return true;
+        }
+        this.$logger.warn(`Cached bundletool at "${jarPath}" does not match the expected checksum and will be downloaded again.`);
+        this.$fs.deleteFile(jarPath);
+        return false;
+    }
+    async downloadBundleTool(jarPath) {
+        const jarName = `bundletool-all-${constants_1.BUNDLETOOL_VERSION}.jar`;
+        const url = `${constants_1.BUNDLETOOL_RELEASES_URL}/${constants_1.BUNDLETOOL_VERSION}/${jarName}`;
+        const tempPath = `${jarPath}.download`;
+        const spinner = this.$terminalSpinnerService.createSpinner();
+        spinner.start(`Downloading bundletool ${constants_1.BUNDLETOOL_VERSION}`);
+        try {
+            await this.$httpClient.httpRequest({
+                url,
+                method: "GET",
+                headers: { "Accept-Encoding": "identity" },
+                pipeTo: this.$fs.createWriteStream(tempPath),
+                onDownloadProgress: (progress) => {
+                    spinner.text = `Downloading bundletool ${constants_1.BUNDLETOOL_VERSION} ${this.formatProgress(progress)}`;
+                },
+            });
+        }
+        catch (err) {
+            spinner.fail(`Failed to download bundletool ${constants_1.BUNDLETOOL_VERSION}`);
+            this.$fs.deleteFile(tempPath);
+            this.$errors.fail(`Unable to download bundletool from "${url}". ` +
+                `Set ${constants_1.BUNDLETOOL_PATH_ENV_VAR} to the path of a local bundletool jar to skip the download. ` +
+                `Error: ${err.message}`);
+        }
+        const shasum = await this.$fs.getFileShasum(tempPath, {
+            algorithm: "sha256",
+        });
+        if (shasum !== constants_1.BUNDLETOOL_SHA256) {
+            spinner.fail(`Failed to download bundletool ${constants_1.BUNDLETOOL_VERSION}`);
+            this.$fs.deleteFile(tempPath);
+            this.$errors.fail(`Checksum mismatch for bundletool downloaded from "${url}". ` +
+                `Expected ${constants_1.BUNDLETOOL_SHA256}, got ${shasum}.`);
+        }
+        this.$fs.rename(tempPath, jarPath);
+        spinner.succeed(`Downloaded bundletool ${constants_1.BUNDLETOOL_VERSION}`);
+    }
+    formatProgress(progress) {
+        const toMb = (bytes) => (bytes / 1024 / 1024).toFixed(1);
+        return progress.total
+            ? `${toMb(progress.loaded)}/${toMb(progress.total)} MB`
+            : `${toMb(progress.loaded)} MB`;
+    }
 }
 exports.AndroidBundleToolService = AndroidBundleToolService;
+AndroidBundleToolService.LOCK_OPTIONS = {
+    stale: 5 * 60 * 1000,
+    retriesObj: {
+        retries: 300,
+        minTimeout: 200,
+        maxTimeout: 2000,
+        factor: 1.5,
+    },
+};
 yok_1.injector.register("androidBundleToolService", AndroidBundleToolService);

package/lib/services/android/gradle-build-args-service.d.ts

@@ -0,0 +1,17 @@
+import { IGradleBuildArgsService } from "../../definitions/gradle";
+import { IAndroidBuildData } from "../../definitions/build";
+import { IHooksService, IAnalyticsService } from "../../common/declarations";
+import { IProjectData } from "../../definitions/project";
+export declare class GradleBuildArgsService implements IGradleBuildArgsService {
+    private $hooksService;
+    private $analyticsService;
+    private $staticConfig;
+    private $projectData;
+    private $logger;
+    constructor($hooksService: IHooksService, $analyticsService: IAnalyticsService, $staticConfig: Config.IStaticConfig, $projectData: IProjectData, $logger: ILogger);
+    getBuildTaskArgs(buildData: IAndroidBuildData): Promise<string[]>;
+    getCleanTaskArgs(buildData: IAndroidBuildData): string[];
+    private getBaseTaskArgs;
+    private getBuildLoggingArgs;
+    private getBuildTaskName;
+}

package/lib/services/android/gradle-build-service.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from "events";
+import { IGradleBuildService, IGradleBuildArgsService, IGradleCommandService } from "../../definitions/gradle";
+import { IAndroidBuildData } from "../../definitions/build";
+import { IChildProcess } from "../../common/declarations";
+export declare class GradleBuildService extends EventEmitter implements IGradleBuildService {
+    private $childProcess;
+    private $gradleBuildArgsService;
+    private $gradleCommandService;
+    constructor($childProcess: IChildProcess, $gradleBuildArgsService: IGradleBuildArgsService, $gradleCommandService: IGradleCommandService);
+    buildProject(projectRoot: string, buildData: IAndroidBuildData): Promise<void>;
+    cleanProject(projectRoot: string, buildData: IAndroidBuildData): Promise<void>;
+}

package/lib/services/android/gradle-command-service.d.ts

@@ -0,0 +1,11 @@
+import { IChildProcess, IErrors, IHostInfo, ISpawnResult } from "../../common/declarations";
+import { IGradleCommandService, IGradleCommandOptions } from "../../definitions/gradle";
+export declare class GradleCommandService implements IGradleCommandService {
+    private $childProcess;
+    private $errors;
+    private $hostInfo;
+    private $logger;
+    constructor($childProcess: IChildProcess, $errors: IErrors, $hostInfo: IHostInfo, $logger: ILogger);
+    executeCommand(gradleArgs: string[], options: IGradleCommandOptions): Promise<ISpawnResult>;
+    private executeCommandSafe;
+}

package/lib/services/android-device-debug-service.d.ts

@@ -0,0 +1,30 @@
+import { DebugServiceBase } from "./debug-service-base";
+import { IDeviceDebugService, IDebugData, IDebugOptions, IDebugResultInfo } from "../definitions/debug";
+import { IStaticConfig } from "../declarations";
+import { IErrors, INet } from "../common/declarations";
+import { ICleanupService } from "../definitions/cleanup-service";
+export declare class AndroidDeviceDebugService extends DebugServiceBase implements IDeviceDebugService {
+    protected device: Mobile.IAndroidDevice;
+    protected $devicesService: Mobile.IDevicesService;
+    protected $cleanupService: ICleanupService;
+    private $errors;
+    private $logger;
+    private $androidProcessService;
+    private $staticConfig;
+    private $net;
+    private $deviceLogProvider;
+    private _packageName;
+    private deviceIdentifier;
+    get platform(): string;
+    constructor(device: Mobile.IAndroidDevice, $devicesService: Mobile.IDevicesService, $cleanupService: ICleanupService, $errors: IErrors, $logger: ILogger, $androidProcessService: Mobile.IAndroidProcessService, $staticConfig: IStaticConfig, $net: INet, $deviceLogProvider: Mobile.IDeviceLogProvider);
+    debug(debugData: IDebugData, debugOptions: IDebugOptions): Promise<IDebugResultInfo>;
+    debugStop(): Promise<void>;
+    private removePortForwarding;
+    private getForwardedDebugPort;
+    private unixSocketForward;
+    private debugCore;
+    private printDebugPort;
+    private validateRunningApp;
+    private waitForDebugServer;
+    private isAppRunning;
+}

package/lib/services/android-plugin-build-service.d.ts

@@ -0,0 +1,55 @@
+import { INodePackageManager, IWatchIgnoreListService, IOptions } from "../declarations";
+import { IProjectData, IProjectDataService } from "../definitions/project";
+import { IAndroidPluginBuildService, IPluginBuildOptions } from "../definitions/android-plugin-migrator";
+import { IFileSystem, IChildProcess, IHostInfo, IErrors, IHooksService } from "../common/declarations";
+import { IFilesHashService } from "../definitions/files-hash-service";
+import { IInjector } from "../common/definitions/yok";
+export declare class AndroidPluginBuildService implements IAndroidPluginBuildService {
+    private $fs;
+    private $childProcess;
+    private $hostInfo;
+    private $options;
+    private $logger;
+    private $packageManager;
+    private $projectData;
+    private $projectDataService;
+    private $devicePlatformsConstants;
+    private $errors;
+    private $filesHashService;
+    $hooksService: IHooksService;
+    private $injector;
+    private $watchIgnoreListService;
+    private get $platformsDataService();
+    constructor($fs: IFileSystem, $childProcess: IChildProcess, $hostInfo: IHostInfo, $options: IOptions, $logger: ILogger, $packageManager: INodePackageManager, $projectData: IProjectData, $projectDataService: IProjectDataService, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $errors: IErrors, $filesHashService: IFilesHashService, $hooksService: IHooksService, $injector: IInjector, $watchIgnoreListService: IWatchIgnoreListService);
+    private static MANIFEST_ROOT;
+    private getAndroidSourceDirectories;
+    private getManifest;
+    private updateManifestContent;
+    private createManifestContent;
+    private getXml;
+    private getIncludeGradleCompileDependenciesScope;
+    private getScope;
+    buildAar(options: IPluginBuildOptions): Promise<boolean>;
+    private cleanPluginDir;
+    private getSourceFilesHashes;
+    private writePluginHashInfo;
+    private shouldBuildAar;
+    private getPathToPluginBuildDataFile;
+    private updateManifest;
+    private copySourceSetDirectories;
+    private setupGradle;
+    private getRuntimeGradleVersions;
+    private getLatestRuntimeVersion;
+    private getLocalGradleVersions;
+    private getGradleVersions;
+    private getGradleVersionsCore;
+    private replaceGradleVersion;
+    private replaceGradleAndroidPluginVersion;
+    private replaceFileContent;
+    private addCompileDependencies;
+    private copyAar;
+    migrateIncludeGradle(options: IPluginBuildOptions): boolean;
+    private buildPlugin;
+    private validateOptions;
+    private validatePlatformsAndroidDirPathOption;
+}

package/lib/services/android-project-service.d.ts

@@ -0,0 +1,75 @@
+import * as semver from "semver";
+import * as projectServiceBaseLib from "./platform-project-service-base";
+import { IProjectData, IProjectDataService, IValidatePlatformOutput } from "../definitions/project";
+import { IPlatformData, IPlatformEnvironmentRequirements } from "../definitions/platform";
+import { IAndroidToolsInfo, IAndroidResourcesMigrationService, IOptions, IDependencyData } from "../declarations";
+import { IAndroidBuildData } from "../definitions/build";
+import { IPluginData } from "../definitions/plugins";
+import { IErrors, IFileSystem, IAnalyticsService, IRelease, ISpawnResult } from "../common/declarations";
+import { IAndroidPluginBuildService } from "../definitions/android-plugin-migrator";
+import { IFilesHashService } from "../definitions/files-hash-service";
+import { IGradleCommandService, IGradleBuildService } from "../definitions/gradle";
+import { IInjector } from "../common/definitions/yok";
+import { INotConfiguredEnvOptions } from "../common/definitions/commands";
+export declare class AndroidProjectService extends projectServiceBaseLib.PlatformProjectServiceBase {
+    private $androidToolsInfo;
+    private $errors;
+    private $logger;
+    private $options;
+    private $injector;
+    private $devicePlatformsConstants;
+    private $androidPluginBuildService;
+    private $platformEnvironmentRequirements;
+    private $androidResourcesMigrationService;
+    private $filesHashService;
+    private $gradleCommandService;
+    private $gradleBuildService;
+    private $analyticsService;
+    private static VALUES_DIRNAME;
+    private static VALUES_VERSION_DIRNAME_PREFIX;
+    private static ANDROID_PLATFORM_NAME;
+    private static MIN_RUNTIME_VERSION_WITH_GRADLE;
+    constructor($androidToolsInfo: IAndroidToolsInfo, $errors: IErrors, $fs: IFileSystem, $logger: ILogger, $projectDataService: IProjectDataService, $options: IOptions, $injector: IInjector, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants, $androidPluginBuildService: IAndroidPluginBuildService, $platformEnvironmentRequirements: IPlatformEnvironmentRequirements, $androidResourcesMigrationService: IAndroidResourcesMigrationService, $filesHashService: IFilesHashService, $gradleCommandService: IGradleCommandService, $gradleBuildService: IGradleBuildService, $analyticsService: IAnalyticsService);
+    private _platformData;
+    getPlatformData(projectData: IProjectData): IPlatformData;
+    getCurrentPlatformVersion(platformData: IPlatformData, projectData: IProjectData): string;
+    validateOptions(): Promise<boolean>;
+    getAppResourcesDestinationDirectoryPath(projectData: IProjectData): string;
+    validate(projectData: IProjectData, options: IOptions, notConfiguredEnvOptions?: INotConfiguredEnvOptions): Promise<IValidatePlatformOutput>;
+    createProject(frameworkDir: string, frameworkVersion: string, projectData: IProjectData): Promise<void>;
+    private getResDestinationDir;
+    private cleanResValues;
+    interpolateData(projectData: IProjectData): Promise<void>;
+    interpolateConfigurationFile(projectData: IProjectData): void;
+    private getProjectNameFromId;
+    afterCreateProject(projectRoot: string): void;
+    updatePlatform(currentVersion: string, newVersion: string, canUpdate: boolean, projectData: IProjectData, addPlatform?: Function, removePlatforms?: (platforms: string[]) => Promise<void>): Promise<boolean>;
+    buildProject(projectRoot: string, projectData: IProjectData, buildData: IAndroidBuildData): Promise<void>;
+    buildForDeploy(projectRoot: string, projectData: IProjectData, buildData?: IAndroidBuildData): Promise<void>;
+    isPlatformPrepared(projectRoot: string, projectData: IProjectData): boolean;
+    getFrameworkFilesExtensions(): string[];
+    prepareProject(): Promise<void>;
+    ensureConfigurationFileInAppResources(projectData: IProjectData): void;
+    prepareAppResources(projectData: IProjectData): void;
+    preparePluginNativeCode(pluginData: IPluginData, projectData: IProjectData): Promise<void>;
+    processConfigurationFilesFromAppResources(): Promise<void>;
+    removePluginNativeCode(pluginData: IPluginData, projectData: IProjectData): Promise<void>;
+    beforePrepareAllPlugins(projectData: IProjectData, dependencies?: IDependencyData[]): Promise<IDependencyData[]>;
+    handleNativeDependenciesChange(projectData: IProjectData, opts: IRelease): Promise<void>;
+    private filterUniqueDependencies;
+    private provideDependenciesJson;
+    private static isNativeAndroidDependency;
+    stopServices(projectRoot: string): Promise<ISpawnResult>;
+    cleanProject(projectRoot: string): Promise<void>;
+    cleanDeviceTempFolder(deviceIdentifier: string, projectData: IProjectData): Promise<void>;
+    checkForChanges(): Promise<void>;
+    getDeploymentTarget(projectData: IProjectData): semver.SemVer;
+    private copy;
+    private validatePackageName;
+    private validateProjectName;
+    private getLegacyAppResourcesDestinationDirPath;
+    private getUpdatedAppResourcesDestinationDirPath;
+    private cleanUpPreparedResources;
+    private trackKotlinUsage;
+    private tryGetAndroidBuildStatistics;
+}

package/lib/services/android-resources-migration-service.d.ts

@@ -0,0 +1,17 @@
+import { IAndroidResourcesMigrationService } from "../declarations";
+import { IFileSystem, IErrors } from "../common/declarations";
+export declare class AndroidResourcesMigrationService implements IAndroidResourcesMigrationService {
+    private $fs;
+    private $errors;
+    private $logger;
+    private $devicePlatformsConstants;
+    private static ANDROID_DIR;
+    private static ANDROID_DIR_TEMP;
+    private static ANDROID_DIR_OLD;
+    constructor($fs: IFileSystem, $errors: IErrors, $logger: ILogger, $devicePlatformsConstants: Mobile.IDevicePlatformsConstants);
+    canMigrate(platformString: string): boolean;
+    hasMigrated(appResourcesDir: string): boolean;
+    migrate(appResourcesDir: string, backupLocation?: string): Promise<void>;
+    private tryMigrate;
+    private recover;
+}

package/lib/services/apple-portal/apple-portal-application-service.d.ts

@@ -0,0 +1,12 @@
+import { IErrors, Server } from "../../common/declarations";
+import { IApplePortalUserDetail, IApplePortalSessionService, IApplePortalApplicationService, IApplePortalApplicationSummary, IApplePortalApplication } from "./definitions";
+export declare class ApplePortalApplicationService implements IApplePortalApplicationService {
+    private $applePortalSessionService;
+    private $errors;
+    private $httpClient;
+    constructor($applePortalSessionService: IApplePortalSessionService, $errors: IErrors, $httpClient: Server.IHttpClient);
+    getApplications(user: IApplePortalUserDetail): Promise<IApplePortalApplicationSummary[]>;
+    getApplicationsByProvider(contentProviderId: number): Promise<IApplePortalApplication>;
+    private getApplicationsByUrl;
+    getApplicationByBundleId(user: IApplePortalUserDetail, bundleId: string): Promise<IApplePortalApplicationSummary>;
+}