How I can update my adapter for RecyclerView after change my LiveData?

Question

I created a fragment that in the onActivityCreated method fetches Firebase data by limiting the query to a calendar date. Then I place Observers on my LiveData that are inside my ViewModel and that will deliver the list to my Adapter.

If I add, remove or update items in the same list, the changes are sent to firebase and the adapter reflects them on the screen. It works ok.

But, I am trying to develop a filter button, which will basically change the deadline date for the Firebase query. When I select a particular filter, the viewModel needs to retrieve the data from Firebase limited to the filter date. This generates a new list, having a different size from the previous one.

However, when the query occurs, the Adapter's getItemCount() method stores the size of the last list. This fact confuses the Adapter and the functions notifyItemInserted and notifyItemRemoved end up making confusing animations on the screen after changing the filter. I dont know whats is wrong.

How can I correctly observes LiveData and tell the adapter? Am I making a mistake in the MVVM architecture or forgetting some function?

My Fragment:

class HistoryFragment : Fragment(), OnItemMenuRecyclerViewClickListener {

private lateinit var mSecurityPreferences: SecurityPreferences
private lateinit var viewModel: BalancesViewModel
private lateinit var adapter: BalancesAdapter

override fun onCreateView(
    inflater: LayoutInflater,
    container: ViewGroup?,
    savedInstanceState: Bundle?
): View? {
    setHasOptionsMenu(true)

    viewModel = ViewModelProvider(this).get(BalancesViewModel::class.java)
    adapter = BalancesAdapter(requireContext())
    mSecurityPreferences = SecurityPreferences(requireContext())

    return inflater.inflate(R.layout.fragment_history, container, false)
}

override fun onActivityCreated(savedInstanceState: Bundle?) {
    super.onActivityCreated(savedInstanceState)

    setupFilter()

    //Setup adapter
    adapter.listenerMenu = this
    recycler_view_history.adapter = adapter

    //Fetch data based in filter by date
    viewModel.fetchBalances(mSecurityPreferences.getStoredLong(FILTER_DATE))

    // Put logic to listen RealTimeUpdates
    viewModel.getRealTimeUpdates(mSecurityPreferences.getStoredLong(FILTER_DATE))

    viewModel.balances.observe(viewLifecycleOwner, Observer {
        adapter.setBalances(it)
    })

    viewModel.balance.observe(viewLifecycleOwner, Observer {
        adapter.addBalance(it)
    })

}

override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
    inflater.inflate(R.menu.history_menu_filter, menu)
    super.onCreateOptionsMenu(menu, inflater)
}

override fun onOptionsItemSelected(item: MenuItem): Boolean {
    when (item.itemId) {
        R.id.item_menu_filter_this_month -> {
            updateFilter(THIS_MONTH)
        }
        R.id.item_menu_filter_two_months -> {
            updateFilter(TWO_MONTHS)
        }
        R.id.item_menu_filter_last_six_months -> {
            updateFilter(LAST_SIX_MONTHS)
        }
        R.id.item_menu_filter_all -> {
            updateFilter(ALL_MONTHS)
        }
    }
    return super.onOptionsItemSelected(item)
}

private fun setupFilter() {
    var filterOption = mSecurityPreferences.getStoredLong(FILTER_DATE)
    if (filterOption == 0L){
        filterOption = HandleDate.getLongToFilter(LAST_SIX_MONTHS)
        mSecurityPreferences.storeLong(FILTER_DATE, filterOption)
    }
}

private fun updateFilter(filterOption: Int){
    val newFilterOption = HandleDate.getLongToFilter(filterOption)
    mSecurityPreferences.storeLong(FILTER_DATE, newFilterOption)
    updateUI()
}

private fun updateUI(){
    viewModel.fetchBalances(mSecurityPreferences.getStoredLong(FILTER_DATE))
    viewModel.getRealTimeUpdates(mSecurityPreferences.getStoredLong(FILTER_DATE))

}
}

My ViewModel:

