APT专项学习（一）

implementation 'com.google.auto.service:auto-service:1.0-rc6'
    kapt 'com.google.auto.service:auto-service:1.0-rc6'
    implementation project (':GrowthAnnotation')
    implementation 'com.squareup:kotlinpoet:0.7.0'

package com.xpj.growthannotation

// 定义的注解，编译时作用在类上
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.SOURCE)
annotation class GrowthClass

// 作用域为类中的变量
@Target(AnnotationTarget.FIELD)
@Retention(AnnotationRetention.SOURCE)
annotation class GrowthFindView(val value: Int = -1)

// 生成类后缀
const val GROWTH_BIND_VIEW = "_growthBindView"
// 方法
const val GROWTH_BIND_VIEW_METHOD = "growthBindView"

package com.xpj.growthapi

import com.xpj.growthannotation.GROWTH_BIND_VIEW
import com.xpj.growthannotation.GROWTH_BIND_VIEW_METHOD

class GrowthKapt {
    companion object {
        fun bindView(target: Any) {
            val classs = target.javaClass
            val claName = classs.name + GROWTH_BIND_VIEW
            // 反射生成对应的clazz
            val clazz = Class.forName(claName)

            // 这里找到自己自定义的方法，使用反射调用,这里要和定义的方法对应上，而不是和注解名字对应
            val bindMethod = clazz.getMethod(GROWTH_BIND_VIEW_METHOD, target::class.java)
            // 生成对应的对象实例
            val ob = clazz.newInstance()
            // 反射invoke身上的 GROWTH_BIND_VIEW_METHOD 方法
            bindMethod.invoke(ob, target)
        }
    }
}

package com.xpj.mygrowthpath

import kotlin.jvm.JvmStatic

// kotlin搭配kotlinpoet yyds，这里生成的类就是生成这种很简洁但不简单的方法，生成的是静态方法，这里用了cb 伴生对象，你把对应的Activity传递进去他帮你调用findViewById并且复制
class SecondActivity_growthBindView {
    companion object {
        @JvmStatic
        fun growthBindView(activity: SecondActivity) {
            activity.text1 = activity.findViewById(2131231051)
            activity.img = activity.findViewById(2131231048)
        }
    }
}

package com.xpj.growthanncom

import com.google.auto.service.AutoService
import com.squareup.kotlinpoet.FileSpec
import com.squareup.kotlinpoet.FunSpec
import com.squareup.kotlinpoet.TypeSpec
import com.squareup.kotlinpoet.asClassName
import com.xpj.growthannotation.GROWTH_BIND_VIEW
import com.xpj.growthannotation.GROWTH_BIND_VIEW_METHOD
import com.xpj.growthannotation.GrowthClass
import com.xpj.growthannotation.GrowthFindView
import java.io.File
import javax.annotation.processing.*
import javax.lang.model.SourceVersion
import javax.lang.model.element.TypeElement
import javax.lang.model.util.Elements

@AutoService(Processor::class)
@SupportedSourceVersion(SourceVersion.RELEASE_8)
class GrowthAnnCompiler : AbstractProcessor() {
    private lateinit var mLogger: GrowthLogger
    private var elementUtils: Elements? = null

    // 这里返回对应的支持类型，是一个set
    override fun getSupportedAnnotationTypes(): Set<String> {
        return setOf(GrowthClass::class.java.canonicalName)
    }

    override fun init(processingEnv: ProcessingEnvironment) {
        super.init(processingEnv)
        mLogger = GrowthLogger(processingEnv.messager)
        // 首先是初始化的时候存下来这个utils
        elementUtils = processingEnv.elementUtils

        mLogger.info(" ${this::class.java.simpleName} init")
    }


    override fun process(
        annotations: MutableSet<out TypeElement>,
        roundEnv: RoundEnvironment
    ): Boolean {
        mLogger.info("processor start")

        // 先找到目标声明的类
        val elements = roundEnv.getElementsAnnotatedWith(GrowthClass::class.java)

        // 遍历对应的type
        elements.forEach {
            val typeElement = it as TypeElement
            // 拿到所有的members
            val members = elementUtils!!.getAllMembers(typeElement)

            // 这里是生成的方法，哪里名字错了，因此找不到 FunSpec 属于kotlinpoet，使用 GROWTH_BIND_VIEW_METHOD 这个名字去构造方法，参数是activity 加上JvmStatic的注解
            val bindFunBuilder = FunSpec.builder(GROWTH_BIND_VIEW_METHOD).addParameter(
                "activity",
                typeElement.asClassName()
            ).addAnnotation(JvmStatic::class.java)


            // 对成员进行遍历
            members.forEach { ele ->
                val find: GrowthFindView? = ele.getAnnotation(GrowthFindView::class.java)
                if (find != null) {
                    mLogger.info("find annotation " + ele.simpleName)
                    // 如果找到了，就对 bindFunBuilder 添加执行语句
                    bindFunBuilder.addStatement(
                        "activity.${ele.simpleName} " +
                                "= activity.findViewById(${find.value})"
                    )
                }
            }

            // 这里方法的语句准备好了
            val bindFun = bindFunBuilder.build()


            // 生成对应的类 it.simpleName.toString() + "_bindView" 这个是文件名，这里忘了改了。
            val file = FileSpec.builder(
                getPackageName(typeElement),
                it.simpleName.toString() + "_bindView"
            ).addType(
                // 这里是类名，然后addType是add的一个包含method的type，最后build并且写入文件
                TypeSpec.classBuilder(it.simpleName.toString() + GROWTH_BIND_VIEW).addType(
                    TypeSpec.companionObjectBuilder()
                        .addFunction(bindFun).build()
                ).build()
            ).build()
            file.writeFile()
        }

        mLogger.info("end")

        return true
    }

    private fun getPackageName(type: TypeElement): String {
        return elementUtils!!.getPackageOf(type).qualifiedName.toString()
    }


    // 这里设定生成类的目标地址
    private fun FileSpec.writeFile() {
        val kaptKotlinGeneratedDir = processingEnv.options["kapt.kotlin.generated"]
        val outputFile = File(kaptKotlinGeneratedDir!!).apply {
            mkdirs()
        }
        writeTo(outputFile.toPath())
    }
}