Salle - Le répertoire d'exportation de schéma n'est pas fourni au processeur d'annotation, nous ne pouvons donc pas exporter le schéma

J'utilise la salle de composants de base de données Android

J'ai tout configuré, mais quand je compile, Android Studio me donne cet avertissement:

Le répertoire d'exportation de schéma n'est pas fourni au processeur d'annotation, nous ne pouvons donc pas exporter le schéma. Vous pouvez soit fournir l' room.schemaLocationargument du processeur d'annotation OU définir exportSchema sur false.

Si je comprends bien, c'est l'emplacement où le fichier DB sera situé

Comment cela peut-il affecter mon application? Quelle est la meilleure pratique ici? Dois-je utiliser l'emplacement par défaut ( falsevaleur)?

Selon les documents :

Vous pouvez définir l'argument du processeur d'annotations (room.schemaLocation) pour indiquer à Room d'exporter le schéma dans un dossier. Même si ce n'est pas obligatoire, c'est une bonne pratique d'avoir l'historique des versions dans votre base de code et vous devez valider ce fichier dans votre système de contrôle de version (mais ne le livrez pas avec votre application!).

Donc, si vous n'avez pas besoin de vérifier le schéma et que vous souhaitez vous débarrasser de l'avertissement, ajoutez simplement exportSchema = falseà votre RoomDatabase, comme suit.

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

Si vous suivez la réponse @mikejonesguy ci-dessous, vous suivrez la bonne pratique mentionnée dans la documentation :). Fondamentalement, vous obtiendrez un .jsonfichier dans votre ../app/schemas/dossier. Et cela ressemble à ceci:

{
  "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 ma compréhension est correcte, vous obtiendrez un tel fichier avec chaque mise à jour de la version de la base de données, afin que vous puissiez facilement suivre l'historique de votre base de données.

Dans le build.gradlefichier de votre module d'application, ajoutez-le à la defaultConfigsection (sous la androidsection). Cela écrira le schéma dans un schemassous - dossier de votre dossier de projet.

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

Comme ça:

// ...

android {

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

    defaultConfig {

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

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

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

}

// ...

Kotlin? Et c'est parti:

android {

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

    defaultConfig {

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

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

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

//...

N'oubliez pas le plugin:

apply plugin: 'kotlin-kapt'

Pour plus d'informations sur le processeur d'annotations kotlin, veuillez visiter: Kotlin docs

Les réponses ci-dessus sont correctes. Cette version est facile à suivre:

Parce que "le répertoire d'exportation de schéma n'est pas fourni au processeur d'annotation", nous devons donc fournir le répertoire pour l'exportation de schéma:

Étape [1] Dans votre fichier qui étend la RoomDatabase, changez la ligne en:

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

Ou

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

(car la valeur par défaut est toujours vraie)

Étape [2] Dans votre fichier build.gradle (projet: ????), à l'intérieur de la section defaultConfig {} (qui se trouve à l'intérieur de la grande section android {} ), ajoutez la section javaCompileOptions {} , ce sera comme:

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

$ projectDir : est un nom de variable, vous ne pouvez pas le changer. il obtiendra votre propre répertoire de projet

schémas : est une chaîne, vous pouvez la changer en celle que vous voulez. Par exemple: "$projectDir/MyOwnSchemas".toString()

La réponse @mikejonesguy est parfaite, juste au cas où vous prévoyez de tester les migrations de salle (recommandé), ajoutez l'emplacement du schéma aux ensembles source.

Dans votre fichier build.gradle, vous spécifiez un dossier pour placer ces fichiers JSON de schéma générés. Lorsque vous mettez à jour votre schéma, vous vous retrouverez avec plusieurs fichiers JSON, un pour chaque version. Assurez-vous de valider chaque fichier généré pour le contrôle de code source. La prochaine fois que vous augmenterez à nouveau votre numéro de version, Room pourra utiliser le fichier JSON pour les tests.

• Florina Muntenescu ( source )

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

    // [...]
}

J'utilise des .ktsfichiers Gradle (Kotlin Gradle DSL) et le kotlin-kaptplugin mais j'obtiens toujours une erreur de compilation de script lorsque j'utilise la réponse d'Ivanov Maksim.

Unresolved reference: kapt

Pour moi, c'est la seule chose qui a fonctionné:

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

Vous n'avez probablement pas ajouté votre classe de chambre à la classe enfant RoomDatabaseenfant dans@Database(entities = {your_classes})