feat(preview): add public API for deviceFound and deviceLost for preview devices

lib/bootstrap.ts

@@ -134,6 +134,7 @@ $injector.require("usbLiveSyncService", "./services/livesync/livesync-service");
 $injector.require("previewAppLiveSyncService", "./services/livesync/playground/preview-app-livesync-service");
 $injector.require("previewAppPluginsService", "./services/livesync/playground/preview-app-plugins-service");
 $injector.require("previewSdkService", "./services/livesync/playground/preview-sdk-service");
+$injector.requirePublicClass("previewDevicesService", "./services/livesync/playground/devices/preview-devices-service");
 $injector.require("playgroundQrCodeGenerator", "./services/livesync/playground/qr-code-generator");
 $injector.requirePublic("sysInfo", "./sys-info");
 

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

@@ -12,7 +12,6 @@ declare global {
 
 	interface IPreviewSdkService extends EventEmitter {
 		getQrCodeUrl(options: IHasUseHotModuleReloadOption): string;
-		connectedDevices: Device[];
 		initialize(getInitialFiles: (device: Device) => Promise<FilesPayload>): void;
 		applyChanges(filesPayload: FilesPayload): Promise<void>;
 		stop(): void;
@@ -34,4 +33,11 @@ declare global {
 		 */
 		link: boolean;
 	}
+
+	interface IPreviewDevicesService extends EventEmitter {
+		getConnectedDevices(): Device[];
+		updateConnectedDevices(devices: Device[]): void;
+		getDeviceById(id: string): Device;
+		getDevicesForPlatform(platform: string): Device[];
+	}
 }

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

@@ -0,0 +1,40 @@
+import { Device } from "nativescript-preview-sdk";
+import { EventEmitter } from "events";
+import { DeviceDiscoveryEventNames } from "../../../../common/constants";
+
+export class PreviewDevicesService extends EventEmitter implements IPreviewDevicesService {
+	private connectedDevices: Device[] = [];
+
+	public getConnectedDevices(): Device[] {
+		return this.connectedDevices;
+	}
+
+	public updateConnectedDevices(devices: Device[]): void {
+		_(devices)
+			.reject(d => _.find(this.connectedDevices, device => d.id === device.id))
+			.each(device => this.raiseDeviceFound(device));
+
+		_(this.connectedDevices)
+			.reject(d => _.find(devices, device => d.id === device.id))
+			.each(device => this.raiseDeviceLost(device));
+	}
+
+	public getDeviceById(id: string): Device {
+		return _.find(this.connectedDevices, { id });
+	}
+
+	public getDevicesForPlatform(platform: string): Device[] {
+		return _.filter(this.connectedDevices, { platform: platform.toLowerCase() });
+	}
+
+	private raiseDeviceFound(device: Device) {
+		this.emit(DeviceDiscoveryEventNames.DEVICE_FOUND, device);
+		this.connectedDevices.push(device);
+	}
+
+	private raiseDeviceLost(device: Device) {
+		this.emit(DeviceDiscoveryEventNames.DEVICE_LOST, device);
+		_.remove(this.connectedDevices, d => d.id === device.id);
+	}
+}
+$injector.register("previewDevicesService", PreviewDevicesService);

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

@@ -28,6 +28,7 @@ export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
 		private $projectDataService: IProjectDataService,
 		private $previewSdkService: IPreviewSdkService,
 		private $previewAppPluginsService: IPreviewAppPluginsService,
+		private $previewDevicesService: IPreviewDevicesService,
 		private $projectFilesManager: IProjectFilesManager,
 		private $hmrStatusService: IHmrStatusService,
 		private $projectFilesProvider: IProjectFilesProvider) { }
