[android基础] Gradle，gradlew的使用

因为在gradle语法中有时会出现Groovy 的一些定义，所以下面先简单学习下groovy语法

Gradle学习

1. 最基础的知识参考文献1
   0.1 新建一个build.gradle文件，然后在其中编写参考文献1中提到的各种task，然后调用下面的方法来运行

gradle task名

0.2 基础语法知识。
0.2.1 Action的使用
用<<简化为task分配doLast action

task hello << {
    println "hello"
}

或者定义中间task在给自己的task赋值，在fiveT这个task中将printTaskName赋值给fiveT

def printTaskName = { task->
        println "Running ${task.name}"
}
task fiveT {
        doFirst printTaskName
}

自定义Action

task first{
        doLast{
                new Action(){
                        void execute(task){
                                println 'Running ${task.name}'
                        }
                }
        }
}

在build.gradle文件中加入defaultTasks后，输入gradle不需要加任务名则运行默认的

defaultTasks 'hello','upper'

0.2 task也有属性和方法。
0.2.1 默认的方法
0.2.1.1 dependsOn(task) 设置依赖task，有几种方法可以书写这个方法，多重依赖即多写几个

task loadTestData {    dependsOn createSchema }　//直接书写
task loadTestData {    dependsOn << createSchema }　//简易赋值
task loadTestData {    dependsOn 'createSchema' }　//单引号使用
task loadTestData 　　//定义完成后再单独赋值
loadTestData.dependsOn createSchema
task loadTestData(dependsOn: createSchema) //简写形式

0.2.1.2 doFirst方法用来首先运行。同样也有几种写法，当有多个doFirst方法时按照最后写最先执行。

task setupDatabaseTests << {    println 'load test data'}
setupDatabaseTests.doFirst {    println 'create database schema'}
setupDatabaseTests.doFirst {    println 'drop database schema'}

0.2.1.3 doLast(closure)方法用来表示最后运行。同样也有几种写法，跟doFirst类似。
0.2.1.4 onlyIf(closure) 只有在onlyIf返回true时才运行task－－－这个是比较重要的方法，先判断，再决定是否执行该task. 写法和doFirst类似，具体使用在后面有案例。

0.2.2 包含的属性。
0.2.2.1 didWork 表明该任务是否已经work过。案例见后面。
0.2.2.2 enabled 在task未启动之前可以设置。描述该task是否可以使用。
0.2.2.3 path，指明相对当前构建路径的路径。
0.2.2.4 description，对当前task进行描述

defaultTasks 'longrunning'
task longrunning (){
    onlyIf{task->
        def now = Calendar.instance
        def weekDay = now[Calendar.DAY_OF_WEEK]
        def weekDayInWeekend = weekDay in [Calendar.MONDAY,Calendar.SATURDAY, Calendar.SUNDAY]
        println "executed here"
        return weekDayInWeekend
    }
    dependsOn 'handleFile' // dependsOn
    doLast{
        if(handleFile.didWork){ // didwork property
            println "Do long running stuff"
        }
        if(handleFile.enabled){ //enabled property
            println "the task is enable"
        }
    }
}
def file = new File('test.groovy') //groovy defination
task handleFile{
    doFirst{ //doFirst function
        println "work with file ${file.name}"
    }
}
handleFile.onlyIf(new Spec(){
    boolean  isSatisfiedBy(task){
        println "task path is ${task.path}"
        file.exists()
    }
})
handleFile.enabled = true

0.3 可以书写groovy语言。
0.3.1 在这个代码中定义变量使用def

def taskGroup = 'base'
task first2(description: 'Base task', group: taskGroup) << {
    println "I am first"
}
task second2(dependsOn:first2,description:'Secondary task', group:taskGroup)<<{
        println "i am second"
}

0.4 task 类型有copy, jar, JavaExec等
0.5 可以自定义task类型。

1.0 Gradle高级知识。
1.0.1 Gradle的守护进程，gradle –daemon参数只用启动一次虚拟机后，后面可以多次使用。gradle -stop可以停止。
1.0.2 Gradle生命周期。

initialization 在多项目构建中决定哪个是主项目
configuration 将所有的task对象装配到一个叫做DAG（for directed acyclic graph）的对象模型中
execution　执行task
1.0.3 可以通过从其他gradle文件中获取属性。

1.1 Gradle 包装器，这个是在没有gradle的情况下调用。
1.2 依赖管理，可以将一组依赖定义在一个配置里。每一个配置都有一个名字，它可以继承自其它配置。

configurations {
    commonsLib { // 单独列出来
        description = 'Common libraries'
    }
    mainLib {
        description = 'Main libraries'
        extendsFrom commonsLib　//继承commonsLib属性。
    }
}

