com.jayway.maven.plugins.android.AbstractZipalignMojo Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of android-maven-plugin Show documentation
Show all versions of android-maven-plugin Show documentation
Maven Plugin for Android Development
package com.jayway.maven.plugins.android;
import com.jayway.maven.plugins.android.configuration.Zipalign;
import org.apache.maven.plugin.MojoExecutionException;
import static com.jayway.maven.plugins.android.common.AndroidExtension.APK;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
/**
* Implementation for the zipaplign goal. Implements parsing parameters from pom or command line arguments and sets
* useful defaults as well.
*
* @author Manfred Moser
*/
public abstract class AbstractZipalignMojo extends AbstractAndroidMojo {
/**
* The configuration for the zipalign goal. As soon as a zipalign goal is invoked the command will be executed
* unless the skip parameter is set. By default the input file is the apk produced by the build in target. The
* outputApk will use the postfix -aligned.apk. The following shows a default full configuration of the zipalign
* goal as an example for changes as plugin configuration.
*
* <zipalign>
* <skip>false</skip>
* <verbose>true</verbose>
* <inputApk>${project.build.directory}/${project.artifactId}.apk</inputApk>
* <outputApk>${project.build.directory}/${project.artifactId}-aligned.apk</outputApk>
* </zipalign>
*
*
* Values can also be configured as properties on the command line as android.zipalign.*
* or in pom or settings file as properties like zipalign.*.
* @parameter
*/
private Zipalign zipalign;
/**
* Skip the zipalign goal execution.
* @parameter expression="${android.zipalign.skip}"
* @see com.jayway.maven.plugins.android.configuration.Zipalign#skip
*/
private Boolean zipalignSkip;
/**
* Activate verbose output for the zipalign goal execution.
* @parameter expression="${android.zipalign.verbose}"
* @see com.jayway.maven.plugins.android.configuration.Zipalign#verbose
*/
private Boolean zipalignVerbose;
/**
* The apk file to be zipaligned. Per default the file is taken from build directory (target normally) using the
* build final name as file name and apk as extension.
*
* @parameter expression="${android.zipalign.inputApk}"
* @see com.jayway.maven.plugins.android.configuration.Zipalign#inputApk
*/
private String zipalignInputApk;
/**
* The apk file produced by the zipalign goal. Per default the file is placed into the build directory (target
* normally) using the build final name appended with "-aligned" as file name and apk as extension.
*
* @parameter expression="${android.zipalign.outputApk}"
* @see com.jayway.maven.plugins.android.configuration.Zipalign#outputApk
*/
private String zipalignOutputApk;
private Boolean parsedSkip;
private Boolean parsedVerbose;
private String parsedInputApk;
private String parsedOutputApk;
/**
* the apk file to be zipaligned.
*/
private File apkFile;
/**
* the output apk file for the zipalign process.
*/
private File alignedApkFile;
/**
* actually do the zipalign
*
* @throws MojoExecutionException
*/
protected void zipalign() throws MojoExecutionException {
// If we're not on a supported packaging with just skip (Issue 87)
// http://code.google.com/p/maven-android-plugin/issues/detail?id=87
if (! SUPPORTED_PACKAGING_TYPES.contains(project.getPackaging())) {
getLog().info("Skipping zipalign on " + project.getPackaging());
return;
}
parseParameters();
if (parsedSkip) {
getLog().info("Skipping zipalign");
} else {
CommandExecutor executor = CommandExecutor.Factory.createDefaultCommmandExecutor();
executor.setLogger(this.getLog());
String command = getAndroidSdk().getZipalignPath();
List parameters = new ArrayList();
if (parsedVerbose) {
parameters.add("-v");
}
parameters.add("-f"); // force overwriting existing output file
parameters.add("4"); // byte alignment has to be 4!
parameters.add(parsedInputApk);
parameters.add(parsedOutputApk);
try {
getLog().info("Running command: " + command);
getLog().info("with parameters: " + parameters);
executor.executeCommand(command, parameters);
// Attach the resulting artifact (Issue 88)
// http://code.google.com/p/maven-android-plugin/issues/detail?id=88
File aligned = new File(parsedOutputApk);
if (aligned.exists()) {
projectHelper.attachArtifact(project, APK, "aligned", aligned);
getLog().info("Attach " + aligned.getAbsolutePath() + " to the project");
} else {
getLog().error("Cannot attach " + aligned.getAbsolutePath() + " to the project" +
" - The file does not exist");
}
} catch (ExecutionException e) {
throw new MojoExecutionException("", e);
}
}
}
private void parseParameters() {
getLog().debug("Parsing parameters");
// exist in pom file
if (zipalign != null) {
// exists in pom file
if (zipalign.isSkip() != null) {
parsedSkip = zipalign.isSkip();
} else {
parsedSkip = determineSkip();
}
// exists in pom file
if (zipalign.isVerbose() != null) {
parsedVerbose = zipalign.isVerbose();
} else {
parsedVerbose = determineVerbose();
}
// exists in pom file
if (zipalign.getInputApk() != null) {
parsedInputApk = zipalign.getInputApk();
} else {
parsedInputApk = determineInputApk();
}
// exists in pom file
if (zipalign.getOutputApk() != null) {
parsedOutputApk = zipalign.getOutputApk();
} else {
parsedOutputApk = determineOutputApk();
}
}
// command line options
else {
parsedSkip = determineSkip();
parsedVerbose = determineVerbose();
parsedInputApk = determineInputApk();
parsedOutputApk = determineOutputApk();
}
getLog().debug("skip:" + parsedSkip);
getLog().debug("verbose:" + parsedVerbose);
getLog().debug("inputApk:" + parsedInputApk);
getLog().debug("outputApk:" + parsedOutputApk);
}
/**
* Get skip value for zipalign from command line option.
*
* @return if available return command line value otherwise return default false.
*/
private Boolean determineSkip() {
Boolean enabled;
if (zipalignSkip != null) {
enabled = zipalignSkip;
} else {
getLog().debug("Using default for zipalign.skip=false");
enabled = Boolean.FALSE;
}
return enabled;
}
/**
* Get verbose value for zipalign from command line option.
*
* @return if available return command line value otherwise return default false.
*/
private Boolean determineVerbose() {
Boolean enabled;
if (zipalignVerbose != null) {
enabled = zipalignVerbose;
} else {
getLog().debug("Using default for zipalign.verbose=false");
enabled = Boolean.FALSE;
}
return enabled;
}
/**
* Gets the apk file location from basedir/target/finalname.apk
*
* @return absolute path.
*/
private String getApkLocation() {
if (apkFile == null) apkFile = new File(project.getBuild().getDirectory(),
project.getBuild().getFinalName() + "." + APK);
return apkFile.getAbsolutePath();
}
/**
* Gets the apk file location from basedir/target/finalname-aligned.apk. "-aligned" is the inserted string for the
* output file.
*
* @return absolute path.
*/
private String getAlignedApkLocation() {
if (alignedApkFile == null) alignedApkFile = new File(project.getBuild().getDirectory(),
project.getBuild().getFinalName() + "-aligned." + APK);
return alignedApkFile.getAbsolutePath();
}
/**
* Get inputApk value for zipalign from command line option.
*
* @return if available return command line value otherwise return default.
*/
private String determineInputApk() {
String inputApk;
if (zipalignInputApk != null) {
inputApk = zipalignInputApk;
} else {
String inputPath = getApkLocation();
getLog().debug("Using default for zipalign.inputApk: " + inputPath);
inputApk = inputPath;
}
return inputApk;
}
/**
* Get outputApk value for zipalign from command line option.
*
* @return if available return command line value otherwise return default.
*/
private String determineOutputApk() {
String outputApk;
if (zipalignOutputApk != null) {
outputApk = zipalignOutputApk;
} else {
String outputPath = getAlignedApkLocation();
getLog().debug("Using default for zipalign.outputApk: " + outputPath);
outputApk = outputPath;
}
return outputApk;
}
}