Android: comment gérer le clic de bouton

Ayant une solide expérience dans les domaines non Java et non-Android, j’apprends Android.

J’ai beaucoup de confusion avec différents domaines, l’un d’eux est comment gérer les clics de bouton. Il y a au moins 4 façons de le faire (!!!), elles sont brièvement listées ici

pour des raisons de cohérence, je les énumérerai:

  1. Avoir un membre de la classe View.OnClickListener dans l’activité et l’affecter à une instance qui onClick logique onClick dans la méthode d’activité onCreate .

  2. Créer ‘onClickListener’ dans la méthode d’activité ‘onCreate’ et l’affecter au bouton à l’aide de setOnClickListener

  3. Implémentez ‘onClickListener’ dans l’activité elle-même et affectez ‘this’ comme écouteur pour le bouton. Dans le cas où l’activité comporte peu de boutons, le bouton id doit être analysé pour exécuter le gestionnaire ‘onClick’ pour le bouton approprié

  4. Avoir une méthode publique sur l’activité qui implémente la logique ‘onClick’ et l’affecter au bouton dans la déclaration XML d’activité

Question 1:

S’agit-il de toutes les méthodes, y a-t-il une autre option? (Je n’ai besoin d’aucun autre, juste curieux)

Pour moi, la manière la plus intuitive serait la plus récente: elle nécessite le moins de code à saisir et est la plus lisible (du moins pour moi).

Cependant, je ne vois pas cette approche largement utilisée. Quels sont les inconvénients pour l’utiliser?

Question 2:

Quels sont les avantages / inconvénients pour chacune de ces méthodes? S’il vous plaît partager soit votre expérience ou un bon lien.

Tout commentaire est le bienvenu!

