web-dev-qa-db-fra.com

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

Je viens de commencer à utiliser Android et à essayer d'utiliser la bibliothèque de salle. Depuis hier, je suis confronté à 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'
}
androidandroid-roomandroid-lifecycle
127
Shax

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

79
Mücahit Kambur

Ajoutez simplement cette ligne à gradle.properties:

kapt.incremental.apt=true
151
Ali Ahmed

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 version 1.3.30 + , le traitement incrémentiel a permis aux modules de ne pas être entièrement traités à nouveau chaque fois qu'un changement se produit, donnant au processus de construction de meilleures performances:

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

De documentation Kotlin :

Les processeurs d'annotation (voir JSR 269) sont pris en charge dans Kotlin avec le plugin de compilation 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'annotation incrémentielle de Room est désactivé par défaut. C'est 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 vous débarrasser de l'avertissement en définissant:

dans gradle.properties fichier:

kapt.incremental.apt=true

(étapes facultatives)

pour permettre à databinding d'être incrémentiel:

Android.databinding.incremental=true

pour des builds 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 de 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")
            }
        }
    } 
}

Modifier:

9 octobre 2019

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

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

94
Dimas Mendes

De Documentation de la salle :

"Room a les options de processeur d'annotation suivantes ... room.incremental: Active le processeur d'annotation incrémentiel 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 à 2.2.x ou supérieure.

27
Alberto Gaona

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 fichier build.gradle (Module):

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

Dans votre fichier gradle.properties:

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
18
smdufb

Beaucoup d'autres réponses 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.properties fichier. 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
9
Jacques.S

Activer la demande de traitement d'annotations incrémentielles Kapt

Utilisez Kotlin 1.3.31 ou plus récent Kotlin 1.3.30 est sorti

Dans votre fichier Android kotlin project gradle.properties

# 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
9
Shomu

S'il se plaint que "le traitement d'annotation incrémentiel 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". Ça l'a fait pour moi.

5
D. C. Christopher

Ce que vous devez vraiment faire est d'implémenter ces lignes de code dans votre balise buildConfig dans votre build.gradle, module d'application:

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

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 utilisez Android.Arch.lifecycle cela pourrait 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 OnLifecycleEvent annotations pour LifecycleObserver classes et laissez ces observateurs implémenter DefaultLifecycleObserver à la place.

Le passage à cette méthode est également recommandé dans le build.gradle dépendances affichées ici .

2
Anigif

Cela peut également être dû à des problèmes de caractères tels que "İ" du côté databinding 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.

0
Hasan Kucuk