Gradle for Android

android下可配置项

android {
    defaultConfig {
        //默认配置项，defaultConfig就是程序的默认配置，注意，如果在   AndroidMainfest.xml里面定义了与这里相同的属性，会以这里的为主。
    }

    buildTypes {
      // 编译配置，release或debug版本的内容
    }

    compileOptions {
      // Java 的版本配置
    }

    sourceSets {
        //源码设置(项目目录结构的设置)
    }

    packagingOptions {
       //打包时的相关配置  
    }

    lintOptions {
        //编译的 lint 开关，程序在buid的时候，会执行lint检查，有任何的错误或者警告提示，都会终止构建，我们可以将其关掉。
        //abortOnError false  
    }

    productFlavors {
        //产品发布的一些东西，比如渠道、包名等
        flavor1 {
        }

        flavor2 {
        }
    }

    signingConfigs {
        //签名的配置
        release {
        }
    }

    testOptions{
        //测试配置，TestOptions类型
    } 
    aaptOptions{
      //aapt配置，AaptOptions类型 
    } 
     lintOptions{
       //lint配置，LintOptions类型
    } 
    dexOptions{
       //dex配置，DexOptions类型
    } 
    compileOptions{
     // 编译配置，CompileOptions类型
    } 
    packagingOptions{
       // PackagingOptions类型
    } 
    jacoco{ 
       //JacocoExtension类型。 用于设定 jacoco版本
    } 
    splits{
       //Splits类型。
    } 
}

统一版本管理

顶层build.gradle文件：

// Top-level build file where you can add configuration options common to all sub-projects/modules.
ext {
    configuration = [
            package          : "com.chm.myapplication",
            buildToolsVersion: "24.0.2",
            compileVersion   : 24,
            minSdk           : 14,
            targetSdk        : 23,
            version_code     : 1,
            version_name     : "0.0.1",
    ]

    libraries = [
            supportVersion    : "24.2.1",
            retrofit2         : "2.1.0",
            rxandroid         : "2.0.1",
            dagger            : "2.1",
            annotation        : "10.0-b28",
            rxjava2_adapter   : "1.0.0",
            javax_annotation  : "10.0-b28",
            butterknife       : "7.0.1",
            glide             : "3.7.0",
            recycler_animators: "2.1.0",
            circleimageview   : "2.0.0",
            eventBus          : "3.0.0",
            gson              : "2.6.2"
    ]
}

