Android - ¿Cómo lograr setOnClickListener en Kotlin?

Quería saber cómo configuramos el onClickListener básico en Kotlin para el desarrollo de Android.

Suponga que tiene textView para hacer clic

text_view.text = "Hello Kotlin";

text_view.setOnClickListener {
    val intent = Intent(this@MainActivity, SecondActivity::class.java)
    intent.putExtra("key", "Kotlin")
    startActivity(intent)
}

Utilice el siguiente código

val textview = findViewById<TextView>(R.id.textview)
textview.setOnClickListener(clickListener)

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

clickListener código.

val clickListener = View.OnClickListener {view ->

    when (view.getId()) {
        R.id.textview -> firstFun()
        R.id.button -> secondFun()
    }
}

Aquí hay un ejemplo sobre cómo usar onClickListener en Kotlin

button1.setOnClickListener(object : View.OnClickListener{
            override fun onClick(v: View?) {
                //Your code here
            }})

Método 1:

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

Método 2:

class FirstActivity : AppCompatActivity(), View.OnClickListener {

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_first)
    txtNext.setOnClickListener(this)
}

override fun onClick(v: View) {
    when (v.id) {
        R.id.txtNext -> {
            val intent = Intent(applicationContext, SecondActivity::class.java)
            startActivity(intent)
        }
        else -> {
            // else condition
        }
    }
  }
}

Hay cinco formas de utilizar SetOnClickListener:

Primero:

button.setOnClickListener {
    // Do some work here
}

Segundo:

button.setOnClickListener(object : View.OnClickListener {
    override fun onClick(view: View?) {
        // Do some work here
    }

})

Tercero:

button.setOnClickListener(View.OnClickListener { view ->
    // Do some work here
})

Adelante:

class MainActivity : AppCompatActivity(), View.OnClickListener{

    lateinit var button : Button

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        button = findViewById(R.id.button1)
        button.setOnClickListener(this)
    }

    override fun onClick(view: View?) {
        when(view?.id){
            R.id.button1->{
                // do some work here
            }
        }
    }
}

Quinto:

class MainActivity : AppCompatActivity(){

    lateinit var button : Button

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        button = findViewById(R.id.button1)
        button.setOnClickListener(listener)
    }

    val listener= View.OnClickListener { view ->
        when (view.getId()) {
            R.id.button1 -> {
                // Do some work here
            }
        }
    }
}

¡Salud!

Para usar múltiples identificadores:

textview1.setOnClickListener(clickListener)
textview2.setOnClickListener(clickListener)

Crear clase anónima:

 private val clickListener: View.OnClickListener = View.OnClickListener { view ->
    when (view.id) {
        R.id.textview1-> { 
           Toast.makeText(this, "Clicked 1", Toast.LENGTH_SHORT).show()
        }
        R.id.textview2-> { 
           Toast.makeText(this, "Clicked 2", Toast.LENGTH_SHORT).show()
        }
    }
}

Primero debe obtener la referencia a la Vista (por ejemplo, Button, TextView, etc.) y establecer un OnClickListener a la referencia usando el método setOnClickListener ()

// get reference to button
val btn_click_me = findViewById(R.id.btn_click_me) as Button
// set on-click listener
btn_click_me.setOnClickListener {
    Toast.makeText(this@MainActivity, "You clicked me.", Toast.LENGTH_SHORT).show()
}

Consulte el ejemplo de Kotlin SetOnClickListener para obtener un ejemplo completo de Android de Kotlin donde un botón está presente en una actividad y OnclickListener se aplica al botón. Al hacer clic en el botón, se ejecuta el código dentro del bloque SetOnClickListener.

Actualizar

Ahora puede hacer referencia al botón directamente con su identificación al incluir la siguiente declaración de importación en el archivo de clase. Documentación .

import kotlinx.android.synthetic.main.activity_main.*

y luego para el botón

btn_click_me.setOnClickListener {
    // statements to run when button is clicked
}

Referir tutorial de Android Studio .

Use este código para agregar onClickListeneren Kotlin

val button : Button = getView()?.findViewById<Button>(R.id.testButton) as Button
button.setOnClickListener {view ->
         Toast.makeText(context, "Write your message here", Toast.LENGTH_LONG).show()
    }
}

Simplemente puede obtener OnClickListener en kotlin

view1.setOnClickListener{

//body 

}

