Ma classe de base de données d'application

@Database(entities = {Detail.class}, version = Constant.DATABASE_VERSION)
public abstract class AppDatabase extends RoomDatabase {

    private static AppDatabase INSTANCE;

    public abstract FavoritesDao favoritesDao();

    public static AppDatabase getAppDatabase(Context context) {
        if (INSTANCE == null) {
            INSTANCE =
                    Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, Constant.DATABASE).allowMainThreadQueries().build();

                    //Room.inMemoryDatabaseBuilder(context.getApplicationContext(),AppDatabase.class).allowMainThreadQueries().build();
        }
        return INSTANCE;
    }

    public static void destroyInstance() {
        INSTANCE = null;
    }
}

Gradle lib:

 compile "android.arch.persistence.room:runtime:+"   
 annotationProcessor "android.arch.persistence.room:compiler:+"

Et quand je demande par exemple cela donnera cette erreur, AppDatabase_Impl n'existe pas dans ma classe d'application

public class APp extends Application {

    private boolean appRunning = false;

    @Override
    public void onCreate() {
        super.onCreate();
        AppDatabase.getAppDatabase(this); //--AppDatabase_Impl does not exist

    }   

}

Pour ceux qui travaillent avec Kotlin , essayez de passer annotationProcessorà kaptdans les applicationsbuild.gradle

par exemple:

// Extensions = ViewModel + LiveData
implementation "android.arch.lifecycle:extensions:1.1.0"
kapt "android.arch.lifecycle:compiler:1.1.0"
// Room
implementation "android.arch.persistence.room:runtime:1.0.0"
kapt "android.arch.persistence.room:compiler:1.0.0"

n'oubliez pas d'ajouter ce plugin

apply plugin: 'kotlin-kapt'

en haut du fichier build.gradle au niveau de l'application et effectuez un nettoyage et une reconstruction (selon https://codelabs.developers.google.com/codelabs/android-room-with-a-view/#6 )

Dans Android Studio, si vous obtenez des erreurs lorsque vous collez du code ou pendant le processus de génération, sélectionnez Générer> Nettoyer le projet. Sélectionnez ensuite Construire> Rebuild Project, puis reconstruisez à nouveau.

METTRE À JOUR

Si vous avez migré vers androidx

def room_version = "2.2.3" // check latest version from docs

implementation "androidx.room:room-runtime:$room_version"
kapt "androidx.room:room-compiler:$room_version"

Juste utiliser

apply plugin: 'kotlin-kapt'

dans l'application build.gradle

Et gardez les deux dans les dépendances

annotationProcessor "android.arch.persistence.room:compiler:$rootProject.roomVersion"
kapt "android.arch.persistence.room:compiler:$rootProject.roomVersion"

ÉDITER

Dans la version plus récente, il n'est pas nécessaire d'ajouter les deux dépendances à la fois. Utilisez simplement, j'espère que cela fonctionnera.

kapt 'android.arch.persistence.room:compiler:1.1.1'

J'ai eu cette erreur quand j'ai raté

