chore: add preparePlatformService and remove platformJSService and platformNativeService

Author: Fatme

lib/bootstrap.ts

@@ -34,10 +34,9 @@ $injector.require("tnsModulesService", "./services/tns-modules-service");
 
 $injector.require("platformsData", "./platforms-data");
 $injector.require("platformService", "./services/platform-service");
-$injector.require("platformJSService", "./services/prepare-platform-js-service");
-$injector.require("platformNativeService", "./services/prepare-platform-native-service");
-$injector.require("platformAddService", "./services/platform/platform-add-service");
-$injector.require("platformBuildService", "./services/platform/platform-build-service");
+$injector.require("addPlatformService", "./services/platform/add-platform-service");
+$injector.require("buildPlatformService", "./services/platform/build-platform-service");
+$injector.require("preparePlatformService", "./services/platform/prepare-platform-service");
 $injector.require("platformValidationService", "./services/platform/platform-validation-service");
 $injector.require("platformCommandsService", "./services/platform/platform-commands-service");
 $injector.require("platformWatcherService", "./services/platform/platform-watcher-service");

lib/commands/appstore-upload.ts

@@ -14,7 +14,7 @@ export class PublishIOS implements ICommand {
 		private $prompter: IPrompter,
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		private $platformValidationService: IPlatformValidationService,
-		// private $platformBuildService: IPlatformBuildService,
+		// private $buildPlatformService: BuildPlatformService,
 		// private $xcodebuildService: IXcodebuildService
 		) {
 		this.$projectData.initializeProjectData();

lib/commands/deploy.ts

@@ -5,24 +5,23 @@ export class DeployOnDeviceCommand extends ValidatePlatformCommandBase implement
 	public allowedParameters: ICommandParameter[] = [];
 
 	constructor($platformValidationService: IPlatformValidationService,
-		private $platformService: IPlatformService,
 		private $platformCommandParameter: ICommandParameter,
 		$options: IOptions,
 		$projectData: IProjectData,
-		private $deployCommandHelper: IDeployCommandHelper,
 		private $errors: IErrors,
 		private $mobileHelper: Mobile.IMobileHelper,
 		$platformsData: IPlatformsData,
 		private $bundleValidatorHelper: IBundleValidatorHelper,
+		private $liveSyncCommandHelper: ILiveSyncCommandHelper,
 		private $androidBundleValidatorHelper: IAndroidBundleValidatorHelper) {
 			super($options, $platformsData, $platformValidationService, $projectData);
 			this.$projectData.initializeProjectData();
 	}
 
 	public async execute(args: string[]): Promise<void> {
-		const deployPlatformInfo = this.$deployCommandHelper.getDeployPlatformInfo(args[0]);
-
-		return this.$platformService.deployPlatform(deployPlatformInfo);
+		const platform = args[0].toLowerCase();
+		// TODO: Add a separate deployCommandHelper with base class for it and LiveSyncCommandHelper
+		await this.$liveSyncCommandHelper.executeCommandLiveSync(platform, <any>{ release: true });
 	}
 
 	public async canExecute(args: string[]): Promise<boolean | ICanExecuteCommandOutput> {

lib/commands/platform-clean.ts

@@ -1,12 +1,13 @@
+import { PlatformCommandsService } from "../services/platform/platform-commands-service";
+
 export class CleanCommand implements ICommand {
 	public allowedParameters: ICommandParameter[] = [];
 
 	constructor(
 		private $errors: IErrors,
 		private $options: IOptions,
-		private $platformCommandsService: IPlatformCommandsService,
+		private $platformCommandsService: PlatformCommandsService,
 		private $platformValidationService: IPlatformValidationService,
-		private $platformService: IPlatformService,
 		private $platformEnvironmentRequirements: IPlatformEnvironmentRequirements,
 		private $projectData: IProjectData
 	) {
@@ -29,7 +30,7 @@ export class CleanCommand implements ICommand {
 		for (const platform of args) {
 			this.$platformValidationService.validatePlatformInstalled(platform, this.$projectData);
 
-			const currentRuntimeVersion = this.$platformService.getCurrentPlatformVersion(platform, this.$projectData);
+			const currentRuntimeVersion = this.$platformCommandsService.getCurrentPlatformVersion(platform, this.$projectData);
 			await this.$platformEnvironmentRequirements.checkEnvironmentRequirements({
 				platform,
 				projectDir: this.$projectData.projectDir,

lib/declarations.d.ts

@@ -1030,6 +1030,7 @@ interface INetworkConnectivityValidator {
 interface IBundleWorkflowService {
 	preparePlatform(platform: string, projectDir: string, options: IOptions): Promise<void>;
 	buildPlatform(platform: string, projectDir: string, options: IOptions): Promise<string>;
+	deployPlatform(projectDir: string, deviceDescriptors: ILiveSyncDeviceInfo[], liveSyncInfo: ILiveSyncInfo): Promise<void>;
 	runPlatform(projectDir: string, deviceDescriptors: ILiveSyncDeviceInfo[], liveSyncInfo: ILiveSyncInfo): Promise<void>;
 }
 
@@ -1063,11 +1064,6 @@ interface IBuildArtefactsService {
 	getAllBuiltApplicationPackages(buildOutputPath: string, validBuildOutputData: IValidBuildOutputData): IApplicationPackage[];
 }
 
-interface IPlatformAddService {
-	addPlatform(projectData: IProjectData, addPlatformData: any): Promise<void>;
-	addPlatformIfNeeded(platformData: IPlatformData, projectData: IProjectData, addPlatformData: any): Promise<void>;
-}
-
 interface IPlatformCommandsService {
 	addPlatforms(platforms: string[], projectData: IProjectData, frameworkPath: string): Promise<void>;
 	cleanPlatforms(platforms: string[], projectData: IProjectData, framworkPath: string): Promise<void>;

lib/definitions/livesync.d.ts

@@ -143,6 +143,7 @@ declare global {
 	 */
 	interface ILiveSyncInfo extends IProjectDir, IRelease, IOptionalSkipWatcher, IHasUseHotModuleReloadOption, IHasSyncToPreviewAppOption {
 		webpackCompilerConfig: IWebpackCompilerConfig;
+		emulator?: boolean;
 
 		/**
 		 * Forces a build before the initial livesync.

lib/helpers/deploy-command-helper.ts

@@ -1,24 +1,26 @@
+import { BuildPlatformService } from "../services/platform/build-platform-service";
+
 // import { LiveSyncEvents } from "../constants";
 
 export class LiveSyncCommandHelper implements ILiveSyncCommandHelper {
 	public static MIN_SUPPORTED_WEBPACK_VERSION_WITH_HMR = "0.17.0";
 
-	constructor(private $platformService: IPlatformService,
+	constructor(
 		private $projectData: IProjectData,
 		private $options: IOptions,
 		private $bundleWorkflowService: IBundleWorkflowService,
-		// private $liveSyncService: ILiveSyncService,
 		private $iosDeviceOperations: IIOSDeviceOperations,
 		private $mobileHelper: Mobile.IMobileHelper,
 		private $devicesService: Mobile.IDevicesService,
 		private $platformsData: IPlatformsData,
+		private $buildPlatformService: BuildPlatformService,
 		private $analyticsService: IAnalyticsService,
 		private $bundleValidatorHelper: IBundleValidatorHelper,
 		private $errors: IErrors,
 		private $iOSSimulatorLogProvider: Mobile.IiOSSimulatorLogProvider,
 		private $logger: ILogger,
-		private $cleanupService: ICleanupService) {
-	}
+		private $cleanupService: ICleanupService
+	) { }
 
 	public getPlatformsForOperation(platform: string): string[] {
 		const availablePlatforms = platform ? [platform] : _.values<string>(this.$platformsData.availablePlatforms);
@@ -70,11 +72,6 @@ export class LiveSyncCommandHelper implements ILiveSyncCommandHelper {
 			}
 		}
 
-		if (this.$options.release) {
-			await this.runInReleaseMode(platform, additionalOptions);
-			return;
-		}
-
 		// Now let's take data for each device:
 		const deviceDescriptors: ILiveSyncDeviceInfo[] = devices
 			.map(d => {
@@ -95,7 +92,7 @@ export class LiveSyncCommandHelper implements ILiveSyncCommandHelper {
 
 				const buildAction = additionalOptions && additionalOptions.buildPlatform ?
 					additionalOptions.buildPlatform.bind(additionalOptions.buildPlatform, d.deviceInfo.platform, buildConfig, this.$projectData) :
-					this.$platformService.buildPlatform.bind(this.$platformService, d.deviceInfo.platform, buildConfig, this.$projectData);
+					this.$buildPlatformService.buildPlatform.bind(this.$buildPlatformService, d.deviceInfo.platform, buildConfig, this.$projectData);
 
 				const outputPath = additionalOptions && additionalOptions.getOutputDirectory && additionalOptions.getOutputDirectory({
 					platform: d.deviceInfo.platform,
@@ -125,9 +122,16 @@ export class LiveSyncCommandHelper implements ILiveSyncCommandHelper {
 			},
 			timeout: this.$options.timeout,
 			useHotModuleReload: this.$options.hmr,
-			force: this.$options.force
+			force: this.$options.force,
+			emulator: this.$options.emulator
 		};
 
+		// if (this.$options.release) {
+			// liveSyncInfo.skipWatcher = true;
+			// await this.$bundleWorkflowService.deployPlatform(this.$projectData.projectDir, deviceDescriptors, liveSyncInfo);
+			// return;
+		// }
+
 		await this.$bundleWorkflowService.runPlatform(this.$projectData.projectDir, deviceDescriptors, liveSyncInfo);
 
 		// const remainingDevicesToSync = devices.map(d => d.deviceInfo.identifier);
@@ -158,47 +162,6 @@ export class LiveSyncCommandHelper implements ILiveSyncCommandHelper {
 
 		return result;
 	}
-
-	private async runInReleaseMode(platform: string, additionalOptions?: ILiveSyncCommandHelperAdditionalOptions): Promise<void> {
-		const runPlatformOptions: IRunPlatformOptions = {
-			device: this.$options.device,
-			emulator: this.$options.emulator,
-			justlaunch: this.$options.justlaunch
-		};
-
-		const deployOptions = _.merge<IDeployPlatformOptions, IYargArgv>((<IDeployPlatformOptions>{
-			projectDir: this.$projectData.projectDir,
-			clean: true
-		}), this.$options.argv);
-
-		const availablePlatforms = this.getPlatformsForOperation(platform);
-		for (const currentPlatform of availablePlatforms) {
-			const deployPlatformInfo: IDeployPlatformInfo = {
-				platform: currentPlatform,
-				appFilesUpdaterOptions: {
-					bundle: !!this.$options.bundle,
-					release: this.$options.release,
-					useHotModuleReload: this.$options.hmr
-				},
-				deployOptions,
-				buildPlatform: this.$platformService.buildPlatform.bind(this.$platformService),
-				projectData: this.$projectData,
-				config: <any>this.$options,
-				env: this.$options.env
-			};
-
-			await this.$platformService.deployPlatform(deployPlatformInfo);
-
-			await this.$platformService.startApplication(
-				currentPlatform,
-				runPlatformOptions,
-				{
-					appId: this.$projectData.projectIdentifiers[currentPlatform.toLowerCase()],
-					projectName: this.$projectData.projectName
-				}
-			);
-		}
-	}
 }
 
 $injector.register("liveSyncCommandHelper", LiveSyncCommandHelper);

lib/helpers/livesync-command-helper.ts

@@ -4,11 +4,11 @@ import { getShortPluginName, hook } from "../common/helpers";
 import { Builder, parseString } from "xml2js";
 
 export class AndroidPluginBuildService implements IAndroidPluginBuildService {
-	private get $platformService(): IPlatformService {
-		return this.$injector.resolve("platformService");
+	private get $platformsData(): IPlatformsData {
+		return this.$injector.resolve("platformsData");
 	}
 
-	constructor(private $injector: IInjector,
+	constructor(
 		private $fs: IFileSystem,
 		private $childProcess: IChildProcess,
 		private $hostInfo: IHostInfo,
@@ -19,7 +19,9 @@ export class AndroidPluginBuildService implements IAndroidPluginBuildService {
 		private $devicePlatformsConstants: Mobile.IDevicePlatformsConstants,
 		private $errors: IErrors,
 		private $filesHashService: IFilesHashService,
-		public $hooksService: IHooksService) { }
+		public $hooksService: IHooksService,
+		private $injector: IInjector
+	) { }
 
 	private static MANIFEST_ROOT = {
 		$: {
@@ -290,10 +292,9 @@ export class AndroidPluginBuildService implements IAndroidPluginBuildService {
 	private async getRuntimeGradleVersions(projectDir: string): Promise<IRuntimeGradleVersions> {
 		let runtimeGradleVersions: IRuntimeGradleVersions = null;
 		if (projectDir) {
-			const projectRuntimeVersion = this.$platformService.getCurrentPlatformVersion(
-				this.$devicePlatformsConstants.Android,
-				this.$projectDataService.getProjectData(projectDir));
-			runtimeGradleVersions = await this.getGradleVersions(projectRuntimeVersion);
+			const projectData = this.$projectDataService.getProjectData(projectDir);
+			const platformData = this.$platformsData.getPlatformData(this.$devicePlatformsConstants.Android, projectData);
+			const projectRuntimeVersion = platformData.platformProjectService.getFrameworkVersion(projectData);
 			this.$logger.trace(`Got gradle versions ${JSON.stringify(runtimeGradleVersions)} from runtime v${projectRuntimeVersion}`);
 		}