refactor: start using getInitialFiles instead of applyChanges during the first Preview sync

Author: DimitarTachev

lib/definitions/preview-app-livesync.d.ts

@@ -1,20 +1,19 @@
-import { FilePayload, Device } from "nativescript-preview-sdk";
+import { FilePayload, Device, FilesPayload } from "nativescript-preview-sdk";
 
 declare global {
 	interface IPreviewAppLiveSyncService {
-		initialize(): void;
-		initialSync(data: IPreviewAppLiveSyncData): Promise<void>;
+		initialize(data: IPreviewAppLiveSyncData): void;
 		syncFiles(data: IPreviewAppLiveSyncData, filesToSync: string[]): Promise<void>;
 		stopLiveSync(): Promise<void>;
 	}
 
 	interface IPreviewAppLiveSyncData extends IProjectDir, IAppFilesUpdaterOptionsComposition, IEnvOptions { }
 
-	interface IPreviewSdkService extends NodeJS.EventEmitter {
+	interface IPreviewSdkService {
 		qrCodeUrl: string;
 		connectedDevices: Device[];
-		initialize(): void;
-		applyChanges(files: FilePayload[], platform: string): Promise<void>;
+		initialize(getInitialFiles: (device: Device) => Promise<FilesPayload>): void;
+		applyChanges(filesPayload: FilesPayload): Promise<void>;
 		stop(): void;
 	}
 

lib/services/livesync/livesync-service.ts

@@ -321,7 +321,14 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 		let deviceDescriptorsForInitialSync: ILiveSyncDeviceInfo[] = [];
 
 		if (liveSyncData.syncToPreviewApp) {
-			this.$previewAppLiveSyncService.initialize();
+			this.$previewAppLiveSyncService.initialize({
+				appFilesUpdaterOptions: {
+					bundle: liveSyncData.bundle,
+					release: liveSyncData.release
+				},
+				env: liveSyncData.env,
+				projectDir: projectData.projectDir
+			});
 		} else {
 			await this.$pluginsService.ensureAllDependenciesAreInstalled(projectData);
 			// In case liveSync is called for a second time for the same projectDir.
@@ -457,26 +464,11 @@ export class LiveSyncService extends EventEmitter implements IDebugLiveSyncServi
 	}
 
 	private async initialSync(projectData: IProjectData, liveSyncData: ILiveSyncInfo, deviceDescriptors: ILiveSyncDeviceInfo[]): Promise<void> {
-		if (liveSyncData.syncToPreviewApp) {
-			await this.initialSyncToPreviewApp(projectData, liveSyncData);
-		} else {
+		if (!liveSyncData.syncToPreviewApp) {
 			await this.initialCableSync(projectData, liveSyncData, deviceDescriptors);
 		}
 	}
 
-	private async initialSyncToPreviewApp(projectData: IProjectData, liveSyncData: ILiveSyncInfo) {
-		await this.addActionToChain(projectData.projectDir, async () => {
-			await this.$previewAppLiveSyncService.initialSync({
-				appFilesUpdaterOptions: {
-					bundle: liveSyncData.bundle,
-					release: liveSyncData.release
-				},
-				env: liveSyncData.env,
-				projectDir: projectData.projectDir
-			});
-		});
-	}
-
 	private async initialCableSync(projectData: IProjectData, liveSyncData: ILiveSyncInfo, deviceDescriptors: ILiveSyncDeviceInfo[]): Promise<void> {
 		const preparedPlatforms: string[] = [];
 		const rebuiltInformation: ILiveSyncBuildInfo[] = [];

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

@@ -1,5 +1,4 @@
 export class PreviewSdkEventNames {
-	public static DEVICE_CONNECTED = "onDeviceConnected";
 	public static CHANGE_EVENT_NAME = "change";
 }
 

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

@@ -1,5 +1,5 @@
 import * as path from "path";
-import { FilePayload, Device } from "nativescript-preview-sdk";
+import { FilePayload, Device, FilesPayload } from "nativescript-preview-sdk";
 import { PreviewSdkEventNames } from "./preview-app-constants";
 import { APP_FOLDER_NAME, APP_RESOURCES_FOLDER_NAME, TNS_MODULES_FOLDER_NAME } from "../../../constants";
 const isTextOrBinary = require('istextorbinary');
@@ -9,6 +9,7 @@ export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
 	private excludedFiles = [".DS_Store"];
 
 	constructor(private $fs: IFileSystem,
+		private $errors: IErrors,
 		private $hooksService: IHooksService,
 		private $logger: ILogger,
 		private $platformService: IPlatformService,
@@ -19,15 +20,14 @@ export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
 		private $projectFilesManager: IProjectFilesManager,
 		private $projectFilesProvider: IProjectFilesProvider) { }
 
-	public initialize() {
-		this.$previewSdkService.initialize();
-	}
+	public initialize(data: IPreviewAppLiveSyncData) {
+		this.$previewSdkService.initialize(async (device: Device) => {
+			if (!device) {
+				this.$errors.failWithoutHelp("Sending initial preview files without a specified device is not supported.");
+			}
 
-	public async initialSync(data: IPreviewAppLiveSyncData): Promise<void> {
-		this.$previewSdkService.on(PreviewSdkEventNames.DEVICE_CONNECTED, async (device: Device) => {
-			this.$logger.trace("Found connected device", device);
 			const filesToSyncMap: IDictionary<string[]> = {};
-			let promise = Promise.resolve();
+			let promise = Promise.resolve<FilesPayload>(null);
 			const startSyncFilesTimeout = async (platform: string) => {
 				await promise
 					.then(async () => {
@@ -45,11 +45,13 @@ export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
 						appFilesUpdaterOptions: data.appFilesUpdaterOptions,
 					},
 					filesToSyncMap,
-				 	startSyncFilesTimeout: startSyncFilesTimeout.bind(this)
+					startSyncFilesTimeout: startSyncFilesTimeout.bind(this)
 				}
-            });
+			            });
 			await this.$previewAppPluginsService.comparePluginsOnDevice(device);
-			await this.syncFilesForPlatformSafe(data, device.platform);
+			const payloads = await this.syncFilesForPlatformSafe(data, device.platform);
+
+			return payloads;
 		});
 	}
 
@@ -71,33 +73,41 @@ export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
 	}
 
 	public async stopLiveSync(): Promise<void> {
-		this.$previewSdkService.removeAllListeners();
 		this.$previewSdkService.stop();
 	}
 
-	private async syncFilesForPlatformSafe(data: IPreviewAppLiveSyncData, platform: string, files?: string[]): Promise<void> {
+	private async syncFilesForPlatformSafe(data: IPreviewAppLiveSyncData, platform: string, files?: string[]): Promise<FilesPayload> {
 		this.$logger.info(`Start syncing changes for platform ${platform}.`);
 
 		try {
 			const { appFilesUpdaterOptions, env, projectDir } = data;
 			const projectData = this.$projectDataService.getProjectData(projectDir);
+			const platformData = this.$platformsData.getPlatformData(platform, projectData);
 			await this.preparePlatform(platform, appFilesUpdaterOptions, env, projectData);
 
-			await this.applyChanges(projectData, platform, files);
+			let result: FilesPayload = null;
+			if (files && files.length) {
+				result = await this.applyChanges(platformData, projectData, files);
+			} else {
+				result = await this.getFilesPayload(platformData, projectData);
+			}
 
 			this.$logger.info(`Successfully synced changes for platform ${platform}.`);
+
+			return result;
 		} catch (err) {
 			this.$logger.warn(`Unable to apply changes for platform ${platform}. Error is: ${err}, ${JSON.stringify(err, null, 2)}.`);
 		}
 	}
 
-	private async applyChanges(projectData: IProjectData, platform: string, files: string[]) {
-		const platformData = this.$platformsData.getPlatformData(platform, projectData);
-		const payloads = this.getFilePayloads(platformData, projectData, _(files).uniq().value());
-		await this.$previewSdkService.applyChanges(payloads, platform);
+	private async applyChanges(platformData: IPlatformData, projectData: IProjectData, files: string[]): Promise<FilesPayload> {
+		const payloads = this.getFilesPayload(platformData, projectData, _(files).uniq().value());
+		await this.$previewSdkService.applyChanges(payloads);
+
+		return payloads;
 	}
 
-	private getFilePayloads(platformData: IPlatformData, projectData: IProjectData, files?: string[]): FilePayload[] {
+	private getFilesPayload(platformData: IPlatformData, projectData: IProjectData, files?: string[]): FilesPayload {
 		const appFolderPath = path.join(projectData.projectDir, APP_FOLDER_NAME);
 		const platformsAppFolderPath = path.join(platformData.appDestinationDirectoryPath, APP_FOLDER_NAME);
 
@@ -127,7 +137,7 @@ export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
 				};
 
 				if (filePayload.binary) {
-					const bitmap =  <string>this.$fs.readFile(file);
+					const bitmap = <string>this.$fs.readFile(file);
 					const base64 = Buffer.from(bitmap).toString('base64');
 					filePayload.fileContents = base64;
 				} else {
@@ -137,7 +147,7 @@ export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
 				return filePayload;
 			});
 
-		return payloads;
+		return { files: payloads, platform: platformData.normalizedPlatformName.toLowerCase() };
 	}
 
 	private async preparePlatform(platform: string, appFilesUpdaterOptions: IAppFilesUpdaterOptions, env: Object, projectData: IProjectData): Promise<void> {

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

@@ -1,9 +1,8 @@
-import { FilePayload, MessagingService, Config, Device, DeviceConnectedMessage, SdkCallbacks, ConnectedDevices } from "nativescript-preview-sdk";
-import { EventEmitter } from "events";
-import { PreviewSdkEventNames, PubnubKeys } from "./preview-app-constants";
+import { MessagingService, Config, Device, DeviceConnectedMessage, SdkCallbacks, ConnectedDevices, FilesPayload } from "nativescript-preview-sdk";
+import { PubnubKeys } from "./preview-app-constants";
 const pako = require("pako");
 
-export class PreviewSdkService extends EventEmitter implements IPreviewSdkService {
+export class PreviewSdkService implements IPreviewSdkService {
 	private messagingService: MessagingService = null;
 	private instanceId: string = null;
 	public connectedDevices: Device[] = [];
@@ -12,22 +11,21 @@ export class PreviewSdkService extends EventEmitter implements IPreviewSdkServic
 		private $logger: ILogger,
 		private $httpClient: Server.IHttpClient,
 		private $config: IConfiguration) {
-		super();
 	}
 
 	public get qrCodeUrl(): string {
 		return `nsplay://boot?instanceId=${this.instanceId}&pKey=${PubnubKeys.PUBLISH_KEY}&sKey=${PubnubKeys.SUBSCRIBE_KEY}&template=play-ng`;
 	}
 
-	public initialize(): void {
-		const initConfig = this.getInitConfig();
+	public initialize(getInitialFiles: (device: Device) => Promise<FilesPayload>): void {
+		const initConfig = this.getInitConfig(getInitialFiles);
 		this.messagingService = new MessagingService();
 		this.instanceId = this.messagingService.initialize(initConfig);
 	}
 
-	public applyChanges(files: FilePayload[], platform: string): Promise<void> {
+	public applyChanges(filesPayload: FilesPayload): Promise<void> {
 		return new Promise((resolve, reject) => {
-			this.messagingService.applyChanges(this.instanceId, { files, platform }, err => {
+			this.messagingService.applyChanges(this.instanceId, filesPayload, err => {
 				if (err) {
 					reject(err);
 				} else {
@@ -41,16 +39,12 @@ export class PreviewSdkService extends EventEmitter implements IPreviewSdkServic
 		this.messagingService.stop();
 	}
 
-	private getInitConfig(): Config {
+	private getInitConfig(getInitialFiles: (device: Device) => Promise<FilesPayload>): Config {
 		return {
 			pubnubPublishKey: PubnubKeys.PUBLISH_KEY,
 			pubnubSubscribeKey: PubnubKeys.SUBSCRIBE_KEY,
 			callbacks: this.getCallbacks(),
-			getInitialFiles: async () => {
-				return {
-					files: []
-				};
-			}
+			getInitialFiles
 		};
 	}
 
@@ -71,7 +65,6 @@ export class PreviewSdkService extends EventEmitter implements IPreviewSdkServic
 			},
 			onDeviceConnectedMessage: (deviceConnectedMessage: DeviceConnectedMessage) => ({ }),
 			onDeviceConnected: (device: Device) => {
-				this.emit(PreviewSdkEventNames.DEVICE_CONNECTED, device);
 				if (!_.includes(this.connectedDevices, device)) {
 					this.connectedDevices.push(device);
 				}

npm-shrinkwrap.json

@@ -56,7 +56,7 @@
     "mkdirp": "0.5.1",
     "mute-stream": "0.0.5",
     "nativescript-doctor": "1.2.0",
-    "nativescript-preview-sdk": "0.2.2",
+    "nativescript-preview-sdk": "0.2.4",
     "open": "0.0.5",
     "ora": "2.0.0",
     "osenv": "0.1.3",