Como se livrar do aviso solicitado do processamento de anotação incremental?

150

Acabei de começar a usar o desenvolvimento Android e a tentar usar a biblioteca do Room. Desde ontem eu estou enfrentando esta mensagem de aviso

w: [kapt] O processamento de anotação incremental é solicitado, mas o suporte está desativado porque os seguintes processadores não são incrementais: androidx.lifecycle.LifecycleProcessor (NON_INCREMENTAL), androidx.room.RoomProcessor (NON_INCREMENTAL).

Eu tentei pesquisar e corrigir, mas não é possível evitar esse erro aqui é o meu arquivo grale.build. sugira / aconselhe o que estou fazendo de errado.

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'
}
Shax
fonte
por que seu processador de anotações é comentado? Você tentou descomentá-los e depois criar o projeto? (para sala e ciclo de vida)
Ferhat Ergün
1
tentar adicionar android.enableSeparateAnnotationProcessing = true em seus gradle.properities reddit.com/r/androiddev/comments/ai92pt/... encontrado neste, pode estar relacionado com o seu problema
Ferhat Ergün
7
Você pode fazer o downgrade do kotlin-gradle-plugin no arquivo build.gradle do projeto para a versão 1.3.41 por enquanto. Eu acho que é um bug relacionado ao kapt. Mais informações: youtrack.jetbrains.com/issue/KT-33515
Necrontyr
4
Você também pode criar um arquivo gradle.properties em libs / <nome do seu módulo> com kapt.incremental.apt=falsetambém, conforme descrito no problema, como uma solução alternativa. Funcionou para mim.
Necrontyr 27/08/19
2
@Necrontyr, sua sugestão realmente deu certo. Muito obrigado
Shax

Respostas:

80

Há um erro na versão kotlin-gradle-plugin da 1.3.50, como @Necrontyr mencionado. Apenas faça o downgrade do kotlin_version em build.gradle (Project) para 1.3.41.

Mücahid Kambur
fonte
71
O bug mencionado por @Necrontyr não está relacionado ao aviso. O aviso é realmente planejado e descer para 1.3.41 apenas oculta o aviso, mas o problema permanece o mesmo, se não pior. As pessoas podem pensar que, porque ativaram o processamento de anotação incremental, isso tornará as coisas mais rápidas. Mas a verdade é que, se algum dos processadores de anotação não for incremental, nenhum deles será processado incrementalmente. Este é um lembrete amigável que indicará qual biblioteca é a culpada.
Antimonit
15
Usar uma versão desatualizada da biblioteca não é uma solução.
Andrew Koster
5
Esse ainda é o caso de Kotlin 1.3.70?
IgorGanapolsky 15/03
2
Estou usando o Kotlin 1.3.72 e ainda enfrenta esse problema?
Anbuselvan Rocky
4
Também estou enfrentando esse problema 1.3.72 alguma solução pessoal?
hiashutoshsingh
174

Basta adicionar esta linha a você gradle.properties:

kapt.incremental.apt=true
Ali Ahmed
fonte
11
Esta é uma opção melhor que a resposta aceita. Para aqueles que precisam entender e entrar em mais detalhes, consulte este link: medium.com/avast-engineering/…
Abhimanyu
4
falhou para mim também.
steven smith
alguém é o motivo pelo qual está acontecendo aqui?
Omer
Recentemente, ativei a ligação de dados ao meu projeto android (kotlin) e comecei a receber esse aviso. A adição da propriedade conforme indicado acima funcionou para mim. Também usando as versões mais recentes de tudo, por exemplo, todas as dependências, compiladores, ferramentas de compilação, SDKs etc.
Gail
4
Fazendo exatamente isso, não funcionou para mim. Eu também tive que editar meu arquivo build.gradle, conforme descrito na documentação da biblioteca da sala .
Nelson Ferragut
121

O verdadeiro problema é que o processamento incremental torna as coisas mais rápidas, mas se algum dos processadores de anotação não for incremental, nenhum deles será realmente processado dessa maneira.

Qual é o objetivo do processamento incremental?

