Detailed explanation of APT application (hand-in-hand teaching you to write ButterKnife tool)

[[410458]]

This article is reprinted from the WeChat public account "Android Development Programming", the author is Android Development Programming. Please contact the Android Development Programming public account for reprinting this article.

1. What is APT? What is it for? Learn with doubts

• APT (Annotation Processing Tool) is an annotation processor, which is a tool for processing annotations. To be more precise, it is a tool of javac, which is used to scan and process annotations during compilation. The annotation processor takes Java code (or compiled bytecode) as input and generates .java files as output;
• Simply put, at compile time, .java files are generated through annotations;
• The advantage of using APT is that it is convenient and simple, and can reduce a lot of repeated code. Students who have used annotation frameworks such as ButterKnife, Dagger, and EventBus can feel that using these frameworks can reduce a lot of code. Just write some annotations. They just help generate some efficient code through annotations.

2. APT application - write an annotation based on ButterKnife

Implement a function through APT and implement View binding by annotating View variables

1. Create several Libraries to declare

 Android Library: aptlibs Normally write Android lib
 Java or Kotlin Library: aptlib-anno (specially for annotations written by us)
 Java or Kotlin Library: aptlib-processor (write the logic of dynamically generated files)
 aptlibs
 plugins {
 id 'com.android.library'  
 id 'kotlin-android'  
 }
 aptlib-anno
 plugins {
 id 'java-library'  
 }
 aptlib-processor
 plugins {
 id 'java-library'  
 }

This should be remembered clearly. Many bloggers probably have never written apt and cannot distinguish between AndroidLib and javaLib.

apt is originally provided by java, and the Android library does not allow inheritance of AbstractProcessor

2. Define annotations-custom annotations

Remember to create it under the aptlib-anno repository

 @Retention(RetentionPolicy.CLASS)
 @Target(ElementType.FIELD)
 public @interface BindView {
 int value();
 }

The runtime annotation BindView is defined, where value() is used to obtain the id of the corresponding View;

• @Retention(RetentionPolicy.CLASS): indicates compile-time annotation
• @Target(ElementType.FIELD): indicates that the annotation scope is class members (constructors, methods, member variables)
• @Retention: defines how long to retain
• RetentionPoicy.SOURCE, RetentionPoicy.CLASS, RetentionPoicy.RUNTIME
• @Target: defines the scope of the modified object
• TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, etc.

3. Define annotation processor-dynamically generate associated files

aptlib-processor library

First add dependencies under this lib

 dependencies {
    implementation 'com.google.auto.service:auto-service:1.0-rc2'   
    implementation project( ':aptlib-anno' )
 }

