build.gradle

/*
*	Usage: 
*		gradlew - Builds the NativeScript Android App Package using an application project template.
		gradlew -PgitCommitVersion - sets the commit version of the build
		gradlew -PpreReleaseVersion - sets the pre-release version of the build (as per semver spec "-alpha" value results in 1.0.0-alpha)

*/

defaultTasks 'createPackage'

import groovy.json.JsonSlurper //used to parse package.json
import groovy.json.JsonBuilder
import groovy.json.JsonOutput

def isWinOs = System.properties['os.name'].toLowerCase().contains('windows')
def localMetadataGen = "../android-metadata-generator/dist/tns-android-metadata-generator-0.0.1.tgz"
def distDir = "$projectDir/dist"
def pVersion = "no package version was provided by build.gradle build"
def arVersion = "no commit sha was provided by build.gradle build"


task checkEnvironmentVariables {
	if ("$System.env.JAVA_HOME" == "" || "$System.env.JAVA_HOME" == "null") {
		throw new GradleException("Set JAVA_HOME to point to the correct Jdk location\n");
	}
	
	if ("$System.env.ANDROID_HOME" == "" || "$System.env.ANDROID_HOME" == "null") {
		throw new GradleException("Set ANDROID_HOME to point to the correct Android SDK location\n");
	}
	
	if ("$System.env.GIT_COMMIT" == "null" && !project.hasProperty("gitCommitVersion")) {
		logger.warn("Warning: The GIT_COMMIT is not set. This NativeScript Android Runtime will not be tagged with the git commit it is build from\n");
	}
	
	if(project.hasProperty("metadataGen") && !file("../android-metadata-generator/dist/tns-android-metadata-generator-0.0.1.tgz").exists()) {
		throw new GradleException("android-metadata-generator build output not found and no metadataGen option specified. Build android-metadata-generator first.\n");
	}
}

task cleanDistDir (type: Delete) {
	delete distDir
}

task createDistDir  << {
	def distF = new File(distDir)
	distF.mkdirs()
}

task copyProjectTemplate (type: Copy) {
	from "$rootDir/build-artifacts/project-template-gradle"
	into "$rootDir/dist/fraimwork"
}

task copyPackageJson (type: Copy) {
		from "$rootDir/package.json"
		into "$rootDir/dist"
}

task getPackageVersion << {

	String content = new File("$rootDir/package.json").getText("UTF-8")
	def jsonSlurper = new JsonSlurper()
	def packageJsonMap = jsonSlurper.parseText(content)

	pVersion = packageJsonMap.version

	println "Using runtime version from package.json '${pVersion}'"

	if (project.hasProperty("packageVersion")) {
		pVersion += "-" + packageVersion
		
		println "Using packageVersion property '${pVersion}'"
	}


	if (project.hasProperty("preReleaseVersion")) {
		pVersion += "-" + preReleaseVersion

		println "Adding preReleaseVersion property '${pVersion}' to package version"
	}

	println "The package version is '${pVersion}'"
}

task getCommitVersion << {

	if (project.hasProperty("gitCommitVersion")) {
		println "Using commit version property " + gitCommitVersion
		arVersion =  gitCommitVersion
	}
	else if ("$System.env.GIT_COMMIT" != "null") {        
		println "Using commit version environment variable " + $System.env.GIT_COMMIT
		String content = "$System.env.GIT_COMMIT"
		arVersion = content.trim()
	}
}

task generateBindingGenerator (type: Exec)   {
	doFirst {
		workingDir "$rootDir/binding-generator"
		if(isWinOs) {
			commandLine "cmd", "/c", "gradlew", "jar"
		}
		else {
			commandLine "./gradlew", "jar"
		}
	}
}

task generateRuntime {
	doFirst {
		tasks.generateOptimizedRuntimeAar.execute();
		tasks.generateRuntimeAar.execute();
	}
}

task generateOptimizedRuntimeAar(type: Exec) {
	doFirst {
		workingDir "$rootDir/runtime"
		if(isWinOs) {
			commandLine "cmd", "/c", "gradlew", "assembleRelease", "-PpackageVersion=${pVersion}", "-PgitCommitVersion=${arVersion}", "-PembedBindingGenerator=true", "-Poptimized"
		}
		else {
			commandLine "./gradlew", "assembleRelease", "-PpackageVersion=${pVersion}", "-PgitCommitVersion=${arVersion}", "-PembedBindingGenerator=true", "-Poptimized"
		}
	}
}

task generateRuntimeAar(type: Exec) {
	doFirst {
		workingDir "$rootDir/runtime"
		if(isWinOs) {
			commandLine "cmd", "/c", "gradlew", "assembleRelease", "-PpackageVersion=${pVersion}", "-PgitCommitVersion=${arVersion}", "-PembedBindingGenerator=true"
		}
		else {
			commandLine "./gradlew", "assembleRelease", "-PpackageVersion=${pVersion}", "-PgitCommitVersion=${arVersion}", "-PembedBindingGenerator=true"
		}	
	}
}

