How to update Room database in Kotlin without activity refreshing?

Question

I'm fairly new to Kotlin/Android development, and am trying to figure out the best way to update data in a Room database. After following some tutorials, I currently have an architecture that looks like this:

Room Database with tables and DAOs -> Repository -> ViewModel -> Activity

So the activity has a ViewModel that calls the Repository, which in turn updates the database.

The ViewModel for the activity has a LiveData list of the object (there's also a factory to create the ViewModel, but that's just to allow the bookId to be passed in):

class ViewBookViewModel(application: Application, bookId: Int) : AndroidViewModel(application) {
    private val repository: AppRepository
    internal val flashCards: LiveData<List<FlashCard>>

    init {
        val flashCardDao = AppDatabase.getDatabase(application, viewModelScope).flashCardDao()
        val bookDao = AppDatabase.getDatabase(application, viewModelScope).bookDao()
        repository = AppRepository(flashCardDao, bookDao)
        flashCards = flashCardDao.getByBookId(bookId)
    }

    fun insert(flashCard: FlashCard) = viewModelScope.launch(Dispatchers.IO){
        repository.insert(flashCard)
    }

    fun setIsFavorited(cardUid: Long, favorited: Boolean) = viewModelScope.launch(Dispatchers.IO) {
        repository.setIsFavorited(cardUid, favorited)
    }
}

//The actual query that gets called eventually
    @Query("UPDATE flashcard SET is_favorited = :favorited WHERE uid LIKE :cardUid")
fun setFavorited(cardUid: Long, favorited: Boolean)

And the Activity sets up the viewModel and also creates an observer on the

class ViewBookActivity : AppCompatActivity() {
    private lateinit var flashCards: LiveData<List<FlashCard>>
    private var layoutManager: RecyclerView.LayoutManager? = null
    private lateinit var viewModel: ViewBookViewModel
    private var bookId: Int = 0
    private lateinit var bookTitle: String

    override fun onCreate(savedInstanceState: Bundle?) {
...
        bookId = intent.extras["bookId"] as Int
        bookTitle = intent.extras["bookTitle"].toString()

        layoutManager = LinearLayoutManager(this)
        flashCardRecyclerView.layoutManager = layoutManager

        viewModel = ViewModelProviders.of(this, ViewBookViewModelFactory(application, bookId as Int)).get(ViewBookViewModel::class.java)

        flashCards = viewModel.flashCards
        flashCards.observe(this, Observer { flashCards:List<FlashCard> ->
                flashCardRecyclerView.adapter = FlashCardRecyclerAdapter(flashCards, viewModel)
            })
    }
}

Finally, I have a custom RecyclerAdapter, which is where I'm running into trouble. I have it set up so that when the user taps the "favorite" button on the Flash Card, it updates the database. However, this also causes the Activity to "refresh", scrolling to the top. I assume this is because it is observing LiveData, and that data is being changed.

custom RecylcerAdapter with ViewHolder code (stripped not-relevant code):

class FlashCardRecyclerAdapter(val flashCards: List<FlashCard>, val viewModel: ViewBookViewModel) : RecyclerView.Adapter<FlashCardRecyclerAdapter.FlashCardViewHolder>() {
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): FlashCardViewHolder {
        val v: View = LayoutInflater
            .from(parent.context)
            .inflate(R.layout.flash_card, parent, false)
        return FlashCardViewHolder(v)
    }

    override fun onBindViewHolder(holder: FlashCardViewHolder, position: Int) {
        val card = flashCards[position]
        holder.isFavorited = card.isFavorited
        holder.uid = card.uid
        holder.modifyFavoriteButtonImage(holder.isFavorited)
    }

    override fun getItemCount(): Int {
        return flashCards.size
    }

    inner class FlashCardViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView){
        var mFavorited: Button

        var frontShowing: Boolean
        var isFavorited: Boolean = false
        var uid: Long = 0

        init {
            mFavorited = itemView.findViewById(R.id.favoriteButton)

            mFavorited.setOnClickListener { _ ->
                isFavorited = !isFavorited

                viewModel.setIsFavorited(uid, isFavorited) // Here is the database call

                modifyFavoriteButtonImage(isFavorited)
            }
        }

        fun modifyFavoriteButtonImage(isFavorited: Boolean){
            // Code removed, just updates the image to be a filled/empty star based on favorited status
    }
}

I feel like I am probably doing something wrong, as passing the ViewModel into the recylcer adapter in order to update the DB does not seem correct. Is there a pattern I should be using for this sort of situation, or should I change the code to not be using LiveData? Any help would be greatly appreciated.

Answer 1

flashCards.observe(this, Observer { flashCards:List<FlashCard> ->
                flashCardRecyclerView.adapter = FlashCardRecyclerAdapter(flashCards, viewModel)
            }

you should not be making a new adapter instance here, instead, assign the values you get from the live data to the existing adapter (adapter.flashCards = flashCards, LiveData value) and call adapter.notifyDataSetChanged, this will tell your adapter that new data came in and it needs to update.

you should not be passing your ViewModel to your adapter (or anything).

you can do something like this instead:

class FlashCardRecyclerAdapter(val flashCards: List<FlashCard>, val callback:(FlashCard) -> Unit)

then, where you declare your adapter, you do this :

val adapter = FlashCardRecyclerAdapter(...) {
  viewModel.update(it)
}

and then :

override fun onBindViewHolder(holder: FlashCardViewHolder, position: Int) {
        val card = flashCards[position]
        holder.isFavorited = card.isFavorited
        holder.uid = card.uid
        holder.itemView.setOnClickListener {
        callback.invoke(card)
        }

        holder.modifyFavoriteButtonImage(holder.isFavorited)
    }

Answer 2

In your repository method, I am not sure what you are doing there but rather than passing in a livedata instance, you should pass in the underlying data of the livedata instance. That way, the observer in the main activity doesn't get triggered everytime you call setIsFavorited(). If you do want to trigger the observer, then you can just call postValue() on the livedata instance. As for the adapter question, I do not know the best practices but I usually create a listener interface so I don't have to pass around my viewmodels everywhere. All of my viewmodels are contained within my fragments and never goes anywhere else. Let me know if this answers your questions.

Also, if you are using viewmodels with recyclerview, consider using list adapters. They are made to work seamlessly with viewmodels. https://developer.android.com/reference/android/support/v7/recyclerview/extensions/ListAdapter

It makes it much simpler to use viewmodels with recyclerview.