Using Annotation Processing Tool (APT) for Automated Code Generation in Android Development

APT (Annotation Processing Tool) is a built‑in compiler tool that scans and processes annotations during the Java compilation phase. It enables developers to generate repetitive boilerplate code automatically, improving readability and reducing manual effort. Popular libraries such as ButterKnife and GreenDAO already leverage APT.

The article uses a common Android activity‑navigation scenario to illustrate APT usage, covering project setup, annotation definition, processor implementation, data extraction, and code generation with JavaPoet.

1. Project Setup

Create an Android Library to hold custom annotations, then add a Java Library that depends on it. Register the annotation processor using the auto-service library or manual META‑INF services registration.

Example Gradle dependency:

implementation 'com.google.auto.service:auto-service:1.0-rc2'

For Kotlin projects use kapt instead of annotationProcessor: kapt project(':libProce') 2. Define an Annotation

@Retention(CLASS)
@Target(FIELD)
public @interface AutoBundle {
    boolean require() default false;
}

3. Implement the Processor

@AutoService(Processor.class)
public class AutoBundleProcessor extends AbstractProcessor {
    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) { /* ... */ }

    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) { /* ... */ }

    @Override
    public Set<String> getSupportedAnnotationTypes() { return Collections.singleton(AutoBundle.class.getCanonicalName()); }
}

Inside process, retrieve elements annotated with @AutoBundle:

for (Element element : roundEnvironment.getElementsAnnotatedWith(AutoBundle.class)) {
    // handle each field
}

For each VariableElement, obtain the field name, type, package, class name, and annotation values:

String className = typeElement.getSimpleName().toString();
String packageName = elements.getPackageOf(typeElement).getQualifiedName().toString();
AutoBundle autoBundle = variableElement.getAnnotation(AutoBundle.class);
boolean require = autoBundle.require();
Name name = variableElement.getSimpleName();
TypeMirror type = variableElement.asType();

4. Generate Code with JavaPoet

JavaPoet simplifies building Java source files. Use TypeSpec for classes, MethodSpec for methods, and FieldSpec for fields.

TypeSpec.Builder contentBuilder = TypeSpec.classBuilder("YourClassName");
MethodSpec.Builder buildMethodBuilder = MethodSpec.methodBuilder("build")
        .addModifiers(Modifier.PUBLIC)
        .returns(ClassName.get("android.content", "Intent"));
buildMethodBuilder.addParameter(ClassName.get("android.content", "Context"), "context");
buildMethodBuilder.addStatement("Intent intent = new Intent(context, $L.class)", className);
// add putExtra statements for each field
buildMethodBuilder.addStatement("return intent");
contentBuilder.addMethod(buildMethodBuilder.build());

Write the generated file to the compiler's Filer:

JavaFile javaFile = JavaFile.builder(packageName, contentBuilder.build()).build();
try {
    javaFile.writeTo(filer);
} catch (IOException e) {
    e.printStackTrace();
}

5. Resulting Generated Code

public Intent build(Context context) {
    Intent intent = new Intent(context, TestActivity.class);
    intent.putExtra("id", id);
    intent.putExtra("name", name);
    intent.putExtra("is", is);
    if (!(context instanceof Activity)) {
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    }
    return intent;
}

And a binding method to read the extras back into the activity:

public void bind(TestActivity target, Intent intent) {
    target.id = intent.getIntExtra("id", 0);
    target.name = intent.getStringExtra("name");
    target.is = intent.getBooleanExtra("is", false);
}

The article concludes with a flow diagram summarizing the entire APT development process, from annotation definition to automatic Java file generation, demonstrating how APT can streamline Android codebases.