buildscript {
    ext.kotlin_version = '1.1.1'
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.2.3'
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath 'com.github.dcendents:android-maven-gradle-plugin:1.5'
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

allprojects {
    repositories {
        jcenter()
        maven { url "https://jitpack.io" }
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

module下build.gralde文件：

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: "kotlin-android-extensions"
apply plugin: 'com.neenbedankt.android-apt'

def cfg = rootProject.ext.configuration // 配置
def libs = rootProject.ext.libraries // 库

android {
    compileSdkVersion cfg.compileVersion
    buildToolsVersion cfg.buildToolsVersion

    defaultConfig {
        applicationId cfg.package
        minSdkVersion cfg.minSdk
        targetSdkVersion cfg.targetSdk
        versionCode 1
        versionName "1.0"

        //buildConfigField管理私有参数, 配置在gradle.properties里面.
        buildConfigField("String", "MARVEL_PUBLIC_KEY", "\"${marvel_public_key}\"")
        println("${marvel_public_key}")

    }
    buildTypes {
        release {
            debuggable true
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
//    compileOptions {
//        sourceCompatibility JavaVersion.VERSION_1_8
//        targetCompatibility JavaVersion.VERSION_1_8
//    }
}

dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    testCompile 'junit:junit:4.12'
    compile "com.android.support:appcompat-v7:${libs.supportVersion}"
    compile "com.android.support:design:${libs.supportVersion}"
    compile "com.android.support:cardview-v7:${libs.supportVersion}"
    compile "org.greenrobot:eventbus:${libs.eventBus}"

    compile "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version"
    compile project(':colorpicker')

    compile "jp.wasabeef:recyclerview-animators:${libs.recycler_animators}" // Recycler动画
    compile "de.hdodenhof:circleimageview:${libs.circleimageview}" // 头像视图

    compile "com.squareup.retrofit2:retrofit:${libs.retrofit2}"
    compile "com.squareup.retrofit2:converter-gson:${libs.retrofit2}"
    compile "com.jakewharton.retrofit:retrofit2-rxjava2-adapter:${libs.rxjava2_adapter}"
    compile "io.reactivex.rxjava2:rxandroid:${libs.rxandroid}"
    // Because RxAndroid releases are few and far between, it is recommended you also
    // explicitly depend on RxJava's latest version for bug fixes and new features.
    compile "io.reactivex.rxjava2:rxjava:${libs.rxandroid}"
    compile "com.github.bumptech.glide:glide:${libs.glide}"
    provided "com.google.dagger:dagger-compiler:${libs.dagger}"
    compile "com.google.dagger:dagger:${libs.dagger}"
    provided "org.glassfish:javax.annotation:${libs.annotation}"
    compile "com.jakewharton:butterknife:${libs.butterknife}"
    compile "com.google.code.gson:gson:${libs.gson}"
}

利用Gradle全局变量，对于多Module有很大的好处，统一版本，管理起来方便。

多渠道打包

比如我们的app需要打包到多个应用市场，如xiaomi，360等。

• 第一步 在AndroidManifest.xml里配置PlaceHolder

<meta-data
            android:name="MY_CHANNEL"
            android:value="${MY_CHANNEL}" />

• 第二步 在build.gradle设置productFlavors

productFlavors{
        xiaomi {
            //用gradle修改AndroidManifest.xml中的meta-data元素值
            manifestPlaceholders = [MY_CHANNEL: "xiaomi"]
            applicationId "com.chm.xiaomi"
        }

        _360 {
            manifestPlaceholders = [MY_CHANNEL: "_360"]
            applicationId "com.chm._360"
        }
        baidu {
            manifestPlaceholders = [MY_CHANNEL: "baidu"]
            applicationId "com.chm.baidu"
        }

        huawei{
            manifestPlaceholders = [MY_CHANNEL: "huawei"]
            applicationId "com.chm.huawei"
        }
    }

• 最后，最好在defaultConfig中定义一个默认的渠道

defaultConfig{
    ...
    manifestPlaceholders = [ MY_CHANNEL:"xiaomi" ]
}

生成如下一下包：

挑选其中的一个包（baidu）反编译看一下AndroidManifest.xml文件，MY_CHANNEL被正确赋值，并且包名也被正确赋值（com.chm.baidu）。

如果现在需求变更，需要一个free版本，一个price版本，如何打包呢？

android{
    ...

    flavorDimensions 'price','store'
    productFlavors{
        xiaomi{
            flavorDimension "store"
        }

        360{
            flavorDimension "store"
        }

        free{
            flavorDimension "price"
        }

        price{
            flavorDimension "price"
        }
    }
}

flavorDimensions—-是一个数组，store和price代表的2个维度，每个flavor分配到指定的维度中。

修改APP名称

• 渠道包重命名

在build.gradle文件中加入如下代码：

android.applicationVariants.all { variant ->
        variant.outputs.each { output ->
            def outputFile = output.outputFile
            if (outputFile != null && outputFile.name.endsWith('.apk')) {
                File outputDirectory = new File(outputFile.parent);
                def fileName
                if (variant.buildType.name == "release") {
                    fileName = "chm_${variant.productFlavors[0].name}.apk"
                } else {
                    fileName = "chm_${variant.productFlavors[0].name}_beta.apk"
                }
                output.outputFile = new File(outputDirectory, fileName)
            }
        }
    }

生成如下的一些包：

• 根据渠道修改APP名称

buildTypes {
        debug {
            // 显示Log
            buildConfigField "boolean", "LOG_DEBUG", "true"
            //重命名
            resValue("string","app_name","DEBUG")
            versionNameSuffix "-debug"
            minifyEnabled false
            zipAlignEnabled false
            shrinkResources false
            signingConfig signingConfigs.debug
        }
        release {
            // 不显示Log
            buildConfigField "boolean", "LOG_DEBUG", "false"
            //重命名
            resValue("string","app_name","RELEASE")
            //混淆
            minifyEnabled true
            //加载默认混淆配置文件
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            //签名
            signingConfig signingConfigs.release
        }
    }

签名的配置

上面打出的包都是没有指定签名的，我们要配置一个签名，首先需要生成签名文件。我生成的签名文件是1.jks

signingConfigs{
        signR1{
            storeFile file("build/1.jks");
            storePassword "123456"
            keyAlias "xxx"
            keyPassword "123456"
        }
        signR2{
            storeFile file("build/2.jks");
            storePassword "123456"
            keyAlias "xxx"
            keyPassword "123456"
        }
    }

签名在signingConfigs中配置，signR1，signR2是签名的名字，在buildTypes中使用。注意：signingConfigs声明应在buildTypes前面，不然buildTypes中找不到signR1、signR2等属性。

buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
        r1{
            signingConfig signingConfigs.signR1
            //在包名后面加上了一个后缀r1
            applicationIdSuffix ".r1"
        }
        r2{
            signingConfig signingConfigs.signR2
            applicationIdSuffix ".r2"
        }

    }

动态参数配置

signingConfigs{
        release{
            storeFile file("build/mykey.jks")
            storePassword   "123456"
            keyAlias "123456"
            keyPassword   "123456"
        }
    }

上面的这段配置，有个缺点，就是值直接写死了，我们可以动态配置参数。在哪里配置呢，一开始就说了，在gradle.properties中配置参数。如下：

systemPro.keyAliasPassword=123456
systemPro.keyAlias=123456
systemPro.keyStorePassword=123456
systemPro.keyStore=mykey.jks

配置好了，就可以在相关处使用了。

signingConfigs{
        release{
            storeFile       System.properties["keyStore"]
            storePassword   System.properties["keyStorePassword"]
            keyAlias        System.properties["keyAlias"]
            keyPassword     System.properties["keyAliasPassword"]
        }
    }

gradle.properties文件配置

gradle.properties常见配置比如有：

• 开启并行编译：加快gradle 的编译

org.gradle.parallel=true

• 开启编译守护进程：

该进程在第一次启动后回一直存在，当你进行二次编译的时候，可以重用该进程。

org.gradle.daemon=true

• 加大可用编译内存：

org.gradle.jvmargs=-Xms256m -Xmx1024m

最后，总结一下：

• build.gradle：控制每个Module的构建过程

• gradle.properties：配置gradle脚本中的参数

• local.properties：gradle的SDK和NDK环境变量配置

• setting.gradle：配置gradle的多项目管理