A partir da versão 1.3.30+ , o processamento incremental permitia que os módulos não fossem totalmente processados ​​novamente toda vez que uma alteração ocorresse, dando ao processo de construção um melhor desempenho:

As principais áreas de foco desta versão foram o Kotlin / Native, o desempenho do KAPT e as melhorias do IntelliJ IDEA.

Da documentação do Kotlin :

Processadores de anotação (consulte JSR 269) são suportados no Kotlin com o plugin do compilador kapt. Em poucas palavras, você pode usar bibliotecas como Dagger ou Data Binding em seus projetos Kotlin.

Como corrigir o processamento incremental de sala?

E o processador de anotação incremental de sala está desativado por padrão. Este é um problema conhecido e está descrito aqui . Eles pretendem corrigi-lo na versão 2.2.0. Você pode apenas esperar a atualização ou habilitar isso para se livrar do aviso, definindo:

no arquivo gradle.properties :

kapt.incremental.apt=true

(etapas opcionais)

para permitir que a ligação de dados seja incremental:

android.databinding.incremental=true

para compilações mais rápidas:

kapt.use.worker.api=true

se apenas algumas alterações forem feitas, o tempo de compilação diminui bastante:

kapt.include.compile.classpath=false

(voltando ao assunto)

em seu projeto build.gradle , adicione as dependências necessárias (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"]
            }
        }
    }
}

Versão DSL do 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")
            }
        }
    } 
}

Editar:

9 de outubro de 2019

É lançado o androidx.room:room-*:2.2.0 .

Processador de anotação incremental Gradle: O Room agora é um processador de anotação de isolamento Gradle e a incrementabilidade pode ser ativada através da opção de processador room.incremental.

Dimas Mendes
fonte
8
Este deve ser aceito como kapt.incremental.apt = true é algo que estará faltando ao incluir Room em seu projeto. Que não é sequer mencionado nos docs Android para quarto
sela
1
Esta resposta me ajudou como eu estava usando androidx.lifecycle:lifecycle-extensionsna versão 2.1.0 e depois de mudar para 2.2.0-beta01 o aviso foi embora!
simne7
2
@ simne7 confira minha edição no final. A versão 2.2.0 foi lançada =) você já pode atualizá-lo para acessar o recurso de processamento incremental e aumentar sua compilação.
Dimas Mendes
A ativação android.buildcache=truetornaria mais rápido?
IgorGanapolsky 15/03
1
@IgorGanapolsky de acordo com o site do Google Developers Projects using Android plugin 2.3.0 and higher enable the build cache by default (unless you explicitly disable the build cache),. Portanto, não faz sentido ativá-lo como está ativado por padrão.
Dimas Mendes
37

Da documentação da sala :

"A sala possui as seguintes opções de processador de anotação ... room.incremental: Ativa o processador de anotação incremental Gradle."

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

Certifique-se de atualizar a versão da sala para 2.2.x ou superior.

Alberto Gaona
fonte
3
Pessoas de resposta corretas, se você deseja manter o processamento incremental. Talvez você não precise dos argumentos schemaLocation ou expandProjection definidos acima. room.incremental basta.
bajicdusko 20/09/19
1
De acordo com developer.android.com/jetpack/androidx/releases/room , ainda existe a versão 2.2.0-rc01.
CoolMind 26/09/19
1
já está disponível -> developer.android.com/jetpack/androidx/releases/…
jesses.co.tt 10/10
Atualizar a versão do espaço para 2.2.0 isso funcionou para mim
DivideBy0
25

Aqui está uma lista de coisas que você pode fazer para corrigir isso e diminuir significativamente o tempo de compilação enquanto estiver trabalhando.

No seu build.gradlearquivo (módulo):

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

No seu gradle.propertiesarquivo:

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 
smdufb
fonte
18

Habilitar o processamento de anotações incrementais do Kapt

Use o Kotlin 1.3.31 ou o Kotlin 1.3.30 mais recente, lançado

No seu arquivo android kotlin project 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
Shomu
fonte
Que tal android.lifecycleProcessor.incremental=true?
IgorGanapolsky 15/03
10

