Questa pagina include indicazioni dettagliate su come aggiungere e configurare i processori di annotazione come dipendenze del progetto. Per scoprire di più sugli elaboratori di annotazioni, consulta la voce in Configurare le dipendenze.
Se aggiungi elaboratori di annotazioni al percorso di classe di compilazione, viene visualizzato un messaggio di errore simile al seguente:
Error: Annotation processors must be explicitly declared now.
Per risolvere questo errore, aggiungi gli elaboratori di annotazioni al progetto configurando la dipendenza utilizzando annotationProcessor come mostrato di seguito:
Kotlin
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")
}
Groovy
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'
}
Nota: il plug-in Android per Gradle 3.0.0 e versioni successive non supporta più il plug-in
android-apt.
Passare gli argomenti ai processori di annotazioni
Se devi passare argomenti a un elaboratore di annotazioni, puoi farlo utilizzando il blocco AnnotationProcessorOptions nella configurazione di compilazione del modulo. Ad esempio, se vuoi passare tipi di dati primitivi come coppie chiave-valore, puoi utilizzare la proprietà argument, come mostrato di seguito:
Kotlin
android {
...
defaultConfig {
...
javaCompileOptions {
annotationProcessorOptions {
arguments += mapOf("key1" to "value1",
"key2" to "value2")
}
}
}
}
Groovy
android {
...
defaultConfig {
...
javaCompileOptions {
annotationProcessorOptions {
argument 'key1', 'value1'
argument 'key2', 'value2'
}
}
}
}
Tuttavia, quando utilizzi il plug-in Android Gradle 3.2.0 e versioni successive, devi passare gli argomenti del processore che rappresentano file o directory utilizzando l'interfaccia CommandLineArgumentProvider di Gradle.
L'utilizzo di CommandLineArgumentProvider consente a te o all'autore del processore di annotazioni di migliorare la correttezza e le prestazioni delle build incrementali e pulite memorizzate nella cache applicando annotazioni del tipo di proprietà di build incrementale a ogni argomento.
Ad esempio, la classe riportata di seguito implementa CommandLineArgumentProvider e annota ogni argomento per il processore.
Kotlin
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 {...}
Groovy
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 {...}
Dopo aver definito una classe che implementa CommandLineArgumentProvider, devi creare un'istanza e passarla al plug-in Android utilizzando il metodo annotationProcessorOptions.compilerArgumentProvider, come mostrato di seguito.
Kotlin
// 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")))
}
}
}
}
Groovy
// 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"))
}
}
}
}
Per scoprire di più su come l'implementazione di CommandLineArgumentProvider contribuisce a migliorare il rendimento della compilazione, leggi Caching Java projects.
Disattivare il controllo degli errori del processore di annotazioni
Se nel classpath di compilazione sono presenti dipendenze che includono elaboratori di annotazioni non necessari, puoi disattivare il controllo degli errori aggiungendo quanto segue al file build.gradle.kts. Tieni presente che i processori di annotazioni aggiunti al classpath di compilazione non vengono ancora aggiunti al classpath del processore.
Kotlin
android {
...
defaultConfig {
...
javaCompileOptions {
annotationProcessorOptions {
argument("includeCompileClasspath", "false")
}
}
}
}
Groovy
android {
...
defaultConfig {
...
javaCompileOptions {
annotationProcessorOptions {
includeCompileClasspath false
}
}
}
}
Se utilizzi Kotlin e kapt:
Kotlin
android {
...
defaultConfig {
...
kapt {
includeCompileClasspath = false
}
}
}
Groovy
android {
...
defaultConfig {
...
kapt {
includeCompileClasspath false
}
}
}
Se riscontri problemi dopo la migrazione dei processori di annotazione del progetto al percorso di classe del processore, puoi consentire i processori di annotazione nel percorso di compilazione impostando includeCompileClasspath su true. Tuttavia, l'impostazione di questa proprietà su true non è consigliata e l'opzione verrà rimossa in un aggiornamento futuro del plug-in per Android.