@@ -55,15 +56,15 @@ export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
 	public async syncFiles(data: IPreviewAppLiveSyncData, filesToSync: string[], filesToRemove: string[]): Promise<void> {
 		this.showWarningsForNativeFiles(filesToSync);
 
-		for (const device of this.$previewSdkService.connectedDevices) {
+		const connectedDevices = this.$previewDevicesService.getConnectedDevices();
+		for (const device of connectedDevices) {
 			await this.$previewAppPluginsService.comparePluginsOnDevice(data, device);
 		}
 
-		const platforms = _(this.$previewSdkService.connectedDevices)
+		const platforms = _(connectedDevices)
 			.map(device => device.platform)
 			.uniq()
 			.value();
-
 		for (const platform of platforms) {
 			await this.syncFilesForPlatformSafe(data, platform, { filesToSync, filesToRemove, useHotModuleReload: data.appFilesUpdaterOptions.useHotModuleReload });
 		}
@@ -112,7 +113,7 @@ export class PreviewAppLiveSyncService implements IPreviewAppLiveSyncService {
 				await promise;
 
 				if (data.appFilesUpdaterOptions.useHotModuleReload && platformHmrData.hash) {
-					const devices = _.filter(this.$previewSdkService.connectedDevices, { platform: platform.toLowerCase() });
+					const devices = this.$previewDevicesService.getDevicesForPlatform(platform);
 
 					await Promise.all(_.map(devices, async (previewDevice: Device) => {
 						const status = await this.$hmrStatusService.getHmrStatus(previewDevice.id, platformHmrData.hash);

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

@@ -1,18 +1,18 @@
 import { MessagingService, Config, Device, DeviceConnectedMessage, SdkCallbacks, ConnectedDevices, FilesPayload } from "nativescript-preview-sdk";
 import { PubnubKeys } from "./preview-app-constants";
-import { DEVICE_LOG_EVENT_NAME } from "../../../common/constants";
 import { EventEmitter } from "events";
+import { DEVICE_LOG_EVENT_NAME } from "../../../common/constants";
 const pako = require("pako");
 
 export class PreviewSdkService extends EventEmitter implements IPreviewSdkService {
 	private static MAX_FILES_UPLOAD_BYTE_LENGTH = 15 * 1024 * 1024; // In MBs
 	private messagingService: MessagingService = null;
 	private instanceId: string = null;
-	public connectedDevices: Device[] = [];
 
-	constructor(private $logger: ILogger,
+	constructor(private $config: IConfiguration,
 		private $httpClient: Server.IHttpClient,
-		private $config: IConfiguration) {
+		private $logger: ILogger,
+		private $previewDevicesService: IPreviewDevicesService) {
 			super();
 	}
 
@@ -60,9 +60,8 @@ export class PreviewSdkService extends EventEmitter implements IPreviewSdkServic
 			onLogSdkMessage: (log: string) => {
 				this.$logger.trace("Received onLogSdkMessage message: ", log);
 			},
-			onConnectedDevicesChange: (connectedDevices: ConnectedDevices) => ({ }),
 			onLogMessage: (log: string, deviceName: string, deviceId: string) => {
-				const device = _.find(this.connectedDevices, { id: deviceId});
+				const device = this.$previewDevicesService.getDeviceById(deviceId);
 				this.emit(DEVICE_LOG_EVENT_NAME, log, deviceId, device ? device.platform : "");
 				this.$logger.info(`LOG from device ${deviceName}: ${log}`);
 			},
@@ -72,13 +71,10 @@ export class PreviewSdkService extends EventEmitter implements IPreviewSdkServic
 			onUncaughtErrorMessage: () => {
 				this.$logger.warn("The Preview app has terminated unexpectedly. Please run it again to get a detailed crash report.");
 			},
-			onDeviceConnectedMessage: (deviceConnectedMessage: DeviceConnectedMessage) => ({ }),
-			onDeviceConnected: (device: Device) => {
-				if (!_.find(this.connectedDevices, {id: device.id})) {
-					this.connectedDevices.push(device);
-				}
-			},
-			onDevicesPresence: (devices: Device[]) => ({ }),
+			onConnectedDevicesChange: (connectedDevices: ConnectedDevices) => ({}),
+			onDeviceConnectedMessage: (deviceConnectedMessage: DeviceConnectedMessage) => ({}),
+			onDeviceConnected: (device: Device) => ({}),
+			onDevicesPresence: (devices: Device[]) => this.$previewDevicesService.updateConnectedDevices(devices),
 			onSendingChange: (sending: boolean) => ({ }),
 			onBiggerFilesUpload: async (filesContent, callback) => {
 				const gzippedContent = Buffer.from(pako.gzip(filesContent));

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

@@ -75,7 +75,6 @@ class PreviewSdkServiceMock extends EventEmitter implements IPreviewSdkService {
 		return "my_cool_qr_code_url";
 	}
 
-	public connectedDevices: Device[] = [deviceMockData];
 	public initialize(getInitialFiles: (device: Device) => Promise<FilesPayload>) {
 		this.getInitialFiles = async (device) => {
 			const filesPayload = await getInitialFiles(device);
@@ -158,6 +157,9 @@ function createTestInjector(options?: {
 			isHookCalledWithHMR = args.hookArgs.config.appFilesUpdaterOptions.useHotModuleReload;
 		}
 	});
+	injector.register("previewDevicesService", {
+		getConnectedDevices: () => [deviceMockData]
+	});
 
 	return injector;
 }

test/services/preview-devices-service.ts

@@ -0,0 +1,120 @@
+import { Yok } from "../../lib/common/yok";
+import { PreviewDevicesService } from "../../lib/services/livesync/playground/devices/preview-devices-service";
+import { Device } from "nativescript-preview-sdk";
+import { assert } from "chai";
+import { DeviceDiscoveryEventNames } from "../../lib/common/constants";
+import { LoggerStub } from "../stubs";
+
+let foundDevices: Device[] = [];
+let lostDevices: Device[] = [];
+
+function createTestInjector(): IInjector {
+	const injector = new Yok();
+	injector.register("previewDevicesService", PreviewDevicesService);
+	injector.register("logger", LoggerStub);
+	return injector;
+}
+
+function createDevice(id: string): Device {
+	return {
+		id,
+		platform: "ios",
+		model: "my test model",
+		name: "my test name",
+		osVersion: "10.0.0",
+		previewAppVersion: "19.0.0",
+		runtimeVersion: "5.0.0"
+	};
+}
+
+function resetDevices() {
+	foundDevices = [];
+	lostDevices = [];
+}
+
+describe("PreviewDevicesService", () => {
+	describe("onDevicesPresence", () => {
+		let previewDevicesService: IPreviewDevicesService = null;
+		beforeEach(() => {
+			const injector = createTestInjector();
+			previewDevicesService = injector.resolve("previewDevicesService");
+			previewDevicesService.on(DeviceDiscoveryEventNames.DEVICE_FOUND, device => {
+				foundDevices.push(device);
+			});
+			previewDevicesService.on(DeviceDiscoveryEventNames.DEVICE_LOST, device => {
+				lostDevices.push(device);
+			});
+		});
+
+		afterEach(() => {
+			previewDevicesService.removeAllListeners();
+			resetDevices();
+		});
+
+		it("should add new device", () => {
+			const device = createDevice("device1");
+
+			previewDevicesService.updateConnectedDevices([device]);
+
+			assert.deepEqual(previewDevicesService.getConnectedDevices(), [device]);
+			assert.deepEqual(foundDevices, [device]);
+			assert.deepEqual(lostDevices, []);
+		});
+		it("should add new device when there are already connected devices", () => {
+			const device1 = createDevice("device1");
+			const device2 = createDevice("device2");
+
+			previewDevicesService.updateConnectedDevices([device1]);
+			assert.deepEqual(previewDevicesService.getConnectedDevices(), [device1]);
+			assert.deepEqual(foundDevices, [device1]);
+			assert.deepEqual(lostDevices, []);
+			resetDevices();
+
+			previewDevicesService.updateConnectedDevices([device1, device2]);
+
+			assert.deepEqual(previewDevicesService.getConnectedDevices(), [device1, device2]);
+			assert.deepEqual(foundDevices, [device2]);
+			assert.deepEqual(lostDevices, []);
+		});
+		it("should add more than one new device", () => {
+			const device1 = createDevice("device1");
+			const device2 = createDevice("device2");
+			const device3 = createDevice("device3");
+
+			previewDevicesService.updateConnectedDevices([device1, device2, device3]);
+
+			assert.deepEqual(previewDevicesService.getConnectedDevices(), [device1, device2, device3]);
+			assert.deepEqual(foundDevices, [device1, device2, device3]);
+			assert.deepEqual(lostDevices, []);
+		});
+		it("should remove device", () => {
+			const device1 = createDevice("device1");
+			previewDevicesService.updateConnectedDevices([device1]);
+			assert.deepEqual(previewDevicesService.getConnectedDevices(), [device1]);
+			assert.deepEqual(foundDevices, [device1]);
+			assert.deepEqual(lostDevices, []);
+			resetDevices();
+
+			previewDevicesService.updateConnectedDevices([]);
+
+			assert.deepEqual(foundDevices, []);
+			assert.deepEqual(lostDevices, [device1]);
+		});
+		it("should add and remove devices in the same time", () => {
+			const device1 = createDevice("device1");
+			const device2 = createDevice("device2");
+
+			previewDevicesService.updateConnectedDevices([device1]);
+			assert.deepEqual(previewDevicesService.getConnectedDevices(), [device1]);
+			assert.deepEqual(foundDevices, [device1]);
+			assert.deepEqual(lostDevices, []);
+			resetDevices();
+
+			previewDevicesService.updateConnectedDevices([device2]);
+
+			assert.deepEqual(previewDevicesService.getConnectedDevices(), [device2]);
+			assert.deepEqual(foundDevices, [device2]);
+			assert.deepEqual(lostDevices, [device1]);
+		});
+	});
+});

test/services/preview-sdk-service.ts

@@ -8,7 +8,7 @@ const getPreviewSdkService = (): IPreviewSdkService => {
 	testInjector.register("logger", LoggerStub);
 	testInjector.register("config", {});
 	testInjector.register("previewSdkService", PreviewSdkService);
-
+	testInjector.register("previewDevicesService", {});
 	testInjector.register("httpClient", {
 		httpRequest: async (options: any, proxySettings?: IProxySettings): Promise<Server.IResponse> => undefined
 	});