Gradle进阶篇(七)-AGP插件详解-六虎

携手创作，一起生长！这是我参与「日新方案 8 月更文应战」的第6天，点击检查活动概况>>

Hi，我是小余。

本文已收录到GitHub Androider-Planet中。这儿有 Android 进阶生长常识体系，关注公众号 [小余的自习室] ，在成功的路上不走失！

前语

前面几篇文章咱们解说了关于关于Gradle的根底，Gradle生命周期，Gradle相关Api的解说，以及Gradle自定义插件,Gradle Maven库房办理.

Gradle系列文章如下：

Gradle筑基篇：

Gradle筑基篇(一)-Gradle初探
Gradle筑基篇(二)-Groovy语法的详解
Gradle筑基篇(三)-Gradle生命周期
Gradle筑基篇(四)-Gradle APi详解
Gradle筑基篇(五)-Gradle自定义插件实战
Gradle筑基篇(六)-Gradle Maven库房办理

Gradle进阶篇

Gradle进阶篇(七)-AGP详解

今日这篇文章咱们来解说下Android Gradle Plugin相关常识。

简化起见：本文所指AGP：Android Gradle Plugin

1.`Gradle Plugin`和`AGP`的差异？

Gradle Plugin是Gradle构建进程中运用的插件的总称，而Android Gradle Plugin是这个总称里面的一个插件元素.

Android Gradle Plugin合作Gradle构建咱们的运用apk

2.apk构建流程

典型 Android 运用模块的构建流程。

依照以下常规进程履行：

1.将源文件和class文件编译组合后编译为dex文件
2.将资源文件转换为编译后的资源文件
3.将dex文件和编译后的资源文件打包为apk文件
4.运用签名东西对文件进行签名
5.生成最终apk之前，会运用 zipalign 东西对运用进行优化，减小apk运行时内存

在Gradle控制面板：履行assemble使命看看：

