本文由玉剛說寫作平臺(tái)提供寫作贊助，版權(quán)歸玉剛說微信公眾號(hào)所有
原作者：ShinyZeng
版權(quán)聲明：未經(jīng)玉剛說許可，不得以任何形式轉(zhuǎn)載
前言：這篇文章在一個(gè)月之前已經(jīng)發(fā)布到玉剛說微信公眾號(hào)。Gradle 這一塊對(duì)于我們Android開發(fā)來說，一直是比較無(wú)人問津的一塊，平日的開發(fā)中也比較少涉及，即使涉及也是網(wǎng)上查查資料就可以解決，并不會(huì)深入理解原理，即使深入了，過一段時(shí)間不接觸也容易忘記，譬如我今日再看這篇文章，就發(fā)現(xiàn)有很多已經(jīng)忘記了...真是汗顏啊...所以簡(jiǎn)書中再發(fā)出來，做個(gè)備忘吧。
一、源碼依賴
本文基于:
android gradle plugin版本：com.android.tools.build:gradle:2.3.0
gradle 版本：4.1
Gradle源碼總共30個(gè)G，為簡(jiǎn)單起見，方便大家看源碼，此處通過gradle依賴的形式來查看源碼，依賴源碼姿勢(shì)：
創(chuàng)建一個(gè)新工程，app 項(xiàng)目目錄中刪除所有文件，僅留下gradle文件，依賴
apply plugin: 'java'
sourceCompatibility = 1.8
dependencies {
compile gradleApi()
compile 'com.android.tools.build:gradle:2.3.0'
}
將跟目錄下的gradle文件，刪除掉gradle依賴
buildscript {
repositories {
google()
jcenter()
}
dependencies {
// compile 'com.android.tools.build:gradle:2.3.0'
}
}
然后rebuild一下，就可以在External Libraries中查看到android gradle的源碼已經(jīng)依賴了
二、Android Gradle Plugin簡(jiǎn)介
我們知道Android gradle plugin是用來構(gòu)建Android工程的gradle插件，在Android gradle 插件中，可以看到app工程和library工程所依賴的plugin是不一樣的
// app 工程
apply plugin: 'com.android.application'
// library 工程
apply plugin: 'com.android.library'
而對(duì)應(yīng)填寫andorid塊中所填寫的配置也不同，這就是區(qū)分Application和Library的插件的extension塊
分別為：
app工程 -> AppPlugin -> AppExtension
librar工程 -> LibraryPlugin -> LibraryExtension
對(duì)應(yīng)的是AppPlugin和AppExtension，這兩個(gè)插件構(gòu)建的流程大抵是相同的，只是各自插件生成的任務(wù)不同，接下來我們著重分析Application插件是如何構(gòu)建我們的Android應(yīng)用的
三、AppPlugin的構(gòu)建流程
我們先看下app工程中g(shù)radle的文件格式
apply plugin: 'com.android.application'
android {
compileSdkVersion 25
buildToolsVersion '26.0.2'
defaultConfig {
applicationId "com.zengshaoyi.gradledemo"
minSdkVersion 15
targetSdkVersion 25
versionCode project.ext.versionCode
versionName project.ext.versionName
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
lintOptions {
abortOnError false
}
}
跟蹤apply方法，其實(shí)是進(jìn)入到
AppPlugin的apply的方法，我們可以看到內(nèi)部實(shí)現(xiàn)是直接調(diào)用父類BasePlugin的apply方法
protected void apply(@NonNull Project project) {
checkPluginVersion();
this.project = project;
ExecutionConfigurationUtil.setThreadPoolSize(project);
checkPathForErrors();
checkModulesForErrors();
ProfilerInitializer.init(project);
threadRecorder = ThreadRecorder.get();
ProcessProfileWriter.getProject(project.getPath())
.setAndroidPluginVersion(Version.ANDROID_GRADLE_PLUGIN_VERSION)
.setAndroidPlugin(getAnalyticsPluginType())
.setPluginGeneration(GradleBuildProject.PluginGeneration.FIRST);
threadRecorder.record(
ExecutionType.BASE_PLUGIN_PROJECT_CONFIGURE,
project.getPath(),
null,
this::configureProject);
threadRecorder.record(
ExecutionType.BASE_PLUGIN_PROJECT_BASE_EXTENSION_CREATION,
project.getPath(),
null,
this::configureExtension);
threadRecorder.record(
ExecutionType.BASE_PLUGIN_PROJECT_TASKS_CREATION,
project.getPath(),
null,
this::createTasks);
// Apply additional plugins
for (String plugin : AndroidGradleOptions.getAdditionalPlugins(project)) {
project.apply(ImmutableMap.of("plugin", plugin));
}
}
threadRecoirder.recode()是記錄最后一個(gè)參數(shù)的路徑和執(zhí)行的時(shí)間點(diǎn)，前面做了一些必要性的信息檢測(cè)之前，其實(shí)主要做了以下幾件事情：
// 配置項(xiàng)目，設(shè)置構(gòu)建回調(diào)
this::configureProject
// 配置Extension
this::configureExtension
// 創(chuàng)建任務(wù)
this::createTasks
::是java 8引入的特性，詳情可以查看java8特性 ，這里就是方法的調(diào)用
configureProject
直接來看源碼
private void configureProject() {
extraModelInfo = new ExtraModelInfo(project);
checkGradleVersion();
AndroidGradleOptions.validate(project);
// Android SDK處理類
sdkHandler = new SdkHandler(project, getLogger());
// 設(shè)置項(xiàng)目評(píng)估階段回調(diào)
project.afterEvaluate(p -> {
// TODO: Read flag from extension.
if (!p.getGradle().getStartParameter().isOffline()
&& AndroidGradleOptions.getUseSdkDownload(p)) {
// 相關(guān)配置依賴的下載處理
SdkLibData sdkLibData =
SdkLibData.download(getDownloader(), getSettingsController());
dependencyManager.setSdkLibData(sdkLibData);
sdkHandler.setSdkLibData(sdkLibData);
}
});
// 創(chuàng)建AndroidBuilder
androidBuilder = new AndroidBuilder(
project == project.getRootProject() ? project.getName() : project.getPath(),
creator,
new GradleProcessExecutor(project),
new GradleJavaProcessExecutor(project),
extraModelInfo,
getLogger(),
isVerbose());
// dataBinding的相關(guān)處理
dataBindingBuilder = new DataBindingBuilder();
dataBindingBuilder.setPrintMachineReadableOutput(
extraModelInfo.getErrorFormatMode() ==
ExtraModelInfo.ErrorFormatMode.MACHINE_PARSABLE);
// Apply the Java and Jacoco plugins.
project.getPlugins().apply(JavaBasePlugin.class);
project.getPlugins().apply(JacocoPlugin.class);
// 給assemble任務(wù)添加描述
project.getTasks()
.getByName("assemble")
.setDescription(
"Assembles all variants of all applications and secondary packages.");
...
可以看到 configureProject 方法中在 project.afterEvaluate 設(shè)置了回調(diào)，當(dāng)項(xiàng)目評(píng)估結(jié)束時(shí)，根據(jù)項(xiàng)目配置情況，設(shè)置 dependece 依賴；創(chuàng)建了 AndroidBuilder 對(duì)象，這個(gè)對(duì)象是用來合并manifest 和創(chuàng)建 dex 等作用，后面在創(chuàng)建任務(wù)的過程中會(huì)使用到，結(jié)下來繼續(xù)看 configureProject 的源碼
// call back on execution. This is called after the whole build is done (not
// after the current project is done).
// This is will be called for each (android) projects though, so this should support
// being called 2+ times.
// 設(shè)置構(gòu)建回調(diào)
project.getGradle()
.addBuildListener(
new BuildListener() {
private final LibraryCache libraryCache = LibraryCache.getCache();
@Override
public void buildStarted(Gradle gradle) {}
@Override
public void settingsEvaluated(Settings settings) {}
@Override
public void projectsLoaded(Gradle gradle) {}
@Override
public void projectsEvaluated(Gradle gradle) {}
@Override
public void buildFinished(BuildResult buildResult) {
ExecutorSingleton.shutdown();
sdkHandler.unload();
threadRecorder.record(
ExecutionType.BASE_PLUGIN_BUILD_FINISHED,
project.getPath(),
null,
() -> {
// 當(dāng)任務(wù)執(zhí)行完成時(shí)，清楚dex緩存
PreDexCache.getCache()
.clear(
FileUtils.join(
project.getRootProject()
.getBuildDir(),
FD_INTERMEDIATES,
"dex-cache",
"cache.xml"),
getLogger());
JackConversionCache.getCache()
.clear(
FileUtils.join(
project.getRootProject()
.getBuildDir(),
FD_INTERMEDIATES,
"jack-cache",
"cache.xml"),
getLogger());
libraryCache.unload();
Main.clearInternTables();
});
}
});
// 設(shè)置創(chuàng)建有向圖任務(wù)回調(diào)
project.getGradle()
.getTaskGraph()
.addTaskExecutionGraphListener(
taskGraph -> {
for (Task task : taskGraph.getAllTasks()) {
// TransformTask是class編譯成dex的重要任務(wù)
if (task instanceof TransformTask) {
Transform transform = ((TransformTask) task).getTransform();
if (transform instanceof DexTransform) {
PreDexCache.getCache()
.load(
FileUtils.join(
project.getRootProject()
.getBuildDir(),
FD_INTERMEDIATES,
"dex-cache",
"cache.xml"));
break;
} else if (transform instanceof JackPreDexTransform) {
JackConversionCache.getCache()
.load(
FileUtils.join(
project.getRootProject()
.getBuildDir(),
FD_INTERMEDIATES,
"jack-cache",
"cache.xml"));
break;
}
}
}
});
這里在添加了 BuildListener，在 buildFinished 的時(shí)候清楚了dex緩存，而在任務(wù)有向圖創(chuàng)建的回調(diào)中，判斷是否是 DexTransfrom，從而從緩存中加載dex。
總結(jié)一下 configureProject 做的事情，主要是進(jìn)行版本有效性的判斷，創(chuàng)建了 AndroidBuilder 對(duì)象，并設(shè)置了構(gòu)建流程的回調(diào)來處理依賴和dex的加載和緩存清理。
configureExtension
這個(gè)階段就是配置 extension 的階段，就是創(chuàng)建我們 android 塊中的可配置的對(duì)象
private void configureExtension() {
final NamedDomainObjectContainer<BuildType> buildTypeContainer =
project.container(
BuildType.class,
new BuildTypeFactory(instantiator, project, project.getLogger()));
final NamedDomainObjectContainer<ProductFlavor> productFlavorContainer =
project.container(
ProductFlavor.class,
new ProductFlavorFactory(
instantiator, project, project.getLogger(), extraModelInfo));
final NamedDomainObjectContainer<SigningConfig> signingConfigContainer =
project.container(SigningConfig.class, new SigningConfigFactory(instantiator));
extension =
createExtension(
project,
instantiator,
androidBuilder,
sdkHandler,
buildTypeContainer,
productFlavorContainer,
signingConfigContainer,
extraModelInfo);
...
首先創(chuàng)建了 BuildType、ProductFlavor、SigningConfig 三個(gè)類型的Container，接著傳入到了createExtension方法中，點(diǎn)入查看是個(gè)抽象的方法，各自的實(shí)現(xiàn)在子類中，這里也就是我們的AppPlugin 中
@NonNull
@Override
protected BaseExtension createExtension(
@NonNull Project project,
@NonNull Instantiator instantiator,
@NonNull AndroidBuilder androidBuilder,
@NonNull SdkHandler sdkHandler,
@NonNull NamedDomainObjectContainer<BuildType> buildTypeContainer,
@NonNull NamedDomainObjectContainer<ProductFlavor> productFlavorContainer,
@NonNull NamedDomainObjectContainer<SigningConfig> signingConfigContainer,
@NonNull ExtraModelInfo extraModelInfo) {
return project.getExtensions()
.create(
"android",
AppExtension.class,
project,
instantiator,
androidBuilder,
sdkHandler,
buildTypeContainer,
productFlavorContainer,
signingConfigContainer,
extraModelInfo);
}
這里也就是可以看到我們android塊配置是如何來的了，對(duì)應(yīng)的Extension也確實(shí)是AppExtension，繼續(xù)查看 configureExtension 的源碼
dependencyManager = new DependencyManager(
project,
extraModelInfo,
sdkHandler);
ndkHandler = new NdkHandler(
project.getRootDir(),
null, /* compileSkdVersion, this will be set in afterEvaluate */
"gcc",
"" /*toolchainVersion*/);
taskManager =
createTaskManager(
project,
androidBuilder,
dataBindingBuilder,
extension,
sdkHandler,
ndkHandler,
dependencyManager,
registry,
threadRecorder);
variantFactory = createVariantFactory(instantiator, androidBuilder, extension);
variantManager =
new VariantManager(
project,
androidBuilder,
extension,
variantFactory,
taskManager,
instantiator,
threadRecorder);
// Register a builder for the custom tooling model
ModelBuilder modelBuilder = new ModelBuilder(
androidBuilder,
variantManager,
taskManager,
extension,
extraModelInfo,
ndkHandler,
new NativeLibraryFactoryImpl(ndkHandler),
getProjectType(),
AndroidProject.GENERATION_ORIGINAL);
registry.register(modelBuilder);
// Register a builder for the native tooling model
NativeModelBuilder nativeModelBuilder = new NativeModelBuilder(variantManager);
registry.register(nativeModelBuilder);
這一部分主要是創(chuàng)建一些管理類，其中 createTaskManager、createVariantFactory 都是抽象方法，對(duì)應(yīng)的實(shí)現(xiàn)類
createTaskManager
AppPlugin -> ApplicationTaskManager
LibraryPlugin -> LibraryTaskManager
createVariantFactory
AppPlugin -> ApplicationVariantFactory
LibraryPlugin -> LibraryVariantFactory
這里簡(jiǎn)單介紹一下 TaskManager 就是創(chuàng)建具體任務(wù)的管理類，app 工程和庫(kù) library 工程所需的構(gòu)建任務(wù)是不同的，后面我們會(huì)介紹 app 工程創(chuàng)建的構(gòu)建任務(wù)；VariantFactory 就是我們常說的構(gòu)建變體的工廠類，主要是生成Variant（構(gòu)建變體）的對(duì)象。我們回到 createExtension 的源碼中
// map the whenObjectAdded callbacks on the containers.
signingConfigContainer.whenObjectAdded(variantManager::addSigningConfig);
buildTypeContainer.whenObjectAdded(
buildType -> {
SigningConfig signingConfig =
signingConfigContainer.findByName(BuilderConstants.DEBUG);
buildType.init(signingConfig);
variantManager.addBuildType(buildType);
});
productFlavorContainer.whenObjectAdded(variantManager::addProductFlavor);
...
// create default Objects, signingConfig first as its used by the BuildTypes.
variantFactory.createDefaultComponents(
buildTypeContainer, productFlavorContainer, signingConfigContainer);
這一部分做得事情，配置了 BuildTypeContainer、ProductFlavorContainer、SigningConfigContainer 這三個(gè)配置項(xiàng)的 whenObjectAdded 的回調(diào)，每個(gè)配置的添加都會(huì)加入到 variantManager 中；創(chuàng)建默認(rèn)配置，下面是 ApplicationVariantFactory 的 createDefaultComponents 代碼
@Override
public void createDefaultComponents(
@NonNull NamedDomainObjectContainer<BuildType> buildTypes,
@NonNull NamedDomainObjectContainer<ProductFlavor> productFlavors,
@NonNull NamedDomainObjectContainer<SigningConfig> signingConfigs) {
// must create signing config first so that build type 'debug' can be initialized
// with the debug signing config.
signingConfigs.create(DEBUG);
buildTypes.create(DEBUG);
buildTypes.create(RELEASE);
}
總結(jié)一下 configureExtension 方法的作用，主要是創(chuàng)建 Android 插件的擴(kuò)展對(duì)象，對(duì)配置項(xiàng) BuildType、ProductFlavor、SigningConfig 做了統(tǒng)一的創(chuàng)建和回調(diào)處理， 創(chuàng)建taskManager、variantFactory、variantManager。
createTasks
private void createTasks() {
threadRecorder.record(
ExecutionType.TASK_MANAGER_CREATE_TASKS,
project.getPath(),
null,
() -> // 在項(xiàng)目評(píng)估之前創(chuàng)建任務(wù)
taskManager.createTasksBeforeEvaluate(
new TaskContainerAdaptor(project.getTasks())));
project.afterEvaluate(
project ->
threadRecorder.record(
ExecutionType.BASE_PLUGIN_CREATE_ANDROID_TASKS,
project.getPath(),
null,
// 在項(xiàng)目評(píng)估完成之后創(chuàng)建 androidTask
() -> createAndroidTasks(false)));
}
這里主要是分兩塊，一個(gè)是在 beforeEvaluate 創(chuàng)建任務(wù)；一個(gè)是在 afterEvaluate 創(chuàng)建任務(wù)。這里的區(qū)別是 AndroidTask 是依賴配置項(xiàng)的配置才能生成相應(yīng)任務(wù)，所以是需要在 afterEvaluate 之后創(chuàng)建，如果對(duì)項(xiàng)目評(píng)估回調(diào)不理解的話，可以查閱Project文檔。beforeEvaluate 創(chuàng)建的任務(wù)跟我們編譯沒有太大關(guān)系，我們重點(diǎn)查看一下 afterEvaluate 創(chuàng)建的任務(wù) createAndroidTasks
@VisibleForTesting
final void createAndroidTasks(boolean force) {
...
threadRecorder.record(
ExecutionType.VARIANT_MANAGER_CREATE_ANDROID_TASKS,
project.getPath(),
null,
() -> {
// 創(chuàng)建AndroidTasks
variantManager.createAndroidTasks();
ApiObjectFactory apiObjectFactory =
new ApiObjectFactory(
androidBuilder, extension, variantFactory, instantiator);
for (BaseVariantData variantData : variantManager.getVariantDataList()) {
apiObjectFactory.create(variantData);
}
});
...
}
我們主要看下variantManager的createAndroidTasks的方法
/**
* Variant/Task creation entry point.
*
* Not used by gradle-experimental.
*/
public void createAndroidTasks() {
variantFactory.validateModel(this);
variantFactory.preVariantWork(project);
final TaskFactory tasks = new TaskContainerAdaptor(project.getTasks());
if (variantDataList.isEmpty()) {
recorder.record(
ExecutionType.VARIANT_MANAGER_CREATE_VARIANTS,
project.getPath(),
null /*variantName*/,
this::populateVariantDataList);
}
// Create top level test tasks.
recorder.record(
ExecutionType.VARIANT_MANAGER_CREATE_TESTS_TASKS,
project.getPath(),
null /*variantName*/,
() -> taskManager.createTopLevelTestTasks(tasks, !productFlavors.isEmpty()));
for (final BaseVariantData<? extends BaseVariantOutputData> variantData : variantDataList) {
recorder.record(
ExecutionType.VARIANT_MANAGER_CREATE_TASKS_FOR_VARIANT,
project.getPath(),
variantData.getName(),
() -> createTasksForVariantData(tasks, variantData));
}
taskManager.createReportTasks(tasks, variantDataList);
}
首先判斷 variantDataList 是否是空，如果是空的就會(huì)進(jìn)入到 populateVariantDataList 方法中
/**
* Create all variants.
*/
public void populateVariantDataList() {
if (productFlavors.isEmpty()) {
createVariantDataForProductFlavors(Collections.emptyList());
} else {
List<String> flavorDimensionList = extension.getFlavorDimensionList();
// Create iterable to get GradleProductFlavor from ProductFlavorData.
Iterable<CoreProductFlavor> flavorDsl =
Iterables.transform(
productFlavors.values(),
ProductFlavorData::getProductFlavor);
// Get a list of all combinations of product flavors.
List<ProductFlavorCombo<CoreProductFlavor>> flavorComboList =
ProductFlavorCombo.createCombinations(
flavorDimensionList,
flavorDsl);
for (ProductFlavorCombo<CoreProductFlavor> flavorCombo : flavorComboList) {
//noinspection unchecked
createVariantDataForProductFlavors(
(List<ProductFlavor>) (List) flavorCombo.getFlavorList());
}
}
}
從方法注釋可以看到，這個(gè)方法主要的作用就是創(chuàng)建所有的 variants，試想一下該段代碼會(huì)做哪些事情，是否是解析 buildType、productFlavor 配置？
創(chuàng)建構(gòu)建變體（BuildVariant）
繼續(xù)觀察上面的代碼，可以看到無(wú)論是否有配置productFlavor 子項(xiàng)，都會(huì)進(jìn)入到 createVariantDataForProductFlavors 方法。如果有配置的話，通過獲取配置的 flavorDimension 和 productFlavor 數(shù)組，調(diào)用 ProductFlavorCombo.createCombinations 組合出最后的產(chǎn)品風(fēng)味數(shù)組 flavorComboList ，最后通過遍歷調(diào)用 createVariantDataForProductFlavors 方法
/**
* Creates VariantData for a specified list of product flavor.
*
* This will create VariantData for all build types of the given flavors.
*
* @param productFlavorList the flavor(s) to build.
*/
private void createVariantDataForProductFlavors(
@NonNull List<ProductFlavor> productFlavorList) {
...
for (BuildTypeData buildTypeData : buildTypes.values()) {
boolean ignore = false;
...
if (!ignore) {
BaseVariantData<?> variantData = createVariantData(
buildTypeData.getBuildType(),
productFlavorList);
variantDataList.add(variantData);
...
}
}
...
}
看上述代碼，通過 creatVariantData 方法，將 buildType 和 productFlavor 的作為參數(shù)傳入，創(chuàng)建了 variantData，并且加入到了 variantDataList 集合中，這里我們就是將所有的構(gòu)建變體集合到了 variantDataList 中。
接著我們返回繼續(xù)看 createAndroidTasks 方法
/**
* Variant/Task creation entry point.
*
* Not used by gradle-experimental.
*/
public void createAndroidTasks() {
...
for (final BaseVariantData<? extends BaseVariantOutputData> variantData : variantDataList) {
recorder.record(
ExecutionType.VARIANT_MANAGER_CREATE_TASKS_FOR_VARIANT,
project.getPath(),
variantData.getName(),
() -> createTasksForVariantData(tasks, variantData));
}
...
}
通過上面拿到的variantDataList，遍歷該集合來創(chuàng)建任務(wù)
/**
* Create tasks for the specified variantData.
*/
public void createTasksForVariantData(
final TaskFactory tasks,
final BaseVariantData<? extends BaseVariantOutputData> variantData) {
final BuildTypeData buildTypeData = buildTypes.get(
variantData.getVariantConfiguration().getBuildType().getName());
if (buildTypeData.getAssembleTask() == null) {
// 創(chuàng)建assemble + buildType任務(wù)
buildTypeData.setAssembleTask(taskManager.createAssembleTask(tasks, buildTypeData));
}
// Add dependency of assemble task on assemble build type task.
tasks.named("assemble", new Action<Task>() {
@Override
public void execute(Task task) {
assert buildTypeData.getAssembleTask() != null;
// 將 assemble 任務(wù)依賴于我們的 assemble + buildType 任務(wù)
task.dependsOn(buildTypeData.getAssembleTask().getName());
}
});
VariantType variantType = variantData.getType();
// 根據(jù) variantData 創(chuàng)建 assemble + flavor + buildType 任務(wù)
createAssembleTaskForVariantData(tasks, variantData);
if (variantType.isForTesting()) {
...
} else {
// 根據(jù) variantData 創(chuàng)建一系列任務(wù)
taskManager.createTasksForVariantData(tasks, variantData);
}
}
首先會(huì)先根據(jù) buildType 信息創(chuàng)建 assemble + buildType 的任務(wù)，可以看下taskManager. createAssembleTask里的代碼
@NonNull
public AndroidTask<DefaultTask> createAssembleTask(
@NonNull TaskFactory tasks,
@NonNull VariantDimensionData dimensionData) {
final String sourceSetName =
StringHelper.capitalize(dimensionData.getSourceSet().getName());
return androidTasks.create(
tasks,
// 設(shè)置任務(wù)名字為 assembleXXX
"assemble" + sourceSetName,
assembleTask -> {
// 設(shè)置描述和任務(wù)組
assembleTask.setDescription("Assembles all " + sourceSetName + " builds.");
assembleTask.setGroup(BasePlugin.BUILD_GROUP);
});
}
創(chuàng)建完任務(wù)之后，將assemble任務(wù)依賴于我們的assembleXXX任務(wù)，隨后調(diào)用 createAssembleTaskForVariantData 方法，此方法是創(chuàng)建 assemble + flavor + buildType 任務(wù)，流程多了 productFlavor 任務(wù)的創(chuàng)建，這里就不贅述了。后面會(huì)執(zhí) createTasksForVariantData，這個(gè)方法就是根據(jù) variant 生成一系列 Android 構(gòu)建所需任務(wù)（后面會(huì)詳細(xì)介紹），回到 createAndroidTasks 方法中
threadRecorder.record(
ExecutionType.VARIANT_MANAGER_CREATE_ANDROID_TASKS,
project.getPath(),
null,
() -> {
variantManager.createAndroidTasks();
ApiObjectFactory apiObjectFactory =
new ApiObjectFactory(
androidBuilder, extension, variantFactory, instantiator);
for (BaseVariantData variantData : variantManager.getVariantDataList()) {
// 創(chuàng)建variantApi，添加到extensions中
apiObjectFactory.create(variantData);
}
});
最后就遍歷 variantDataList 通過 ApiObjectFactory 創(chuàng)建 variantApi，添加到 extensions 中；
至此，我們就已經(jīng)將配置的構(gòu)建變種任務(wù)已經(jīng)添加到我們的任務(wù)列表中，并形成了相關(guān)依賴。
Application 的編譯任務(wù)
我們繼續(xù)查看createTasksForVariantData的最后一行，
taskManager.createTasksForVariantData，發(fā)現(xiàn) createTasksForVariantData 是抽象方法，這里的 taskManager 具體實(shí)現(xiàn)是 ApplicationTaskManager，查看 ApplicationTaskManager 的 createTasksForVariantData 方法
/**
* Creates the tasks for a given BaseVariantData.
*/
@Override
public void createTasksForVariantData(
@NonNull final TaskFactory tasks,
@NonNull final BaseVariantData<? extends BaseVariantOutputData> variantData) {
assert variantData instanceof ApplicationVariantData;
final VariantScope variantScope = variantData.getScope();
//create sourceGenTask, resGenTask, assetGenTask
createAnchorTasks(tasks, variantScope);
createCheckManifestTask(tasks, variantScope);
handleMicroApp(tasks, variantScope);
// Create all current streams (dependencies mostly at this point)
createDependencyStreams(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 this aidl file
// Add a task to process shader source
// Add NDK tasks
// Add external native build tasks
// Add a task to merge the jni libs folders
// Add a compile task
// Add data binding tasks if enabled
// create packaging task
// create the lint tasks.
...
}
代碼實(shí)在太長(zhǎng)了，我只留下了每段代碼的注釋，注釋也已經(jīng)非常清楚了，這個(gè)主要就是生成 variantData 的一系列像 compileXXX、generateXXX、processXXX、mergeXXX的任務(wù)，這一系列 task 就是構(gòu)建一個(gè)可運(yùn)行的完整APK的所需的所有task。下面介紹在編譯dex中的過程，涉及的幾個(gè)task。
Dex的編譯過程
// Add a compile task
recorder.record(
ExecutionType.APP_TASK_MANAGER_CREATE_COMPILE_TASK,
project.getPath(),
variantScope.getFullVariantName(),
() -> {
CoreJackOptions jackOptions =
variantData.getVariantConfiguration().getJackOptions();
// create data binding merge task before the javac task so that it can
// parse jars before any consumer
createDataBindingMergeArtifactsTaskIfNecessary(tasks, variantScope);
AndroidTask<? extends JavaCompile> javacTask =
// 創(chuàng)建 javac 任務(wù)
createJavacTask(tasks, variantScope);
if (jackOptions.isEnabled()) {
AndroidTask<TransformTask> jackTask =
createJackTask(tasks, variantScope, true /*compileJavaSource*/);
setJavaCompilerTask(jackTask, tasks, variantScope);
} else {
...
addJavacClassesStream(variantScope);
setJavaCompilerTask(javacTask, tasks, variantScope);
getAndroidTasks()
.create(
tasks,
// 創(chuàng)建 AndroidJarTask ，生成classes.jar
new AndroidJarTask.JarClassesConfigAction(variantScope));
createPostCompilationTasks(tasks, variantScope);
}
});
我們直接查看 Add a compile task 注釋下的代碼，在執(zhí)行 createPostCompilationTasks 之前，先創(chuàng)建了 javac 任務(wù)，任務(wù)名稱為 compileXXXJavaWithJavac ，該任務(wù)是將 java 源文件編譯成 class 文件，具體實(shí)現(xiàn)是在 JavaCompileConfigAction 類中。創(chuàng)建 javac 任務(wù)之后，接著創(chuàng)建了 AndroidJarTask 任務(wù)，該任務(wù)是將 class 文件整合輸出 jar 包，具體實(shí)現(xiàn)就是在 AndroidJarTask 類中。
緊接著我們來看一下 createPostCompilationTasks 的方法
/**
* 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(
@NonNull TaskFactory tasks,
@NonNull final VariantScope variantScope) {
checkNotNull(variantScope.getJavacTask());
variantScope.getInstantRunBuildContext().setInstantRunMode(
getIncrementalMode(variantScope.getVariantConfiguration()) != IncrementalMode.NONE);
final BaseVariantData<? extends BaseVariantOutputData> variantData = variantScope.getVariantData();
final GradleVariantConfiguration config = variantData.getVariantConfiguration();
TransformManager transformManager = variantScope.getTransformManager();
...
boolean isMinifyEnabled = isMinifyEnabled(variantScope);
boolean isMultiDexEnabled = config.isMultiDexEnabled();
// Switch to native multidex if possible when using instant run.
boolean isLegacyMultiDexMode = isLegacyMultidexMode(variantScope);
AndroidConfig extension = variantScope.getGlobalScope().getExtension();
// ----- External Transforms -----
// apply all the external transforms.
...
// ----- Minify next -----
if (isMinifyEnabled) {
boolean outputToJarFile = isMultiDexEnabled && isLegacyMultiDexMode;
// 內(nèi)部會(huì)判斷是否使用 proguard 來創(chuàng)建 proguard 任務(wù)和 shrinkResources 任務(wù)
createMinifyTransform(tasks, variantScope, outputToJarFile);
}
// ----- 10x support
...
// ----- Multi-Dex support
Optional<AndroidTask<TransformTask>> multiDexClassListTask;
// non Library test are running as native multi-dex
if (isMultiDexEnabled && isLegacyMultiDexMode) {
...
} else {
multiDexClassListTask = Optional.empty();
}
// create dex transform
// 從 extension 中獲取 dexOptions 項(xiàng)的配置
DefaultDexOptions dexOptions = DefaultDexOptions.copyOf(extension.getDexOptions());
...
// 創(chuàng)建 DexTransform
DexTransform dexTransform = new DexTransform(
dexOptions,
config.getBuildType().isDebuggable(),
isMultiDexEnabled,
isMultiDexEnabled && isLegacyMultiDexMode ? variantScope.getMainDexListFile() : null,
variantScope.getPreDexOutputDir(),
variantScope.getGlobalScope().getAndroidBuilder(),
getLogger(),
variantScope.getInstantRunBuildContext(),
AndroidGradleOptions.getBuildCache(variantScope.getGlobalScope().getProject()));
// 創(chuàng)建 dexTask
Optional<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.ifPresent(t -> {
t.optionalDependsOn(tasks, multiDexClassListTask.orElse(null));
variantScope.addColdSwapBuildTask(t);
});
...
}
為了講述主流程，我將一些 mutiDex 和 instantRun 判斷的源碼省略了，這里我們關(guān)注非mutiDex和非instantRun的情況。我們看到，如果我們?cè)O(shè)置了 minifyEnabled 為 true，那么這里就會(huì)去創(chuàng)建 createMinifyTransform ，如果use proguard，這里會(huì)創(chuàng)建 progruad 的任務(wù)和 shrinkResources 的任務(wù)。后面將創(chuàng)建 dexTask， 這個(gè)是 transfromTask 類型的任務(wù)，我們先來看下 transFromTask 類
/**
* A task running a transform.
*/
@ParallelizableTask
public class TransformTask extends StreamBasedTask implements Context {
private Transform transform;
...
public Transform getTransform() {
return transform;
}
...
@TaskAction
void transform(final IncrementalTaskInputs incrementalTaskInputs)
throws IOException, TransformException, InterruptedException {
...
recorder.record(
ExecutionType.TASK_TRANSFORM,
executionInfo,
getProject().getPath(),
getVariantName(),
new Recorder.Block<Void>() {
@Override
public Void call() throws Exception {
transform.transform(
new TransformInvocationBuilder(TransformTask.this)
.addInputs(consumedInputs.getValue())
.addReferencedInputs(referencedInputs.getValue())
.addSecondaryInputs(changedSecondaryInputs.getValue())
.addOutputProvider(
outputStream != null
? outputStream.asOutput()
: null)
.setIncrementalMode(isIncremental.getValue())
.build());
return null;
}
});
}
}
我們知道，自定義任務(wù)中，在任務(wù)執(zhí)行階段會(huì)去執(zhí)行被 @TaskAction 注解的方法，這里也就是執(zhí)行 transfrom 方法，而 transfrom 方法中最后又會(huì)調(diào)用到 transform 的 transfrom 方法，在我們 dexTask 中傳入的 transfrom 是DexTransfrom，那我們就去看下 DexTransfrom 的 transfrom 具體實(shí)現(xiàn)
public class DexTransform extends Transform {
@Override
public void transform(@NonNull TransformInvocation transformInvocation)
throws TransformException, IOException, InterruptedException {
...
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()) {
// since there is only one dex file, we can merge all the scopes into the full
// application one.
File outputDir = outputProvider.getContentLocation("main",
getOutputTypes(),
TransformManager.SCOPE_FULL_PROJECT,
Format.DIRECTORY);
FileUtils.mkdirs(outputDir);
// first delete the output folder where the final dex file(s) will be.
FileUtils.cleanOutputDir(outputDir);
// gather the inputs. This mode is always non incremental, so just
// gather the top level folders/jars
final List<File> inputFiles =
Stream.concat(
jarInputs.stream().map(JarInput::getFile),
directoryInputs.stream().map(DirectoryInput::getFile))
.collect(Collectors.toList());
// 通過 AndroidBuilder 轉(zhuǎn)化為 byte
androidBuilder.convertByteCode(
inputFiles,
outputDir,
multiDex,
mainDexListFile,
dexOptions,
outputHandler);
for (File file : Files.fileTreeTraverser().breadthFirstTraversal(outputDir)) {
if (file.isFile()) {
instantRunBuildContext.addChangedFile(FileType.DEX, file);
}
}
} else {
...
}
最后執(zhí)行到androidBuilder.convertByteCode
/**
* Converts the bytecode to Dalvik format
* @param inputs the input files
* @param outDexFolder the location of the output folder
* @param dexOptions dex options
* @throws IOException
* @throws InterruptedException
* @throws ProcessException
*/
public void convertByteCode(
@NonNull Collection<File> inputs,
@NonNull File outDexFolder,
boolean multidex,
@Nullable File mainDexList,
@NonNull DexOptions dexOptions,
@NonNull ProcessOutputHandler processOutputHandler)
throws IOException, InterruptedException, ProcessException {checkNotNull(inputs, "inputs cannot be null.");
checkNotNull(outDexFolder, "outDexFolder cannot be null.");
checkNotNull(dexOptions, "dexOptions cannot be null.");
checkArgument(outDexFolder.isDirectory(), "outDexFolder must be a folder");
checkState(mTargetInfo != null,
"Cannot call convertByteCode() before setTargetInfo() is called.");
ImmutableList.Builder<File> verifiedInputs = ImmutableList.builder();
for (File input : inputs) {
if (checkLibraryClassesJar(input)) {
verifiedInputs.add(input);
}
}
//創(chuàng)建 DexProcessBuilder
DexProcessBuilder builder = new DexProcessBuilder(outDexFolder);
builder.setVerbose(mVerboseExec)
.setMultiDex(multidex)
.setMainDexList(mainDexList)
.addInputs(verifiedInputs.build());
runDexer(builder, dexOptions, processOutputHandler);
}
創(chuàng)建了 DexProcessBuilder ，隨后執(zhí)行到了 runDexer 方法中
public void runDexer(
@NonNull final DexProcessBuilder builder,
@NonNull final DexOptions dexOptions,
@NonNull final ProcessOutputHandler processOutputHandler)
throws ProcessException, IOException, InterruptedException {
initDexExecutorService(dexOptions);
if (dexOptions.getAdditionalParameters().contains("--no-optimize")) {
mLogger.warning(DefaultDexOptions.OPTIMIZE_WARNING);
}
if (shouldDexInProcess(dexOptions)) {
dexInProcess(builder, dexOptions, processOutputHandler);
} else {
dexOutOfProcess(builder, dexOptions, processOutputHandler);
}
}
進(jìn)入到dexInProcess方法
private void dexInProcess(
@NonNull final DexProcessBuilder builder,
@NonNull final DexOptions dexOptions,
@NonNull final ProcessOutputHandler outputHandler)
throws IOException, ProcessException {
final String submission = Joiner.on(',').join(builder.getInputs());
mLogger.verbose("Dexing in-process : %1$s", submission);
try {
sDexExecutorService.submit(() -> {
Stopwatch stopwatch = Stopwatch.createStarted();
ProcessResult result = DexWrapper.run(builder, dexOptions, outputHandler);
result.assertNormalExitValue();
mLogger.verbose("Dexing %1$s took %2$s.", submission, stopwatch.toString());
return null;
}).get();
} catch (Exception e) {
throw new ProcessException(e);
}
}
/**
* Wrapper around the real dx classes.
*/
public class DexWrapper {
/**
* Runs the dex command.
*
* @return the integer return code of com.android.dx.command.dexer.Main.run()
*/
public static ProcessResult run(
@NonNull DexProcessBuilder processBuilder,
@NonNull DexOptions dexOptions,
@NonNull ProcessOutputHandler outputHandler) throws IOException, ProcessException {
ProcessOutput output = outputHandler.createOutput();
int res;
try {
DxContext dxContext = new DxContext(output.getStandardOutput(), output.getErrorOutput());
// 構(gòu)建 Main.Arguments 參數(shù)
Main.Arguments args = buildArguments(processBuilder, dexOptions, dxContext);
res = new Main(dxContext).run(args);
} finally {
output.close();
}
outputHandler.handleOutput(output);
return new DexProcessResult(res);
}
...
}
buildArguments方法通過傳入的DexProcessBuilder、dexOptions、dxContext構(gòu)建 arguments，后面使用的args的參數(shù)fileNames，outName，jarOutput都是從DexProcessBuilder來的，然后執(zhí)行Main的run方法
package com.android.dx.command.dexer;
...
/**
* Main class for the class file translator.
*/
public class Main {
/**
* Run and return a result code.
* @param arguments the data + parameters for the conversion
* @return 0 if success > 0 otherwise.
*/
public int run(Arguments arguments) throws IOException {
// Reset the error count to start fresh.
errors.set(0);
// empty the list, so that tools that load dx and keep it around
// for multiple runs don't reuse older buffers.
libraryDexBuffers.clear();
args = arguments;
args.makeOptionsObjects(context);
OutputStream humanOutRaw = null;
if (args.humanOutName != null) {
humanOutRaw = openOutput(args.humanOutName);
humanOutWriter = new OutputStreamWriter(humanOutRaw);
}
try {
if (args.multiDex) {
return runMultiDex();
} else {
return runMonoDex();
}
} finally {
closeOutput(humanOutRaw);
}
}
}
這里我們關(guān)注非multiDex的情況，即執(zhí)行了runMonoDex的方法
private int runMonoDex() throws IOException {
...
// 內(nèi)部會(huì)創(chuàng)建dexFile，并填充class
if (!processAllFiles()) {
return 1;
}
if (args.incremental && !anyFilesProcessed) {
return 0; // this was a no-op incremental build
}
// this array is null if no classes were defined
byte[] outArray = null;
if (!outputDex.isEmpty() || (args.humanOutName != null)) {
// 內(nèi)部通過Dex類toDex 方法將 class 文件轉(zhuǎn)化dex byte[]
outArray = writeDex(outputDex);
if (outArray == null) {
return 2;
}
}
if (args.incremental) {
outArray = mergeIncremental(outArray, incrementalOutFile);
}
outArray = mergeLibraryDexBuffers(outArray);
if (args.jarOutput) {
// Effectively free up the (often massive) DexFile memory.
outputDex = null;
if (outArray != null) {
// 輸出的文件名為 classes.dex
outputResources.put(DexFormat.DEX_IN_JAR_NAME, outArray);
}
if (!createJar(args.outName)) {
return 3;
}
} else if (outArray != null && args.outName != null) {
OutputStream out = openOutput(args.outName);
out.write(outArray);
closeOutput(out);
}
return 0;
}
上面的代碼中，填充class以及dex流轉(zhuǎn)換，內(nèi)部流程較為復(fù)雜，就不再繼續(xù)深入，簡(jiǎn)單做下總結(jié)：
1.通過執(zhí)行 processAllFiles ，內(nèi)部創(chuàng)建 DexFile 也就是outputDex，并且填充 class 文件
2.通過 writeDex 方法，將 outputDex 傳入，方法內(nèi)部執(zhí)行的是 outputDex.toDex 方法，將 outputDex 內(nèi)部填充的 class 轉(zhuǎn)化為 dex 的 byte[] 返回
3.最后將 byte[] 數(shù)組創(chuàng)建 classes.dex 輸出
總結(jié)：
Android Gradle Plugin源碼繁多，以上文章只是對(duì)整體流程的簡(jiǎn)單梳理，其中簡(jiǎn)要介紹了構(gòu)建變體任務(wù)的解析和添加 ，最后對(duì)編譯dex流程做了簡(jiǎn)單分析。個(gè)人精力有限，這里的源碼解析也只是九牛一毛，如有紕漏，歡迎大家拍磚，希望這篇文章能幫助到想了解 Android Gradle Plguin 原理的同學(xué)。
