blob: f51a71a091ddaa88bfddaba3a832b10de2999a63 [file] [log] [blame]
// Copyright 2016 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// This file was auto-generated via go generate.
// DO NOT UPDATE MANUALLY
package main
const gradleInitScript = `// Copyright 2016 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
import groovy.json.*;
allprojects {
// Add the extract task only to the project in the current directory.
if (project.projectDir == gradle.startParameter.currentDir) {
task madbExtractVariantProperties << {
extract(project)
}
}
}
// Main driver of the property extraction script.
void extract(project) {
project = getApplicationModule(project)
if (project == null) {
def errMsg = 'The current project is not an Android application module, '
+ 'nor does it contain any application sub-modules. '
+ 'Please run the madb command from an Android application project directory.'
throw new GradleException(errMsg)
}
// Get the target variant.
def targetVariant = getTargetVariant(project)
// Collect the variant properties in a map, so that it can be printed out as a JSON.
def result = [
ProjectPath: project.path,
VariantName: targetVariant.name,
CleanTask: project.path + ":clean",
AssembleTask: targetVariant.assemble.path,
AppID: getApplicationId(targetVariant),
Activity: getMainActivity(project),
AbiFilters: getAbiFilters(targetVariant),
VariantOutputs: getVariantOutputs(targetVariant)
]
// Format the resulting map into JSON and print it.
def resultJson = JsonOutput.prettyPrint(JsonOutput.toJson(result))
printResult(project, resultJson)
}
// Prints the given result to the desired output stream.
// If the output file is specified, write the result to the file.
// Otherwise, print it out to the console.
void printResult(project, result) {
// An optional output file name can be specified by a Gradle command-line flag:
// -PmadbOutputFile=<file_name>
def output = project.properties.containsKey('madbOutputFile')
? new File(project.properties['madbOutputFile'])
: null
if (output != null) {
// Empty the file, and then print the result.
output.text = ''
output.append(result)
} else {
println result
}
}
// Returns an Android application module from the given project.
// The given project is returned immediately, if itself is an application module.
// Otherwise, the first available application sub-module is returned, if any.
// Returns null if no Android application modules were found from the given project.
Object getApplicationModule(project) {
if (isApplicationModule(project)) {
return project
}
def subApplicationModules = project.subprojects.findAll { isApplicationModule(it) }
if (subApplicationModules.isEmpty()) {
return null
}
def result = subApplicationModules.first()
if (subApplicationModules.size() > 1) {
print 'Multiple application sub-modules were detected. '
println 'The first application module "' + result.name + '" is chosen automatically.'
println '(NOTE: Application module can be explicitly specified using -module=<name> flag.)'
}
return result
}
// Returns true iff the given project is an Android application.
boolean isApplicationModule(project) {
return project.plugins.hasPlugin('com.android.application')
}
// Returns the target application variant for the project.
// If the 'madbVariant' property was explicitly set from the command line, the
// matching variant is returned.
// If there is no variant with the provided name, it throws an exception.
//
// If the 'madbVariant' property is not provided, the first available variant is
// returned. Usually the first available variant would be 'debug'.
Object getTargetVariant(project) {
def allVariants = project.android.applicationVariants
if (project.properties.containsKey('madbVariant')) {
def variantName = project.properties['madbVariant']
def targetVariant = allVariants.find { variantName.equalsIgnoreCase(it.name) }
if (targetVariant == null) {
throw new GradleException('Variant "' + variantName + '" is not found.')
}
return targetVariant
} else {
def targetVariant = allVariants.iterator().next()
print 'Build variant not specified. '
println 'The first variant "' + targetVariant.name + '" is chosen automatically.'
println '(NOTE: Variant can be explicitly specified using -variant=<name> flag.)'
return targetVariant
}
}
// Returns the application ID for the given variant.
String getApplicationId(variant) {
def suffix = variant.buildType.applicationIdSuffix
if (suffix == null) {
suffix = ""
}
return variant.mergedFlavor.applicationId + suffix
}
String getMainActivity(project) {
def manifestFile = getAndroidManifestLocation(project)
// Parse the xml file and find the main activity.
def manifest = new XmlSlurper().parse(manifestFile)
def mainActivity = manifest.application.activity.find { isMainActivity(it) }
def name = mainActivity.'@android:name'.text()
// If the activity name is using the shorthand syntax starting with a dot,
// make it a fully-qualified name by prepending it with the package name.
if (name.startsWith('.')) {
return manifest.'@package'.text() + name
} else {
return name
}
}
// Returns the location of the "AndroidManifest.xml" file.
// TODO(youngseokyoon): investigate whether we can obtain the merged manifest.
File getAndroidManifestLocation(project) {
try {
return project.android.sourceSets.main.manifest.srcFile
} catch (all) {
return null
}
}
// Determines whether the given activity is the main activity or not.
boolean isMainActivity(activity) {
try {
def intentFilter = activity.'intent-filter'
return intentFilter.action.'@android:name'.text() == 'android.intent.action.MAIN' &&
intentFilter.category.'@android:name'.text() == 'android.intent.category.LAUNCHER'
} catch (all) {
return false
}
}
// Returns the list of supported ABIs for the given variant.
// Returns null if there are no ABI filters specified.
Object getAbiFilters(variant) {
return variant.variantData.variantConfiguration.supportedAbis
}
// Gets the outputs and their properties of the given variant.
// The returned object is a list of variant outputs, each of which is a map containing the
// properties of a variant output, such as the absolute path of the .apk file, and its filters.
Object getVariantOutputs(variant) {
def variantOutputs = []
for (def variantOutput : variant.outputs) {
def filters = []
for (def filter : variantOutput.mainOutputFile.filters) {
filters.add([FilterType: filter.filterType, Identifier: filter.identifier])
}
def result = [
Name: variantOutput.name,
OutputFilePath: variantOutput.mainOutputFile.outputFile.absolutePath,
VersionCode: variantOutput.versionCode,
Filters: filters
]
variantOutputs.add(result)
}
return variantOutputs
}
`