Introduction à cette section

En 3.1, nous avons découvert l'un des mécanismes de gestion des événements sous Android — le mécanisme de gestion des événements basé sur les écouteurs. En termes simples, il ajoute un écouteur à notre source d'événement (composant). Lorsque l'utilisateur déclenche un événement, celui-ci est transmis à l'écouteur pour traitement, et différentes opérations sont effectuées selon les différents événements. Alors, quel est le principe du mécanisme de gestion des événements basé sur les callbacks ? Eh bien, il y a aussi une autre question : savez-vous ce qu'est uncallback de méthode? Le savez-vous ? Je crois que beaucoup de personnes le comprennent mais n'arrivent pas vraiment à l'expliquer ! Très bien, avec ces questions, analysons le mécanisme de gestion des événements par callback dans le système de gestion des événements d'Android !


1. Qu'est-ce qu'un callback de méthode ?

Description textuelle :

Réponse : C'est un moyen de séparer la définition de fonction de son implémentation, une idée de conception de découplage ; en Java, les callbacks sont implémentés via des interfaces. En tant qu'architecture système, elle doit avoir son propre environnement d'exécution et doit fournir des interfaces que les utilisateurs implémentent ; l'implémentation dépend du client, de sorte que l'interface puisse être unifiée tandis que les implémentations diffèrent. Le système « rappelle » notre classe d'implémentation dans différents états, réalisant ainsi la séparation de l'interface et de l'implémentation !

Un exemple simple :

Par exemple :Tu rentres de l'école le vendredi après-midi et tu demandes à ta maman si le dîner est prêt. Elle dit que ce n'est pas encore prêt. Alors tu lui dis : « Maman, je vais regarder Pleasant Goat. Appelle-moi quand le dîner sera prêt ! »Analyse :Toi et ta maman avez convenu d'une interface. Par cette interface, tu demandes à ta maman de cuisiner. Quand le repas est prêt, ta maman utilise cette interface pour te faire un retour : « Le dîner est prêt ! »

2. Explication détaillée du mécanisme de gestion d'événements basé sur les callbacks d'Android :

Dans Android, il existe deux scénarios dans lesquels le mécanisme de gestion d'événements basé sur les callbacks est utilisé :

1) Vue personnalisée

Lorsqu'un utilisateur déclenche un événement sur un composant GUI, le composant possède ses propres méthodes spécifiques chargées de gérer cet événement. Utilisation courante : hériter d'un composant GUI de base et redéfinir ses méthodes de gestion d'événements, c'est-à-dire créer une vue personnalisée. Remarque : lors de l'utilisation d'une vue personnalisée dans une mise en page XML, vous devez utiliser le « nom de classe pleinement qualifié ».

Méthodes de callback courantes des composants View :

Android fournit certaines méthodes de callback pour la gestion des événements sur les composants GUI. En prenant View comme exemple, il existe les méthodes suivantes :

① Déclenchement d'un événement d'écran sur ce composant : booleanonTouchEvent(MotionEvent event);
② Appui sur un bouton de ce composant : booleanonKeyDown(int keyCode,KeyEvent event);
③ Relâchement d'un bouton de ce composant : booleanonKeyUp(int keyCode,KeyEvent event);
④ Appui long sur un bouton de ce composant : booleanonKeyLongPress(int keyCode,KeyEvent event);
⑤ Un événement de raccourci clavier se produit : booleanonKeyShortcut(int keyCode,KeyEvent event);
⑥ Déclenchement d'un événement d'écran de trackball sur ce composant : booleanonTrackballEvent(MotionEvent event);
*⑦ Lorsque le focus du composant change — contrairement aux six méthodes précédentes, cette méthode ne peut être redéfinie que dans View ! protected voidonFocusChanged(boolean gainFocus, int direction, Rect previously FocusedRect)

De plus, laissez-moi expliquer ce qu'est une trackball. Elle n'est cependant pas très utile ; on pouvait la voir sur les anciens téléphones BlackBerry. Lorsque nous parcourons des pages web, nous pouvons considérer la trackball comme une souris. Toutefois, pour de telles opérations, nous pouvons les gérer avec onTouchEvent, et ce n'est pas très élégant, donc elle est rarement utilisée aujourd'hui. Si vous êtes intéressé pour la voir, vous pouvez appuyer sur F6 dans l'émulateur Android d'origine !

Exemple de code :Nous définissons une classe personnalisée MyButton qui hérite de la classe Button, puis nous redéfinissons la méthode onKeyLongPress. Ensuite, dans le fichier XML, nous appelons la vue personnalisée en utilisant son nom de classe pleinement qualifié.

