Android自定义Gradle插件的详细过程

dependencies {
        classpath "com.android.tools.build:gradle:4.1.3"
     }

  def a=1;

     def b="hello world";

     def int c=1;

     def test(){ //定义方法
        
         println("123");

         return 0;

     }

def a=1;

    a="Hello World"   

    def test(a){

       println(a);

       1; //方法的返回值为1，返回值可以省略return 

    }

    test 1  //调用方法，可以省略括号

 def int a=1;

    def double b=1.1;

    println(a.class);

    println(b.class);

def a=1;

    String b="Hello ${a}" //字符串结果为 Hello 1

//定义闭包

     def closure = { println("Hello World") }

     def closure1= { a,b -> a b  }

     //调用闭包

     closure();

     closure.call(); //函数式调用或者使用call方式调用,这两种方式调用闭包都是可以的

     def a=closure1(1,2);

     def a=closure1.call(1,2);

//先写一个Java中的语法

    List list=new ArrayList<>();

    list.add(1);

    list.add(2);
    
    //Groovy除了像Java中一样写法，还可以这样来定义List

    def lists=[1,2,3];

    lists.add(4);

    lists.add(5);

    print(lists.class); //我们打印这个lists的class,它就是java.util.ArrayList

 def result=lists.find{
      
      return it%2==0;

    } //这里find查找方法传入的参数是一个闭包，返回的是第一个能整除2的元素
    
 def results=lists.findAll {

      return it%2==0;

    } //查找List中所有的能整除2的元素 

 def resList=lists.sort {

        x1,x2->  return x1==x2?0:x1>x2?1:-1

    } //List中sort方法，传入一个闭包参数，用于对List排序
    
lists.each{
       
       print(it ",");


    } //each方法遍历List

 //先写一个Java中Map的写法

     Map map=new HashMap<>();
     
     map.put("a",1);
     
     map.put("b",2);

     //Groovy除了像Java中一样写法，还可以这样来定义Map

     def map=["a":1,"b":2];

     prinlt(map.get("a")); //获取某个键对应的值

     prinltn(map.a);//map.key 这种方式也可以获取map中某个键的值

     println(map.getClass()); //这样定义map,Map的默认数据类型是java.util.LinkedHashMap

                              //这里我们是使用map.getClass()来获取map的类，而不能map.class来获取

                              //是因为map有map.key这种用法，用来获取map中键为key的值，所以如果写map.class

                              //会被认为是获取map中键为class的值，所以这里只能用map.getClass()来获取map的class类型
    

    def v=map.find {

     if (it.getValue()==2){
          return it;
      }

   } //map中的find方法，传入一个闭包参数,可以查找map中第一个满足条件的一个Entry(键值对实体)

   println(v.key);

   map.each {

     println(it.getKey() ":" it.getValue());

   } //可以使用map的each方法，参数是一个闭包，来遍历map

   map还有一些其他方法，所以这里可不一一列举了

   def resMap=map.sort {

      e1,e2->

        return e1.key==e2.key?0:e1.key>e2.key?1:-1

  } //map的sort方法传入一个闭包参数,对map进行排序，返回的是一个排序后的新的map,注意原map并没有变化

def rang=1..10 //这里相当于定义了一个集合，集合中的元素值从1到10

   println(range.class); //groovy.lang.IntRange

   println(rang[0]) //range[0]为1 

   println(range.getFrom());// 1 range.getFrom() 获取range的下限值

   println(range.getTo()); //10 range.getTo()获取range的上限值

   //如果定义的def range=10..1; range.getFrom()和range.getTo()的值还是1,10

   //因为10..1 下限值还是1，上限值还是10  

   def charRange='f'..'a';

   charRange.each {

     println(it)

   } //打印出 f,e,d,c,b,a

   def score=60;

   switch (score){
    case 0..59:
        println("及格");
        break
    case 60..85:
        println("及格");
        break
    case 86..100:
        println("优秀");
        break
}

trait MyTrait{

      abstract void test();

      void play(){

         prinlt("play game");

      }

    }  

    class TestClass implement MyTrait{

       @Override 
       void test(){

       }

    }

