refactor(analytics): remove AnalyticsServiceBase and obsolete static config props

Remove `AnalyticsServiceBase` by moving the required code to `AnalyticsService`.
Remove obsolete static config props.

Author: rosen-vladimirov

lib/common/definitions/config.d.ts

@@ -6,8 +6,6 @@ declare module Config {
 		USER_AGENT_NAME: string;
 		CLIENT_NAME_ALIAS?: string;
 		FULL_CLIENT_NAME?: string;
-		ANALYTICS_API_KEY: string;
-		ANALYTICS_EXCEPTIONS_API_KEY: string;
 		ANALYTICS_INSTALLATION_ID_SETTING_NAME: string;
 		TRACK_FEATURE_USAGE_SETTING_NAME: string;
 		ERROR_REPORT_SETTING_NAME: string;

lib/common/services/analytics-service-base.ts

@@ -5,8 +5,6 @@ import * as os from "os";
 export abstract class StaticConfigBase implements Config.IStaticConfig {
 	public PROJECT_FILE_NAME: string = null;
 	public CLIENT_NAME: string = null;
-	public ANALYTICS_API_KEY: string = null;
-	public abstract ANALYTICS_EXCEPTIONS_API_KEY: string;
 	public ANALYTICS_INSTALLATION_ID_SETTING_NAME: string = null;
 	public TRACK_FEATURE_USAGE_SETTING_NAME: string = null;
 	public ERROR_REPORT_SETTING_NAME: string = null;

lib/common/static-config-base.ts

@@ -1,6 +1,6 @@
 import { CommonLoggerStub, ErrorsStub } from "./stubs";
 import { Yok } from "../../yok";
-import { AnalyticsServiceBase } from '../../services/analytics-service-base';
+import { AnalyticsService } from '../../../services/analytics/analytics-service';
 import helpersLib = require("../../helpers");
 import { HostInfo } from "../../host-info";
 import { OsInfo } from "../../os-info";
@@ -43,9 +43,10 @@ interface ITestScenario {
 
 function createTestInjector(testScenario: ITestScenario): IInjector {
 	const testInjector = new Yok();
+
 	testInjector.register("logger", CommonLoggerStub);
 	testInjector.register("errors", ErrorsStub);
-	testInjector.register("analyticsService", AnalyticsServiceBase);
+	testInjector.register("analyticsService", AnalyticsService);
 	testInjector.register("analyticsSettingsService", {
 		canDoRequest: () => {
 			return Promise.resolve(testScenario.canDoRequest);
@@ -92,10 +93,14 @@ function createTestInjector(testScenario: ITestScenario): IInjector {
 		attachToProcessExitSignals: (context: any, callback: () => void): void => (undefined)
 	});
 
+	testInjector.register("childProcess", {});
+	testInjector.register("projectDataService", {});
+	testInjector.register("mobileHelper", {});
+
 	return testInjector;
 }
 
-describe("analytics-service-base", () => {
+describe("analytics-service", () => {
 	let baseTestScenario: ITestScenario;
 	let service: IAnalyticsService = null;
 

lib/common/test/unit-tests/analytics-service.ts

@@ -26,8 +26,6 @@ export class StaticConfig extends StaticConfigBase implements IStaticConfig {
 	public CLIENT_NAME_KEY_IN_PROJECT_FILE = "nativescript";
 	public CLIENT_NAME = "tns";
 	public CLIENT_NAME_ALIAS = "NativeScript";
-	public ANALYTICS_API_KEY = "5752dabccfc54c4ab82aea9626b7338e";
-	public ANALYTICS_EXCEPTIONS_API_KEY = "35478fe7de68431399e96212540a3d5d";
 	public TRACK_FEATURE_USAGE_SETTING_NAME = "TrackFeatureUsage";
 	public ERROR_REPORT_SETTING_NAME = "TrackExceptions";
 	public ANALYTICS_INSTALLATION_ID_SETTING_NAME = "AnalyticsInstallationID";

lib/config.ts

@@ -1,35 +1,73 @@
-import { AnalyticsServiceBase } from "../../common/services/analytics-service-base";
 import { ChildProcess } from "child_process";
 import * as path from "path";
 import { cache } from "../../common/decorators";
-import { isInteractive } from '../../common/helpers';
+import { isInteractive, toBoolean } from '../../common/helpers';
 import { DeviceTypes, AnalyticsClients } from "../../common/constants";
 
-export class AnalyticsService extends AnalyticsServiceBase {
+export class AnalyticsService implements IAnalyticsService, IDisposable {
 	private static ANALYTICS_BROKER_START_TIMEOUT = 10 * 1000;
 	private brokerProcess: ChildProcess;
-
-	constructor(protected $logger: ILogger,
-		protected $options: IOptions,
-		protected $processService: IProcessService,
-		$staticConfig: Config.IStaticConfig,
-		$prompter: IPrompter,
-		$userSettingsService: UserSettings.IUserSettingsService,
-		$analyticsSettingsService: IAnalyticsSettingsService,
+	private shouldDisposeInstance: boolean = true;
+	private analyticsStatuses: IDictionary<AnalyticsStatus> = {};
+
+	constructor(private $logger: ILogger,
+		private $options: IOptions,
+		private $processService: IProcessService,
+		private $staticConfig: Config.IStaticConfig,
+		private $prompter: IPrompter,
+		private $userSettingsService: UserSettings.IUserSettingsService,
+		private $analyticsSettingsService: IAnalyticsSettingsService,
 		private $childProcess: IChildProcess,
 		private $projectDataService: IProjectDataService,
 		private $mobileHelper: Mobile.IMobileHelper) {
-		super($logger, $options, $staticConfig, $processService, $prompter, $userSettingsService, $analyticsSettingsService);
 	}
 
-	public trackException(exception: any, message: string): Promise<void> {
-		const data: IExceptionsTrackingInformation = {
-			type: TrackingTypes.Exception,
-			exception,
-			message
-		};
+	public setShouldDispose(shouldDispose: boolean): void {
+		this.shouldDisposeInstance = shouldDispose;
+	}
 
-		return this.sendInfoForTracking(data, this.$staticConfig.ERROR_REPORT_SETTING_NAME);
+	public async checkConsent(): Promise<void> {
+		if (await this.$analyticsSettingsService.canDoRequest()) {
+			const initialTrackFeatureUsageStatus = await this.getStatus(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME);
+			let trackFeatureUsage = initialTrackFeatureUsageStatus === AnalyticsStatus.enabled;
+
+			if (await this.isNotConfirmed(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME) && isInteractive()) {
+				this.$logger.out("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."
+					+ " You can read our official Privacy Policy at");
+
+				const message = this.$analyticsSettingsService.getPrivacyPolicyLink();
+				trackFeatureUsage = await this.$prompter.confirm(message, () => true);
+				await this.setStatus(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME, trackFeatureUsage);
+
+				await this.trackAcceptFeatureUsage({ acceptTrackFeatureUsage: trackFeatureUsage });
+			}
+
+			const isErrorReportingUnset = await this.isNotConfirmed(this.$staticConfig.ERROR_REPORT_SETTING_NAME);
+			const isUsageReportingConfirmed = !await this.isNotConfirmed(this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME);
+			if (isErrorReportingUnset && isUsageReportingConfirmed) {
+				await this.setStatus(this.$staticConfig.ERROR_REPORT_SETTING_NAME, trackFeatureUsage);
+			}
+		}
+	}
+
+	public async setStatus(settingName: string, enabled: boolean): Promise<void> {
+		this.analyticsStatuses[settingName] = enabled ? AnalyticsStatus.enabled : AnalyticsStatus.disabled;
+		await this.$userSettingsService.saveSetting(settingName, enabled.toString());
+	}
+
+	public async isEnabled(settingName: string): Promise<boolean> {
+		const analyticsStatus = await this.getStatus(settingName);
+		return analyticsStatus === AnalyticsStatus.enabled;
+	}
+
+	public getStatusMessage(settingName: string, jsonFormat: boolean, readableSettingName: string): Promise<string> {
+		if (jsonFormat) {
+			return this.getJsonStatusMessage(settingName);
+		}
+
+		return this.getHumanReadableStatusMessage(settingName, readableSettingName);
 	}
 
 	public async trackAcceptFeatureUsage(settings: { acceptTrackFeatureUsage: boolean }): Promise<void> {
@@ -192,6 +230,72 @@ export class AnalyticsService extends AnalyticsServiceBase {
 			}
 		});
 	}
+
+	@cache()
+	private async initAnalyticsStatuses(): Promise<void> {
+		if (await this.$analyticsSettingsService.canDoRequest()) {
+			this.$logger.trace("Initializing analytics statuses.");
+			const settingsNames = [this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME, this.$staticConfig.ERROR_REPORT_SETTING_NAME];
+
+			for (const settingName of settingsNames) {
+				await this.getStatus(settingName);
+			}
+
+			this.$logger.trace("Analytics statuses: ", this.analyticsStatuses);
+		}
+	}
+
+	private async getStatus(settingName: string): Promise<AnalyticsStatus> {
+		if (!_.has(this.analyticsStatuses, settingName)) {
+			const settingValue = await this.$userSettingsService.getSettingValue<string>(settingName);
+
+			if (settingValue) {
+				const isEnabled = toBoolean(settingValue);
+				if (isEnabled) {
+					this.analyticsStatuses[settingName] = AnalyticsStatus.enabled;
+				} else {
+					this.analyticsStatuses[settingName] = AnalyticsStatus.disabled;
+				}
+			} else {
+				this.analyticsStatuses[settingName] = AnalyticsStatus.notConfirmed;
+			}
+		}
+
+		return this.analyticsStatuses[settingName];
+	}
+
+	private async isNotConfirmed(settingName: string): Promise<boolean> {
+		const analyticsStatus = await this.getStatus(settingName);
+		return analyticsStatus === AnalyticsStatus.notConfirmed;
+	}
+
+	private async getHumanReadableStatusMessage(settingName: string, readableSettingName: string): Promise<string> {
+		let status: string = null;
+
+		if (await this.isNotConfirmed(settingName)) {
+			status = "disabled until confirmed";
+		} else {
+			status = await this.getStatus(settingName);
+		}
+
+		return `${readableSettingName} is ${status}.`;
+	}
+
+	private async getJsonStatusMessage(settingName: string): Promise<string> {
+		const status = await this.getStatus(settingName);
+		const enabled = status === AnalyticsStatus.notConfirmed ? null : status === AnalyticsStatus.enabled;
+		return JSON.stringify({ enabled });
+	}
+
+	public trackException(exception: any, message: string): Promise<void> {
+		const data: IExceptionsTrackingInformation = {
+			type: TrackingTypes.Exception,
+			exception,
+			message
+		};
+
+		return this.sendInfoForTracking(data, this.$staticConfig.ERROR_REPORT_SETTING_NAME);
+	}
 }
 
 $injector.register("analyticsService", AnalyticsService);