Acabo de comenzar a usar el desarrollo de Android y tratar de usar la biblioteca de habitaciones. Desde ayer me enfrento a este mensaje de advertencia

w: [kapt] Procesamiento de anotación incremental solicitado, pero el soporte está deshabilitado porque los siguientes procesadores no son incrementales: androidx.lifecycle.LifecycleProcessor (NON_INCREMENTAL), androidx.room.RoomProcessor (NON_INCREMENTAL).

He intentado investigar y solucionar, pero no puedo evitar este error, aquí está mi archivo grale.build. sugiera / aconseje lo que estoy haciendo mal.

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

Hay un error en la versión kotlin-gradle-plugin de 1.3.50 como se menciona en @Necrontyr. Simplemente baje la versión de kotlin_version en build.gradle (Project) a 1.3.41.

Simplemente agregue esta línea a gradle.properties:

kapt.incremental.apt=true

El verdadero problema es que el procesamiento incremental hace que las cosas sean más rápidas, pero si alguno de los procesadores de anotaciones no es incremental, ninguno de ellos se procesará realmente de esa manera.

¿Cuál es el propósito del procesamiento incremental?

A partir de la versión 1.3.30+ , el procesamiento incremental permitió que los módulos no se procesen por completo nuevamente cada vez que se produce un cambio, lo que le da al proceso de compilación un mejor rendimiento:

Las principales áreas de enfoque para esta versión se han centrado en Kotlin / Native, el rendimiento de KAPT, así como las mejoras para IntelliJ IDEA.

De la documentación de Kotlin :

Los procesadores de anotaciones (ver JSR 269) son compatibles con Kotlin con el complemento compilador kapt. En pocas palabras, puede usar bibliotecas como Dagger o Data Binding en sus proyectos de Kotlin.

¿Cómo arreglar el procesamiento incremental de la sala?

Y el procesador de anotación incremental Room está deshabilitado de forma predeterminada. Este es un problema conocido y se describe aquí . Tienen la intención de arreglarlo en la versión 2.2.0. Puede esperar la actualización o habilitarla para deshacerse de la advertencia configurando:

en el archivo gradle.properties :

kapt.incremental.apt=true

(pasos opcionales)

para permitir que el enlace de datos sea ​​incremental:

android.databinding.incremental=true

para construcciones más rápidas:

kapt.use.worker.api=true

Si solo se realizan algunos cambios, el tiempo de construcción disminuye considerablemente:

kapt.include.compile.classpath=false

(volver al tema)

en su proyecto build.gradle , agregue las dependencias necesarias (Groovy):

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

y

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

Versión Kotlin DSL:

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

y

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

Editar:

9 de octubre de 2019

se lanza androidx.room:room-*:2.2.0 .

Procesador de anotación incremental Gradle: Room ahora es un procesador de anotación de aislamiento Gradle y la capacidad de incremento se puede habilitar a través de la opción de procesador room.incremental.

De la documentación de la sala :

"Room tiene las siguientes opciones de procesador de anotación ... room.incremental: habilita el procesador de anotación incremental Gradle".

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

Asegúrese de actualizar la versión de la sala a 2.2.xo superior.

Aquí hay una lista de cosas que puede hacer para solucionar esto y disminuir significativamente los tiempos de construcción mientras lo hace.

En su build.gradlearchivo (módulo):

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

En tu gradle.propertiesarchivo:

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 Kapt Solicitud de procesamiento de anotaciones incrementales

Utilice Kotlin 1.3.31 o una versión más reciente de Kotlin 1.3.30

En su proyecto de Android Kotlin, el archivo 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

Muchas de las otras respuestas aquí cubren el error o deshabilitan el procesamiento incremental en lugar de hacerlo funcionar de la manera deseada.

Puede habilitar el procesamiento incremental para su biblioteca específica en el gradle.propertiesarchivo. Simplemente agregue esta configuración, o la que coincida con la biblioteca que arroja el error:

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

Si se queja de que "Se solicitó el procesamiento de anotaciones incrementales, pero el soporte está deshabilitado porque los siguientes procesadores no son incrementales", entonces establecer "kapt.incremental.apt" en "verdadero" (mencionado en una respuesta diferente) en gradle.properties es counter- intuitivo. Debe establecerlo en "falso". Eso lo hizo por mí.

Estoy usando AndroidX , pero supongo que es lo mismo android.arch.lifecycle. Para mí, simplemente ayudó a reemplazar esto:

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

... con este:

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

Entonces, si lo está usando android.arch.lifecycle, podría tener el mismo efecto reemplazando esto:

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

... con este:

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

Tenga en cuenta que esto solo funciona si está utilizando Java 8 y que también debe eliminar las OnLifecycleEventanotaciones para las LifecycleObserverclases y dejar que esos observadores implementenDefaultLifecycleObserver lugar.

También se recomienda cambiar a este método en las build.gradledependencias que se muestran aquí .

Lo que realmente debe hacer es implementar estas líneas de código en su buildConfigetiqueta en su build.gradleaplicación de módulo:

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

Respuestas anteriores pueden ser útiles, pero lo que me ayudó es reducir el kotlin_versionen build.gradle(Project)a1.3.41 , y la construcción del proyecto. Esto le permitirá ver si hay algún problema con su modelo de entidad.

El mío fue, olvidé anotar @PrimaryKey. Tu puede ser algo diferente. Kotlin 1.3.41permite ver esos problemas. Solucione esos problemas y vuelva a su kotlin_versionanterior.

Esto también puede ser causado por problemas de caracteres como " İ " en el lado de enlace de datos cuando el idioma del sistema no es inglés. En tal caso, el uso del idioma del sistema informático en inglés resolverá el problema.