Android - Comment réaliser setOnClickListener dans Kotlin?

Je voulais savoir comment nous définissons onClickListener de base dans Kotlin pour le développement Android.

Supposons que vous ayez textView sur lequel cliquer

text_view.text = "Hello Kotlin";

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

Utilisez le code ci-dessous

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

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

code clickListener .

val clickListener = View.OnClickListener {view ->

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

Voici un exemple d'utilisation de onClickListener dans Kotlin

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

Méthode 1:

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

Méthode 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
        }
    }
  }
}

Il existe cinq façons d'utiliser SetOnClickListener:

Première:

button.setOnClickListener {
    // Do some work here
}

Seconde:

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

})

Troisième:

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

Quatrièmement:

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
            }
        }
    }
}

Cinquième:

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
            }
        }
    }
}

À votre santé!

Pour utiliser plusieurs identifiants:

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

Créez une classe anonyme:

 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()
        }
    }
}

Vous devez d'abord obtenir la référence à la vue (par exemple Button, TextView, etc.) et définir un OnClickListener sur la référence à l'aide de la méthode 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()
}

Reportez-vous à l' exemple Kotlin SetOnClickListener pour un exemple complet de Kotlin Android où un bouton est présent dans une activité et OnclickListener est appliqué au bouton. Lorsque vous cliquez sur le bouton, le code à l'intérieur du bloc SetOnClickListener est exécuté.

Mettre à jour

Vous pouvez maintenant référencer le bouton directement avec son identifiant en incluant l'instruction d'importation suivante dans le fichier de classe. Documentation .

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

puis pour le bouton

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

Reportez-vous au didacticiel Android Studio .

Utilisez ce code pour ajouter onClickListenerdans 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()
    }
}

Vous pouvez simplement obtenir OnClickListener dans kotlin

view1.setOnClickListener{

//body 

}

Je vois beaucoup de suggestions ici, mais cette collection manque les suivantes.

button.setOnClickListener(::onButtonClicked)

et dans la classe actuelle, nous avons une méthode comme celle-ci:

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

var tv = findViewById(R.id.tv) comme 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()
                }
            }
        }

Un moyen simple serait d'enregistrer un écouteur de clic et de créer un écouteur de clic avec une expression lambda.

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

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

Et implémentez clickListener:

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

Vous pouvez remplacer _par un nom si vous avez besoin de la vue pour l'utiliser. Par exemple, vous devez vérifier l'ID de l'écouteur de clic.

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

Il existe plusieurs façons d'y parvenir, comme le montre la variété des réponses à cette question.

Pour affecter réellement l'auditeur à la vue, vous utilisez les mêmes méthodes que vous le feriez en Java:

button.setOnClickListener()

Cependant, Kotlin facilite l'attribution d'un lambda en tant qu'auditeur:

button.onSetClickListener {
    // Listener code
}

Sinon, si vous souhaitez utiliser cet écouteur pour plusieurs vues, envisagez une expression lambda (un lambda affecté à une variable / valeur pour référence):

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

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

Faites simplement comme ci-dessous:

button.setOnClickListener{doSomething()}

   button.setOnClickListener {
          //write your code here
   }

Vous utilisez comme ça onclickListener dans 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()
)

Voici la solution. Votre code aimera ceci:

button.setOnClickListener {
            //your code here
        }

Pas besoin d'ajouter quoi que ce soit. comme ci-dessous:

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

}

Commencez par trouver le bouton, pour empêcher la distribution de la, Viewvous pouvez utiliser le <>comme suit:

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

Une fois que vous avez une instance de Button, vous pouvez maintenant attacher l'écouteur de clic comme suit:

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
}

Le moyen le plus simple que je connaisse pour y parvenir est d'utiliser les extensions Kotlin Android.

Sur votre application / build.gradle

apply plugin: 'kotlin-android-extensions'

Si votre bouton s'appelle 'btnAdd', alors sur votre fragment ou activité, importez les éléments suivants:

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 vous voulez simuler l'ancienne méthode anonyme dans Kotlin, j'ai trouvé que cela fonctionnait parfaitement.

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

Ajouter clickListener sur un bouton comme celui-ci

    btUpdate.setOnClickListener(onclickListener)

ajoutez ce code dans votre activité

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


        }
    }

Vous pouvez utiliser setOnClickListener comme ceci dans Kotlin

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