Java tutorial
/* * ### * 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.phase05compile; import static org.apache.commons.lang.StringUtils.isBlank; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FilenameFilter; import java.io.IOException; import java.util.ArrayList; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.Set; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.commons.io.FileUtils; import org.apache.maven.archiver.MavenArchiveConfiguration; import org.apache.maven.archiver.MavenArchiver; import org.apache.maven.artifact.Artifact; import org.apache.maven.artifact.factory.ArtifactFactory; import org.apache.maven.plugin.MojoExecutionException; import org.apache.maven.plugin.MojoFailureException; import org.codehaus.plexus.archiver.jar.JarArchiver; import org.codehaus.plexus.util.IOUtil; import com.photon.maven.plugins.android.AbstractAndroidMojo; import com.photon.maven.plugins.android.AndroidNdk; import com.photon.maven.plugins.android.CommandExecutor; import com.photon.maven.plugins.android.ExecutionException; import com.photon.maven.plugins.android.common.AetherHelper; import com.photon.maven.plugins.android.common.NativeHelper; import com.photon.maven.plugins.android.configuration.HeaderFilesDirective; import com.photon.maven.plugins.android.configuration.Ndk; /** * @goal ndk-build * @phase compile * @requiresProject true */ public class NdkBuildMojo extends AbstractAndroidMojo { /** * <p>The Android NDK to use.</p> * <p>Looks like this:</p> * <pre> * <ndk> * <path>/opt/android-ndk-r4</path> * </ndk> * </pre> * <p>The <code><path></code> parameter is optional. The default is the setting of the ANDROID_NDK_HOME environment * variable. The parameter can be used to override this setting with a different environment variable like this:</p> * <pre> * <ndk> * <path>${env.ANDROID_NDK_HOME}</path> * </ndk> * </pre> * <p>or just with a hardcoded absolute path. The parameters can also be configured from command-line with parameter * <code>-Dandroid.ndk.path</code>.</p> * * @parameter */ private Ndk ndk; /** Allows for overriding the default ndk-build executable. * * @parameter expression="${android.ndk.ndk-build-executable}" */ private String ndkBuildExecutable; /** * * @parameter expression="${android.ndk.ndk-build-directory}" default="${basedir}"; */ private String ndkBuildDirectory; /** * <p>Parameter designed to pick up <code>-Dandroid.ndk.path</code> in case there is no pom with an * <code><ndk></code> configuration tag.</p> * <p>Corresponds to {@link com.jayway.maven.plugins.android.configuration.Ndk#path}.</p> * * @parameter expression="${android.ndk.path}" * @readonly */ private File ndkPath; /** * Specifies the classifier with which the artifact should be stored in the repository * * @parameter expression="${android.ndk.build.native-classifier}" */ protected String ndkClassifier; /** * Specifies additional command line parameters to pass to ndk-build * * @parameter expression="${android.ndk.build.command-line}" */ protected String ndkBuildAdditionalCommandline; /** * Flag indicating whether the NDK output directory (libs/<architecture>) should be cleared after build. This * will essentially 'move' all the native artifacts (.so) to the ${project.build.directory}/libs/<architecture>. * If an APK is built as part of the invocation, the libraries will be included from here. * * @parameter expression="${android.ndk.build.clear-native-artifacts}" default="false" */ protected boolean clearNativeArtifacts = false; /** * Flag indicating whether the resulting native library should be attached as an artifact to the build. This * means the resulting .so is installed into the repository as well as being included in the final APK. * * @parameter expression="${android.ndk.build.attach-native-artifact}" default="false" */ protected boolean attachNativeArtifacts; /** * The <code>ANDROID_NDK_HOME</code> environment variable name. */ public static final String ENV_ANDROID_NDK_HOME = "ANDROID_NDK_HOME"; /** * Build folder to place built native libraries into * * @parameter expression="${android.ndk.build.ndk-output-directory}" default-value="${project.build.directory}/ndk-libs" */ protected File ndkOutputDirectory; /** <p>Folder containing native, static libraries compiled and linked by the NDK.</p> * * @parameter expression="${android.nativeLibrariesOutputDirectory}" default-value="${project.basedir}/obj/local" */ private File nativeLibrariesOutputDirectory; /** <p>Target to invoke on the native makefile.</p> * * @parameter expression="${android.nativeTarget}" */ private String target; /** * Defines the architecture for the NDK build * * @parameter expression="${android.ndk.build.architecture}" default="armeabi" */ protected String ndkArchitecture = "armeabi"; /** * @component * @readonly * @required */ protected ArtifactFactory artifactFactory; /** * Flag indicating whether the header files used in the build should be included and attached to the build as * an additional artifact. * * @parameter expression="${android.ndk.build.attach-header-files}" default="true" */ private boolean attachHeaderFiles = true; /** Flag indicating whether the make files last LOCAL_SRC_INCLUDES should be used for determing what header * files to include. Setting this flag to true, overrides any defined header files directives. * <strong>Note: </strong> By setting this flag to true, all header files used in the project will be * added to the resulting header archive. This may be undesirable in most cases and is therefore turned off by default. * * @parameter expression="${android.ndk.build.use-local-src-include-paths}" default="false" */ private boolean useLocalSrcIncludePaths = false; /** Specifies the set of header files includes/excludes which should be used for bundling the exported header * files. The below shows an example of how this can be used. * * <pre> * <headerFilesDirectives> * <headerFilesDirective> * <directory>${basedir}/jni/include</directory> * <includes> * <includes>**\/*.h</include> * </includes> * <headerFilesDirective> * </headerFilesDirectives> * </pre> * <br/> * If no <code>headerFilesDirectives</code> is specified, the default includes will be defined as shown below: * <br/> * <pre> * <headerFilesDirectives> * <headerFilesDirective> * <directory>${basedir}/jni</directory> * <includes> * <includes>**\/*.h</include> * </includes> * <excludes> * <exclude>**\/*.c</exclude> * </excludes> * <headerFilesDirective> * [..] * </headerFilesDirectives> * </pre> * * @parameter */ private List<HeaderFilesDirective> headerFilesDirectives; /** The Jar archiver. * * @component role="org.codehaus.plexus.archiver.Archiver" roleHint="jar" */ private JarArchiver jarArchiver; /** * Flag indicating whether the header files for native, static library dependencies should be used. If true, * the header archive for each statically linked dependency will be resolved. * * @parameter expression="${android.ndk.build.use-header-archives}" default="true" */ private boolean useHeaderArchives = true; /** Defines additional system properties which should be exported to the ndk-build script. This * <br/> * <pre> * <systemProperties> * <propertyName>propertyValue</propertyName> * <build-target>android</build-target> * [..] * </systemProperties> * </pre> * * @parameter */ private Map<String, String> systemProperties; /** * Flag indicating whether warnings should be ignored while compiling. If true, * the build will not fail if warning are found during compile. * * @parameter expression="${android.ndk.build.ignore-build-warnings}" default="true" */ private boolean ignoreBuildWarnings = true; /** * Defines the regular expression used to detect whether error/warning output from ndk-build is a minor compile warning * or is actually an error which should cause the build to fail. * * If the pattern matches, the output from the compiler will <strong>not</strong> be considered an error and compile * will be successful. * * @parameter expression="${android.ndk.build.build-warnings-regular-expression}" default=".*[warning|note]: .*" */ private String buildWarningsRegularExpression = ".*[warning|note]: .*"; public void execute() throws MojoExecutionException, MojoFailureException { // Validate the NDK final File ndkBuildFile = new File(getAndroidNdk().getNdkBuildPath()); NativeHelper.validateNDKVersion(ndkBuildFile.getParentFile()); // This points File nativeLibDirectory = new File(nativeLibrariesOutputDirectory, ndkArchitecture); final boolean libsDirectoryExists = nativeLibDirectory.exists(); File directoryToRemove = nativeLibDirectory; if (!libsDirectoryExists) { getLog().info("Creating native output directory " + nativeLibDirectory); if (nativeLibDirectory.getParentFile().exists()) { nativeLibDirectory.mkdir(); } else { nativeLibDirectory.mkdirs(); directoryToRemove = nativeLibDirectory.getParentFile(); } } final CommandExecutor executor = CommandExecutor.Factory.createDefaultCommmandExecutor(); executor.setErrorListener(new CommandExecutor.ErrorListener() { @Override public boolean isError(String error) { Pattern pattern = Pattern.compile(buildWarningsRegularExpression); Matcher matcher = pattern.matcher(error); if (ignoreBuildWarnings && matcher.matches()) { return false; } return true; } }); final Set<Artifact> nativeLibraryArtifacts = findNativeLibraryDependencies(); // If there are any static libraries the code needs to link to, include those in the make file final Set<Artifact> resolveNativeLibraryArtifacts = AetherHelper.resolveArtifacts(nativeLibraryArtifacts, repoSystem, repoSession, projectRepos); try { File f = File.createTempFile("android_maven_plugin_makefile", ".mk"); f.deleteOnExit(); String makeFile = MakefileHelper.createMakefileFromArtifacts(f.getParentFile(), resolveNativeLibraryArtifacts, useHeaderArchives, repoSession, projectRepos, repoSystem); IOUtil.copy(makeFile, new FileOutputStream(f)); // Add the path to the generated makefile executor.addEnvironment("ANDROID_MAVEN_PLUGIN_MAKEFILE", f.getAbsolutePath()); // Only add the LOCAL_STATIC_LIBRARIES if (NativeHelper.hasStaticNativeLibraryArtifact(resolveNativeLibraryArtifacts)) { executor.addEnvironment("ANDROID_MAVEN_PLUGIN_LOCAL_STATIC_LIBRARIES", MakefileHelper.createStaticLibraryList(resolveNativeLibraryArtifacts, true)); } if (NativeHelper.hasSharedNativeLibraryArtifact(resolveNativeLibraryArtifacts)) { executor.addEnvironment("ANDROID_MAVEN_PLUGIN_LOCAL_SHARED_LIBRARIES", MakefileHelper.createStaticLibraryList(resolveNativeLibraryArtifacts, false)); } } catch (IOException e) { throw new MojoExecutionException(e.getMessage()); } File localCIncludesFile = null; // try { localCIncludesFile = File.createTempFile("android_maven_plugin_makefile_captures", ".tmp"); localCIncludesFile.deleteOnExit(); executor.addEnvironment("ANDROID_MAVEN_PLUGIN_LOCAL_C_INCLUDES_FILE", localCIncludesFile.getAbsolutePath()); } catch (IOException e) { throw new MojoExecutionException(e.getMessage()); } // Add any defined system properties if (systemProperties != null && !systemProperties.isEmpty()) { for (Map.Entry<String, String> entry : systemProperties.entrySet()) { executor.addEnvironment(entry.getKey(), entry.getValue()); } } executor.setLogger(this.getLog()); final List<String> commands = new ArrayList<String>(); commands.add("-C"); if (ndkBuildDirectory == null) { ndkBuildDirectory = project.getBasedir().getAbsolutePath(); } commands.add(ndkBuildDirectory); if (ndkBuildAdditionalCommandline != null) { String[] additionalCommands = ndkBuildAdditionalCommandline.split(" "); for (final String command : additionalCommands) { commands.add(command); } } // If a build target is specified, tag that onto the command line as the // very last of the parameters if (target != null) { commands.add(target); } else { commands.add(project.getArtifactId()); } final String ndkBuildPath = resolveNdkBuildExecutable(); getLog().info(ndkBuildPath + " " + commands.toString()); try { executor.executeCommand(ndkBuildPath, commands, project.getBasedir(), true); } catch (ExecutionException e) { throw new MojoExecutionException(e.getMessage(), e); } // Cleanup libs/armeabi directory if needed - this implies moving any native artifacts into target/libs if (clearNativeArtifacts) { final File destinationDirectory = new File(ndkOutputDirectory.getAbsolutePath(), "/" + ndkArchitecture); try { if (!libsDirectoryExists) { FileUtils.moveDirectory(nativeLibDirectory, destinationDirectory); } else { FileUtils.copyDirectory(nativeLibDirectory, destinationDirectory); FileUtils.cleanDirectory(nativeLibDirectory); } nativeLibDirectory = destinationDirectory; } catch (IOException e) { throw new MojoExecutionException(e.getMessage(), e); } } if (!libsDirectoryExists) { getLog().info("Cleaning up native library output directory after build"); getLog().debug("Removing directory: " + directoryToRemove); if (!directoryToRemove.delete()) { getLog().warn("Could not remove directory, marking as delete on exit"); directoryToRemove.deleteOnExit(); } } // Attempt to attach the native library if the project is defined as a "pure" native Android library // (packaging is 'so' or 'a') or if the plugin has been configured to attach the native library to the build if ("so".equals(project.getPackaging()) || "a".equals(project.getPackaging()) || attachNativeArtifacts) { File[] files = nativeLibDirectory.listFiles(new FilenameFilter() { public boolean accept(final File dir, final String name) { if ("a".equals(project.getPackaging())) { return name.startsWith("lib" + (target != null ? target : project.getArtifactId())) && name.endsWith(".a"); } else { return name.startsWith("lib" + (target != null ? target : project.getArtifactId())) && name.endsWith(".so"); } } }); // slight limitation at this stage - we only handle a single .so artifact if (files == null || files.length != 1) { getLog().warn("Error while detecting native compile artifacts: " + (files == null || files.length == 0 ? "None found" : "Found more than 1 artifact")); if (files != null && files.length > 1) { getLog().error("Currently, only a single, final native library is supported by the build"); throw new MojoExecutionException( "Currently, only a single, final native library is supported by the build"); } else { getLog().error( "No native compiled library found, did the native compile complete successfully?"); throw new MojoExecutionException( "No native compiled library found, did the native compile complete successfully?"); } } else { getLog().debug("Adding native compile artifact: " + files[0]); final String artifactType = resolveArtifactType(files[0]); projectHelper.attachArtifact(this.project, artifactType, (ndkClassifier != null ? ndkClassifier : ndkArchitecture), files[0]); } } // Process conditionally any of the headers to include into the header archive file processHeaderFileIncludes(localCIncludesFile); } private String resolveNdkBuildExecutable() throws MojoExecutionException { if (ndkBuildExecutable != null) { getLog().debug("ndk-build overriden, using " + ndkBuildExecutable); return ndkBuildExecutable; } return getAndroidNdk().getNdkBuildPath(); } private void processHeaderFileIncludes(File localCIncludesFile) throws MojoExecutionException { try { if (attachHeaderFiles) { final List<HeaderFilesDirective> finalHeaderFilesDirectives = new ArrayList<HeaderFilesDirective>(); if (useLocalSrcIncludePaths) { Properties props = new Properties(); props.load(new FileInputStream(localCIncludesFile)); String localCIncludes = props.getProperty("LOCAL_C_INCLUDES"); if (localCIncludes != null && !localCIncludes.trim().isEmpty()) { String[] includes = localCIncludes.split(" "); for (String include : includes) { final HeaderFilesDirective headerFilesDirective = new HeaderFilesDirective(); File includeDir = new File(project.getBasedir(), include); headerFilesDirective.setDirectory(includeDir.getAbsolutePath()); headerFilesDirective.setIncludes(new String[] { "**/*.h" }); finalHeaderFilesDirectives.add(headerFilesDirective); } } } else { if (headerFilesDirectives != null) { finalHeaderFilesDirectives.addAll(headerFilesDirectives); } } if (finalHeaderFilesDirectives.isEmpty()) { getLog().debug("No header files included, will add default set"); final HeaderFilesDirective e = new HeaderFilesDirective(); e.setDirectory(new File(project.getBasedir() + "/jni").getAbsolutePath()); e.setIncludes(new String[] { "**/*.h" }); finalHeaderFilesDirectives.add(e); } createHeaderArchive(finalHeaderFilesDirectives); } } catch (Exception e) { throw new MojoExecutionException("Error while processing headers to include: " + e.getMessage(), e); } } private void createHeaderArchive(List<HeaderFilesDirective> finalHeaderFilesDirectives) throws MojoExecutionException { try { MavenArchiver mavenArchiver = new MavenArchiver(); mavenArchiver.setArchiver(jarArchiver); final File jarFile = new File(new File(project.getBuild().getDirectory()), project.getBuild().getFinalName() + ".har"); mavenArchiver.setOutputFile(jarFile); for (HeaderFilesDirective headerFilesDirective : finalHeaderFilesDirectives) { mavenArchiver.getArchiver().addDirectory(new File(headerFilesDirective.getDirectory()), headerFilesDirective.getIncludes(), headerFilesDirective.getExcludes()); } final MavenArchiveConfiguration mavenArchiveConfiguration = new MavenArchiveConfiguration(); mavenArchiveConfiguration.setAddMavenDescriptor(false); mavenArchiver.createArchive(project, mavenArchiveConfiguration); projectHelper.attachArtifact(project, "har", (ndkClassifier != null ? ndkClassifier : ndkArchitecture), jarFile); } catch (Exception e) { throw new MojoExecutionException(e.getMessage()); } } private Set<Artifact> findNativeLibraryDependencies() throws MojoExecutionException { NativeHelper nativeHelper = new NativeHelper(project, projectRepos, repoSession, repoSystem, artifactFactory, getLog()); final Set<Artifact> staticLibraryArtifacts = nativeHelper .getNativeDependenciesArtifacts(unpackedApkLibsDirectory, false); final Set<Artifact> sharedLibraryArtifacts = nativeHelper .getNativeDependenciesArtifacts(unpackedApkLibsDirectory, true); final Set<Artifact> mergedArtifacts = new LinkedHashSet<Artifact>(staticLibraryArtifacts); mergedArtifacts.addAll(sharedLibraryArtifacts); return mergedArtifacts; } /** Resolve the artifact type from the current project and the specified file. If the project packaging is * either 'a' or 'so' it will use the packaging, otherwise it checks the file for the extension * * @param file The file being added as an artifact * @return The artifact type (so or a) */ private String resolveArtifactType(File file) { if ("so".equals(project.getPackaging()) || "a".equals(project.getPackaging())) { return project.getPackaging(); } else { // At this point, the file (as found by our filtering previously will end with either 'so' or 'a' return file.getName().endsWith("so") ? "so" : "a"; } } /** * <p>Returns the Android NDK to use.</p> * <p/> * <p>Current implementation looks for <code><ndk><path></code> configuration in pom, then System * property <code>android.ndk.path</code>, then environment variable <code>ANDROID_NDK_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 NDK is chosen, and from where on disk.</p> * * @return the Android NDK to use. * @throws org.apache.maven.plugin.MojoExecutionException * if no Android NDK path configuration is available at all. */ protected AndroidNdk getAndroidNdk() throws MojoExecutionException { File chosenNdkPath; if (ndk != null) { // An <ndk> tag exists in the pom. if (ndk.getPath() != null) { // An <ndk><path> tag is set in the pom. chosenNdkPath = ndk.getPath(); } else { // There is no <ndk><path> tag in the pom. if (ndkPath != null) { // -Dandroid.ndk.path is set on command line, or via <properties><ndk.path>... chosenNdkPath = ndkPath; } else { // No -Dandroid.ndk.path is set on command line, or via <properties><ndk.path>... chosenNdkPath = new File(getAndroidNdkHomeOrThrow()); } } } else { // There is no <ndk> tag in the pom. if (ndkPath != null) { // -Dandroid.ndk.path is set on command line, or via <properties><ndk.path>... chosenNdkPath = ndkPath; } else { // No -Dandroid.ndk.path is set on command line, or via <properties><ndk.path>... chosenNdkPath = new File(getAndroidNdkHomeOrThrow()); } } return new AndroidNdk(chosenNdkPath); } private String getAndroidNdkHomeOrThrow() throws MojoExecutionException { final String androidHome = System.getenv(ENV_ANDROID_NDK_HOME); if (isBlank(androidHome)) { throw new MojoExecutionException( "No Android NDK path could be found. You may configure it in the pom using <ndk><path>...</path></ndk> or <properties><ndk.path>...</ndk.path></properties> or on command-line using -Dandroid.ndk.path=... or by setting environment variable " + ENV_ANDROID_NDK_HOME); } return androidHome; } }