L'effet est présenté ci-dessous :

Un simple bouton. Cliquer sur le bouton déclenche l'événement onTouchEvent. Lorsque nous appuyons sur une touche du clavier de l'émulateur, l'appui déclenche onKeyDown, et le relâchement de la touche déclenche l'événement onKeyUp. Nous observons cela via Logcat !

Code d'implémentation : MyButton.java

public class MyButton extends Button{  
    private static String TAG = "呵呵";  
    public MyButton(Context context, AttributeSet attrs) {  
        super(context, attrs);  
    }  
  
    //重写键盘按下触发的事件  
    @Override  
    public boolean onKeyDown(int keyCode, KeyEvent event) {  
        super.onKeyDown(keyCode,event);  
        Log.i(TAG, "onKeyDown方法被调用");  
        return true;  
    }  
  
    //重写弹起键盘触发的事件  
    @Override  
    public boolean onKeyUp(int keyCode, KeyEvent event) {  
        super.onKeyUp(keyCode,event);  
        Log.i(TAG,"onKeyUp方法被调用");  
        return true;  
    }  
  
    //组件被触摸了  
    @Override  
    public boolean onTouchEvent(MotionEvent event) {  
        super.onTouchEvent(event);  
        Log.i(TAG,"onTouchEvent方法被调用");  
        return true;  
    }  
} 

Fichier de mise en page :

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    xmlns:tools="http://schemas.android.com/tools"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    tools:context=".MyActivity">  
    
    <example.jay.com.mybutton.MyButton  
        android:layout_width="wrap_content"  
        android:layout_height="wrap_content"  
        android:text="按钮"/> 

Analyse du code :

Comme nous avons directement redéfini les trois méthodes de rappel de Button, lorsqu'un événement de clic se produit, nous n'avons pas besoin de lier un écouteur d'événements dans le fichier Java pour effectuer le rappel. C'est-à-dire que le composant gère lui-même l'événement correspondant — l'événement est géré par la source de l'événement (le composant) elle-même !


2) Propagation d'événements basée sur les rappels :

En résumé, le fait que l'événement se propage vers l'extérieur dépend de si la valeur de retour de la méthode est true ou false ;

Exemple de code :

public class MyButton extends Button{  
    private static String TAG = "呵呵";  
    public MyButton(Context context, AttributeSet attrs) {  
        super(context, attrs);  
    }  
  
    //重写键盘按下触发的事件  
    @Override  
    public boolean onKeyDown(int keyCode, KeyEvent event) {  
        super.onKeyDown(keyCode,event);  
        Log.i(TAG, "自定义按钮的onKeyDown方法被调用");  
        return false;  
    }  
}

main.xml :

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    xmlns:tools="http://schemas.android.com/tools"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    tools:context=".MyActivity">  
  
    <example.jay.com.mybutton.MyButton  
        android:layout_width="wrap_content"  
        android:layout_height="wrap_content"  
        android:text="自定义按钮"  
        android:id="@+id/btn_my"/>  
</LinearLayout>  

MainActivity.java :

public class MyActivity extends ActionBarActivity {  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_my);  
  
        Button btn = (Button)findViewById(R.id.btn_my);  
        btn.setOnKeyListener(new View.OnKeyListener() {  
            @Override  
            public boolean onKey(View v, int keyCode, KeyEvent event) {  
                if(event.getAction() == KeyEvent.ACTION_DOWN)  
                {  
                    Log.i("呵呵","监听器的onKeyDown方法被调用");  
                }  
                return false;  
            }  
        });  
    }  
  
    @Override  
    public boolean onKeyDown(int keyCode, KeyEvent event) {  
        super.onKeyDown(keyCode, event);  
        Log.i("呵呵","Activity的onKeyDown方法被调用");  
        return false;  
    }  
} 

Capture d'écran d'exécution :

Analyse des résultats : D'après les résultats d'exécution ci-dessus, nous pouvons voir que l'ordre de propagation est :Écouteur--->méthode de rappel du composant View--->méthode de rappel de l'Activity;


Résumé de cette section

Cette section a expliqué le mécanisme de gestion des événements basé sur les rappels dans le système de gestion des événements d'Android ! Le cœur est l'ordre de propagation des événements : l'écouteur est prioritaire, puis le composant View lui-même, et enfin l'Activity ; une valeur de retour false poursuit la propagation, tandis que true l'arrête~!