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

7 minutos de lectura

avatar de usuario
Misha Akopov

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
room.schemaLocation argumento del procesador de anotaciones O establezca exportSchema en falso.

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

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

avatar de usuario
DoruChidean

según el documentos:

Puede configurar el argumento del procesador de anotaciones (room.schemaLocation) para decirle a Room que exporte el esquema a una carpeta. Aunque no es obligatorio, es una buena práctica tener un historial de versiones en su base de código y debe confirmar ese archivo en 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 = false para usted RoomDatabasecomo sigue.

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

Si sigue la respuesta de @mikejonesguy a continuación, seguirá la buena práctica mencionada en los documentos :). Básicamente obtendrás un .json archivo en su ../app/schemas/ carpeta. Y se ve algo como 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, para que pueda seguir fácilmente el historial de su base de datos.

  • ¿Qué significa realmente “No enviar con su aplicación”? ¿Se incluirá en APK?

    – Jongz Puangput

    10 de marzo de 2018 a las 0:48

  • Si sigue “No enviar con su aplicación”, ¿debería eliminar los archivos JSON antes de generar APK?

    – ilusiónJJ

    15 de mayo de 2018 a las 2:47

  • “No enviar con su aplicación” significa “No configurar schemaLocation para que le guste ‘app/res/raw’. Configure schemaLocation en un directorio no incluido en el APK”.

    – galcyurio

    6 de julio de 2018 a las 9:38

  • @galcyurio $projectDir/schemas es un directorio fuera del APK, ¿verdad? He explorado el APK generado y no lo veo por ahí. Aunque veo /res (que representa app/src/main/res) por ejemplo.

    – xarlymg89

    11 de julio de 2018 a las 9:55

  • @xarlymg89 ¿Pudiste confirmar eso? $projectDir/schemas es NO incluido en el APK? De acuerdo con esta respuesta, los subdirectorios personalizados no lo son.

    usuario11566289

    18 de julio de 2019 a las 12:31


avatar de usuario
mikejonesguy

En el build.gradle archivo para el módulo de su aplicación, agréguelo al defaultConfig sección (bajo el android sección). Esto escribirá el esquema en un schemas subcarpeta de la carpeta de su proyecto.

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

Como esto:

// ...

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

    defaultConfig {

        // ... (applicationId, miSdkVersion, etc)
        
        javaCompileOptions {
            annotationProcessorOptions {
                arguments += ["room.schemaLocation": "$projectDir/schemas".toString()]
            }
        }
    }
   
    // ... (buildTypes, compileOptions, etc)

}

// ...

  • Si alguien se pregunta, este enfoque exacto también funciona para Kotlin cuando se usa captado

    – DanielDiSu

    2 de diciembre de 2017 a las 11:40

  • ¿Deberíamos ignorar el archivo json generado en el app/schemas directorio por esta operación. Y escuché que deberíamos poner el esquema en un directorio que no está incluido en el apk. ¿Cómo podemos hacer eso?

    – ravi

    8 de julio de 2018 a las 9:57

  • @ravi, los archivos de esquema generados deben almacenarse en el control de versiones, ya que Room lo usa para detectar cambios y ayudar a garantizar que, si la base de datos cambia, actualice la versión de la base de datos y cree un plan de migración

    – appmattus

    27 de agosto de 2018 a las 7:54

  • usar arguument += por lo que no interfiere con sus bibliotecas DI como Hilt (consulte esta respuesta para obtener más información stackoverflow.com/a/62891182/5780236)

    – Ahmad Reza Enshaee

    27 de septiembre de 2020 a las 14:11


  • @ChantellOsejo actualizado hace un momento. Se cambió “argumentos = …” a “argumentos += …”.

    – mikejonesguy

    20 de enero de 2021 a las 1:11

avatar de usuario
Ivanov Maksim

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:
Documentos de Kotlin

  • Conseguí un > No signature of method: build_xyz.android() is applicable for argument types: (build_xyz$_run_closure1) values: [[email protected]] dónde xyz es una cadena aleatoria larga… ¿es un error?

    – Minh Nghĩa

    24 de noviembre de 2020 a las 15:08


  • Este probablemente sea una mejor opción

    – esprajagopal

    13 de junio de 2021 a las 13:36

  • La respuesta anterior de @ mikejonesguy funcionó para mí.

    – esprajagopal

    13 de junio de 2021 a las 13:45

  • Mismo problema aquí con el método de firma faltante.

    – Akito

    9 oct 2021 a las 21:21

  • Al usar javaCompileOptions como lo sugieren otras respuestas, vi un error “Causado por: groovy.lang.MissingMethodException: No hay firma del método: build_….android() es aplicable para tipos de argumentos…”. Parece que javaCompileOptions podría haber quedado obsoleto. Estoy usando AGP v7.0.2. Necesitaba usar kapt{} en su lugar para establecer el argumento como lo describe Ivanov (lo usé dentro de Android{} y se generó el esquema).

    – Ollie C.

    19 oct 2021 a las 9:45

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 extiende 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(project:????), dentro del configuración por defecto{ } (que está dentro androide{ } sección grande), agregue el javaCompileOptions{ } sección, será como:

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

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

esquemas:es una cadena, puedes cambiarla por la que quieras. 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, terminará con 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 aumente su número de versión nuevamente, Room podrá usar el archivo JSON para realizar pruebas.

construir.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())
    }

    // [...]
}

avatar de usuario
Eyjafl

Para Kotlin KSP:

ksp {
    arg('room.schemaLocation', "$projectDir/schemas")
}

avatar de usuario
jsa

yo suelo .kts Archivos Gradle (Kotlin Gradle DSL) y el kotlin-kapt complemento, pero sigo recibiendo un error de compilación del script cuando uso la respuesta de Ivanov Maksim.

Unresolved reference: kapt

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

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

  • A mi tampoco me funciona nada. Estoy usando Kotlin.

    – nyxee

    6 abr 2020 a las 21:42


  • ¿Cómo funciona esta respuesta? arguments es un MutableMap, val arguments: MutableMap<String, String> y da un error de compilación cuando intentas asignar algo, y agregando con arguments["room.schemaLocation"] ="$projectDir/schemas"no funciona para mi Otra respuesta tampoco funciona.

    – tracio

    30 de agosto de 2020 a las 12:34


¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad