Sala: el directorio de exportación del esquema no se proporciona al procesador de anotaciones, por lo que no podemos exportar el esquema.

Estoy usando la Sala de componentes de la base de datos de Android

He configurado todo, pero cuando compilo, Android Studio me da esta advertencia:

El directorio de exportación de esquemas no se proporciona al procesador de anotaciones, por lo que no podemos exportar el esquema. Puede proporcionar el room.schemaLocationargumento del procesador de anotaciones O establecer exportSchema en falso.

Según tengo entendido, es la ubicación donde se ubicará el archivo DB

¿Cómo puede afectar mi aplicación? ¿Cuál es la mejor práctica aquí? ¿Debo usar la ubicación predeterminada ( falsevalor)?

Según los documentos :

Puede establecer el argumento del procesador de anotaciones (room.schemaLocation) para indicarle a Room que exporte el esquema a una carpeta. Aunque no es obligatorio, es una buena práctica tener el historial de versiones en su código base y debe enviar ese archivo a su sistema de control de versiones (¡pero no lo envíe con su aplicación!).

Entonces, si no necesita verificar el esquema y desea deshacerse de la advertencia, simplemente agregue exportSchema = falsea su RoomDatabase, de la siguiente manera.

@Database(entities = { YourEntity.class }, version = 1, exportSchema = false)
public abstract class AppDatabase extends RoomDatabase {
   //...
}

Si sigue la respuesta de @mikejonesguy a continuación, seguirá las buenas prácticas mencionadas en los documentos :). Básicamente, obtendrá un .jsonarchivo en su ../app/schemas/carpeta. Y se parece a esto:

{
  "formatVersion": 1,
  "database": {
    "version": 1,
    "identityHash": "53db508c5248423325bd5393a1c88c03",
    "entities": [
      {
        "tableName": "sms_table",
        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `message` TEXT, `date` INTEGER, `client_id` INTEGER)",
        "fields": [
          {
            "fieldPath": "id",
            "columnName": "id",
            "affinity": "INTEGER"
          },
          {
            "fieldPath": "message",
            "columnName": "message",
            "affinity": "TEXT"
          },
          {
            "fieldPath": "date",
            "columnName": "date",
            "affinity": "INTEGER"
          },
          {
            "fieldPath": "clientId",
            "columnName": "client_id",
            "affinity": "INTEGER"
          }
        ],
        "primaryKey": {
          "columnNames": [
            "id"
          ],
          "autoGenerate": true
        },
        "indices": [],
        "foreignKeys": []
      }
    ],
    "setupQueries": [
      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, \"53db508c5248423325bd5393a1c88c03\")"
    ]
  }
}

Si mi entendimiento es correcto, obtendrá dicho archivo con cada actualización de la versión de la base de datos, de modo que pueda seguir fácilmente el historial de su base de datos.

En el build.gradlearchivo del módulo de su aplicación, agregue esto a la defaultConfigsección (debajo de la androidsección). Esto escribirá el esquema en una schemassubcarpeta de la carpeta de su proyecto.

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

Me gusta esto:

// ...

android {

    // ... (compileSdkVersion, buildToolsVersion, etc)

    defaultConfig {

        // ... (applicationId, miSdkVersion, etc)

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

    // ... (buildTypes, compileOptions, etc)

}

// ...

Kotlin? Aquí vamos:

android {

    // ... (compileSdkVersion, buildToolsVersion, etc)

    defaultConfig {

        // ... (applicationId, miSdkVersion, etc)

        kapt {
            arguments {
                arg("room.schemaLocation", "$projectDir/schemas")
            }
        }
    }

    buildTypes {
        // ... (buildTypes, compileOptions, etc)
    }
}

//...

No te olvides del complemento:

apply plugin: 'kotlin-kapt'

Para obtener más información sobre el procesador de anotaciones Kotlin , visite: Kotlin docs

Las respuestas anteriores son correctas. Esta versión es fácil de seguir:

Debido a que "el directorio de exportación de esquemas no se proporciona al procesador de anotaciones", debemos proporcionar el directorio para la exportación de esquemas:

Paso [1] En su archivo que amplía RoomDatabase, cambie la línea a:

`@Database(entities = ???.class,version = 1, exportSchema = true)`

O

`@Database(entities = ???.class,version = 1)` 

(porque el valor predeterminado siempre es verdadero)

Paso [2] En su archivo build.gradle (proyecto: ????), dentro de defaultConfig {} (que está dentro de la sección grande de Android {} ), agregue la sección javaCompileOptions {} , será como:

         android{
                defaultConfig{
                      //javaComplieOptions SECTION
                      javaCompileOptions {
                            annotationProcessorOptions {
                                     arguments = ["room.schemaLocation":"$projectDir/schemas".toString()]
                            }
                       }
                      //Other SECTION
                      ...
                }
         }

$ projectDir : es un nombre de variable, no puede cambiarlo. obtendrá su propio directorio de proyectos

esquemas : es una cadena, puede cambiarla por la que desee. Por ejemplo: "$projectDir/MyOwnSchemas".toString()

La respuesta de @mikejonesguy es perfecta, en caso de que planee probar las migraciones de salas (recomendado), agregue la ubicación del esquema a los conjuntos de fuentes.

En su archivo build.gradle, especifica una carpeta para colocar estos archivos JSON de esquema generados. A medida que actualice su esquema, obtendrá varios archivos JSON, uno para cada versión. Asegúrese de enviar todos los archivos generados al control de código fuente. La próxima vez que vuelva a aumentar el número de versión, Room podrá utilizar el archivo JSON para realizar pruebas.

• Florina Muntenescu ( fuente )

build.gradle

android {

    // [...]

    defaultConfig {

        // [...]

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

    // add the schema location to the source sets
    // used by Room, to test migrations
    sourceSets {
        androidTest.assets.srcDirs += files("$projectDir/schemas".toString())
    }

    // [...]
}

Yo uso .ktslos archivos Gradle (Kotlin Gradle DSL) y el kotlin-kaptplug-in, pero sigo teniendo un error de compilación de la escritura cuando se utiliza la respuesta de Maksim Ivanov.

Unresolved reference: kapt

Para mí, esto fue lo único que funcionó:

android {
    defaultConfig {
        javaCompileOptions {
            annotationProcessorOptions {
                arguments = mapOf("room.schemaLocation" to "$projectDir/schemas")
            }
        }
    }
}

Probablemente no agregó su clase de salón a la clase infantil RoomDatabaseinfantil en@Database(entities = {your_classes})