Android : comment gérer le clic d'un bouton

Question

Ayant une solide expérience dans le domaine non-Java et non-Android, j'apprends Android.

J'ai beaucoup de confusion dans différents domaines, l'un d'entre eux étant la façon de gérer les clics de bouton. Il y a au moins 4 façons de le faire ( !!!), elles sont brièvement énumérées ci-dessous aquí

Par souci de cohérence, je vais les énumérer :

1. Avoir un membre de la View.OnClickListener dans l'activité et l'assigner à une instance qui gérera la classe onClick logique dans le onCreate méthode d'activité.

2. Créez un "onClickListener" dans la méthode d'activité "onCreate" et affectez-le au bouton en utilisant setOnClickListener.

3. Implémentez 'onClickListener' dans l'activité elle-même et assignez 'this' comme un écouteur pour le bouton. Si l'activité comporte plusieurs boutons, l'identifiant du bouton doit être analysé afin d'exécuter le gestionnaire "onClick" pour le bon bouton.

4. Avoir une méthode publique sur l'activité qui implémente la logique 'onClick' et l'assigner au bouton dans la déclaration xml de l'activité.

Question n° 1 :

Est-ce que ce sont toutes les méthodes, y a-t-il une autre option ? (Je n'en ai pas besoin, je suis juste curieux)

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

Cependant, je ne vois pas cette approche utilisée à grande échelle. Quels sont les inconvénients de son utilisation ?

Question n°2 :

Quels sont les avantages et les inconvénients de chacune de ces méthodes ? Veuillez partager votre expérience ou un bon lien.

Tout commentaire est le bienvenu !

P.S. J'ai essayé de chercher sur Google et de trouver quelque chose pour ce sujet, mais les seules choses que j'ai trouvées sont des descriptions du "comment" faire cela, pas pourquoi c'est bon ou mauvais.

Answer 1

Question 1 : Malheureusement, celui que vous dites être le plus intuitif est le moins utilisé dans Android. Si je comprends bien, vous devez séparer votre interface utilisateur (XML) et les fonctionnalités informatiques (fichiers de classe Java). Cela permet également de faciliter 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 éléments utilisés sont le #2 et le #3. Je vais utiliser un bouton clickButton comme exemple.

2

se présente sous la forme d'une classe 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***
            }
        });

C'est ma préférée car la méthode onClick se trouve juste à côté de l'endroit où la variable du bouton a été définie avec le findViewById. Le fait que tout ce qui concerne la vue du bouton clickButton se trouve ici semble très ordonné.

Un inconvénient que mon collègue commente, est que si vous imaginez que vous avez beaucoup de vues qui ont besoin d'un listener onclick. Vous pouvez voir que votre onCreate va devenir très long. C'est pourquoi il aime utiliser :

3

Disons que vous avez 5 boutons de clic :

Assurez-vous que votre activité/fragment implémente le 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
    }
}

Cette méthode, comme l'explique mon collègue, est plus propre à ses yeux, car tous les calculs de l'onClick sont traités à un seul endroit et n'encombrent pas la méthode onCreate. Mais l'inconvénient que je vois est que la méthode :

1. eux-mêmes,
2. et tout autre objet qui pourrait se trouver dans onCreate utilisé par la méthode onClick devra être transformé en champ.

Faites-moi savoir si vous souhaitez obtenir plus d'informations. Je n'ai pas répondu complètement à votre question parce que c'est une question assez longue. Et si je trouve des sites, je développerai ma réponse, pour l'instant je ne fais que donner quelques expériences.

Answer 2

#1 J'utilise fréquemment la dernière lorsque j'ai des boutons sur la mise en page qui ne sont pas générés (mais statiques évidemment).

Si vous l'utilisez dans la pratique et dans une application commerciale, faites très attention ici, car lorsque vous utilisez source obfuscateur comme ProGuard, vous devrez marquer ces méthodes dans votre activité pour qu'elles ne soient pas obfusquées.

Pour archiver une sorte de sécurité au moment de la compilation avec cette approche, jetez un coup d'œil à Android Lint ( exemple ).

---

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

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

Si vous devez attribuer le même OnClickListener à plusieurs instances de boutons, enregistrez-la dans la classe-scope (#1). Si vous avez besoin d'un simple écouteur pour un bouton, créez une implémentation anonyme :

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

J'ai tendance à ne pas mettre en œuvre la OnClickListener dans l'activité, cela devient un peu confus de temps en temps (surtout lorsque vous implémentez de multiples autres gestionnaires d'événements et que personne ne sait ce qu'il faut faire ). this fait).

Answer 3

Je préfère l'option 4, mais elle a un sens intuitif pour moi car je travaille beaucoup trop en 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 autre widget :

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

Puis dans la classe, gérez 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 l'entretien devient une seconde nature.

Un grand avantage est que vous pouvez maintenant écrire des tests unitaires pour la méthode. L'option 1 permet de le faire, mais les options 2 et 3 sont plus difficiles.

Answer 4

Le moyen le plus utilisé 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 l'objet View.OnClickListener et le fixer sur le bouton plus tard, mais vous devez toujours surcharger 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 surcharger la méthode onClick(View v) au niveau de l'activité. Vous pouvez alors assigner cette activité en tant qu'écouteur du bouton, car elle implémente déjà l'interface et surcharge 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) La quatrième approche est utilisée lorsque plusieurs boutons ont le même gestionnaire, et vous pouvez déclarer une méthode dans la classe d'activité et affecter cette méthode à plusieurs boutons dans la mise en page xml, vous pouvez également créer une méthode pour un bouton, mais dans ce cas je préfère déclarer les gestionnaires à l'intérieur de la classe d'activité.

Answer 5

Étape 1 : créer un fichier XML :

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btnClickEvent"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Click Me" />
</LinearLayout>

Étape 2 : Créer l'activité principale :

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 !