Właśnie zacząłem używać programowania na Androida i próbować korzystać z biblioteki Room. Od wczoraj mam do czynienia z tym ostrzeżeniem

w: [kapt] Zażądano przyrostowego przetwarzania adnotacji, ale obsługa jest wyłączona, ponieważ następujące procesory nie są przyrostowe: androidx.lifecycle.LifecycleProcessor (NON_INCREMENTAL), androidx.room.RoomProcessor (NON_INCREMENTAL).

Próbowałem zbadać i naprawić, ale nie mogę uniknąć tego błędu. Oto mój plik grale.build. proszę zasugerować / doradzić, co robię źle.

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

Jest błąd w wersji kotlin-gradle-plugin 1.3.50, o czym wspomniał @Necrontyr. Po prostu obniż wersję kotlin_version w build.gradle (projekt) do 1.3.41.

Po prostu dodaj tę linię do gradle.properties:

kapt.incremental.apt=true

Prawdziwym problemem jest to, że przetwarzanie przyrostowe przyspiesza pracę, ale jeśli którykolwiek z procesorów adnotacji nie jest przyrostowy, żaden z nich nie będzie przetwarzany w ten sposób.

Jaki jest cel przetwarzania przyrostowego?

Począwszy od wersji 1.3.30+ , przetwarzanie przyrostowe pozwalało modułom nie być ponownie przetwarzane w całości za każdym razem, gdy nastąpiła zmiana, co zapewniało lepszą wydajność procesu kompilacji:

Główne obszary zainteresowania w tym wydaniu to Kotlin / Native, wydajność KAPT, a także ulepszenia dla IntelliJ IDEA.

Z dokumentacji Kotlin :

Procesory adnotacji (patrz JSR 269) są obsługiwane w Kotlin przez wtyczkę kompilatora kapt. Krótko mówiąc, w projektach Kotlin możesz korzystać z bibliotek, takich jak Dagger lub Data Binding.

Jak naprawić przyrostowe przetwarzanie pokoju?

Procesor przyrostowych adnotacji pomieszczenia jest domyślnie wyłączony . To znany problem i został opisany tutaj . Zamierzają to naprawić w wersji 2.2.0. Możesz po prostu poczekać na aktualizację lub włączyć tę opcję, aby pozbyć się ostrzeżenia, ustawiając:

w pliku gradle.properties :

kapt.incremental.apt=true

(opcjonalne kroki)

aby umożliwić przyrostowe powiązanie danych:

android.databinding.incremental=true

dla szybszych kompilacji:

kapt.use.worker.api=true

jeśli wprowadzisz tylko kilka zmian, czas kompilacji znacznie się skróci:

kapt.include.compile.classpath=false

(wróć do tematu)

w swoim projekcie build.gradle dodaj niezbędne zależności (Groovy):

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

i

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

Wersja Kotlin DSL:

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

i

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

Edytować:

9 października 2019 r

Androidx.room:room-*:2.2.0 zostaje wydany .

Gradle Incremental Annotation Processor: Pokój jest teraz izolowanym procesorem adnotacji Gradle, a zwiększanie możliwości można włączyć za pomocą opcji procesora room.incremental.

Z dokumentacji pokoju :

„Room ma następujące opcje procesora adnotacji ... room.incremental: Włącza przyrostowy proces adnotacji Gradle”.

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

Pamiętaj, aby zaktualizować wersję pokoju do wersji 2.2.x lub nowszej.

Oto lista rzeczy, które możesz zrobić, aby to naprawić i znacznie skrócić czas kompilacji, gdy jesteś na tym.

W build.gradlepliku (modułu):

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

W Twoim gradle.propertiespliku:

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 

Włącz żądanie przetwarzania przyrostowych adnotacji Kapt

Użyj Kotlin 1.3.31 lub nowszej wersji Kotlin 1.3.30 wydanej

W pliku gradle.properties projektu kotlin systemu Android

# 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

Wiele innych odpowiedzi tutaj ukrywa błąd lub wyłącza przetwarzanie przyrostowe, zamiast faktycznie działać tak, jak chcesz.

Możesz włączyć przetwarzanie przyrostowe dla określonej biblioteki w gradle.propertiespliku. Po prostu dodaj te ustawienia lub którekolwiek z nich pasuje do biblioteki, która zgłasza błąd:

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

Jeśli narzeka, że ​​„Żądano przyrostowego przetwarzania adnotacji, ale obsługa jest wyłączona, ponieważ następujące procesory nie są przyrostowe”, ustawienie „kapt.incremental.apt” na „true” (wspomniane w innej odpowiedzi) w gradle.properties jest przeciwne intuicyjny. Musisz ustawić to na „false”. Zrobiło to dla mnie.

Używam AndroidX , ale myślę, że to to samo dla android.arch.lifecycle. U mnie to po prostu pomogło zastąpić to:

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

... z tym:

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

Więc jeśli android.arch.lifecyclego używasz , może mieć ten sam efekt, zastępując to:

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

... z tym:

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

Należy pamiętać, że działa to tylko wtedy, gdy używasz Javy 8 i że powinieneś również usunąć OnLifecycleEventadnotacje dla LifecycleObserverklas i pozwolić tym obserwatorom na implementację DefaultLifecycleObserver.

Zmiana na tę metodę jest również zalecana w build.gradleprzedstawionych tutaj zależnościach .

To, co naprawdę powinieneś zrobić, to zaimplementować następujące wiersze kodu w swoim buildConfigtagu w build.gradleaplikacji modułu:

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

Powyższe odpowiedzi mogą być przydatne, ale to, co pomogło mi to redukuje się kotlin_versionw build.gradle(Project)celu 1.3.41i budowania projektu. Umożliwi to sprawdzenie, czy istnieje jakiś problem z modelem jednostki.

Mój był, zapomniałem dodać adnotacji @PrimaryKey. Twoja może być inna. Kotlin 1.3.41pozwala zobaczyć te kwestie. Napraw te problemy i wróć kotlin_versiondo poprzedniego.

Może to być również spowodowane problemami ze znakami, takimi jak „ İ ” po stronie wiązania danych, gdy język systemu nie jest językiem angielskim. W takim przypadku użycie języka systemu komputerowego w języku angielskim rozwiąże problem.