Android编译及Dex过程源码分析

BasePlugin.apply(Project) -> createTasks() -> createAndroidTasks(boolean force) -> VariantManager.createAndroidTasks() 

  ///build-system/gradle-core/src/main/groovy/com/android/build/gradle/internal/ApplicationTaskManager.java   public void createTasksForVariantData(         @NonNull final TaskFactory tasks,         @NonNull final BaseVariantData<? extends BaseVariantOutputData> variantData) {     assert variantData instanceof ApplicationVariantData;     final ApplicationVariantData appVariantData = (ApplicationVariantData) variantData;      final VariantScope variantScope = variantData.getScope();      //create sourceGenTask, resGenTask, assetGenTask and compileTask     createAnchorTasks(tasks, variantScope);     //create checkManifestTask     createCheckManifestTask(tasks, variantScope);      // Add a task to process the manifest(s)     // Add a task to create the res values     // Add a task to compile renderscript files.     // Add a task to merge the resource folders     // Add a task to merge the asset folders     // Add a task to create the BuildConfig class     // Add a task to process the Android Resources and generate source files     // Add a task to process the java resources     // Add a task to process the aidl     ......      // Add a compile task     ThreadRecorder.get().record(ExecutionType.APP_TASK_MANAGER_CREATE_COMPILE_TASK,             new Recorder.Block<Void>() {                 @Override                 public Void call() {                     AndroidTask<JavaCompile> javacTask = createJavacTask(tasks, variantScope);                      if (variantData.getVariantConfiguration().getUseJack()) {                         createJackTask(tasks, variantScope);                     } else {                         setJavaCompilerTask(javacTask, tasks, variantScope);                         createJarTask(tasks, variantScope);                         createPostCompilationTasks(tasks, variantScope);                     }                     return null;                 }             });      // Add NDK tasks     // Creates the final packaging task, and optionally the zipalign task     // create the lint tasks.     ...... } 

