java/com/android/dialer/rootcomponentgenerator/ComponentGeneratingStep.java - platform/packages/apps/Dialer - Git at Google

 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License
  */

 package com.android.dialer.rootcomponentgenerator;

 import static com.google.auto.common.AnnotationMirrors.getAnnotationValue;
 import static com.google.auto.common.MoreElements.getAnnotationMirror;
 import static javax.lang.model.element.Modifier.ABSTRACT;
 import static javax.lang.model.element.Modifier.PUBLIC;
 import static javax.lang.model.element.Modifier.STATIC;
 import static javax.lang.model.util.ElementFilter.typesIn;

 import com.android.dialer.inject.IncludeInDialerRoot;
 import com.google.auto.common.BasicAnnotationProcessor.ProcessingStep;
 import com.google.auto.common.MoreElements;
 import com.google.common.base.Optional;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.SetMultimap;
 import com.squareup.javapoet.AnnotationSpec;
 import com.squareup.javapoet.ClassName;
 import com.squareup.javapoet.FieldSpec;
 import com.squareup.javapoet.MethodSpec;
 import com.squareup.javapoet.ParameterSpec;
 import com.squareup.javapoet.TypeName;
 import com.squareup.javapoet.TypeSpec;
 import dagger.Subcomponent;
 import java.lang.annotation.Annotation;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 import javax.annotation.processing.ProcessingEnvironment;
 import javax.lang.model.element.AnnotationMirror;
 import javax.lang.model.element.AnnotationValue;
 import javax.lang.model.element.Element;
 import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.VariableElement;
 import javax.lang.model.type.TypeMirror;

 /**
  * Generates component for a type annotated with {@link IncludeInDialerRoot}.
  *
  * <p>Our components have boilerplate code like:
  *
  * <p>
  *
  * <pre>
  * <code>
  *
  * {@literal @}dagger.Subcomponent
  * public abstract class GenXXXXComponent {
  *   public static SimulatorComponent get(Context context) {
  *      return ((HasComponent)((HasRootComponent) context.getApplicationContext()).component())
  *         .simulatorComponent();
  *   }
  *   {@literal @}IncludeInDialerRoot
  *   public interface HasComponent {
  *      SimulatorComponent simulatorComponent();
  *  }
  * }
  * </code>
  * </pre>
  */
 final class ComponentGeneratingStep implements ProcessingStep {

   private static final String DIALER_INJECT_PACKAGE = "com.android.dialer.inject";
   private static final String DIALER_HASROOTCOMPONENT_INTERFACE = "HasRootComponent";
   private static final ClassName ANDROID_CONTEXT_CLASS_NAME =
       ClassName.get("android.content", "Context");
   private final ProcessingEnvironment processingEnv;

   public ComponentGeneratingStep(ProcessingEnvironment processingEnv) {
     this.processingEnv = processingEnv;
   }

   @Override
   public Set<? extends Class<? extends Annotation>> annotations() {
     return ImmutableSet.of(IncludeInDialerRoot.class);
   }

   @Override
   public Set<? extends Element> process(
       SetMultimap<Class<? extends Annotation>, Element> elementsByAnnotation) {
     for (TypeElement type : typesIn(elementsByAnnotation.get(IncludeInDialerRoot.class))) {
       generateComponent(type);
     }
     return Collections.emptySet();
   }

   /**
    * Generates component file for a componentElement.
    *
    * <p>The annotation processor will generate a new type file with some prefix, which contains
    * public static XXX get(Context context) method and HasComponent interface.
    *
    * @param dialerComponentElement a component used by the annotation processor.
    */
   private void generateComponent(TypeElement dialerComponentElement) {
     TypeSpec.Builder componentClass =
         dialerComponentElement.getKind().isClass()
             ? cloneClass(dialerComponentElement, RootComponentUtils.GENERATED_COMPONENT_PREFIX)
             : cloneInterface(dialerComponentElement, RootComponentUtils.GENERATED_COMPONENT_PREFIX);
     componentClass.addAnnotation(makeDaggerSubcomponentAnnotation(dialerComponentElement));
     RootComponentUtils.writeJavaFile(
         processingEnv,
         ClassName.get(dialerComponentElement).packageName(),
         dialerBoilerplateCode(componentClass, dialerComponentElement));
   }

   @SuppressWarnings("unchecked")
   private AnnotationSpec makeDaggerSubcomponentAnnotation(TypeElement dialerComponentElement) {

     Optional<AnnotationMirror> componentMirror =
         getAnnotationMirror(dialerComponentElement, IncludeInDialerRoot.class);

     AnnotationSpec.Builder subcomponentBuilder = AnnotationSpec.builder(Subcomponent.class);
     for (AnnotationValue annotationValue :
         (List<? extends AnnotationValue>)
             getAnnotationValue(componentMirror.get(), "modules").getValue()) {
       subcomponentBuilder.addMember(
           "modules", "$T.class", ClassName.get((TypeMirror) annotationValue.getValue()));
     }
     return subcomponentBuilder.build();
   }

   private TypeSpec dialerBoilerplateCode(
       TypeSpec.Builder typeBuilder, TypeElement dialerComponentElement) {
     return typeBuilder
         .addType(hasComponentInterface(typeBuilder, dialerComponentElement))
         .addMethod(addGetComponentMethod(typeBuilder, dialerComponentElement))
         .build();
   }

   private TypeSpec hasComponentInterface(
       TypeSpec.Builder typeBuilder, TypeElement dialerComponentElement) {
     return TypeSpec.interfaceBuilder("HasComponent")
         .addModifiers(PUBLIC)
         .addMethod(
             MethodSpec.methodBuilder("make" + dialerComponentElement.getSimpleName())
                 .addModifiers(PUBLIC, ABSTRACT)
                 .returns(getComponentClass(typeBuilder, dialerComponentElement))
                 .build())
         .build();
   }

   private MethodSpec addGetComponentMethod(
       TypeSpec.Builder typeBuilder, TypeElement dialerComponentElement) {
     ClassName hasComponenetInterface =
         ClassName.get(
                 getPackageName(dialerComponentElement),
                 RootComponentUtils.GENERATED_COMPONENT_PREFIX
                     + dialerComponentElement.getSimpleName())
             .nestedClass("HasComponent");
     ClassName hasRootComponentInterface =
         ClassName.get(DIALER_INJECT_PACKAGE, DIALER_HASROOTCOMPONENT_INTERFACE);
     return MethodSpec.methodBuilder("get")
         .addModifiers(PUBLIC, STATIC)
         .addParameter(ParameterSpec.builder(ANDROID_CONTEXT_CLASS_NAME, "context").build())
         .addStatement(
             "$1T hasRootComponent = ($1T) context.getApplicationContext()",
             hasRootComponentInterface)
         .addStatement(
             "return (($T) (hasRootComponent.component())).make$T()",
             hasComponenetInterface,
             dialerComponentElement)
         .returns(getComponentClass(typeBuilder, dialerComponentElement))
         .build();
   }

   private void addElement(TypeSpec.Builder builder, Element element) {
     switch (element.getKind()) {
       case INTERFACE:
         builder.addType(cloneInterface(MoreElements.asType(element), "").build());
         break;
       case CLASS:
         builder.addType(cloneClass(MoreElements.asType(element), "").build());
         break;
       case FIELD:
         builder.addField(cloneField(MoreElements.asVariable(element)).build());
         break;
       case METHOD:
         builder.addMethod(cloneMethod(MoreElements.asExecutable(element)));
         break;
       case CONSTRUCTOR:
         builder.addMethod(cloneConstructor(MoreElements.asExecutable(element)));
         break;
       default:
         throw new RuntimeException(
             String.format("Unexpected element %s met during class cloning phase!", element));
     }
   }

   private MethodSpec cloneMethod(ExecutableElement element) {
     return MethodSpec.methodBuilder(element.getSimpleName().toString())
         .addModifiers(element.getModifiers())
         .returns(TypeName.get(element.getReturnType()))
         .addParameters(cloneParameters(element.getParameters()))
         .build();
   }

   private MethodSpec cloneConstructor(ExecutableElement element) {
     return MethodSpec.constructorBuilder()
         .addModifiers(element.getModifiers())
         .addParameters(cloneParameters(element.getParameters()))
         .build();
   }

   private List<ParameterSpec> cloneParameters(
       List<? extends VariableElement> variableElementsList) {
     List<ParameterSpec> list = new ArrayList<>();
     for (VariableElement variableElement : variableElementsList) {
       ParameterSpec.Builder builder =
           ParameterSpec.builder(
                   TypeName.get(variableElement.asType()),
                   variableElement.getSimpleName().toString())
               .addModifiers(variableElement.getModifiers());
       list.add(builder.build());
     }
     return list;
   }

   private TypeSpec.Builder cloneInterface(TypeElement element, String prefix) {
     return cloneType(TypeSpec.interfaceBuilder(prefix + element.getSimpleName()), element);
   }

   private TypeSpec.Builder cloneClass(TypeElement element, String prefix) {
     return cloneType(TypeSpec.classBuilder(prefix + element.getSimpleName()), element);
   }

   private FieldSpec.Builder cloneField(VariableElement element) {
     FieldSpec.Builder builder =
         FieldSpec.builder(TypeName.get(element.asType()), element.getSimpleName().toString());
     element.getModifiers().forEach(builder::addModifiers);
     return builder;
   }

   private TypeSpec.Builder cloneType(TypeSpec.Builder builder, TypeElement element) {
     element.getModifiers().forEach(builder::addModifiers);
     for (Element enclosedElement : element.getEnclosedElements()) {
       addElement(builder, enclosedElement);
     }
     return builder;
   }

   private ClassName getComponentClass(
       TypeSpec.Builder typeBuilder, TypeElement dialerComponentElement) {
     return ClassName.get(getPackageName(dialerComponentElement), typeBuilder.build().name);
   }

   private String getPackageName(TypeElement element) {
     return ClassName.get(element).packageName();
   }
 }
	/*
	* Copyright (C) 2018 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License
	*/

	package com.android.dialer.rootcomponentgenerator;

	import static com.google.auto.common.AnnotationMirrors.getAnnotationValue;
	import static com.google.auto.common.MoreElements.getAnnotationMirror;
	import static javax.lang.model.element.Modifier.ABSTRACT;
	import static javax.lang.model.element.Modifier.PUBLIC;
	import static javax.lang.model.element.Modifier.STATIC;
	import static javax.lang.model.util.ElementFilter.typesIn;

	import com.android.dialer.inject.IncludeInDialerRoot;
	import com.google.auto.common.BasicAnnotationProcessor.ProcessingStep;
	import com.google.auto.common.MoreElements;
	import com.google.common.base.Optional;
	import com.google.common.collect.ImmutableSet;
	import com.google.common.collect.SetMultimap;
	import com.squareup.javapoet.AnnotationSpec;
	import com.squareup.javapoet.ClassName;
	import com.squareup.javapoet.FieldSpec;
	import com.squareup.javapoet.MethodSpec;
	import com.squareup.javapoet.ParameterSpec;
	import com.squareup.javapoet.TypeName;
	import com.squareup.javapoet.TypeSpec;
	import dagger.Subcomponent;
	import java.lang.annotation.Annotation;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;
	import java.util.Set;
	import javax.annotation.processing.ProcessingEnvironment;
	import javax.lang.model.element.AnnotationMirror;
	import javax.lang.model.element.AnnotationValue;
	import javax.lang.model.element.Element;
	import javax.lang.model.element.ExecutableElement;
	import javax.lang.model.element.TypeElement;
	import javax.lang.model.element.VariableElement;
	import javax.lang.model.type.TypeMirror;

	/**
	* Generates component for a type annotated with {@link IncludeInDialerRoot}.
	*
	* <p>Our components have boilerplate code like:
	*
	* <p>
	*
	* <pre>
	* <code>
	*
	* {@literal @}dagger.Subcomponent
	* public abstract class GenXXXXComponent {
	* public static SimulatorComponent get(Context context) {
	* return ((HasComponent)((HasRootComponent) context.getApplicationContext()).component())
	* .simulatorComponent();
	* }
	* {@literal @}IncludeInDialerRoot
	* public interface HasComponent {
	* SimulatorComponent simulatorComponent();
	* }
	* }
	* </code>
	* </pre>
	*/
	final class ComponentGeneratingStep implements ProcessingStep {

	private static final String DIALER_INJECT_PACKAGE = "com.android.dialer.inject";
	private static final String DIALER_HASROOTCOMPONENT_INTERFACE = "HasRootComponent";
	private static final ClassName ANDROID_CONTEXT_CLASS_NAME =
	ClassName.get("android.content", "Context");
	private final ProcessingEnvironment processingEnv;

	public ComponentGeneratingStep(ProcessingEnvironment processingEnv) {
	this.processingEnv = processingEnv;
	}

	@Override
	public Set<? extends Class<? extends Annotation>> annotations() {
	return ImmutableSet.of(IncludeInDialerRoot.class);
	}

	@Override
	public Set<? extends Element> process(
	SetMultimap<Class<? extends Annotation>, Element> elementsByAnnotation) {
	for (TypeElement type : typesIn(elementsByAnnotation.get(IncludeInDialerRoot.class))) {
	generateComponent(type);
	}
	return Collections.emptySet();
	}

	/**
	* Generates component file for a componentElement.
	*
	* <p>The annotation processor will generate a new type file with some prefix, which contains
	* public static XXX get(Context context) method and HasComponent interface.
	*
	* @param dialerComponentElement a component used by the annotation processor.
	*/
	private void generateComponent(TypeElement dialerComponentElement) {
	TypeSpec.Builder componentClass =
	dialerComponentElement.getKind().isClass()
	? cloneClass(dialerComponentElement, RootComponentUtils.GENERATED_COMPONENT_PREFIX)
	: cloneInterface(dialerComponentElement, RootComponentUtils.GENERATED_COMPONENT_PREFIX);
	componentClass.addAnnotation(makeDaggerSubcomponentAnnotation(dialerComponentElement));
	RootComponentUtils.writeJavaFile(
	processingEnv,
	ClassName.get(dialerComponentElement).packageName(),
	dialerBoilerplateCode(componentClass, dialerComponentElement));
	}

	@SuppressWarnings("unchecked")
	private AnnotationSpec makeDaggerSubcomponentAnnotation(TypeElement dialerComponentElement) {

	Optional<AnnotationMirror> componentMirror =
	getAnnotationMirror(dialerComponentElement, IncludeInDialerRoot.class);

	AnnotationSpec.Builder subcomponentBuilder = AnnotationSpec.builder(Subcomponent.class);
	for (AnnotationValue annotationValue :
	(List<? extends AnnotationValue>)
	getAnnotationValue(componentMirror.get(), "modules").getValue()) {
	subcomponentBuilder.addMember(
	"modules", "$T.class", ClassName.get((TypeMirror) annotationValue.getValue()));
	}
	return subcomponentBuilder.build();
	}

	private TypeSpec dialerBoilerplateCode(
	TypeSpec.Builder typeBuilder, TypeElement dialerComponentElement) {
	return typeBuilder
	.addType(hasComponentInterface(typeBuilder, dialerComponentElement))
	.addMethod(addGetComponentMethod(typeBuilder, dialerComponentElement))
	.build();
	}

	private TypeSpec hasComponentInterface(
	TypeSpec.Builder typeBuilder, TypeElement dialerComponentElement) {
	return TypeSpec.interfaceBuilder("HasComponent")
	.addModifiers(PUBLIC)
	.addMethod(
	MethodSpec.methodBuilder("make" + dialerComponentElement.getSimpleName())
	.addModifiers(PUBLIC, ABSTRACT)
	.returns(getComponentClass(typeBuilder, dialerComponentElement))
	.build())
	.build();
	}

	private MethodSpec addGetComponentMethod(
	TypeSpec.Builder typeBuilder, TypeElement dialerComponentElement) {
	ClassName hasComponenetInterface =
	ClassName.get(
	getPackageName(dialerComponentElement),
	RootComponentUtils.GENERATED_COMPONENT_PREFIX
	+ dialerComponentElement.getSimpleName())
	.nestedClass("HasComponent");
	ClassName hasRootComponentInterface =
	ClassName.get(DIALER_INJECT_PACKAGE, DIALER_HASROOTCOMPONENT_INTERFACE);
	return MethodSpec.methodBuilder("get")
	.addModifiers(PUBLIC, STATIC)
	.addParameter(ParameterSpec.builder(ANDROID_CONTEXT_CLASS_NAME, "context").build())
	.addStatement(
	"$1T hasRootComponent = ($1T) context.getApplicationContext()",
	hasRootComponentInterface)
	.addStatement(
	"return (($T) (hasRootComponent.component())).make$T()",
	hasComponenetInterface,
	dialerComponentElement)
	.returns(getComponentClass(typeBuilder, dialerComponentElement))
	.build();
	}

	private void addElement(TypeSpec.Builder builder, Element element) {
	switch (element.getKind()) {
	case INTERFACE:
	builder.addType(cloneInterface(MoreElements.asType(element), "").build());
	break;
	case CLASS:
	builder.addType(cloneClass(MoreElements.asType(element), "").build());
	break;
	case FIELD:
	builder.addField(cloneField(MoreElements.asVariable(element)).build());
	break;
	case METHOD:
	builder.addMethod(cloneMethod(MoreElements.asExecutable(element)));
	break;
	case CONSTRUCTOR:
	builder.addMethod(cloneConstructor(MoreElements.asExecutable(element)));
	break;
	default:
	throw new RuntimeException(
	String.format("Unexpected element %s met during class cloning phase!", element));
	}
	}

	private MethodSpec cloneMethod(ExecutableElement element) {
	return MethodSpec.methodBuilder(element.getSimpleName().toString())
	.addModifiers(element.getModifiers())
	.returns(TypeName.get(element.getReturnType()))
	.addParameters(cloneParameters(element.getParameters()))
	.build();
	}

	private MethodSpec cloneConstructor(ExecutableElement element) {
	return MethodSpec.constructorBuilder()
	.addModifiers(element.getModifiers())
	.addParameters(cloneParameters(element.getParameters()))
	.build();
	}

	private List<ParameterSpec> cloneParameters(
	List<? extends VariableElement> variableElementsList) {
	List<ParameterSpec> list = new ArrayList<>();
	for (VariableElement variableElement : variableElementsList) {
	ParameterSpec.Builder builder =
	ParameterSpec.builder(
	TypeName.get(variableElement.asType()),
	variableElement.getSimpleName().toString())
	.addModifiers(variableElement.getModifiers());
	list.add(builder.build());
	}
	return list;
	}

	private TypeSpec.Builder cloneInterface(TypeElement element, String prefix) {
	return cloneType(TypeSpec.interfaceBuilder(prefix + element.getSimpleName()), element);
	}

	private TypeSpec.Builder cloneClass(TypeElement element, String prefix) {
	return cloneType(TypeSpec.classBuilder(prefix + element.getSimpleName()), element);
	}

	private FieldSpec.Builder cloneField(VariableElement element) {
	FieldSpec.Builder builder =
	FieldSpec.builder(TypeName.get(element.asType()), element.getSimpleName().toString());
	element.getModifiers().forEach(builder::addModifiers);
	return builder;
	}

	private TypeSpec.Builder cloneType(TypeSpec.Builder builder, TypeElement element) {
	element.getModifiers().forEach(builder::addModifiers);
	for (Element enclosedElement : element.getEnclosedElements()) {
	addElement(builder, enclosedElement);
	}
	return builder;
	}

	private ClassName getComponentClass(
	TypeSpec.Builder typeBuilder, TypeElement dialerComponentElement) {
	return ClassName.get(getPackageName(dialerComponentElement), typeBuilder.build().name);
	}

	private String getPackageName(TypeElement element) {
	return ClassName.get(element).packageName();
	}
	}