Android releated commands - platform add, prepare, build and platform list

lib/bootstrap.ts

@@ -3,8 +3,16 @@ require("./common/bootstrap");
 $injector.require("nativescript-cli", "./nativescript-cli");
 
 $injector.require("projectService", "./services/project-service");
+$injector.require("androidProjectService", "./services/project-service");
+$injector.require("iOSProjectService", "./services/project-service");
 $injector.require("projectTemplatesService", "./services/project-templates-service");
+$injector.require("platformService", "./services/platform-service");
 
 $injector.requireCommand("create", "./commands/create-project-command");
+$injector.requireCommand("platform|*list", "./commands/platform-command");
+$injector.requireCommand("platform|add", "./commands/platform-command");
+$injector.requireCommand("run", "./commands/run-command");
+$injector.requireCommand("prepare", "./commands/run-command");
+$injector.requireCommand("build", "./commands/run-command");
 
 $injector.require("npm", "./node-package-manager");

lib/commands/platform-command.ts

@@ -0,0 +1,29 @@
+///<reference path="../.d.ts"/>
+import helpers = require("./../common/helpers");
+
+export class ListPlatformsCommand implements ICommand {
+	constructor(private $platformService: IPlatformService,
+		private $logger: ILogger) { }
+
+	execute(args: string[]): IFuture<void> {
+		return (() => {
+			var availablePlatforms = this.$platformService.getAvailablePlatforms().wait();
+			this.$logger.out("Available platforms: %s", helpers.formatListOfNames(availablePlatforms));
+
+			var installedPlatforms = this.$platformService.getInstalledPlatforms().wait();
+			this.$logger.out("Installed platforms %s", helpers.formatListOfNames(installedPlatforms));
+		}).future<void>()();
+	}
+}
+$injector.registerCommand("platform|*list", ListPlatformsCommand);
+
+export class AddPlatformCommand implements ICommand {
+	constructor(private $platformService: IPlatformService) { }
+
+	execute(args: string[]): IFuture<void> {
+		return (() => {
+			this.$platformService.addPlatforms(args).wait();
+		}).future<void>()();
+	}
+}
+$injector.registerCommand("platform|add", AddPlatformCommand);

lib/commands/run-command.ts

@@ -0,0 +1,34 @@
+///<reference path="../.d.ts"/>
+
+export class RunCommand implements ICommand {
+	constructor(private $platformService: IPlatformService) { }
+
+	execute(args: string[]): IFuture<void> {
+		return (() => {
+			this.$platformService.runPlatform(args[0]).wait();
+		}).future<void>()();
+	}
+}
+$injector.registerCommand("run", RunCommand);
+
+export class PrepareCommand implements ICommand {
+	constructor(private $platformService: IPlatformService) { }
+
+	execute(args: string[]): IFuture<void> {
+		return (() => {
+			this.$platformService.preparePlatform(args[0]).wait();
+		}).future<void>()();
+	}
+}
+$injector.registerCommand("prepare", PrepareCommand);
+
+export class BuildCommand implements ICommand {
+	constructor(private $platformService: IPlatformService) { }
+
+	execute(args: string[]): IFuture<void> {
+		return (() => {
+			this.$platformService.buildPlatform(args[0]).wait();
+		}).future<void>()();
+	}
+}
+$injector.registerCommand("build", BuildCommand);

lib/definitions/platform.d.ts

@@ -0,0 +1,12 @@
+interface IPlatformService {
+	addPlatforms(platforms: string[]): IFuture<void>;
+	getInstalledPlatforms(): IFuture<string[]>;
+	getAvailablePlatforms(): IFuture<string[]>;
+	runPlatform(platform: string): IFuture<void>;
+	preparePlatform(platform: string): IFuture<void>;
+	buildPlatform(platform: string): IFuture<void>;
+}
+
+interface IPlatformCapabilities {
+	targetedOS?: string[];
+}

lib/definitions/project.d.ts

@@ -1,7 +1,31 @@
 interface IProjectService {
 	createProject(projectName: string, projectId: string): IFuture<void>;
+	createPlatformSpecificProject(platform: string): IFuture<void>;
+	prepareProject(platform: string): IFuture<void>;
+	buildProject(platform: string): IFuture<void>;
+	ensureProject(): void;
+	projectData: IProjectData;
+}
+
+interface IAndroidProjectService {
+	createProject(projectData: IProjectData): IFuture<void>;
+	prepareProject(projectData: IProjectData): IFuture<void>;
+	buildProject(projectData: IProjectData): IFuture<void>;
+}
+
+interface IiOSProjectService {
+	createProject(projectData: IProjectData): IFuture<void>;
+}
+
+interface IProjectData {
+	projectDir: string;
+	platformsDir: string;
+	projectFilePath: string;
+	projectId?: string;
+	projectName?: string;
 }
 
 interface IProjectTemplatesService {
 	defaultTemplatePath: IFuture<string>;
+	androidFrameworkPath: IFuture<string>;
 }

lib/definitions/shelljs.d.ts

@@ -2,4 +2,5 @@ declare module "shelljs" {
 	function cp(arg: string, sourcePath: string, destinationPath: string): void;
 	function sed(arg: string, oldValue: any, newValue: string, filePath: string): void;
 	function mv(source: string[], destination: string);
+	function grep(what: any, where: string): any;
 }

