Aggiungi processori di annotazioni

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.

Nota: in genere, gli autori del processore di annotazioni forniscono questa classe o istruzioni su come scrivere una classe di questo tipo. Questo perché ogni argomento deve specificare l'annotazione corretta per il tipo di proprietà build per poter funzionare come previsto.

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.