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;
    }
}