1.3 仓库管理，对远程和本地的仓库进行管理

repositories {
 //一共有三种仓库：maven仓库，ivy仓库以及flat本地仓库
    mavenLocal()
    mavenCentral()
    maven {
        // Name is optional. If not set url property is used
        name = 'Main Maven repository'
        url = 'http://intranet/repo'
    }
    mavenRepo(name: 'Snapshot repository', url: 'http://intranet/snapshots')
    //XML描述文件和jar包不在同一个地方的时候的定义方式:
    maven {
        url: 'http://intranet/mvn'
        artifactUrls 'http://intranet/jars'
        artifactUrls 'http://intranet/snapshot-jars'
    }
    maven(name: 'Secured repository') {    //有权限控制的仓库
        credentials {
            username = 'username'
            password = 'password'
        }
        url = 'http://intranet/repo'
    }
    repositories {//本地仓库
        flatDir(dir: '../lib', name: 'libs directory') //flatDir表明是本地仓库
    }
}

1.4 Gradle常用命令
gradle tasks –all 查看所有的可执行的任务
gradle projects 列出命名
gradle -m 查看可执行的任务
gradle task1 task2 [….] 多任务调用
gradle -x task1 task2 排除任务
gradle -b xxx.gradle 指定gradle文件来编译

1.5 更多关于gradle的参考见gradle在Android studio的使用

Groovy参考

1. 为了运行起groovy还是先用这篇文章groovy配置
   0.0.1 为了安装使用了如下语法

sudo apt-get update
sudo apt-get install groovy
~$ groovy -version
Groovy Version: 1.8.6 JVM: 1.7.0_72 Vendor: Oracle Corporation OS: Linux

0.0.2 可以在*.groovy文件里面书写，或者运行groovyConsole直接运行所需要的groovy代码。
0.0.3 也可以在studio的terminal下输入which groovy来看是否有groovy路径，然后添加groovy的路径，并在
studio中编辑groovy文件，然后运行。
1. 然后在上面的groovy配置中详细介绍了groovy的使用。

参考文献

工程实践案例

1. 使用下面的命令来查看版本。

 ./gradlew -v

２. 使用下面的命令来下载gradle的依赖。

 ./gradlew clean
 //clean成功后出现下面的信息
 :app:clean UP-TO-DATE
:extras:ShimmerAndroid:clean UP-TO-DATE

BUILD SUCCESSFUL

1. gradlew的使用，通过Gradle Wrapper允许你在没有安装Gradle的机器上进行Gradle构建，可以使得项目组成员不必预先安装好gradle，便于统一项目所使用的gradle版本。
   3.1 一般新建好一个工程后都会出现一个gradlew文件，如果没有，可以去其他的工程copy这个gradlew文件以及gradle文件夹到当前的目录。
   3.2 然后到拷贝过来的gradle文件夹下面可以找到如下文件 gradle-wrapper.properties，这个时候可以把团队共享的gradle.zip放到该目录下，然后修改这个distributionUrl=gradle.zip即可以使用本地的gradle. 参考wrapper使用本地的gradle

distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-all.zip

3.3 在配置好gradlew以后，就需要设置各种配置文件了。
3.3.1 首先是local.properties文件。内容如下，需要设置sdk的路径和那个其他库的路径。

sdk.dir=/work/android-sdk-linux

3.3.2 然后是settings.gradle。内容如下：需要输入要包括的参考工程文件，可以用多行来分隔。

include ':app'

3.3.3 在设置common.gradle文件，这个主要是用来设置sdk版本等信息，然后在其他文件中可以用”${project.var.sdkVersion}“来调用。

var {
    sdkVersion = "android-23"
    toolVersion = "23.0.1"
}

3.3.4 然后书写那个builde.gradle文件，这个也是运行./gradlew build运行的文件

buildscript {
    repositories {
        maven {
            url 'xxx'
        }
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.1.0'
    }
}

allprojects {
//引入本地的common.gradle
    apply from: "${project.rootDir}/common.gradle"
    repositories {
        jcenter()
    }
}

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

android {
    compileSdkVersion "${project.var.sdkVersion}"
    buildToolsVersion "${project.var.toolVersion}"
    defaultConfig {
        applicationId "com.example.xxx.testprojfirst"
        minSdkVersion 23
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:23.+'
}

3.4 然后就可以运行gradlew了。

上面的代码难点在于怎样去使用本地的gradle。

3.5 还有个小知识点，就是上面gradle版本和plugin的版本区别，参考文献
gradle wrapper task利用gradle-wrapper.properties来下载指定的gradle
build.gradle中classpath ‘com.android.tools.build:gradle:1.5.0’表示要使用这个android plugin的库
这个android plugin是对gradle库的扩展