Create BindViewProcessor

 @AutoService(Processor.class)
 public class BindViewProcessor extends AbstractProcessor {
    private Messager mMessager;
    private Elements mElementUtils;
    private Map<String, ClassCreatorProxy> mProxyMap = new HashMap<>();
 @Override
 public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        mMessager = processingEnv.getMessager();
        mElementUtils = processingEnv.getElementUtils();
 }
 @Override
 public   Set <String> getSupportedAnnotationTypes() {
        HashSet<String> supportTypes = new LinkedHashSet<>();
        supportTypes.add ( BindView.class.getCanonicalName ());
 return supportTypes;
 }
 @Override
 public SourceVersion getSupportedSourceVersion() {
 return SourceVersion.latestSupported();
 }
 @Override
 public boolean process( Set <? extends TypeElement> set , RoundEnvironment roundEnv) {
           mMessager.printMessage(Diagnostic.Kind.NOTE, "processing..." );
 mProxyMap.clear();
 //Get all annotations
 Set <? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(BindView.class);
 for (Element element : elements) {
            VariableElement variableElement = (VariableElement) element;
            TypeElement classElement = (TypeElement) variableElement.getEnclosingElement();
            String fullClassName = classElement.getQualifiedName().toString();
            ClassCreatorProxy proxy = mProxyMap.get(fullClassName);
            if (proxy == null ) {
                proxy = new ClassCreatorProxy(mElementUtils, classElement);
                mProxyMap.put(fullClassName, proxy);
 }
            BindView bindAnnotation = variableElement.getAnnotation(BindView.class);
 int id = bindAnnotation.value();
            proxy.putElement(id, variableElement);
 }
 //Create java files by traversing mProxyMap
 for (String key : mProxyMap.keySet()) {
            ClassCreatorProxy proxyInfo = mProxyMap.get( key );
 try {
                mMessager.printMessage(Diagnostic.Kind.NOTE, " --> create " + proxyInfo.getProxyClassFullName());
                JavaFileObject jfo = processingEnv.getFiler().createSourceFile(proxyInfo.getProxyClassFullName(), proxyInfo.getTypeElement());
                Writer writer = jfo.openWriter();
                writer.write(proxyInfo.generateJavaCode());
                writer.flush();
                writer.close () ;
            } catch (IOException e) {
                mMessager.printMessage(Diagnostic.Kind.NOTE, " --> create " + proxyInfo.getProxyClassFullName() + "error" );
 }
 }
        mMessager.printMessage(Diagnostic.Kind.NOTE, "process finish ..." );
 return   true ;
 }
 }

 public class ClassCreatorProxy {
    private String mBindingClassName;
    private String mPackageName;
    private TypeElement mTypeElement;
    private Map< Integer , VariableElement> mVariableElementMap = new HashMap<>();
 public ClassCreatorProxy(Elements elementUtils, TypeElement classElement) {
        this.mTypeElement = classElement;
        PackageElement packageElement = elementUtils.getPackageOf(mTypeElement);
        String packageName = packageElement.getQualifiedName().toString();
        String className = mTypeElement.getSimpleName().toString();
        this.mPackageName = packageName;
        this.mBindingClassName = className + "_ViewBinding" ;
 }
 public void putElement( int id, VariableElement element) {
        mVariableElementMap.put(id, element);
 }
 /**
 * Create Java code
 * @return  
 */
 public String generateJavaCode() {
        StringBuilder builder = new StringBuilder();
        builder.append( "package " ).append(mPackageName).append( ";\n\n" );
        builder.append( "import com.example.gavin.apt_library.*;\n" );
        builder.append( '\n' );
        builder.append( "public class " ).append(mBindingClassName);
        builder.append( " {\n" );
        generateMethods(builder);
        builder.append( '\n' );
        builder.append( "}\n" );
 return builder.toString();
 }
 /**
 * Add Method
 * @param builder
 */
    private void generateMethods(StringBuilder builder) {
        builder.append( "public void bind(" + mTypeElement.getQualifiedName() + " host ) {\n" );
 for ( int id : mVariableElementMap.keySet()) {
            VariableElement element = mVariableElementMap.get(id);
            String name = element.getSimpleName().toString();
            String type = element.asType().toString();
            builder.append( "host." + name ).append( " = " );
            builder.append( "(" + type + ")(((android.app.Activity)host).findViewById( " + id + "));\n" );
 }
        builder.append( " }\n" );
 }
 public String getProxyClassFullName()
 {
 return mPackageName + "." + mBindingClassName;
 }
 public TypeElement getTypeElement()
 {
 return mTypeElement;
 }
 }

• init: Initialization. You can get ProcessingEnviroment, which provides many useful tool classes Elements, Types and Filer
• getSupportedAnnotationTypes: Specifies which annotation this annotation processor is registered for. Here it is the annotation BindView
• getSupportedSourceVersion: specifies the Java version to use, usually returns SourceVersion.latestSupported()
• process: You can write code here to scan, evaluate, and process annotations and generate Java files
• Auto-service library: a library required for automatic code generation

4. Write the tool class BindViewTools

Write binding classes in the aptlib project

 public class BindViewTools {
 public   static void bind(Activity activity) {
        Class clazz = activity.getClass();
 try {
            Class bindViewClass = Class.forName(clazz.getName() + "_ViewBinding" );
            Method method = bindViewClass.getMethod( "bind" , activity.getClass());
            method.invoke(bindViewClass.newInstance(), activity);
        } catch (Exception e) {
            e.printStackTrace();
 }
 }
 }

5. Introduced into the main project app

 implementation project(path: ':aptlib' )
 annotationProcessor project(path: ':aptlib-process' )

In MainActivity, add the BindView annotation in front of View and pass in the id

 public class MainActivity extends AppCompatActivity {
 @BindView(R.id.tv)
 TextView mTextView;
 @BindView(R.id.btn)
 Button mButton;
 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        BindViewTools.bind(this);
        mTextView.setText( "bind TextView success" );
        mButton.setText( "bind Button success" );
 }
 }

Summarize

1. APT technology is actually custom annotations and annotation processors, which generate Java files during compilation, similar to IOC control inversion, and can be easily decoupled;

2. If you can also implement many different projects, such as routing framework, etc., you will also write some apt projects later.