Comment se débarrasser du traitement d'annotations incrémentielles demandé l'avertissement?

150

Je viens de commencer à utiliser le développement Android et à essayer d'utiliser la bibliothèque Room. Depuis hier je suis face à ce message d'avertissement

w: [kapt] Traitement d'annotation incrémentiel demandé, mais la prise en charge est désactivée car les processeurs suivants ne sont pas incrémentiels: androidx.lifecycle.LifecycleProcessor (NON_INCREMENTAL), androidx.room.RoomProcessor (NON_INCREMENTAL).

J'ai essayé de rechercher et de corriger mais je n'ai pas pu éviter cette erreur, voici mon fichier grale.build. Veuillez suggérer / conseiller ce que je fais mal.

apply plugin: 'com.android.application'

apply plugin: 'kotlin-android'

apply plugin: 'kotlin-android-extensions'

apply plugin: 'kotlin-kapt'

android {
    compileSdkVersion 29
    buildToolsVersion "29.0.2"
    defaultConfig {
        applicationId "ps.room.bookkeeper"
        minSdkVersion 15
        targetSdkVersion 29
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        javaCompileOptions {
            annotationProcessorOptions {
                arguments = ["room.schemaLocation":"$projectDir/schemas".toString()]
            }
        }    
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
    implementation 'androidx.appcompat:appcompat:1.0.2'
    implementation 'androidx.core:core-ktx:1.0.2'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    implementation 'com.google.android.material:material:1.0.0'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test:runner:1.2.0'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'

    // life cycle dependencies
    def lifecycle_version = "2.0.0"
    implementation "android.arch.lifecycle:extensions:$lifecycle_version"
    kapt "android.arch.lifecycle:compiler:$lifecycle_version"

    //Room dependencies
    //def room_version = "2.1.0"
    implementation 'android.arch.persistence.room:runtime:2.1.0'
    kapt 'android.arch.persistence.room:compiler:2.1.0'
    //annotationProcessor 'android.arch.persistence.room:compiler:2.1.0'

//    implementation "android.arch.lifecycle:extensions:$room_version"
//    kapt "android.arch.persistence.room:compiler:$room_version"
//    androidTestImplementation "android.arch.persistence.room:testing:$room_version"

    //implementation 'androidx.room:room-runtime:2.1.0'
    //annotationProcessor 'androidx.room:room-compiler:2.1.0'
}
Shax
la source
pourquoi votre annotationProcessor est-il commenté? Avez-vous essayé de les décommenter, puis de créer un projet? (pour la pièce et le cycle de vie)
Ferhat Ergün
1
essayez d'ajouter android.enableSeparateAnnotationProcessing = true dans votre gradle.properities reddit.com/r/androiddev/comments/ai92pt/… trouvé à ce sujet, cela pourrait être lié à votre problème
Ferhat Ergün
7
Vous pouvez rétrograder kotlin-gradle-plugin dans le fichier build.gradle de votre projet à la version 1.3.41 pour le moment. Je pense que c'est un bug lié à kapt. Plus d'infos: youtrack.jetbrains.com/issue/KT-33515
Necrontyr
5
Vous pouvez également créer un fichier gradle.properties dans libs / <nom de votre module> kapt.incremental.apt=falsecomme décrit dans le problème comme solution de contournement. Cela a fonctionné pour moi.
Necrontyr
2
@Necrontyr, votre suggestion a vraiment fonctionné. Merci beaucoup
Shax

Réponses:

80

Il y a un bogue dans la version 1.3.50 de kotlin-gradle-plugin comme @Necrontyr l'a mentionné. Il suffit de rétrograder la version kotlin_version dans build.gradle (Projet) vers 1.3.41.

Mücahid Kambur
la source
71
Le bogue mentionné par @Necrontyr n'est pas lié à l'avertissement. L'avertissement est en fait prévu et descendre à 1.3.41 masque simplement l'avertissement mais le problème reste le même, sinon pire. Les gens pourraient penser que, parce qu'ils ont activé le traitement des annotations incrémentielles, cela accélérera les choses. Mais la vérité est que si l'un des processeurs d'annotation n'est pas incrémentiel, aucun d'entre eux ne sera traité de manière incrémentielle. Ceci est un rappel amical qui indiquera quelle bibliothèque est le coupable.
Antimonit le
15
L'utilisation d'une version de bibliothèque obsolète n'est pas une solution.
Andrew Koster
5
Est-ce toujours le cas avec Kotlin 1.3.70?
IgorGanapolsky
2
J'utilise Kotlin 1.3.72 et je suis toujours confronté à ce problème?
Anbuselvan Rocky
4
Je suis également confronté à ce problème 1.3.72 des gars de solution?
hiashutoshsingh
174

Ajoutez simplement cette ligne à votre gradle.properties:

kapt.incremental.apt=true
Ali Ahmed
la source
11
C'est une meilleure option que la réponse acceptée. Pour ceux qui ont besoin de comprendre et d'entrer dans plus de détails, reportez-vous à ce lien: medium.com/avast-engineering/…
Abhimanyu
4
raté pour moi aussi.
steven smith
est-ce que quelqu'un est la raison pour laquelle cela se passe ici?
Omer
J'ai récemment activé la liaison de données à mon projet Android (kotlin) et j'ai commencé à recevoir cet avertissement. L'ajout de la propriété comme indiqué ci-dessus a fonctionné pour moi. En utilisant également les dernières versions de tout, par exemple toutes les dépendances, compilateurs, outils de construction, SDK, etc.
Gail
4
Faire juste cela n'a pas fonctionné pour moi. J'ai dû également éditer mon fichier build.gradle comme décrit dans la documentation de la bibliothèque Room .
Nelson Ferragut
121

Le vrai problème est que le traitement incrémentiel accélère les choses, mais si l'un des processeurs d'annotation n'est pas incrémentiel, aucun d'entre eux ne sera réellement traité de cette manière.

Quel est le but du traitement incrémentiel?

À partir de la version 1.3.30+ , le traitement incrémentiel permettait aux modules de ne pas être entièrement traités à nouveau à chaque fois qu'un changement se produisait, donnant au processus de construction de meilleures performances:

Les principaux domaines d'intérêt de cette version ont été autour de Kotlin / Native, des performances de KAPT, ainsi que des améliorations pour IntelliJ IDEA.

À partir de la documentation Kotlin :

Les processeurs d'annotation (voir JSR 269) sont pris en charge dans Kotlin avec le plugin de compilateur kapt. En un mot, vous pouvez utiliser des bibliothèques telles que Dagger ou Data Binding dans vos projets Kotlin.

Comment réparer le traitement incrémentiel de la pièce?

Et le processeur d'annotations incrémentielles de pièce est désactivé par défaut. Il s'agit d'un problème connu et il est décrit ici . Ils ont l'intention de le corriger sur la version 2.2.0. Vous pouvez simplement attendre la mise à jour ou l'activer pour éliminer l'avertissement en définissant:

dans le fichier gradle.properties :

kapt.incremental.apt=true

(étapes facultatives)

pour permettre à la liaison de données d'être incrémentielle:

android.databinding.incremental=true

pour des constructions plus rapides:

kapt.use.worker.api=true

si seulement quelques modifications sont apportées, le temps de construction diminue considérablement:

kapt.include.compile.classpath=false

(retour au sujet)

dans votre projet build.gradle , ajoutez les dépendances nécessaires (Groovy):

dependencies {
    ...
    implementation "androidx.room:room-runtime:2.2.0-rc01"
    annotationProcessor "androidx.room:room-compiler:2.2.0-rc01"
}

et

android {
    ...
    defaultConfig {
        ...
        javaCompileOptions {
            annotationProcessorOptions {
                arguments = ["room.incremental":"true"]
            }
        }
    }
}

Version DSL Kotlin:

dependencies {
    ...
    implementation("androidx.room:room-runtime:2.2.0-rc01")
    kapt("androidx.room:room-compiler:2.2.0-rc01")
}

et

android {
    ...
    defaultConfig {
        ...
        javaCompileOptions {
            annotationProcessorOptions {
                arguments = mapOf("room.incremental" to "true")
            }
        }
    } 
}

Éditer:

9 octobre 2019

androidx.room:room-*:2.2.0 est publié .

Processeur d'annotations incrémentales Gradle: Room est désormais un processeur d'annotations isolant Gradle et l'incrémentabilité peut être activée via l'option de processeur room.incremental.

Dimas Mendes
la source
8
Celui-ci doit être accepté comme kapt.incremental.apt = true est quelque chose qui manquera lors de l'inclusion de Room dans votre projet. Celui-ci n'est même pas mentionné dans la documentation Android pour Room
sela
1
Cette réponse m'a aidé car j'utilisais androidx.lifecycle:lifecycle-extensionsdans la version 2.1.0 et après le passage à 2.2.0-beta01, l'avertissement a disparu!
simne7
2
@ simne7 vérifie ma modification à la fin. la version 2.2.0 est publiée =) vous pouvez déjà la mettre à niveau pour accéder à la fonctionnalité de traitement incrémentiel et booster votre build.
Dimas Mendes
L'activation le android.buildcache=truerendrait-il plus rapide?
IgorGanapolsky
1
@IgorGanapolsky selon Google Developers site, Projects using Android plugin 2.3.0 and higher enable the build cache by default (unless you explicitly disable the build cache). Cela n'a donc pas de sens de l'activer car il est activé par défaut.
Dimas Mendes
37