public void createPostCompilationTasks(TaskFactory tasks, @NonNull final VariantScope scope) {     checkNotNull(scope.getJavacTask());     boolean isMinifyEnabled = config.isMinifyEnabled();     boolean isMultiDexEnabled = config.isMultiDexEnabled() && !isTestForApp;     boolean isLegacyMultiDexMode = config.isLegacyMultiDexMode();      AndroidTask<CreateMainDexList> createMainDexListTask = null;     AndroidTask<RetraceMainDexList> retraceTask = null;      // Multi-Dex support     if (isMultiDexEnabled && isLegacyMultiDexMode) {         // Create a task to collect the list of manifest entry points which are needed in the primary dex         AndroidTask<CreateManifestKeepList> manifestKeepListTask = androidTasks.create(tasks,                 new CreateManifestKeepList.ConfigAction(scope, pcData));         manifestKeepListTask.dependsOn(tasks,                 variantData.getOutputs().get(0).getScope().getManifestProcessorTask());          // Create a proguard task to shrink the classes to manifest components         AndroidTask<ProGuardTask> proguardComponentsTask =                 androidTasks.create(tasks, new ProGuardTaskConfigAction(scope, pcData));         proguardComponentsTask.dependsOn(tasks, manifestKeepListTask);         proguardComponentsTask.optionalDependsOn(tasks,                 pcData.getClassGeneratingTasks(),                 pcData.getLibraryGeneratingTasks());          // Compute the full list of classes for the main dex file         createMainDexListTask =                 androidTasks.create(tasks, new CreateMainDexList.ConfigAction(scope, pcData));         createMainDexListTask.dependsOn(tasks, proguardComponentsTask);          // If proguard is enabled, create a de-obfuscated list to aid debugging.         if (isMinifyEnabled) {             retraceTask = androidTasks.create(tasks,                     new RetraceMainDexList.ConfigAction(scope, pcData));             retraceTask.dependsOn(tasks, scope.getObfuscationTask(), createMainDexListTask);         }      }       AndroidTask<Dex> dexTask = androidTasks.create(tasks, new Dex.ConfigAction(scope, pcData));     scope.setDexTask(dexTask);      // dependencies, some of these could be null     dexTask.optionalDependsOn(tasks,             pcData.getClassGeneratingTasks(),             pcData.getLibraryGeneratingTasks(),             createMainDexListTask,             retraceTask); } 

//build-system/gradle-core/src/main/groovy/com/android/build/gradle/tasks/Dex.groovy @TaskAction void taskAction(IncrementalTaskInputs inputs) {     Collection<File> _inputFiles = getInputFiles()     File _inputDir = getInputDir()     ......     doTaskAction(_inputFiles, _inputDir, !forceFullRun.get()) }  private void doTaskAction(         @Nullable Collection<File> inputFiles,         @Nullable File inputDir,         boolean incremental) {     ......     getBuilder().convertByteCode(             inputFiles,             getLibraries(),             outFolder,             getMultiDexEnabled(),             getMainDexListFile(),             getDexOptions(),             getAdditionalParameters(),             tmpFolder,             incremental,             getOptimize(),             new LoggedProcessOutputHandler(getILogger())  //build-system/builder/src/main/java/com/android/builder/core/AndroidBuilder.java //Converts the bytecode to Dalvik format public void convertByteCode(         @NonNull Collection<File> inputs,         @NonNull Collection<File> preDexedLibraries,         @NonNull File outDexFolder,                  boolean multidex,         @Nullable File mainDexList,         @NonNull DexOptions dexOptions,         @Nullable List<String> additionalParameters,         @NonNull File tmpFolder,         boolean incremental,         boolean optimize,         @NonNull ProcessOutputHandler processOutputHandler)         throws IOException, InterruptedException, ProcessException {     BuildToolInfo buildToolInfo = mTargetInfo.getBuildTools();     DexProcessBuilder builder = new DexProcessBuilder(outDexFolder);      builder.setVerbose(mVerboseExec)             .setIncremental(incremental)             .setNoOptimize(!optimize)             .setMultiDex(multidex)             .setMainDexList(mainDexList)             .addInputs(preDexedLibraries)             .addInputs(verifiedInputs.build());      if (additionalParameters != null) {         builder.additionalParameters(additionalParameters);     }      JavaProcessInfo javaProcessInfo = builder.build(buildToolInfo, dexOptions);     ProcessResult result = mJavaProcessExecutor.execute(javaProcessInfo, processOutputHandler); } 

//dalvik/dx/src/com/android/dx/command/Main.java public static void main(String[] args) {     ......     if (arg.equals("--dex")) {         com.android.dx.command.dexer.Main.main(without(args, i));         break;     }     ...... }  //dalvik/dx/src/com/android/dx/command/dexer/Main.java public static void main(String[] argArray) throws IOException {     Arguments arguments = new Arguments();     arguments.parse(argArray);      int result = run(arguments);     if (result != 0) {         System.exit(result);     } }  public static int run(Arguments arguments) throws IOException {         args = arguments;     ......         if (args.multiDex) {         return runMultiDex();     } else {         return runMonoDex();     } } 

//dalvik/dx/src/com/android/dx/command/dexer/Main.java private static int runMultiDex() throws IOException {     dexOutPool = Executors.newFixedThreadPool(args.numThreads);      if (!processAllFiles()) {         return 1;     }      ......          if (args.jarOutput) {         for (int i = 0; i < dexOutputArrays.size(); i++) {             outputResources.put(getDexFileName(i),                     dexOutputArrays.get(i));         }          if (!createJar(args.outName)) {             return 3;         }     } else if (args.outName != null) {         File outDir = new File(args.outName);         assert outDir.isDirectory();         for (int i = 0; i < dexOutputArrays.size(); i++) {             OutputStream out = new FileOutputStream(new File(outDir, getDexFileName(i)));             try {                 out.write(dexOutputArrays.get(i));             } finally {                 closeOutput(out);             }         }     }      return 0; }  private static boolean processAllFiles() {     createDexFile();      ......          try {         if (args.mainDexListFile != null) {             // with --main-dex-list             FileNameFilter mainPassFilter = args.strictNameCheck ? new MainDexListFilter() :                 new BestEffortMainDexListFilter();              // forced in main dex             for (int i = 0; i < fileNames.length; i++) {                 processOne(fileNames[i], mainPassFilter);             }              if (dexOutputFutures.size() > 0) {                 throw new DexException("Too many classes in " + Arguments.MAIN_DEX_LIST_OPTION                         + ", main dex capacity exceeded");             }              if (args.minimalMainDex) {                 // start second pass directly in a secondary dex file.                  // Wait for classes in progress to complete                 synchronized(dexRotationLock) {                     while(maxMethodIdsInProcess > 0 || maxFieldIdsInProcess > 0) {                         try {                             dexRotationLock.wait();                         } catch(InterruptedException ex) {                             /* ignore */                         }                     }                 }                  rotateDexFile();             }              // remaining files             for (int i = 0; i < fileNames.length; i++) {                 processOne(fileNames[i], new NotFilter(mainPassFilter));             }         } else {             // without --main-dex-list             for (int i = 0; i < fileNames.length; i++) {                 processOne(fileNames[i], ClassPathOpener.acceptAll);             }         }     } catch (StopProcessing ex) {         /*          * Ignore it and just let the error reporting do          * their things.          */     }      return true; }  //dalvik/dx/src/com/android/dx/cf/direct/ClassPathOpener.java private static void processOne(String pathname, FileNameFilter filter) {     ClassPathOpener opener;      opener = new ClassPathOpener(pathname, true, filter, new FileBytesConsumer());      if (opener.process()) {       updateStatus(true);     } }  private boolean processOne(File file, boolean topLevel) {     try {         if (file.isDirectory()) {             return processDirectory(file, topLevel);         }          String path = file.getPath();          if (path.endsWith(".zip") ||                 path.endsWith(".jar") ||                 path.endsWith(".apk")) {             return processArchive(file);         }         if (filter.accept(path)) {             byte[] bytes = FileUtils.readFile(file);             return consumer.processFileBytes(path, file.lastModified(), bytes);         } else {             return false;         }     } catch (Exception ex) {         consumer.onException(ex);         return false;     } }   private static class FileBytesConsumer implements ClassPathOpener.Consumer {      @Override     public boolean processFileBytes(String name, long lastModified,             byte[] bytes)   {         return Main.processFileBytes(name, lastModified, bytes);     } }  private static boolean processFileBytes(String name, long lastModified, byte[] bytes) {      boolean isClass = name.endsWith(".class");     boolean isClassesDex = name.equals(DexFormat.DEX_IN_JAR_NAME);     boolean keepResources = (outputResources != null);      if (!isClass && !isClassesDex && !keepResources) {         if (args.verbose) {             DxConsole.out.println("ignored resource " + name);         }         return false;     }      if (args.verbose) {         DxConsole.out.println("processing " + name + "...");     }      String fixedName = fixPath(name);      if (isClass) {          if (keepResources && args.keepClassesInJar) {             synchronized (outputResources) {                 outputResources.put(fixedName, bytes);             }         }         if (lastModified < minimumFileAge) {             return true;         }         processClass(fixedName, bytes);         // Assume that an exception may occur. Status will be updated         // asynchronously, if the class compiles without error.         return false;     } else if (isClassesDex) {         synchronized (libraryDexBuffers) {             libraryDexBuffers.add(bytes);         }         return true;     } else {         synchronized (outputResources) {             outputResources.put(fixedName, bytes);         }         return true;     } }   private static boolean processClass(String name, byte[] bytes) {     if (! args.coreLibrary) {         checkClassName(name);     }      try {         new DirectClassFileConsumer(name, bytes, null).call(                 new ClassParserTask(name, bytes).call());     } catch (ParseException ex) {         // handled in FileBytesConsumer         throw ex;     } catch(Exception ex) {         throw new RuntimeException("Exception parsing classes", ex);     }      return true; }   private static class DirectClassFileConsumer implements Callable<Boolean> {      private Boolean call(DirectClassFile cf) {          int maxMethodIdsInClass = 0;         int maxFieldIdsInClass = 0;          if (args.multiDex) {              // Calculate max number of indices this class will add to the             // dex file.             // The possibility of overloading means that we can't easily             // know how many constant are needed for declared methods and             // fields. We therefore make the simplifying assumption that             // all constants are external method or field references.              int constantPoolSize = cf.getConstantPool().size();             maxMethodIdsInClass = constantPoolSize + cf.getMethods().size()                     + MAX_METHOD_ADDED_DURING_DEX_CREATION;             maxFieldIdsInClass = constantPoolSize + cf.getFields().size()                     + MAX_FIELD_ADDED_DURING_DEX_CREATION;             synchronized(dexRotationLock) {                  int numMethodIds;                 int numFieldIds;                 // Number of indices used in current dex file.                 synchronized(outputDex) {                     numMethodIds = outputDex.getMethodIds().items().size();                     numFieldIds = outputDex.getFieldIds().items().size();                 }                 // Wait until we're sure this class will fit in the current                 // dex file.                 while(((numMethodIds + maxMethodIdsInClass + maxMethodIdsInProcess                         > args.maxNumberOfIdxPerDex) ||                        (numFieldIds + maxFieldIdsInClass + maxFieldIdsInProcess                         > args.maxNumberOfIdxPerDex))) {                      if (maxMethodIdsInProcess > 0 || maxFieldIdsInProcess > 0) {                         // There are classes in the translation phase that                         // have not yet been added to the dex file, so we                         // wait for the next class to complete.                         try {                             dexRotationLock.wait();                         } catch(InterruptedException ex) {                             /* ignore */                         }                     } else if (outputDex.getClassDefs().items().size() > 0) {                         // There are no further classes in the translation                         // phase, and we have a full dex file. Rotate!                         rotateDexFile();                     } else {                         // The estimated number of indices is too large for                         // an empty dex file. We proceed hoping the actual                         // number of indices needed will fit.                         break;                     }                     synchronized(outputDex) {                         numMethodIds = outputDex.getMethodIds().items().size();                         numFieldIds = outputDex.getFieldIds().items().size();                     }                 }                 // Add our estimate to the total estimate for                 // classes under translation.                 maxMethodIdsInProcess += maxMethodIdsInClass;                 maxFieldIdsInProcess += maxFieldIdsInClass;             }         }          // Submit class to translation phase.         Future<ClassDefItem> cdif = classTranslatorPool.submit(                 new ClassTranslatorTask(name, bytes, cf));         Future<Boolean> res = classDefItemConsumer.submit(new ClassDefItemConsumer(                 name, cdif, maxMethodIdsInClass, maxFieldIdsInClass));         addToDexFutures.add(res);          return true;     } } 

构建一个apk的入口为BasePlugin.apply(Project)，构建过程由各种Android Tasks组成。

其中Compile Task，用于将.java文件编译成.class文件。

对于PostCompile Task，如果支持multi dex，则先生成manifest_keep.txt，maindexlist.txt文件并对组件类进行混淆操作。最后另起一个进程将.class写入dex包。