/*
* Copyright (C) 2009 Jayway AB
* Copyright (C) 2007-2008 JVending Masa
*
* 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.simpligility.maven.plugins.android.phase09package;
import com.simpligility.maven.plugins.android.AbstractAndroidMojo;
import com.simpligility.maven.plugins.android.CommandExecutor;
import com.simpligility.maven.plugins.android.ExecutionException;
import com.simpligility.maven.plugins.android.common.AaptCommandBuilder;
import com.simpligility.maven.plugins.android.common.AndroidExtension;
import com.simpligility.maven.plugins.android.common.NativeHelper;
import com.simpligility.maven.plugins.android.config.PullParameter;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.model.Resource;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.plugins.annotations.LifecyclePhase;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import org.apache.maven.plugins.annotations.ResolutionScope;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.archiver.jar.JarArchiver;
import org.codehaus.plexus.archiver.util.DefaultFileSet;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import static com.simpligility.maven.plugins.android.common.AndroidExtension.AAR;
import static com.simpligility.maven.plugins.android.common.AndroidExtension.APKLIB;
/**
* Creates the apklib file.<br>
* apklib files do not generate deployable artifacts.
*
* @author nmaiorana@gmail.com
* @deprecated Use Aar instead see {@link com.simpligility.maven.plugins.android.phase09package.AarMojo}
*/
@Deprecated
@Mojo( name = "apklib", defaultPhase = LifecyclePhase.PACKAGE, requiresDependencyResolution = ResolutionScope.COMPILE )
public class ApklibMojo extends AbstractAndroidMojo
{
/**
* The name of the top level folder in the APKLIB where native libraries are found.
* NOTE: This is inconsistent with APK where the folder is called "lib"
*/
public static final String NATIVE_LIBRARIES_FOLDER = "libs";
/**
* <p>Classifier to add to the artifact generated. If given, the artifact will be an attachment instead.</p>
*/
@Parameter
private String classifier;
/**
* Specifies the application makefile to use for the build (if other than the default Application.mk).
*/
@Parameter
@PullParameter
private String applicationMakefile;
/**
* Defines the architecture for the NDK build
*/
@Parameter( property = "android.ndk.build.architecture" )
@PullParameter
private String ndkArchitecture;
/**
* Specifies the classifier with which the artifact should be stored in the repository
*/
@Parameter( property = "android.ndk.build.native-classifier" )
@PullParameter
private String ndkClassifier;
private List<String> sourceFolders = new ArrayList<String>();
/**
* @throws MojoExecutionException
* @throws MojoFailureException
*/
public void execute() throws MojoExecutionException, MojoFailureException
{
String out = targetDirectory.getPath();
for ( String src : project.getCompileSourceRoots() )
{
if ( !src.startsWith( out ) )
{
sourceFolders.add( src );
}
}
generateIntermediateApk();
File outputFile = createApkLibraryFile();
if ( classifier == null )
{
// Set the generated file as the main artifact (because the pom states <packaging>apklib</packaging>)
project.getArtifact().setFile( outputFile );
}
else
{
// If there is a classifier specified, attach the artifact using that
projectHelper.attachArtifact( project, AndroidExtension.APKLIB, classifier, outputFile );
}
if ( attachJar )
{
final File jarFile = new File( targetDirectory,
finalName + ".jar" );
projectHelper.attachArtifact( project, "jar", project.getArtifact().getClassifier(), jarFile );
}
}
private File createApkLibraryFile() throws MojoExecutionException
{
final File apklibrary = new File( targetDirectory,
finalName + "." + APKLIB );
FileUtils.deleteQuietly( apklibrary );
try
{
JarArchiver jarArchiver = new JarArchiver();
jarArchiver.setDestFile( apklibrary );
jarArchiver.addFile( destinationManifestFile, "AndroidManifest.xml" );
addDirectory( jarArchiver, assetsDirectory, "assets" );
addDirectory( jarArchiver, resourceDirectory, "res" );
for ( String src : sourceFolders )
{
addDirectory( jarArchiver, new File( src ), "src" );
}
File[] overlayDirectories = getResourceOverlayDirectories();
for ( File resOverlayDir : overlayDirectories )
{
if ( resOverlayDir != null && resOverlayDir.exists() )
{
addDirectory( jarArchiver, resOverlayDir, "res" );
}
}
addJavaResources( jarArchiver, resources, "src" );
// Lastly, add any native libraries
addNativeLibraries( jarArchiver );
jarArchiver.createArchive();
}
catch ( ArchiverException e )
{
throw new MojoExecutionException( "ArchiverException while creating ." + APKLIB + " file.", e );
}
catch ( IOException e )
{
throw new MojoExecutionException( "IOException while creating ." + APKLIB + " file.", e );
}
return apklibrary;
}
private void addNativeLibraries( final JarArchiver jarArchiver ) throws MojoExecutionException
{
try
{
if ( nativeLibrariesDirectory.exists() )
{
getLog().info( nativeLibrariesDirectory + " exists, adding libraries." );
addDirectory( jarArchiver, nativeLibrariesDirectory, NATIVE_LIBRARIES_FOLDER );
}
else
{
getLog().info( nativeLibrariesDirectory
+ " does not exist, looking for libraries in target directory." );
// Add native libraries built and attached in this build
String[] ndkArchitectures = NativeHelper.getNdkArchitectures( ndkArchitecture,
applicationMakefile,
project.getBasedir() );
for ( String architecture : ndkArchitectures )
{
final File ndkLibsDirectory = new File( ndkOutputDirectory, architecture );
addSharedLibraries( jarArchiver, ndkLibsDirectory, architecture );
// Add native library dependencies
// FIXME: Remove as causes duplicate libraries when building final APK if this set includes
// libraries from dependencies of the APKLIB
//final File dependentLibs = new File( ndkOutputDirectory.getAbsolutePath(), ndkArchitecture );
//addSharedLibraries( jarArchiver, dependentLibs, prefix );
}
}
// Removing this as the APK is now able to pull the native libs from the chained apklibs
// get native libs from other apklibs
// for ( Artifact apkLibraryArtifact : getTransitiveDependencyArtifacts( APKLIB ) )
// {
// final File apklibLibsDirectory = getUnpackedLibNativesFolder( apkLibraryArtifact );
// if ( apklibLibsDirectory.exists() )
// {
// addDirectory( jarArchiver, apklibLibsDirectory, NATIVE_LIBRARIES_FOLDER );
// }
// }
}
catch ( ArchiverException e )
{
throw new MojoExecutionException( "IOException while creating ." + APKLIB + " file.", e );
}
// TODO: Next is to check for any:
// TODO: - compiled in (as part of this build) libs
// TODO: - That is of course easy if the artifact is indeed attached
// TODO: - If not attached, it gets a little trickier - check the target dir for any compiled .so files (generated by NDK mojo)
// TODO: - But where is that directory configured?
}
protected void addJavaResources( JarArchiver jarArchiver, List<Resource> javaResources, String prefix )
throws IOException
{
for ( Resource javaResource : javaResources )
{
addJavaResource( jarArchiver, javaResource, prefix );
}
}
/**
* Adds a Java Resources directory (typically "src/main/resources") to a {@link JarArchiver}.
*
* @param jarArchiver
* @param javaResource The Java resource to add.
* @param prefix An optional prefix for where in the Jar file the directory's contents should go.
* @throws IOException in case the resource path can not be resolved
*/
protected void addJavaResource( JarArchiver jarArchiver, Resource javaResource, String prefix )
throws IOException
{
if ( javaResource != null )
{
final File javaResourceDirectory = new File( javaResource.getDirectory() );
if ( javaResourceDirectory.exists() )
{
final String resourcePath = javaResourceDirectory.getCanonicalPath();
final String apkLibUnpackBasePath = getUnpackedLibsDirectory().getCanonicalPath();
// Don't include our dependencies' resource dirs.
if ( ! resourcePath.startsWith( apkLibUnpackBasePath ) )
{
final DefaultFileSet javaResourceFileSet = new DefaultFileSet();
javaResourceFileSet.setDirectory( javaResourceDirectory );
javaResourceFileSet.setPrefix( endWithSlash( prefix ) );
jarArchiver.addFileSet( javaResourceFileSet );
}
}
}
}
/**
* Makes sure the string ends with "/"
*
* @param prefix any string, or null.
* @return the prefix with a "/" at the end, never null.
*/
protected String endWithSlash( String prefix )
{
prefix = StringUtils.defaultIfEmpty( prefix, "/" );
if ( ! prefix.endsWith( "/" ) )
{
prefix = prefix + "/";
}
return prefix;
}
/**
* Adds a directory to a {@link JarArchiver} with a directory prefix.
*
* @param jarArchiver
* @param directory The directory to add.
* @param prefix An optional prefix for where in the Jar file the directory's contents should go.
*/
protected void addDirectory( JarArchiver jarArchiver, File directory, String prefix )
{
if ( directory != null && directory.exists() )
{
final DefaultFileSet fileSet = new DefaultFileSet();
fileSet.setPrefix( endWithSlash( prefix ) );
fileSet.setDirectory( directory );
// XXX: trying to avoid duplicated sources
fileSet.setExcludes( new String[] { "**/R.java", "**/BuildConfig.java" } );
jarArchiver.addFileSet( fileSet );
getLog().debug( "Added files from " + directory );
}
}
/**
* Adds all shared libraries (.so) to a {@link JarArchiver} under 'libs'.
*
* @param jarArchiver The jarArchiver to add files to
* @param directory The directory to scan for .so files
* @param architecture The prefix for where in the jar the .so files will go.
*/
protected void addSharedLibraries( JarArchiver jarArchiver, File directory, String architecture )
{
getLog().debug( "Searching for shared libraries in " + directory );
File[] libFiles = directory.listFiles( new FilenameFilter()
{
public boolean accept( final File dir, final String name )
{
return name.startsWith( "lib" ) && name.endsWith( ".so" );
}
} );
if ( libFiles != null )
{
for ( File libFile : libFiles )
{
String dest = NATIVE_LIBRARIES_FOLDER + "/" + architecture + "/" + libFile.getName();
getLog().debug( "Adding " + libFile + " as " + dest );
jarArchiver.addFile( libFile, dest );
}
}
}
/**
* Generates an intermediate apk file (actually .ap_) containing the resources and assets.
*
* @throws MojoExecutionException
*/
private void generateIntermediateApk() throws MojoExecutionException
{
CommandExecutor executor = CommandExecutor.Factory.createDefaultCommmandExecutor();
executor.setLogger( this.getLog() );
File[] overlayDirectories = getResourceOverlayDirectories();
File androidJar = getAndroidSdk().getAndroidJar();
File outputFile = new File( targetDirectory, finalName + ".ap_" );
List<File> dependencyArtifactResDirectoryList = new ArrayList<File>();
for ( Artifact libraryArtifact : getTransitiveDependencyArtifacts( APKLIB, AAR ) )
{
final File apklibResDirectory = getUnpackedLibResourceFolder( libraryArtifact );
if ( apklibResDirectory.exists() )
{
dependencyArtifactResDirectoryList.add( apklibResDirectory );
}
}
AaptCommandBuilder commandBuilder = AaptCommandBuilder
.packageResources( getLog() )
.forceOverwriteExistingFiles()
.setPathToAndroidManifest( destinationManifestFile )
.addResourceDirectoriesIfExists( overlayDirectories )
.addResourceDirectoryIfExists( resourceDirectory )
.addResourceDirectoriesIfExists( dependencyArtifactResDirectoryList )
.autoAddOverlay()
// NB aapt only accepts a single assets parameter - combinedAssets is a merge of all assets
.addRawAssetsDirectoryIfExists( combinedAssets )
.addExistingPackageToBaseIncludeSet( androidJar )
.setOutputApkFile( outputFile )
.addConfigurations( configurations )
.setVerbose( aaptVerbose );
getLog().debug( getAndroidSdk().getAaptPath() + " " + commandBuilder.toString() );
getLog().info( "Generating apklib" );
try
{
executor.setCaptureStdOut( true );
List<String> commands = commandBuilder.build();
executor.executeCommand( getAndroidSdk().getAaptPath(), commands, project.getBasedir(), false );
}
catch ( ExecutionException e )
{
throw new MojoExecutionException( "", e );
}
}
}