feat: track data from preview app on preview and run commands

{N} CLI checks if there is a file on device written from preview app, gets its content if such file exists and sends an event to google analytics. This will allow us to know how much users are using the Playground site and {N} CLI.

Author: Fatme

lib/commands/run.ts

@@ -6,7 +6,9 @@ export class RunCommandBase implements ICommand {
 	private liveSyncCommandHelperAdditionalOptions: ILiveSyncCommandHelperAdditionalOptions = <ILiveSyncCommandHelperAdditionalOptions>{};
 
 	public platform: string;
-	constructor(private $projectData: IProjectData,
+	constructor(
+		private $analyticsService: IAnalyticsService,
+		private $projectData: IProjectData,
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		private $errors: IErrors,
 		private $hostInfo: IHostInfo,
@@ -15,6 +17,7 @@ export class RunCommandBase implements ICommand {
 
 	public allowedParameters: ICommandParameter[] = [];
 	public async execute(args: string[]): Promise<void> {
+		await this.$analyticsService.trackPreviewAppData(this.platform, this.$projectData.projectDir);
 		return this.$liveSyncCommandHelper.executeCommandLiveSync(this.platform, this.liveSyncCommandHelperAdditionalOptions);
 	}
 

lib/common/declarations.d.ts

@@ -203,6 +203,11 @@ declare const enum TrackingTypes {
 	 */
 	GoogleAnalyticsData = "googleAnalyticsData",
 
+	/**
+	 * Defines that the broker process should get and track the data from preview app to Google Analytics
+	 */
+	PreviewAppData = "PreviewAppData",
+
 	/**
 	 * Defines that all information has been sent and no more data will be tracked in current session.
 	 */
@@ -700,6 +705,11 @@ interface IAnalyticsService {
 	 */
 	trackEventActionInGoogleAnalytics(data: IEventActionData): Promise<void>;
 
+	/**
+	 * Tracks preview's app data to Google Analytics project.
+	 */
+	trackPreviewAppData(platform: string, projectDir: string): Promise<void>
+
 	/**
 	 * Defines if the instance should be disposed.
 	 * @param {boolean} shouldDispose Defines if the instance should be disposed and the child processes should be disconnected.

lib/common/definitions/google-analytics.d.ts

@@ -13,6 +13,11 @@ interface IGoogleAnalyticsData {
 	customDimensions?: IStringDictionary;
 }
 
+interface IPreviewAppGoogleAnalyticsData {
+	platform: string;
+	additionalData?: string;
+}
+
 /**
  * Describes information about event that should be tracked.
  */

lib/common/definitions/mobile.d.ts

@@ -368,6 +368,7 @@ declare module Mobile {
 	interface IDeviceFileSystem {
 		listFiles(devicePath: string, appIdentifier?: string): Promise<any>;
 		getFile(deviceFilePath: string, appIdentifier: string, outputFilePath?: string): Promise<void>;
+		getFileContent(deviceFilePath: string, appIdentifier: string): Promise<string>;
 		putFile(localFilePath: string, deviceFilePath: string, appIdentifier: string): Promise<void>;
 		deleteFile(deviceFilePath: string, appIdentifier: string): Promise<void>;
 		transferFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<Mobile.ILocalToDevicePathData[]>;

lib/common/mobile/android/android-device-file-system.ts

@@ -48,6 +48,11 @@ export class AndroidDeviceFileSystem implements Mobile.IDeviceFileSystem {
 		}
 	}
 
+	public async getFileContent(deviceFilePath: string, appIdentifier: string): Promise<string> {
+		const result = await this.adb.executeShellCommand(["cat", deviceFilePath]);
+		return result;
+	}
+
 	public async putFile(localFilePath: string, deviceFilePath: string, appIdentifier: string): Promise<void> {
 		await this.adb.pushFile(localFilePath, deviceFilePath);
 	}

lib/common/mobile/ios/device/ios-device-file-system.ts

@@ -23,15 +23,19 @@ export class IOSDeviceFileSystem implements Mobile.IDeviceFileSystem {
 	}
 
 	public async getFile(deviceFilePath: string, appIdentifier: string, outputFilePath?: string): Promise<void> {
-		if (!outputFilePath) {
-			const result = await this.$iosDeviceOperations.readFiles([{ deviceId: this.device.deviceInfo.identifier, path: deviceFilePath, appId: appIdentifier }]);
-			const response = result[this.device.deviceInfo.identifier][0];
-			if (response) {
-				this.$logger.out(response.response);
-			}
-		} else {
+		if (outputFilePath) {
 			await this.$iosDeviceOperations.downloadFiles([{ appId: appIdentifier, deviceId: this.device.deviceInfo.identifier, source: deviceFilePath, destination: outputFilePath }]);
+			return;
 		}
+
+		const fileContent = await this.getFileContent(deviceFilePath, appIdentifier);
+		this.$logger.out(fileContent);
+	}
+
+	public async getFileContent(deviceFilePath: string, appIdentifier: string): Promise<string> {
+		const result = await this.$iosDeviceOperations.readFiles([{ deviceId: this.device.deviceInfo.identifier, path: deviceFilePath, appId: appIdentifier }]);
+		const response = result[this.device.deviceInfo.identifier][0];
+		return response.response;
 	}
 
 	public async putFile(localFilePath: string, deviceFilePath: string, appIdentifier: string): Promise<void> {

lib/common/mobile/ios/simulator/ios-simulator-file-system.ts

@@ -16,6 +16,11 @@ export class IOSSimulatorFileSystem implements Mobile.IDeviceFileSystem {
 		}
 	}
 
+	public async getFileContent(deviceFilePath: string, appIdentifier: string): Promise<string> {
+		const result = this.$fs.readText(deviceFilePath);
+		return result;
+	}
+
 	public async putFile(localFilePath: string, deviceFilePath: string, appIdentifier: string): Promise<void> {
 		shelljs.cp("-f", localFilePath, deviceFilePath);
 	}
@@ -27,7 +32,7 @@ export class IOSSimulatorFileSystem implements Mobile.IDeviceFileSystem {
 	public async transferFiles(deviceAppData: Mobile.IDeviceAppData, localToDevicePaths: Mobile.ILocalToDevicePathData[]): Promise<Mobile.ILocalToDevicePathData[]> {
 		await Promise.all(
 			_.map(localToDevicePaths, localToDevicePathData => this.transferFile(localToDevicePathData.getLocalPath(), localToDevicePathData.getDevicePath())
-			));
+		));
 		return localToDevicePaths;
 	}
 

lib/constants.ts

@@ -153,7 +153,8 @@ export const enum TrackActionNames {
 	CheckEnvironmentRequirements = "Check Environment Requirements",
 	Options = "Options",
 	AcceptTracking = "Accept Tracking",
-	Performance = "Performance"
+	Performance = "Performance",
+	PreviewAppData = "Preview App Data"
 }
 
 export const AnalyticsEventLabelDelimiter = "__";

lib/services/analytics/analytics-broker-process.ts

@@ -54,6 +54,33 @@ const finishTracking = async (data?: ITrackingInformation) => {
 	}
 };
 
+const trackPreviewAppData = async (data: any) => {
+	const mobileHelper = $injector.resolve<Mobile.IMobileHelper>("mobileHelper");
+	const devicesService = $injector.resolve<Mobile.IDevicesService>("devicesService");
+	await devicesService.initialize({ platform: data.platform, skipDeviceDetectionInterval: true, skipEmulatorStart: true });
+
+	const devices = await devicesService.getDevicesForPlatform(data.platform);
+	_.each(devices, async (device: Mobile.IDevice) => {
+		try {
+			let previewAppFilePath = null;
+			if (mobileHelper.isAndroidPlatform(device.deviceInfo.platform)) {
+				previewAppFilePath = "/sdcard/org.nativescript.preview/device.json";
+			} else if (mobileHelper.isiOSPlatform(device.deviceInfo.platform)) {
+				previewAppFilePath = "Documents/device.json";
+			}
+
+			const previewAppFileContent = await device.fileSystem.getFileContent(previewAppFilePath, "org.nativescript.preview");
+			const previewAppDeviceId = JSON.parse(previewAppFileContent).id;
+			data.label += `_${previewAppDeviceId}`;
+
+			analyticsLoggingService.logData({ message: `analytics-broker-process will send the data from preview app: ${data}` });
+			await sendDataForTracking(data);
+		} catch (err) {
+			// ignore the error
+		}
+	});
+};
+
 process.on("message", async (data: ITrackingInformation) => {
 	analyticsLoggingService.logData({ message: `analytics-broker-process received message of type: ${data.type}` });
 
@@ -63,6 +90,10 @@ process.on("message", async (data: ITrackingInformation) => {
 		return;
 	}
 
+	if (data.type === TrackingTypes.PreviewAppData) {
+		await trackPreviewAppData(<IPreviewAppTrackingInformation>data);
+	}
+
 	await sendDataForTracking(data);
 });
 

lib/services/analytics/analytics-service.ts

@@ -96,7 +96,6 @@ export class AnalyticsService implements IAnalyticsService, IDisposable {
 		const platform = device ? device.deviceInfo.platform : data.platform;
 		const normalizedPlatform = platform ? this.$mobileHelper.normalizePlatformName(platform) : platform;
 		const isForDevice = device ? !device.isEmulator : data.isForDevice;
-
 		let label: string = "";
 		label = this.addDataToLabel(label, normalizedPlatform);
 
@@ -129,6 +128,25 @@ export class AnalyticsService implements IAnalyticsService, IDisposable {
 		await this.trackInGoogleAnalytics(googleAnalyticsEventData);
 	}
 
+	public async trackPreviewAppData(platform: string, projectDir: string): Promise<void> {
+		const customDimensions: IStringDictionary = {};
+		this.setProjectRelatedCustomDimensions(customDimensions, projectDir);
+
+		let label: string = "";
+		label = this.addDataToLabel(label, this.$mobileHelper.normalizePlatformName(platform));
+
+		const eventActionData = {
+			googleAnalyticsDataType: GoogleAnalyticsDataType.Event,
+			action: TrackActionNames.PreviewAppData,
+			platform,
+			label,
+			customDimensions,
+			type: TrackingTypes.PreviewAppData
+		};
+
+		await this.trackInGoogleAnalytics(eventActionData);
+	}
+
 	private forcefullyTrackInGoogleAnalytics(gaSettings: IGoogleAnalyticsData): Promise<void> {
 		gaSettings.customDimensions = gaSettings.customDimensions || {};
 		gaSettings.customDimensions[GoogleAnalyticsCustomDimensions.client] = this.$options.analyticsClient || (isInteractive() ? AnalyticsClients.Cli : AnalyticsClients.Unknown);

lib/services/analytics/analytics.d.ts

@@ -37,6 +37,8 @@ interface IAnalyticsBroker {
 
 interface IGoogleAnalyticsTrackingInformation extends IGoogleAnalyticsData, ITrackingInformation { }
 
+interface IPreviewAppTrackingInformation extends IPreviewAppGoogleAnalyticsData, ITrackingInformation { }
+
 /**
  * Describes methods required to track in Google Analytics.
  */

lib/services/livesync/playground/preview-app-livesync-service.ts

@@ -1,6 +1,6 @@
 import * as path from "path";
 import { Device, FilesPayload } from "nativescript-preview-sdk";
-import { APP_RESOURCES_FOLDER_NAME, APP_FOLDER_NAME } from "../../../constants";
+import { AnalyticsEventLabelDelimiter, APP_RESOURCES_FOLDER_NAME, APP_FOLDER_NAME, TrackActionNames } from "../../../constants";
 import { PreviewAppLiveSyncEvents } from "./preview-app-constants";
 import { HmrConstants } from "../../../common/constants";
 import { stringify } from "../../../common/helpers";
@@ -12,6 +12,7 @@ export class PreviewAppLiveSyncService extends EventEmitter implements IPreviewA
 	private deviceInitializationPromise: IDictionary<Promise<FilesPayload>> = {};
 
 	constructor(
+		private $analyticsService: IAnalyticsService,
 		private $errors: IErrors,
 		private $hooksService: IHooksService,
 		private $logger: ILogger,
@@ -33,6 +34,16 @@ export class PreviewAppLiveSyncService extends EventEmitter implements IPreviewA
 					this.$errors.failWithoutHelp("Sending initial preview files without a specified device is not supported.");
 				}
 
+				const deviceUniqueId = (<any>device).uniqueId;
+
+				if (deviceUniqueId) {
+					this.$analyticsService.trackEventActionInGoogleAnalytics({
+						action: TrackActionNames.PreviewAppData,
+						platform: device.platform,
+						additionalData: `previewAppDeviceId${AnalyticsEventLabelDelimiter}${deviceUniqueId}`
+					});
+				}
+
 				if (this.deviceInitializationPromise[device.id]) {
 					return this.deviceInitializationPromise[device.id];
 				}