Gradle support

Author: Fatme Havaluova

lib/services/android-project-service.ts

@@ -12,14 +12,12 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
 	private static MIN_SUPPORTED_VERSION = 17;
 	private SUPPORTED_TARGETS = ["android-17", "android-18", "android-19", "android-21", "android-22"]; // forbidden for now: "android-MNC"
 	private static ANDROID_TARGET_PREFIX = "android";
-	private static RES_DIRNAME = "res";
 	private static VALUES_DIRNAME = "values";
 	private static VALUES_VERSION_DIRNAME_PREFIX = AndroidProjectService.VALUES_DIRNAME + "-v";
 	private static ANDROID_PLATFORM_NAME = "android";
 	private static LIBS_FOLDER_NAME = "libs";
 	private static MIN_JAVA_VERSION = "1.7.0";
 
-	private targetApi: string;
 	private _androidProjectPropertiesManagers: IDictionary<IAndroidProjectPropertiesManager>;
 
 	constructor(private $androidEmulatorServices: Mobile.IEmulatorPlatformServices,
@@ -30,6 +28,7 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
 		private $logger: ILogger,
 		private $options: IOptions,
 		private $projectData: IProjectData,
+		private $projectDataService: IProjectDataService,
 		private $propertiesParser: IPropertiesParser,
 		private $sysInfo: ISysInfo,
 		$fs: IFileSystem) {
@@ -45,19 +44,21 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
 			this._platformData = {
 				frameworkPackageName: "tns-android",
 				normalizedPlatformName: "Android",
-				appDestinationDirectoryPath: path.join(projectRoot, "assets"),
-				appResourcesDestinationDirectoryPath: path.join(projectRoot, "res"),
+				appDestinationDirectoryPath: path.join(projectRoot, "src", "main", "assets"),
+				appResourcesDestinationDirectoryPath: path.join(projectRoot, "src", "main", "res"),
 				platformProjectService: this,
 				emulatorServices: this.$androidEmulatorServices,
 				projectRoot: projectRoot,
-				deviceBuildOutputPath: path.join(this.$projectData.platformsDir, "android", "bin"),
+				deviceBuildOutputPath: path.join(projectRoot, "build", "outputs", "apk"),
 				validPackageNamesForDevice: [
 					`${this.$projectData.projectName}-debug.apk`,
-					`${this.$projectData.projectName}-release.apk`
+					`${this.$projectData.projectName}-release.apk`,
+					"android-debug.apk",
+					"android-release.apk"
 				],
 				frameworkFilesExtensions: [".jar", ".dat", ".so"],
 				configurationFileName: "AndroidManifest.xml",
-				configurationFilePath: path.join(this.$projectData.platformsDir, "android", "AndroidManifest.xml"),
+				configurationFilePath: path.join(projectRoot, "src", "main", "AndroidManifest.xml"),
 				mergeXmlConfig: [{ "nodename": "manifest", "attrname": "*" }, {"nodename": "application", "attrname": "*"}]
 			};
 		}
