Questa pagina include indicazioni dettagliate su come aggiungere e configurare i processori di annotazione come dipendenze del progetto. Per saperne di più sui processori di annotazioni, consulta la voce in Configurare le dipendenze.
Se aggiungi processori di annotazioni al classpath di compilazione, vedrai un messaggio di errore simile al seguente:
Error: Annotation processors must be explicitly declared now.
Per risolvere questo errore, aggiungi processori di annotazione 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") }
trendy
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
.
Passa argomenti ai processori di annotazione
Se devi passare argomenti a un processore di annotazioni, puoi farlo utilizzando il blocco AnnotationProcessorOptions
nella configurazione di compilazione del modulo. Ad esempio, se vuoi trasferire
i 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") } } } }
trendy
android { ... defaultConfig { ... javaCompileOptions { annotationProcessorOptions { argument 'key1', 'value1' argument 'key2', 'value2' } } } }
Tuttavia, quando utilizzi il plug-in Android per Gradle 3.2.0 e versioni successive, devi passare gli argomenti del processore che rappresentano i file o le directory utilizzando l'interfaccia CommandLineArgumentProvider
di Gradle.
L'utilizzo di CommandLineArgumentProvider
consente a te o all'autore del processore di annotazione di migliorare la correttezza e le prestazioni delle build pulita incrementali e memorizzate nella cache applicando annotazioni del tipo di proprietà di build incrementale a ciascun argomento.
Ad esempio, la classe seguente 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 {...}
trendy
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"))) } } } }
trendy
// 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 le prestazioni della build, consulta Memorizzazione nella cache dei progetti Java.
Disattiva il controllo degli errori del processore di annotazioni
Se sul classpath di compilazione sono presenti dipendenze che includono processori di annotazione non necessari, puoi disabilitare il controllo degli errori aggiungendo quanto segue al file build.gradle.kts
. Tieni presente che i processori di annotazioni che aggiungi al classpath di compilazione non vengono ancora aggiunti al classpath del processore.
Kotlin
android { ... defaultConfig { ... javaCompileOptions { annotationProcessorOptions { argument("includeCompileClasspath", "false") } } } }
trendy
android { ... defaultConfig { ... javaCompileOptions { annotationProcessorOptions { includeCompileClasspath false } } } }
Se usi Kotlin e kapt:
Kotlin
android { ... defaultConfig { ... kapt { includeCompileClasspath = false } } }
trendy
android { ... defaultConfig { ... kapt { includeCompileClasspath false } } }
Se riscontri problemi dopo aver eseguito la migrazione dei processori di annotazione del tuo progetto al classpath del processore, puoi consentire i processori di annotazioni sul classpath di compilazione impostando includeCompileClasspath
su true
. Tuttavia, non è consigliabile impostare
questa proprietà su true
e l'opzione in tal senso verrà rimossa
in un futuro aggiornamento del plug-in Android.