How to Set an OnClickListener in Kotlin for Android

By the end of this page, you will understand how click listeners work in Android using Kotlin, how to attach them to views like buttons, what happens when a user taps a UI element, and how this pattern is used in real Android apps.

In Android, an OnClickListener is used to run code when the user taps a view such as a Button, TextView, ImageView, or other clickable UI element.

In Kotlin, the most common way to attach a click listener is with setOnClickListener { ... }.

button.setOnClickListener {
    // code to run when the button is clicked
}

This works because Android's click listener API is designed around event handling. A click is an event, and your code provides the response.

This concept matters because user interaction is central to Android development. Apps respond to taps, selections, gestures, and form actions. setOnClickListener is one of the first and most important event-handling tools you learn.

In Kotlin, this is cleaner than older Java-style listener code because Kotlin supports lambda expressions. Instead of writing a full anonymous class, you can often write just the action that should happen on click.

Common uses include:

• Opening another screen
• Showing a message
• Submitting a form
• Updating text on the screen
• Starting a calculation or API request

So the key idea is simple: find the view, then attach the action you want when it is clicked.

Think of a button like a doorbell.

• The button on the screen is the physical bell
• The click is someone pressing it
• The listener is the wiring that tells the house what to do
• Your Kotlin code is the sound or action that happens afterward

Without a listener, pressing the bell does nothing. The view exists, but no response has been connected.

setOnClickListener is how you connect that wiring.

The basic syntax in Kotlin is:

view.setOnClickListener {
    // action here
}

Example with a Button

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val button = findViewById<Button>(R.id.myButton)

        button.setOnClickListener {
            println("Button clicked")
        }
    }
}

What this does

• setContentView(...) loads the layout
• findViewById<Button>(R.id.myButton) gets the button from the layout
• setOnClickListener { ... } attaches click behavior
• When the user taps the button, the code inside the block runs

Example showing a Toast

class MainActivity : AppCompatActivity() {

    override fun  {
        .onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

         button = findViewById<Button>(R.id.myButton)

        button.setOnClickListener {
            Toast.makeText(, , Toast.LENGTH_SHORT).show()
        }
    }
}

Consider this code:

val button = findViewById<Button>(R.id.myButton)

button.setOnClickListener {
    Toast.makeText(this, "Clicked!", Toast.LENGTH_SHORT).show()
}

Here is what happens step by step:

1. Android loads the activity layout using setContentView(...).
2. The app looks for a Button with the ID myButton.
3. That button reference is stored in the button variable.
4. setOnClickListener attaches a click handler to that button.
5. The app keeps waiting for user interaction.
6. When the user taps the button, Android detects the click.
7. Android runs the code inside the listener block.
8. Toast.makeText(...) creates a short popup message.
9. .show() displays the message on the screen.

Trace example

val countButton = findViewById<Button>(R.id.countButton)
var count = 0

countButton.setOnClickListener {
    count += 1
    Toast.makeText(this, "Count: $count", Toast.LENGTH_SHORT).show()
}

setOnClickListener appears everywhere in Android apps.

Common practical uses

• Form submission: when a user taps a login or signup button
• Navigation: opening another activity or fragment
• Cart actions: adding an item to a shopping cart
• Refresh actions: retrying a failed network request
• Dialogs: opening confirmation popups
• Counters and toggles: updating values in the UI

Example: open another activity

val nextButton = findViewById<Button>(R.id.nextButton)

nextButton.setOnClickListener {
    val intent = Intent(this, SecondActivity::class.java)
    startActivity(intent)
}

Example: validate input before action

val submitButton = findViewById<Button>(R.id.submitButton)
val nameInput = findViewById<EditText>(R.id.nameInput)

submitButton.setOnClickListener {
    val name = nameInput.text.toString()

    if (name.isBlank()) {
        Toast.makeText(this, "Please enter your name", Toast.LENGTH_SHORT).show()
        return@setOnClickListener
    }

    Toast.makeText(this, "Hello, $name", Toast.LENGTH_SHORT).show()
}

This is a very common pattern in production apps.

In real Android projects, developers use click listeners in structured and maintainable ways.

Common patterns

Guard clauses and early returns

These keep listener code readable.

saveButton.setOnClickListener {
    val title = titleInput.text.toString()

    if (title.isBlank()) {
        titleInput.error = "Title is required"
        return@setOnClickListener
    }

    saveTitle(title)
}

Calling separate functions

Instead of putting too much code inside the listener, developers often call a method.

deleteButton.setOnClickListener {
    confirmDelete()
}

This makes code easier to test and read.

Updating UI state

likeButton.setOnClickListener {
    isLiked = !isLiked
    updateLikeUi(isLiked)
}

Triggering ViewModel actions

In modern Android apps, UI click events often forward actions to a ViewModel.

submitButton.setOnClickListener {
    viewModel.submitForm()
}

Reusing one listener for multiple views

val listener = View.OnClickListener {
    Toast.makeText(, , Toast.LENGTH_SHORT).show()
}

button1.setOnClickListener(listener)
button2.setOnClickListener(listener)

Beginners often run into a few common issues when using setOnClickListener.

1. Forgetting to call setContentView() before findViewById()

Broken example:

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

    val button = findViewById<Button>(R.id.myButton)
    setContentView(R.layout.activity_main)
}

Problem:

• The layout is not loaded yet, so the view cannot be found correctly.

Correct version:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    val button = findViewById<Button>(R.id.myButton)
}

2. Using the wrong view ID

If the ID in Kotlin does not match the XML ID, the app will fail to find the correct view.

val button = findViewById<Button>(R.id.button)

Here are a few useful comparisons related to click handling in Android Kotlin.

Lambda vs older Java-style listener

Kotlin lambda

val button = findViewById<Button>(R.id.myButton)
button.setOnClickListener {
    // code here
}

Quick rules

• Call setContentView(...) before findViewById(...)
• Make sure the view has the correct XML ID
• Put click logic inside setOnClickListener { ... }
• Use Toast.makeText(...).show() to display a toast
• Use return@setOnClickListener for early exit inside the click block

Common examples

Show a toast

button.setOnClickListener {
    Toast.makeText(this, "Clicked", Toast.LENGTH_SHORT).show()
}

Validate before continuing

button.setOnClickListener {
    if (input.text.toString().isBlank()) {
        return@setOnClickListener
    }

    submit()
}

Call another function

button.setOnClickListener {
    handleClick()
}

Remember

How do I add an OnClickListener to a button in Kotlin?

Use findViewById to get the button, then call setOnClickListener on it.

val button = findViewById<Button>(R.id.myButton)
button.setOnClickListener {
    // action
}

Why is setOnClickListener easier in Kotlin than Java?

Kotlin supports lambdas, so you can write shorter and cleaner listener code without a full anonymous class.

Where should I put setOnClickListener in an Activity?

Usually inside onCreate() after setContentView(...).

Can I use setOnClickListener with views other than buttons?

Yes. Any clickable view such as TextView, ImageView, CardView, or custom views can use it.

Why is my click listener not working?

Common reasons include:

• wrong view ID
• setContentView(...) called too late

• findViewById - Used to get a view reference before attaching a listener.
• Button - A common clickable UI component in Android.
• Toast - Often used to show quick feedback after a click.
• Intent - Frequently used inside click listeners to open another screen.
• Activity lifecycle - Important because listeners are usually attached in onCreate().
• Lambda expressions in Kotlin - Explains why listener code is shorter in Kotlin.
• ViewBinding - A modern alternative to findViewById for accessing views safely.