@@ -80,38 +81,28 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
 		return (() => {
 			this.$fs.ensureDirectoryExists(projectRoot).wait();
 
-			let newTarget = this.getAndroidTarget(frameworkDir).wait();
+			let newTarget = this.getAndroidTarget().wait();
 			this.$logger.trace(`Using Android SDK '${newTarget}'.`);
 			let versionNumber = _.last(newTarget.split("-"));
 			if(this.$options.symlink) {
 				this.copyResValues(projectRoot, frameworkDir, versionNumber).wait();
-				this.copy(projectRoot, frameworkDir, ".project AndroidManifest.xml project.properties custom_rules.xml", "-f").wait();
+				this.copy(projectRoot, frameworkDir, "AndroidManifest.xml custom_rules.xml", "-f");
 
-				this.symlinkDirectory("assets", projectRoot, frameworkDir).wait();
+				this.symlinkDirectory("build-tools", projectRoot, frameworkDir).wait();
 				this.symlinkDirectory("libs", projectRoot, frameworkDir).wait();
+				this.symlinkDirectory("src", projectRoot, frameworkDir).wait();
 			} else {
 				this.copyResValues(projectRoot, frameworkDir, versionNumber).wait();
-				this.copy(projectRoot, frameworkDir, "assets libs", "-R").wait();
-				this.copy(projectRoot, frameworkDir, ".project AndroidManifest.xml project.properties custom_rules.xml", "-f").wait();
+				this.copy(projectRoot, frameworkDir, "build-tools libs src", "-R");
+				this.copy(projectRoot, frameworkDir, "build.gradle", "-f"); 
 			}
-
-			if(newTarget) {
-				this.updateTarget(projectRoot, newTarget).wait();
-			}
-
-			// Create src folder
-			let packageName = this.$projectData.projectId;
-			let packageAsPath = packageName.replace(/\./g, path.sep);
-			let activityDir = path.join(projectRoot, 'src', packageAsPath);
-			this.$fs.createDirectory(activityDir).wait();
-
 		}).future<any>()();
 	}
 
 	private copyResValues(projectRoot: string, frameworkDir: string, versionNumber: string): IFuture<void> {
 		return (() => {
-			let resSourceDir = path.join(frameworkDir, AndroidProjectService.RES_DIRNAME);
-			let resDestinationDir = path.join(projectRoot, AndroidProjectService.RES_DIRNAME);
+			let resSourceDir = path.join(frameworkDir, "src", "main", "res");
+			let resDestinationDir = this.platformData.appResourcesDestinationDirectoryPath;
 			this.$fs.createDirectory(resDestinationDir).wait();
 			let versionDirName = AndroidProjectService.VALUES_VERSION_DIRNAME_PREFIX + versionNumber;
 			let directoriesToCopy = [AndroidProjectService.VALUES_DIRNAME];
@@ -133,43 +124,38 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
 				directoriesToCopy.push(versionDir);
 			}
 
-			this.copy(resDestinationDir, resSourceDir, directoriesToCopy.join(" "), "-R").wait();
+			this.copy(resDestinationDir, resSourceDir, directoriesToCopy.join(" "), "-R");
 		}).future<void>()();
 	}
 
 	public interpolateData(projectRoot: string): IFuture<void> {
 		return (() => {
 			// Interpolate the activity name and package
-			let manifestPath = path.join(projectRoot, "AndroidManifest.xml");
+			let manifestPath = this.platformData.configurationFilePath;
 			shell.sed('-i', /__PACKAGE__/, this.$projectData.projectId, manifestPath);
-			shell.sed('-i', /__APILEVEL__/, this.getTarget(projectRoot).wait().split('-')[1], manifestPath);
+			shell.sed('-i', /__APILEVEL__/, this.getApiLevel().wait(), manifestPath);
 
-			let stringsFilePath = path.join(projectRoot, 'res', 'values', 'strings.xml');
+			let stringsFilePath = path.join(this.platformData.appResourcesDestinationDirectoryPath, 'values', 'strings.xml');
 			shell.sed('-i', /__NAME__/, this.$projectData.projectName, stringsFilePath);
 			shell.sed('-i', /__TITLE_ACTIVITY__/, this.$projectData.projectName, stringsFilePath);
-			shell.sed('-i', /__NAME__/, this.$projectData.projectName, path.join(projectRoot, '.project'));
 		}).future<void>()();
 	}
 
 	public afterCreateProject(projectRoot: string): IFuture<void> {
 		return (() => {
-			let targetApi = this.getTarget(projectRoot).wait();
-			this.$logger.trace("Android target: %s", targetApi);
-			this.runAndroidUpdate(projectRoot, targetApi).wait();
-			this.adjustMinSdk(projectRoot);
+			let targetApi = this.getAndroidTarget().wait();
+			this.$logger.trace(`Adroid target: ${targetApi}`);
+			this.adjustMinSdk(projectRoot).wait();
 		}).future<void>()();
 	}
 
