tools/layoutlib/create/src/com/android/tools/layoutlib/create/AsmGenerator.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2008 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.tools.layoutlib.create;

 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.ClassVisitor;
 import org.objectweb.asm.ClassWriter;

 import java.io.ByteArrayOutputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.ListIterator;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.jar.JarEntry;
 import java.util.jar.JarOutputStream;

 /**
  * Class that generates a new JAR from a list of classes, some of which are to be kept as-is
  * and some of which are to be stubbed partially or totally.
  */
 public class AsmGenerator {

     /** Output logger. */
     private final Log mLog;
     /** The path of the destination JAR to create. */
     private final String mOsDestJar;
     /** List of classes to inject in the final JAR from _this_ archive. */
     private final Class<?>[] mInjectClasses;
     /** The set of methods to stub out. */
     private final Set<String> mStubMethods;
     /** All classes to output as-is, except if they have native methods. */
     private Map<String, ClassReader> mKeep;
     /** All dependencies that must be completely stubbed. */
     private Map<String, ClassReader> mDeps;
     /** All files that are to be copied as-is. */
     private Map<String, InputStream> mCopyFiles;
     /** All classes where certain method calls need to be rewritten. */
     private Set<String> mReplaceMethodCallsClasses;
     /** Counter of number of classes renamed during transform. */
     private int mRenameCount;
     /** FQCN Names of the classes to rename: map old-FQCN => new-FQCN */
     private final HashMap<String, String> mRenameClasses;
     /** FQCN Names of "old" classes that were NOT renamed. This starts with the full list of
      *  old-FQCN to rename and they get erased as they get renamed. At the end, classes still
      *  left here are not in the code base anymore and thus were not renamed. */
     private HashSet<String> mClassesNotRenamed;
     /** A map { FQCN => set { list of return types to delete from the FQCN } }. */
     private HashMap<String, Set<String>> mDeleteReturns;
     /** A map { FQCN => set { method names } } of methods to rewrite as delegates.
      *  The special name {@link DelegateClassAdapter#ALL_NATIVES} can be used as in internal set. */
     private final HashMap<String, Set<String>> mDelegateMethods;
     /** FQCN Names of classes to refactor. All reference to old-FQCN will be updated to new-FQCN.
      * map old-FQCN => new-FQCN */
     private final HashMap<String, String> mRefactorClasses;
     /** Methods to inject. FQCN of class in which method should be injected => runnable that does
      * the injection. */
     private final Map<String, ICreateInfo.InjectMethodRunnable> mInjectedMethodsMap;
     /** A map { FQCN => set { field names } } which should be promoted to public visibility */
     private final Map<String, Set<String>> mPromotedFields;

     /**
      * Creates a new generator that can generate the output JAR with the stubbed classes.
      *
      * @param log Output logger.
      * @param osDestJar The path of the destination JAR to create.
      * @param createInfo Creation parameters. Must not be null.
      */
     public AsmGenerator(Log log, String osDestJar, ICreateInfo createInfo) {
         mLog = log;
         mOsDestJar = osDestJar;
         ArrayList<Class<?>> injectedClasses =
                 new ArrayList<Class<?>>(Arrays.asList(createInfo.getInjectedClasses()));
         // Search for and add anonymous inner classes also.
         ListIterator<Class<?>> iter = injectedClasses.listIterator();
         while (iter.hasNext()) {
             Class<?> clazz = iter.next();
             try {
                 int i = 1;
                 while(i < 100) {
                     iter.add(Class.forName(clazz.getName() + "$" + i));
                     i++;
                 }
             } catch (ClassNotFoundException ignored) {
                 // Expected.
             }
         }
         mInjectClasses = injectedClasses.toArray(new Class<?>[0]);
         mStubMethods = new HashSet<String>(Arrays.asList(createInfo.getOverriddenMethods()));

         // Create the map/set of methods to change to delegates
         mDelegateMethods = new HashMap<String, Set<String>>();
         addToMap(createInfo.getDelegateMethods(), mDelegateMethods);

         for (String className : createInfo.getDelegateClassNatives()) {
             className = binaryToInternalClassName(className);
             Set<String> methods = mDelegateMethods.get(className);
             if (methods == null) {
                 methods = new HashSet<String>();
                 mDelegateMethods.put(className, methods);
             }
             methods.add(DelegateClassAdapter.ALL_NATIVES);
         }

         // Create the map of classes to rename.
         mRenameClasses = new HashMap<String, String>();
         mClassesNotRenamed = new HashSet<String>();
         String[] renameClasses = createInfo.getRenamedClasses();
         int n = renameClasses.length;
         for (int i = 0; i < n; i += 2) {
             assert i + 1 < n;
             // The ASM class names uses "/" separators, whereas regular FQCN use "."
             String oldFqcn = binaryToInternalClassName(renameClasses[i]);
             String newFqcn = binaryToInternalClassName(renameClasses[i + 1]);
             mRenameClasses.put(oldFqcn, newFqcn);
             mClassesNotRenamed.add(oldFqcn);
         }

         // Create a map of classes to be refactored.
         mRefactorClasses = new HashMap<String, String>();
         String[] refactorClasses = createInfo.getJavaPkgClasses();
         n = refactorClasses.length;
         for (int i = 0; i < n; i += 2) {
             assert i + 1 < n;
             String oldFqcn = binaryToInternalClassName(refactorClasses[i]);
             String newFqcn = binaryToInternalClassName(refactorClasses[i + 1]);
             mRefactorClasses.put(oldFqcn, newFqcn);
         }

         // create the map of renamed class -> return type of method to delete.
         mDeleteReturns = new HashMap<String, Set<String>>();
         String[] deleteReturns = createInfo.getDeleteReturns();
         Set<String> returnTypes = null;
         String renamedClass = null;
         for (String className : deleteReturns) {
             // if we reach the end of a section, add it to the main map
             if (className == null) {
                 if (returnTypes != null) {
                     mDeleteReturns.put(renamedClass, returnTypes);
                 }

                 renamedClass = null;
                 continue;
             }

             // if the renamed class is null, this is the beginning of a section
             if (renamedClass == null) {
                 renamedClass = binaryToInternalClassName(className);
                 continue;
             }

             // just a standard return type, we add it to the list.
             if (returnTypes == null) {
                 returnTypes = new HashSet<String>();
             }
             returnTypes.add(binaryToInternalClassName(className));
         }

         mPromotedFields = new HashMap<String, Set<String>>();
         addToMap(createInfo.getPromotedFields(), mPromotedFields);

         mInjectedMethodsMap = createInfo.getInjectedMethodsMap();
     }

     /**
      * For each value in the array, split the value on '#' and add the parts to the map as key
      * and value.
      */
     private void addToMap(String[] entries, Map<String, Set<String>> map) {
         for (String entry : entries) {
             int pos = entry.indexOf('#');
             if (pos <= 0 || pos >= entry.length() - 1) {
                 return;
             }
             String className = binaryToInternalClassName(entry.substring(0, pos));
             String methodOrFieldName = entry.substring(pos + 1);
             Set<String> set = map.get(className);
             if (set == null) {
                 set = new HashSet<String>();
                 map.put(className, set);
             }
             set.add(methodOrFieldName);
         }
     }

     /**
      * Returns the list of classes that have not been renamed yet.
      * <p/>
      * The names are "internal class names" rather than FQCN, i.e. they use "/" instead "."
      * as package separators.
      */
     public Set<String> getClassesNotRenamed() {
         return mClassesNotRenamed;
     }

     /**
      * Utility that returns the internal ASM class name from a fully qualified binary class
      * name. E.g. it returns android/view/View from android.view.View.
      */
     String binaryToInternalClassName(String className) {
         if (className == null) {
             return null;
         } else {
             return className.replace('.', '/');
         }
     }

     /** Sets the map of classes to output as-is, except if they have native methods */
     public void setKeep(Map<String, ClassReader> keep) {
         mKeep = keep;
     }

     /** Sets the map of dependencies that must be completely stubbed */
     public void setDeps(Map<String, ClassReader> deps) {
         mDeps = deps;
     }

     /** Sets the map of files to output as-is. */
     public void setCopyFiles(Map<String, InputStream> copyFiles) {
         mCopyFiles = copyFiles;
     }

     public void setRewriteMethodCallClasses(Set<String> rewriteMethodCallClasses) {
         mReplaceMethodCallsClasses = rewriteMethodCallClasses;
     }

     /** Generates the final JAR */
     public void generate() throws IOException {
         TreeMap<String, byte[]> all = new TreeMap<String, byte[]>();

         for (Class<?> clazz : mInjectClasses) {
             String name = classToEntryPath(clazz);
             InputStream is = ClassLoader.getSystemResourceAsStream(name);
             ClassReader cr = new ClassReader(is);
             byte[] b = transform(cr, true);
             name = classNameToEntryPath(transformName(cr.getClassName()));
             all.put(name, b);
         }

         for (Entry<String, ClassReader> entry : mDeps.entrySet()) {
             ClassReader cr = entry.getValue();
             byte[] b = transform(cr, true);
             String name = classNameToEntryPath(transformName(cr.getClassName()));
             all.put(name, b);
         }

         for (Entry<String, ClassReader> entry : mKeep.entrySet()) {
             ClassReader cr = entry.getValue();
             byte[] b = transform(cr, true);
             String name = classNameToEntryPath(transformName(cr.getClassName()));
             all.put(name, b);
         }

         for (Entry<String, InputStream> entry : mCopyFiles.entrySet()) {
             try {
                 byte[] b = inputStreamToByteArray(entry.getValue());
                 all.put(entry.getKey(), b);
             } catch (IOException e) {
                 // Ignore.
             }

         }
         mLog.info("# deps classes: %d", mDeps.size());
         mLog.info("# keep classes: %d", mKeep.size());
         mLog.info("# renamed     : %d", mRenameCount);

         createJar(new FileOutputStream(mOsDestJar), all);
         mLog.info("Created JAR file %s", mOsDestJar);
     }

     /**
      * Writes the JAR file.
      *
      * @param outStream The file output stream were to write the JAR.
      * @param all The map of all classes to output.
      * @throws IOException if an I/O error has occurred
      */
     void createJar(FileOutputStream outStream, Map<String,byte[]> all) throws IOException {
         JarOutputStream jar = new JarOutputStream(outStream);
         for (Entry<String, byte[]> entry : all.entrySet()) {
             String name = entry.getKey();
             JarEntry jar_entry = new JarEntry(name);
             jar.putNextEntry(jar_entry);
             jar.write(entry.getValue());
             jar.closeEntry();
         }
         jar.flush();
         jar.close();
     }

     /**
      * Utility method that converts a fully qualified java name into a JAR entry path
      * e.g. for the input "android.view.View" it returns "android/view/View.class"
      */
     String classNameToEntryPath(String className) {
         return className.replaceAll("\\.", "/").concat(".class");
     }

     /**
      * Utility method to get the JAR entry path from a Class name.
      * e.g. it returns something like "com/foo/OuterClass$InnerClass1$InnerClass2.class"
      */
     private String classToEntryPath(Class<?> clazz) {
         return classNameToEntryPath(clazz.getName());
     }

     /**
      * Transforms a class.
      * <p/>
      * There are 3 kind of transformations:
      *
      * 1- For "mock" dependencies classes, we want to remove all code from methods and replace
      * by a stub. Native methods must be implemented with this stub too. Abstract methods are
      * left intact. Modified classes must be overridable (non-private, non-final).
      * Native methods must be made non-final, non-private.
      *
      * 2- For "keep" classes, we want to rewrite all native methods as indicated above.
      * If a class has native methods, it must also be made non-private, non-final.
      *
      * Note that unfortunately static methods cannot be changed to non-static (since static and
      * non-static are invoked differently.)
      */
     byte[] transform(ClassReader cr, boolean stubNativesOnly) {

         boolean hasNativeMethods = hasNativeMethods(cr);

         // Get the class name, as an internal name (e.g. com/android/SomeClass$InnerClass)
         String className = cr.getClassName();

         String newName = transformName(className);
         // transformName returns its input argument if there's no need to rename the class
         if (!newName.equals(className)) {
             mRenameCount++;
             // This class is being renamed, so remove it from the list of classes not renamed.
             mClassesNotRenamed.remove(className);
         }

         mLog.debug("Transform %s%s%s%s", className,
                 newName.equals(className) ? "" : " (renamed to " + newName + ")",
                 hasNativeMethods ? " -- has natives" : "",
                 stubNativesOnly ? " -- stub natives only" : "");

         // Rewrite the new class from scratch, without reusing the constant pool from the
         // original class reader.
         ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);

         ClassVisitor cv = cw;

         if (mReplaceMethodCallsClasses.contains(className)) {
             cv = new ReplaceMethodCallsAdapter(cv, className);
         }

         cv = new RefactorClassAdapter(cv, mRefactorClasses);
         if (!newName.equals(className)) {
             cv = new RenameClassAdapter(cv, className, newName);
         }

         String binaryNewName = newName.replace('/', '.');
         if (mInjectedMethodsMap.keySet().contains(binaryNewName)) {
             cv = new InjectMethodsAdapter(cv, mInjectedMethodsMap.get(binaryNewName));
         }
         cv = new TransformClassAdapter(mLog, mStubMethods, mDeleteReturns.get(className),
                 newName, cv, stubNativesOnly);

         Set<String> delegateMethods = mDelegateMethods.get(className);
         if (delegateMethods != null && !delegateMethods.isEmpty()) {
             // If delegateMethods only contains one entry ALL_NATIVES and the class is
             // known to have no native methods, just skip this step.
             if (hasNativeMethods ||
                     !(delegateMethods.size() == 1 &&
                             delegateMethods.contains(DelegateClassAdapter.ALL_NATIVES))) {
                 cv = new DelegateClassAdapter(mLog, cv, className, delegateMethods);
             }
         }

         Set<String> promoteFields = mPromotedFields.get(className);
         if (promoteFields != null && !promoteFields.isEmpty()) {
             cv = new PromoteFieldClassAdapter(cv, promoteFields);
         }
         cr.accept(cv, 0);
         return cw.toByteArray();
     }

     /**
      * Should this class be renamed, this returns the new name. Otherwise it returns the
      * original name.
      *
      * @param className The internal ASM name of the class that may have to be renamed
      * @return A new transformed name or the original input argument.
      */
     String transformName(String className) {
         String newName = mRenameClasses.get(className);
         if (newName != null) {
             return newName;
         }
         int pos = className.indexOf('$');
         if (pos > 0) {
             // Is this an inner class of a renamed class?
             String base = className.substring(0, pos);
             newName = mRenameClasses.get(base);
             if (newName != null) {
                 return newName + className.substring(pos);
             }
         }

         return className;
     }

     /**
      * Returns true if a class has any native methods.
      */
     boolean hasNativeMethods(ClassReader cr) {
         ClassHasNativeVisitor cv = new ClassHasNativeVisitor();
         cr.accept(cv, 0);
         return cv.hasNativeMethods();
     }

     private byte[] inputStreamToByteArray(InputStream is) throws IOException {
         ByteArrayOutputStream buffer = new ByteArrayOutputStream();
         byte[] data = new byte[8192];  // 8KB
         int n;
         while ((n = is.read(data, 0, data.length)) != -1) {
             buffer.write(data, 0, n);
         }
         return buffer.toByteArray();
     }
 }
	/*
	* Copyright (C) 2008 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.tools.layoutlib.create;

	import org.objectweb.asm.ClassReader;
	import org.objectweb.asm.ClassVisitor;
	import org.objectweb.asm.ClassWriter;

	import java.io.ByteArrayOutputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.ListIterator;
	import java.util.Map;
	import java.util.Map.Entry;
	import java.util.Set;
	import java.util.TreeMap;
	import java.util.jar.JarEntry;
	import java.util.jar.JarOutputStream;

	/**
	* Class that generates a new JAR from a list of classes, some of which are to be kept as-is
	* and some of which are to be stubbed partially or totally.
	*/
	public class AsmGenerator {

	/** Output logger. */
	private final Log mLog;
	/** The path of the destination JAR to create. */
	private final String mOsDestJar;
	/** List of classes to inject in the final JAR from _this_ archive. */
	private final Class<?>[] mInjectClasses;
	/** The set of methods to stub out. */
	private final Set<String> mStubMethods;
	/** All classes to output as-is, except if they have native methods. */
	private Map<String, ClassReader> mKeep;
	/** All dependencies that must be completely stubbed. */
	private Map<String, ClassReader> mDeps;
	/** All files that are to be copied as-is. */
	private Map<String, InputStream> mCopyFiles;
	/** All classes where certain method calls need to be rewritten. */
	private Set<String> mReplaceMethodCallsClasses;
	/** Counter of number of classes renamed during transform. */
	private int mRenameCount;
	/** FQCN Names of the classes to rename: map old-FQCN => new-FQCN */
	private final HashMap<String, String> mRenameClasses;
	/** FQCN Names of "old" classes that were NOT renamed. This starts with the full list of
	* old-FQCN to rename and they get erased as they get renamed. At the end, classes still
	* left here are not in the code base anymore and thus were not renamed. */
	private HashSet<String> mClassesNotRenamed;
	/** A map { FQCN => set { list of return types to delete from the FQCN } }. */
	private HashMap<String, Set<String>> mDeleteReturns;
	/** A map { FQCN => set { method names } } of methods to rewrite as delegates.
	* The special name {@link DelegateClassAdapter#ALL_NATIVES} can be used as in internal set. */
	private final HashMap<String, Set<String>> mDelegateMethods;
	/** FQCN Names of classes to refactor. All reference to old-FQCN will be updated to new-FQCN.
	* map old-FQCN => new-FQCN */
	private final HashMap<String, String> mRefactorClasses;
	/** Methods to inject. FQCN of class in which method should be injected => runnable that does
	* the injection. */
	private final Map<String, ICreateInfo.InjectMethodRunnable> mInjectedMethodsMap;
	/** A map { FQCN => set { field names } } which should be promoted to public visibility */
	private final Map<String, Set<String>> mPromotedFields;

	/**
	* Creates a new generator that can generate the output JAR with the stubbed classes.
	*
	* @param log Output logger.
	* @param osDestJar The path of the destination JAR to create.
	* @param createInfo Creation parameters. Must not be null.
	*/
	public AsmGenerator(Log log, String osDestJar, ICreateInfo createInfo) {
	mLog = log;
	mOsDestJar = osDestJar;
	ArrayList<Class<?>> injectedClasses =
	new ArrayList<Class<?>>(Arrays.asList(createInfo.getInjectedClasses()));
	// Search for and add anonymous inner classes also.
	ListIterator<Class<?>> iter = injectedClasses.listIterator();
	while (iter.hasNext()) {
	Class<?> clazz = iter.next();
	try {
	int i = 1;
	while(i < 100) {
	iter.add(Class.forName(clazz.getName() + "$" + i));
	i++;
	}
	} catch (ClassNotFoundException ignored) {
	// Expected.
	}
	}
	mInjectClasses = injectedClasses.toArray(new Class<?>[0]);
	mStubMethods = new HashSet<String>(Arrays.asList(createInfo.getOverriddenMethods()));

	// Create the map/set of methods to change to delegates
	mDelegateMethods = new HashMap<String, Set<String>>();
	addToMap(createInfo.getDelegateMethods(), mDelegateMethods);

	for (String className : createInfo.getDelegateClassNatives()) {
	className = binaryToInternalClassName(className);
	Set<String> methods = mDelegateMethods.get(className);
	if (methods == null) {
	methods = new HashSet<String>();
	mDelegateMethods.put(className, methods);
	}
	methods.add(DelegateClassAdapter.ALL_NATIVES);
	}

	// Create the map of classes to rename.
	mRenameClasses = new HashMap<String, String>();
	mClassesNotRenamed = new HashSet<String>();
	String[] renameClasses = createInfo.getRenamedClasses();
	int n = renameClasses.length;
	for (int i = 0; i < n; i += 2) {
	assert i + 1 < n;
	// The ASM class names uses "/" separators, whereas regular FQCN use "."
	String oldFqcn = binaryToInternalClassName(renameClasses[i]);
	String newFqcn = binaryToInternalClassName(renameClasses[i + 1]);
	mRenameClasses.put(oldFqcn, newFqcn);
	mClassesNotRenamed.add(oldFqcn);
	}

	// Create a map of classes to be refactored.
	mRefactorClasses = new HashMap<String, String>();
	String[] refactorClasses = createInfo.getJavaPkgClasses();
	n = refactorClasses.length;
	for (int i = 0; i < n; i += 2) {
	assert i + 1 < n;
	String oldFqcn = binaryToInternalClassName(refactorClasses[i]);
	String newFqcn = binaryToInternalClassName(refactorClasses[i + 1]);
	mRefactorClasses.put(oldFqcn, newFqcn);
	}

	// create the map of renamed class -> return type of method to delete.
	mDeleteReturns = new HashMap<String, Set<String>>();
	String[] deleteReturns = createInfo.getDeleteReturns();
	Set<String> returnTypes = null;
	String renamedClass = null;
	for (String className : deleteReturns) {
	// if we reach the end of a section, add it to the main map
	if (className == null) {
	if (returnTypes != null) {
	mDeleteReturns.put(renamedClass, returnTypes);
	}

	renamedClass = null;
	continue;
	}

	// if the renamed class is null, this is the beginning of a section
	if (renamedClass == null) {
	renamedClass = binaryToInternalClassName(className);
	continue;
	}

	// just a standard return type, we add it to the list.
	if (returnTypes == null) {
	returnTypes = new HashSet<String>();
	}
	returnTypes.add(binaryToInternalClassName(className));
	}

	mPromotedFields = new HashMap<String, Set<String>>();
	addToMap(createInfo.getPromotedFields(), mPromotedFields);

	mInjectedMethodsMap = createInfo.getInjectedMethodsMap();
	}

	/**
	* For each value in the array, split the value on '#' and add the parts to the map as key
	* and value.
	*/
	private void addToMap(String[] entries, Map<String, Set<String>> map) {
	for (String entry : entries) {
	int pos = entry.indexOf('#');
	if (pos <= 0 \|\| pos >= entry.length() - 1) {
	return;
	}
	String className = binaryToInternalClassName(entry.substring(0, pos));
	String methodOrFieldName = entry.substring(pos + 1);
	Set<String> set = map.get(className);
	if (set == null) {
	set = new HashSet<String>();
	map.put(className, set);
	}
	set.add(methodOrFieldName);
	}
	}

	/**
	* Returns the list of classes that have not been renamed yet.
	* <p/>
	* The names are "internal class names" rather than FQCN, i.e. they use "/" instead "."
	* as package separators.
	*/
	public Set<String> getClassesNotRenamed() {
	return mClassesNotRenamed;
	}

	/**
	* Utility that returns the internal ASM class name from a fully qualified binary class
	* name. E.g. it returns android/view/View from android.view.View.
	*/
	String binaryToInternalClassName(String className) {
	if (className == null) {
	return null;
	} else {
	return className.replace('.', '/');
	}
	}

	/** Sets the map of classes to output as-is, except if they have native methods */
	public void setKeep(Map<String, ClassReader> keep) {
	mKeep = keep;
	}

	/** Sets the map of dependencies that must be completely stubbed */
	public void setDeps(Map<String, ClassReader> deps) {
	mDeps = deps;
	}

	/** Sets the map of files to output as-is. */
	public void setCopyFiles(Map<String, InputStream> copyFiles) {
	mCopyFiles = copyFiles;
	}

	public void setRewriteMethodCallClasses(Set<String> rewriteMethodCallClasses) {
	mReplaceMethodCallsClasses = rewriteMethodCallClasses;
	}

	/** Generates the final JAR */
	public void generate() throws IOException {
	TreeMap<String, byte[]> all = new TreeMap<String, byte[]>();

	for (Class<?> clazz : mInjectClasses) {
	String name = classToEntryPath(clazz);
	InputStream is = ClassLoader.getSystemResourceAsStream(name);
	ClassReader cr = new ClassReader(is);
	byte[] b = transform(cr, true);
	name = classNameToEntryPath(transformName(cr.getClassName()));
	all.put(name, b);
	}

	for (Entry<String, ClassReader> entry : mDeps.entrySet()) {
	ClassReader cr = entry.getValue();
	byte[] b = transform(cr, true);
	String name = classNameToEntryPath(transformName(cr.getClassName()));
	all.put(name, b);
	}

	for (Entry<String, ClassReader> entry : mKeep.entrySet()) {
	ClassReader cr = entry.getValue();
	byte[] b = transform(cr, true);
	String name = classNameToEntryPath(transformName(cr.getClassName()));
	all.put(name, b);
	}

	for (Entry<String, InputStream> entry : mCopyFiles.entrySet()) {
	try {
	byte[] b = inputStreamToByteArray(entry.getValue());
	all.put(entry.getKey(), b);
	} catch (IOException e) {
	// Ignore.
	}

	}
	mLog.info("# deps classes: %d", mDeps.size());
	mLog.info("# keep classes: %d", mKeep.size());
	mLog.info("# renamed : %d", mRenameCount);

	createJar(new FileOutputStream(mOsDestJar), all);
	mLog.info("Created JAR file %s", mOsDestJar);
	}

	/**
	* Writes the JAR file.
	*
	* @param outStream The file output stream were to write the JAR.
	* @param all The map of all classes to output.
	* @throws IOException if an I/O error has occurred
	*/
	void createJar(FileOutputStream outStream, Map<String,byte[]> all) throws IOException {
	JarOutputStream jar = new JarOutputStream(outStream);
	for (Entry<String, byte[]> entry : all.entrySet()) {
	String name = entry.getKey();
	JarEntry jar_entry = new JarEntry(name);
	jar.putNextEntry(jar_entry);
	jar.write(entry.getValue());
	jar.closeEntry();
	}
	jar.flush();
	jar.close();
	}

	/**
	* Utility method that converts a fully qualified java name into a JAR entry path
	* e.g. for the input "android.view.View" it returns "android/view/View.class"
	*/
	String classNameToEntryPath(String className) {
	return className.replaceAll("\\.", "/").concat(".class");
	}

	/**
	* Utility method to get the JAR entry path from a Class name.
	* e.g. it returns something like "com/foo/OuterClass$InnerClass1$InnerClass2.class"
	*/
	private String classToEntryPath(Class<?> clazz) {
	return classNameToEntryPath(clazz.getName());
	}

	/**
	* Transforms a class.
	* <p/>
	* There are 3 kind of transformations:
	*
	* 1- For "mock" dependencies classes, we want to remove all code from methods and replace
	* by a stub. Native methods must be implemented with this stub too. Abstract methods are
	* left intact. Modified classes must be overridable (non-private, non-final).
	* Native methods must be made non-final, non-private.
	*
	* 2- For "keep" classes, we want to rewrite all native methods as indicated above.
	* If a class has native methods, it must also be made non-private, non-final.
	*
	* Note that unfortunately static methods cannot be changed to non-static (since static and
	* non-static are invoked differently.)
	*/
	byte[] transform(ClassReader cr, boolean stubNativesOnly) {

	boolean hasNativeMethods = hasNativeMethods(cr);

	// Get the class name, as an internal name (e.g. com/android/SomeClass$InnerClass)
	String className = cr.getClassName();

	String newName = transformName(className);
	// transformName returns its input argument if there's no need to rename the class
	if (!newName.equals(className)) {
	mRenameCount++;
	// This class is being renamed, so remove it from the list of classes not renamed.
	mClassesNotRenamed.remove(className);
	}

	mLog.debug("Transform %s%s%s%s", className,
	newName.equals(className) ? "" : " (renamed to " + newName + ")",
	hasNativeMethods ? " -- has natives" : "",
	stubNativesOnly ? " -- stub natives only" : "");

	// Rewrite the new class from scratch, without reusing the constant pool from the
	// original class reader.
	ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);

	ClassVisitor cv = cw;

	if (mReplaceMethodCallsClasses.contains(className)) {
	cv = new ReplaceMethodCallsAdapter(cv, className);
	}

	cv = new RefactorClassAdapter(cv, mRefactorClasses);
	if (!newName.equals(className)) {
	cv = new RenameClassAdapter(cv, className, newName);
	}

	String binaryNewName = newName.replace('/', '.');
	if (mInjectedMethodsMap.keySet().contains(binaryNewName)) {
	cv = new InjectMethodsAdapter(cv, mInjectedMethodsMap.get(binaryNewName));
	}
	cv = new TransformClassAdapter(mLog, mStubMethods, mDeleteReturns.get(className),
	newName, cv, stubNativesOnly);

	Set<String> delegateMethods = mDelegateMethods.get(className);
	if (delegateMethods != null && !delegateMethods.isEmpty()) {
	// If delegateMethods only contains one entry ALL_NATIVES and the class is
	// known to have no native methods, just skip this step.
	if (hasNativeMethods \|\|
	!(delegateMethods.size() == 1 &&
	delegateMethods.contains(DelegateClassAdapter.ALL_NATIVES))) {
	cv = new DelegateClassAdapter(mLog, cv, className, delegateMethods);
	}
	}

	Set<String> promoteFields = mPromotedFields.get(className);
	if (promoteFields != null && !promoteFields.isEmpty()) {
	cv = new PromoteFieldClassAdapter(cv, promoteFields);
	}
	cr.accept(cv, 0);
	return cw.toByteArray();
	}

	/**
	* Should this class be renamed, this returns the new name. Otherwise it returns the
	* original name.
	*
	* @param className The internal ASM name of the class that may have to be renamed
	* @return A new transformed name or the original input argument.
	*/
	String transformName(String className) {
	String newName = mRenameClasses.get(className);
	if (newName != null) {
	return newName;
	}
	int pos = className.indexOf('$');
	if (pos > 0) {
	// Is this an inner class of a renamed class?
	String base = className.substring(0, pos);
	newName = mRenameClasses.get(base);
	if (newName != null) {
	return newName + className.substring(pos);
	}
	}

	return className;
	}

	/**
	* Returns true if a class has any native methods.
	*/
	boolean hasNativeMethods(ClassReader cr) {
	ClassHasNativeVisitor cv = new ClassHasNativeVisitor();
	cr.accept(cv, 0);
	return cv.hasNativeMethods();
	}

	private byte[] inputStreamToByteArray(InputStream is) throws IOException {
	ByteArrayOutputStream buffer = new ByteArrayOutputStream();
	byte[] data = new byte[8192]; // 8KB
	int n;
	while ((n = is.read(data, 0, data.length)) != -1) {
	buffer.write(data, 0, n);
	}
	return buffer.toByteArray();
	}
	}