Kotlin 修炼手册（18）注解处理器（APT）

class MyProcessor: AbstractProcessor() {
    override fun process(set: MutableSet<out TypeElement>?, 
                         roundEnvironment: RoundEnvironment?): Boolean {
        return false
    }
}

class MyProcessor: AbstractProcessor() {
    override fun process(set: MutableSet<out TypeElement>?,
                         roundEnvironment: RoundEnvironment?): Boolean {
        return false
    }
    // 指定支持的注解类型
    override fun getSupportedAnnotationTypes(): MutableSet<String> {
        return mutableSetOf(MyAnnotation::javaClass.javaClass.canonicalName)
    }
    // 指定支持的Java版本
    override fun getSupportedSourceVersion(): SourceVersion {
        return SourceVersion.latestSupported()
    }
}

// 指定支持的注解类型
@SupportedAnnotationTypes("cc.lixiaoyu.complier.MyAnnotation")
// 指定支持的Java版本，这里指定了Java 8
@SupportedSourceVersion(SourceVersion.RELEASE_8)
class MyProcessor: AbstractProcessor() {
    override fun process(set: MutableSet<out TypeElement>?,
                         roundEnvironment: RoundEnvironment?): Boolean {
        return false
    }
}

@AutoService(Processor.class)
class MyProcessor: AbstractProcessor() {
    //...
}

package com.example;	// PackageElement
public class Foo {		// TypeElement
	private int a;		// VariableElement
	private Foo other; 	// VariableElement
	public Foo () {} 	// ExecuteableElement
	public void setA ( 	// ExecuteableElement
	                 int newA	// TypeParameterElement
	                 ) {}
}

// 错误，也有可能是一个接口
if (element instanceof TypeElement) { 
}
// 正确
if (element.getKind() == ElementKind.CLASS) { 
    //doSomething
}

public static final String CUSTOM_ANNOTATION = "customAnnotation";
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
   try {
       String resultPath = processingEnv.getOptions().get(CUSTOM_ANNOTATION);
       if (resultPath == null) {
           ...
           return false;
       }
       ...
   } catch (Exception e) {
       e.printStackTrace();
       ...
   }
   return true;
}
@Override
public Set<String> getSupportedOptions() {
   Set<String> options = new LinkedHashSet<String>();
   options.add(CUSTOM_ANNOTATION);
   return options;
}

public abstract boolean process(Set<? extends TypeElement> annotations,
                                RoundEnvironment roundEnv)

class MainActivity {
  @BindView(R.id.button)
  Button btnAdd;
  
  public void onCreate() {
    // 对应 ButterKnife.bind(this);
    CakeKnife.bind(this);
    btnAdd.setText("Add task");
  }
}

@Target(AnnotationTarget.FIELD)
@Retention(AnnotationRetention.BINARY)
annotation class BindView(val value: Int = -1)

@AutoService(Processor::class)
class BindViewProcessor : AbstractProcessor() {
    private lateinit var elementUtils: Elements // 对 Element 的工具类
    private lateinit var typeUtils: Types  // 对 TypeMirror 的工具类
    private lateinit var filer: Filer  // 用来创建文件
    private lateinit var messager: Messager  // 用来打印错误信息
    override fun init(processingEnv: ProcessingEnvironment?) {
        super.init(processingEnv)
        if (processingEnv == null) {
            return
        }
        elementUtils = processingEnv.elementUtils
        typeUtils = processingEnv.typeUtils
        filer = processingEnv.filer
        messager = processingEnv.messager
    }
    override fun process(set: MutableSet<out TypeElement>?,
                         roundEnv: RoundEnvironment?): Boolean {
        return true
    }
    override fun getSupportedAnnotationTypes(): MutableSet<String> {
        val annotations = mutableSetOf<String>()
        annotations.add(BindView::class.java.canonicalName)
        return annotations
    }
    override fun getSupportedSourceVersion(): SourceVersion {
        return SourceVersion.latestSupported()
    }
}

class BindViewProcessor : AbstractProcessor() {
    
    override fun process(set: MutableSet<out TypeElement>?,
                         roundEnv: RoundEnvironment?): Boolean {
        if (roundEnv == null) {
            error(null, "roundEnv is null")
        }
        processBindView(roundEnv!!)
        return true
    }
    /*
     * 处理 @BindView 注解
     */
    private fun processBindView(roundEnv: RoundEnvironment) {
        // 获取所有使用了BindView注解的元素
        val bindViewElements = roundEnv.getElementsAnnotatedWith(BindView::class.java)
        // 根据不同的类来对使用了注解的元素进行分组，每一个类创建一个ViewBinding类
        val groupedElement = groupingElementWithType(bindViewElements)
        // 生成ViewBinding类的Java代码
        generateViewBindingClasses(groupedElement)
    }
    /**
     * 打印错误信息的方法
     */
    private fun error(element: Element?, msg: String, vararg args: Any?) {
        messager.printMessage(Diagnostic.Kind.ERROR, String.format(msg, args), element)
    }
}

/**
 * 对所有加了注解的元素按类名进行分组
 */
private fun groupingElementWithType(eleSet: Set<Element>): Map<TypeElement, ArrayList<Element>> {
    // 定义了一个 <Class, List<Element>> 的map，属于同一个类的被 @BindView 修饰的元素都会被添加到list中
    val groupedElement = HashMap<TypeElement, ArrayList<Element>>()
    // 遍历所有被 @BindView 修饰的元素
    for (item in eleSet) {
        // 检查使用注解元素的合法性（只能是变量，不能加private和final修饰符）
        checkAnnotationLegal(item)
        // 获取到这个元素所在类元素信息
        val enclosingElement = item.enclosingElement as TypeElement
        // 如果这个类已经在map中有了，就直接添加到对应的list中
        if (groupedElement.containsKey(enclosingElement)) {
            groupedElement[enclosingElement]?.add(item)
        } else {
            // 如果这个类在map中没有，就put到map中，并新建一个list用来存放这个元素
            val list = ArrayList<Element>()
            list += item
            groupedElement[enclosingElement] = list
        }
    }
    // 返回这个分组结果
    return groupedElement
}

