[3/3]gradle 编译 Android app 概览

灰太狼 2022-04-12 12:46 171阅读 0赞

转自：http://www.cnblogs.com/chenjie0949/p/4778042.html  
  
  
引言：经过上两篇的论述，我们已经从代码到架构都简单的熟悉了一遍，理论上，只要知道android app的编译过程，我们大可以自己写一份用gradle编译app的插件，插件内将将整个流程用Task的依赖串联起来。现在我们看看gradle是怎么做的。  
  
\[size=large\]\[b\]复习，android 编译流程\[/b\]\[/size\]  
面试中经常出现的问题，android的编译流程。这个问题十分简单和好记。android是用java来开发的，所以最基本的流程和java一致：.java -> .class。android有着自己独特的虚拟机环境dalvik，毕竟arm架构寄存器比较多，而是内存较小，所以要转换一下.class -> .dex。再说资源那条线，第一件事当然是生成R.java文件了,这个java文件和我们一般的java文件并没有区别，不然我们代码怎么用呢，然后是将资源文件和dex文件打包成apk：rec+.dex=.apk。有了.apk,签名.signed.apk，压缩.aligned.signed.apk。当然还有其他的分支，比如 .aidl，可以理解成一种特殊的资源文件，同样生成.java文件和我们的代码对接，jni也是同样，只是生成顺序是我们写java端的，当然这无关紧要，符合接口约定就可以。  
  
主线： .java --(java)-->.class--(dex)-->.dex +rec --(apkbuild)-->.apk--(jarSigne)-->.Singed.apk--(zipalign)-->.aligned.signed.apk  
  
  
  
\[size=large\]\[b\]设置属性即可\[/b\]\[/size\]  
我们用android studio 创建一个android app程序，打开他的build.gradle。

apply plugin: 'com.android.application'
    
    android {
       
        compileSdkVersion 21
        buildToolsVersion "23.0.0 rc2"
    
        defaultConfig {
       
            applicationId "suning.com.myapplication"
            minSdkVersion 15
            targetSdkVersion 21
            versionCode 1
            versionName "1.0"
        }
        sourceSets{
       
    
        }
    
        buildTypes {
       
            release {
       
                minifyEnabled false
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            }
        }
    }
    
    dependencies {
       
        compile fileTree(dir: 'libs', include: ['*.jar'])
        compile 'com.android.support:appcompat-v7:22.2.0'
    }

android studio的好处是我们能方便的看到源码，鉴于上两篇把整个代码组织流程已经推敲过，所以整个脚本并没有什么难以理解的地方。  
  
