nativescript 9.1.0-alpha.15 → 9.1.0-alpha.17

package/lib/services/analytics/analytics-service.js

@@ -12,7 +12,11 @@ const _ = require("lodash");
 const decorators_1 = require("../../common/decorators");
 const helpers_1 = require("../../common/helpers");
 const constants_1 = require("../../common/constants");
+const constants_2 = require("../../constants");
+const enums_1 = require("../../common/enums");
 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");
 class AnalyticsService {
     constructor($logger, $options, $staticConfig, $prompter, $userSettingsService, $analyticsSettingsService, $childProcess, $projectDataService, $mobileHelper, $projectHelper) {
         this.$logger = $logger;
@@ -34,7 +38,7 @@ class AnalyticsService {
     async checkConsent() {
         if (await this.$analyticsSettingsService.canDoRequest()) {
             const initialTrackFeatureUsageStatus = await this.getStatus(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME);
-            let trackFeatureUsage = initialTrackFeatureUsageStatus === "enabled" /* AnalyticsStatus.enabled */;
+            let trackFeatureUsage = initialTrackFeatureUsageStatus === enums_1.AnalyticsStatus.enabled;
             if ((await this.isNotConfirmed(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME)) &&
                 (0, helpers_1.isInteractive)()) {
                 const message = `Do you want to help us improve ${this.$analyticsSettingsService.getClientName()} by automatically sending anonymous usage statistics? We will not use this information to identify or contact you.`;
@@ -53,13 +57,13 @@ class AnalyticsService {
     }
     async setStatus(settingName, enabled) {
         this.analyticsStatuses[settingName] = enabled
-            ? "enabled" /* AnalyticsStatus.enabled */
-            : "disabled" /* AnalyticsStatus.disabled */;
+            ? enums_1.AnalyticsStatus.enabled
+            : enums_1.AnalyticsStatus.disabled;
         await this.$userSettingsService.saveSetting(settingName, enabled.toString());
     }
     async isEnabled(settingName) {
         const analyticsStatus = await this.getStatus(settingName);
-        return analyticsStatus === "enabled" /* AnalyticsStatus.enabled */;
+        return analyticsStatus === enums_1.AnalyticsStatus.enabled;
     }
     getStatusMessage(settingName, jsonFormat, readableSettingName) {
         if (jsonFormat) {
@@ -70,8 +74,8 @@ class AnalyticsService {
     async trackAcceptFeatureUsage(settings) {
         const acceptTracking = !!(settings && settings.acceptTrackFeatureUsage);
         const googleAnalyticsEventData = {
-            googleAnalyticsDataType: "event" /* GoogleAnalyticsDataType.Event */,
-            action: "Accept Tracking" /* TrackActionNames.AcceptTracking */,
+            googleAnalyticsDataType: enums_1.GoogleAnalyticsDataType.Event,
+            action: constants_2.TrackActionNames.AcceptTracking,
             label: acceptTracking.toString(),
         };
         await this.forcefullyTrackInGoogleAnalytics(googleAnalyticsEventData);
@@ -79,7 +83,7 @@ class AnalyticsService {
     async trackInGoogleAnalytics(gaSettings) {
         await this.initAnalyticsStatuses();
         if (!this.$staticConfig.disableAnalytics &&
-            this.analyticsStatuses[this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME] === "enabled" /* AnalyticsStatus.enabled */) {
+            this.analyticsStatuses[this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME] === enums_1.AnalyticsStatus.enabled) {
             return this.forcefullyTrackInGoogleAnalytics(gaSettings);
         }
     }
@@ -92,8 +96,6 @@ class AnalyticsService {
         const isForDevice = device ? !device.isEmulator : data.isForDevice;
         let label = "";
         label = this.addDataToLabel(label, normalizedPlatform);
-        // In some cases (like in case action is Build and platform is Android), we do not know if the deviceType is emulator or device.
-        // Just exclude the device_type in this case.
         if (isForDevice !== null && isForDevice !== undefined) {
             const deviceType = isForDevice
                 ? constants_1.DeviceTypes.Device
@@ -111,7 +113,7 @@ class AnalyticsService {
         const customDimensions = {};
         this.setProjectRelatedCustomDimensions(customDimensions, data.projectDir);
         const googleAnalyticsEventData = {
-            googleAnalyticsDataType: "event" /* GoogleAnalyticsDataType.Event */,
+            googleAnalyticsDataType: enums_1.GoogleAnalyticsDataType.Event,
             action: data.action,
             label,
             customDimensions,
@@ -124,7 +126,7 @@ class AnalyticsService {
             if (this.brokerProcess && this.brokerProcess.connected) {
                 let timer;
                 const handler = (data) => {
-                    if (data === "ProcessFinishedTasks" /* DetachedProcessMessages.ProcessFinishedTasks */) {
+                    if (data === detached_process_enums_1.DetachedProcessMessages.ProcessFinishedTasks) {
                         this.brokerProcess.removeListener("message", handler);
                         clearTimeout(timer);
                         resolve();
@@ -135,7 +137,7 @@ class AnalyticsService {
                     resolve();
                 }, 3000);
                 this.brokerProcess.on("message", handler);
-                const msg = { type: "FinishTracking" /* TrackingTypes.FinishTracking */ };
+                const msg = { type: enums_1.TrackingTypes.FinishTracking };
                 this.brokerProcess.send(msg, (err) => this.$logger.trace(`Error while sending ${JSON.stringify(msg)}`));
             }
             else {
@@ -145,13 +147,13 @@ class AnalyticsService {
     }
     forcefullyTrackInGoogleAnalytics(gaSettings) {
         gaSettings.customDimensions = gaSettings.customDimensions || {};
-        gaSettings.customDimensions["cd5" /* GoogleAnalyticsCustomDimensions.client */] =
+        gaSettings.customDimensions[google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.client] =
             this.$options.analyticsClient ||
-                ((0, helpers_1.isInteractive)() ? "CLI" /* AnalyticsClients.Cli */ : "Unknown" /* AnalyticsClients.Unknown */);
+                ((0, helpers_1.isInteractive)() ? constants_1.AnalyticsClients.Cli : constants_1.AnalyticsClients.Unknown);
         this.setProjectRelatedCustomDimensions(gaSettings.customDimensions);
         const googleAnalyticsData = _.merge({
-            type: "googleAnalyticsData" /* TrackingTypes.GoogleAnalyticsData */,
-            category: "CLI" /* AnalyticsClients.Cli */,
+            type: enums_1.TrackingTypes.GoogleAnalyticsData,
+            category: constants_1.AnalyticsClients.Cli,
         }, gaSettings);
         this.$logger.trace("Will send the following information to Google Analytics:", googleAnalyticsData);
         return this.sendMessageToBroker(googleAnalyticsData);
@@ -162,15 +164,14 @@ class AnalyticsService {
                 projectDir = this.$projectHelper.projectDir;
             }
             catch (err) {
-                // In case there's no project dir here, the above getter will fail.
                 this.$logger.trace("Unable to get the projectDir from projectHelper", err);
             }
         }
         if (projectDir) {
             const projectData = this.$projectDataService.getProjectData(projectDir);
-            customDimensions["cd2" /* GoogleAnalyticsCustomDimensions.projectType */] =
+            customDimensions[google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.projectType] =
                 projectData.projectType;
-            customDimensions["cd9" /* GoogleAnalyticsCustomDimensions.isShared */] =
+            customDimensions[google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.isShared] =
                 projectData.isShared.toString();
         }
         return customDimensions;
@@ -208,7 +209,7 @@ class AnalyticsService {
                 }
             });
             broker.on("message", (data) => {
-                if (data === "ProcessReadyToReceive" /* DetachedProcessMessages.ProcessReadyToReceive */) {
+                if (data === detached_process_enums_1.DetachedProcessMessages.ProcessReadyToReceive) {
                     clearTimeout(timeoutId);
                     if (!isSettled) {
                         isSettled = true;
@@ -232,7 +233,7 @@ class AnalyticsService {
     async sendInfoForTracking(trackingInfo, settingName) {
         await this.initAnalyticsStatuses();
         if (!this.$staticConfig.disableAnalytics &&
-            this.analyticsStatuses[settingName] === "enabled" /* AnalyticsStatus.enabled */) {
+            this.analyticsStatuses[settingName] === enums_1.AnalyticsStatus.enabled) {
             return this.sendMessageToBroker(trackingInfo);
         }
     }
@@ -280,21 +281,21 @@ class AnalyticsService {
             if (settingValue) {
                 const isEnabled = (0, helpers_1.toBoolean)(settingValue);
                 if (isEnabled) {
-                    this.analyticsStatuses[settingName] = "enabled" /* AnalyticsStatus.enabled */;
+                    this.analyticsStatuses[settingName] = enums_1.AnalyticsStatus.enabled;
                 }
                 else {
-                    this.analyticsStatuses[settingName] = "disabled" /* AnalyticsStatus.disabled */;
+                    this.analyticsStatuses[settingName] = enums_1.AnalyticsStatus.disabled;
                 }
             }
             else {
-                this.analyticsStatuses[settingName] = "not confirmed" /* AnalyticsStatus.notConfirmed */;
+                this.analyticsStatuses[settingName] = enums_1.AnalyticsStatus.notConfirmed;
             }
         }
         return this.analyticsStatuses[settingName];
     }
     async isNotConfirmed(settingName) {
         const analyticsStatus = await this.getStatus(settingName);
-        return analyticsStatus === "not confirmed" /* AnalyticsStatus.notConfirmed */;
+        return analyticsStatus === enums_1.AnalyticsStatus.notConfirmed;
     }
     async getHumanReadableStatusMessage(settingName, readableSettingName) {
         let status = null;
@@ -308,14 +309,14 @@ class AnalyticsService {
     }
     async getJsonStatusMessage(settingName) {
         const status = await this.getStatus(settingName);
-        const enabled = status === "not confirmed" /* AnalyticsStatus.notConfirmed */
+        const enabled = status === enums_1.AnalyticsStatus.notConfirmed
             ? null
-            : status === "enabled" /* AnalyticsStatus.enabled */;
+            : status === enums_1.AnalyticsStatus.enabled;
         return JSON.stringify({ enabled });
     }
     trackException(exception, message) {
         const data = {
-            type: "exception" /* TrackingTypes.Exception */,
+            type: enums_1.TrackingTypes.Exception,
             exception,
             message,
         };
@@ -331,4 +332,3 @@ __decorate([
     (0, decorators_1.cache)()
 ], AnalyticsService.prototype, "initAnalyticsStatuses", null);
 yok_1.injector.register("analyticsService", AnalyticsService);
-//# sourceMappingURL=analytics-service.js.map

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,138 +1,142 @@
 "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 decorators_1 = require("../../common/decorators");
+const constants_1 = require("../../common/constants");
+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({
-                type: "Error" /* FileLogMessageType.Error */,
+                type: detached_process_enums_1.FileLogMessageType.Error,
                 message: `Unable to track information ${JSON.stringify(trackInfo)}. Error is: ${e}`,
             });
             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 "pageview" /* GoogleAnalyticsDataType.Page */:
-                await this.trackPageView(visitor, trackInfo);
-                break;
-            case "event" /* 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 = {
-            ["cd1" /* GoogleAnalyticsCustomDimensions.cliVersion */]: this.$staticConfig.version,
-            ["cd6" /* GoogleAnalyticsCustomDimensions.nodeVersion */]: process.version,
-            ["cd3" /* GoogleAnalyticsCustomDimensions.clientID */]: this.clientId,
-            ["cd2" /* GoogleAnalyticsCustomDimensions.projectType */]: null,
-            ["cd9" /* GoogleAnalyticsCustomDimensions.isShared */]: null,
-            ["cd4" /* GoogleAnalyticsCustomDimensions.sessionID */]: sessionId,
-            ["cd5" /* GoogleAnalyticsCustomDimensions.client */]: "Unknown" /* AnalyticsClients.Unknown */,
+            [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.cliVersion]: this.$staticConfig.version,
+            [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.nodeVersion]: process.version,
+            [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.clientID]: this.clientId,
+            [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.projectType]: null,
+            [google_analytics_custom_dimensions_1.GoogleAnalyticsCustomDimensions.isShared]: null,
+            [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: "Error" /* 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: "Error" /* 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);
-//# sourceMappingURL=google-analytics-provider.js.map

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

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

package/lib/services/analytics-settings-service.js

@@ -62,10 +62,6 @@ class AnalyticsSettingsService {
         return userAgent;
     }
     getMacOSReleaseVersion(osRelease) {
-        // https://en.wikipedia.org/wiki/Darwin_(operating_system)#Release_history
-        // Each macOS version is labeled 10.<version>, where it looks like <versions> is taken from the major version returned by os.release() (16.x.x for example) and subtracting 4 from it.
-        // So the version becomes "10.12" in this case.
-        // Could be improved by spawning `system_profiler SPSoftwareDataType` and getting the System Version line from the result.
         const majorVersion = osRelease && _.first(osRelease.split("."));
         return majorVersion && `10.${+majorVersion - 4}`;
     }
@@ -90,4 +86,3 @@ __decorate([
     (0, decorators_1.exported)("analyticsSettingsService")
 ], AnalyticsSettingsService.prototype, "getUserAgentString", null);
 yok_1.injector.register("analyticsSettingsService", AnalyticsSettingsService);
-//# sourceMappingURL=analytics-settings-service.js.map

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,7 +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);
-//# sourceMappingURL=android-bundle-tool-service.js.map

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;
+}