@Database(entity="{<model.class>})

Assurez-vous que le modèle d'entité spécifié dans l'annotation ci-dessus fait référence à la classe de modèle particulière et assurez-vous également que l'annotation nécessaire:

@Entity(tableName = "<table_name>" ...)

est bien défini et vous seriez bien

si vous utilisez des classes kotlin pour implémenter la base de données, utilisez

apply plugin: 'kotlin-kapt'

et

kapt "android.arch.persistence.room:compiler:1.1.1"

dans votre fichier gradle, cela fonctionnera.

Il ne s'agit pas seulement de mettre à jour vos dépendances. Assurez-vous que toutes vos dépendances de salle ont la même version.

implementation 'android.arch.persistence.room:rxjava2:1.1.0-alpha2'
implementation 'android.arch.persistence.room:runtime:1.1.0-alpha2'
annotationProcessor "android.arch.persistence.room:compiler:1.1.0-alpha2"

Dans l'exemple d'extrait ci-dessus, toutes mes dépendances de salle ont la même version 1.1.0-alpha2

Pour les développeurs Kotlin

Utilisez ceci:

implementation "android.arch.persistence.room:runtime:1.0.0"
kapt "android.arch.persistence.room:compiler:1.0.0"

Et ajoutez apply plugin: 'kotlin-kapt'au sommet du niveau de l'application build.gradle.

Pour les développeurs Java

implementation "android.arch.persistence.room:runtime:1.0.0"
annotationProcessor "android.arch.persistence.room:compiler:1.0.0"

J'ai rencontré ce problème car j'ai oublié les dépendances apt

implementation "android.arch.lifecycle:extensions:$archLifecycleVersion"
implementation "android.arch.persistence.room:runtime:$archRoomVersion"
annotationProcessor "android.arch.lifecycle:compiler:$archLifecycleVersion"
annotationProcessor "android.arch.persistence.room:compiler:$archRoomVersion"

après avoir ajouté l'annotationProcessor et le reconstruire, le problème est résolu.

Je rencontre le problème, car j'oublie l' @Daoannotation

@Dao
public interface SearchHistoryDao {
    @Query("SELECT * FROM search_history")
    List<SearchHistory> getAll();

    @Insert
    void insertAll(SearchHistory... histories);

    @Delete()
    void delete(SearchHistory history);
}

Tutoriel officiel de la salle

assurez-vous d'ajouter une dépendance correcte pour la pièce dans build.gradle

ext {
   roomVersion = '2.1.0-alpha06'
}

// Room components
implementation "androidx.room:room-runtime:$rootProject.roomVersion"
implementation "androidx.room:room-ktx:$rootProject.roomVersion"
kapt "androidx.room:room-compiler:$rootProject.roomVersion"
androidTestImplementation "androidx.room:room-testing:$rootProject.roomVersion"

Et en dessous de la ligne en haut-

apply plugin: 'kotlin-kapt'

La question est assez ancienne, mais je suis tombée dessus aujourd'hui et aucune des réponses fournies ne m'a aidé. Enfin, j'ai réussi à le résoudre en remarquant que la documentation Google est toujours adoptée par défaut par Java et non par Kotlin, en fait, ils ont ajouté un commentaire que j'ai ignoré

Pour Kotlin, utilisez kapt au lieu d'annotationProcessor

Donc, au lieu de

annotationProcessor "androidx.room:room-compiler:$room_version"

Si vous développez avec Kotlin, vous devez utiliser:

    kapt "androidx.room:room-compiler:$room_version"

Avait le même problème. Implémentation des quelques classes et interfaces comme indiqué officiellement dans un nouvel exemple de projet créé par Android Studio: https://developer.android.com/training/data-storage/room/

Toutes les solutions mentionnées ci-dessus n'ont pas aidé, les fichiers _Impl nécessaires selon ma classe de base de données n'ont pas été générés par Room. Enfin, l'exécution de gradle clean build dans le terminal m'a donné l'indication qui a conduit à la solution:

"avertissement: le répertoire d'exportation du schéma n'est pas fourni au processeur d'annotations, 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."

J'ai ajouté le paramètre exportSchema = false dans la classe de base de données

@Database(entities = arrayOf(User::class), version = 1, exportSchema = false)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
}

Et puis cela a fonctionné, j'ai trouvé ces deux fichiers générés dans le module d'application sous generatedJava:

• AppDatabase_Impl
• UserDao_Impl

Je ne comprends pas ce comportement car le paramètre est dit facultatif, voir https://stackoverflow.com/a/44645943/3258117

Utilisez le lien gradle suivant:

compile 'android.arch.persistence.room:runtime:1.0.0-alpha9'
annotationProcessor 'android.arch.persistence.room:compiler:1.0.0-alpha9'

Vous devez créer une classe singloton diffretn et obtenir l'Appdatabase comme ceci:

RoomDB.java

