Table of Contents
Why Click Handling Matters in Lists
RecyclerView is all about displaying collections of items. In most real apps, these items are not just for show. You tap a message to open it, tap a product to see its details, or long press an item to show a context menu. Click handling turns a plain list into an interactive UI.
This chapter focuses on how to detect and handle user interactions on RecyclerView items and their child views. You already know what RecyclerView is and how adapters and ViewHolders work, so we will build on that knowledge and focus only on click logic.
Basic Item Clicks on RecyclerView Rows
The most common interaction is a simple tap on a list row. The usual place to attach a click listener is in the ViewHolder, because each holder owns its root view and knows about the UI it manages.
A typical pattern looks like this:
class UserAdapter(
private val users: List<User>,
private val onItemClick: (User) -> Unit
) : RecyclerView.Adapter<UserAdapter.UserViewHolder>() {
inner class UserViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
private val nameText: TextView = itemView.findViewById(R.id.textName)
fun bind(user: User) {
nameText.text = user.name
itemView.setOnClickListener {
onItemClick(user)
}
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): UserViewHolder {
val view = LayoutInflater.from(parent.context)
.inflate(R.layout.item_user, parent, false)
return UserViewHolder(view)
}
override fun onBindViewHolder(holder: UserViewHolder, position: Int) {
val user = users[position]
holder.bind(user)
}
override fun getItemCount(): Int = users.size
}
Here the adapter receives a lambda onItemClick that describes what should happen when an item is tapped. The ViewHolder calls this lambda when its itemView is clicked. The important idea is that the adapter does not know about activities or fragments, it just forwards the event.
You can use this adapter from an Activity or Fragment like this:
val adapter = UserAdapter(users) { user ->
// Handle click in the Activity or Fragment
Toast.makeText(this, "Clicked: ${user.name}", Toast.LENGTH_SHORT).show()
}
recyclerView.adapter = adapterThis keeps your click handling logic close to the screen that owns the RecyclerView and keeps the adapter reusable.
Always use the data object itself when handling clicks, not a stored numeric position. Positions can change when the list is modified, but your data object remains valid.
Using Adapter Position Safely in Clicks
Sometimes you need the position of the clicked item as well as the data. For example, you might want to remove an item from the list at that exact position.
You might be tempted to do this:
itemView.setOnClickListener {
val position = adapterPosition
onItemClick(position)
}
However, adapterPosition can temporarily be invalid. RecyclerView may be updating items or removing them. For safe usage, you must check for RecyclerView.NO_POSITION before acting.
A safer pattern looks like this:
inner class UserViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
init {
itemView.setOnClickListener {
val position = bindingAdapterPosition
if (position != RecyclerView.NO_POSITION) {
val user = users[position]
onItemClick(user, position)
}
}
}
fun bind(user: User) {
// Bind views here
}
}
The key points are that you call bindingAdapterPosition inside the click listener, and you check for RecyclerView.NO_POSITION. This ensures that clicks during layout updates do not cause crashes.
Never use a stored position captured earlier in onBindViewHolder for click handling. Always read the position at click time using bindingAdapterPosition and check against RecyclerView.NO_POSITION.
Passing Click Events Through Interfaces
If you are not comfortable with lambdas, or you want a more explicit contract, you can use an interface for click callbacks. This also works well in Java.
Define an interface inside or outside the adapter:
interface OnUserClickListener {
fun onUserClick(user: User)
}Then let the adapter receive an implementation:
class UserAdapter(
private val users: List<User>,
private val listener: OnUserClickListener
) : RecyclerView.Adapter<UserAdapter.UserViewHolder>() {
inner class UserViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
private val nameText: TextView = itemView.findViewById(R.id.textName)
fun bind(user: User) {
nameText.text = user.name
itemView.setOnClickListener {
listener.onUserClick(user)
}
}
}
// onCreateViewHolder, onBindViewHolder, getItemCount...
}Your Activity or Fragment implements the interface:
class UserListActivity : AppCompatActivity(), OnUserClickListener {
override fun onUserClick(user: User) {
// Navigate to user detail, for example
}
}This pattern is especially useful when you want to keep your adapter reusable and explicit about the events it can send.
Clicks on Child Views Inside Each Item
Often a list item layout contains multiple interactive elements, such as a delete button, a favorite icon, or a checkbox. In this case you usually do not want to treat the whole row as a single click target.
You can attach listeners directly to child views in the ViewHolder:
class UserAdapter(
private val users: MutableList<User>,
private val onItemClick: (User) -> Unit,
private val onDeleteClick: (User, Int) -> Unit
) : RecyclerView.Adapter<UserAdapter.UserViewHolder>() {
inner class UserViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
private val nameText: TextView = itemView.findViewById(R.id.textName)
private val deleteButton: ImageButton = itemView.findViewById(R.id.buttonDelete)
fun bind(user: User) {
nameText.text = user.name
itemView.setOnClickListener {
onItemClick(user)
}
deleteButton.setOnClickListener {
val position = bindingAdapterPosition
if (position != RecyclerView.NO_POSITION) {
onDeleteClick(user, position)
}
}
}
}
// Adapter methods...
}You can then remove the item from your list and notify the adapter in the Activity or Fragment:
val adapter = UserAdapter(users,
onItemClick = { user ->
// open detail
},
onDeleteClick = { user, position ->
users.removeAt(position)
adapter.notifyItemRemoved(position)
}
)This allows you to combine row clicks and specific button clicks in the same item layout.
Handling Long Clicks for Context Actions
A long press is a useful alternative for secondary actions, such as showing a menu or toggling selection. You can add a long click listener alongside the normal click listener.
A long click listener must return a Boolean that tells the system whether the event has been consumed. If you return true, the long click will not turn into a normal click afterwards.
Here is an example:
class UserAdapter(
private val users: List<User>,
private val onItemClick: (User) -> Unit,
private val onItemLongClick: (User) -> Unit
) : RecyclerView.Adapter<UserAdapter.UserViewHolder>() {
inner class UserViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
fun bind(user: User) {
itemView.setOnClickListener {
onItemClick(user)
}
itemView.setOnLongClickListener {
onItemLongClick(user)
true
}
}
}
// Other methods...
}
You could use the long click to start a selection mode or show a popup menu. Long clicks on child views can also be set up using setOnLongClickListener on those specific views.
Always return true from setOnLongClickListener if you want to prevent the same tap from also triggering the normal click listener.
Avoiding Common Click Handling Mistakes
Click handling in RecyclerView is simple once you follow a few consistent rules and avoid some common traps.
A frequent mistake is to attach the listener in onBindViewHolder and then use the position parameter inside the listener. That position was correct when binding happened, but might be wrong when the user taps, especially after inserts or deletions. The correct approach is to read the position inside the listener from bindingAdapterPosition.
Another issue is creating a new listener instance each time onBindViewHolder is called. While this works, it can create a lot of objects for large lists. If you need the position and not much else, attaching the listener once in the ViewHolder initializer and reading the position at click time is more efficient.
Here is an example of this approach:
inner class UserViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
private val nameText: TextView = itemView.findViewById(R.id.textName)
init {
itemView.setOnClickListener {
val position = bindingAdapterPosition
if (position != RecyclerView.NO_POSITION) {
val user = users[position]
onItemClick(user)
}
}
}
fun bind(user: User) {
nameText.text = user.name
}
}One more point to remember is that click listeners should be fast. Do not perform heavy work directly inside the listener. Instead, trigger navigation or start a background task, which you will handle with other tools in later chapters.
Click Handling in MVVM and Clean Architectures
If you use ViewModel and MVVM, you still handle clicks in the same place, usually the Activity or Fragment that owns the RecyclerView. The difference is what you do when a click happens. Instead of performing logic directly, you often call methods on the ViewModel.
For example:
val adapter = UserAdapter(users,
onItemClick = { user ->
viewModel.onUserSelected(user)
}
)Inside the ViewModel you can update LiveData or send events, and the Activity or Fragment can observe those changes. The adapter stays simple, and the click logic remains testable and separate from UI details.
Summary
Click handling turns RecyclerView from a simple list into an interactive component. You usually attach listeners in the ViewHolder using itemView or specific child views. You pass events back to the Activity or Fragment using lambdas or interfaces, and you always obtain the current position at click time using bindingAdapterPosition with a check for RecyclerView.NO_POSITION. With careful use of normal clicks, long clicks, and child view listeners, you can support rich interactions in list based UIs.