Line 172: > Task :application:preBuild UP-TO-DATE //编译预处理使命：空完成
	Line 176: > Task :application:preF1F3DebugBuild UP-TO-DATE //preF1F3DebugBuild F1F3变体预处理使命
	Line 180: > Task :application:compileF1F3DebugAidl NO-SOURCE //编译aidl文件
	Line 184: > Task :application:compileF1F3DebugRenderscript NO-SOURCE //编译制作脚本文件
	Line 188: > Task :application:dataBindingMergeDependencyArtifactsF1F3Debug UP-TO-DATE //dataBinding依靠的类库或许插件兼并
	Line 192: > Task :application:dataBindingMergeGenClassesF1F3Debug UP-TO-DATE //dataBinding依靠的class文件兼并
	Line 196: > Task :application:generateF1F3DebugResValues UP-TO-DATE //生成ResValues 
	Line 200: > Task :application:generateF1F3DebugResources UP-TO-DATE//生成编译后的Resources
	Line 204: > Task :application:mergeF1F3DebugResources UP-TO-DATE //兼并资源文件
	Line 208: > Task :application:dataBindingGenBaseClassesF1F3Debug UP-TO-DATE
	Line 212: > Task :application:dataBindingTriggerF1F3Debug UP-TO-DATE
	Line 216: > Task :application:generateF1F3DebugBuildConfig UP-TO-DATE 生成BuildConfig文件
	Line 220: > Task :application:javaPreCompileF1F3Debug UP-TO-DATE //java预编译
	Line 224: > Task :application:checkF1F3DebugAarMetadata UP-TO-DATE  //检测aar的元数据
	Line 228: > Task :application:createF1F3DebugCompatibleScreenManifests UP-TO-DATE 
	Line 232: > Task :application:extractDeepLinksF1F3Debug UP-TO-DATE
	Line 236: > Task :application:processF1F3DebugMainManifest UP-TO-DATE //处理MainManifest
	Line 240: > Task :application:processF1F3DebugManifest UP-TO-DATE //处理Manifest
	Line 244: > Task :application:processF1F3DebugManifestForPackage UP-TO-DATE//处理ManifestForPackage 
	Line 248: > Task :application:processF1F3DebugResources UP-TO-DATE//处理Resources
	Line 252: > Task :application:compileF1F3DebugJavaWithJavac UP-TO-DATE //编译原代码为class文件
	Line 256: > Task :application:compileF1F3DebugSources UP-TO-DATE//编译Sources
	Line 260: > Task :application:mergeF1F3DebugNativeDebugMetadata NO-SOURCE
	Line 264: > Task :application:mergeF1F3DebugShaders UP-TO-DATE
	Line 268: > Task :application:compileF1F3DebugShaders NO-SOURCE
	Line 272: > Task :application:generateF1F3DebugAssets UP-TO-DATE //生成Assets
	Line 276: > Task :application:mergeF1F3DebugAssets UP-TO-DATE //兼并Assets
	Line 280: > Task :application:compressF1F3DebugAssets UP-TO-DATE //紧缩Assets
	Line 284: > Task :application:checkF1F3DebugDuplicateClasses UP-TO-DATE //检测DuplicateClasses
	Line 288: > Task :application:desugarF1F3DebugFileDependencies UP-TO-DATE
	Line 292: > Task :application:mergeExtDexF1F3Debug UP-TO-DATE //兼并des
	Line 296: > Task :application:processF1F3DebugJavaRes NO-SOURCE //处理JavaRes
	Line 300: > Task :application:mergeF1F3DebugJavaResource UP-TO-DATE //兼并JavaResource
	Line 304: > Task :application:mergeLibDexF1F3Debug UP-TO-DATE //兼并lib的dex
	Line 308: > Task :application:dexBuilderF1F3Debug UP-TO-DATE //dexBuilder
	Line 312: > Task :application:mergeProjectDexF1F3Debug UP-TO-DATE//mergeProjectDex
	Line 316: > Task :application:mergeF1F3DebugJniLibFolders UP-TO-DATE//兼并JniLibFolders
	Line 320: > Task :application:mergeF1F3DebugNativeLibs UP-TO-DATE//兼并NativeLibs
	Line 324: > Task :application:stripF1F3DebugDebugSymbols NO-SOURCE
	Line 328: > Task :application:validateSigningF1F3Debug UP-TO-DATE //检测签名
	Line 332: > Task :application:packageF1F3Debug UP-TO-DATE //打包变种
	Line 336: > Task :application:assembleF1F3Debug UP-TO-DATE//打包变种

能够看到打包apk的使命根本和前面图片里面描述的流程一致，整个进程都是编译然后兼并，打包的进程

首要触及：

1.资源文件。

2.源文件。

3.库文件的资源

4.库文件的class文件，

5.jni的静动态库信息，

6.manfest清单文件的创立

7.签名校验等其他生成一些装备文件

3.`AGP`常用设置类型:

1.buildTypes:编译类型：是debug或许release或许其他自定义类型

android {
    defaultConfig {
        manifestPlaceholders = [hostName:"www.example.com"]
        ...
    }
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
        debug {
            applicationIdSuffix ".debug"
            debuggable true
        }
        /**
         * The `initWith` property allows you to copy configurations from other build types,
         * then configure only the settings you want to change. This one copies the debug build
         * type, and then changes the manifest placeholder and application ID.
         */
        staging {
            initWith debug
            manifestPlaceholders = [hostName:"internal.example.com"]
            applicationIdSuffix ".debugStaging"
        }
    }
}

2.productFlavor：产品变种

创立产品变种与创立 build 类型类似：将其添加到 build 装备中的 productFlavors 代码块并添加所需的设置。产品变种支撑与 defaultConfig 相同的特点，这是因为，defaultConfig 实际上归于 ProductFlavor 类。

这意味着，您能够在 defaultConfig 代码块中提供一切变种的根本装备，每个变种均可更改其中任何默认值，如 applicationId

