dependencies > build types > product flavors > main source directory

gradle assemble

/**
 * Create tasks for the specified variantData.
 */
public void createTasksForVariantData(
        final TaskFactory tasks,
        final BaseVariantData<? extends BaseVariantOutputData> variantData) {
       

    // Add dependency of assemble task on assemble build type task.
    tasks.named("assemble", new Action<Task>() {
       
        @Override
        public void execute(Task task) {
       
            BuildTypeData buildTypeData = buildTypes.get(
                            variantData.getVariantConfiguration().getBuildType().getName());
            task.dependsOn(buildTypeData.getAssembleTask());
        }
    });
    ...
        taskManager.createTasksForVariantData(tasks, variantData);
    }
}

/**
 * TaskManager for creating tasks in an Android application project.
 */
public class ApplicationTaskManager extends TaskManager {
       

    @Override
    public void createTasksForVariantData(
            @NonNull final TaskFactory tasks,
            @NonNull final BaseVariantData<? extends BaseVariantOutputData> variantData) {
       
            ...
        // 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;
                    }
                });
                ...
    }
}

/**
 * Creates the post-compilation tasks for the given Variant.
 *
 * These tasks create the dex file from the .class files, plus optional intermediary steps like
 * proguard and jacoco
 *
 */
public void createPostCompilationTasks(TaskFactory tasks, @NonNull final VariantScope variantScope) {
       
    checkNotNull(variantScope.getJavacTask());

    final ApkVariantData variantData = (ApkVariantData) variantScope.getVariantData();
    final GradleVariantConfiguration config = variantData.getVariantConfiguration();

    TransformManager transformManager = variantScope.getTransformManager();
...
    boolean isMinifyEnabled = config.isMinifyEnabled();
    boolean isMultiDexEnabled = config.isMultiDexEnabled();
    boolean isLegacyMultiDexMode = config.isLegacyMultiDexMode();

    AndroidConfig extension = variantScope.getGlobalScope().getExtension();

// ----- Multi-Dex support

AndroidTask<TransformTask> multiDexClassListTask = null;
// non Library test are running as native multi-dex
if (isMultiDexEnabled && isLegacyMultiDexMode) {
       
    if (AndroidGradleOptions.useNewShrinker(project)) {
       
        throw new IllegalStateException("New shrinker + multidex not supported yet.");
    }

    // ----------
    // create a transform to jar the inputs into a single jar.
    if (!isMinifyEnabled) {
       
        // merge the classes only, no need to package the resources since they are
        // not used during the computation.
        JarMergingTransform jarMergingTransform = new JarMergingTransform(
                TransformManager.SCOPE_FULL_PROJECT);
        transformManager.addTransform(tasks, variantScope, jarMergingTransform);
    }
    
    // ----------
    // 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(variantScope));
    manifestKeepListTask.dependsOn(tasks,
            variantData.getOutputs().get(0).getScope().getManifestProcessorTask());

    // ---------
    // create the transform that's going to take the code and the proguard keep list
    // from above and compute the main class list.
    MultiDexTransform multiDexTransform = new MultiDexTransform(
            variantScope.getManifestKeepListFile(),
            variantScope,
            null);
    multiDexClassListTask = transformManager.addTransform(
            tasks, variantScope, multiDexTransform);
    multiDexClassListTask.dependsOn(tasks, manifestKeepListTask);
}

    // create dex transform
    DexTransform dexTransform = new DexTransform(
            extension.getDexOptions(),
            config.getBuildType().isDebuggable(),
            isMultiDexEnabled,
            isMultiDexEnabled && isLegacyMultiDexMode ? variantScope.getMainDexListFile() : null,
            variantScope.getPreDexOutputDir(),
            variantScope.getGlobalScope().getAndroidBuilder(),
            getLogger());
    AndroidTask<TransformTask> dexTask = transformManager.addTransform(
            tasks, variantScope, dexTransform);
    // need to manually make dex task depend on MultiDexTransform since there's no stream
    // consumption making this automatic
    dexTask.optionalDependsOn(tasks, multiDexClassListTask);
}

/**
 * A task running a transform.
 */
@ParallelizableTask
public class TransformTask extends StreamBasedTask implements Context {
       