PS J’ai essayé de Google et trouver quelque chose pour ce sujet, mais les seules choses que j’ai trouvées sont la description “comment” faire, pas pourquoi c’est bon ou mauvais.

    Question 1: Malheureusement, celle dans laquelle vous dites être la plus intuitive est la moins utilisée dans Android. Si je comprends bien, vous devez séparer votre interface utilisateur (XML) et votre fonctionnalité de calcul (fichiers de classe Java). Cela facilite également le débogage. Il est en fait beaucoup plus facile de lire de cette façon et de penser à Android imo.

    Question 2: Je crois que les deux principaux utilisés sont # 2 et # 3. Je vais utiliser un bouton clickButton comme exemple.

    2

    est sous la forme d’un cours anonyme.

     Button clickButton = (Button) findViewById(R.id.clickButton); clickButton.setOnClickListener( new OnClickListener() { @Override public void onClick(View v) { // TODO Auto-generated method stub ***Do what you want with the click here*** } }); 

    Ceci est mon préféré car il a la méthode onClick juste à côté où la variable de bouton a été définie avec findViewById. Il semble très ordonné et net que tout ce qui concerne ce clickButton Button View se trouve ici.

    Un con que mon collègue commente, c’est d’imaginer que vous avez beaucoup de points de vue qui nécessitent un auditeur onclick. Vous pouvez voir que votre onCreate sera très long. Alors, pourquoi il aime utiliser:

    3

    Disons que vous avez 5 boutons de clic:

    Assurez-vous que votre activité / fragmentation implémente OnClickListener

     // in OnCreate Button mClickButton1 = (Button)findViewById(R.id.clickButton1); mClickButton1.setOnClickListener(this); Button mClickButton2 = (Button)findViewById(R.id.clickButton2); mClickButton2.setOnClickListener(this); Button mClickButton3 = (Button)findViewById(R.id.clickButton3); mClickButton3.setOnClickListener(this); Button mClickButton4 = (Button)findViewById(R.id.clickButton4); mClickButton4.setOnClickListener(this); Button mClickButton5 = (Button)findViewById(R.id.clickButton5); mClickButton5.setOnClickListener(this); // somewhere else in your code public void onClick(View v) { switch (v.getId()) { case R.id.clickButton1: { // do something for button 1 click break; } case R.id.clickButton2: { // do something for button 2 click break; } //.... etc } } 

    De cette manière, comme l’explique mon collègue, il est plus proche des yeux, car tous les calculs sur onClick sont gérés à un endroit et ne surchargent pas la méthode onCreate. Mais l’inconvénient, je vois, c’est que:

    1. vues eux-mêmes,
    2. et tout autre object pouvant se trouver dans onCreate utilisé par la méthode onClick devra être transformé en un champ.

    Faites-moi savoir si vous souhaitez plus d’informations. Je n’ai pas répondu complètement à votre question parce que c’est une très longue question. Et si je trouve des sites, je développerai ma réponse, maintenant je ne fais que donner de l’expérience.

    # 1 J’utilise fréquemment le dernier lorsque des boutons sur la mise en page ne sont pas générés (mais manifestement statiques).

    Si vous l’utilisez dans la pratique et dans une application professionnelle, portez une attention particulière ici, car lorsque vous utilisez obfuscater source comme ProGuard, vous devez marquer ces méthodes dans votre activité pour ne pas être obscurcies.

    Pour l’archivage d’une sorte de sécurité à la compilation avec cette approche, consultez Android Lint ( exemple ).


    # 2 Avantages et inconvénients pour toutes les méthodes sont presque les mêmes et la leçon devrait être:

    Utilisez ce qui est le plus approprié ou qui vous semble le plus intuitif.

    Si vous devez atsortingbuer le même OnClickListener à plusieurs instances de bouton, enregistrez-le dans le champ d’application de la classe (# 1). Si vous avez besoin d’un simple écouteur pour un bouton, effectuez une implémentation anonyme:

     button.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { // Take action. } }); 

    J’ai tendance à ne pas implémenter OnClickListener dans l’activité, cela devient un peu déroutant de temps en temps (en particulier lorsque vous implémentez plusieurs autres gestionnaires d’événements et que personne ne sait ce que tout cela fait).

    Je préfère l’option 4, mais cela me semble intuitif car je travaille beaucoup trop avec Grails, Groovy et JavaFX. Les connexions “magiques” entre la vue et le contrôleur sont communes à tous. Il est important de bien nommer la méthode:

    Dans la vue, ajoutez la méthode onClick au bouton ou à un autre widget:

      android:clickable="true" android:onClick="onButtonClickCancel" 

    Ensuite, dans la classe, manipulez la méthode:

     public void onButtonClickCancel(View view) { Toast.makeText(this, "Cancel pressed", Toast.LENGTH_LONG).show(); } 

    Encore une fois, nommez clairement la méthode, quelque chose que vous devriez faire de toute façon, et la maintenance devient une seconde nature.

    Un gros avantage est que vous pouvez désormais écrire des tests unitaires pour la méthode. L’option 1 peut le faire, mais 2 et 3 sont plus difficiles.

    La manière la plus utilisée est la déclaration anonyme

      Button send = (Button) findViewById(R.id.buttonSend); send.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { // handle click } }); 

    Vous pouvez également créer un object View.OnClickListener et le définir sur le bouton plus tard, mais vous devez toujours remplacer la méthode onClick par exemple.

     View.OnClickListener listener = new View.OnClickListener(){ @Override public void onClick(View v) { // handle click } } Button send = (Button) findViewById(R.id.buttonSend); send.setOnClickListener(listener); 

    Lorsque votre activité implémente l’interface OnClickListener, vous devez remplacer la méthode onClick (View v) sur le niveau d’activité. Ensuite, vous pouvez associer cette activité en tant qu’écouteur au bouton, car il implémente déjà l’interface et remplace la méthode onClick ()

     public class MyActivity extends Activity implements View.OnClickListener{ @Override public void onClick(View v) { // handle click } @Override public void onCreate(Bundle b) { Button send = (Button) findViewById(R.id.buttonSend); send.setOnClickListener(this); } } 

    (imho) 4ème approche utilisée lorsque plusieurs boutons ont le même gestionnaire, et que vous pouvez déclarer une méthode dans la classe d’activité et atsortingbuer cette méthode à plusieurs boutons dans la disposition xml, vous pouvez également créer une méthode pour un bouton, mais dans ce cas je préférez déclarer les gestionnaires dans la classe d’activité.

    Les options 1 et 2 impliquent l’utilisation d’une classe interne qui rendra le code un peu encombrant. L’option 2 est en quelque sorte désordonnée car il y aura un auditeur pour chaque bouton. Si vous avez peu de boutons, ça va. Pour l’option 4, je pense que ce sera plus difficile à déboguer, car vous devrez revenir en arrière et classer le code XML et Java. J’utilise personnellement l’option 3 lorsque je dois gérer plusieurs clics.

    Mon échantillon, testé dans le studio Android 2.1

    Bouton Définir dans la mise en page XML

      

    Détection de pulsations Java

     Button clickButton = (Button) findViewById(R.id.btn1); if (clickButton != null) { clickButton.setOnClickListener( new View.OnClickListener() { @Override public void onClick(View v) { /***Do what you want with the click here***/ } }); } 

    Pour rendre les choses plus faciles asp Question 2, vous pouvez utiliser la méthode lambda comme celle-ci pour économiser de la mémoire variable et éviter de naviguer de haut en bas dans votre classe de vue

     //method 1 findViewById(R.id.buttonSend).setOnClickListener(v -> { // handle click }); 

    mais si vous souhaitez appliquer un événement click à votre bouton à la fois dans une méthode.

    vous pouvez utiliser la question 3 de @D. Tran répond. Mais n’oubliez pas d’implémenter votre classe d’ View.OnClickListener avec View.OnClickListener .

    Dans d’autres pour utiliser correctement la question n ° 3

    Question n ° 1 – Ce sont les seuls moyens de gérer les clics de vue.

    Question 2 –
    Option 1 / Option 4 – Il n’y a pas beaucoup de différence entre les options 1 et 4. La seule différence que je vois est que dans un cas, l’activité implémente OnClickListener, alors que dans l’autre cas, il y aurait une implémentation anonyme.

    Option # 2 – Dans cette méthode, une classe anonyme sera générée. Cette méthode est un peu lourde, car vous devrez le faire plusieurs fois si vous avez plusieurs boutons. Pour les classes anonymes, vous devez faire attention à gérer les memory leaks.

    Option n ° 3 – Bien que ce soit un moyen facile. En règle générale, les programmeurs essaient de ne pas utiliser de méthode tant qu’ils ne l’écrivent pas et, par conséquent, cette méthode n’est pas largement utilisée. Vous verrez que la plupart des gens utilisent l’option # 4. Parce que c’est plus propre en terme de code.

    Il existe également des options disponibles sous la forme de diverses bibliothèques qui peuvent rendre ce processus très familier aux personnes qui ont utilisé d’autres frameworks MVVM.

    https://developer.android.com/topic/libraries/data-binding/

    Affiche un exemple de bibliothèque officielle, qui vous permet de lier des boutons comme celui-ci:

      

    Étape 1: Créez un fichier XML:

     < ?xml version="1.0" encoding="utf-8"?>    

    Étape 2: Créer MainActivity:

     package com.scancode.acutesoft.telephonymanagerapp; import android.app.Activity; import android.os.Bundle; import android.view.View; import android.widget.Button; public class MainActivity extends Activity implements View.OnClickListener { Button btnClickEvent; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); btnClickEvent = (Button) findViewById(R.id.btnClickEvent); btnClickEvent.setOnClickListener(MainActivity.this); } @Override public void onClick(View v) { //Your Logic } } 

    HappyCoding!