De documentation de la salle :

"Room a les options de processeur d'annotation suivantes ... room.incremental: Active le processeur d'annotation incrémentielle Gradle."

android {
    ...
    defaultConfig {
        ...
        javaCompileOptions {
            annotationProcessorOptions {
                arguments = [
                    "room.schemaLocation":"$projectDir/schemas".toString(),
                    "room.incremental":"true",
                    "room.expandProjection":"true"]
            }
        }
    }
}

Assurez-vous de mettre à jour la version de la salle vers 2.2.x ou supérieur.

Alberto Gaona
la source
3
Corrigez les réponses aux personnes, si vous souhaitez conserver un traitement incrémentiel. Vous n'aurez peut-être pas besoin des arguments schemaLocation ou expandProjection définis ci-dessus. chambre.incrémental suffit.
bajicdusko
1
Selon developer.android.com/jetpack/androidx/releases/room , il existe toujours la version 2.2.0-rc01.
CoolMind
1
sa sortie maintenant -> developer.android.com/jetpack/androidx/releases/…
jesses.co.tt
Mettez à jour la version de la salle à 2.2.0 cela a fonctionné pour moi
DivideBy0
25

Voici une liste de choses que vous pouvez faire pour résoudre ce problème et réduire considérablement vos temps de construction pendant que vous y êtes.