-	private adjustMinSdk(projectRoot: string): void {
-		let manifestPath = path.join(projectRoot, "AndroidManifest.xml");
-		let apiLevel = this.getTarget(projectRoot).wait().split('-')[1];
-		if (apiLevel === "MNC") { // MNC SDK requires that minSdkVersion is set to "MNC"
-			shell.sed('-i', /android:minSdkVersion=".*?"/, `android:minSdkVersion="${apiLevel}"`, manifestPath);
-		}
-	}
-
-	public getDebugOnDeviceSetup(): Mobile.IDebugOnDeviceSetup {
-		return { };
+	private adjustMinSdk(projectRoot: string): IFuture<void> {
+		return (() => {
+			let apiLevel = this.getApiLevel().wait();
+			if (apiLevel === "MNC") { // MNC SDK requires that minSdkVersion is set to "MNC"
+				shell.sed('-i', /android:minSdkVersion=".*?"/, `android:minSdkVersion="${apiLevel}"`, this.platformData.configurationFilePath);
+			}
+		}).future<void>()();
 	}
 
 	public canUpdatePlatform(currentVersion: string, newVersion: string): IFuture<boolean> {
@@ -181,13 +167,29 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
 	}
 
 	public buildProject(projectRoot: string): IFuture<void> {
-		let buildConfiguration = this.$options.release ? "release" : "debug";
-		let args = this.getAntArgs(buildConfiguration, projectRoot);
-		return this.spawn('ant', args);
+		return (() => {
+			this.$projectDataService.initialize(this.$projectData.projectDir);
+			let frameworkVersion = this.$projectDataService.getValue(this.platformData.frameworkPackageName).wait().version;
+			if(semver.lt(frameworkVersion, "1.3.0")) {	
+				let args = this.getAntArgs(this.$options.release ? "release" : "debug", projectRoot);
+				this.spawn('ant', args).wait();
+			} else { // Gradle build
+				let buildOptions = ["buildapk"];
+				if(this.$options.release) {
+					buildOptions.push("-Prelease");
+					buildOptions.push(`-PksPath=${this.$options.keyStorePath}`);
+					buildOptions.push(`-PksPassword=${this.$options.keyStorePassword}`);
+					buildOptions.push(`-Palias=${this.$options.keyStoreAlias}`);
+					buildOptions.push(`-Ppass=${this.$options.keyStoreAliasPassword}`);
+				} 
+				
+				this.$childProcess.spawnFromEvent("gradle", buildOptions, "close", { stdio: "inherit", cwd: this.platformData.projectRoot }).wait();					
+			}
+		}).future<void>()();
 	}
 
 	public isPlatformPrepared(projectRoot: string): IFuture<boolean> {
-		return this.$fs.exists(path.join(projectRoot, "assets", constants.APP_FOLDER_NAME));
+		return this.$fs.exists(path.join(this.platformData.appDestinationDirectoryPath, constants.APP_FOLDER_NAME));
 	}
 
 	private getProjectPropertiesManager(filePath: string): IAndroidProjectPropertiesManager {
@@ -197,32 +199,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
 
 		return this._androidProjectPropertiesManagers[filePath];
 	}
-	
-	private parseProjectProperties(projDir: string, destDir: string): IFuture<void> { // projDir is libraryPath, targetPath is the path to lib folder
-		return (() => {
-			projDir = projDir.trim();
-			let projProp = path.join(projDir, "project.properties");
-			if (!this.$fs.exists(projProp).wait()) {
-				this.$logger.warn("Warning: File %s does not exist", projProp);
-				return;
-			}
-			
-			let projectPropertiesManager = this.getProjectPropertiesManager(projDir);
-			let references = projectPropertiesManager.getProjectReferences().wait();
-			_.each(references, reference => {
-				let adjustedPath = this.$fs.isRelativePath(reference.path) ? path.join(projDir, reference.path) : reference.path;
-				this.parseProjectProperties(adjustedPath, destDir).wait();
-			});
-	
-			this.$logger.info("Copying %s", projDir);
-			shell.cp("-Rf", projDir, destDir);
-	
-			let targetDir = path.join(destDir, path.basename(projDir));
-			let targetSdk = `android-${this.$options.sdk || AndroidProjectService.MIN_SUPPORTED_VERSION}`;
-			this.$logger.info("Generate build.xml for %s", targetDir);
-			this.runAndroidUpdate(targetDir, targetSdk).wait();
-		}).future<void>()();
-	}
 
 	public addLibrary(libraryPath: string): IFuture<void> {
 		return (() => {
@@ -232,20 +208,10 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
 			let targetPath = path.dirname(targetLibPath);
 			this.$fs.ensureDirectoryExists(targetPath).wait();
 
-			if(this.$fs.exists(path.join(libraryPath, "project.properties")).wait()) {
-				this.parseProjectProperties(libraryPath, targetPath).wait();
-			}
-
 			shell.cp("-f", path.join(libraryPath, "*.jar"), targetPath);
 			let projectLibsDir = path.join(this.platformData.projectRoot, "libs");
 			this.$fs.ensureDirectoryExists(projectLibsDir).wait();
 			shell.cp("-f", path.join(libraryPath, "*.jar"), projectLibsDir);
-
-			let libProjProp = path.join(libraryPath, "project.properties");
-			if (this.$fs.exists(libProjProp).wait()) {
-				this.updateProjectReferences(this.platformData.projectRoot, targetLibPath).wait();
-				this.runAndroidUpdate(targetLibPath, this.getTarget(this.platformData.projectRoot).wait()).wait();
-			}
 		}).future<void>()();
 	}
 
@@ -311,25 +277,16 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
 		 return path.join(this.$projectData.projectDir, "lib", this.platformData.normalizedPlatformName, libraryName);
 	}
 
-	private updateProjectReferences(projDir: string, libraryPath: string): IFuture<void> {
-		let relLibDir = this.getLibraryRelativePath(projDir, libraryPath);
-		
-		let projectPropertiesManager = this.getProjectPropertiesManager(projDir);		
-		return projectPropertiesManager.addProjectReference(relLibDir);
-	}
-	
 	private getAllLibrariesForPlugin(pluginData: IPluginData): IFuture<string[]> {
 		return (() => {
 			let filterCallback = (fileName: string, pluginPlatformsFolderPath: string) => fileName !== AndroidProjectService.LIBS_FOLDER_NAME && this.$fs.exists(path.join(pluginPlatformsFolderPath, fileName, "project.properties")).wait();
 			return this.getAllNativeLibrariesForPlugin(pluginData, AndroidProjectService.ANDROID_PLATFORM_NAME, filterCallback).wait();
 		}).future<string[]>()();
 	}
 
