ButterKnifeProcessor-parseListenerAnnotation.java

private void parseListenerAnnotation(Class<? extends Annotation> annotationClass, Element element,
    Map<TypeElement, BindingSet.Builder> builderMap, Set<TypeElement> erasedTargetNames)
    throws Exception {
  ...
  ExecutableElement executableElement = (ExecutableElement) element;
  TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();

  // Assemble information on the method.
  Annotation annotation = element.getAnnotation(annotationClass);
  Method annotationValue = annotationClass.getDeclaredMethod("value");
  ...

  int[] ids = (int[]) annotationValue.invoke(annotation);
  String name = executableElement.getSimpleName().toString();
  boolean required = isListenerRequired(executableElement);
  ...
  ListenerClass listener = annotationClass.getAnnotation(ListenerClass.class);
  ...
  ListenerMethod method;
  ListenerMethod[] methods = listener.method();
  if (methods.length > 1) {
    ...
  } else if (methods.length == 1) {
    ...
    method = methods[0];
  } else {
    Method annotationCallback = annotationClass.getDeclaredMethod("callback");
    Enum<?> callback = (Enum<?>) annotationCallback.invoke(annotation);
    Field callbackField = callback.getDeclaringClass().getField(callback.name());
    method = callbackField.getAnnotation(ListenerMethod.class);
    ...
  }

  // Verify that the method has equal to or less than the number of parameters as the listener.
  List<? extends VariableElement> methodParameters = executableElement.getParameters();
  ...
  Parameter[] parameters = Parameter.NONE;
  if (!methodParameters.isEmpty()) {
    parameters = new Parameter[methodParameters.size()];
    BitSet methodParameterUsed = new BitSet(methodParameters.size());
    String[] parameterTypes = method.parameters();
    for (int i = 0; i < methodParameters.size(); i++) {
      VariableElement methodParameter = methodParameters.get(i);
      TypeMirror methodParameterType = methodParameter.asType();
      if (methodParameterType instanceof TypeVariable) {
        TypeVariable typeVariable = (TypeVariable) methodParameterType;
        methodParameterType = typeVariable.getUpperBound();
      }

      for (int j = 0; j < parameterTypes.length; j++) {
        if (methodParameterUsed.get(j)) {
          continue;
        }
        if ((isSubtypeOfType(methodParameterType, parameterTypes[j])
                && isSubtypeOfType(methodParameterType, VIEW_TYPE))
            || isTypeEqual(methodParameterType, parameterTypes[j])
            || isInterface(methodParameterType)) {
          parameters[i] = new Parameter(j, TypeName.get(methodParameterType));
          methodParameterUsed.set(j);
          break;
        }
      }
      ...
    }
  }

  MethodViewBinding binding = new MethodViewBinding(name, Arrays.asList(parameters), required);
  BindingSet.Builder builder = getOrCreateBindingBuilder(builderMap, enclosingElement);
  for (int id : ids) {
    QualifiedId qualifiedId = elementToQualifiedId(element, id);
    
    builder.addMethod(getId(qualifiedId), listener, method, binding)
    ...
  }

  // Add the type-erased version to the valid binding targets set.
  erasedTargetNames.add(enclosingElement);
}