Jak pozbyć się ostrzeżenia o żądaniu przyrostowego przetwarzania adnotacji?


150

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

dlaczego twoja adnotacja jest skomentowana przez procesor? Czy próbowałeś odkomentować je, a następnie zbudować projekt? (zarówno dla pokoju, jak i cyklu życia)
Ferhat Ergün

1
spróbuj dodać android.enableSeparateAnnotationProcessing = true w swoim gradle.properities reddit.com/r/androiddev/comments/ai92pt/ ... znaleziony w tym miejscu może być związany z Twoim problemem
Ferhat Ergün

7
Na razie możesz obniżyć wersję kotlin-gradle-plugin w pliku build.gradle projektu do wersji 1.3.41. Myślę, że jest to błąd związany z kapt. Więcej informacji: youtrack.jetbrains.com/issue/KT-33515
Necrontyr Sierpnia

4
Możesz również utworzyć plik gradle.properties w libs / <nazwa modułu>, korzystając z rozwiązania kapt.incremental.apt=falseopisanego w problemie jako obejścia. U mnie to zadziałało.
Necrontyr

2
@Necrontyr, twoja sugestia naprawdę się sprawdziła.
Wielkie

Odpowiedzi:


80

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.


71
Błąd wspomniany przez @Necrontyr nie ma związku z ostrzeżeniem. Ostrzeżenie jest faktycznie zamierzone i zejście do 1.3.41 po prostu ukrywa ostrzeżenie, ale problem pozostaje taki sam, jeśli nie gorszy. Ludzie mogą pomyśleć, że ponieważ włączyli przyrostowe przetwarzanie adnotacji, przyspieszy to. Ale prawda jest taka, że ​​jeśli którykolwiek z procesorów adnotacji nie jest przyrostowy, żaden z nich nie będzie przetwarzany przyrostowo. To przyjazne przypomnienie, które wskaże, która biblioteka jest winowajcą.
Antimonit

15
Korzystanie z przestarzałej wersji biblioteki nie jest rozwiązaniem.
Andrew Koster

5
Czy nadal tak jest w przypadku Kotlina 1.3.70?
IgorGanapolsky

2
Używam Kotlin 1.3.72 i nadal mam ten problem?
Anbuselvan Rocky

4
Stoję też w obliczu tego problemu 1.3.72 jakieś rozwiązanie faceci?
hiashutoshsingh

174

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

kapt.incremental.apt=true

11
To lepsza opcja niż zaakceptowana odpowiedź. Dla tych, którzy chcą zrozumieć i uzyskać więcej szczegółów, skorzystaj z tego linku: medium.com/avast-engineering/ ...
Abhimanyu

4
mi też się nie udało.
steven smith

jest ktoś, jaki jest powód, dla którego to się tutaj dzieje?
Omer

Niedawno włączyłem powiązanie danych z moim projektem na Androida (kotlin) i zacząłem otrzymywać to ostrzeżenie. Dodanie nieruchomości, jak wspomniano powyżej, zadziałało dla mnie. Również używając najnowszych wersji wszystkiego, np. Wszystkich zależności, kompilatorów, narzędzi do budowania, SDK itp.
Gail

4
Zrobienie tego nie zadziałało dla mnie. Musiałem również edytować plik build.gradle zgodnie z opisem w dokumentacji biblioteki Room .
Nelson Ferragut

121

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.


8
Ten powinien zostać zaakceptowany jako kapt.incremental.apt = true to coś, czego będzie brakować podczas włączania Room do projektu. O tym nie ma nawet wzmianki w dokumentach Androida dla Pokoju
sela

1
Ta odpowiedź pomogła mi, ponieważ androidx.lifecycle:lifecycle-extensionsużywałem w wersji 2.1.0 i po przejściu na 2.2.0-beta01 ostrzeżenie zniknęło!
simne7

2
@ simne7 sprawdź na końcu moją edycję. Wersja 2.2.0 została wydana =) możesz ją już zaktualizować, aby uzyskać dostęp do funkcji przetwarzania przyrostowego i przyspieszyć kompilację.
Dimas Mendes

Czy włączenie android.buildcache=trueprzyspieszyłoby to?
IgorGanapolsky

1
@IgorGanapolsky według Google Developers Serwisu Projects using Android plugin 2.3.0 and higher enable the build cache by default (unless you explicitly disable the build cache). Dlatego nie ma sensu go włączać, ponieważ jest domyślnie włączony.
Dimas Mendes

37

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.


3
Poprawnie odpowiadaj ludziom, jeśli chcesz kontynuować przetwarzanie przyrostowe. Możesz nie potrzebować argumentów schemaLocation lub expandProjection ustawionych powyżej. pokój. zapasowy wystarczy.
bajicdusko

1
Według developer.android.com/jetpack/androidx/releases/room nadal istnieje wersja 2.2.0-rc01.
CoolMind


Zaktualizuj wersję pokoju do wersji 2.2.0, która działała dla mnie
DivideBy0

25

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 

18

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

O co chodzi android.lifecycleProcessor.incremental=true?
IgorGanapolsky

10

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

2
Nie jestem tego taki pewien android.lifecycleProcessor.incremental=true, wydaje się, że nie jest to nigdzie udokumentowane
Daniel Wilson,

Też nie jestem pewien, ale spróbowałem tego z pewnym przeczuciem i kompilator przestał mi mówić, że biblioteka lifecycleProcessor nie ma włączonego przetwarzania przyrostowego.
Jacques S.

5

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.


1
TO faktycznie zadziałało. Ustaw to na FALSE people! dzięki
Sakiboy

A co się stanie? Czy skompiluje się szybciej, czy po prostu ukryje ostrzeżenie?
CoolMind

@CoolMind Wyłączyłbyś przyrostowe przetwarzanie adnotacji, coś, co i tak się nie wydarzy, jeśli którakolwiek z twoich zależności tego nie obsługuje. Tak więc ostrzeżenie znika i nie ma zmian w procesie kompilacji od wcześniejszego.
DC Christopher,

2
O dziwo kapt.incremental.apt=falsepomogło mi ustawienie , już nie dostaję błędu
Rakhi Dhavale

2
Nie masz więcej błędów, ale teraz nie masz przyrostowego przetwarzania :)
JustAnotherCoder

2

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 .


Dlaczego się pozbywasz kapt?
IgorGanapolsky

@IgorGanapolsky To sugeruje cykl życia AndroidX, jeśli używasz Javy 8. Więcej informacji znajdziesz tutaj: developer.android.com/jetpack/androidx/releases/ ...
Anigif

kaptjest niezbędna dla Kotlina
IgorGanapolsky

1
Tylko jeśli biblioteka tego wymaga. Zgodnie z tą stroną adnotacje zostaną wycofane, gdy Java 8 stanie się bardziej popularna na Androidzie, więc common-java8jeśli to możliwe , zalecają : developer.android.com/reference/androidx/lifecycle/Lifecycle
Anigif

Ciekawy. kaptAle nie wspominają w szczególności ...
IgorGanapolsky

2

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"]
            }
        }

0

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.


-1

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.

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.