Nivel inicial10 min de lectura · Publicado el

Eventos click en Android: onClick y setOnClickListener

Eventos click en Android: el Button es el timbre y el listener, quien abre; setOnClickListener le dice quién escucha. Sin listener no pasa nadarubentejera.com Button¡ding!listenerquien abresetOnClickListener { … }
El botón es el timbre y el listener, la persona pendiente de abrir: setOnClickListener le dice quién escucha y qué hace al oírlo. Si nadie escucha, el timbre suena y no pasa nada.

Un evento click es el aviso que recibe tu app cuando alguien toca un botón. Tu trabajo es decidir quién escucha ese aviso y qué hace con él.

Es como el timbre de casa: el botón es el timbre y el listener («escuchador») es la persona que está pendiente de abrir la puerta. Si nadie escucha, el timbre suena y no pasa nada.

Las tres formas

Forma Dónde se conecta el click ¿Recomendable?
1. android:onClick en el XML En la vista No: obsoleto desde la API 31
2. setOnClickListener en línea En el código, por botón Sí, es la forma habitual
3. Un listener con when En el código, para varios botones Sí, si comparten lógica

1. android:onClick en el XML

No es aconsejable: la vista no debería conocer nombres de métodos ni lógica de nuestro código. Debería ser totalmente independiente. Si renombras el método, el XML no se entera y la app falla al pulsar el botón.

Además, Android marcó este atributo como obsoleto en la API 31 (Android 12). La documentación explica que Android busca el método recorriendo la jerarquía de contextos, algo frágil y que dificulta que herramientas como R8 optimicen el código, y recomienda usar setOnClickListener en su lugar. Lo dejamos aquí porque lo encontrarás en proyectos antiguos.

class ClickEventsActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_click_events) // en esta vista se asigna xmlClick
    }

    // Reglas para los clicks desde XML:
    // 1. El método tiene que ser público.
    // 2. Su nombre tiene que coincidir con el del atributo android:onClick.
    // 3. Recibe un solo parámetro, de tipo View.
    fun xmlClick(view: View) {
        Toast.makeText(this, "Click by XML", Toast.LENGTH_SHORT).show()
    }
}

Y el botón en la vista:

<!-- android:onClick conecta el botón con el método xmlClick de la Activity -->
<Button
    android:id="@+id/buttonClickXML"
    android:layout_width="0dp"
    android:layout_height="wrap_content"
    android:layout_marginStart="16dp"
    android:layout_marginTop="32dp"
    android:layout_marginEnd="16dp"
    android:text="@string/button_click_xml"
    android:onClick="xmlClick"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintTop_toTopOf="parent" />

2. Click en línea con setOnClickListener

Es la forma que usa la documentación oficial de Android. Buscas el botón y le pasas una lambda (un bloque de código entre llaves) que se ejecuta al pulsarlo:

class ClickEventsActivity : AppCompatActivity() {

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

        clickInLine() // se llama aquí para registrar el listener al crear la pantalla
    }

    private fun clickInLine() {
        val btn = findViewById<Button>(R.id.buttonClickInLine)
        btn.setOnClickListener {
            Toast.makeText(this, "Click in Line!", Toast.LENGTH_SHORT).show()
        }
    }
}

3. Varios botones con un listener y when

Si varios botones hacen algo parecido, puedes crear un único listener y decidir qué hacer según el id del botón pulsado:

class ClickEventsActivity : AppCompatActivity() {

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

        val listener = View.OnClickListener { view ->
            val texto = when (view.id) {
                R.id.buttonClickMulti1 -> "Click Multi 1"
                R.id.buttonClickMulti2 -> "Click Multi 2"
                R.id.buttonClickMulti3 -> "Click Multi 3"
                else -> return@OnClickListener
            }
            Toast.makeText(this, texto, Toast.LENGTH_SHORT).show()
        }

