La mia classe di database dell'app

@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:+"

E quando chiedo, ad esempio, questo errore, AppDatabase_Impl non esiste nella mia classe di applicazione

public class APp extends Application {

    private boolean appRunning = false;

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

    }   

}

Per coloro che lavorano con Kotlin , prova a passare annotationProcessora kaptnelle appbuild.gradle

per esempio:

// 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"

ricorda anche di aggiungere questo plugin

apply plugin: 'kotlin-kapt'

nella parte superiore del file build.gradle a livello di app ed esegui una pulizia e ricostruzione (secondo https://codelabs.developers.google.com/codelabs/android-room-with-a-view/#6 )

In Android Studio, se si verificano errori quando si incolla il codice o durante il processo di generazione, selezionare Genera> Pulisci progetto. Quindi seleziona Genera> Ricostruisci progetto, quindi compila nuovamente.

AGGIORNARE

Se sei migrato su 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"

Basta usare

apply plugin: 'kotlin-kapt'

in app build.gradle

E mantieni entrambe le dipendenze

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

MODIFICARE

Nella versione più recente non è necessario aggiungere entrambe le dipendenze alla volta Basta usare, spero che funzioni.

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

Ho avuto questo errore quando mi sono perso

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

Assicurarsi che il modello di entità specificato nell'annotazione precedente si riferisca alla particolare classe del modello e assicurarsi inoltre che l'annotazione necessaria:

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

è correttamente definito e saresti bravo

se si utilizzano classi kotlin per implementare il database, utilizzare

apply plugin: 'kotlin-kapt'

e

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

nel tuo file gradle, funzionerà.

Non si tratta solo di aggiornare le tue dipendenze. Assicurati che tutte le dipendenze della tua stanza abbiano la stessa versione.

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"

Nello snippet di esempio sopra, tutte le dipendenze di My Room hanno la stessa versione 1.1.0-alpha2

Per gli sviluppatori Kotlin

Usa questo:

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

E aggiungi apply plugin: 'kotlin-kapt'all'inizio del livello dell'app build.gradle.

Per sviluppatori Java

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

Ho riscontrato questo problema perché ho dimenticato le dipendenze 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"

dopo aver aggiunto l'annotationProcessor e ricostruito, il problema è stato risolto.

Incontro il problema, perché dimentico l' @Daoannotazione

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

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

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

Tutorial ufficiale della sala

assicurati di aggiungere la dipendenza corretta per la room in 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"

E sotto la riga in alto-

apply plugin: 'kotlin-kapt'

La domanda è piuttosto vecchia, ma oggi mi sono imbattuto in questo e nessuna delle risposte fornite mi ha aiutato. Finalmente sono riuscito a risolverlo notando che la documentazione di Google in realtà è ancora adottata su Java e non su Kotlin per impostazione predefinita, in realtà hanno aggiunto un commento che ho ignorato

Per Kotlin usa kapt invece di annotationProcessor

Quindi, invece di

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

Se stai sviluppando con Kotlin, dovresti usare:

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

Ho avuto lo stesso problema. Implementate le poche classi e l'interfaccia come detto ufficialmente in un nuovo progetto di esempio creato da Android Studio: https://developer.android.com/training/data-storage/room/

Tutte le soluzioni sopra menzionate non hanno aiutato, i file _Impl necessari secondo la mia classe di database non sono stati generati da Room. Infine, l'esecuzione di Gradle Clean Build in Terminal mi ha dato il suggerimento che ha portato alla soluzione:

"avviso: la directory di esportazione dello schema non viene fornita al processore delle annotazioni, quindi non possiamo esportare lo schema. Puoi fornire l' room.schemaLocationargomento del processore delle annotazioni O impostare exportSchema su false."

Ho aggiunto il parametro exportSchema = false nella classe del database

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

E poi ha funzionato, ho trovato questi due file generati nel modulo dell'app in generateJava:

• AppDatabase_Impl
• UserDao_Impl

Non capisco questo comportamento poiché si dice che il parametro è facoltativo, vedere https://stackoverflow.com/a/44645943/3258117

Usa il seguente link gradle:

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

Devi creare una classe singloton diffusa e ottenere l'Appdatabase da lì in questo modo:

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
}

Nel mio caso, stavo testando la connettività per il database room e ho inserito la classe test all'interno della directory che ho creato nella cartella AndroidTest. L'ho spostato dalla directory personalizzata, quindi ha funzionato abbastanza bene.

Lo stesso fenomeno mi è venuto in mente.

a seguire

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

L'aggiunta provoca un altro errore di generazione ma tiene traccia della causa dal registro.

Nel mio caso, si è verificato un errore nell'implementazione SQL. Dopo la correzione, la compilazione ha avuto esito positivo.

Quindi potresti voler controllare l'implementazione dell'intera libreria della stanza invece di guardare i locali in crash.

Il problema riguarda più la libreria corretta che non è inclusa nella build gradle. Ho avuto un problema simile e ho aggiunto i dispersi

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

Cambiare le dipendenze nel mio file gradle non mi ha aiutato a correggere l'errore. Avevo perso questa annotazione del database in classe in cui era stato inizializzato il database Room che causava questo problema.

@Database (entity = [UserModel :: class], version = 1)

Assicurarsi che il modello di entità specificato nell'annotazione precedente si riferisca alla particolare classe del modello

Per me, Android Studio ha aggiornato automaticamente le dipendenze non appena includi le importazioni relative al database Room. Ma secondo https://developer.android.com/jetpack/androidx/releases/room#declaring_dependencies è necessario aggiornare alcuni. Ecco come appare la mia base di codice:

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

Aggiorna build.gradle come specificato in una delle risposte:

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"

}

Sincronizza il voto e dovresti essere bravo ad andare.

Leggendo l'esempio qui: Esempio di stanza

Ho corretto questo errore usando solo l'annotazioneProcessorFile corretta (immagino che sia), come segue:

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

Inoltre, ho eseguito l'aggiornamento alla 2.2.0 sia nella versione Room che nella versione Ciclo di vita.

Una volta sincronizzato il graddle, ho potuto iniziare a lavorare con Room.

Quindi buona fortuna! E lascia che il codice sia con te!

Nella mia app kotlin, ho appena aggiunto la seguente riga nella parte superiore del mio file build.gradle:

apply plugin: 'kotlin-kapt'

E la seguente riga nella sezione delle dipendenze:

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

Spero che risolva il tuo problema.

Non nel caso di OP, ma ciò accade anche quando si utilizza erroneamente l' implementazione invece di annotationProcessor in questo modo:

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

Invece di questo:

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