Problem accessing SQLite data in Android with Room. MVVM architecture. LiveData

Question

The following code is an MVVM architecture-based ROOM implementation in Kotlin for Android.

I have a problem with the pre-population of the database. My database doesn't have any data or I can't find the solution to get or insert data.

The IDE doesn't throw any compilation problems.

I think the problem is in the ViewModel but I'm at a dead end.

EDITED: I have seen the DB and it's populated. The insert is fine but not the data read. I will try to modify the ViewModel and its associated livedata and mutablelive data.

This is my data class:

@Entity(tableName = Constants.DATABASE_NAME)
data class Card(
    @PrimaryKey(autoGenerate = true) @ColumnInfo(name = Constants.COLUMN_NAME_ID) val id: Int?,
    @ColumnInfo(name = Constants.COLUMN_NAME_FAV) val fav: Boolean,
    @ColumnInfo(name = Constants.COLUMN_NAME_DATE) val date: Date,
    @ColumnInfo(name = Constants.COLUMN_NAME_RAW_VALUE) val rawValue: String,
    @ColumnInfo(name = Constants.COLUMN_NAME_STORE_TYPE) val storeType: String,
    @ColumnInfo(name = Constants.COLUMN_NAME_STORE_NAME) val storeName: String,
    @ColumnInfo(name = Constants.COLUMN_NAME_STORE_NOTES) val storeNotes: String
)

This is my interface dao

@Insert
suspend fun insertNewCard(card: Card) {
}

@Delete
suspend fun deleteCard(card: Card)

@Query("SELECT * FROM ${Constants.DATABASE_NAME}")
fun getAllCards(): LiveData<List<Card>>

• UPDATE: This is my Database class

@Database(
    entities = [Card::class],
    version = 1,
    exportSchema = true,
    //autoMigrations = [AutoMigration (from = 1, to = 2)]
)
@TypeConverters(Converters::class)

abstract class CardsDatabase : RoomDatabase() {

    abstract fun cardsDao(): CardsDao

    private class CardsDatabaseCallback(private val scope: CoroutineScope)
        : RoomDatabase.Callback() {

        override fun onCreate(db: SupportSQLiteDatabase) {
            super.onCreate(db)
            INSTANCE?.let { database ->
                scope.launch {
                    populateDatabase(database.cardsDao())
                }
            }
        }

        suspend fun populateDatabase(cardsDao: CardsDao) {
            val testCard = Card(null,
                false,
                ((Calendar.getInstance()).time),
                "test",
                "codebar test 1",
                "Prueba tienda",
                "Esta es una tienda de prueba"
            )
            val testCardTwo = Card(null,
                false,
                ((Calendar.getInstance()).time),
                "barcode test 2",
                "codebar",
                "Prueba tienda 2",
                "Esta es una segunda prueba de tienda"
            )
            Log.d("ROOM", "$testCard")
            cardsDao.insertNewCard(testCard)
        }
    }

    companion object {
        @Volatile
        private var INSTANCE: CardsDatabase? = null

        fun getDatabase(context: Context, scope: CoroutineScope): CardsDatabase {
            return INSTANCE ?: synchronized(this) {
                val  instance = Room.databaseBuilder(
                    context.applicationContext,
                    CardsDatabase::class.java,
                    Constants.DATABASE_NAME)
                    .addCallback(CardsDatabaseCallback(scope))
                    .build()
                INSTANCE = instance
                instance
            }

        }
    }

This is the repository class

val allCards: LiveData<List<Card>> = cardsDao.getAllCards()

@Suppress("RedundantSuspendModifier")
@WorkerThread
suspend fun insertCard(card: Card) {
    cardsDao.insertNewCard(card)
}

suspend fun deleteCard(card: Card) {
    cardsDao.deleteCard(card)
}

This is my viewModel:

The Logcat shows as null the LiveData at this point.

private val _allCards = MutableLiveData<List<Card>>()

    val allCards : LiveData<List<Card>> = _allCards

    init {
        getAllCards()
        Log.d("ROOM", "${allCards.value}")
    }

    private fun getAllCards() = viewModelScope.launch {

        _allCards.value = cardRepository.allCards.value

        Log.d("ROOM", "_ : ${_allCards.value}")
    }

    fun insertCard(card: Card) = viewModelScope.launch {
        cardRepository.insertCard(card)
        Log.d("ROOM", "inserted: $card")

    }

}

class CardsViewModelFactory(private val repository: CardRepository) :
    ViewModelProvider.Factory {
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        if (modelClass.isAssignableFrom(CardsViewModel::class.java)) {
            @Suppress("UNCHECKED_CAST")
            return CardsViewModel(repository) as T
        }
        throw IllegalArgumentException("Unknown ViewModel class")
    }

This is the application class:

private val applicationScope = CoroutineScope(SupervisorJob())

private val database by lazy { CardsDatabase.getDatabase(this, applicationScope) }
val repository by lazy { CardRepository(database.cardsDao()) }

For last, the observe in MainActivity:

cardsViewModel.allCards.observe(this) { cards ->
        cards?.let { adapter.setData(it) }
}

Answer 1

The problem is the LiveData created in DAO. To fix it:

• Remove LiveData from DAO to return a List:

@Query("SELECT * FROM ${Constants.DATABASE_NAME}")
 suspend fun getAllCards(): List<Card>

• From the repository, make a suspend fun that gets access to DAO and gets the List, and remove the LiveData type.

suspend fun getAllCards() : List<Card> = cardsDao.getAllCards()

• Change the method to access the repository in ViewModel. It works fine.

private fun getAllCards() = viewModelScope.launch {
        _allCards.value = cardRepository.getAllCards()
 }  

Solved.