Mécanisme de gestion des événements basé sur le rappel
Introduction à cette section
En 3.1, nous avons étudié un mécanisme de traitement d'événements sous Android - le mécanisme de traitement d'événements basé sur l'écoute. Pour faire simple, c'est le cas. Ajoutez un écouteur à notre source d'événement (composant), puis lorsque l'utilisateur déclenche l'événement, il est transmis à l'écouteur pour qu'il le gère, en fonction des différents événements Effectuer différentes opérations ; alors quel est le principe du mécanisme de traitement des événements basé sur le rappel ? Ok, encore une question : tu sais Qu'est-ce que le rappel de méthode ? Savez-vous? Je crois que beaucoup d’amis le savent, mais ils ne peuvent pas l’exprimer ! D'accord, avec ces questions, nous Analysons le mécanisme de traitement des événements de rappel dans le mécanisme de traitement des événements Android !
1. Qu'est-ce qu'un rappel de méthode ?
Description du texte :
Réponse : C'est un moyen de séparer la définition de fonction et la fonction, une idée de conception de découplage en Java. Il est implémenté via le interface, En tant qu'architecture système, elle doit disposer de son propre environnement d'exploitation et fournir aux utilisateurs une interface de mise en œuvre, la mise en œuvre dépend du client, de sorte que ; Pour obtenir des interfaces unifiées et des implémentations différentes, le système réalise la séparation des interfaces et des implémentations en « rappelant » nos classes d'implémentation dans différents états !
Un exemple simple :
Par exemple : Tu rentres de l'école vendredi et tu demandes à ta mère de cuisinier Le riz est-il bon ? Ta mère dit qu'il n'est pas encore cuit, alors tu lui dis : Maman, laisse-moi regarder Pleasant Goat. Quand tu as cuit le riz, appelle-moi Analyse : Toi et ta mère êtes d'accord sur une interface. Vous pouvez demander à votre mère de cuisiner via cette interface. le riz est prêt, ta mère Il vous donnera également un retour via cette interface, "Le riz est cuit" !
2. Explication détaillée du mécanisme de traitement des événements des rappels Android :
Il existe deux scénarios d'utilisation pour le mécanisme de traitement des événements basé sur les rappels dans Android :
1) Vue de personnalisation
Lorsque l'utilisateur déclenche un événement sur un composant GUI, le composant a sa propre méthode spécifique qui est responsable de la gestion de l'événement. Utilisation courante : hériter du composant GUI de base et réécrire la méthode de traitement des événements du composant, c'est-à-dire personnaliser la vue Remarque : Lorsque vous utilisez une vue personnalisée dans la mise en page XML, vous devez utiliser le « nom de classe complet »
Méthodes de rappel des composants View courants :
android Fournit des méthodes de rappel de traitement d'événements pour les composants de l'interface graphique. En prenant View comme exemple, il existe les méthodes suivantes
.①Déclencher des événements d'écran sur ce composant : booléen onTouchEvent(événement MotionEvent);
②Lorsqu'un bouton est enfoncé sur ce composant : booléen onKeyDown(int keyCode, Événement KeyEvent);
③Lors du relâchement d'un bouton du composant : booléen onKeyUp(int keyCode,KeyEvent event);
④Lors d'un appui long sur un bouton du composant : booléen onKeyLongPress(int keyCode,KeyEvent event);
⑤L'événement de raccourci clavier se produit : booléen onKeyShortcut(int keyCode,KeyEvent event);
⑥Sur le composant Déclenchez l'événement d'écran du trackball : boolean onTrackballEvent (Événement MotionEvent);
*⑦Lorsque le focus du composant change, contrairement aux 6 précédents, cette méthode ne peut être réécrite que dans View ! protected void onFocusChanged(boolean gainFocus, int direction, Rect précédemment FocusedRect)
De plus, cela explique ce qu'est un trackball, mais ce n'est pas très utile dans le passé, Téléphones mobiles BlackBerry Vous pouvez le voir lorsque nous naviguons sur le Web ; , vous pouvez considérer le trackball comme une souris, mais nous pouvons résoudre cette opération en utilisant onTouchEvent, et ce n'est pas assez beau, alors maintenant C'est très utile et fondamentalement inutile. Si vous êtes intéressé et souhaitez le voir, vous pouvez appuyer sur f6 dans l'émulateur Android d'origine pour le voir
Exemple de code. : Nous personnalisons une classe MyButton pour hériter de la classe Button, puis remplaçons la méthode onKeyLongPress ; Appelez ensuite la vue personnalisée
via le nom de classe complet dans le fichier XML. Le rendu est le suivant :
<. 🎜>
Code d'implémentation : MyButton.java
private static String TAG = "haha";
public MyButton(Context context, AttributeSet attrs) {
super(context, attrs); }
//Réécrivez l'événement déclenché par l'appui sur le clavier
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
super.onKeyDown(keyCode, event); Log.i(TAG, "la méthode onKeyDown est appelée");
return true;
}
//Réécrivez l'événement déclenché par l'apparition du clavier
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
super.onKeyUp(keyCode, event);
Log.i(TAG, "la méthode onKeyUp a été appelée"); 🎜>
//Le composant a été touché
@Override
public boolean onTouchEvent(Moti onEvent event) {
super.onTouchEvent(event);
Log.i(TAG", méthode onTouchEvent); est un appel");
return true;
}
}
Fichier de mise en page :
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="button"/> ;
Analyse du code :
Parce que nous avons directement réécrit les trois méthodes de rappel de Button, lorsqu'un événement de clic se produit, nous n'avons pas besoin de l'ajouter à le fichier Java en cours La liaison de l'écouteur d'événement peut compléter le rappel, c'est-à-dire que le composant traitera l'événement correspondant, c'est-à-dire que l'événement est géré par la source d'événement (composant) elle-même !
2) Propagation d'événements basée sur le rappel :
Exemple de code :
}
//Réécriture des événements déclenchés par les pressions sur le clavier
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
super. onKeyDown(keyCode, event);
Log.i(TAG, "La méthode onKeyDown du bouton personnalisé a été appelée");
return false;
main.xml :
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：
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate (état d'instance enregistré);
setContentView(R.layout.activity_my);
Bouton btn = (Bouton)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 ;
}
}
Exécuter la capture d'écran :
Analyse des résultats : À partir des résultats d'exécution ci-dessus, nous pouvons savoir que l'ordre de propagation est : Listener--->Méthode de rappel du composant de vue--->Méthode de rappel de l'activité ;
Résumé de cette section
Cette section explique le mécanisme de traitement des événements basé sur le rappel dans le mécanisme de traitement des événements Android ! Le cœur est l’ordre de propagation des événements L'écouteur a la priorité, puis sur le composant View lui-même, et enfin sur l'Activité ; la valeur de retour false continue de se propager, et true termine la propagation ~ !