lib/nativescript-cli.ts

@@ -1,16 +1,16 @@
 ///<reference path=".d.ts"/>
+"use strict";
 
-import Fiber = require("fibers");
-import Future = require("fibers/future");
 import path = require("path");
 
+require("./common/extensions");
 require("./bootstrap");
 require("./options");
 
 import errors = require("./common/errors");
 errors.installUncaughtExceptionListener();
 
-$injector.register("config", {"CI_LOGGER": false});
+$injector.register("config", {"CI_LOGGER": false, PROJECT_FILE_NAME: ".tnsproject", "DEBUG": true});
 
 var dispatcher = $injector.resolve("dispatcher");
-dispatcher.runMainFiber();
+dispatcher.runMainFiber();

lib/node-package-manager.ts

@@ -33,4 +33,4 @@ export class NodePackageManager implements INodePackageManager {
 		return future;
 	}
 }
-$injector.register("npm", NodePackageManager);
+$injector.register("npm", NodePackageManager);

lib/services/platform-service.ts

@@ -0,0 +1,127 @@
+///<reference path="../.d.ts"/>
+
+import path = require("path");
+import helpers = require("./../common/helpers");
+
+export class PlatformService implements IPlatformService {
+	constructor(private $errors: IErrors,
+		private $fs: IFileSystem,
+		private $projectService: IProjectService) { }
+
+	private platformCapabilities: { [key: string]: IPlatformCapabilities } = {
+		ios: {
+			targetedOS: ['darwin']
+		},
+		android: {
+		}
+	};
+
+	public getCapabilities(platform: string): IPlatformCapabilities {
+		return this.platformCapabilities[platform];
+	}
+
+	public addPlatforms(platforms: string[]): IFuture<void> {
+		return (() => {
+			this.$projectService.ensureProject();
+
+			if(!platforms || platforms.length === 0) {
+				this.$errors.fail("No platform specified. Please specify a platform to add");
+			}
+
+			var platformsDir = this.$projectService.projectData.platformsDir;
+			if(!this.$fs.exists(platformsDir).wait()) {
+				this.$fs.createDirectory(platformsDir).wait();
+			}
+
+			_.each(platforms, platform => {
+				this.addPlatform(platform.toLowerCase()).wait();
+			});
+
+		}).future<void>()();
+	}
+
+	private addPlatform(platform: string): IFuture<void> {
+		return(() => {
+			platform = platform.split("@")[0];
+			var platformPath = path.join(this.$projectService.projectData.platformsDir, platform);
+
+			// TODO: Check for version compatability if the platform is in format platform@version. This should be done in PR for semanting versioning
+
+			this.validatePlatform(platform);
+
+			if (this.$fs.exists(platformPath).wait()) {
+				this.$errors.fail("Platform %s already added", platform);
+			}
+
+			// Copy platform specific files in platforms dir
+			this.$projectService.createPlatformSpecificProject(platform).wait();
+
+		}).future<void>()();
+	}
+
+	public getInstalledPlatforms(): IFuture<string[]> {
+		return(() => {
+			if(!this.$fs.exists(this.$projectService.projectData.platformsDir).wait()) {
+				return [];
+			}
+
+			var subDirs = this.$fs.readDirectory(this.$projectService.projectData.platformsDir).wait();
+			return _.filter(subDirs, p => { return Object.keys(this.platformCapabilities).indexOf(p) > -1; });
+		}).future<string[]>()();
+	}
+
+	public getAvailablePlatforms(): IFuture<string[]> {
+		return (() => {
+			var installedPlatforms = this.getInstalledPlatforms().wait();
+			return _.filter(_.keys(this.platformCapabilities), p => {
+				return installedPlatforms.indexOf(p) < 0 && this.isPlatformSupportedForOS(p); // Only those not already installed
+			});
+		}).future<string[]>()();
+	}
+
+	public runPlatform(platform: string): IFuture<void> {
+		return (() => {
+
+		}).future<void>()();
+	}
+
+	public preparePlatform(platform: string): IFuture<void> {
+		return (() => {
+			this.validatePlatform(platform);
+
+			this.$projectService.prepareProject(platform).wait();
+		}).future<void>()();
+	}
+
+	public buildPlatform(platform: string): IFuture<void> {
+		return (() => {
+			this.$projectService.buildProject(platform);
+		}).future<void>()();
+	}
+
+	private validatePlatform(platform): void {
+		if (!this.isValidPlatform(platform)) {
+			this.$errors.fail("Invalid platform %s. Valid platforms are %s.", platform, helpers.formatListOfNames(_.keys(this.platformCapabilities)));
+		}
+
+		if (!this.isPlatformSupportedForOS(platform)) {
+			this.$errors.fail("Applications for platform %s can not be built on this OS - %s", platform, process.platform);
+		}
+	}
+
+	private isValidPlatform(platform: string) {
+		return this.platformCapabilities[platform];
+	}
+
+	private isPlatformSupportedForOS(platform: string): boolean {
+		var platformCapabilities = this.getCapabilities(platform);
+		var targetedOS = platformCapabilities.targetedOS;
+
+		if(!targetedOS || targetedOS.indexOf("*") >= 0 || targetedOS.indexOf(process.platform) >= 0) {
+			return true;
+		}
+
+		return false;
+	}
+}
+$injector.register("platformService", PlatformService);