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'
}

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.

Ajoutez simplement cette ligne à votre gradle.properties:

kapt.incremental.apt=true

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.

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.

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 

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

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

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.

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 .

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"]
            }
        }

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.

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.