开头第一句导入 com.android.application 的编译插件，下面则是对整个编译的参数进行设置（和第二篇的最后一个例子如出一辙，不过例子上的代码很简化）。我们按住ctr，鼠标左击第三行的android，就可以进入这个属性的源码：AppExtension.groovy,它继承于TestedExtension.groovy,又继承于BaseExtension.groovy。看这一长串的extension，结合我们上一篇的例子，不难猜出这是需要绑定在project里的extension 属性。我们看下BaseExtension的源码：

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 package com.android.build.gradle
 
 import com.android.SdkConstants
 import com.android.annotations.NonNull
 import com.android.annotations.Nullable
 import com.android.build.gradle.api.AndroidSourceSet
 import com.android.build.gradle.api.BaseVariant
 import com.android.build.gradle.api.TestVariant
 import com.android.build.gradle.api.VariantFilter
 import com.android.build.gradle.internal.CompileOptions
 import com.android.build.gradle.internal.ExtraModelInfo
 import com.android.build.gradle.internal.LoggingUtil
 import com.android.build.gradle.internal.SdkHandler
 import com.android.build.gradle.internal.SourceSetSourceProviderWrapper
 import com.android.build.gradle.internal.coverage.JacocoExtension
 import com.android.build.gradle.internal.dsl.AaptOptions
 import com.android.build.gradle.internal.dsl.AdbOptions
 import com.android.build.gradle.internal.dsl.AndroidSourceSetFactory
 import com.android.build.gradle.internal.dsl.BuildType
 import com.android.build.gradle.internal.dsl.DexOptions
 import com.android.build.gradle.internal.dsl.GroupableProductFlavor
 import com.android.build.gradle.internal.dsl.LintOptions
 import com.android.build.gradle.internal.dsl.PackagingOptions
 import com.android.build.gradle.internal.dsl.ProductFlavor
 import com.android.build.gradle.internal.dsl.SigningConfig
 import com.android.build.gradle.internal.dsl.Splits
 import com.android.build.gradle.internal.dsl.TestOptions
 import com.android.builder.core.AndroidBuilder
 import com.android.builder.core.BuilderConstants
 import com.android.builder.model.SourceProvider
 import com.android.builder.sdk.TargetInfo
 import com.android.builder.testing.api.DeviceProvider
 import com.android.builder.testing.api.TestServer
 import com.android.sdklib.repository.FullRevision
 import com.google.common.collect.Lists
 import groovy.transform.CompileStatic
 import org.gradle.api.Action
 import org.gradle.api.GradleException
 import org.gradle.api.NamedDomainObjectContainer
 import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.ConfigurationContainer
 import org.gradle.api.internal.project.ProjectInternal
 import org.gradle.api.logging.Logger
 import org.gradle.api.logging.Logging
 import org.gradle.api.tasks.SourceSet
 import org.gradle.internal.reflect.Instantiator
 
 /**
 * Base 'android' extension for all android plugins.
 *
 * This is never used directly. Instead,
 *<ul>
 * <li>Plugin <code>com.android.application</code> uses {@link AppExtension}</li>
 * <li>Plugin <code>com.android.library</code> uses {@link LibraryExtension}</li>
 * </ul>
 */
 public abstract class BaseExtension {
 
 
 private String target
 private FullRevision buildToolsRevision
 
 /** Default config, shared by all flavors. */
 final ProductFlavor defaultConfig
 
 /** Options for aapt, tool for packaging resources. */
 final AaptOptions aaptOptions
 
 /** Lint options. */
 final LintOptions lintOptions
 
 /** Dex options. */
 final DexOptions dexOptions
 
 /** Options for running tests. */
 final TestOptions testOptions
 
 /** Compile options */
 final CompileOptions compileOptions
 
 /** Packaging options. */
 final PackagingOptions packagingOptions
 
 /** JaCoCo options. */
 final JacocoExtension jacoco
 
 /**
 * APK splits options.
 *
 * See <a href="http://tools.android.com/tech-docs/new-build-system/user-guide/apk-splits">APK Splits</a>.
 */
 final Splits splits
 
 /** All product flavors used by this project. */
 final NamedDomainObjectContainer<GroupableProductFlavor> productFlavors
 
 /** Build types used by this project. */
 final NamedDomainObjectContainer<BuildType> buildTypes
 
 /** Signing configs used by this project. */
 final NamedDomainObjectContainer<SigningConfig> signingConfigs
 
 private ExtraModelInfo extraModelInfo
 
 protected Project project
 
 /** Adb options */
 final AdbOptions adbOptions;
 
 /** A prefix to be used when creating new resources. Used by Studio */
 String resourcePrefix
 
 List<String> flavorDimensionList
 
 private String defaultPublishConfig = "release"
 private boolean publishNonDefault = false
 
 private Closure<Void> variantFilter
 
 private final List<DeviceProvider> deviceProviderList = Lists.newArrayList();
 private final List<TestServer> testServerList = Lists.newArrayList();
 
 private final AndroidBuilder androidBuilder
 
 private final SdkHandler sdkHandler
 
 protected Logger logger
 
 private boolean isWritable = true;
 
 /**
 * The source sets container.
 */
 final NamedDomainObjectContainer<AndroidSourceSet> sourceSetsContainer
 
 BaseExtension(
 @NonNull ProjectInternal project,
 @NonNull Instantiator instantiator,
 @NonNull AndroidBuilder androidBuilder,
 @NonNull SdkHandler sdkHandler,
 @NonNull NamedDomainObjectContainer<BuildType> buildTypes,
 @NonNull NamedDomainObjectContainer<GroupableProductFlavor> productFlavors,
 @NonNull NamedDomainObjectContainer<SigningConfig> signingConfigs,
 @NonNull ExtraModelInfo extraModelInfo,
 boolean isLibrary) {
 
 this.androidBuilder = androidBuilder
 this.sdkHandler = sdkHandler
 this.buildTypes = buildTypes
 this.productFlavors = productFlavors
 this.signingConfigs = signingConfigs
 this.extraModelInfo = extraModelInfo
 this.project = project
 
 logger = Logging.getLogger(this.class)
 
 defaultConfig = instantiator.newInstance(ProductFlavor, BuilderConstants.MAIN,
 project, instantiator, project.getLogger())
 
 aaptOptions = instantiator.newInstance(AaptOptions)
 dexOptions = instantiator.newInstance(DexOptions)
 lintOptions = instantiator.newInstance(LintOptions)
 testOptions = instantiator.newInstance(TestOptions)
 compileOptions = instantiator.newInstance(CompileOptions)
 packagingOptions = instantiator.newInstance(PackagingOptions)
 jacoco = instantiator.newInstance(JacocoExtension)
 adbOptions = instantiator.newInstance(AdbOptions)
 splits = instantiator.newInstance(Splits, instantiator)
 
 sourceSetsContainer = project.container(AndroidSourceSet,
 new AndroidSourceSetFactory(instantiator, project, isLibrary))
 
 sourceSetsContainer.whenObjectAdded { AndroidSourceSet sourceSet ->
 ConfigurationContainer configurations = project.getConfigurations()
 
 createConfiguration(
 configurations,
 sourceSet.getCompileConfigurationName(),
 "Classpath for compiling the ${sourceSet.name} sources.")
 
 String packageConfigDescription
 if (isLibrary) {
 
 packageConfigDescription = "Classpath only used when publishing '${sourceSet.name}'."
 } else {
 
 packageConfigDescription = "Classpath packaged with the compiled '${sourceSet.name}' classes."
 }
 createConfiguration(
 configurations,
 sourceSet.getPackageConfigurationName(),
 packageConfigDescription)
 
 createConfiguration(
 configurations,
 sourceSet.getProvidedConfigurationName(),
 "Classpath for only compiling the ${sourceSet.name} sources.")
 
 createConfiguration(
 configurations,
 sourceSet.getWearAppConfigurationName(),
 "Link to a wear app to embed for object '${sourceSet.name}'.")
 
 sourceSet.setRoot(String.format("src/%s", sourceSet.getName()))
 }
 
 sourceSetsContainer.create(defaultConfig.name)
 }
 
 /**
 * Disallow further modification on the extension.
 */
 public void disableWrite() {
 
 isWritable = false
 }
 
 protected checkWritability() {
 
 if (!isWritable) {
 
 throw new GradleException(
 "Android tasks have already been created.\n" +
 "This happens when calling android.applicationVariants,\n" +
 "android.libraryVariants or android.testVariants.\n" +
 "Once these methods are called, it is not possible to\n" +
 "continue configuring the model.")
 }
 }
 
 protected void createConfiguration(
 @NonNull ConfigurationContainer configurations,
 @NonNull String configurationName,
 @NonNull String configurationDescription) {
 
 logger.info("Creating configuration ${configurationName}.")
 
 Configuration configuration = configurations.findByName(configurationName)
 if (configuration == null) {
 
 configuration = configurations.create(configurationName)
 }
 configuration.setVisible(false);
 configuration.setDescription(configurationDescription)
 }
 
 /**
 * Sets the compile SDK version, based on full SDK version string, e.g.
 * <code>android-21</code> for Lollipop.
 */
 void compileSdkVersion(String version) {
 
 checkWritability()
 this.target = version
 }
 
 /**
 * Sets the compile SDK version, based on API level, e.g. 21 for Lollipop.
 */
 void compileSdkVersion(int apiLevel) {
 
 compileSdkVersion("android-" + apiLevel)
 }
 
 void setCompileSdkVersion(int apiLevel) {
 
 compileSdkVersion(apiLevel)
 }
 
 void setCompileSdkVersion(String target) {
 
 compileSdkVersion(target)
 }
 
 void buildToolsVersion(String version) {
 
 checkWritability()
 buildToolsRevision = FullRevision.parseRevision(version)
 }
 
 /**
 * Required. Version of the build tools to use.
 *
 * Value assigned to this property is parsed and stored in a normalized form, so reading it
 * back may give a slightly different string.
 */
 String getBuildToolsVersion() {
 
 return buildToolsRevision.toString()
 }
 
 void setBuildToolsVersion(String version) {
 
 buildToolsVersion(version)
 }
 
 /**
 * Configures the build types.
 */
 void buildTypes(Action<? super NamedDomainObjectContainer<BuildType>> action) {
 
 checkWritability()
 action.execute(buildTypes)
 }
 
 /**
 * Configures the product flavors.
 */
 void productFlavors(Action<? super NamedDomainObjectContainer<GroupableProductFlavor>> action) {
 
 checkWritability()
 action.execute(productFlavors)
 }
 
 /**
 * Configures the signing configs.
 */
 void signingConfigs(Action<? super NamedDomainObjectContainer<SigningConfig>> action) {
 
 checkWritability()
 action.execute(signingConfigs)
 }
 
 public void flavorDimensions(String... dimensions) {
 
 checkWritability()
 flavorDimensionList = Arrays.asList(dimensions)
 }
 
 /**
 * Configures the source sets. Note that the Android plugin uses its own implementation of
 * source sets, {@link AndroidSourceSet}.
 */
 void sourceSets(Action<NamedDomainObjectContainer<AndroidSourceSet>> action) {
 
 checkWritability()
 action.execute(sourceSetsContainer)
 }
 
 /**
 * All source sets. Note that the Android plugin uses its own implementation of
 * source sets, {@link AndroidSourceSet}.
 */
 NamedDomainObjectContainer<AndroidSourceSet> getSourceSets() {
 
 sourceSetsContainer
 }
 
 /**
 * The default configuration, inherited by all build flavors (if any are defined).
 */
 void defaultConfig(Action<ProductFlavor> action) {
 
 checkWritability()
 action.execute(defaultConfig)
 }
 
 /**
 * Configures aapt options.
 */
 void aaptOptions(Action<AaptOptions> action) {
 
 checkWritability()
 action.execute(aaptOptions)
 }
 
 /**
 * Configures dex options.
 * @param action
 */
 void dexOptions(Action<DexOptions> action) {
 
 checkWritability()
 action.execute(dexOptions)
 }
 
 /**
 * Configure lint options.
 */
 void lintOptions(Action<LintOptions> action) {
 
 checkWritability()
 action.execute(lintOptions)
 }
 
 /** Configures the test options. */
 void testOptions(Action<TestOptions> action) {
 
 checkWritability()
 action.execute(testOptions)
 }
 
 /**
 * Configures compile options.
 */
 void compileOptions(Action<CompileOptions> action) {
 
 checkWritability()
 action.execute(compileOptions)
 }
 
 /**
 * Configures packaging options.
 */
 void packagingOptions(Action<PackagingOptions> action) {
 
 checkWritability()
 action.execute(packagingOptions)
 }
 
 /**
 * Configures JaCoCo options.
 */
 void jacoco(Action<JacocoExtension> action) {
 
 checkWritability()
 action.execute(jacoco)
 }
 
 /**
 * Configures adb options.
 */
 void adbOptions(Action<AdbOptions> action) {
 
 checkWritability()
 action.execute(adbOptions)
 }
 
 /**
 * Configures APK splits.
 */
 void splits(Action<Splits> action) {
 
 checkWritability()
 action.execute(splits)
 }
 
 void deviceProvider(DeviceProvider deviceProvider) {
 
 checkWritability()
 deviceProviderList.add(deviceProvider)
 }
 
 @NonNull
 List<DeviceProvider> getDeviceProviders() {
 
 return deviceProviderList
 }
 
 void testServer(TestServer testServer) {
 
 checkWritability()
 testServerList.add(testServer)
 }
 
 @NonNull
 List<TestServer> getTestServers() {
 
 return testServerList
 }
 
 public void defaultPublishConfig(String value) {
 
 setDefaultPublishConfig(value)
 }
 
 public void publishNonDefault(boolean value) {
 
 publishNonDefault = value
 }
 
 /**
 * Name of the configuration used to build the default artifact of this project.
 *
 * See <a href="http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Referencing-a-Library">
 * Referencing a Library</a>
 */
 public String getDefaultPublishConfig() {
 
 return defaultPublishConfig
 }
 
 public void setDefaultPublishConfig(String value) {
 
 defaultPublishConfig = value
 }
 
 /**
 * Whether to publish artifacts for all configurations, not just the default one.
 *
 * See <a href="http://tools.android.com/tech-docs/new-build-system/user-guide#TOC-Referencing-a-Library">
 * Referencing a Library</a>
 */
 public boolean getPublishNonDefault() {
 
 return publishNonDefault
 }
 
 void variantFilter(Closure<Void> filter) {
 
 setVariantFilter(filter)
 }
 
 void setVariantFilter(Closure<Void> filter) {
 
 variantFilter = filter
 }
 
 /**
 * A variant filter to control which variants are excluded.
 * The filter is a closure which is passed a single object of type
 * {@link com.android.build.gradle.internal.api.VariantFilter}. It should set the
 * {@link VariantFilter#setIgnore(boolean)} flag to filter out the given variant.
 */
 public Closure<Void> getVariantFilter() {
 
 return variantFilter;
 }
 
 void resourcePrefix(String prefix) {
 
 resourcePrefix = prefix
 }
 
 abstract void addVariant(BaseVariant variant)
 
 public void registerArtifactType(@NonNull String name,
 boolean isTest,
 int artifactType) {
 
 extraModelInfo.registerArtifactType(name, isTest, artifactType)
 }
 
 public void registerBuildTypeSourceProvider(
 @NonNull String name,
 @NonNull BuildType buildType,
 @NonNull SourceProvider sourceProvider) {
 
 extraModelInfo.registerBuildTypeSourceProvider(name, buildType, sourceProvider)
 }
 
 public void registerProductFlavorSourceProvider(
 @NonNull String name,
 @NonNull ProductFlavor productFlavor,
 @NonNull SourceProvider sourceProvider) {
 
 extraModelInfo.registerProductFlavorSourceProvider(name, productFlavor, sourceProvider)
 }
 
 @CompileStatic
 public void registerJavaArtifact(
 @NonNull String name,
 @NonNull BaseVariant variant,
 @NonNull String assembleTaskName,
 @NonNull String javaCompileTaskName,
 @NonNull Collection<File> generatedSourceFolders,
 @NonNull Iterable<String> ideSetupTaskNames,
 @NonNull Configuration configuration,
 @NonNull File classesFolder,
 @NonNull File javaResourceFolder,
 @Nullable SourceProvider sourceProvider) {
 
 extraModelInfo.registerJavaArtifact(name, variant, assembleTaskName,
 javaCompileTaskName, generatedSourceFolders, ideSetupTaskNames,
 configuration, classesFolder, javaResourceFolder, sourceProvider)
 }
 
 public void registerMultiFlavorSourceProvider(
 @NonNull String name,
 @NonNull String flavorName,
 @NonNull SourceProvider sourceProvider) {
 
 extraModelInfo.registerMultiFlavorSourceProvider(name, flavorName, sourceProvider)
 }
 
 @NonNull
 public SourceProvider wrapJavaSourceSet(@NonNull SourceSet sourceSet) {
 
 return new SourceSetSourceProviderWrapper(sourceSet)
 }
 
 /**
 * Required. Compile SDK version.
 *
 * Your code will be compiled against the android.jar from this API level. You should
 * generally use the most up-to-date SDK version here. Use the Lint tool to make sure you don't
 * use APIs not available in earlier platform version without checking.
 *
 * Setter can be called with a string like "android-21" or a number.
 *
 * Value assigned to this property is parsed and stored in a normalized form, so reading it
 * back may give a slightly different string.
 */
 public String getCompileSdkVersion() {
 
 return target
 }
 
 public FullRevision getBuildToolsRevision() {
 
 return buildToolsRevision
 }
 
 public File getSdkDirectory() {
 
 return sdkHandler.getSdkFolder()
 }
 
 public File getNdkDirectory() {
 
 return sdkHandler.getNdkFolder()
 }
 
 public List<File> getBootClasspath() {
 
 ensureTargetSetup()
 return androidBuilder.getBootClasspath()
 }
 
 public File getAdbExe() {
 
 return sdkHandler.getSdkInfo().adb
 }
 
 public File getDefaultProguardFile(String name) {
 
 File sdkDir = sdkHandler.getAndCheckSdkFolder()
 return new File(sdkDir,
 SdkConstants.FD_TOOLS + File.separatorChar
 + SdkConstants.FD_PROGUARD + File.separatorChar
 + name);
 }
 
 // ---------------
 // TEMP for compatibility
 // STOPSHIP Remove in 1.0
 
 // by default, we do not generate pure splits
 boolean generatePureSplits = false;
 
 void generatePureSplits(boolean flag) {
 
 if (flag) {
 
 logger.warn("Pure splits are not supported by PlayStore yet.")
 }
 this.generatePureSplits = flag;
 }
 
 private boolean enforceUniquePackageName = true
 
 public void enforceUniquePackageName(boolean value) {
 
 if (!value) {
 
 LoggingUtil.displayDeprecationWarning(logger, project, "Support for libraries with same package name is deprecated and will be removed in 1.0")
 }
 enforceUniquePackageName = value
 }
 
 public void setEnforceUniquePackageName(boolean value) {
 
 enforceUniquePackageName(value)
 }
 
 public getEnforceUniquePackageName() {
 
 return enforceUniquePackageName
 }
 
 private void ensureTargetSetup() {
 
 // check if the target has been set.
 TargetInfo targetInfo = androidBuilder.getTargetInfo()
 if (targetInfo == null) {
 
 sdkHandler.initTarget(
 getCompileSdkVersion(),
 buildToolsRevision,
 androidBuilder)
 }
 }
 }

在整个android app的编译流程用的工具，在这个类中基本都可以设置属性，设置的方式当然是我们一直用的闭包。随便举个例子，我们想设置下apk签名，工具当然是jarSign,搜索下jarSign,没有，换个sign，就能找到import com.android.build.gradle.internal.dsl.SigningConfig，进入SigningConfig类，所有和签名有关的代码一目了然了。用闭包的方法设置就是：

android{ 
         signingConfigs {
       
                releaseConfig {
       
                    keyAlias 'stone'
                    keyPassword 'mypwd'
                    storeFile file('/Users/stone/Documents/project_AS/myapplication/stone.keystore')
                    storePassword 'mypwd'
                }
         }
    }

建议把BaseExtension的代码大致浏览下，基本的编译设置都能找到。  
  
  
  
我认为学习技术开始无需太过关注细节，主流程通了，实现技术了然于心，下面的事查下帮助文档就可以了。额，贴个帮助文档的地址把：  
  
http://avatarqing.github.io/Gradle-Plugin-User-Guide-Chinese-Verision/