Classe do banco de dados do meu aplicativo

@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 eu pedir, por exemplo, ele dará esse erro, AppDatabase_Impl não existe na minha classe de aplicativo

public class APp extends Application {

    private boolean appRunning = false;

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

    }   

}

Para aqueles que trabalham com Kotlin , tente mudar annotationProcessorpara kaptnos aplicativosbuild.gradle

por exemplo:

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

lembre-se de adicionar este plugin

apply plugin: 'kotlin-kapt'

na parte superior do arquivo build.gradle no nível do aplicativo e faça uma limpeza e reconstrução (de acordo com https://codelabs.developers.google.com/codelabs/android-room-with-a-view/#6 )

No Android Studio, se você receber erros ao colar o código ou durante o processo de compilação, selecione Compilar> Limpar projeto. Em seguida, selecione Build> Rebuild Project e, em seguida, construa novamente.

ATUALIZAR

Se você migrou para o 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"

Apenas use

apply plugin: 'kotlin-kapt'

no aplicativo build.gradle

E mantenha ambos em dependências

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

EDITAR

Na versão mais recente, não é necessário adicionar as duas dependências por vez. Basta usar, espero que funcione.

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

Eu tive esse erro quando perdi

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

Certifique-se de que o modelo de entidade especificado na anotação acima se refira à classe de modelo específica e também garanta que a anotação necessária:

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

está definido corretamente e você seria bom

Se você estiver usando classes kotlin para implementar banco de dados, use

apply plugin: 'kotlin-kapt'

e

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

no seu arquivo gradle, ele funcionará.

Não se trata apenas de atualizar suas dependências. Verifique se todas as dependências da sala têm a mesma versão.

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"

No snippet de amostra acima, todas as minhas dependências da sala têm a mesma versão 1.1.0-alpha2

Para desenvolvedores Kotlin

Usa isto:

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

E adicione apply plugin: 'kotlin-kapt'ao topo do nível do aplicativo build.gradle.

Para desenvolvedores Java

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

Encontrei esse problema porque esqueci as dependências do 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"

depois de adicionar o annotationProcessor e reconstruí-lo, o problema foi resolvido.

Eu me deparo com o problema, porque esqueci a @Daoanotação

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

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

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

Tutorial oficial da sala

certifique-se de adicionar a dependência correta para o espaço no 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 abaixo da linha no topo

apply plugin: 'kotlin-kapt'

A pergunta é bem antiga, mas eu me deparei com isso hoje e nenhuma das respostas fornecidas me ajudou. Finalmente, consegui resolvê-lo percebendo que a documentação do Google ainda é adotada no Java e não no Kotlin por padrão. Na verdade, eles adicionaram um comentário que eu ignorei

Para o Kotlin, use o kapt em vez de annotationProcessor

Então, ao invés de

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

Se você estiver desenvolvendo com o Kotlin, use:

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

Teve o mesmo problema. Implementou as poucas classes e interfaces conforme oficialmente relatadas em um novo projeto de exemplo criado pelo Android Studio: https://developer.android.com/training/data-storage/room/

Todas as soluções mencionadas acima não ajudaram, os arquivos _Impl necessários de acordo com a minha classe de banco de dados não foram gerados pelo Room. Finalmente, a execução de gradle clean build no terminal deu-me a dica que levou à solução:

"aviso: o diretório de exportação do esquema não é fornecido ao processador de anotações, portanto não podemos exportar o esquema. Você pode fornecer o room.schemaLocationargumento do processador de anotações OU definir exportSchema como false."

Adicionei o parâmetro exportSchema = false na classe de banco de dados

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

E então funcionou, encontrou esses dois arquivos gerados no módulo de aplicativo em generateJava:

• AppDatabase_Impl
• UserDao_Impl

Eu não entendo esse comportamento, pois o parâmetro é opcional, consulte https://stackoverflow.com/a/44645943/3258117

Use o seguinte link gradle:

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

Você precisa criar diferentes classes de singlotons e obter o Appdatabase a partir desta forma:

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
}

No meu caso, eu estava testando a conectividade para o banco de dados da sala e coloquei a classe de teste dentro do diretório que criei na pasta AndroidTest. Mudei para fora do diretório personalizado e funcionou muito bem.

O mesmo fenômeno me ocorreu.

Segue

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

A adição causa outro erro de construção, mas rastreia a causa no log.

No meu caso, houve um erro na implementação do SQL. Após a correção, a compilação foi bem-sucedida.

Portanto, convém verificar a implementação de toda a biblioteca da sala, em vez de examinar os locais afetados.

O problema é mais sobre a biblioteca correta que não está incluída na compilação gradle. Eu tive um problema semelhante e adicionei o item ausente

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

Alterar as dependências no meu arquivo gradle não me ajudou a corrigir o erro. Eu havia perdido essa anotação de banco de dados na classe em que o banco de dados da sala foi inicializado, causando o problema.

@Database (entidades = [UserModel :: class], versão = 1)

Verifique se o modelo de entidade especificado na anotação acima se refere à classe de modelo específica

Para mim, o Android Studio atualizou automaticamente as dependências assim que você incluir qualquer importação relacionada ao banco de dados da sala. Mas, de acordo com https://developer.android.com/jetpack/androidx/releases/room#declaring_dependencies, você precisa atualizar alguns. Aqui está como minha base de código se parece:

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

Atualize o build.gradle conforme especificado em uma das respostas:

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"

}

Sincronize o gradle e você deve estar pronto.

Lendo o exemplo aqui: Exemplo de Sala

Corrigi esse erro usando apenas o correto (acho que é) annotationProcessorFile, da seguinte maneira:

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

Além disso, atualizei para o 2.2.0 na versão Room ou na versão Lifecycle.

Depois de sincronizar a grade, eu poderia começar a trabalhar com o Room.

Então boa sorte! E deixe o código estar com você!

No meu aplicativo kotlin, acabei de adicionar a seguinte linha na parte superior do meu arquivo build.gradle:

apply plugin: 'kotlin-kapt'

E a seguinte linha na seção de dependências:

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

Espero que isso resolva seu problema.

Não no caso do OP, mas isso também acontece quando você usa a implementação por engano em vez do annotationProcessor como este:

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

Em vez disso:

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