private void modifyForIncremental(MergeManifests mergeManifests, List<ManifestProvider> allManifest) {
    if (appVariantContext.getAtlasExtension().getTBuildConfig().isIncremental()) {
        File mainManifest = mergeManifests.getMainManifest();
        File baseManifest = appVariantContext.apContext.getBaseModifyManifest();
        // allManifest.add(new ManifestHelper.MainManifestProvider(mainManifest, "main-manifest"));
        ConventionMappingHelper.map(mergeManifests, "mainManifest", new Callable<File>() {
            @Override
            public File call() throws Exception {
                return baseManifest;
            }
        });
        if (baseVariantOutput instanceof ApkVariantOutput) {
            // TODO Improve performance
            ApkVariantOutput variantOutputData = (ApkVariantOutput)baseVariantOutput;
            DefaultManifestParser manifestParser = new DefaultManifestParser(baseManifest);
            String versionNameOverride = variantOutputData.getVersionNameOverride();
            if (Strings.isNullOrEmpty(versionNameOverride)) {
                variantOutputData.setVersionNameOverride(manifestParser.getVersionName());
                GradleVariantConfiguration variantConfiguration = appVariantContext.getScope()
                    .getVariantConfiguration();
                ProductFlavor mergedFlavor = variantConfiguration.getMergedFlavor();
                String versionName = mergedFlavor.getVersionName();
                if (versionName == null) {
                    ((DefaultProductFlavor)mergedFlavor).setVersionName(manifestParser.getVersionName());
                }
            }
            int versionCodeOverride = variantOutputData.getVersionCodeOverride();
            if (versionCodeOverride == -1) {
                variantOutputData.setVersionCodeOverride(manifestParser.getVersionCode());
            }
        }
    }
}
 

public void createMergeAppManifestsTask(
        @NonNull TaskFactory tasks,
        @NonNull VariantScope variantScope) {

    ApplicationVariantData appVariantData =
            (ApplicationVariantData) variantScope.getVariantData();
    Set<String> screenSizes = appVariantData.getCompatibleScreens();

    // loop on all outputs. The only difference will be the name of the task, and location
    // of the generated manifest
    for (final BaseVariantOutputData vod : appVariantData.getOutputs()) {
        VariantOutputScope scope = vod.getScope();

        AndroidTask<CompatibleScreensManifest> csmTask = null;
        if (vod.getMainOutputFile().getFilter(DENSITY) != null) {
            csmTask = androidTasks.create(tasks,
                    new CompatibleScreensManifest.ConfigAction(scope, screenSizes));
            scope.setCompatibleScreensManifestTask(csmTask);
        }

        scope.setManifestProcessorTask(androidTasks.create(tasks,
                new MergeManifests.ConfigAction(scope)));

        if (csmTask != null) {
            scope.getManifestProcessorTask().dependsOn(tasks, csmTask);
        }
    }
}
 

@Override
    public void execute(Task task) {

        AtlasExtension atlasExtension = appVariantContext.getAtlasExtension();

        ManifestProcessorTask manifestProcessorTask = baseVariantOutput.getProcessManifest();

        Set<String> notMergedArtifacts = Sets.newHashSet();

        if (null != atlasExtension.getManifestOptions() && null != atlasExtension.getManifestOptions()
            .getNotMergedBundles()) {
            notMergedArtifacts = atlasExtension.getManifestOptions().getNotMergedBundles();
        }

        if (manifestProcessorTask instanceof MergeManifests) {

            MergeManifests mergeManifests = (MergeManifests)manifestProcessorTask;

            VariantScope variantScope = appVariantContext.getScope();
            GradleVariantConfiguration config = variantScope.getVariantConfiguration();
            AtlasDependencyTree dependencyTree = AtlasBuildContext.androidDependencyTrees.get(config.getFullName());

            List<ManifestProvider> bundleProviders = ManifestHelper.getBundleManifest(appVariantContext, dependencyTree,
                                                                                      atlasExtension);

            List<ManifestProvider> mainDexProviders = ManifestHelper.getMainDexManifest(appVariantContext, dependencyTree,
                    atlasExtension);

            List<ManifestProvider> allManifest = new ArrayList<>();
            modifyForIncremental(mergeManifests, allManifest);
//            allManifest.addAll(ManifestHelper.convert(mergeManifests.getProviders(), appVariantContext));
            allManifest.addAll(bundleProviders);
            allManifest.addAll(mainDexProviders);

            AtlasBuildContext.androidBuilderMap.get(appVariantContext.getProject()).manifestProviders = allManifest;

            mergeManifests.setAndroidBuilder(AtlasBuildContext.androidBuilderMap.get(appVariantContext.getProject()));
            //if (sLogger.isInfoEnabled()) {
            //    for (ManifestProvider manifestProvider : allManifest) {
            //        sLogger.warn("[manifestLibs] " + manifestProvider.getManifest().getAbsolutePath());
            //    }
            //}

            // Without this step, each time getLibraries It's going to be recomputed from the mapping
//            mergeManifests.(allManifest);
        }
    }
 

public File getModifiedManifest(ResolvedArtifactResult artifact) {
    return new File(getModifyManifestDir(),
            MergeManifests.getArtifactName(artifact) +
                    ".xml");

}