// Specifies one flavor dimension.
flavorDimensions 'abi','version'
productFlavors {
	f1 {
		dimension 'abi'
		versionName '1.0'
	}
	f2 {
		dimension 'abi'
		versionName '2.0'
	}
	f3 {
		dimension 'version'
	}
	f4 {
		dimension 'version'
	}
}

对应的变体：

3.build 变体

build 变体是 build 类型与产品变种的穿插产物，也是 Gradle 用来构建运用的装备如上面的类型，编译时可选变体类型：

4.清单 (Manifest) 条目

在装备清单中能够设置Manifest清单中给的装备信息，如

applicationId "com.example.myapp"
minSdkVersion 15
targetSdkVersion 24
versionCode 1
versionName "1.0"

这些信息能够单独装备在不同给的变种中：如上面的类型，编译时可选变体类型：这样能够针对不同变体设置不同的清单Manifest信息：

productFlavors {
    f1 {
        dimension 'abi'
        applicationId "com.example.myapp"
        minSdkVersion 15
        targetSdkVersion 24
        versionCode 1
        versionName "1.0"
    }
    f2 {
        dimension 'x86'
        applicationId "com.example.myapp1"
        minSdkVersion 16
        targetSdkVersion 25
        versionCode 2
        versionName "2.0"
    }
}

装备清单中信息会覆盖原Manifest文件中的信息,当有多个清单装备时会兼并兼并东西会依据每个清单文件的优先级按次序兼并，将一切清单文件组合到一个文件中。例如，假如您有三个清单文件，则会先将优先级最低的清单兼并到优先级第二高的清单中，然后再将兼并后的清单兼并到优先级最高的清单中，如图：

5.sourceSets：原文件文件目录

sourceSets {
	main {
		java {
			srcDirs = ['src/main/java']
		}
		res {
			srcDirs = ['src/main/res']
		}
		aidl {
			srcDirs = ['src/main/aidl']
		}
	}
}

6.signingConfigs:签名

Android 体系要求一切 APK 必须先运用证书进行数字签名，然后才能安装到设备上或进行更新

signingConfigs {
    release {
        storeFile file("myreleasekey.keystore")
        storePassword "password"
        keyAlias "MyReleaseKey"
        keyPassword "password"
    }
}

7.compileOptions:指定当时编译的java版别信息

compileOptions {
	sourceCompatibility JavaVersion.VERSION_1_8
	targetCompatibility JavaVersion.VERSION_1_8
}

7.buildFeatures：编译特色特点

buildFeatures {
	aidl = true
	buildConfig = true
	viewBinding = false
	dataBinding = true
}
//这个方法已经被弃用，后边源码能够看到弃用的当地
dataBinding {
	enabled = true
}

以上便是咱们运用AGP时常用的插件装备项

下面咱们从源码去看下AGP插件内部原理。

4.`AGP插件`内部原理

1.源码检查办法

因为AGP插件源码大概有30多个g。所以不建议直接下载源码去阅读能够直接在模块中引进就能够：

1.创立一个lib模块：
2.修改build.gradle中的代码：

apply plugin: 'java'
sourceCompatibility = 1.8
dependencies {
    implementation gradleApi()
    implementation 'com.android.tools.build:gradle:4.1.1'
}

同步代码后：能够在‘External Libraries’中检查源码：

2.检查源码

前面在解说Gradle自定义插件的时分，说过，咱们运用的每个插件都会在resources中进行声明：

大局搜索：

找到implementation-class=com.android.build.gradle.AppPlugin

进入AppPlugin看看：

/**
 * The plugin applied with `com.android.application'
 */
@Suppress("DEPRECATION")
class AppPlugin: BasePlugin() {
    override fun apply(project: Project) {
        super.apply(project)
        project.apply(INTERNAL_PLUGIN_ID)
    }
}
private val INTERNAL_PLUGIN_ID = mapOf("plugin" to "com.android.internal.application")

看到这儿运用的INTERNAL_PLUGIN_ID中的plugin：com.android.internal.application

咱们再次大局搜索下：com.android.internal.application