Dans votre build.gradlefichier (module):

android {
    ...
    defaultConfig {
        ...
        kapt {
            arguments {
                 arg("room.schemaLocation", "$projectDir/schemas".toString())
                 arg("room.incremental", "true")
                 arg("room.expandProjection", "true")
            }
        }
    }
    ...
}

Dans votre gradle.propertiesdossier:

kapt.incremental.apt=true            // enabled by default on 1.3.50+
kapt.use.worker.api=true             // faster builds
kapt.include.compile.classpath=false // near instant builds when there are few changes

android.databinding.incremental=true
android.lifecycleProcessor.incremental=true
//add your specific library if it supports incremental kapt 
smdufb
la source
18

Activer le traitement des annotations incrémentielles Kapt demandé

Utilisez Kotlin 1.3.31 ou plus récent Kotlin 1.3.30 publié

Dans votre fichier gradle.properties de projet android kotlin

# Enable Kapt Incremental annotation processing requeste
kapt.incremental.apt=true

# Enable android.databinding.annotationprocessor.ProcessDataBinding (DYNAMIC)
android.databinding.incremental=true

# Decrease gradle builds time 
kapt.use.worker.api=true

# turn off AP discovery in compile path, and therefore turn on Compile Avoidance
kapt.include.compile.classpath=false

# Enable In Logcat to determine Kapt
kapt.verbose=true
Shomu
la source
Et quoi android.lifecycleProcessor.incremental=true?
IgorGanapolsky
10

Beaucoup d'autres réponses ici couvrent l'erreur ou désactivent le traitement incrémentiel au lieu de le faire fonctionner comme vous le souhaitez.

Vous pouvez activer le traitement incrémentiel pour votre bibliothèque spécifique dans le gradle.propertiesfichier. Ajoutez simplement ces paramètres, ou celui qui correspond à la bibliothèque qui génère l'erreur:

