Ich habe gerade angefangen, Android-Entwicklung zu verwenden und zu versuchen, Raumbibliothek zu verwenden. Seit gestern stehe ich vor dieser Warnmeldung

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

Ich habe versucht zu recherchieren und zu beheben, aber ich kann diesen Fehler nicht vermeiden. Hier ist meine grale.build-Datei. Bitte schlagen Sie vor / beraten Sie, 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'
}

Es gibt einen Fehler in der Kotlin-Gradle-Plugin-Version von 1.3.50, wie @Necrontyr erwähnt. Downgraden Sie einfach die kotlin_version in build.gradle (Project) auf 1.3.41.

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

kapt.incremental.apt=true

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

Was ist der Zweck der inkrementellen Verarbeitung?

Ab Version 1.3.30+ konnten Module durch inkrementelle Verarbeitung nicht bei jeder Änderung erneut vollständig verarbeitet werden, wodurch der Erstellungsprozess eine bessere Leistung erhielt:

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

Aus der Kotlin-Dokumentation :

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

Wie kann ich die inkrementelle Raumverarbeitung beheben?

Der inkrementelle Raumanmerkungsprozessor ist standardmäßig deaktiviert . Dies ist ein bekanntes Problem, das hier beschrieben wird . Sie beabsichtigen, es auf Version 2.2.0 zu beheben. Sie können einfach auf das Update warten oder es aktivieren, um die Warnung zu entfernen, indem Sie Folgendes einstellen:

in der Datei gradle.properties :

kapt.incremental.apt=true

(optionale Schritte)

Damit die Datenbindung inkrementell sein kann:

android.databinding.incremental=true

für schnellere Builds:

kapt.use.worker.api=true

Wenn nur wenige Änderungen vorgenommen werden, verringert sich die Erstellungszeit erheblich:

kapt.include.compile.classpath=false

(zurück zum Thema)

Fügen Sie in Ihrem Projekt build.gradle die erforderlichen 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")
            }
        }
    } 
}

Bearbeiten:

9. Oktober 2019

androidx.room:room-*:2.2.0 wird veröffentlicht .

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

Aus der Raumdokumentation :

"Room verfügt über die folgenden Optionen für den Anmerkungsprozessor ... room.incremental: Aktiviert den inkrementellen Annotation-Annotation-Prozessor 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.

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

In Ihrer build.gradle(Modul-) Datei:

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

In Ihrer gradle.propertiesDatei:

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 

Aktivieren Sie die Anforderung zur Verarbeitung von inkrementellen Kapt-Anmerkungen

Verwenden Sie Kotlin 1.3.31 oder neuer Kotlin 1.3.30

In Ihrer Android Kotlin Projekt gradle.properties Datei

# 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

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

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

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

Wenn beschwert wird, dass "Inkrementelle Annotationsverarbeitung angefordert, aber die Unterstützung deaktiviert ist, weil die folgenden Prozessoren nicht inkrementell sind", ist das Setzen von "kapt.incremental.apt" auf "true" (in einer anderen Antwort erwähnt) in gradle.properties konter- intuitiv. Sie müssen es auf "false" setzen. Das hat es für mich getan.

Ich benutze AndroidX , aber es ist wohl das gleiche für android.arch.lifecycle. Für mich hat es einfach geholfen, dies zu ersetzen:

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

... mit diesem:

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

Wenn Sie es also verwenden android.arch.lifecycle, kann dies den gleichen Effekt haben:

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

... mit diesem:

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

Beachten Sie, dass dies nur funktioniert, wenn Sie Java 8 verwenden, und dass Sie auch OnLifecycleEventAnmerkungen für LifecycleObserverKlassen entfernen und diese Beobachter DefaultLifecycleObserverstattdessen implementieren lassen sollten .

Die Umstellung auf dieses Verfahren wird auch in den empfohlenen build.gradleDepencies gezeigt hier .

Was Sie wirklich tun sollten, ist, diese Codezeilen in Ihrem buildConfigTag in Ihrer build.gradleModul-App zu implementieren :

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

Oben Antworten kann nützlich sein, aber was hat mir geholfen , die Verringerung kotlin_versionin build.gradle(Project)zu 1.3.41und den Bau des Projekts. Auf diese Weise können Sie feststellen, ob ein Problem mit Ihrem Entitätsmodell vorliegt.

Meins war, ich habe vergessen zu kommentieren @PrimaryKey. Ihr mag etwas anderes sein. Kotlin 1.3.41erlaubt es, diese Probleme zu sehen. Beheben Sie diese Probleme und kehren Sie kotlin_versionzum vorherigen zurück.

Dies kann auch durch Zeichenprobleme wie " İ " auf der Datenbindungsseite verursacht werden, wenn die Systemsprache eine nicht englische Sprache ist. In einem solchen Fall wird das Problem durch die Verwendung der Computersystemsprache Englisch gelöst.