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

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.

Basta adicionar esta linha a você gradle.properties:

kapt.incremental.apt=true

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.

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.

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 

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

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

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.

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 .

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

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.

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.