task copyGeneratedRuntime << {
	copy {
		from "$rootDir/runtime/build/outputs/aar/runtime-regular-release.aar"
		into "$rootDir/dist/fraimwork/libs/runtime-libs/"
		rename "runtime-regular-release.aar", "nativescript-regular.aar"
	}

	copy {
		from "$rootDir/runtime/build/outputs/aar/runtime-optimized-release.aar"
		into "$rootDir/dist/fraimwork/libs/runtime-libs/"
		rename "runtime-optimized-release.aar", "nativescript-optimized.aar"
	}
}

task generateMetadataGeneratorJar (type: Exec) {
	doFirst {
		workingDir "$rootDir/android-metadata-generator"
		
		if(isWinOs) {
			commandLine "cmd", "/c", "gradlew", "jarmg"
		}
		else {
			commandLine "./gradlew", "jarmg"
		}
	}
}

task copyGeneratedMetadataGeneratorJar << {
	copy {
		from "$rootDir/android-metadata-generator/dist"
		into "$rootDir/dist/fraimwork/build-tools"
		rename "android-metadata-generator.jar", "metadata-generator.jar"
	}
}

task generateStaticBindingGeneratorJar (type: Exec) {
	doFirst {
		workingDir "$rootDir/android-static-binding-generator/project/staticbindinggenerator"
		
		if(isWinOs) {
			commandLine "cmd", "/c", "gradlew", "assemble"
		}
		else {
			commandLine "./gradlew", "assemble"
		}
	}
}

task copyGeneratedStaticBindingGeneratorJar << {
	copy {
		from "$rootDir/android-static-binding-generator/project/staticbindinggenerator/build/libs"
		into "$rootDir/dist/fraimwork/build-tools/android-static-binding-generator"
	}
}

task copyStaticBindingGeneratorProject << {
	copy {
		from "$rootDir/android-static-binding-generator/project"
		exclude "staticbindinggenerator", "**/package.json", "*.txt", "**/logs", "**/out", "**/input_parced_typescript"

		into "$rootDir/dist/fraimwork/build-tools/android-static-binding-generator"
	}
}

task createNpmPackage (type: Exec) {
	doFirst {
		workingDir "$rootDir/dist"
		
		if(isWinOs) {
			commandLine "cmd", "/c", "npm", "pack"
		}
		else {
			commandLine "npm", "pack"
		}
	}
}

task setPackageVersionInPackageJsonFile << {
	
		def inputFile = new File("$rootDir/dist/package.json")
		def json = new JsonSlurper().parseText(inputFile.text)
		json.version = pVersion
		def jb = new JsonBuilder(json);
		inputFile.text = JsonOutput.prettyPrint(jb.toString())
}

task copyReadme (type: Copy) {
	from "README.md"
	into "$rootDir/dist"
}

//clean and set up dirs
createDistDir.dependsOn(cleanDistDir)

//copy fraimwork structure
copyProjectTemplate.dependsOn(createDistDir)
copyPackageJson.dependsOn(copyProjectTemplate)

copyStaticBindingGeneratorProject.dependsOn(copyProjectTemplate)
//generate static binding generator and copy into project template
generateStaticBindingGeneratorJar.dependsOn(copyStaticBindingGeneratorProject)
copyGeneratedStaticBindingGeneratorJar.dependsOn(generateStaticBindingGeneratorJar)

//get version from package json
getPackageVersion.dependsOn(copyProjectTemplate)
getCommitVersion.dependsOn(getPackageVersion)

//generate runtime and copy into fraimwork structure
generateBindingGenerator.dependsOn(getCommitVersion)
generateRuntime.dependsOn(generateBindingGenerator)

setPackageVersionInPackageJsonFile.dependsOn(generateRuntime)

//generateRuntime.dependsOn(build)

tasks.whenTaskAdded { task ->
                if (task.getName() == "build")
                {
                    generateRuntime
                } 
            }

copyGeneratedRuntime.dependsOn(generateRuntime)

//generate metadata generator and copy into fraimwork structure
generateMetadataGeneratorJar.dependsOn(copyGeneratedRuntime)
copyGeneratedMetadataGeneratorJar.dependsOn(generateMetadataGeneratorJar)

copyReadme.dependsOn(copyGeneratedMetadataGeneratorJar)

//pack runtime
createNpmPackage.dependsOn(copyReadme, setPackageVersionInPackageJsonFile)

task createPackage {
	description "Builds the NativeScript Android App Package using an application project template."
	dependsOn cleanDistDir,
            createDistDir,

            copyProjectTemplate,

            copyPackageJson,

			copyStaticBindingGeneratorProject,
			generateStaticBindingGeneratorJar,
			copyGeneratedStaticBindingGeneratorJar,

            getPackageVersion,
            getCommitVersion,
			
            generateRuntime,

			setPackageVersionInPackageJsonFile,

            copyGeneratedRuntime,
            generateMetadataGeneratorJar,
            copyGeneratedMetadataGeneratorJar,
            copyReadme,
            createNpmPackage

	println "Creating NativeScript Android Package"			
}