android studio gradle 插件开发之初步整理gradle

gradle 指令补充

1. gradle  taskName --> 执行任务（注：taskName可以不用全名，用字母的简称 或者 骆驼峰命名首字母拼写而成)
2. gradle  task1Name task2Name -->多任务执行
3. gradle  task1Name -x task2Name -->排除task2任务执行，即使task2是task1 的依赖任务
4. gradle --continue  --> 失败之后重新构建，发现后面更多的问题
5. gradle -q -b   fileAbsolutePath/fileName  taskName --> 构建其它文件的任务
6. gradle -q -p fileAubolutePath  taskName --> 构建其它目录下的任务
7. Gradle --recompile--scripts  --> 清除缓存脚本文件，重新缓存

注：
a). -b 参数用以指定脚本具体所在位置, 格式为 构建文件具体路径/构建文件名.
b). -p 参数用以指定脚本目录即可.

gradle获取构建信息

1.   获取项目构建信息 -->gradle -q projects
2.   为项目添加描述 --> build.gradle 文件添加 description = 'The des for the project'
3.   获取任务构建信息 -->gradle -q tasks
4.   获取更多的任务构建信息，包含任务间的依赖关系 -->gradle -q tasks --all
5.   获取任务具体信息 --> gradle -q help --task taskName
6.   获取依赖关系 --> gradle -q dependecies  taskName:dependecies
7.   过滤依赖信息 --> gradle -q taskName:dependecies --configuration taskDependeciesName
8.   查看固定依赖 --> gradle -q taskName:dependencyInsight --dependency groovy --configuration compile
9.   查看项目属性列表 --> gradle -q taskName:properties
10. 获取构建日志 --> --profile 参数可以收集一些构建期间的信息并保存到 build/reports/profile 

project 构建对象属性

gradle task 整理

1. task 的排序 --> must run after(mustRunAfter)  和 should run after(shouldRunAfter)
2. task 的依赖 --> 依赖另一个项目的task ；依赖本项目的task ；依赖闭包
    a).project('projectA') {
          task taskX(dependsOn: ':projectB:taskY') << {
              println 'taskX'
          }
      }

        project('projectB') {
            task taskY << {
                println 'taskY'
            }
        }

    b).task taskX << {
            println 'taskX'
        }

        task taskY << {
            println 'taskY'
        }  

        taskX.dependsOn taskY

    c).task taskX << {
            println 'taskX'
        }

        taskX.dependsOn {
            tasks.findAll { task -> task.name.startsWith('lib') }
        }

        task lib1 << {
            println 'lib1'
        }

        task lib2 << {
            println 'lib2'
        }

        task notALib << {
            println 'notALib'
        }
    
3. 复写task
    
     task copy(type: Copy)

     task copy(overwrite: true) << {
        println('I am the new one.')
     }

4. 跳过 tasks

    a). 使用判断条件跳过一个任务
        task hello << {
            println 'hello world'
        }

        hello.onlyIf { !project.hasProperty('skipHello') }

    b). 使用 StopExecutionException
         task compile << {
            println 'We are doing the compile.'
          }

          compile.doFirst {
              // Here you would put arbitrary conditions in real life.
              // But this is used in an integration test so we want defined behavior.
              if (true) { throw new StopExecutionException() }
            }
           task myTask(dependsOn: 'compile') << {
               println 'I am not affected'
            }

    c). 激活和注销 tasks
         task disableMe << {
             println 'This should not be printed if the task is disabled.'
         }
         disableMe.enabled = false //默认为true

  5. 跳过 up-to-date task-->声明task的输入和输出
      task transform {
            ext.srcFile = file('mountains.xml')
            ext.destDir = new File(buildDir, 'generated')
            inputs.file srcFile
            outputs.dir destDir
            doLast {
                println "Transforming source file."
                destDir.mkdirs()
                def mountains = new XmlParser().parse(srcFile)
                mountains.mountain.each { mountain ->
                def name = mountain.name[0].text()
                def height = mountain.height[0].text()
                def destFile = new File(destDir, "${name}.txt")
                destFile.text = "$name -> ${height}\n"
                }
            }
      }

  6. task规则--> addRule("Pattern: ping<ID>")
  7. task 终止器-->这里的终止任务并不是指终止一个任务, 而是指一个无论运行结果如何最后都会被执行的任务.
      taskY finalizedBy taskX 

gradle 文件操作

1. 定位文件的三种方式-->
    a).使用一个相对路径:
         File configFile = file('src/config.xml')
    b).使用一个绝对路径
         configFile = file(configFile.absolutePath)
    c).使用一个项目路径的文件对象 
         configFile = file(new File('src/config.xml'))

 2. 文件集合--> FileCollection
     FileCollection collection = files('src/file1.txt',
                              new File('src/file2.txt'),
                              ['src/file3.txt', 'src/file4.txt'])

 3. 文件树-->FileTree 继承自 FileCollection
     //以一个基准目录创建一个文件树
     FileTree tree = fileTree(dir: 'src/main')

     // 添加包含和排除规则
     tree.include '**/*.java'
     tree.exclude '**/Abstract*'

     // 使用路径创建一个树
     tree = fileTree('src').include('**/*.java')

     // 使用闭合创建一个数
     tree = fileTree('src') {
         include '**/*.java'
     }

     // 使用map创建一个树
     tree = fileTree(dir: 'src', include: '**/*.java')
     tree = fileTree(dir: 'src', includes: ['**/*.java', '**/*.xml'])
     tree = fileTree(dir: 'src', include: '**/*.java', exclude: '**/*test*/**')

     **使用归档文件的内容作为文件树**
     // 使用路径创建一个 ZIP 文件
     FileTree zip = zipTree('someFile.zip')

     // 使用路径创建一个 TAR 文件
     FileTree tar = tarTree('someFile.tar')

     //tar tree 能够根据文件扩展名得到压缩方式,如果你想明确的指定压缩方式,你可以使用下面方法
     FileTree someTar = tarTree(resources.gzip('someTar.ext'))

4. 指定一组输入文件
    //使用一个 File 对象设置源目录
    compile {
      source = file('src/main/java')
    }

    //使用一个字符路径设置源目录
    compile {
      source = 'src/main/java'
    }

    // 使用一个集合设置多个源目录
    compile {
      source = ['src/main/java', '../shared/java']
    }

  // 使用 FileCollection 或者 FileTree 设置源目录
  compile {
      source = fileTree(dir: 'src/main/java').matching { include 'org/gradle/api/**' }
  }

  // 使用一个闭合设置源目录
  compile {
      source = {
          // Use the contents of each zip file in the src dir
        file('src').listFiles().findAll {it.name.endsWith('.zip')}.collect { zipTree(it) }
      }
  }

5. 复制文件-->
    task copyTask(type: Copy) {
          from 'src/main/webapp'
          into 'build/explodedWar'
    }

6. 使用同步任务-->
    task libs(type: Sync) {
        from configurations.runtime
        into "$buildDir/libs"
    }

使用其他的脚本配置项目

apply from: 'other.gradle'