/*
* ###
* Android Maven Plugin - android-maven-plugin
*
* Copyright (C) 1999 - 2012 Photon Infotech Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* ###
*/
/*
* Copyright (C) 2009 Jayway AB
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.photon.maven.plugins.android;
import static com.photon.maven.plugins.android.common.AndroidExtension.APK;
import static org.apache.commons.lang.StringUtils.isBlank;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import org.apache.commons.jxpath.JXPathContext;
import org.apache.commons.jxpath.JXPathNotFoundException;
import org.apache.commons.jxpath.xml.DocumentContainer;
import org.apache.commons.lang.StringUtils;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.MavenProjectHelper;
import org.codehaus.plexus.util.DirectoryScanner;
import org.sonatype.aether.RepositorySystem;
import org.sonatype.aether.RepositorySystemSession;
import org.sonatype.aether.repository.RemoteRepository;
import com.android.ddmlib.AndroidDebugBridge;
import com.android.ddmlib.IDevice;
import com.android.ddmlib.InstallException;
import com.photon.maven.plugins.android.common.AetherHelper;
import com.photon.maven.plugins.android.common.AndroidExtension;
import com.photon.maven.plugins.android.common.DeviceHelper;
import com.photon.maven.plugins.android.configuration.Sdk;
/**
* Contains common fields and methods for android mojos.
*
*/
public abstract class AbstractAndroidMojo extends AbstractMojo {
public static final List<String> SUPPORTED_PACKAGING_TYPES = new ArrayList<String>();
static {
SUPPORTED_PACKAGING_TYPES.add(AndroidExtension.APK);
SUPPORTED_PACKAGING_TYPES.add(AndroidExtension.APKPERF);
}
/** Android Debug Bridge initialisation timeout in milliseconds. */
private static final long ADB_TIMEOUT_MS = 60L * 1000;
/**
* The maven project.
*
* @parameter expression="${project}"
* @required
* @readonly
*/
protected MavenProject project;
/**
* The maven session.
*
* @parameter expression="${session}"
* @required
* @readonly
*/
protected MavenSession session;
/**
* The java sources directory.
*
* @parameter default-value="${project.build.sourceDirectory}"
*
* @readonly
*/
protected File sourceDirectory;
/**
* The android resources directory.
*
* @parameter default-value="${project.basedir}/source/res"
*/
protected File resourceDirectory;
/**
* <p>
* Root folder containing native libraries to include in the application
* package.
* </p>
*
* @parameter expression="${android.nativeLibrariesDirectory}"
* default-value="${project.basedir}/libs"
*/
protected File nativeLibrariesDirectory;
/**
* The android resources overlay directory. This will be overriden by
* resourceOverlayDirectories if present.
*
* @parameter default-value="${project.basedir}/res-overlay"
*/
protected File resourceOverlayDirectory;
/**
* The android resources overlay directories. If this is specified, the
* {@link #resourceOverlayDirectory} parameter will be ignored.
*
* @parameter
*/
protected File[] resourceOverlayDirectories;
/**
* The android assets directory.
*
* @parameter default-value="${project.basedir}/source/assets"
*/
protected File assetsDirectory;
/**
* The <code>AndroidManifest.xml</code> file.
*
* @parameter default-value="${project.basedir}/source/AndroidManifest.xml"
*/
protected File androidManifestFile;
/**
* @parameter expression=
* "${project.build.directory}/generated-sources/extracted-dependencies"
* @readonly
*/
protected File extractedDependenciesDirectory;
/**
* @parameter expression=
* "${project.build.directory}/generated-sources/extracted-dependencies/res"
* @readonly
*/
protected File extractedDependenciesRes;
/**
* @parameter expression=
* "${project.build.directory}/generated-sources/extracted-dependencies/assets"
* @readonly
*/
protected File extractedDependenciesAssets;
/**
* @parameter expression=
* "${project.build.directory}/generated-sources/extracted-dependencies/src/main/java"
* @readonly
*/
protected File extractedDependenciesJavaSources;
/**
* @parameter expression=
* "${project.build.directory}/generated-sources/extracted-dependencies/src/main/resources"
* @readonly
*/
protected File extractedDependenciesJavaResources;
/**
* The combined resources directory. This will contain both the resources
* found in "res" as well as any resources contained in a apksources
* dependency.
*
* @parameter expression=
* "${project.build.directory}/generated-sources/combined-resources/res"
* @readonly
*/
protected File combinedRes;
/**
* The combined assets directory. This will contain both the assets found in
* "assets" as well as any assets contained in a apksources dependency.
*
* @parameter expression=
* "${project.build.directory}/generated-sources/combined-assets/assets"
* @readonly
*/
protected File combinedAssets;
/**
* Extract the apklib dependencies here
*
* @parameter expression="${project.build.directory}/unpack/apklibs"
* @readonly
*/
protected File unpackedApkLibsDirectory;
/**
* Specifies which device to connect to, by serial number. Special values
* "usb" and "emulator" are also valid, for selecting the only USB connected
* device or the only running emulator, respectively.
*
* @parameter expression="${android.device}"
*/
protected String device;
/**
* A selection of configurations to be included in the APK as a comma
* separated list. This will limit the configurations for a certain type.
* For example, specifying <code>hdpi</code> will exclude all resource
* folders with the <code>mdpi</code> or <code>ldpi</code> modifiers, but
* won't affect language or orientation modifiers. For more information
* about this option, look in the aapt command line help.
*
* @parameter expression="${android.configurations}"
*/
protected String configurations;
/**
* A list of extra arguments that must be passed to aapt.
*
* @parameter expression="${android.aaptExtraArgs}"
*/
protected String[] aaptExtraArgs;
/**
* Decides whether the Apk should be generated or not. If set to false, dx
* and apkBuilder will not run. This is probably most useful for a project
* used to generate apk sources to be inherited into another application
* project.
*
* @parameter expression="${android.generateApk}" default-value="true"
*/
protected boolean generateApk;
/**
* The entry point to Aether, i.e. the component doing all the work.
*
* @component
*/
protected RepositorySystem repoSystem;
/**
* The current repository/network configuration of Maven.
*
* @parameter default-value="${repositorySystemSession}"
* @readonly
*/
protected RepositorySystemSession repoSession;
/**
* The project's remote repositories to use for the resolution of project
* dependencies.
*
* @parameter default-value="${project.remoteProjectRepositories}"
* @readonly
*/
protected List<RemoteRepository> projectRepos;
/**
* Generates R.java into a different package.
*
* @parameter expression="${android.customPackage}"
*/
protected String customPackage;
/**
* Maven ProjectHelper.
*
* @component
* @readonly
*/
protected MavenProjectHelper projectHelper;
/**
* <p>
* The Android SDK to use.
* </p>
* <p>
* Looks like this:
* </p>
*
* <pre>
* <sdk>
* <path>/opt/android-sdk-linux</path>
* <platform>2.1</platform>
* </sdk>
* </pre>
* <p>
* The <code><platform></code> parameter is optional, and corresponds
* to the <code>platforms/android-*</code> directories in the Android SDK
* directory. Default is the latest available version, so you only need to
* set it if you for example want to use platform 1.5 but also have e.g. 2.2
* installed. Has no effect when used on an Android SDK 1.1. The parameter
* can also be coded as the API level. Therefore valid values are 1.1, 1.5,
* 1.6, 2.0, 2.01, 2.1, 2,2 as well as 3, 4, 5, 6, 7, 8. If a platform/api
* level is not installed on the machine an error message will be produced.
* </p>
* <p>
* The <code><path></code> parameter is optional. The default is the
* setting of the ANDROID_HOME environment variable. The parameter can be
* used to override this setting with a different environment variable like
* this:
* </p>
*
* <pre>
* <sdk>
* <path>${env.ANDROID_SDK}</path>
* </sdk>
* </pre>
* <p>
* or just with a hardcoded absolute path. The parameters can also be
* configured from command-line with parameters
* <code>-Dandroid.sdk.path</code> and <code>-Dandroid.sdk.platform</code>.
* </p>
*
* @parameter
*/
private Sdk sdk;
/**
* <p>
* Parameter designed to pick up <code>-Dandroid.sdk.path</code> in case
* there is no pom with an <code><sdk></code> configuration tag.
* </p>
* <p>
* Corresponds to
* {@link com.photon.maven.plugins.android.configuration.Sdk#path}.
* </p>
*
* @parameter expression="${android.sdk.path}"
* @readonly
*/
private File sdkPath;
/**
* <p>
* Parameter designed to pick up environment variable
* <code>ANDROID_HOME</code> in case <code>android.sdk.path</code> is not
* configured.
* </p>
*
* @parameter expression="${env.ANDROID_HOME}"
* @readonly
*/
private String envANDROID_HOME;
/**
* The <code>ANDROID_HOME</code> environment variable name.
*/
public static final String ENV_ANDROID_HOME = "ANDROID_HOME";
/**
* <p>
* Parameter designed to pick up <code>-Dandroid.sdk.platform</code> in case
* there is no pom with an <code><sdk></code> configuration tag.
* </p>
* <p>
* Corresponds to
* {@link com.photon.maven.plugins.android.configuration.Sdk#platform}.
* </p>
*
* @parameter expression="${android.sdk.platform}"
* @readonly
*/
private String sdkPlatform;
/**
* <p>
* Whether to undeploy an apk from the device before deploying it.
* </p>
* <p/>
* <p>
* Only has effect when running <code>mvn android:deploy</code> in an
* Android application project manually, or when running
* <code>mvn integration-test</code> (or <code>mvn install</code>) in a
* project with instrumentation tests.
* </p>
* <p/>
* <p>
* It is useful to keep this set to <code>true</code> at all times, because
* if an apk with the same package was previously signed with a different
* keystore, and deployed to the device, deployment will fail becuase your
* keystore is different.
* </p>
*
* @parameter default-value=false
* expression="${android.undeployBeforeDeploy}"
*/
protected boolean undeployBeforeDeploy;
/**
* <p>
* Whether to attach the normal .jar file to the build, so it can be
* depended on by for example integration-tests which may then access
* {@code R.java} from this project.
* </p>
* <p>
* Only disable it if you know you won't need it for any integration-tests.
* Otherwise, leave it enabled.
* </p>
*
* @parameter default-value=true expression="${android.attachJar}"
*/
protected boolean attachJar;
/**
* <p>
* Whether to attach sources to the build, which can be depended on by other
* {@code apk} projects, for including them in their builds.
* </p>
* <p>
* Enabling this setting is only required if this project's source code
* and/or res(ources) will be included in other projects, using the Maven
* <dependency> tag.
* </p>
*
* @parameter default-value=false expression="${android.attachSources}"
*/
protected boolean attachSources;
/**
* @parameter expression="${project.basedir}" required="true"
* @readonly
*/
protected File baseDir;
/**
* @parameter expression="${environmentName}" required="true"
*/
protected String environmentName;
private static final Object ADBLOCK = new Object();
private static boolean adbInitialized = false;
private String[] deviceSerialNumberArr = null;
/**
* Which dependency scopes should not be included when unpacking
* dependencies into the apk.
*/
/*
* protected static final List<String> EXCLUDED_DEPENDENCY_SCOPES = Arrays
* .asList("provided", "system", "import");
*/
protected static final List<String> EXCLUDED_DEPENDENCY_SCOPES = Arrays
.asList("provided", "import");
/**
* @return a {@code Set} of dependencies which may be extracted and
* otherwise included in other artifacts. Never {@code null}. This
* excludes artifacts of the {@code EXCLUDED_DEPENDENCY_SCOPES}
* scopes.
*/
protected Set<Artifact> getRelevantCompileArtifacts() {
final List<Artifact> allArtifacts = project.getCompileArtifacts();
final Set<Artifact> results = filterOutIrrelevantArtifacts(allArtifacts);
return results;
}
/**
* @return a {@code Set} of direct project dependencies. Never {@code null}.
* This excludes artifacts of the {@code EXCLUDED_DEPENDENCY_SCOPES}
* scopes.
*/
protected Set<Artifact> getRelevantDependencyArtifacts() {
final Set<Artifact> allArtifacts = project.getDependencyArtifacts();
final Set<Artifact> results = filterOutIrrelevantArtifacts(allArtifacts);
return results;
}
/**
* @return a {@code List} of all project dependencies. Never {@code null}.
* This excludes artifacts of the {@code EXCLUDED_DEPENDENCY_SCOPES}
* scopes. And This should maintain dependency order to comply with
* library project resource precedence.
*/
protected Set<Artifact> getAllRelevantDependencyArtifacts() {
final Set<Artifact> allArtifacts = project.getArtifacts();
final Set<Artifact> results = filterOutIrrelevantArtifacts(allArtifacts);
return results;
}
private Set<Artifact> filterOutIrrelevantArtifacts(
Iterable<Artifact> allArtifacts) {
final Set<Artifact> results = new LinkedHashSet<Artifact>();
for (Artifact artifact : allArtifacts) {
if (artifact == null) {
continue;
}
if (EXCLUDED_DEPENDENCY_SCOPES.contains(artifact.getScope())) {
continue;
}
if ("apk".equalsIgnoreCase(artifact.getType())) {
continue;
}
results.add(artifact);
}
return results;
}
/**
* Attempts to resolve an {@link Artifact} to a {@link File}.
*
* @param artifact
* to resolve
* @return a {@link File} to the resolved artifact, never <code>null</code>.
* @throws MojoExecutionException
* if the artifact could not be resolved.
*/
protected File resolveArtifactToFile(Artifact artifact)
throws MojoExecutionException {
Artifact resolvedArtifact = AetherHelper.resolveArtifact(artifact,
repoSystem, repoSession, projectRepos);
final File jar = resolvedArtifact.getFile();
if (jar == null) {
throw new MojoExecutionException(
"Could not resolve artifact "
+ artifact.getId()
+ ". Please install it with \"mvn install:install-file ...\" or deploy it to a repository with \"mvn deploy:deploy-file ...\"");
}
return jar;
}
/**
* Initialize the Android Debug Bridge and wait for it to start. Does not
* reinitialize it if it has already been initialized (that would through
* and IllegalStateException...). Synchronized sine the init call in the
* library is also synchronized .. just in case.
*
* @return
*/
protected AndroidDebugBridge initAndroidDebugBridge()
throws MojoExecutionException {
synchronized (ADBLOCK) {
if (!adbInitialized) {
AndroidDebugBridge.init(false);
adbInitialized = true;
}
AndroidDebugBridge androidDebugBridge = AndroidDebugBridge
.createBridge(getAndroidSdk().getAdbPath(), false);
waitUntilConnected(androidDebugBridge);
return androidDebugBridge;
}
}
/**
* Run a wait loop until adb is connected or trials run out. This method
* seems to work more reliably then using a listener.
*
* @param adb
*/
private void waitUntilConnected(AndroidDebugBridge adb) {
int trials = 10;
while (trials > 0) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (adb.isConnected()) {
break;
}
trials--;
}
}
/**
* Wait for the Android Debug Bridge to return an initial device list.
*
* @param androidDebugBridge
* @throws MojoExecutionException
*/
protected void waitForInitialDeviceList(
final AndroidDebugBridge androidDebugBridge)
throws MojoExecutionException {
if (!androidDebugBridge.hasInitialDeviceList()) {
getLog().info(
"Waiting for initial device list from the Android Debug Bridge");
long limitTime = System.currentTimeMillis() + ADB_TIMEOUT_MS;
while (!androidDebugBridge.hasInitialDeviceList()
&& (System.currentTimeMillis() < limitTime)) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new MojoExecutionException(
"Interrupted waiting for initial device list from Android Debug Bridge");
}
}
if (!androidDebugBridge.hasInitialDeviceList()) {
getLog().error(
"Did not receive initial device list from the Android Debug Bridge.");
}
}
}
/**
* Deploys an apk file to a connected emulator or usb device.
*
* @param apkFile
* the file to deploy
* @throws MojoExecutionException
* If there is a problem deploying the apk file.
*/
protected void deployApk(final File apkFile) throws MojoExecutionException,
MojoFailureException {
if (undeployBeforeDeploy) {
undeployApk(apkFile);
}
doWithDevices(new DeviceCallback() {
@Override
public void doWithDevice(final IDevice device)
throws MojoExecutionException {
try {
device.installPackage(apkFile.getAbsolutePath(), true);
getLog().info(
"Successfully installed "
+ apkFile.getAbsolutePath() + " to "
+ DeviceHelper.getDescriptiveName(device));
} catch (InstallException e) {
throw new MojoExecutionException("Install of "
+ apkFile.getAbsolutePath() + "failed.", e);
}
}
});
}
protected void deployDependencies() throws MojoExecutionException,
MojoFailureException {
Set<Artifact> directDependentArtifacts = project
.getDependencyArtifacts();
if (directDependentArtifacts != null) {
for (Artifact artifact : directDependentArtifacts) {
String type = artifact.getType();
if (type.equals(APK)) {
getLog().debug(
"Detected apk dependency " + artifact
+ ". Will resolve and deploy to device...");
final File targetApkFile = resolveArtifactToFile(artifact);
/*
* if (undeployBeforeDeploy) { getLog().debug(
* "Attempting undeploy of " + targetApkFile +
* " from device..."); undeployApk(targetApkFile); }
*/
getLog().debug(
"Deploying " + targetApkFile + " to device...");
deployApk(targetApkFile);
}
}
}
}
protected void deployBuiltApk() throws MojoExecutionException,
MojoFailureException {
// If we're not on a supported packaging with just skip (Issue 112)
// http://code.google.com/p/maven-android-plugin/issues/detail?id=112
if (!SUPPORTED_PACKAGING_TYPES.contains(project.getPackaging())) {
getLog().info("Skipping deployment on " + project.getPackaging());
return;
}
File apkFile = new File(project.getBuild().getDirectory(), project
.getBuild().getFinalName() + "." + APK);
deployApk(apkFile);
}
/**
* Determines which {@link IDevice}(s) to use, and performs the callback
* action on it/them.
*
* @param deviceCallback
* the action to perform on each device
* @throws org.apache.maven.plugin.MojoExecutionException
* in case there is a problem
* @throws org.apache.maven.plugin.MojoFailureException
* in case there is a problem
*/
protected void doWithDevices(final DeviceCallback deviceCallback)
throws MojoExecutionException, MojoFailureException {
final AndroidDebugBridge androidDebugBridge = initAndroidDebugBridge();
if (androidDebugBridge.isConnected()) {
waitForInitialDeviceList(androidDebugBridge);
List<IDevice> devices = Arrays.asList(androidDebugBridge
.getDevices());
int numberOfDevices = devices.size();
getLog().info(
"Found "
+ numberOfDevices
+ " devices connected with the Android Debug Bridge");
if (devices.size() > 0) {
if (StringUtils.isNotBlank(device)) {
boolean deviceFound = false;
if ("emulator".equals(device) || ("usb".equals(device))) {
getLog().info(
"android.device parameter set to " + device);
for (IDevice idevice : devices) {
// use specified device or all emulators or all
// devices
if ("emulator".equals(device)
&& idevice.isEmulator()) {
getLog().info(
"Emulator "
+ DeviceHelper
.getDescriptiveName(idevice)
+ " found.");
deviceFound = true;
deviceCallback.doWithDevice(idevice);
} else if ("usb".equals(device)
&& !idevice.isEmulator()) {
getLog().info(
"Device "
+ DeviceHelper
.getDescriptiveName(idevice)
+ " found.");
deviceFound = true;
deviceCallback.doWithDevice(idevice);
}
}
} else {
getLog().info(
"android.device parameter set to serial number: " + device);
if (StringUtils.indexOf(device, ",") > -1) {
deviceSerialNumberArr = device.trim().split(",");
for (final IDevice idevice : devices) {
for (int i = 0; i < deviceSerialNumberArr.length; i++) {
if (idevice.isEmulator()
&& (deviceSerialNumberArr[i]
.equalsIgnoreCase(idevice
.getAvdName()) || deviceSerialNumberArr[i]
.equalsIgnoreCase(idevice
.getSerialNumber()))) {
getLog().info(
"Emulator "
+ DeviceHelper
.getDescriptiveName(idevice)
+ " found.");
deviceFound = true;
deviceCallback.doWithDevice(idevice);
break;
} else if (!idevice.isEmulator()
&& deviceSerialNumberArr[i]
.equals(idevice
.getSerialNumber())) {
getLog().info(
"Device "
+ DeviceHelper
.getDescriptiveName(idevice)
+ " found.");
deviceFound = true;
deviceCallback.doWithDevice(idevice);
break;
}
}
}
} else {
deviceSerialNumberArr = new String[1];
deviceSerialNumberArr[0] = device.trim();
for (final IDevice idevice : devices) {
for (int i = 0; i < deviceSerialNumberArr.length; i++) {
if (idevice.isEmulator()
&& (deviceSerialNumberArr[i]
.equalsIgnoreCase(idevice
.getAvdName()) || deviceSerialNumberArr[i]
.equalsIgnoreCase(idevice
.getSerialNumber()))) {
getLog().info(
"Emulator "
+ DeviceHelper
.getDescriptiveName(idevice)
+ " found.");
deviceFound = true;
deviceCallback.doWithDevice(idevice);
break;
} else if (!idevice.isEmulator()
&& deviceSerialNumberArr[i]
.equals(idevice
.getSerialNumber())) {
getLog().info(
"Device "
+ DeviceHelper
.getDescriptiveName(idevice)
+ " found.");
deviceFound = true;
deviceCallback.doWithDevice(idevice);
break;
}
}
}
}
}
if (!deviceFound) {
throw new MojoExecutionException(
"No device found for android.device=" + device);
}
} else {
getLog().info(
"android.device parameter not set, using all attached devices");
for (IDevice idevice : devices) {
deviceCallback.doWithDevice(idevice);
}
}
} else {
throw new MojoExecutionException("No online devices attached.");
}
} else {
throw new MojoExecutionException(
"Android Debug Bridge is not connected.");
}
}
/**
* Undeploys an apk from a connected emulator or usb device. Also deletes
* the application's data and cache directories on the device.
*
* @param apkFile
* the file to undeploy
* @return <code>true</code> if successfully undeployed, <code>false</code>
* otherwise.
*/
protected boolean undeployApk(File apkFile) throws MojoExecutionException,
MojoFailureException {
final String packageName;
packageName = extractPackageNameFromApk(apkFile);
return undeployApk(packageName);
}
/**
* Undeploys an apk, specified by package name, from a connected emulator or
* usb device. Also deletes the application's data and cache directories on
* the device.
*
* @param packageName
* the package name to undeploy.
* @return <code>true</code> if successfully undeployed, <code>false</code>
* otherwise.
*/
protected boolean undeployApk(final String packageName)
throws MojoExecutionException, MojoFailureException {
final AtomicBoolean result = new AtomicBoolean(true); // if no devices
// are present,
// it counts as
// successful
doWithDevices(new DeviceCallback() {
@Override
public void doWithDevice(final IDevice device)
throws MojoExecutionException {
try {
device.uninstallPackage(packageName);
getLog().info(
"Successfully uninstalled " + packageName
+ " from "
+ DeviceHelper.getDescriptiveName(device));
result.set(true);
} catch (InstallException e) {
result.set(false);
throw new MojoExecutionException("Uninstall of "
+ packageName + "failed.", e);
}
}
});
return result.get();
}
/**
* Extracts the package name from an apk file.
*
* @param apkFile
* apk file to extract package name from.
* @return the package name from inside the apk file.
*/
protected String extractPackageNameFromApk(File apkFile)
throws MojoExecutionException {
CommandExecutor executor = CommandExecutor.Factory
.createDefaultCommmandExecutor();
executor.setLogger(this.getLog());
List<String> commands = new ArrayList<String>();
commands.add("dump");
commands.add("xmltree");
commands.add(apkFile.getAbsolutePath());
commands.add("AndroidManifest.xml");
getLog().info(
getAndroidSdk().getPathForTool("aapt") + " "
+ commands.toString());
try {
executor.executeCommand(getAndroidSdk().getPathForTool("aapt"),
commands, false);
final String xmlTree = executor.getStandardOut();
return extractPackageNameFromAndroidManifestXmlTree(xmlTree);
} catch (ExecutionException e) {
throw new MojoExecutionException(
"Error while trying to figure out package name from inside apk file "
+ apkFile);
} finally {
String errout = executor.getStandardError();
if ((errout != null) && (errout.trim().length() > 0)) {
getLog().error(errout);
}
}
}
/**
* Extracts the package name from an XmlTree dump of AndroidManifest.xml by
* the <code>aapt</code> tool.
*
* @param aaptDumpXmlTree
* output from
* <code>aapt dump xmltree <apkFile> AndroidManifest.xml
* @return the package name from inside the apkFile.
*/
protected String extractPackageNameFromAndroidManifestXmlTree(
String aaptDumpXmlTree) {
final Scanner scanner = new Scanner(aaptDumpXmlTree);
// Finds the root element named "manifest".
scanner.findWithinHorizon("^E: manifest", 0);
// Finds the manifest element's attribute named "package".
scanner.findWithinHorizon(" A: package=\"", 0);
// Extracts the package value including the trailing double quote.
String packageName = scanner.next(".*?\"");
// Removes the double quote.
packageName = packageName.substring(0, packageName.length() - 1);
return packageName;
}
protected String extractPackageNameFromAndroidManifest(
File androidManifestFile) throws MojoExecutionException {
final URL xmlURL;
try {
xmlURL = androidManifestFile.toURI().toURL();
} catch (MalformedURLException e) {
throw new MojoExecutionException(
"Error while trying to figure out package name from inside AndroidManifest.xml file "
+ androidManifestFile, e);
}
final DocumentContainer documentContainer = new DocumentContainer(
xmlURL);
final Object packageName = JXPathContext.newContext(documentContainer)
.getValue("manifest/@package", String.class);
return (String) packageName;
}
/**
* Attempts to find the instrumentation test runner from inside the
* AndroidManifest.xml file.
*
* @param androidManifestFile
* the AndroidManifest.xml file to inspect.
* @return the instrumentation test runner declared in AndroidManifest.xml,
* or {@code null} if it is not declared.
* @throws MojoExecutionException
*/
protected String extractInstrumentationRunnerFromAndroidManifest(
File androidManifestFile) throws MojoExecutionException {
final URL xmlURL;
try {
xmlURL = androidManifestFile.toURI().toURL();
} catch (MalformedURLException e) {
throw new MojoExecutionException(
"Error while trying to figure out instrumentation runner from inside AndroidManifest.xml file "
+ androidManifestFile, e);
}
final DocumentContainer documentContainer = new DocumentContainer(
xmlURL);
final Object instrumentationRunner;
try {
instrumentationRunner = JXPathContext.newContext(documentContainer)
.getValue("manifest//instrumentation/@android:name",
String.class);
} catch (JXPathNotFoundException e) {
return null;
}
return (String) instrumentationRunner;
}
protected int deleteFilesFromDirectory(File baseDirectory,
String... includes) throws MojoExecutionException {
final String[] files = findFilesInDirectory(baseDirectory, includes);
if (files == null) {
return 0;
}
for (String file : files) {
final boolean successfullyDeleted = new File(baseDirectory, file)
.delete();
if (!successfullyDeleted) {
throw new MojoExecutionException("Failed to delete \"" + file
+ "\"");
}
}
return files.length;
}
/**
* Finds files.
*
* @param baseDirectory
* Directory to find files in.
* @param includes
* Ant-style include statements, for example
* <code>"** /*.aidl"</code> (but without the space in the
* middle)
* @return <code>String[]</code> of the files' paths and names, relative to
* <code>baseDirectory</code>. Empty <code>String[]</code> if
* <code>baseDirectory</code> does not exist.
*/
protected String[] findFilesInDirectory(File baseDirectory,
String... includes) {
if (baseDirectory.exists()) {
DirectoryScanner directoryScanner = new DirectoryScanner();
directoryScanner.setBasedir(baseDirectory);
directoryScanner.setIncludes(includes);
directoryScanner.addDefaultExcludes();
directoryScanner.scan();
String[] files = directoryScanner.getIncludedFiles();
return files;
} else {
return new String[0];
}
}
/**
* <p>
* Returns the Android SDK to use.
* </p>
* <p/>
* <p>
* Current implementation looks for <code><sdk><path></code>
* configuration in pom, then System property <code>android.sdk.path</code>,
* then environment variable <code>ANDROID_HOME</code>.
* <p/>
* <p>
* This is where we collect all logic for how to lookup where it is, and
* which one to choose. The lookup is based on available parameters. This
* method should be the only one you should need to look at to understand
* how the Android SDK is chosen, and from where on disk.
* </p>
*
* @return the Android SDK to use.
* @throws org.apache.maven.plugin.MojoExecutionException
* if no Android SDK path configuration is available at all.
*/
protected AndroidSdk getAndroidSdk() throws MojoExecutionException {
File chosenSdkPath;
String chosenSdkPlatform;
if (sdk != null) {
// An <sdk> tag exists in the pom.
if (sdk.getPath() != null) {
// An <sdk><path> tag is set in the pom.
chosenSdkPath = sdk.getPath();
} else {
// There is no <sdk><path> tag in the pom.
if (sdkPath != null) {
// -Dandroid.sdk.path is set on command line, or via
// <properties><android.sdk.path>...
chosenSdkPath = sdkPath;
} else {
// No -Dandroid.sdk.path is set on command line, or via
// <properties><android.sdk.path>...
chosenSdkPath = new File(getAndroidHomeOrThrow());
}
}
// Use <sdk><platform> from pom if it's there, otherwise try
// -Dandroid.sdk.platform from command line or
// <properties><sdk.platform>...
if (!isBlank(sdk.getPlatform())) {
chosenSdkPlatform = sdk.getPlatform();
} else {
chosenSdkPlatform = sdkPlatform;
}
} else {
// There is no <sdk> tag in the pom.
if (sdkPath != null) {
// -Dandroid.sdk.path is set on command line, or via
// <properties><android.sdk.path>...
chosenSdkPath = sdkPath;
} else {
// No -Dandroid.sdk.path is set on command line, or via
// <properties><android.sdk.path>...
chosenSdkPath = new File(getAndroidHomeOrThrow());
}
// Use any -Dandroid.sdk.platform from command line or
// <properties><sdk.platform>...
chosenSdkPlatform = sdkPlatform;
}
return new AndroidSdk(chosenSdkPath, chosenSdkPlatform);
}
private String getAndroidHomeOrThrow() throws MojoExecutionException {
final String androidHome = System.getenv(ENV_ANDROID_HOME);
if (isBlank(androidHome)) {
throw new MojoExecutionException(
"No Android SDK path could be found. You may configure it in the "
+ "plugin configuration section in the pom file using <sdk><path>...</path></sdk> or "
+ "<properties><android.sdk.path>...</android.sdk.path></properties> or on command-line "
+ "using -Dandroid.sdk.path=... or by setting environment variable "
+ ENV_ANDROID_HOME);
}
return androidHome;
}
protected String getLibraryUnpackDirectory(Artifact apkLibraryArtifact) {
return AbstractAndroidMojo.getLibraryUnpackDirectory(
unpackedApkLibsDirectory, apkLibraryArtifact);
}
public static String getLibraryUnpackDirectory(
File unpackedApkLibsDirectory, Artifact apkLibraryArtifact) {
return unpackedApkLibsDirectory.getAbsolutePath() + File.separator
+ apkLibraryArtifact.getId().replace(":", "_");
}
}