Ho appena iniziato a utilizzare lo sviluppo Android e provare a utilizzare la libreria Room. Da ieri sto affrontando questo messaggio di avvertimento

w: [kapt] Elaborazione annotazione incrementale richiesta, ma il supporto è disabilitato perché i seguenti processori non sono incrementali: androidx.lifecycle.LifecycleProcessor (NON_INCREMENTAL), androidx.room.RoomProcessor (NON_INCREMENTAL).

Ho provato a cercare e correggere ma non riesco a evitare questo errore qui è il mio file grale.build. per favore, suggerisci / consiglio cosa sto facendo di sbagliato.

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

C'è un bug nella versione di kotlin-gradle-plugin di 1.3.50 come menzionato da @Necrontyr. Esegui il downgrade di kotlin_version in build.gradle (Progetto) a 1.3.41.

Aggiungi questa riga a te gradle.properties:

kapt.incremental.apt=true

Il vero problema è che l'elaborazione incrementale rende le cose più veloci, ma se uno qualsiasi dei processori di annotazione non è incrementale, nessuno di questi verrà effettivamente elaborato in quel modo.

Qual è lo scopo dell'elaborazione incrementale?

Dalla versione 1.3.30+ , l'elaborazione incrementale ha permesso di non rielaborare completamente i moduli ogni volta che si verifica una modifica, offrendo al processo di generazione prestazioni migliori:

Le principali aree di interesse di questa versione sono state le prestazioni di Kotlin / Native, KAPT e i miglioramenti di IntelliJ IDEA.

Dalla documentazione di Kotlin :

I processori di annotazione (vedi JSR 269) sono supportati in Kotlin con il plugin del compilatore kapt. In poche parole, puoi usare librerie come Dagger o Data Binding nei tuoi progetti Kotlin.

Come risolvere l'elaborazione incrementale della stanza?

E il processore di annotazione incrementale della stanza è disabilitato per impostazione predefinita. Questo è un problema noto ed è descritto qui . Intendono risolverlo sulla versione 2.2.0. Puoi semplicemente attendere l'aggiornamento o puoi abilitarlo per eliminare l'avviso impostando:

nel file gradle.properties :

kapt.incremental.apt=true

(passaggi opzionali)

per consentire che la banca dati sia incrementale:

android.databinding.incremental=true

per build più veloci:

kapt.use.worker.api=true

se vengono apportate solo alcune modifiche, il tempo di costruzione diminuisce notevolmente:

kapt.include.compile.classpath=false

(torna all'argomento)

nel progetto build.gradle , aggiungi le dipendenze necessarie (Groovy):

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

e

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

Versione DSL di Kotlin:

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

e

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

Modificare:

9 ottobre 2019

androidx.room:room-*:2.2.0 è stato rilasciato .

Processore di annotazione incrementale Gradle: Room è ora un processore di annotazione con isolamento Gradle e la incrementabilità può essere abilitata tramite l'opzione del processore room.incremental.

Dalla documentazione della camera :

"Room ha le seguenti opzioni del processore di annotazione ... room.incremental: abilita il promotore di annotazione incrementale Gradle."

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

Assicurati di aggiornare la versione della stanza a 2.2.xo successive.

Ecco un elenco di cose che puoi fare per risolvere questo problema e ridurre significativamente i tempi di compilazione mentre ci sei.

Nel tuo build.gradlefile (modulo):

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

Nel tuo gradle.propertiesfile:

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 

Abilita richiesta di elaborazione annotazione incrementale Kapt

Usa Kotlin 1.3.31 o Kotlin 1.3.30 più recente rilasciato

Nel file gradle.properties del progetto 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

Molte delle altre risposte qui coprono l'errore o disabilitano l'elaborazione incrementale invece di farlo effettivamente funzionare nel modo desiderato.

È possibile abilitare l'elaborazione incrementale per la libreria specifica nel gradle.propertiesfile. Basta aggiungere queste impostazioni, o qualunque corrisponda alla libreria che genera l'errore:

android.databinding.incremental=true
android.lifecycleProcessor.incremental=true

Se si lamenta che "È richiesta l'elaborazione incrementale delle annotazioni, ma il supporto è disabilitato perché i seguenti processori non sono incrementali", impostare "kapt.incremental.apt" su "true" (indicato in una risposta diversa) in gradle.properties è contro- intuitivo. Devi impostarlo su "false". Che ha fatto per me.

Sto usando AndroidX , ma suppongo sia lo stesso per android.arch.lifecycle. Per me ha semplicemente aiutato a sostituire questo:

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

... con questo:

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

Quindi, se lo stai usando android.arch.lifecycle, potrebbe avere lo stesso effetto sostituendolo:

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

... con questo:

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

Ricorda che questo funziona solo se stai usando Java 8 e che dovresti anche rimuovere le OnLifecycleEventannotazioni per le LifecycleObserverclassi e lasciare DefaultLifecycleObserverinvece implementare quegli osservatori .

La modifica a questo metodo è consigliata anche nelle build.gradledipendenze mostrate qui .

Quello che dovresti davvero fare è implementare queste righe di codice nel tuo buildConfigtag nella tua build.gradleapp del modulo:

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

Risposte di cui sopra possono essere utili, ma quello che mi ha aiutato è la riduzione del kotlin_versionin build.gradle(Project)a1.3.41 e costruzione del progetto. Questo ti permetterà di vedere se c'è qualche problema con il tuo modello di entità.

Il mio era, mi sono dimenticato di annotare @PrimaryKey. Il tuo potrebbe essere qualcosa di diverso. Kotlin 1.3.41permette di vedere quei problemi. Risolvi questi problemi e ripristina il tuo kotlin_versionprecedente.

Ciò può anche essere causato da problemi di carattere come " © " sul lato del database quando la lingua del sistema è una lingua non inglese. In tal caso, l'utilizzo della lingua del sistema informatico in inglese risolverà il problema.