ButterKnifeソース読み

public static Unbinder bind(@NonNull Activity target) {
    View sourceView = target.getWindow().getDecorView();//1.1   Activity    view
    return bind(target, sourceView);
}
  
public static Unbinder bind(@NonNull Object target, @NonNull View source) {
    Class> targetClass = target.getClass();//1.2          
    
    //1.3   Activity class ，     clsName + "_ViewBinding"     
    Constructor extends Unbinder> constructor = findBindingConstructorForClass(targetClass);
    if (constructor == null) {
      return Unbinder.EMPTY;
    }
    
    ...
    //1.9             
    return constructor.newInstance(target, source);//try-catch
}  

@AutoService(Processor.class)
@IncrementalAnnotationProcessor(IncrementalAnnotationProcessorType.DYNAMIC)
@SuppressWarnings("NullAway") // TODO fix all these...
public final class ButterKnifeProcessor extends AbstractProcessor {
    ...
}

@Override public Set getSupportedAnnotationTypes() {
    Set types = new LinkedHashSet<>();
    for (Class extends Annotation> annotation : getSupportedAnnotations()) {
      types.add(annotation.getCanonicalName());
    }
    return types;
}
private Set> getSupportedAnnotations() {
    Set> annotations = new LinkedHashSet<>();
    //  ButterKnife       
    annotations.add(BindAnim.class);
    annotations.add(BindArray.class);
    annotations.add(BindBitmap.class);
    ...
    
    return annotations;
}
  

@Override public boolean procesButterKnifes(Set extends TypeElement> elements, RoundEnvironment env) {
    //1.        ButterKnife           
    Map bindingMap = findAndParseTargets(env);
    //2.       bind  ，        java  
    for (Map.Entry entry : bindingMap.entrySet()) {
      TypeElement typeElement = entry.getKey();
      BindingSet binding = entry.getValue();

      JavaFile javaFile = binding.brewJava(sdk, debuggable);
      try {
        javaFile.writeTo(filer);
      } catch (IOException e) {
        error(typeElement, "Unable to write binding for type %s: %s", typeElement, e.getMessage());
      }
    }

    return false;
  }

  private Map findAndParseTargets(RoundEnvironment env) {
    Map builderMap = new LinkedHashMap<>();
    Set erasedTargetNames = new LinkedHashSet<>();
    
    ... //       BindInt.class

    //   BindView    Element
    for (Element element : env.getElementsAnnotatedWith(BindView.class)) {
      try {
        //  BindView    
        parseBindView(element, builderMap, erasedTargetNames);
      } catch (Exception e) {
        logParsingError(element, BindView.class, e);
      }
    }
    
    ...//               

    Map classpathBindings =
        findAllSupertypeBindings(builderMap, erasedTargetNames);

    //  builderMap        
    Deque> entries =new ArrayDeque<>(builderMap.entrySet());
    Map bindingMap = new LinkedHashMap<>();
    
    while (!entries.isEmpty()) {
      //      
      Map.Entry entry = entries.removeFirst();
      TypeElement type = entry.getKey();
      BindingSet.Builder builder = entry.getValue();
        //           
      TypeElement parentType = findParentType(type, erasedTargetNames, classpathBindings.keySet());
      if (parentType == null) {
      // TypeElement, BindingSet.Builder      
        bindingMap.put(type, builder.build());
      } else {
        BindingInformationProvider parentBinding = bindingMap.get(parentType);
        if (parentBinding == null) {
          parentBinding = classpathBindings.get(parentType);
        }
        if (parentBinding != null) {
            //       ，  setParent   BindingSet
          builder.setParent(parentBinding);
          bindingMap.put(type, builder.build());
        } else {
          //       ，        。         
          entries.addLast(entry);
        }
      }
    }

    return bindingMap;
  }

  private void parseBindView(Element element, Map builderMap,
      Set erasedTargetNames) {
      
      //getEnclosingElement        （      ）      。
      //       ，   view  
    TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();

    //    fields          andriod  api    
    boolean hasError = isInaccessibleViaGeneratedCode(BindView.class, "fields", element)
        || isBindingInWrongPackage(BindView.class, element);

    //          View  。
    TypeMirror elementType = element.asType();
    if (elementType.getKind() == TypeKind.TYPEVAR) {
      TypeVariable typeVariable = (TypeVariable) elementType;
      elementType = typeVariable.getUpperBound();
    }
    Name qualifiedName = enclosingElement.getQualifiedName();
    Name simpleName = element.getSimpleName();
    if (!isSubtypeOfType(elementType, VIEW_TYPE) && !isInterface(elementType)) {
      ...//         View   ，     ，         
    }
    if (hasError) return;

    //  View    ，   view id
    int id = element.getAnnotation(BindView.class).value();
    //               
    BindingSet.Builder builder = builderMap.get(enclosingElement);
    Id resourceId = elementToId(element, BindView.class, id);
    if (builder != null) {
      ... //  View       ，    id     ，          
    } else {
        //  BindingSet.Builder， enclosingElement  builderMap
      builder = getOrCreateBindingBuilder(builderMap, enclosingElement);
    }

    String name = simpleName.toString();
    TypeName type = TypeName.get(elementType);
    boolean required = isFieldRequired(element);
    //           builder 
    builder.addField(resourceId, new FieldViewBinding(name, type, required));

    //  view       erasedTargetNames  
    erasedTargetNames.add(enclosingElement);
  }

private BindingSet(
      TypeName targetTypeName, ClassName bindingClassName, TypeElement enclosingElement,
      boolean isFinal, boolean isView, boolean isActivity, boolean isDialog,
      ImmutableList viewBindings,
      ImmutableList collectionBindings,
      ImmutableList resourceBindings,
      @Nullable BindingInformationProvider parentBinding) {
    this.isFinal = isFinal;
    this.targetTypeName = targetTypeName;
    this.bindingClassName = bindingClassName;
    this.enclosingElement = enclosingElement;
    this.isView = isView;
    this.isActivity = isActivity;
    this.isDialog = isDialog;
    this.viewBindings = viewBindings;
    this.collectionBindings = collectionBindings;
    this.resourceBindings = resourceBindings;
    this.parentBinding = parentBinding;
  }