plugins {  id 'groovy'  }   或者 apply plugin:'groovy'

dependencies {

    implementation 'com.android.tools.build:gradle:4.1.3'
    implementation gradleApi()
 
  }

package com.example.plugin

import com.android.builder.model.SigningConfig
import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction

class GiaGuTask extends DefaultTask{


    GiaGuBean mGiaGuBean;

    SigningConfig signingConfig;

    File apkFile;

    GiaGuTask() {
        group="jiagu"
    }

    @TaskAction
    void run() {

        project.exec {

            it.commandLine(
                    "java",
                    "-jar",
                    mGiaGuBean.getJiaGuTools(),
                    "-login",
                    mGiaGuBean.getUserName(),
                    mGiaGuBean.getPassword(),

            );

        }

        if (signingConfig) {

            project.exec {

                it.commandLine(
                        "java",
                        "-jar",
                        mGiaGuBean.getJiaGuTools(),
                        "-importsign",
                        signingConfig.storeFile.absolutePath,
                        signingConfig.storePassword,
                        signingConfig.keyAlias,
                        signingConfig.keyPassword
                )

            }
        }

        project.exec {


            it.commandLine("java",

                    "-jar",

                    mGiaGuBean.getJiaGuTools(),

                    "-jiagu",

                    apkFile.absolutePath,

                    apkFile.parent,

                    "-autosign"

            )

        }


    }

}

package com.example.plugin

class GiaGuBean {

    String userName;
    String password;
    String jiaGuTools

    String getUserName() {
        return userName
    }

    void setUserName(String userName) {
        this.userName = userName
    }

    String getPassword() {
        return password
    }

    void setPassword(String password) {
        this.password = password
    }

    String getJiaGuTools() {
        return jiaGuTools
    }

    void setJiaGuTools(String jiaGuTools) {
        this.jiaGuTools = jiaGuTools
    }

}

package com.example.plugin

import com.android.build.gradle.AppExtension
import com.android.build.gradle.api.ApplicationVariant
import com.android.build.gradle.api.BaseVariantOutput
import com.android.builder.model.SigningConfig
import org.gradle.api.Plugin
import org.gradle.api.Project

class GiaGuPlugin implements Plugin<Project>{

    @Override
    void apply(Project project) {
        GiaGuBean giaGuBean = project.extensions.create("jiagu", GiaGuBean.class);

        project.afterEvaluate {

            AppExtension appExtension = project.extensions.android;

            appExtension.applicationVariants.all {
                    //debug/release

                ApplicationVariant variant ->

                    //对应变体(debug/release)的签名配置
                    SigningConfig signingConfig = variant.signingConfig;

                    variant.outputs.all {

                        BaseVariantOutput baseVariantOutput ->

                            //输出的APK文件
                            File apkFile = baseVariantOutput.outputFile;

                            //创建加固任务
                            GiaGuTask giaGuTask = project.tasks.create("jiagu${variant.baseName.capitalize()}", GiaGuTask.class);
                            giaGuTask.mGiaGuBean = giaGuBean;
                            giaGuTask.signingConfig = signingConfig;
                            giaGuTask.apkFile =apkFile;

                    }
            }


        }

  implementation-class=com.example.plugin.GiaGuPlugin

apply plugin:'maven-publish'

publishing{

            publications{

            Jiagu(MavenPublication){ //Jiagu 这个名字随意取

            from components.java  //这个表示要把源码生成的jar包上传

            groupId 'com.example' //配置插件的groupId(分组ID)

            artifactId "plugin"   //配置ID

            version "1.0" //配置版本号
        }

     }
     
   } 

repositories {

           ...
           
           mavenLocal()

         }                         

      dependencies {
        ...
        classpath "com.example:plugin:1.0" 

        //就是之前上传的是偶配置groupId:artifactId:version

      } 

apply plugins:'com.example.plugin' //就是开发插件的时候resources/META-INF/gradle-plugins/com.example.plugin.properties 这个文件的名字

plugins {

      ...

      id 'com.example.plugin' 

      //就是开发插件的时候resources/META-INF/gradle-plugins/com.example.plugin.properties 这个文件的名字 

}