anttasks/src/com/android/ant/ComputeDependencyTask.java - platform/sdk - Git at Google

 /*
  * Copyright (C) 2012 The Android Open Source Project
  *
  * 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.android.ant;

 import com.android.SdkConstants;
 import com.android.ant.DependencyHelper.JarProcessor;
 import com.android.io.FileWrapper;
 import com.android.sdklib.internal.project.IPropertySource;
 import com.android.xml.AndroidManifest;

 import org.apache.tools.ant.BuildException;
 import org.apache.tools.ant.Project;
 import org.apache.tools.ant.types.Path;
 import org.apache.tools.ant.types.Path.PathElement;

 import java.io.File;
 import java.util.List;

 /**
  * Computes the dependency of the current project.
  *
  * Out params:
  * <code>libraryResFolderPathOut</code>: the Path object containing the res folder for all the
  * library projects in the order needed by aapt.
  *
  * <code>libraryPackagesOut</code>: a simple property containing ;-separated package name from
  * the library projects.
  *
  * <code>jarLibraryPathOut</code>: the Path object containing all the 3rd party jar files.
  *
  * <code>libraryNativeFolderPathOut</code>: the Path with all the native folder for the library
  * projects.
  *
  *
  * In params:
  * <code>targetApi</code>: the compilation target api.
  * <code>verbose</code>: whether the build is verbose.
  *
  */
 public class ComputeDependencyTask extends GetLibraryPathTask {

     private String mLibraryManifestFilePathOut;
     private String mLibraryResFolderPathOut;
     private String mLibraryPackagesOut;
     private String mJarLibraryPathOut;
     private String mLibraryNativeFolderPathOut;
     private String mLibraryBinAidlFolderPathOut;
     private String mLibraryRFilePathOut;
     private int mTargetApi = -1;
     private boolean mVerbose = false;

     public void setLibraryManifestFilePathOut(String libraryManifestFilePathOut) {
         mLibraryManifestFilePathOut = libraryManifestFilePathOut;
     }

     public void setLibraryResFolderPathOut(String libraryResFolderPathOut) {
         mLibraryResFolderPathOut = libraryResFolderPathOut;
     }

     public void setLibraryPackagesOut(String libraryPackagesOut) {
         mLibraryPackagesOut = libraryPackagesOut;
     }

     public void setJarLibraryPathOut(String jarLibraryPathOut) {
         mJarLibraryPathOut = jarLibraryPathOut;
     }

     public void setLibraryBinAidlFolderPathOut(String libraryBinAidlFolderPathOut) {
         mLibraryBinAidlFolderPathOut = libraryBinAidlFolderPathOut;
     }

     public void setLibraryRFilePathOut(String libraryRFilePathOut) {
         mLibraryRFilePathOut = libraryRFilePathOut;
     }

     public void setLibraryNativeFolderPathOut(String libraryNativeFolderPathOut) {
         mLibraryNativeFolderPathOut = libraryNativeFolderPathOut;
     }

     public void setTargetApi(int targetApi) {
         mTargetApi = targetApi;
     }

     @Override
     public void execute() throws BuildException {
         if (mLibraryManifestFilePathOut == null) {
             throw new BuildException("Missing attribute libraryManifestFilePathOut");
         }
         if (mLibraryResFolderPathOut == null) {
             throw new BuildException("Missing attribute libraryResFolderPathOut");
         }
         if (mLibraryPackagesOut == null) {
             throw new BuildException("Missing attribute libraryPackagesOut");
         }
         if (mJarLibraryPathOut == null) {
             throw new BuildException("Missing attribute jarLibraryPathOut");
         }
         if (mLibraryNativeFolderPathOut == null) {
             throw new BuildException("Missing attribute libraryNativeFolderPathOut");
         }
         if (mLibraryBinAidlFolderPathOut == null) {
             throw new BuildException("Missing attribute libraryBinFolderPathOut");
         }
         if (mLibraryRFilePathOut == null) {
             throw new BuildException("Missing attribute libraryRFilePathOut");
         }
         if (mTargetApi == -1) {
             throw new BuildException("Missing attribute targetApi");
         }

         final Project antProject = getProject();

         // get the SDK location
         File sdkDir = TaskHelper.getSdkLocation(antProject);

         // prepare several paths for future tasks
         final Path manifestFilePath = new Path(antProject);
         final Path resFolderPath = new Path(antProject);
         final Path nativeFolderPath = new Path(antProject);
         final Path binAidlFolderPath = new Path(antProject);
         final Path rFilePath = new Path(antProject);
         final StringBuilder packageStrBuilder = new StringBuilder();

         // custom jar processor doing a bit more than just collecting the jar files
         JarProcessor processor = new JarProcessor() {
             @Override
             public void processLibrary(String libRootPath, IPropertySource properties) {
                 // let the super class handle the jar files
                 super.processLibrary(libRootPath, properties);

                 // get the AndroidManifest.xml path.
                 // FIXME: support renamed location.
                 PathElement element = manifestFilePath.createPathElement();
                 element.setPath(libRootPath + '/' + SdkConstants.FN_ANDROID_MANIFEST_XML);

                 // get the res path. $PROJECT/res as well as the crunch cache.
                 // FIXME: support renamed folders.
                 element = resFolderPath.createPathElement();
                 element.setPath(libRootPath + '/' + SdkConstants.FD_OUTPUT +
                         '/' + SdkConstants.FD_RES);
                 element = resFolderPath.createPathElement();
                 element.setPath(libRootPath + '/' + SdkConstants.FD_RESOURCES);

                 // get the folder for the native libraries. Always $PROJECT/libs
                 // FIXME: support renamed folder and/or move libs to bin/libs/
                 element = nativeFolderPath.createPathElement();
                 element.setPath(libRootPath + '/' + SdkConstants.FD_NATIVE_LIBS);

                 // get the bin/aidl folder. $PROJECT/bin/aidl for now
                 // FIXME: support renamed folder.
                 element = binAidlFolderPath.createPathElement();
                 element.setPath(libRootPath + '/' + SdkConstants.FD_OUTPUT +
                         '/' + SdkConstants.FD_AIDL);

                 // get the package from the manifest.
                 FileWrapper manifest = new FileWrapper(libRootPath,
                         SdkConstants.FN_ANDROID_MANIFEST_XML);

                 try {
                     String value = AndroidManifest.getPackage(manifest);
                     if (value != null) { // aapt will complain if it's missing.
                         packageStrBuilder.append(';');
                         packageStrBuilder.append(value);

                         // get the text R file. $PROJECT/bin/R.txt for now
                         // This must be in sync with the package list.
                         // FIXME: support renamed folder.
                         element = rFilePath.createPathElement();
                         element.setPath(libRootPath + "/" + SdkConstants.FD_OUTPUT +
                                 "/" + "R.txt");

                     }
                 } catch (Exception e) {
                     throw new BuildException(e);
                 }
             }
         };

         // list of all the jars that are on the classpath. This will receive the
         // project's libs/*.jar files, the Library Projects output and their own libs/*.jar
         List<File> jars = processor.getJars();


         // in case clean has been called before a build type target, the list of
         // libraries has already been computed so we don't need to compute it again.
         Path libraryFolderPath = (Path) antProject.getReference(getLibraryFolderPathOut());
         if (libraryFolderPath == null) {
             execute(processor);
         } else {
             // this contains the list of library folder in reverse order (compilation order).
             // We need to process it in the normal order (res order).
             System.out.println("Ordered libraries:");

             String[] libraries = libraryFolderPath.list();
             for (int i = libraries.length - 1 ; i >= 0 ; i--) {
                 String libRootPath = libraries[i];
                 System.out.println(libRootPath);

                 processor.processLibrary(libRootPath);
             }
         }

         boolean hasLibraries = jars.size() > 0;

         if (mTargetApi <= 15) {
             System.out.println("\n------------------");
             System.out.println("API<=15: Adding annotations.jar to the classpath.");

             jars.add(new File(sdkDir, SdkConstants.FD_TOOLS +
                     '/' + SdkConstants.FD_SUPPORT +
                     '/' + SdkConstants.FN_ANNOTATIONS_JAR));

         }

         // even with no libraries, always setup these so that various tasks in Ant don't complain
         // (the task themselves can handle a ref to an empty Path)
         antProject.addReference(mLibraryNativeFolderPathOut, nativeFolderPath);
         antProject.addReference(mLibraryManifestFilePathOut, manifestFilePath);
         antProject.addReference(mLibraryBinAidlFolderPathOut, binAidlFolderPath);

         // the rest is done only if there's a library.
         if (hasLibraries) {
             antProject.addReference(mLibraryResFolderPathOut, resFolderPath);
             antProject.setProperty(mLibraryPackagesOut, packageStrBuilder.toString());
             antProject.addReference(mLibraryRFilePathOut, rFilePath);
         }

         File projectFolder = antProject.getBaseDir();

         // add the project's own content of libs/*.jar
         File libsFolder = new File(projectFolder, SdkConstants.FD_NATIVE_LIBS);
         File[] jarFiles = libsFolder.listFiles(processor.getFilter());
         if (jarFiles != null) {
             for (File jarFile : jarFiles) {
                 jars.add(jarFile);
             }
         }

         // now sanitize the path to remove dups
         jars = DependencyHelper.sanitizePaths(projectFolder, new IPropertySource() {
             @Override
             public String getProperty(String name) {
                 return antProject.getProperty(name);
             }

             @Override
             public void debugPrint() {
             }
         }, jars);

         // and create a Path object for them
         Path jarsPath = new Path(antProject);
         if (mVerbose) {
             System.out.println("\n------------------\nSanitized jar list:");
         }
         for (File f : jars) {
             if (mVerbose) {
                 System.out.println("- " + f.getAbsolutePath());
             }
             PathElement element = jarsPath.createPathElement();
             element.setPath(f.getAbsolutePath());
         }
         antProject.addReference(mJarLibraryPathOut, jarsPath);

         if (mVerbose) {
             System.out.println();
         }
     }
 }
	/*
	* Copyright (C) 2012 The Android Open Source Project
	*
	* 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.android.ant;

	import com.android.SdkConstants;
	import com.android.ant.DependencyHelper.JarProcessor;
	import com.android.io.FileWrapper;
	import com.android.sdklib.internal.project.IPropertySource;
	import com.android.xml.AndroidManifest;

	import org.apache.tools.ant.BuildException;
	import org.apache.tools.ant.Project;
	import org.apache.tools.ant.types.Path;
	import org.apache.tools.ant.types.Path.PathElement;

	import java.io.File;
	import java.util.List;

	/**
	* Computes the dependency of the current project.
	*
	* Out params:
	* <code>libraryResFolderPathOut</code>: the Path object containing the res folder for all the
	* library projects in the order needed by aapt.
	*
	* <code>libraryPackagesOut</code>: a simple property containing ;-separated package name from
	* the library projects.
	*
	* <code>jarLibraryPathOut</code>: the Path object containing all the 3rd party jar files.
	*
	* <code>libraryNativeFolderPathOut</code>: the Path with all the native folder for the library
	* projects.
	*
	*
	* In params:
	* <code>targetApi</code>: the compilation target api.
	* <code>verbose</code>: whether the build is verbose.
	*
	*/
	public class ComputeDependencyTask extends GetLibraryPathTask {

	private String mLibraryManifestFilePathOut;
	private String mLibraryResFolderPathOut;
	private String mLibraryPackagesOut;
	private String mJarLibraryPathOut;
	private String mLibraryNativeFolderPathOut;
	private String mLibraryBinAidlFolderPathOut;
	private String mLibraryRFilePathOut;
	private int mTargetApi = -1;
	private boolean mVerbose = false;

	public void setLibraryManifestFilePathOut(String libraryManifestFilePathOut) {
	mLibraryManifestFilePathOut = libraryManifestFilePathOut;
	}

	public void setLibraryResFolderPathOut(String libraryResFolderPathOut) {
	mLibraryResFolderPathOut = libraryResFolderPathOut;
	}

	public void setLibraryPackagesOut(String libraryPackagesOut) {
	mLibraryPackagesOut = libraryPackagesOut;
	}

	public void setJarLibraryPathOut(String jarLibraryPathOut) {
	mJarLibraryPathOut = jarLibraryPathOut;
	}

	public void setLibraryBinAidlFolderPathOut(String libraryBinAidlFolderPathOut) {
	mLibraryBinAidlFolderPathOut = libraryBinAidlFolderPathOut;
	}

	public void setLibraryRFilePathOut(String libraryRFilePathOut) {
	mLibraryRFilePathOut = libraryRFilePathOut;
	}

	public void setLibraryNativeFolderPathOut(String libraryNativeFolderPathOut) {
	mLibraryNativeFolderPathOut = libraryNativeFolderPathOut;
	}

	public void setTargetApi(int targetApi) {
	mTargetApi = targetApi;
	}

	@Override
	public void execute() throws BuildException {
	if (mLibraryManifestFilePathOut == null) {
	throw new BuildException("Missing attribute libraryManifestFilePathOut");
	}
	if (mLibraryResFolderPathOut == null) {
	throw new BuildException("Missing attribute libraryResFolderPathOut");
	}
	if (mLibraryPackagesOut == null) {
	throw new BuildException("Missing attribute libraryPackagesOut");
	}
	if (mJarLibraryPathOut == null) {
	throw new BuildException("Missing attribute jarLibraryPathOut");
	}
	if (mLibraryNativeFolderPathOut == null) {
	throw new BuildException("Missing attribute libraryNativeFolderPathOut");
	}
	if (mLibraryBinAidlFolderPathOut == null) {
	throw new BuildException("Missing attribute libraryBinFolderPathOut");
	}
	if (mLibraryRFilePathOut == null) {
	throw new BuildException("Missing attribute libraryRFilePathOut");
	}
	if (mTargetApi == -1) {
	throw new BuildException("Missing attribute targetApi");
	}

	final Project antProject = getProject();

	// get the SDK location
	File sdkDir = TaskHelper.getSdkLocation(antProject);

	// prepare several paths for future tasks
	final Path manifestFilePath = new Path(antProject);
	final Path resFolderPath = new Path(antProject);
	final Path nativeFolderPath = new Path(antProject);
	final Path binAidlFolderPath = new Path(antProject);
	final Path rFilePath = new Path(antProject);
	final StringBuilder packageStrBuilder = new StringBuilder();

	// custom jar processor doing a bit more than just collecting the jar files
	JarProcessor processor = new JarProcessor() {
	@Override
	public void processLibrary(String libRootPath, IPropertySource properties) {
	// let the super class handle the jar files
	super.processLibrary(libRootPath, properties);

	// get the AndroidManifest.xml path.
	// FIXME: support renamed location.
	PathElement element = manifestFilePath.createPathElement();
	element.setPath(libRootPath + '/' + SdkConstants.FN_ANDROID_MANIFEST_XML);

	// get the res path. $PROJECT/res as well as the crunch cache.
	// FIXME: support renamed folders.
	element = resFolderPath.createPathElement();
	element.setPath(libRootPath + '/' + SdkConstants.FD_OUTPUT +
	'/' + SdkConstants.FD_RES);
	element = resFolderPath.createPathElement();
	element.setPath(libRootPath + '/' + SdkConstants.FD_RESOURCES);

	// get the folder for the native libraries. Always $PROJECT/libs
	// FIXME: support renamed folder and/or move libs to bin/libs/
	element = nativeFolderPath.createPathElement();
	element.setPath(libRootPath + '/' + SdkConstants.FD_NATIVE_LIBS);

	// get the bin/aidl folder. $PROJECT/bin/aidl for now
	// FIXME: support renamed folder.
	element = binAidlFolderPath.createPathElement();
	element.setPath(libRootPath + '/' + SdkConstants.FD_OUTPUT +
	'/' + SdkConstants.FD_AIDL);

	// get the package from the manifest.
	FileWrapper manifest = new FileWrapper(libRootPath,
	SdkConstants.FN_ANDROID_MANIFEST_XML);

	try {
	String value = AndroidManifest.getPackage(manifest);
	if (value != null) { // aapt will complain if it's missing.
	packageStrBuilder.append(';');
	packageStrBuilder.append(value);

	// get the text R file. $PROJECT/bin/R.txt for now
	// This must be in sync with the package list.
	// FIXME: support renamed folder.
	element = rFilePath.createPathElement();
	element.setPath(libRootPath + "/" + SdkConstants.FD_OUTPUT +
	"/" + "R.txt");

	}
	} catch (Exception e) {
	throw new BuildException(e);
	}
	}
	};

	// list of all the jars that are on the classpath. This will receive the
	// project's libs/.jar files, the Library Projects output and their own libs/.jar
	List<File> jars = processor.getJars();


	// in case clean has been called before a build type target, the list of
	// libraries has already been computed so we don't need to compute it again.
	Path libraryFolderPath = (Path) antProject.getReference(getLibraryFolderPathOut());
	if (libraryFolderPath == null) {
	execute(processor);
	} else {
	// this contains the list of library folder in reverse order (compilation order).
	// We need to process it in the normal order (res order).
	System.out.println("Ordered libraries:");

	String[] libraries = libraryFolderPath.list();
	for (int i = libraries.length - 1 ; i >= 0 ; i--) {
	String libRootPath = libraries[i];
	System.out.println(libRootPath);

	processor.processLibrary(libRootPath);
	}
	}

	boolean hasLibraries = jars.size() > 0;

	if (mTargetApi <= 15) {
	System.out.println("\n------------------");
	System.out.println("API<=15: Adding annotations.jar to the classpath.");

	jars.add(new File(sdkDir, SdkConstants.FD_TOOLS +
	'/' + SdkConstants.FD_SUPPORT +
	'/' + SdkConstants.FN_ANNOTATIONS_JAR));

	}

	// even with no libraries, always setup these so that various tasks in Ant don't complain
	// (the task themselves can handle a ref to an empty Path)
	antProject.addReference(mLibraryNativeFolderPathOut, nativeFolderPath);
	antProject.addReference(mLibraryManifestFilePathOut, manifestFilePath);
	antProject.addReference(mLibraryBinAidlFolderPathOut, binAidlFolderPath);

	// the rest is done only if there's a library.
	if (hasLibraries) {
	antProject.addReference(mLibraryResFolderPathOut, resFolderPath);
	antProject.setProperty(mLibraryPackagesOut, packageStrBuilder.toString());
	antProject.addReference(mLibraryRFilePathOut, rFilePath);
	}

	File projectFolder = antProject.getBaseDir();

	// add the project's own content of libs/*.jar
	File libsFolder = new File(projectFolder, SdkConstants.FD_NATIVE_LIBS);
	File[] jarFiles = libsFolder.listFiles(processor.getFilter());
	if (jarFiles != null) {
	for (File jarFile : jarFiles) {
	jars.add(jarFile);
	}
	}

	// now sanitize the path to remove dups
	jars = DependencyHelper.sanitizePaths(projectFolder, new IPropertySource() {
	@Override
	public String getProperty(String name) {
	return antProject.getProperty(name);
	}

	@Override
	public void debugPrint() {
	}
	}, jars);

	// and create a Path object for them
	Path jarsPath = new Path(antProject);
	if (mVerbose) {
	System.out.println("\n------------------\nSanitized jar list:");
	}
	for (File f : jars) {
	if (mVerbose) {
	System.out.println("- " + f.getAbsolutePath());
	}
	PathElement element = jarsPath.createPathElement();
	element.setPath(f.getAbsolutePath());
	}
	antProject.addReference(mJarLibraryPathOut, jarsPath);

	if (mVerbose) {
	System.out.println();
	}
	}
	}