RecyclerView getting way too complex

Question

Context

So, I don't know if any of you has ever gone through the same situation but I've recently taken over an app and we have this RecyclerView on the main screen - because of an NDA I'll change a few things - that shows a list of apartments that you can rent - picture the AirBnB app - and if you tap on one of these apartment items you go to the apartment detail, where you have a bit more of functionality and features.

The thing is that we have way too many moving parts on the apartment list. For example, on each apartment ViewHolder you can:

• Use a checkmark to specify if you are going to bring any pets with you.
• A few UI items to specify how long are you going to stay.
• An EditText to set how may people are going to come.
• A Rent button that turns itself into a spinner and sends an API call.
• A More Options button that expands the ViewHolder, showing a LinearLayout with yet more UI.

Picture something like this

This is actually a simpler example of what I really have. Let me tell you that it looks as if each ViewHolder could be a Fragment because of all the functionality that we have on each.

Now what's the problem here?

Recycling issues. If you scroll off, and scroll back to the same position you are supposed to keep the same state that you had on that ViewHolder, right? If you had checked a CheckButton that's supposed to be check. If you had written something on an EditText, that's supposed to be there. If you had expanded the More Options section, that's supposed to be expanded. You see where I'm going at?

What am I asking here?

Well, about feedback for a possible solution or improvement. I know what most of you would tell me here - because it is the same thing I thought at first - just move all that functionality into the apartment detail, keep that list as simple as possible. But it is not as simple, we have a large user base who is already used to this UI. Changing things so abruptly is not an option.

What do I have right now?

In my RecyclerView adapter I keep a collection of "State" objects which I use to save/restore the ViewHolder states, but it is getting way too big and way too complex. This may sound crazy, but it is there such thing as having a RecyclerList of Fragments? I just don't want to worry/bother about keeping the states of these ViewHolder anymore.

Notes

Sorry I haven't provided any code, but there's not much to show actually, as you may imagine the onBindViewHolder is just a humongous piece of code that sets the views with the data I fetch from the API plus the data that I store in these "State" objects. I save these "State" objects via the onViewDetachedFromWindows() hook from the adapter class that gets triggered when a ViewHolder scrolls off from screen. I wipe out these "State" objects when I fetch a new API response.

Any feedback is appreciated, Thanks!🙇

Answer 1

Your post is vague in it's high-level description but I'll try to comment in a similar manner that may guide you towards solutions.

First, as was already mentioned Epoxy is a thing. As is adapter delegates. You may find those useful. However, you don't need a library to solve you problem - you need separation of concerns and architecture.

---

The thing is that we have way too many moving parts on the apartment list.

OK, so first suggestion is to stop having too many moving parts in the list. Each thing you listed could / should be it's own (custom) view that is driven by it's own ViewModel. A recycler view / view holder / adapter should be as stupid as possible. All those things should be doing is filling in boilerplate that Android requires. Actual logic should exist elsewhere.

If you scroll off, and scroll back to the same position you are supposed to keep the same state that you had on that ViewHolder, right?

No. Your ViewHolder should not maintain state. A ViewHolder holds views so Android doesn't have to re-inflate stuff over and over. It should not keep track of its state - it should be told what its current state is.

You should have a list of data objects (view models) that represent the current state of each item in the list. When you scroll off and back to the same position, you are supposed to re-bind the item that should be at that position to the view that represents it. Saving and clearing "state" objects should not be necessary - you should always have the current state on hand because it's the underlying data model driving your whole UI.

In my RecyclerView adapter I keep a collection of "State" objects which I use to save/restore the ViewHolder states, but it is getting way too big and way too complex

If something is too big and complex, break it down. Instead of having one giant-ass state object for each item, use composition. Make this item state have properties that represent pieces of the UI - PetModel, DateRangeModel, etc.

This may sound crazy, but it is there such thing as having a RecyclerList of Fragments? I just don't want to worry/bother about keeping the states of these ViewHolder anymore.

That does sound crazy because not only would this not solve your problem, you would probably actually make it significantly worse. You don't want to manage the state of a bunch of ViewHolders but you want to manage the states of a bunch of Fragments!? Bruh.

as you may imagine the onBindViewHolder is just a humongous piece of code that sets the views with the data I fetch from the API plus the data that I store in these "State" objects.

Again, break that up. You should not be slapping "data I fetched from the API" directly onto views. Invariably you will need to massage and transform raw data from an API before you display it. This should be handled by a dedicated object (again, ViewModel or some other structure). Again, views should be dumb. Tell them their state and that's it - don't do logic at this level.

Please read the Android Architecture Guide. Also Google around for "Clean Architecture" - that seems to be all the range in Android these days.

And finally - here's some very rough pseudocode of how you could structure this to be more testable and maintainable.

From the bottom up:

• ApiClient - responsible for just fetching the raw data from the API endpoint or reporting an error.
• ApiResponseModel - language-specific object representation of the data you'll get from the API. Has info on the pet, dates, guest count, etc. May contain submodels.
• ItemDomainModel - client side representation of your data after transforming the data you'll get from the API.
• Repository - uses the ApiClient to fetch the data as ApiResponseModel and transforms it into a ItemDomainModel object that makes more sense for your app.
• ItemViewModel - Represents the UI state of a single item in the RecyclerView. Takes a ItemDomainModel instance and exposes the state of the UI based on the state of that model. This can be broken down if it's too complex (PetStateViewModel, DateRangeViewModel, GuestCountViewModel, etc)
• ListViewModel - The top-level Android ViewModel that represents the state of the screen. Uses the Repository to fetch the data then constructs a list of ItemViewModels to feed into the RecyclerViewAdapter.

If you get those pieces in place, your view binding in the adapter should be stupid dumb:

override fun onBindViewHolder(viewHolder: ViewHolder, position: Int) {
    // The adapter list should be a list of view models populated by the
    // fragment after the ListViewModel returns a list of them from the fetch
    val itemViewModel = itemViewModels[position]
    
    // Populating this item view should just be a one-to-one mapping of the view model
    // state - NO LOGIC. Dumb. Stupid. Tonto.
    viewHolder.bringingPets.isChecked = itemViewModel.isBringingPets
    viewHolder.guestCount.text = itemViewModel.guestCount
    // ... etc, etc (if you use databinding this is a one-liner and even stupider)

    // Set up your event listeners so interacting with this specific item in the list
    // updates the state of the underlying data model
    viewHolder.bringingPets.setOnCheckChanged { itemViewModel.isBringingPets = it.isChecked }
    viewHolder.rentButton.onClickListener { itemViewModel.rentThis() }
    // ... etc, etc
}

The goal is to do as little as possible here. Just update the state and wire up your callbacks that just delegate back to the ViewModel. Then, those UI states are driven by the logic in the view model. This is where you do business logic that determines how the UI should look.

class ItemViewModel(private val dataModel: ItemDomainModel) {
    var isBringingPets: Boolean
        get() = /* some business logic that determines if the checkbox is checked */
        set(value) /* update underlying state and notify of changes */

    // ... etc, etc, for guest count and other properties

    fun rentThis() {
        // Fire an event or update live data or invoke a callback that
        // the fragment can use to respond
    }

    // ... etc, etc, for other functions that respond to UI events
}

In Summary

Refactor your code to break down the huge and complex logic into dedicated components that each have a simpler, specific focus, then compose them together to get the behavior you want. Good luck.