Veo muchas sugerencias aquí, pero a esta colección le falta lo siguiente.

button.setOnClickListener(::onButtonClicked)

y en la clase actual tenemos un método como este:

private fun onButtonClicked(view: View) {
     // do stuff
}

var tv = findViewById(R.id.tv) como TextView

    tv.setOnClickListener {
       val i = Intent(this@MainActivity, SecondActivity::class.java)
       startActivity(i)
       finish()
    }

    val button = findViewById<Button>(R.id.button)
    button.setOnClickListener {
        val intent = 
    Intent(this@MainActivity,ThirdActivity::class.java)
        intent.putExtra("key", "Kotlin")
        startActivity(intent)
    }

**i have use kotlin-extension so i can access directly by button id:**


btnSignIN.setOnClickListener {
            if (AppUtils.isNetworkAvailable(activity as BaseActivity)) {
                if (checkValidation()) {

                    hitApiLogin()
                }
            }
        }

Una forma sencilla sería registrar un oyente de clics y crear un oyente de clics con una expresión lambda.

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

    // click listener registered
    myButton.setOnClickListener(clickListener)
}

E implementar el clickListener:

private val clickListener: View.OnClickListener = View.OnClickListener { _ ->
    // do something here
}

Puede reemplazarlo _con un nombre si necesita la vista para usarlo. Por ejemplo, debe verificar la identificación del oyente de clics.

private val clickListener: View.OnClickListener = View.OnClickListener { view ->
    if(view.id == login.id) {
        // do something here
    }
}

Hay varias formas diferentes de lograr esto, como lo demuestra la variedad de respuestas a esta pregunta.

Para asignar realmente el oyente a la vista, use los mismos métodos que usaría en Java:

button.setOnClickListener()

Sin embargo, Kotlin facilita la asignación de un lambda como oyente:

button.onSetClickListener {
    // Listener code
}

Alternativamente, si desea utilizar este oyente para múltiples vistas, considere una expresión lambda (una lambda asignada a una variable / valor como referencia):

val buttonClickListener = View.OnClickListener { view ->
    // Listener code
}

button.setOnClickListener(buttonClickListener)
another_button.setOnClickListener(buttonClickListener)

Simplemente haz lo siguiente:

button.setOnClickListener{doSomething()}

   button.setOnClickListener {
          //write your code here
   }

Usas así onclickListener en kotlin

val fab = findViewById(R.id.fab) as FloatingActionButton
fab.setOnClickListener {  
...
}

findViewById<Button>(R.id.signUp)?.setOnClickListener(
    Toast.makeText(mActivity, "Button Clicked", Toast.LENGTH_LONG).show()
)

Esta es la solución. A tu código le gustará esto:

button.setOnClickListener {
            //your code here
        }

No es necesario agregar nada. como abajo:

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

}

Primero busque el botón, para evitar que el elenco Viewse pueda usar de la <>siguiente manera:

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

Una vez que tenga una instancia de Button, ahora puede adjuntar el oyente de clics de la siguiente manera:

button.setOnClickListener {  
 // You code here
}

val saveButton:Button = findViewById(R.id.button_save)

saveButton.setOnClickListener{
// write code for click event
}

with view object
saveButton.setOnClickListener{
view -> // write code for click event
}

La forma más fácil que conozco de lograrlo es a través de las extensiones de Android de Kotlin.

En su aplicación / build.gradle

apply plugin: 'kotlin-android-extensions'

Si su botón se llama 'btnAdd', entonces en su fragmento o actividad importe lo siguiente:

import kotlinx.android.synthetic.main.fragment_transactions.btnAdd

 override fun onViewCreated(view: View?, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)

    btnAdd.setOnClickListener {
        Toast.makeText(context , "Done", 10).show()
    }
}

Si desea simular la antigua forma anónima en Kotlin, encontré que esto funcionaba perfectamente.

 btnNewWay!!.setOnClickListener(object:View.OnClickListener {
    override fun onClick(v: View?) {
        //Your Code Here!
    }})

Agregar clickListener en un botón como este

    btUpdate.setOnClickListener(onclickListener)

agrega este código en tu actividad

 val onclickListener: View.OnClickListener = View.OnClickListener { view ->
        when (view.id) {
            R.id.btUpdate -> updateData()


        }
    }

Puede usar setOnClickListener así en Kotlin

button.setOnClickListener(View.OnClickListener {        
       //code
})