找到implementation-class=com.android.build.gradle.internal.plugins.AppPlugin
进入：com.android.build.gradle.internal.plugins.AppPlugin

gradle源码：

查找apply办法：

在父类AbstractAppPlugin的父类BasePlugin找到了apply办法：

public final void apply(@NonNull Project project) {
	CrashReporting.runAction(
			() -> {
				//办法1
				basePluginApply(project);
				//办法2
				pluginSpecificApply(project);
			});
}

这儿咱们看办法1：

private void basePluginApply(@NonNull Project project) {
	// We run by default in headless mode, so the JVM doesn't steal focus.
	System.setProperty("java.awt.headless", "true");
	this.project = project;
	//创立Project运行需求的服务信息
	createProjectServices(project);
	//获取Project的特点Options 
	ProjectOptions projectOptions = projectServices.getProjectOptions();
	//依靠检测
	DependencyResolutionChecks.registerDependencyCheck(project, projectOptions);
	//AndroidBasePlugin内部是一个空完成，需求咱们自己去扩展。
	project.getPluginManager().apply(AndroidBasePlugin.class);
	//检测文件途径
	checkPathForErrors();
	//检测模块途径
	checkModulesForErrors();
	AttributionListenerInitializer.INSTANCE.init(
			project, projectOptions.get(StringOption.IDE_ATTRIBUTION_FILE_LOCATION));
	//agp的版别检测
	AgpVersionChecker.enforceTheSamePluginVersions(project);
	RecordingBuildListener buildListener = ProfilerInitializer.init(project, projectOptions);
	//注册buildListener构建的监听逻辑
	ProfileAgent.INSTANCE.register(project.getName(), buildListener);
	threadRecorder = ThreadRecorder.get();
	ProcessProfileWriter.getProject(project.getPath())
			.setAndroidPluginVersion(Version.ANDROID_GRADLE_PLUGIN_VERSION)
			.setAndroidPlugin(getAnalyticsPluginType())
			.setPluginGeneration(GradleBuildProject.PluginGeneration.FIRST)
			.setOptions(AnalyticsUtil.toProto(projectOptions));
	/**
	Gradle构建生命周期中的Agp插件的装备流程：
	1.configureProject：构建project装备、
	2.configureExtension：装备外部Extension字段
	3.createTasks：创立Tasks
	*/
	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);
}

办法1首要使命：

做一些前期的检查工作，设置一些生命周期回调监听，创立使命等操作。
Gradle构建生命周期中的Agp插件的装备流程：

1.configureProject：构建project装备、 2.configureExtension：装备外部Extension字段 3.createTasks：创立Tasks

看第一阶段：configureProject

