Integrate iOS simulator with device discovery

Author: Fatme Havaluova

lib/bootstrap.ts

@@ -25,8 +25,6 @@ $injector.require("analyticsSettingsService", "./services/analytics-settings-ser
 
 $injector.require("emulatorSettingsService", "./services/emulator-settings-service");
 
-$injector.require("usbLiveSyncService", "./services/usb-livesync-service");
-
 $injector.require("platformCommandParameter", "./platform-command-param");
 $injector.requireCommand("create", "./commands/create-project");
 $injector.requireCommand("platform|*list", "./commands/list-platforms");
@@ -64,6 +62,8 @@ $injector.require("commandsServiceProvider", "./providers/commands-service-provi
 $injector.require("deviceAppDataProvider", "./providers/device-app-data-provider");
 
 $injector.require("deviceLogProvider", "./common/mobile/device-log-provider");
+$injector.require("liveSyncProvider", "./providers/livesync-provider");
+$injector.require("projectFilesProvider", "./providers/project-files-provider");
 
 $injector.require("broccoliBuilder", "./tools/broccoli/builder");
 $injector.require("nodeModulesTree", "./tools/broccoli/trees/node-modules-tree");
@@ -80,12 +80,13 @@ $injector.requireCommand("install", "./commands/install");
 $injector.require("initService", "./services/init-service");
 $injector.requireCommand("init", "./commands/init");
 
-$injector.require("projectFilesManager", "./services/project-files-manager");
-$injector.requireCommand("livesync", "./commands/livesync");
 $injector.require("androidToolsInfo", "./android-tools-info");
 
-$injector.require("iosUsbLiveSyncServiceLocator", "./services/usb-livesync-service");
-$injector.require("androidUsbLiveSyncServiceLocator", "./services/usb-livesync-service");
+$injector.requireCommand("livesync", "./commands/livesync");
+$injector.require("usbLiveSyncService", "./services/livesync/livesync-service"); // The name is used in https://github.com/NativeScript/nativescript-dev-typescript
+$injector.require("iosLiveSyncServiceLocator", "./services/livesync/ios-livesync-service");
+$injector.require("androidLiveSyncServiceLocator", "./services/livesync/android-livesync-service");
+
 $injector.require("sysInfo", "./sys-info");
 
 $injector.require("iOSNotificationService", "./services/ios-notification-service");

lib/commands/livesync.ts

@@ -3,7 +3,7 @@
 
 export class LivesyncCommand implements ICommand {
 	constructor(private $logger: ILogger,
-		private $usbLiveSyncService: IUsbLiveSyncService,
+		private $usbLiveSyncService: ILiveSyncService,
 		private $mobileHelper: Mobile.IMobileHelper,
 		private $options: IOptions,
 		private $errors: IErrors) { }

lib/common

@@ -54,14 +54,10 @@ interface IOpener {
     open(target: string, appname: string): void;
 }
 
-interface IUsbLiveSyncService {
+interface ILiveSyncService {
 	liveSync(platform: string): IFuture<void>;
 }
 
-interface IiOSUsbLiveSyncService extends IPlatformSpecificUsbLiveSyncService {
-	sendPageReloadMessageToSimulator(): IFuture<void>;
-}
-
 interface IOptions extends ICommonOptions {
 	frameworkPath: string;
 	frameworkName: string;
@@ -90,10 +86,6 @@ interface IOptions extends ICommonOptions {
 	baseConfig: string;
 }
 
-interface IProjectFilesManager {
-	processPlatformSpecificFiles(directoryPath: string, platform: string, excludedDirs?: string[]): IFuture<void>;
-}
-
 interface IInitService {
 	initialize(): IFuture<void>;
 }

lib/declarations.ts

@@ -48,6 +48,7 @@ interface IPlatformProjectServiceBase {
 
 interface IBuildConfig {
 	runSbGenerator?: boolean;
+	buildForDevice?: boolean;
 }
 
 interface IPlatformProjectService {

lib/definitions/project.d.ts

@@ -2,7 +2,7 @@
 "use strict";
 
 import * as helpers from "../../common/helpers";
-import * as iOSProxyServices from "../../common/mobile/ios/ios-proxy-services";
+import * as iOSProxyServices from "../../common/mobile/ios/device/ios-proxy-services";
 
 export class IOSSocketRequestExecutor implements IiOSSocketRequestExecutor {
 	constructor(private $errors: IErrors,

lib/device-sockets/ios/socket-request-executor.ts

@@ -18,7 +18,7 @@ export class PlatformsData implements IPlatformsData {
 	}
 
 	public getPlatformData(platform: string): IPlatformData {
-		return this.platformsData[platform];
+		return this.platformsData[platform.toLowerCase()];
 	}
 
 	public get availablePlatforms(): any {

lib/platforms-data.ts

@@ -2,60 +2,63 @@
 "use strict";
 import * as deviceAppDataBaseLib from "../common/mobile/device-app-data/device-app-data-base";
 import Future = require("fibers/future");
+import * as path from "path";
 
 export class IOSAppIdentifier extends deviceAppDataBaseLib.DeviceAppDataBase implements Mobile.IDeviceAppData  {
-	private static DEVICE_PROJECT_ROOT_PATH = "Library/Application Support/LiveSync";
+	private static DEVICE_PROJECT_ROOT_PATH = "Library/Application Support/LiveSync/app";
+	private _deviceProjectRootPath: string = null;
 
-	constructor(_appIdentifier: string) {
+	constructor(_appIdentifier: string,
+		public device: Mobile.IDevice,
+		public platform: string,
+		private $iOSSimResolver: Mobile.IiOSSimResolver) {
 		super(_appIdentifier);
 	}
 
 	public get deviceProjectRootPath(): string {
-		return this.getDeviceProjectRootPath(IOSAppIdentifier.DEVICE_PROJECT_ROOT_PATH);
+		if (!this._deviceProjectRootPath) {
+			if (this.device.isEmulator) {
+				let applicationPath = this.$iOSSimResolver.iOSSim.getApplicationPath(this.device.deviceInfo.identifier, this.appIdentifier);
+				this._deviceProjectRootPath = path.join(applicationPath, "app");
+			} else {
+				this._deviceProjectRootPath = IOSAppIdentifier.DEVICE_PROJECT_ROOT_PATH;
+			}
+		}
+
+		return this.getDeviceProjectRootPath(this._deviceProjectRootPath);
 	}
 
-	public isLiveSyncSupported(device: Mobile.IDevice): IFuture<boolean> {
+	public isLiveSyncSupported(): IFuture<boolean> {
 		return Future.fromResult(true);
 	}
 }
 
 export class AndroidAppIdentifier extends deviceAppDataBaseLib.DeviceAppDataBase implements Mobile.IDeviceAppData {
-	constructor(_appIdentifier: string) {
+	constructor(_appIdentifier: string,
+		public device: Mobile.IDevice,
+		public platform: string,
+		private $options: IOptions) {
 		super(_appIdentifier);
 	}
 
 	public get deviceProjectRootPath(): string {
-		let options: IOptions = $injector.resolve("options");
-		let syncFolderName = options.watch ? "sync" : "fullsync";
+		let syncFolderName = this.$options.watch ? "sync" : "fullsync";
 		return `/data/local/tmp/${this.appIdentifier}/${syncFolderName}`;
 	}
 
-	public isLiveSyncSupported(device: Mobile.IDevice): IFuture<boolean> {
+	public isLiveSyncSupported(): IFuture<boolean> {
 		return Future.fromResult(true);
 	}
 }
 
-export class AndroidCompanionAppIdentifier extends deviceAppDataBaseLib.CompanionDeviceAppDataBase implements Mobile.IDeviceAppData {
-	private static APP_IDENTIFIER = "com.telerik.NativeScript";
-
-	constructor() {
-		super(AndroidCompanionAppIdentifier.APP_IDENTIFIER);
-	}
-
-	public get deviceProjectRootPath(): string {
-		return `/mnt/sdcard/Android/data/${this.appIdentifier}/files/12590FAA-5EDD-4B12-856D-F52A0A1599F2`;
-	}
-}
-
 export class DeviceAppDataProvider implements Mobile.IDeviceAppDataProvider {
 	public createFactoryRules(): IDictionary<Mobile.IDeviceAppDataFactoryRule> {
 		return {
 			iOS: {
 				vanilla: IOSAppIdentifier
 			},
 			Android: {
-				vanilla: AndroidAppIdentifier,
-				companion: AndroidCompanionAppIdentifier
+				vanilla: AndroidAppIdentifier
 			}
 		};
 	}

lib/providers/device-app-data-provider.ts

@@ -0,0 +1,50 @@
+///<reference path="../.d.ts"/>
+"use strict";
+
+import * as path from "path";
+
+export class LiveSyncProvider implements ILiveSyncProvider {
+	constructor(private $androidLiveSyncServiceLocator: {factory: Function},
+		private $iosLiveSyncServiceLocator: {factory: Function},
+		private $platformService: IPlatformService,
+		private $platformsData: IPlatformsData,
+		private $logger: ILogger) { }
+
+	private static FAST_SYNC_FILE_EXTENSIONS = [".css", ".xml"];
+
+	public get platformSpecificLiveSyncServices(): IDictionary<any> {
+		return {
+			android: (_device: Mobile.IDevice, $injector: IInjector): IPlatformLiveSyncService => {
+				return $injector.resolve(this.$androidLiveSyncServiceLocator.factory, {_device: _device});
+			},
+			ios: (_device: Mobile.IDevice, $injector: IInjector) => {
+				return $injector.resolve(this.$iosLiveSyncServiceLocator.factory, {_device: _device});
+			}
+		};
+	}
+
+	public buildForDevice(device: Mobile.IDevice): IFuture<string> {
+		return (() => {
+			this.$platformService.buildPlatform(device.deviceInfo.platform, {buildForDevice: !device.isEmulator}).wait();
+			let platformData = this.$platformsData.getPlatformData(device.deviceInfo.platform);
+			if (device.isEmulator) {
+				return this.$platformService.getLatestApplicationPackageForEmulator(platformData).wait().packageName;
+			}
+
+			return this.$platformService.getLatestApplicationPackageForDevice(platformData).wait().packageName;
+		}).future<string>()();
+	}
+
+	public preparePlatformForSync(platform: string): IFuture<void> {
+		return (() => {
+			if (!this.$platformService.preparePlatform(platform).wait()) {
+				this.$logger.out("Verify that listed files are well-formed and try again the operation.");
+			}
+		}).future<void>()();
+	}
+
+	public canExecuteFastSync(filePath: string): boolean {
+		return _.contains(LiveSyncProvider.FAST_SYNC_FILE_EXTENSIONS, path.extname(filePath));
+	}
+}
+$injector.register("liveSyncProvider", LiveSyncProvider);

lib/providers/livesync-provider.ts

@@ -0,0 +1,37 @@
+///<reference path="../.d.ts"/>
+"use strict";
+
+import minimatch = require("minimatch");
+import * as constants from "../constants";
+import * as path from "path";
+
+export class ProjectFilesProvider implements IProjectFilesProvider {
+	constructor(private $platformsData: IPlatformsData,
+		private $projectData: IProjectData) { }
+
+	private static INTERNAL_NONPROJECT_FILES = [ "**/*.ts" ];
+
+	public mapFilePath(filePath: string, platform: string): string {
+		let platformData = this.$platformsData.getPlatformData(platform.toLowerCase());
+		let projectFilesPath = path.join(platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME);
+		let mappedFilePath = path.join(projectFilesPath, path.relative(path.join(this.$projectData.projectDir, constants.APP_FOLDER_NAME), filePath));
+
+		let appResourcesDirectoryPath = path.join(constants.APP_FOLDER_NAME, constants.APP_RESOURCES_FOLDER_NAME);
+		let platformSpecificAppResourcesDirectoryPath = path.join(appResourcesDirectoryPath, platformData.normalizedPlatformName);
+		if (filePath.indexOf(appResourcesDirectoryPath) > -1 && filePath.indexOf(platformSpecificAppResourcesDirectoryPath) === -1) {
+			return null;
+		}
+		if (filePath.indexOf(platformSpecificAppResourcesDirectoryPath) > -1) {
+			let appResourcesRelativePath = path.relative(path.join(this.$projectData.projectDir, constants.APP_FOLDER_NAME, constants.APP_RESOURCES_FOLDER_NAME,
+				platformData.normalizedPlatformName), filePath);
+			mappedFilePath = path.join(platformData.platformProjectService.getAppResourcesDestinationDirectoryPath().wait(), appResourcesRelativePath);
+		}
+
+		return mappedFilePath;
+	}
+
+	public isFileExcluded(filePath: string): boolean {
+		return !!_.find(ProjectFilesProvider.INTERNAL_NONPROJECT_FILES, (pattern) => minimatch(filePath, pattern, { nocase: true }));
+	}
+}
+$injector.register("projectFilesProvider", ProjectFilesProvider);