public class RoomDB {

private static RoomDB INSTANCE;

public static AppDatabase getInstance(Context context) {
    if (INSTANCE == null) {
        INSTANCE =
                Room.databaseBuilder(context.getApplicationContext(), AppDatabase.class, Constant.DATABASE).allowMainThreadQueries().build();

                //Room.inMemoryDatabaseBuilder(context.getApplicationContext(),AppDatabase.class).allowMainThreadQueries().build();
    }
    return INSTANCE;
}

public static void destroyInstance() {
    INSTANCE = null;
}

App.java

public class App extends Application {

private boolean appRunning = false;

@Override
public void onCreate() {
    super.onCreate();
    RoomDB.getInstance(this); //This will provide AppDatabase Instance
}

Dans mon cas, je testais la connectivité pour la base de données de la salle et j'ai mis la classe de test dans le répertoire que j'ai créé dans le dossier AndroidTest. Je l'ai déplacé hors du répertoire personnalisé, puis cela a plutôt bien fonctionné.

Le même phénomène m'est venu à l'esprit.

Suivant

implementation "android.arch.persistence.room:runtime:1.1.1"

L'ajout provoque une autre erreur de construction mais en suit la cause à partir du journal.

Dans mon cas, il y a eu une erreur dans l'implémentation SQL. Après la correction, la construction a réussi.

Vous voudrez peut-être vérifier la mise en œuvre de toute la bibliothèque de la salle au lieu de regarder les habitants en panne.

Le problème concerne davantage la bibliothèque correcte qui n'est pas incluse dans la version gradle. J'ai eu un problème similaire et j'ai ajouté le manquant

testImplementation "android.arch.persistence.room:testing:$room_version

Changer les dépendances dans mon fichier gradle ne m'a pas aidé à corriger l'erreur.J'avais manqué cette annotation de base de données dans la classe où la base de données de la salle a été initialisée, ce qui causait ce problème.

@Database (entités = [UserModel :: class], version = 1)

Assurez-vous que le modèle d'entité spécifié dans l'annotation ci-dessus fait référence à la classe de modèle particulière

Pour moi, Android Studio a automatiquement mis à jour les dépendances dès que vous incluez l'une des importations liées à la base de données Room. Mais selon https://developer.android.com/jetpack/androidx/releases/room#declaring_dependencies vous devez en mettre à jour quelques-uns. Voici à quoi ressemble ma base de code:

AppDatabase.kt

import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase

@Database(entities = arrayOf(MyEntity::class), version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun myDAO(): MyDAO

    companion object {
        @Volatile private var instance: AppDatabase? = null
        private val LOCK = Any()

        operator fun invoke(context: Context)= instance ?: synchronized(LOCK){
            instance ?: buildDatabase(context).also { instance = it}
        }

        private fun buildDatabase(context: Context) = Room.databaseBuilder(context,
            AppDatabase::class.java, "db-name.db")
            .build()
    }
}

Mettez à jour build.gradle comme spécifié dans l'une des réponses:

apply plugin: 'kotlin-kapt' // this goes with other declared plugin at top
dependencies { // add/update the following in dependencies section
    implementation 'androidx.room:room-runtime:2.2.3'
//    annotationProcessor 'androidx.room:room-compiler:2.2.3' // remove this and use the following
    kapt "androidx.room:room-compiler:2.2.3"

}

Synchronisez le gradle et vous devriez être prêt à partir.

Lire l'exemple ici: Exemple de pièce

J'ai corrigé cette erreur en utilisant simplement le bon (je suppose que c'est) annotationProcessorFile, comme suit:

annotationProcessor "android.arch.persistence.room:compiler:<latest_version>"

De plus, je suis passé à la version 2.2.0 soit dans la version de la salle, soit dans la version Lifecycle.

Une fois le graddle synchronisé, je pourrais commencer à travailler avec Room.

Alors bonne chance! Et laissez le code être avec vous!

Dans mon application kotlin, je viens d'ajouter la ligne suivante en haut de mon fichier build.gradle:

apply plugin: 'kotlin-kapt'

Et la ligne suivante dans la section des dépendances:

kapt "androidx.room:room-compiler:2.2.5"

J'espère que cela résout votre problème.

Pas dans le cas de OP, mais cela se produit également lorsque vous utilisez par erreur implémentation au lieu d' annotationProcessor comme ceci:

implementation "android.arch.persistence.room:compiler:x.x.x"

Au lieu de cela:

annotationProcessor "android.arch.persistence.room:compiler:x.x.x"