private void configureProject() {
        final Gradle gradle = project.getGradle();
		//创立缓存版别变化的原因的字符串
        Provider<ConstraintHandler.CachedStringBuildService> cachedStringBuildServiceProvider =
                new ConstraintHandler.CachedStringBuildService.RegistrationAction(project)
                        .execute();
		///** Build service used to cache maven coordinates for libraries. */
        Provider<MavenCoordinatesCacheBuildService> mavenCoordinatesCacheBuildService =
                new MavenCoordinatesCacheBuildService.RegistrationAction(
                                project, cachedStringBuildServiceProvider)
                        .execute();
        new LibraryDependencyCacheBuildService.RegistrationAction(project).execute();
        extraModelInfo = new ExtraModelInfo(mavenCoordinatesCacheBuildService);
        ProjectOptions projectOptions = projectServices.getProjectOptions();
        IssueReporter issueReporter = projectServices.getIssueReporter();
		//创立Aapt2工作的构建Service
        new Aapt2WorkersBuildService.RegistrationAction(project, projectOptions).execute();
		//创立一个Aapt2 Daemon的构建Service
        new Aapt2DaemonBuildService.RegistrationAction(project).execute();
        new SyncIssueReporterImpl.GlobalSyncIssueService.RegistrationAction(
                        project, SyncOptions.getModelQueryMode(projectOptions))
                .execute();
        Provider<SdkComponentsBuildService> sdkComponentsBuildService =
                new SdkComponentsBuildService.RegistrationAction(
                                project,
                                projectOptions,
                                project.getProviders()
                                        .provider(() -> extension.getCompileSdkVersion()),
                                project.getProviders()
                                        .provider(() -> extension.getBuildToolsRevision()),
                                project.getProviders().provider(() -> extension.getNdkVersion()),
                                project.getProviders().provider(() -> extension.getNdkPath()))
                        .execute();
        projectOptions
                .getAllOptions()
                .forEach(projectServices.getDeprecationReporter()::reportOptionIssuesIfAny);
        IncompatibleProjectOptionsReporter.check(
                projectOptions, projectServices.getIssueReporter());
        // Enforce minimum versions of certain plugins
        GradlePluginUtils.enforceMinimumVersionsOfPlugins(project, issueReporter);
        // Apply the Java plugin
        project.getPlugins().apply(JavaBasePlugin.class);
        dslServices =
                new DslServicesImpl(
                        projectServices,
                        new DslVariableFactory(syncIssueReporter),
                        sdkComponentsBuildService);
        MessageReceiverImpl messageReceiver =
                new MessageReceiverImpl(
                        SyncOptions.getErrorFormatMode(projectOptions),
                        projectServices.getLogger());
		//将前面创立的一切服务放到globalScope目标中
        globalScope =
                new GlobalScope(
                        project,
                        creator,
                        dslServices,
                        sdkComponentsBuildService,
                        registry,
                        messageReceiver,
                        componentFactory);
        project.getTasks()
                .named("assemble")
                .configure(
                        task ->
                                task.setDescription(
                                        "Assembles all variants of all applications and secondary packages."));
        // As soon as project is evaluated we can clear the shared state for deprecation reporting.
        gradle.projectsEvaluated(action -> DeprecationReporterImpl.Companion.clean());
        createLintClasspathConfiguration(project);
    }

这个办法首要是创立了一系列构建需求的服务，并将服务放到一个globalScope目标中，也算是一些前期准备工作。

来看阶段2：`configureExtension`

private void configureExtension() {
		//获取dsl服务
        DslServices dslServices = globalScope.getDslServices();
		//获取构建输出
        final NamedDomainObjectContainer<BaseVariantOutput> buildOutputs =
                project.container(BaseVariantOutput.class);
        project.getExtensions().add("buildOutputs", buildOutputs);
		//创立变体的工厂类
        variantFactory = createVariantFactory(projectServices, globalScope);
		//将前面创立的几个目标都放入到variantInputModel目标中：
        variantInputModel =
                new LegacyVariantInputManager(
                        dslServices,
                        variantFactory.getVariantType(),
                        new SourceSetManager(
                                project,
                                isPackagePublished(),
                                dslServices,
                                new DelayedActionsExecutor()));
		//这儿创立了外部扩展Extension，进入到这个办法看看
        extension =
                createExtension(
                        dslServices, globalScope, variantInputModel, buildOutputs, extraModelInfo);
        globalScope.setExtension(extension);
        variantManager =
                new VariantManager<>(
                        globalScope,
                        project,
                        projectServices.getProjectOptions(),
                        extension,
                        variantFactory,
                        variantInputModel,
                        projectServices,
                        threadRecorder);
        registerModels(
                registry,
                globalScope,
                variantInputModel,
                extension,
                extraModelInfo);
        // create default Objects, signingConfig first as its used by the BuildTypes.
        variantFactory.createDefaultComponents(variantInputModel);
        createAndroidTestUtilConfiguration();
    }

进入createExtension办法：

这个是抽象办法：具体完成是在子类AppPlugin中：

