Aggiungi processori di annotazioni

Questa pagina include indicazioni dettagliate su come aggiungere e configurare l'annotazione processori come dipendenze del progetto. Per scoprire di più sui processori di annotazione, vedi la voce in Configura le dipendenze.

Se aggiungi processori di annotazione 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 tua 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")
}

Alla moda

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 è più disponibile supporta Plug-in android-apt.

Passa argomenti ai processori di annotazione

Se devi passare argomenti a un processore di annotazioni, puoi farlo utilizzando AnnotationProcessorOptions nella configurazione della build del tuo modulo. Ad esempio, se vuoi passare tipi di dati primitivi come coppie chiave/valore, puoi usare la proprietà argument, come mostrato di seguito:

Kotlin

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

Alla moda

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

Tuttavia, quando si utilizza il plug-in Android per Gradle 3.2.0 e versioni successive, è necessario passare argomenti del processore che rappresentano file o directory utilizzando l'interfaccia CommandLineArgumentProvider.

L'utilizzo di CommandLineArgumentProvider consente a te o del processore di annotazioni per migliorare la correttezza e le prestazioni build pulite incrementali e memorizzate nella cache applicando il tipo di proprietà della build incrementale annotazioni a ogni 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 {...}

Alla moda

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 per creare un'istanza e passarla al plug-in Android utilizzando 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")))
            }
        }
    }
}

Alla moda

// 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 può essere utile per migliorare le prestazioni delle build, Memorizzazione nella cache dei progetti Java.

Disattiva il controllo degli errori del processore delle annotazioni

Se hai dipendenze nel classpath di compilazione che includono l'annotazione non necessari, puoi disattivare il controllo degli errori aggiungendo quanto segue al tuo file build.gradle.kts. Tieni presente che l'annotazione processori aggiunti al classpath di compilazione non vengono comunque aggiunti di Compute Engine.

Kotlin

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

Alla moda

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

Se usi Kotlin e kapt:

Kotlin

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

Alla moda

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

Se riscontri problemi dopo aver eseguito la migrazione dei processori di annotazione del progetto a del processore classpath, puoi consentire i processori di annotazione nella compilazione classpath impostando includeCompileClasspath su true. Tuttavia, l'impostazione di a true non è consigliato e l'opzione per farlo verrà rimossa in un aggiornamento futuro del plug-in per Android.