    private Transform transform;
    ...
    @TaskAction
    void transform(final IncrementalTaskInputs incrementalTaskInputs)
            throws IOException, TransformException, InterruptedException {
       
		 ...
        ThreadRecorder.get().record(ExecutionType.TASK_TRANSFORM,
                new Recorder.Block<Void>() {
       
                    @Override
                    public Void call() throws Exception {
       
                        transform.transform(
                                TransformTask.this,
                                consumedInputs.getValue(),
                                referencedInputs.getValue(),
                                outputStream != null ? outputStream.asOutput() : null,
                                isIncremental.getValue());
                        return null;
                    }
                },
                new Recorder.Property("project", getProject().getName()),
                new Recorder.Property("transform", transform.getName()),
                new Recorder.Property("incremental", Boolean.toString(transform.isIncremental())));
    }

@Override
public void transform(
        @NonNull Context context,
        @NonNull Collection<TransformInput> inputs,
        @NonNull Collection<TransformInput> referencedInputs,
        @Nullable TransformOutputProvider outputProvider,
        boolean isIncremental) throws TransformException, IOException, InterruptedException {
       
        ...
    // Gather a full list of all inputs.
    List<JarInput> jarInputs = Lists.newArrayList();
    List<DirectoryInput> directoryInputs = Lists.newArrayList();
    for (TransformInput input : inputs) {
       
        jarInputs.addAll(input.getJarInputs());
        directoryInputs.addAll(input.getDirectoryInputs());
    }
    
    
    try {
       
        // if only one scope or no per-scope dexing, just do a single pass that
        // runs dx on everything.
        if ((jarInputs.size() + directoryInputs.size()) == 1 || !dexOptions.getPreDexLibraries()) {
       
            File outputDir = outputProvider.getContentLocation("main",
                    getOutputTypes(), getScopes(),
                    Format.DIRECTORY);
            FileUtils.mkdirs(outputDir);

            // first delete the output folder where the final dex file(s) will be.
            FileUtils.emptyFolder(outputDir);

            // gather the inputs. This mode is always non incremental, so just
            // gather the top level folders/jars
            final List<File> inputFiles = Lists.newArrayList();
            for (JarInput jarInput : jarInputs) {
       
                inputFiles.add(jarInput.getFile());
            }

            for (DirectoryInput directoryInput : directoryInputs) {
       
                inputFiles.add(directoryInput.getFile());
            }

            androidBuilder.convertByteCode(
                    inputFiles,
                    outputDir,
                    multiDex,
                    mainDexListFile,
                    dexOptions,
                    null,
                    false,
                    true,
                    new LoggedProcessOutputHandler(logger));
        } else {
       

 public void convertByteCode(
         @NonNull Collection<File> inputs,
         @NonNull File outDexFolder,
                  boolean multidex,
         @Nullable File mainDexList,
         @NonNull DexOptions dexOptions,
         @Nullable List<String> additionalParameters,
         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(verifiedInputs.build());

     if (additionalParameters != null) {
       
         builder.additionalParameters(additionalParameters);
     }

     JavaProcessInfo javaProcessInfo = builder.build(buildToolInfo, dexOptions);

     ProcessResult result = mJavaProcessExecutor.execute(javaProcessInfo, processOutputHandler);
     result.rethrowFailure().assertNormalExitValue();
 }

 public static void main(String[] args) {
       
...
     try {
       
	...
             if (arg.equals("--dex")) {
       
                 com.android.dx.command.dexer.Main.main(without(args, i));
                 break;
             } else if (arg.equals("--dump")) {
       
                 com.android.dx.command.dump.Main.main(without(args, i));
                 break;
             }
             ...
         }

public static int run(Arguments arguments) throws IOException {
       
 ...
    try {
       
        if (args.multiDex) {
       
            return runMultiDex();
        } else {
       
            return runMonoDex();
        }
    } finally {
       
        closeOutput(humanOutRaw);
    }
}

 private static boolean processAllFiles() {
       
     createDexFile();
...

private static void createDexFile() {
       
    if (outputDex != null) {
       
        dexOutputArrays.add(writeDex());
    }

    outputDex = new DexFile(args.dexOptions);

    if (args.dumpWidth != 0) {
       
        outputDex.setDumpWidth(args.dumpWidth);
    }
}

if (args.numThreads > 1) {
       
    threadPool = Executors.newFixedThreadPool(args.numThreads);
    parallelProcessorFutures = new ArrayList<Future<Void>>();
}

...
   anyFilesProcessed = false;
   String[] fileNames = args.fileNames;
   ...
   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);
           }

/**
 * Processes one pathname element.
 *
 * @param pathname {
        @code non-null;} the pathname to process. May
 * be the path of a class file, a jar file, or a directory
 * containing class files.
 * @param filter {
        @code non-null;} A filter for excluding files.
 */
private static void processOne(String pathname, FileNameFilter filter) {
       
    ClassPathOpener opener;

    opener = new ClassPathOpener(pathname, false, filter,
            new ClassPathOpener.Consumer() {
       

        @Override
        public boolean processFileBytes(String name, long lastModified, byte[] bytes) {
       
            return Main.processFileBytes(name, lastModified, bytes);
        }
...
   });

    if (args.numThreads > 1) {
       
        parallelProcessorFutures.add(threadPool.submit(new ParallelProcessor(opener)));
    } else {
       
        if (opener.process()) {
       
            anyFilesProcessed = true;
        }
    }
}

 /**
  * Processes one file, which may be either a class or a resource.
  *
  * @param name {
        @code non-null;} name of the file
  * @param bytes {
        @code non-null;} contents of the file
  * @return whether processing was successful
  */
 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);
... 
     String fixedName = fixPath(name);

     if (isClass) {
       

         if (keepResources && args.keepClassesInJar) {
       
             synchronized (outputResources) {
       
                 outputResources.put(fixedName, bytes);
             }
         }
         if (lastModified < minimumFileAge) {
       
             return true;
         }
         return processClass(fixedName, bytes);
     } else if (isClassesDex) {
       
         synchronized (libraryDexBuffers) {
       
             libraryDexBuffers.add(bytes);
         }
         return true;
     } else {
       
         synchronized (outputResources) {
       
             outputResources.put(fixedName, bytes);
         }
         return true;
     }
 }

/**
  * Processes one classfile.
  *
  * @param name {
        @code non-null;} name of the file, clipped such that it
  * <i>should</i> correspond to the name of the class it contains
  * @param bytes {
        @code non-null;} contents of the file
  * @return whether processing was successful
  */
 private static boolean processClass(String name, byte[] bytes) {
       
     if (! args.coreLibrary) {
       
         checkClassName(name);
     }

     DirectClassFile cf =
         new DirectClassFile(bytes, name, args.cfOptions.strictNameCheck);

     cf.setAttributeFactory(StdAttributeFactory.THE_ONE);
     cf.getMagic();

     int numMethodIds = outputDex.getMethodIds().items().size();
     int numFieldIds = outputDex.getFieldIds().items().size();
     int constantPoolSize = cf.getConstantPool().size();

     int maxMethodIdsInDex = numMethodIds + constantPoolSize + cf.getMethods().size() +
             MAX_METHOD_ADDED_DURING_DEX_CREATION;
     int maxFieldIdsInDex = numFieldIds + constantPoolSize + cf.getFields().size() +
             MAX_FIELD_ADDED_DURING_DEX_CREATION;

     if (args.multiDex
         // Never switch to the next dex if current dex is already empty
         && (outputDex.getClassDefs().items().size() > 0)
         && ((maxMethodIdsInDex > args.maxNumberOfIdxPerDex) ||
             (maxFieldIdsInDex > args.maxNumberOfIdxPerDex))) {
       
         DexFile completeDex = outputDex;
         createDexFile();
         assert  (completeDex.getMethodIds().items().size() <= numMethodIds +
                 MAX_METHOD_ADDED_DURING_DEX_CREATION) &&
                 (completeDex.getFieldIds().items().size() <= numFieldIds +
                 MAX_FIELD_ADDED_DURING_DEX_CREATION);
     }

     try {
       
         ClassDefItem clazz =
             CfTranslator.translate(cf, bytes, args.cfOptions, args.dexOptions, outputDex);
         synchronized (outputDex) {
       
             outputDex.add(clazz);
         }
         return true;

     } catch (ParseException ex) {
       
         DxConsole.err.println("\ntrouble processing:");
         if (args.debug) {
       
             ex.printStackTrace(DxConsole.err);
         } else {
       
             ex.printContext(DxConsole.err);
         }
     }
     errors.incrementAndGet();
     return false;
 }

        if (dexOutputArrays.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.
            createDexFile();
        }

        // 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.
     */
}

private static int runMultiDex() throws IOException {
       
		...
        } 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);
                }
            }

        }