Muitas das outras respostas aqui encobrem o erro ou desabilitam o processamento incremental em vez de fazê-lo funcionar da maneira que você deseja.

Você pode ativar o processamento incremental para sua biblioteca específica no gradle.propertiesarquivo. Basta adicionar essas configurações ou a que corresponder à biblioteca que gera o erro:

android.databinding.incremental=true
android.lifecycleProcessor.incremental=true
Jacques.S
fonte
2
Eu não estou tão certo sobre android.lifecycleProcessor.incremental=true, ele não parece ser documentado em qualquer lugar
Daniel Wilson
Também não tenho certeza, mas tentei com um palpite e o compilador parou de me dizer que a biblioteca lifecycleProcessor não tinha o processamento incremental ativado.
Jacques.S
5

Se estiver reclamando que "O processamento de anotação incremental foi solicitado, mas o suporte está desativado porque os processadores a seguir não são incrementais", configure "kapt.incremental.apt" como "true" (mencionado em uma resposta diferente) em gradle.properties intuitivo. Você precisa configurá-lo como "false". Isso fez por mim.

DC Christopher
fonte
1
Isso realmente funcionou. Defina-o para pessoas FALSAS! obrigada
Sakiboy 20/09/19
E o que vai acontecer? Ele será compilado mais rapidamente ou simplesmente ocultará o aviso?
CoolMind 26/09/19
@CoolMind Você desativaria o processamento de anotação incremental, algo que de qualquer maneira não acontecerá se alguma de suas dependências não o suportar. Portanto, o aviso desaparece e não há alterações no processo de compilação de antes.
DC Christopher
2
Surpreendentemente configuração kapt.incremental.apt=falseme ajudou, eu não mais recebendo o erro
Rakhi Dhavale
2
Você não tem mais erro, mas agora você não tem processamento incremental :)
JustAnotherCoder
2

Estou usando o AndroidX , mas acho que é o mesmo android.arch.lifecycle. Para mim, isso simplesmente ajudou a substituir isso:

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

... com isso:

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

Portanto, se você estiver usando android.arch.lifecycle, pode ter o mesmo efeito substituindo isso:

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

... com isso:

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

Esteja ciente de que isso só funciona se você estiver usando o Java 8 e também deve remover OnLifecycleEventanotações para LifecycleObserverclasses e permitir que esses observadores implementem DefaultLifecycleObserver.

A mudança para esse método também é recomendada nas build.gradledependências mostradas aqui .

Anigif
fonte
Por que você está se livrando kapt?
IgorGanapolsky 15/03
@IgorGanapolsky Isso é o que é sugerido pelo ciclo de vida do AndroidX se você estiver usando o Java 8. Veja mais aqui: developer.android.com/jetpack/androidx/releases/…
Anigif
kapté essencial para Kotlin
IgorGanapolsky 16/03
1
Somente se a lib exigir. De acordo com esta página, as anotações serão descontinuadas quando o Java 8 ficar mais popular no Android, portanto, recomendam common-java8se possível: developer.android.com/reference/androidx/lifecycle/Lifecycle
Anigif
Interessante. Mas eles não mencionam kaptem particular ...
IgorGanapolsky
2

O que você realmente deve fazer é implementar essas linhas de código em sua buildConfigtag no seu build.gradleaplicativo módulo:

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

Respostas acima pode ser útil, mas o que me ajudou é reduzir o kotlin_versionem build.gradle(Project)que1.3.41 e construir o projeto. Isso permitirá que você veja se há algum problema com seu modelo de entidade.

O meu era, esqueci de anotar @PrimaryKey. Você pode ser algo diferente. Kotlin 1.3.41permite ver essas questões. Corrija esses problemas e volte kotlin_versionao seu anterior.

Sourav Roy
fonte
-1

Isso também pode ser causado por problemas de caracteres, como " © " no lado da ligação de dados , quando o idioma do sistema não é o inglês. Nesse caso, o uso do idioma do sistema do computador em inglês resolverá o problema.

Hasan Kucuk
fonte