protected AppExtension createExtension(
		@NonNull DslServices dslServices,
		@NonNull GlobalScope globalScope,
		@NonNull
				DslContainerProvider<DefaultConfig, BuildType, ProductFlavor, SigningConfig>
						dslContainers,
		@NonNull NamedDomainObjectContainer<BaseVariantOutput> buildOutputs,
		@NonNull ExtraModelInfo extraModelInfo) {
	return project.getExtensions()
			.create(
					"android",
					getExtensionClass(),
					dslServices,
					globalScope,
					buildOutputs,
					dslContainers.getSourceSetManager(),
					extraModelInfo,
					new ApplicationExtensionImpl(dslServices, 
					));
}

能够看到这儿创立了一个‘android’的Extensions，bean类型为：BaseAppModuleExtension

这个BaseAppModuleExtension类便是咱们能够在外部做扩展的起始点，这个类中有哪些特点包括父类中的特点都能够被扩展：进到这个类中看看：

/** The `android` extension for base feature module (application plugin).  */
open class BaseAppModuleExtension(...private val publicExtensionImpl: ApplicationExtensionImpl)
:AppExtension:InternalApplicationExtension by publicExtensionImpl,。。

看到该类承继了AppExtension和InternalApplicationExtension(被ApplicationExtensionImpl代理)

AppExtension又承继AbstractAppExtension承继TestedExtension承继BaseExtension 下面画出对应的类图联系

这几个类组成了AGP一切的对外扩展特点

这儿罗列几个平常项目中开发用到的字段：

1.在ApplicationExtensionImpl中：

buildFeatures特点：

public open val buildFeatures:com.android.build.api.dsl.ApplicationBuildFeatures

检查ApplicationBuildFeatures中的代码：

内部就两条特点：

//用于dataBinding支撑
var dataBinding: Boolean?
var mlModelBinding: Boolean?

ApplicationBuildFeatures 承继 BuildFeatures 进入BuildFeatures 看看:

能够看到这儿面能够装备许多信息：

buildFeatures {
	aidl = true
	buildConfig = true
	viewBinding = false
	dataBinding = true
	....
}

2.在AbstractAppExtension中

val applicationVariants: DomainObjectSet<ApplicationVariant> =
        dslServices.domainObjectSet(ApplicationVariant::class.java)

这条特点，能够让咱们在外部获取到当时一切变种： DomainObjectSet是一个集合，能够运用集合遍历方法：

android.applicationVariants.all {variant->
	variant.outputs.all {output->
		outputFileName ="landi_dev_v${variant.versionName}_${variant.name}"+".apk"
	}
}

相信这个代码我们在自己项目中或多或少都见过通过前面分析咱们就知道：

variant = ApplicationVariant类目标
output = BaseVariantOutput类目标

关于configureExtension就介绍到这

第3阶段：`createTasks`

private void createTasks() {
        threadRecorder.record(
                ExecutionType.TASK_MANAGER_CREATE_TASKS,
                project.getPath(),
                null,
                () ->
                        TaskManager.createTasksBeforeEvaluate(
                                globalScope,
                                variantFactory.getVariantType(),
                                extension.getSourceSets()));
        project.afterEvaluate(
                CrashReporting.afterEvaluate(
                        p -> {
                            variantInputModel.getSourceSetManager().runBuildableArtifactsActions();
                            threadRecorder.record(
                                    ExecutionType.BASE_PLUGIN_CREATE_ANDROID_TASKS,
                                    project.getPath(),
                                    null,
                                    this::createAndroidTasks);
                        }));
    }

