Mi clase de base de datos de aplicaciones

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

Y cuando pregunto, por ejemplo, me dará este error, AppDatabase_Impl no existe en mi clase de aplicación

public class APp extends Application {

    private boolean appRunning = false;

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

    }   

}

Para aquellos que trabajan con Kotlin , intente cambiar annotationProcessora kaptlas aplicacionesbuild.gradle

por ejemplo:

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

También recuerde agregar este complemento

apply plugin: 'kotlin-kapt'

en la parte superior del archivo build.gradle de nivel de aplicación y realice una limpieza y reconstrucción (de acuerdo con https://codelabs.developers.google.com/codelabs/android-room-with-a-view/#6 )

En Android Studio, si obtiene errores al pegar el código o durante el proceso de compilación, seleccione Compilar> Limpiar proyecto. Luego seleccione Compilar> Reconstruir proyecto y luego vuelva a compilar.

ACTUALIZAR

Si has migrado a 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"

Solo usa

apply plugin: 'kotlin-kapt'

en la aplicación build.gradle

Y mantener ambos en dependencias

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

EDITAR

En la versión más reciente, no es necesario agregar ambas dependencias a la vez. Solo use, espero que funcione.

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

Tuve este error cuando perdí

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

Asegúrese de que el modelo de entidad especificado en la anotación anterior se refiere a la clase de modelo particular y también asegúrese de que la anotación necesaria:

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

está bien definido y estarías bien

si está utilizando clases de kotlin para implementar la base de datos, use

apply plugin: 'kotlin-kapt'

y

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

en su archivo gradle, funcionará.

No se trata solo de actualizar sus dependencias. Asegúrese de que todas las dependencias de su sala tengan la misma versión.

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"

En el fragmento de muestra anterior, todas las dependencias de mi sala tienen la misma versión 1.1.0-alpha2

Para desarrolladores de Kotlin

Utilizar este:

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

Y agregue apply plugin: 'kotlin-kapt'a la parte superior del nivel de la aplicación build.gradle.

Para desarrolladores de Java

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

Encontré este problema porque olvidé las dependencias de 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"

Después de agregar el AnnotationProcessor y reconstruirlo, el problema se resolvió.

Me encuentro con el problema, porque olvido la @Daoanotación.

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

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

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

Tutorial oficial de sala

asegúrese de agregar la dependencia correcta para la habitación en 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"

Y debajo de la línea en la parte superior

apply plugin: 'kotlin-kapt'

La pregunta es bastante antigua, pero me he topado con esto hoy y ninguna de las respuestas proporcionadas me ayudó. Finalmente logré resolverlo notando que la documentación de Google en realidad todavía está adoptada en Java y no en Kotlin por defecto, en realidad han agregado un comentario que ignoré

Para Kotlin, use kapt en lugar de anotaciónProcessor

Entonces, en lugar de

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

Si está desarrollando con Kotlin, debe usar:

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

Tuve el mismo problema Implementé las pocas clases e interfaz como se dijo oficialmente en un nuevo proyecto de ejemplo creado por Android Studio: https://developer.android.com/training/data-storage/room/

Todas las soluciones mencionadas anteriormente no ayudaron, los archivos necesarios _Impl de acuerdo con mi clase de base de datos no fueron generados por Room. Finalmente, ejecutar gradle clean build en la terminal me dio la pista que condujo a la solución:

"advertencia: el directorio de exportación de esquema no se proporciona al procesador de anotaciones, por lo que no podemos exportar el esquema. Puede proporcionar room.schemaLocation argumento del procesador de anotación O establecer exportSchema en falso".

Agregué el parámetro exportSchema = false en la clase de base de datos

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

Y luego funcionó, encontró estos dos archivos generados en el módulo de la aplicación en generadoJava:

• AppDatabase_Impl
• UserDao_Impl

No entiendo este comportamiento ya que se dice que el parámetro es opcional, consulte https://stackoverflow.com/a/44645943/3258117

Use el siguiente enlace de gradle:

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

Necesita crear una clase de singloton diferente y obtener la base de datos de aplicaciones de esta manera:

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
}

En mi caso, estaba probando la conectividad para la base de datos de la sala y puse la clase de prueba dentro del directorio que he creado dentro de la carpeta AndroidTest. Lo saqué del directorio personalizado, luego funcionó bastante bien.

Se me ocurrió el mismo fenómeno.

siguiendo

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

Agregar provoca otro error de compilación pero rastrea la causa desde el registro.

En mi caso, hubo un error en la implementación de SQL. Después de arreglar, la construcción fue exitosa.

Por lo tanto, es posible que desee verificar la implementación de toda la biblioteca de la sala en lugar de mirar a los locales bloqueados.

El problema está más relacionado con la biblioteca correcta que no está incluida en la construcción de Gradle. Tuve un problema similar y agregué los que faltaban

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

Cambiar las dependencias en mi archivo gradle no me ayudó a corregir el error. Me había perdido esta anotación de la base de datos en la clase donde se inicializó la base de datos de la sala que estaba causando este problema.

@Database (entidades = [UserModel :: class], versión = 1)

Asegúrese de que el modelo de entidad especificado en la anotación anterior se refiere a la clase de modelo particular

Para mí, Android Studio actualizó automáticamente las dependencias tan pronto como incluyeste las importaciones relacionadas con la base de datos de Room. Pero según https://developer.android.com/jetpack/androidx/releases/room#declaring_dependencies necesita actualizar algunas. Así es como se ve mi código base:

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

Actualice build.gradle como se especifica en una de las respuestas:

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"

}

Sincronice el gradle y debería estar listo para comenzar.

Leyendo el ejemplo aquí: Ejemplo de habitación

Solucioné este error simplemente usando la anotación correcta (supongo que es) ancessationProcessorFile, de la siguiente manera:

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

Además, actualicé a 2.2.0 en la versión Room como en la versión Lifecycle.

Una vez sincronizado el graddle, podría comenzar a trabajar con Room.

¡Buena suerte! ¡Y deja que el código te acompañe!

En mi aplicación kotlin, acabo de agregar la siguiente línea en la parte superior de mi archivo build.gradle:

apply plugin: 'kotlin-kapt'

Y la siguiente línea en la sección de dependencias:

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

Espero que solucione tu problema.

No en el caso de OP, pero esto también sucede cuando usa la implementación por error en lugar de un AnnotationProcessor como este:

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

En lugar de esto:

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