Ich habe gerade mit der Android-Entwicklung begonnen und versucht, die Room-Bibliothek zu verwenden. Seit gestern stehe ich vor dieser Warnmeldung

w: [kapt] Inkrementelle Anmerkungsverarbeitung angefordert, aber Unterstützung ist deaktiviert, da die folgenden Prozessoren nicht inkrementell sind: androidx.lifecycle.LifecycleProcessor (NON_INCREMENTAL), androidx.room.RoomProcessor (NON_INCREMENTAL).

Ich habe versucht, diesen Fehler zu recherchieren und zu beheben, konnte ihn aber nicht vermeiden. Hier ist meine grale.build-Datei. bitte vorschlagen/raten, was ich falsch mache.

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

Fügen Sie einfach diese Zeile zu Ihrer gradle.properties hinzu:

kapt.incremental.apt=true

Das eigentliche Problem besteht darin, dass die inkrementelle Verarbeitung die Dinge schneller macht, aber wenn einer der Anmerkungsprozessoren nicht inkrementell ist, wird keiner von ihnen tatsächlich auf diese Weise verarbeitet.

Was ist der Zweck der inkrementellen Verarbeitung?

Aus Ausführung 1.3.30+ermöglichte die inkrementelle Verarbeitung, dass Module nicht bei jeder Änderung erneut vollständig verarbeitet wurden, was dem Build-Prozess eine bessere Leistung verlieh:

Die Hauptschwerpunkte dieser Version waren Kotlin/Native, KAPT-Leistung sowie Verbesserungen für IntelliJ IDEA.

Aus Kotlin-Dokumentation:

Anmerkungsprozessoren (siehe JSR 269) werden in Kotlin mit dem kapt-Compiler-Plugin unterstützt. Kurz gesagt, Sie können Bibliotheken wie Dagger oder Data Binding in Ihren Kotlin-Projekten verwenden.

Wie behebt man die inkrementelle Raumverarbeitung?

Room Incremental Annotation Processor ist behindert standardmäßig. Dies ist ein bekanntes Problem und es wird beschrieben hier. Sie beabsichtigen, es in Version 2.2.0 zu beheben. Sie können einfach auf das Update warten oder es aktivieren, um die Warnung zu beseitigen, indem Sie Folgendes einstellen:

in gradle.properties Datei:

kapt.incremental.apt=true

(optionale Schritte)

erlauben Datenbindung inkrementell sein:

android.databinding.incremental=true

für schnellere Builds:

kapt.use.worker.api=true

Wenn nur wenige Änderungen vorgenommen werden, verkürzt sich die Bauzeit erheblich:

kapt.include.compile.classpath=false

(zurück zum thema)

in Ihrem Projekt build.gradlefügen Sie die notwendigen Abhängigkeiten hinzu (Groovy):

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

und

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

Kotlin DSL-Version:

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

und

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

9. Oktober 2019

androidx.room:room-*:2.2.0 es ist veröffentlicht worden.

Gradle Incremental Annotation Processor: Room ist jetzt ein isolierender Gradle-Annotationsprozessor, und die Inkrementierbarkeit kann über die Prozessoroption room.incremental aktiviert werden.

Neuestes Update:

Für die neuesten Kotlin DSL-Versionen verwenden Sie bitte

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

Es gibt einen Fehler in der kotlin-gradle-plugin-Version von 1.3.50, wie @Necrontyr erwähnt hat. Führen Sie einfach ein Downgrade der kotlin_version in build.gradle(Project) auf 1.3.41 durch.

Aus Raumdokumentation:

“Room verfügt über die folgenden Anmerkungsprozessoroptionen … room.incremental: Aktiviert den inkrementellen Anmerkungsprozessor von Gradle.”

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

Stellen Sie sicher, dass Sie die Raumversion auf 2.2.x oder höher aktualisieren.

Aktivieren Sie Kapt Incremental Annotation Processing Requeste

Verwenden Sie Kotlin 1.3.31 oder neuer Kotlin 1.3.30 veröffentlicht

In Ihrer Android-Kotlin-Projektdatei 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

Hier ist eine Liste von Dingen, die Sie tun können, um dies zu beheben und Ihre Build-Zeiten erheblich zu verkürzen, während Sie gerade dabei sind.

In deiner build.gradle (Modul-)Datei:

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

In deiner gradle.properties Datei:

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 

Viele der anderen Antworten hier vertuschen den Fehler oder deaktivieren die inkrementelle Verarbeitung, anstatt sie tatsächlich so funktionieren zu lassen, wie Sie es möchten.

Sie können die inkrementelle Verarbeitung für Ihre spezifische Bibliothek in aktivieren gradle.properties Datei. Fügen Sie einfach diese Einstellungen hinzu oder diejenige, die der Bibliothek entspricht, die den Fehler auslöst:

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