1.BeforeEvaluate：装备前创立一些task
2.afterEvaluate:装备后创立一些task：进入createAndroidTasks看看：

 final void createAndroidTasks() {
		//运用variantManager创立变体 关注点1.。。
		variantManager.createVariants();
		//创立TaskManager 关注点2.。。
		TaskManager<VariantT, VariantPropertiesT> taskManager =
                createTaskManager(
                        variants,
                        variantManager.getTestComponents(),
                        !variantInputModel.getProductFlavors().isEmpty(),
                        globalScope,
                        extension,
                        threadRecorder);
		//运用TaskManager创立使命：关注点3.。。
        taskManager.createTasks();
		//这儿设置Transforms的使命，假如外部有
		new DependencyConfigurator(project, project.getName(), globalScope, variantInputModel)
			.configureDependencySubstitutions()
			.configureGeneralTransforms()
			.configureVariantTransforms(variants, variantManager.getTestComponents());
		for (ComponentInfo<VariantT, VariantPropertiesT> variant : variants) {
            apiObjectFactory.create(variant.getProperties());
        }
		// lock the Properties of the variant API after the old API because
        // of the versionCode/versionName properties that are shared between the old and new APIs.
        variantManager.lockVariantProperties();
        // Make sure no SourceSets were added through the DSL without being properly configured
        variantInputModel.getSourceSetManager().checkForUnconfiguredSourceSets();
        // configure compose related tasks.
        taskManager.createPostApiTasks();
        ...
        GradleProperty.Companion.endOfEvaluation();
	 }
	 看关注点1：variantManager.createVariants();
	 /** Creates the variants. */
    public void createVariants() {
        variantFactory.validateModel(variantInputModel);
        variantFactory.preVariantWork(project);
        computeVariants();
    }
	进入computeVariants：
	 /** Create all variants. */
    private void computeVariants() {
		//获取一切flavorDimension放到List中
        List<String> flavorDimensionList = extension.getFlavorDimensionList();
		//获取一切buildTypes和productFlavor信息：
        DimensionCombinator computer =
                new DimensionCombinator(
                        variantInputModel,
                        projectServices.getIssueReporter(),
                        flavorDimensionList);
		//计算一切的变体
        List<DimensionCombination> variants = computer.computeVariants();
		//锁定变体
        variantApiServices.lockValues();
    }

关注点1首要作用便是获取一切的产品变体和buildTypes，创立对应的变体列表

关注点2：createTaskManager

抽象办法在子类AppPlugin中完成：

protected ApplicationTaskManager createTaskManager(
            @NonNull
                    List<ComponentInfo<ApplicationVariantImpl, ApplicationVariantPropertiesImpl>>
                            variants,
            @NonNull
                    List<
                                    ComponentInfo<
                                            TestComponentImpl<
                                                    ? extends TestComponentPropertiesImpl>,
                                            TestComponentPropertiesImpl>>
                            testComponents,
            boolean hasFlavors,
            @NonNull GlobalScope globalScope,
            @NonNull BaseExtension extension,
            @NonNull Recorder threadRecorder) {
			return new ApplicationTaskManager(
                variants, testComponents, hasFlavors, globalScope, extension, threadRecorder);
		}
		}

创立的是一个ApplicationTaskManager类目标，后边会用到

来看关注点3：

这儿面其实便是创立一系列的task,篇幅太长，纷歧一介绍

阶段三:createTasks首要使命：

1.依据Extensions中的信息创立一切变体，
2.给一切变体创立对应的使命：包括装备前使命和装备后的使命

总结咱们的AGP首要使命：

1.创立了一系列构建需求的服务，并将服务放到一个globalScope目标中，作为前期准备工作

2.解析咱们的外部扩展android{}闭包中的信息，设置到Project中

3.依据buidTypes和产品变种创立对应的变种信息，创立一系列的构建使命。

参阅

Android构建官方文档
补齐Android技术树——从AGP构建进程到APK打包进程

Gradle进阶篇(七)-AGP插件详解

前语

1.Gradle Plugin和AGP的差异？

2.apk构建流程

3.AGP常用设置类型:

4.AGP插件内部原理

1.源码检查办法

2.检查源码

看第一阶段：configureProject

来看阶段2：configureExtension

第3阶段：createTasks

参阅

相关文章

SpringBoot-Spring Data Jpa调优

29道面试基础算法题，试试看会不会

线程的生命周期和常用方法

如何实现一款接入chatGPT的智能音箱

作者信息

1.`Gradle Plugin`和`AGP`的差异？

3.`AGP`常用设置类型:

4.`AGP插件`内部原理

来看阶段2：`configureExtension`

第3阶段：`createTasks`