Dodaj procesory adnotacji

Ta strona zawiera szczegółowe wskazówki dotyczące dodawania i konfigurowania procesorów adnotacji jako zależności projektu. Więcej informacji o procesorach adnotacji znajdziesz w artykule Konfigurowanie zależności.

Jeśli dodasz procesory adnotacji do ścieżki kompilacji, zobaczysz komunikat o błędzie podobny do tego:

Error: Annotation processors must be explicitly declared now.

Aby rozwiązać ten problem, dodaj do projektu procesory adnotacji, konfigurując zależność za pomocą elementu annotationProcessor, jak pokazano poniżej:

dependencies {
    // Adds libraries defining annotations to only the compile classpath.
    compileOnly("com.google.dagger:dagger:version-number")
    // Adds the annotation processor dependency to the annotation processor classpath.
    annotationProcessor("com.google.dagger:dagger-compiler:version-number")
}

dependencies {
    // Adds libraries defining annotations to only the compile classpath.
    compileOnly 'com.google.dagger:dagger:version-number'
    // Adds the annotation processor dependency to the annotation processor classpath.
    annotationProcessor 'com.google.dagger:dagger-compiler:version-number'
}

Uwaga: wtyczka Androida do obsługi Gradle w wersji 3.0.0 lub nowszej nie obsługuje już android-aptwtyczki.

Przekazywanie argumentów procesorom adnotacji

Jeśli chcesz przekazać argumenty procesorowi adnotacji, możesz to zrobić za pomocą bloku AnnotationProcessorOptions w konfiguracji kompilacji modułu. Jeśli na przykład chcesz przekazywać proste typy danych jako pary klucz-wartość, możesz użyć właściwości argument, jak pokazano poniżej:

android {
    ...
    defaultConfig {
        ...
        javaCompileOptions {
            annotationProcessorOptions {
                arguments += mapOf("key1" to "value1",
                                   "key2" to "value2")
            }
        }
    }
}

android {
    ...
    defaultConfig {
        ...
        javaCompileOptions {
            annotationProcessorOptions {
                argument 'key1', 'value1'
                argument 'key2', 'value2'
            }
        }
    }
}

Jeśli jednak używasz wtyczki Android Gradle w wersji 3.2.0 lub nowszej, musisz przekazać argumenty procesora, które reprezentują pliki lub katalogi, za pomocą interfejsu CommandLineArgumentProvider Gradle.

Użycie CommandLineArgumentProvider pozwala Tobie lub autorowi procesora adnotacji poprawić poprawność i wydajność czystych kompilacji przyrostowych i kompilacji z wykorzystaniem pamięci podręcznej, stosując adnotacje typu typu własności kompilacji przyrostowej do każdego argumentu.

Na przykład klasa poniżej implementuje funkcję CommandLineArgumentProvider i adnotuje każdy argument dla procesora.

class MyArgsProvider(
    // Annotates each directory as either an input or output for the
    // annotation processor.
    @get:InputFiles
    // Using this annotation helps Gradle determine which part of the file path
    // should be considered during up-to-date checks.
    @get:PathSensitive(PathSensitivity.RELATIVE)
    val inputDir: FileCollection,

    @get:OutputDirectory
    val outputDir: File
) : CommandLineArgumentProvider {
    // Specifies each directory as a command line argument for the processor.
    // The Android plugin uses this method to pass the arguments to the
    // annotation processor.

    override fun asArguments(): Iterable<String> {
        // Use the form '-Akey[=value]' to pass your options to the Java compiler.
        return listOf("-AinputDir=${inputDir.singleFile.absolutePath}",
                      "-AoutputDir=${outputDir.absolutePath}")
    }
}

android {...}

class MyArgsProvider implements CommandLineArgumentProvider {

    // Annotates each directory as either an input or output for the
    // annotation processor.
    @InputFiles
    // Using this annotation helps Gradle determine which part of the file path
    // should be considered during up-to-date checks.
    @PathSensitive(PathSensitivity.RELATIVE)
    FileCollection inputDir

    @OutputDirectory
    File outputDir

    // The class constructor sets the paths for the input and output directories.
    MyArgsProvider(FileCollection input, File output) {
        inputDir = input
        outputDir = output
    }

    // Specifies each directory as a command line argument for the processor.
    // The Android plugin uses this method to pass the arguments to the
    // annotation processor.
    @Override
    Iterable<String> asArguments() {
        // Use the form '-Akey[=value]' to pass your options to the Java compiler.
        ["-AinputDir=${inputDir.singleFile.absolutePath}",
         "-AoutputDir=${outputDir.absolutePath}"]
    }
}

android {...}

Po zdefiniowaniu klasy implementującej interfejs CommandLineArgumentProvider musisz utworzyć jej instancję i przekazać ją do wtyczki Androida za pomocą metody annotationProcessorOptions.compilerArgumentProvider, jak pokazano poniżej.

// This is in your module's build.gradle file.
android {
    defaultConfig {
        javaCompileOptions {
            annotationProcessorOptions {
                // Creates a new MyArgsProvider object, specifies the input and
                // output paths for the constructor, and passes the object
                // to the Android plugin.
                compilerArgumentProvider(MyArgsProvider(files("input/path"),
                                                          file("output/path")))
            }
        }
    }
}

// This is in your module's build.gradle file.
android {
    defaultConfig {
        javaCompileOptions {
            annotationProcessorOptions {
                // Creates a new MyArgsProvider object, specifies the input and
                // output paths for the constructor, and passes the object
                // to the Android plugin.
                compilerArgumentProvider new MyArgsProvider(files("input/path"),
                                         new File("output/path"))
            }
        }
    }
}

Aby dowiedzieć się więcej o tym, jak implementacja CommandLineArgumentProvider pomaga poprawić wydajność kompilacji, przeczytaj artykuł Przyspieszanie kompilacji projektów w języku Java.

Wyłączanie sprawdzania błędów procesora adnotacji

Jeśli masz zależności w ścieżce kompilacji, które obejmują procesory adnotacji, których nie potrzebujesz, możesz wyłączyć sprawdzanie błędów, dodając do pliku build.gradle.kts następujący kod. Pamiętaj, że procesory adnotacji dodane do ścieżki kompilacji nie są jeszcze dodawane do ścieżki procesora.

android {
    ...
    defaultConfig {
        ...
        javaCompileOptions {
            annotationProcessorOptions {
                argument("includeCompileClasspath", "false")
            }
        }
    }
}

android {
    ...
    defaultConfig {
        ...
        javaCompileOptions {
            annotationProcessorOptions {
                includeCompileClasspath false
            }
        }
    }
}

Jeśli używasz Kotlina i kapt:

android {
    ...
    defaultConfig {
        ...
        kapt {
            includeCompileClasspath = false
        }
    }
}

android {
    ...
    defaultConfig {
        ...
        kapt {
            includeCompileClasspath false
        }
    }
}

Jeśli po migracji procesorów adnotacji projektu do classpath procesora wystąpią problemy, możesz zezwolić na procesory adnotacji w ścieżce kompilacji classpath, ustawiając wartość includeCompileClasspath na true. Nie zalecamy jednak ustawiania tej właściwości na true, a ta opcja zostanie usunięta w przyszłej aktualizacji wtyczki na Androida.