extensionsToCheck) {
return new ResFolderInputPath(file, extensionsToCheck);
}
};
/**
* Sets the value of the "executable" attribute.
* @param executable the value.
*/
public void setExecutable(Path executable) {
mExecutable = TaskHelper.checkSinglePath("executable", executable);
}
/**
* Sets the value of the "command" attribute.
* @param command the value.
*/
public void setCommand(String command) {
mCommand = command;
}
/**
* Sets the value of the "force" attribute.
* @param force the value.
*/
public void setForce(boolean force) {
mForce = force;
}
/**
* Sets the value of the "verbose" attribute.
* @param verbose the value.
*/
public void setVerbose(boolean verbose) {
mVerbose = verbose;
}
/**
* Sets the value of the "usecrunchcache" attribute
* @param usecrunch whether to use the crunch cache.
*/
public void setNoCrunch(boolean nocrunch) {
mUseCrunchCache = nocrunch;
}
public void setNonConstantId(boolean nonConstantId) {
mNonConstantId = nonConstantId;
}
public void setVersioncode(String versionCode) {
if (versionCode.length() > 0) {
try {
mVersionCode = Integer.decode(versionCode);
} catch (NumberFormatException e) {
System.out.println(String.format(
"WARNING: Ignoring invalid version code value '%s'.", versionCode));
}
}
}
/**
* Sets the value of the "versionName" attribute
* @param versionName the value
*/
public void setVersionname(String versionName) {
mVersionName = versionName;
}
public void setDebug(boolean value) {
mDebug = value;
}
/**
* Sets the value of the "manifest" attribute.
* @param manifest the value.
*/
public void setManifest(Path manifest) {
mManifest = TaskHelper.checkSinglePath("manifest", manifest);
}
/**
* Sets a custom manifest package ID to be used during packaging.
* The manifest will be rewritten so that its package ID becomes the value given here.
* Relative class names in the manifest (e.g. ".Foo") will be rewritten to absolute names based
* on the existing package name, meaning that no code changes need to be made.
*
* @param packageName The package ID the APK should have.
*/
public void setManifestpackage(String packageName) {
if (packageName != null && packageName.length() != 0) {
mManifestPackage = packageName;
}
}
/**
* Sets the value of the "resources" attribute.
* @param resources the value.
*
* @deprecated Use nested element(s)
*/
@Deprecated
public void setResources(Path resources) {
System.out.println("WARNNG: Using deprecated 'resources' attribute in AaptExecLoopTask." +
"Use nested element(s) instead.");
if (mResources == null) {
mResources = new ArrayList();
}
mResources.add(new Path(getProject(), resources.toString()));
}
/**
* Sets the value of the "assets" attribute.
* @param assets the value.
*/
public void setAssets(Path assets) {
mAssets = TaskHelper.checkSinglePath("assets", assets);
}
/**
* Sets the value of the "androidjar" attribute.
* @param androidJar the value.
*/
public void setAndroidjar(Path androidJar) {
mAndroidJar = TaskHelper.checkSinglePath("androidjar", androidJar);
}
/**
* Sets the value of the "outfolder" attribute.
* @param outFolder the value.
* @deprecated use {@link #setApkfolder(Path)}
*/
@Deprecated
public void setOutfolder(Path outFolder) {
System.out.println("WARNNG: Using deprecated 'outfolder' attribute in AaptExecLoopTask." +
"Use 'apkfolder' (path) instead.");
mApkFolder = TaskHelper.checkSinglePath("outfolder", outFolder);
}
/**
* Sets the value of the "apkfolder" attribute.
* @param apkFolder the value.
*/
public void setApkfolder(Path apkFolder) {
mApkFolder = TaskHelper.checkSinglePath("apkfolder", apkFolder);
}
/**
* Sets the value of the resourcefilename attribute
* @param apkName the value
*/
public void setResourcefilename(String apkName) {
mApkName = apkName;
}
/**
* Sets the value of the "rfolder" attribute.
* @param rFolder the value.
*/
public void setRfolder(Path rFolder) {
mRFolder = TaskHelper.checkSinglePath("rfolder", rFolder);
}
public void setresourcefilter(String filter) {
if (filter != null && filter.length() > 0) {
mResourceFilter = filter;
}
}
/**
* Set the property name of the property that contains the list of res folder for
* Library Projects. This sets the name and not the value itself to handle the case where
* it doesn't exist.
* @param projectLibrariesResName
*/
public void setLibraryResFolderPathRefid(String libraryResFolderPathRefid) {
mLibraryResFolderPathRefid = libraryResFolderPathRefid;
}
public void setLibraryPackagesRefid(String libraryPackagesRefid) {
mLibraryPackagesRefid = libraryPackagesRefid;
}
/**
* Returns an object representing a nested nocompress element.
*/
public Object createNocompress() {
NoCompress nc = new NoCompress();
mNoCompressList.add(nc);
return nc;
}
/**
* Returns an object representing a nested res element.
*/
public Object createRes() {
if (mResources == null) {
mResources = new ArrayList();
}
Path path = new Path(getProject());
mResources.add(path);
return path;
}
/*
* (non-Javadoc)
*
* Executes the loop. Based on the values inside project.properties, this will
* create alternate temporary ap_ files.
*
* @see org.apache.tools.ant.Task#execute()
*/
@Override
public void execute() throws BuildException {
if (mLibraryResFolderPathRefid == null) {
throw new BuildException("Missing attribute libraryResFolderPathRefid");
}
if (mLibraryPackagesRefid == null) {
throw new BuildException("Missing attribute libraryPackagesRefid");
}
Project taskProject = getProject();
String libPkgProp = null;
// if the parameters indicate generation of the R class, check if
// more R classes need to be created for libraries, only if this project itself
// is not a library
if (mNonConstantId == false && mRFolder != null && new File(mRFolder).isDirectory()) {
libPkgProp = taskProject.getProperty(mLibraryPackagesRefid);
if (libPkgProp != null) {
// Replace ";" with ":" since that's what aapt expects
libPkgProp = libPkgProp.replace(';', ':');
}
}
// Call aapt. If there are libraries, we'll pass a non-null string of libs.
callAapt(libPkgProp);
}
@Override
protected String getExecTaskName() {
return "aapt";
}
/**
* Calls aapt with the given parameters.
* @param resourceFilter the resource configuration filter to pass to aapt (if configName is
* non null)
* @param extraPackages an optional list of colon-separated packages. Can be null
* Ex: com.foo.one:com.foo.two:com.foo.lib
*/
private void callAapt(String extraPackages) {
Project taskProject = getProject();
final boolean generateRClass = mRFolder != null && new File(mRFolder).isDirectory();
// Get whether we have libraries
Object libResRef = taskProject.getReference(mLibraryResFolderPathRefid);
// Set up our input paths that matter for dependency checks
ArrayList paths = new ArrayList();
// the project res folder is an input path of course
for (Path pathList : mResources) {
for (String path : pathList.list()) {
paths.add(new File(path));
}
}
// and if libraries exist, their res folders folders too.
if (libResRef instanceof Path) {
for (String path : ((Path)libResRef).list()) {
paths.add(new File(path));
}
}
// Now we figure out what we need to do
if (generateRClass) {
// in this case we only want to run aapt if an XML file was touched, or if any
// file is added/removed
List inputPaths = getInputPaths(paths, Collections.singleton("xml"),
sPathFactory);
// let's not forget the manifest as an input path (with no extension restrictions).
if (mManifest != null) {
inputPaths.add(new InputPath(new File(mManifest)));
}
// Check to see if our dependencies have changed. If not, then skip
if (initDependencies(mRFolder + File.separator + "R.java.d", inputPaths)
&& dependenciesHaveChanged() == false) {
System.out.println("No changed resources. R.java and Manifest.java untouched.");
return;
} else {
System.out.println("Generating resource IDs...");
}
} else {
// in this case we want to run aapt if any file was updated/removed/added in any of the
// input paths
List inputPaths = getInputPaths(paths, null /*extensionsToCheck*/,
sPathFactory);
// let's not forget the manifest as an input path.
if (mManifest != null) {
inputPaths.add(new InputPath(new File(mManifest)));
}
// If we're here to generate a .ap_ file we need to use assets as an input path as well.
if (mAssets != null) {
File assetsDir = new File(mAssets);
if (assetsDir.isDirectory()) {
inputPaths.add(new InputPath(assetsDir));
}
}
// Find our dependency file. It should have the same name as our target .ap_ but
// with a .d extension
String dependencyFilePath = mApkFolder + File.separator + mApkName;
dependencyFilePath += ".d";
// Check to see if our dependencies have changed
if (initDependencies(dependencyFilePath, inputPaths)
&& dependenciesHaveChanged() == false) {
System.out.println("No changed resources or assets. " + mApkName
+ " remains untouched");
return;
}
if (mResourceFilter == null) {
System.out.println("Creating full resource package...");
} else {
System.out.println(String.format(
"Creating resource package with filter: (%1$s)...",
mResourceFilter));
}
}
// create a task for the default apk.
ExecTask task = new ExecTask();
task.setExecutable(mExecutable);
task.setFailonerror(true);
task.setTaskName(getExecTaskName());
// aapt command. Only "package" is supported at this time really.
task.createArg().setValue(mCommand);
// No crunch flag
if (mUseCrunchCache) {
task.createArg().setValue("--no-crunch");
}
if (mNonConstantId) {
task.createArg().setValue("--non-constant-id");
}
// force flag
if (mForce) {
task.createArg().setValue("-f");
}
// verbose flag
if (mVerbose) {
task.createArg().setValue("-v");
}
if (mDebug) {
task.createArg().setValue("--debug-mode");
}
if (generateRClass) {
task.createArg().setValue("-m");
}
// filters if needed
if (mResourceFilter != null && mResourceFilter.length() > 0) {
task.createArg().setValue("-c");
task.createArg().setValue(mResourceFilter);
}
// no compress flag
// first look to see if there's a NoCompress object with no specified extension
boolean compressNothing = false;
for (NoCompress nc : mNoCompressList) {
if (nc.mExtension == null) {
task.createArg().setValue("-0");
task.createArg().setValue("");
compressNothing = true;
break;
}
}
if (compressNothing == false) {
for (NoCompress nc : mNoCompressList) {
task.createArg().setValue("-0");
task.createArg().setValue(nc.mExtension);
}
}
if (mNonConstantId == false && extraPackages != null && extraPackages.length() > 0) {
task.createArg().setValue("--extra-packages");
task.createArg().setValue(extraPackages);
}
// if the project contains libraries, force auto-add-overlay
if (libResRef != null) {
task.createArg().setValue("--auto-add-overlay");
}
if (mVersionCode != 0) {
task.createArg().setValue("--version-code");
task.createArg().setValue(Integer.toString(mVersionCode));
}
if (mVersionName != null && mVersionName.length() > 0) {
task.createArg().setValue("--version-name");
task.createArg().setValue(mVersionName);
}
// manifest location
if (mManifest != null && mManifest.length() > 0) {
task.createArg().setValue("-M");
task.createArg().setValue(mManifest);
}
// Rename manifest package
if (mManifestPackage != null) {
task.createArg().setValue("--rename-manifest-package");
task.createArg().setValue(mManifestPackage);
}
// resources locations.
if (mResources.size() > 0) {
for (Path pathList : mResources) {
for (String path : pathList.list()) {
// This may not exists, and aapt doesn't like it, so we check first.
File res = new File(path);
if (res.isDirectory()) {
task.createArg().setValue("-S");
task.createArg().setValue(path);
}
}
}
}
// add other resources coming from library project
if (libResRef instanceof Path) {
for (String path : ((Path)libResRef).list()) {
// This may not exists, and aapt doesn't like it, so we check first.
File res = new File(path);
if (res.isDirectory()) {
task.createArg().setValue("-S");
task.createArg().setValue(path);
}
}
}
// assets location. This may not exists, and aapt doesn't like it, so we check first.
if (mAssets != null && new File(mAssets).isDirectory()) {
task.createArg().setValue("-A");
task.createArg().setValue(mAssets);
}
// android.jar
if (mAndroidJar != null) {
task.createArg().setValue("-I");
task.createArg().setValue(mAndroidJar);
}
// apk file. This is based on the apkFolder, apkBaseName, and the configName (if applicable)
String filename = null;
if (mApkName != null) {
filename = mApkName;
}
if (filename != null) {
File file = new File(mApkFolder, filename);
task.createArg().setValue("-F");
task.createArg().setValue(file.getAbsolutePath());
}
// R class generation
if (generateRClass) {
task.createArg().setValue("-J");
task.createArg().setValue(mRFolder);
}
// Use dependency generation
task.createArg().setValue("--generate-dependencies");
// final setup of the task
task.setProject(taskProject);
task.setOwningTarget(getOwningTarget());
// execute it.
task.execute();
}
}