android.databinding.incremental=true
android.lifecycleProcessor.incremental=true
Jacques.S
la source
2
Je n'en suis pas si sûr android.lifecycleProcessor.incremental=true, cela ne semble être documenté nulle part
Daniel Wilson
Je ne suis pas sûr non plus, mais je l'ai essayé sur une intuition et le compilateur a arrêté de me dire que la bibliothèque lifecycleProcessor n'avait pas le traitement incrémentiel activé.
Jacques.S
5

S'il se plaint que "le traitement d'annotation incrémentielle est demandé, mais que la prise en charge est désactivée car les processeurs suivants ne sont pas incrémentiels", alors définir "kapt.incremental.apt" sur "true" (mentionné dans une réponse différente) dans gradle.properties est contre- intuitif. Vous devez le définir sur "false". Cela l'a fait pour moi.

DC Christopher
la source
1
CECI a vraiment fonctionné. Définissez-le sur FALSE personnes! merci
Sakiboy
Et que va-t-il se passer? Compilera-t-il plus rapidement ou masquera-t-il simplement l'avertissement?
CoolMind
@CoolMind Vous désactiveriez le traitement des annotations incrémentielles, ce qui ne se produira de toute façon pas si l'une de vos dépendances ne le prend pas en charge. Donc, l'avertissement disparaît et il n'y a pas de changement dans le processus de construction par rapport à avant.
DC Christopher
2
Étonnamment, le réglage kapt.incremental.apt=falsem'a aidé, je ne reçois plus l'erreur
Rakhi Dhavale
2
Vous n'avez plus d'erreur mais maintenant vous n'avez plus de traitement incrémentiel :)
JustAnotherCoder
2

J'utilise AndroidX , mais je suppose que c'est la même chose pour android.arch.lifecycle. Pour moi, cela a simplement aidé à remplacer ceci:

kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"

... avec ça:

implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

Donc, si vous l'utilisez, android.arch.lifecyclecela peut avoir le même effet en remplaçant ceci:

kapt "android.arch.lifecycle:compiler:$lifecycle_version"

... avec ça:

implementation "android.arch.lifecycle:common-java8:$lifecycle_version"

Sachez que cela ne fonctionne que si vous utilisez Java 8 et que vous devez également supprimer les OnLifecycleEventannotations pour les LifecycleObserverclasses et laisser ces observateurs implémenter à la DefaultLifecycleObserverplace.

Le passage à cette méthode est également recommandé dans les build.gradledépendances présentées ici .

Anigif
la source
Pourquoi vous en débarrassez-vous kapt?
IgorGanapolsky
@IgorGanapolsky C'est ce qui est suggéré par le cycle de vie AndroidX si vous utilisez Java 8. Pour en savoir plus: developer.android.com/jetpack/androidx/releases/…
Anigif
kaptest essentiel pour Kotlin
IgorGanapolsky
1
Seulement si la lib le requiert. Selon cette page, les annotations seront obsolètes une fois que Java 8 sera plus courant sur Android, ils recommandent donc common-java8si possible: developer.android.com/reference/androidx/lifecycle/Lifecycle
Anigif
Intéressant. Ils ne mentionnent pas kapten particulier cependant ...
IgorGanapolsky
2

Ce que vous devez vraiment faire est d'implémenter ces lignes de code dans votre buildConfigbalise dans votre build.gradleapplication de module:

javaCompileOptions {
            annotationProcessorOptions {
                arguments = [
                        "room.schemaLocation"  : "$projectDir/schemas".toString(),
                        "room.incremental"     : "true",
                        "room.expandProjection": "true"]
            }
        }
coroutineDispatcher
la source
0

Réponses ci - dessus peuvent être utiles, mais ce qui m'a aidé réduit la kotlin_versiondans build.gradle(Project)à 1.3.41et la construction du projet. Cela vous permettra de voir s'il y a un problème avec votre modèle d'entité.

Le mien était, j'ai oublié d'annoter @PrimaryKey. Votre peut être quelque chose de différent. Kotlin 1.3.41permet de voir ces problèmes. Résolvez ces problèmes et revenez kotlin_versionau précédent.

Sourav Roy
la source
-1

Cela peut également être dû à des problèmes de caractères tels que « © » du côté de la liaison de données lorsque la langue du système n'est pas une langue anglaise. Dans un tel cas, l'utilisation de la langue du système informatique en anglais résoudra le problème.

Hasan Kucuk
la source