-	private copy(projectRoot: string, frameworkDir: string, files: string, cpArg: string): IFuture<void> {
-		return (() => {
-			let paths = files.split(' ').map(p => path.join(frameworkDir, p));
-			shell.cp(cpArg, paths, projectRoot);
-		}).future<void>()();
+	private copy(projectRoot: string, frameworkDir: string, files: string, cpArg: string): void {
+		let paths = files.split(' ').map(p => path.join(frameworkDir, p));
+		shell.cp(cpArg, paths, projectRoot);
 	}
 
 	private spawn(command: string, args: string[]): IFuture<void> {
@@ -367,16 +324,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
 		return args;
 	}
 
-	private runAndroidUpdate(projectPath: string, targetApi: string): IFuture<void> {
-		let args = [
-			"--path", projectPath,
-			"--target", targetApi,
-			"--name", this.$projectData.projectName
-		];
-
-		return this.spawn("android", ['update', 'project'].concat(args));
-	}
-
 	private validatePackageName(packageName: string): void {
 		//Make the package conform to Java package types
 		//Enforce underscore limitation
@@ -401,9 +348,9 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
 		}
 	}
 
-	private getAndroidTarget(frameworkDir: string): IFuture<string> {
+	private getAndroidTarget(): IFuture<string> {
 		return ((): string => { 
-			let newTarget = this.$options.sdk ? `${AndroidProjectService.ANDROID_TARGET_PREFIX}-${this.$options.sdk}` : this.getLatestValidAndroidTarget(frameworkDir).wait();
+			let newTarget = this.$options.sdk ? `${AndroidProjectService.ANDROID_TARGET_PREFIX}-${this.$options.sdk}` : this.getLatestValidAndroidTarget().wait();
 			if(!_.contains(this.SUPPORTED_TARGETS, newTarget)) {
 				let versionNumber = parseInt(_.last(newTarget.split("-")));
 				if(versionNumber && (versionNumber < AndroidProjectService.MIN_SUPPORTED_VERSION)) {
@@ -421,7 +368,7 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
 		}).future<string>()();
 	}
 
-	private getLatestValidAndroidTarget(frameworkDir: string): IFuture<string> {
+	private getLatestValidAndroidTarget(): IFuture<string> {
 		return (() => {
 			let installedTargets = this.getInstalledTargets().wait();
 
@@ -436,23 +383,11 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
 			return newTarget;
 		}).future<string>()();
 	}
-
-	private updateTarget(projectRoot: string, newTarget: string): IFuture<void> {
+	
+	private getApiLevel(): IFuture<string> {
 		return (() => {
-			let file = path.join(projectRoot, "project.properties");
-			let editor = this.$propertiesParser.createEditor(file).wait();
-			editor.set("target", newTarget);
-			let future = new Future<void>();
-			editor.save((err:any) => {
-				if (err) {
-					future.throw(err);
-				} else {
-					this.targetApi = null; // so that later we can repopulate the cache
-					future.return();
-				}
-			});
-			future.wait();
-		}).future<void>()();
+			return this.getAndroidTarget().wait().split('-')[1];
+		}).future<string>()();
 	}
 
 	private installedTargetsCache: string[] = null;
@@ -466,21 +401,6 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
 			return this.installedTargetsCache;
 		}).future<string[]>()();
 	}
-
-	private getTarget(projectRoot: string): IFuture<string> {
-		return (() => {
-			if(!this.targetApi) {
-				let projectPropertiesFilePath = path.join(projectRoot, "project.properties");
-
-				if (this.$fs.exists(projectPropertiesFilePath).wait()) {
-					let properties = this.$propertiesParser.createEditor(projectPropertiesFilePath).wait();
-					this.targetApi = properties.get("target");
-				}
-			}
-
-			return this.targetApi;
-		}).future<string>()();
-	}
 
 	private checkJava(): IFuture<void> {
 		return (() => {

test/stubs.ts

@@ -301,9 +301,6 @@ export class PlatformProjectServiceStub implements IPlatformProjectService {
     addLibrary(libraryPath: string): IFuture<void> {
         return Future.fromResult();
     }
-	getDebugOnDeviceSetup(): Mobile.IDebugOnDeviceSetup {
-		return null;
-	}
 	canUpdatePlatform(currentVersion: string, newVersion: string): IFuture<boolean> {
 		return Future.fromResult(false);
 	}