        findViewById<Button>(R.id.buttonClickMulti1).setOnClickListener(listener)
        findViewById<Button>(R.id.buttonClickMulti2).setOnClickListener(listener)
        findViewById<Button>(R.id.buttonClickMulti3).setOnClickListener(listener)
    }
}

Pulsación larga: setOnLongClickListener

El ejemplo original de este artículo usaba en realidad la pulsación larga (mantener el dedo sobre el botón), que se registra igual pero con setOnLongClickListener. La diferencia es que devuelve un Boolean: true significa «ya me he encargado yo» y el evento no sigue a nadie más.

findViewById<Button>(R.id.buttonClickMulti1).setOnLongClickListener {
    Toast.makeText(this, "Pulsación larga", Toast.LENGTH_SHORT).show()
    true // evento consumido
}
La vista dice qué hay en pantalla; el código decide qué pasa al tocarlo.

En Jetpack Compose

En Compose no hay listeners que registrar: el click es un parámetro más del componente.

@Composable
fun Saludo() {
    val context = LocalContext.current
    Button(onClick = {
        Toast.makeText(context, "Click en Compose", Toast.LENGTH_SHORT).show()
    }) {
        Text("Púlsame")
    }
}

Para hacer clicable cualquier otro elemento, usa Modifier.clickable { … }, y para la pulsación larga, Modifier.combinedClickable(onClick = { … }, onLongClick = { … }).

Evita el doble click: separa la regla para probarla

Un fallo muy común con setOnClickListener: el usuario toca dos veces seguidas un botón que abre una pantalla o envía un formulario, y se abren dos pantallas o se envían dos pedidos. Android entrega los dos clicks, porque son dos clicks.

La solución es una regla sencilla: «si ya atendí un click hace menos de medio segundo, ignora este». Es como el portero que, después de abrir, no vuelve a abrir si llaman otra vez enseguida: da por hecho que es la misma persona.

Si esa regla vive dentro del listener, solo la puedes probar con un emulador y tocando rápido. Si la sacas a una clase de Kotlin normal, que recibe un reloj (una función que devuelve la hora actual), la pruebas en milisegundos:

import kotlin.test.assertFalse
import kotlin.test.assertTrue

class FiltroDobleClick(
    private val intervaloMs: Long = 500,
    private val reloj: () -> Long,
) {
    private var ultimoAceptado: Long? = null

    // ¿Se atiende este click o es un toque repetido?
    fun aceptar(): Boolean {
        val ahora = reloj()
        val anterior = ultimoAceptado
        if (anterior != null && ahora - anterior < intervaloMs) return false
        ultimoAceptado = ahora
        return true
    }
}

fun main() {
    var ahora = 10_000L
    val filtro = FiltroDobleClick(reloj = { ahora })

    assertTrue(filtro.aceptar(), "el primer click se atiende")

    ahora += 120
    assertFalse(filtro.aceptar(), "un segundo toque a 120 ms se ignora")

    ahora += 379 // 499 ms desde el primero
    assertFalse(filtro.aceptar(), "a 499 ms todavía se ignora")

    ahora += 1 // 500 ms
    assertTrue(filtro.aceptar(), "a 500 ms se vuelve a atender")

    println("4 comprobaciones superadas")
}

Se compila con kotlinc y kotlin-test, la biblioteca de aserciones que viene en el zip oficial. Las órdenes suponen kotlinc en el PATH y el zip oficial del compilador descomprimido en ./kotlinc, que es de donde sale kotlin-test.jar:

kotlinc FiltroDobleClick.kt -cp kotlinc/lib/kotlin-test.jar -include-runtime -d filtro.jar
java -cp filtro.jar:kotlinc/lib/kotlin-test.jar FiltroDobleClickKt
4 comprobaciones superadas

Si alguien cambia < por <=, el botón tarda un milisegundo más en responder. Nadie lo notaría a mano; el test sí:

Exception in thread "main" java.lang.AssertionError: a 500 ms se vuelve a atender

En la activity, el listener solo pregunta al filtro. [SIN EJECUTAR], como el resto del código de Android de este artículo:

// import android.os.SystemClock
private val filtro = FiltroDobleClick(reloj = { SystemClock.elapsedRealtime() })

// dentro de onCreate, después de setContentView
findViewById<Button>(R.id.buttonEnviar).setOnClickListener {
    if (!filtro.aceptar()) return@setOnClickListener
    enviarPedido()
}

SystemClock.elapsedRealtime() cuenta el tiempo desde que arrancó el móvil y no cambia si el usuario ajusta la hora, a diferencia de System.currentTimeMillis(). En un proyecto de Android, el test iría en src/test con JUnit.

Errores frecuentes

1. android:onClick apunta a un método que no existe

Si renombras el método o lo escribes en un Fragment, la app compila y se cierra al pulsar el botón. El mensaje lo construye la clase View de Android; según su código fuente (AOSP), tiene esta forma, con el nombre de tu método, la clase del botón y su id:

java.lang.IllegalStateException: Could not find method xmlClick(View) in a parent or ancestor Context for android:onClick attribute defined on view class … with id 'buttonClickXML'

[SIN EJECUTAR]: el texto sale del código fuente de View.java, no de una ejecución en un móvil. Es otro motivo para usar setOnClickListener: si el id no existe en el proyecto, el error salta al compilar. Si existe, pero en otro layout, compila y findViewById devuelve null, que es el error siguiente.

2. Buscar el botón antes de setContentView

Si llamas a findViewById antes de setContentView, todavía no hay layout: la referencia de Android dice que devuelve la vista «o null si no la encuentra». Al llamar a setOnClickListener sobre ese null, la app se cierra con un NullPointerException. El orden es siempre: setContentView y, después, los listeners.

3. Registrar dos listeners en el mismo botón

Un botón solo tiene un OnClickListener. El código fuente de View guarda el listener en un único campo, así que la segunda llamada a setOnClickListener sustituye a la primera, sin avisar. Si necesitas que un click haga dos cosas, llama a las dos desde el mismo listener.

Un detalle útil del mismo método: si la vista no era clicable (un TextView, una imagen), setOnClickListener la hace clicable.

4. La pulsación larga devuelve false

Si el OnLongClickListener devuelve false, el código de View no marca la pulsación larga como atendida, y al levantar el dedo se ejecuta también el click normal. Si solo quieres la pulsación larga, devuelve true.

5. El doble click abre dos pantallas

Es el caso de la sección anterior. Además del filtro, en un formulario también puedes desactivar el botón (isEnabled = false) mientras se envía y volver a activarlo al terminar.

Cuándo no usar setOnClickListener

  • En Jetpack Compose. No hay vistas ni listeners: el click es el parámetro onClick del componente o el modificador Modifier.clickable.
  • Para meter la lógica de la app. El listener debería traducir el toque a una llamada («el usuario quiere enviar») y nada más. Si dentro calculas precios o validas formularios, solo lo puedes probar pulsando en un emulador. Sácalo a una clase como FiltroDobleClick o a un ViewModel.
  • En cada fila de una lista larga desde la activity. En un RecyclerView, el click de cada fila se configura en el adaptador, cuando se crea o se rellena la fila, no buscando cada vista desde fuera.
  • Con android:onClick en código nuevo, por lo que se explica arriba.

Ejercicio de cinco minutos

  1. Añade al test una comprobación de que la ventana empieza a contar desde el último click atendido: tras aceptar a los 500 ms, un toque a los 600 ms debe ignorarse.
  2. Cambia el intervalo a 800 ms. Escribe primero las comprobaciones con 799 ms (se ignora) y 800 ms (se atiende), comprueba que la de 799 falla con el valor por defecto y después pasa intervaloMs = 800.
  3. Busca en tus layouts android:onClick y pasa cada uno a setOnClickListener (o a binding.boton.setOnClickListener, si usas View Binding).

Si quieres saber más sobre el Toast de los ejemplos y su alternativa moderna, mira Toast y Snackbar en Android.

Fuentes

Consultadas el 11 de noviembre de 2026.