/**
 * 检查@BindView注解修饰的变量进行合法检查
 * @param element
 */
private fun checkAnnotationLegal(element: Element) {
    // 首先看注解修饰的是不是变量
    if (element.kind != ElementKind.FIELD) {
        throw RuntimeException("@BindView must in filed! Current kind is " + element.kind)
    }
    // 获取元素的修饰符
    val modifiers = element.modifiers
    // 看修饰符中有没有 final
    if (modifiers.contains(Modifier.FINAL)) {
        throw RuntimeException("@BindView filed can not be final")
    }
    // 看修饰符中有没有 private
    if (modifiers.contains(Modifier.PRIVATE)) {
        throw RuntimeException("@BindView filed can not be private")
    }
}

private fun generateViewBindingClasses(groupedElement: Map<TypeElement, ArrayList<Element>>) {
    // 遍历每一个类
    val keySet = groupedElement.keys
    for (classItem in keySet) {
        // 创建一个XXActivity_ViewBinding辅助类
        val typeBuilder = makeTypeSpecBuilder(classItem)
        // 创建辅助类的构造函数
        val constructorBuilder = makeConstructor(classItem)
        // 生成构造函数中的代码
        buildConstructorCode(constructorBuilder, groupedElement[classItem])
        // 把构造函数加到创建的辅助类中
        typeBuilder.addMethod(constructorBuilder.build())
        // 生成一个Java文件
        val file = JavaFile.builder(getPackageName(classItem), typeBuilder.build()).build()
        // 写入该Java文件
        file.writeTo(this.processingEnv.filer)
    }
}

public class MainActivity_ViewBinding {
  public MainActivity_ViewBinding(MainActivity target) {
    target.btnAdd = target.findViewById(R.id.button);
  }
}

/**
 * 创建一个XXActivity_ViewBinding辅助类，生成的代码如下所示：
 *
 * public class MainActivity_ViewBinding {
 *
 * }
 */
private fun makeTypeSpecBuilder(classItem: TypeElement): TypeSpec.Builder {
    return TypeSpec.classBuilder("${classItem.simpleName}_ViewBinding")
            .addModifiers(Modifier.PUBLIC)
}
/**
 * 创建一个构造函数，传入一个类型是目标Activity的形参target，生成的代码如下所示：
 *
 * public XXActivity_ViewBinding(MainActivity target) {
 *  
 * }
 */
private fun makeConstructor(classItem: TypeElement): MethodSpec.Builder {
    val typeMirror = classItem.asType()
    return MethodSpec.constructorBuilder()
            .addModifiers(Modifier.PUBLIC)
            .addParameter(TypeName.get(typeMirror), "target")
}
/**
 * 生成构造函数中的代码
 * 对这个类中每个加了注解的控件属性进行findViewById的初始化
 * 生成的代码如下所示：
 *
 * target.mTextView = target.findViewById(2131165289);
 */
private fun buildConstructorCode(bindMethodBuilder: MethodSpec.Builder, elements: ArrayList<Element>?) {
    elements?.let {
        for (itemView in elements) {
            bindMethodBuilder.addStatement("target.$itemView = " +
                    "target.findViewById(${itemView.getAnnotation(BindView::class.java).value})")
        }
    }
}
/**
 * 获取类的包名
 */
private fun getPackageName(typeElement: Element): String {
    var ele = typeElement
    while(ele.kind != ElementKind.PACKAGE){
        ele = ele.enclosingElement
    }
    return (ele as PackageElement).qualifiedName.toString()
}

package cc.lixiaoyu.cakeknife
import android.app.Activity
import java.lang.RuntimeException
import java.lang.reflect.Constructor
object CakeKnife {
    @JvmStatic
    fun bind(activity: Activity) {
        // 拿到当前绑定的类
        val targetClass = activity::class.java
        // 通过类名找到APT生成的XXActivity_ViewBinding类的构造函数
        val constructor = findBindingConstructorForClass(targetClass)
        // 通过反射来创建一个实例，在构造函数中调用findViewById来绑定控件。
        constructor?.newInstance(activity)
    }
    private fun findBindingConstructorForClass(cls: Class<*>?) : Constructor<*>?{
        cls?.let {
            // 获取到类名
            val clsName = cls.name
            return try {
                // 通过ClassLoader来加载这个APT生成的类
                val bindingClass = cls.classLoader?.loadClass(clsName + "_ViewBinding")
                // 获取到这个类的构造函数
                bindingClass?.getConstructor(cls)
            } catch (e: ClassNotFoundException) {
                // 如果没有找到这个类，则传入父类继续查找
                findBindingConstructorForClass(cls.superclass)
            } catch (e: NoSuchMethodException) {
                // 如果这个类没有构造方法，则抛出异常
                throw RuntimeException("Unable to find binding constructor for $clsName")
            }
        }
        return null
    }
}

dependencies {
    // 添加这个依赖，可以调用 CakeKnife.bind()
    implementation project(path: ':cakeknife')
    // 添加这个依赖，可以引用到@BindView注解
    implementation project(path: ':annotations')
    // 添加这个依赖，注解处理器BindViewProcessor就可以工作了
    annotationProcessor project(path: ':processor')
}

public class MainActivity extends AppCompatActivity {
    @BindView(R.id.main_textview)
    public TextView mTextView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        CakeKnife.bind(this);
        mTextView.setText("Owen");
    }
}