class BalancesViewModel : ViewModel() {

private val userReference = FirebaseAuth.getInstance().currentUser!!.uid
private val dbUserReference = FirebaseDatabase.getInstance().getReference(userReference)

private val _balances = MutableLiveData<List<Balance>>()
val balances: LiveData<List<Balance>>
    get() = _balances

private val _balance = MutableLiveData<Balance>()
val balance: LiveData<Balance>
    get() = _balance

private val _result = MutableLiveData<Exception?>()
val result: LiveData<Exception?>
    get() = _result


fun addBalance(balance: Balance) {
    balance.id = dbUserReference.push().key
    dbUserReference.child(NODE_BALANCES).child(balance.id!!).setValue(balance)
        .addOnCompleteListener {
            if (it.isSuccessful) {
                _result.value = null
            } else {
                _result.value = it.exception
            }

        }
}

private val childEventListener = object : ChildEventListener {
    override fun onCancelled(error: DatabaseError) {
    }

    override fun onChildMoved(snapshot: DataSnapshot, p1: String?) {
    }

    override fun onChildChanged(snapshot: DataSnapshot, p1: String?) {
        val balance = snapshot.getValue(Balance::class.java)
        balance?.id = snapshot.key
        _balance.value = balance
    }

    override fun onChildAdded(snapshot: DataSnapshot, p1: String?) {
        val balance = snapshot.getValue(Balance::class.java)
        balance?.id = snapshot.key
        _balance.value = balance
    }

    override fun onChildRemoved(snapshot: DataSnapshot) {
        val balance = snapshot.getValue(Balance::class.java)
        balance?.id = snapshot.key
        balance?.isDeleted = true
        _balance.value = balance
    }
}

fun getRealTimeUpdates(longLimitDate: Long) {
    dbUserReference.child(NODE_BALANCES).orderByChild(COLUMN_DATE_MILLI)
        .startAt(longLimitDate.toDouble()).addChildEventListener(childEventListener)
}

fun fetchBalances(longLimitDate: Long) {
    dbUserReference.child(NODE_BALANCES).orderByChild(COLUMN_DATE_MILLI)
        .startAt(longLimitDate.toDouble())
        .addListenerForSingleValueEvent(object : ValueEventListener {
            override fun onCancelled(error: DatabaseError) {}

            override fun onDataChange(snapshot: DataSnapshot) {
                if (snapshot.exists()) {
                    val listBalances = mutableListOf<Balance>()
                    for (balanceSnapshot in (snapshot.children)) {
                        val balance = balanceSnapshot.getValue(Balance::class.java)
                        balance?.id = balanceSnapshot.key
                        balance?.let { listBalances.add(it) }
                    }
                    listBalances.sortByDescending { it.dateMilli }
                    _balances.value = listBalances
                   
                }
            }

        })
}

fun updateBalance(balance: Balance) {
    dbUserReference.child(NODE_BALANCES).child(balance.id!!).setValue(balance)
        .addOnCompleteListener {
            if (it.isSuccessful) {
                _result.value = null
            } else {
                _result.value = it.exception
            }

        }
}

fun deleteBalance(balance: Balance) {
    dbUserReference.child(NODE_BALANCES).child(balance.id!!).setValue(null)
        .addOnCompleteListener {
            if (it.isSuccessful) {
                _result.value = null
            } else {
                _result.value = it.exception
            }

        }
}

My Adapter:

class BalancesAdapter(private val context: Context) :
RecyclerView.Adapter<BalancesAdapter.BalanceViewModel>() {

private var balances = mutableListOf<Balance>()

override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) =
    BalanceViewModel(
        LayoutInflater.from(parent.context)
            .inflate(R.layout.item_recyclerview_balance, parent, false)
    )
override fun getItemCount() = balances.size

override fun onBindViewHolder(holder: BalanceViewModel, position: Int) {
    holder.view.text_view_value_balance_item.text = balances[position].value
    holder.view.text_view_date_item.text = balances[position].date
}

fun setBalances(balances: List<Balance>) {
    this.balances = balances as MutableList<Balance>
    notifyDataSetChanged()
}

fun addBalance(balance: Balance) {
    val index = balances.indexOf(balance)
    if (!balances.contains(balance)) {
        balances.add(balance)
        notifyItemInserted(index)
    } else {
        if (balance.isDeleted) {
            balances.removeAt(index)
            notifyItemRemoved(index)
        } else {
            balances[index] = balance
        }
    }
    notifyItemRangeChanged(index, itemCount)
}

class BalanceViewModel(val view: View) : RecyclerView.ViewHolder(view)

}

Tnks for your attention.

Answer 1

Okay, it's been 4 days since I asked this question and after feeling a little frustrated with the project I come back here on StackOverFlow to post my own answer.

The problematic issue within the code I showed is in my Adapter's addBalance method.

When I created the Balance data model, I set the isDeleted attribute to identify that it was deleted. Upon entering Firebase it receives a NULL value and therefore it ceases to exist.

Then, as I have two listeners (one defined in the addListenerForSingleValueEvent method and the other defined in the addChildEventListener method), one ends up triggering the other when there is a change in the Firebase data, but I don't want to go into detail on that issue. The fact is that I checked that my addBalance method was being called after I deleted an object, causing that object to be inserted back into the Adapter's data list, even before the removal operation ended in Firebase.

So I changed the logic of my method to make sure that my object was deleted and only included it in my Adapter list after checking the isDeleted attribute.

fun dealWithBalance(balance: Balance){

    val index = balances.indexOf(balance)
    if(balance.isDeleted && balances.contains(balance)){
        balances.removeAt(index)
        notifyItemRemoved(index)
    } else if(!balance.isDeleted && !balances.contains(balance)){
        balances.add(balance)
    } else if(index >= 0){
        balances[index] = balance
        notifyItemChanged(index)
    }
}

I renamed addBalance to dealWithBalance...