The best Android Recycler Adapter you’ve ever seen. Probably
Composable, and also the shortest Android Recycler Adapter you could dream of. And I assure you, as soon as you make it only once, you will love it!
All you need to setup your Adapter in most cases is (MovieCell, LoadingCell, ErrorCell are types of a cell here):
class MoviesListAdapter(listener: AdapterListener): BaseListAdapter(
MovieCell, LoadingCell, ErrorCell,
listener = listener
)All you need to create a new type of a Cell in most cases is:
object MovieCell : Cell<RecyclerItem>() {
override fun belongsTo(item: RecyclerItem?): Boolean {
return item is Movie
}
override fun type(): Int {
return R.layout.item_movie
}
override fun holder(parent: ViewGroup):RecyclerView.ViewHolder {
return MovieViewHolder(parent.viewOf(type()))
}
override fun bind(
holder: RecyclerView.ViewHolder,
item: RecyclerItem?,
listener: AdapterListener?
) {
if (holder is MovieViewHolder && item is Movie) {
holder.bind(item)
holder.itemView.setOnClickListener {
listener?.listen(item)
}
}
}}
This solution not only doesn’t have switches, scattered through 3 different methods (getItemViewType, onCreateViewHolder, onBindViewHolder), but is clean, short and expressive, and it allows you to compose Adapters from different sets of Cells.
It’s adaptable for RecyclerView.Adapter, ListAdapter, and also paging library PagedListAdapter. You only have to create new BaseAdapter for each.
Content:
1. I’ll give the code to copy to make it work.
2. I’ll explain step by step how to use it.
3. For curious ones, we’ll dig into the details.
4. Conclusion
What I have to copy to make it work
Below there is a set of abstractions that will allow you to create Adapters as simple and convenient as above.
Cell that represents, well, an Adapter cell:
abstract class Cell<T> {
abstract fun belongsTo(item: T?): Boolean
abstract fun type(): Int
abstract fun holder(parent: ViewGroup): RecyclerView.ViewHolder
abstract fun bind(holder: RecyclerView.ViewHolder, item: T?, listener: AdapterListener?)
protected fun ViewGroup.viewOf(@LayoutRes resource: Int): View {
return LayoutInflater
.from(context)
.inflate(resource, this, false)
}
}CellTypes class that represents a set of Cells, that is available for Adapter:
class CellTypes<T>(vararg types: Cell<T>) {
private val cellTypes: ArrayList<Cell<T>> = ArrayList()
init {
types.forEach { addType(it) }
}
fun addType(type: Cell<T>) {
cellTypes.add(type)
}
fun of(item: T?): Cell<T> {
for (cellType in cellTypes) {
if (cellType.belongsTo(item)) return cellType
}
throw NoSuchRecyclerItemTypeException()
}
fun of(viewType: Int): Cell<T> {
for (cellType in cellTypes) {
if (cellType.type() == viewType) return cellType
}
throw NoSuchRecyclerViewTypeException()
}
}BaseListAdapter, which in our example extends recyclerview.extensions.ListAdapter
(you can also apply the same approach for RecyclerView.Adapter, as well as for paging library PagedListAdapter)
abstract class BaseListAdapter(
vararg types: Cell<RecyclerItem>,
private val listener: AdapterListener? = null
) : ListAdapter<RecyclerItem, RecyclerView.ViewHolder>(BASE_DIFF_CALLBACK) {
private val cellTypes: CellTypes<RecyclerItem> = CellTypes(*types)
override fun getItemViewType(position: Int): Int {
val item = getItem(position)
return cellTypes.of(item).type()
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
return cellTypes.of(viewType).holder(parent)
}
override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
val item = getItem(position)
cellTypes.of(item).bind(holder, item, listener)
}
}RecyclerItem that represents an object passed to the adapter that will be converted to a Cell:
interface RecyclerItem {
val id: String?
override fun equals(other: Any?): Boolean
}Two interfaces for communication between your adapter and a view that holds it:
interface AdapterListener {
fun listen(click: AdapterClick?)
}interface AdapterClick
And base diff that works with it:
val BASE_DIFF_CALLBACK = object : DiffUtil.ItemCallback<RecyclerItem>() {
override fun areItemsTheSame(oldItem: RecyclerItem, newItem: RecyclerItem): Boolean {
return oldItem.id == newItem.id
}
override fun areContentsTheSame(oldItem: RecyclerItem, newItem: RecyclerItem): Boolean {
return oldItem == newItem
}
}And two Exceptions:
class NoSuchRecyclerItemTypeException : RuntimeException()
class NoSuchRecyclerViewTypeException : RuntimeException()That’s pretty much it.
How do I use it?
Let’s try it taking “Movie” as an example.
1. Implement a Cell
- In belongsTo() there should be an object that you are converting into a list cell
- In type() there should be a layout for this object
- In holder() there should be a RecyclerView.ViewHolder for this cell
- In bind() you bind info to the cell, add click listeners, change background, etc
object MovieCell : Cell<RecyclerItem>() {
override fun belongsTo(item: RecyclerItem?): Boolean {
return item is Movie
}
override fun type(): Int {
return R.layout.item_movie
}
override fun holder(
parent: ViewGroup
): RecyclerView.ViewHolder {
return MovieViewHolder(parent.viewOf(type()))
}
override fun bind(
holder: RecyclerView.ViewHolder,
item: RecyclerItem?,
listener: AdapterListener?
) {
if (holder is MovieViewHolder && item is Movie) {
holder.bind(item)
holder.itemView.setOnClickListener {
listener?.listen(item)
}
}
}
}I advise to keep all info binding logic inside a ViewHolder’s method bind() to make it reusable even if you use the same view outside of a recycler’s adapter.
(In example above, besides info binding, I added a listener to the whole cell. When the cell is clicked, listener will get an object of corresponding Movie)
2. Object class, 3. Layout for this object, 4. ViewHolder
Implementation of the steps above I leave up to you. Remember, that movie should implement RecyclerItem and AdapterClick interfaces. Second one, if you want to listen clicks on items, or inside them.
If you have any questions, feel free to write comments. I’ll try to help, or improve the article.
5. Create Adapter
class MovieAdapter(listener: AdapterListener) : BaseListAdapter(
MovieCell,
listener = listener
)6. Implement listener
Inside your Fragment (Activity, or any other view that contains recycler), create adapter, passing listener inside:
override fun listen(click: AdapterClick?) {
when (click) {
is Movie -> // E.g. open movie details
}
}Initialize recycler, pass a list of movies inside the adapter.
And that’s actually it. Now you can add other types of a cell, including such often used ones as LoadingCell or ErrorCell. And all these cells are totally reusable throughout all the adapters.
Congrats, you’ve done it!
Let’s dive into a little detail
Why have I spent time on such a thing at all? As we all do, I wanted to get rid of boilerplate code.
Traditional approach
I believe the vast majority is familiar with this basic type of adapter created to display several types of a cell:
override fun getItemViewType(position: Int): Int {
val item = list.get(position)
return if (item is Movie) {
TYPE_MOVIE
} else if (item is Progress) {
TYPE_PROGRESS
} else if (item is Error) {
TYPE_ERROR
} else {
throw NoSuchRecyclerItemTypeException()
}
}and
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
val inflater = LayoutInflater.from(parent.context)
if (viewType == TYPE_MOVIE) {
val view = inflater.inflate(R.layout.item_movie, parent, false)
return MovieViewHolder(view)
} else if (viewType == TYPE_PROGRESS) {
val view = inflater.inflate(R.layout.item_progress, parent, false)
return ProgressViewHolder(view)
} else if (viewType == TYPE_ERROR) {
val view = inflater.inflate(R.layout.item_error, parent, false)
return ErrorViewHolder(view)
} else {
throw NoSuchRecyclerViewTypeException()
}
}and also
override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
if (holder is MovieViewHolder) {
(holder as MovieViewHolder).bind(list.get(position) as Movie)
} else if (holder is AdViewHolder) {
(holder as ErrorViewHolder).bind(list.get(position) as Error)
} else if (holder is ProgressViewHolder) {
// Do nothing
}
}I think most of you will agree, that it’s hard to read, hard to maintain. It’s error-prone, because every time you need a change you have to make it in 3 places. And it’s just ugly, and a hell lot of a code. You also have to duplicate code for identical cells in different adapters. This is how I did it, this is how most of us did it at a certain point.
Then I came across better solutions.
Improved approaches
Alternative options I saw resolved some problems. Usually they kept code for one cell in one place, that was a really great improvement.
As an example, we have Adapter, that goes through an Enum called CellType:
override fun getItemViewType(position: Int): Int {
return CellType[list.get(position)].type()
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
return CellType[viewType].holder(parent)
}
override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
val item = list.get(position)
CellType[item].bind(holder, item)
}CellType contains four abstract methods for cells to implement, and two other for finding a necessary cell:
private enum class CellType { internal abstract fun `is`(item: Any): Boolean
internal abstract fun type(): Int
internal abstract fun holder(parent: ViewGroup): RecyclerView.ViewHolder
internal abstract fun bind(holder: RecyclerView.ViewHolder, item: Any) companion object {
internal operator fun get(item: Any): CellType {
for (cellType in values()) {
if (cellType.`is`(item)) return cellType
}
throw NoSuchRecyclerItemTypeException()
} internal operator fun get(viewType: Int): CellType {
for (cellType in values()) {
if (cellType.type() == viewType) return cellType
}
throw NoSuchRecyclerViewTypeException()
}
}
}
That CellType also contains cells similar to the following one:
MOVIE {
override fun `is`(item: Any): Boolean {
return item is Movie
}
override fun type(): Int {
return R.layout.item_movie
}
override fun holder(parent: ViewGroup): RecyclerView.ViewHolder {
val inflater = LayoutInflater.from(parent.context)
val view = inflater.inflate(R.layout.item_movie, parent, false)
return MovieViewHolder(view)
}
override fun bind(holder: RecyclerView.ViewHolder, item: Any) {
if (holder is MovieViewHolder && item is Movie) {
holder.bind(item)
}
}
};The example above, together with my whole approach, was inspired by this article. And it was a huge breakthrough. It looks much cleaner, since all the code related to the cell is inside corresponding Enum type.
But copying the rest of the logic from adapter to adapter really bothered me, I felt there was a room for improvement. Because in 95% of cases I just changed nothing but cells, and copy-pasted cells such as Loading and Error from one adapter to another.
So I wanted to erase duplication of logic, and also make something composable so that not to duplicate identical cells.
Development
- Replaced an Enum (that is not composable) inside adapters with a list, hosting cells that implement a Cell interface. All “getItemViewType, onCreateViewHolder, onBindViewHolder” logic was placed inside base adapter called BaseListAdapter.
- Took all the logic that picks corresponding cell based on its object or layout, and placed it inside the list called CellTypes. That erased type-picking duplication.
- Deleted all repetitive code I could get rid of inside the Cell. Now I was forced to follow simpler interface for cell creation.
- Separated click-handling logic from Adapter through AdapterListener interface.
I could use Any? with AdapterListener, since AdapterClick interface is empty. But based on my understanding of the process of casting it’s better for performance to have interface with limited amount of inheritors. I can be wrong here, please feel free to correct me.
Conclusion
Everything else was just polishing that led to super-minimalistic declarative way of adapter creation that also allows you to compose your adapters just like some constructor.
As for now, in absolute majority of cases we have here in Kapowai, we don’t need to do anything else, because approach is flexible enough.
Of course these solutions can be improved further. I see the highest potential in Cell class. And I’ll be happy to hear any feedback on solution code. But I sincerely hope I’ll help some of you, saving your time and giving you joy — the joy I’ve felt every time since I started using this approach while creating new adapter :)
Thank you for reading!
