Présentation des événements d'entrée

Essayer Compose

Jetpack Compose est le kit d'outils d'interface utilisateur recommandé pour Android. Découvrez comment utiliser l'écran tactile et la saisie dans Compose.

<ph type="x-smartling-placeholder"></ph> Gestion des interactions des utilisateurs →

Sous Android, il existe plusieurs façons d'intercepter les événements liés à l'interaction d'un utilisateur avec votre application. Lorsque vous examinez les événements de votre interface utilisateur, l'approche consiste à capturer les événements l'objet View spécifique avec lequel l'utilisateur interagit. La classe View permet d'effectuer cette opération.

Dans les différentes classes View que vous utiliserez pour composer votre mise en page, vous remarquerez peut-être plusieurs rappels publics utiles pour les événements d'interface utilisateur. Ces méthodes sont appelées par le framework Android lorsque l'action correspondante a lieu sur cet objet. Par exemple, lorsqu'un utilisateur appuie sur une vue (un bouton, par exemple), La méthode onTouchEvent() est appelée sur cet objet. Cependant, pour intercepter cela, vous devez étendre la classe et remplacer la méthode. Toutefois, l'extension de chaque objet View pour gérer un tel événement ne serait pas pratique. C'est pourquoi la classe View contient également une collection d'interfaces imbriquées avec des rappels que vous pouvez définir beaucoup plus facilement. Ces interfaces, appelés écouteurs d'événements, qui vous permettent de capturer l'interaction de l'utilisateur avec votre interface utilisateur.

Bien que vous utilisiez plus souvent les écouteurs d'événements pour écouter les interactions des utilisateurs, il peut y avoir vous pouvez étendre une classe View afin de créer un composant personnalisé. Vous souhaitez peut-être étendre Button pour rendre quelque chose plus sophistiqué. Dans ce cas, vous pouvez définir les comportements d'événements par défaut à l'aide de la classe event handlers.

Écouteurs d'événements

Un écouteur d'événements est une interface de la classe View contenant un seul . Ces méthodes seront appelées par le framework Android lorsque la vue sur laquelle l'écouteur a est déclenchée par une interaction de l'utilisateur avec l'élément dans l'UI.

Les interfaces d'écouteur d'événements incluent les méthodes de rappel suivantes:

onClick()

À partir de View.OnClickListener. Cette méthode est appelée lorsque l'utilisateur touche l'élément (en mode Écran tactile), ou se concentre sur l'élément à l'aide des touches de navigation ou du trackball et appuie sur la touche "Entrée" appropriée ou en appuyant de manière prolongée sur le trackball.

onLongClick()

À partir de View.OnLongClickListener. Cette méthode est appelée lorsque l'utilisateur appuie de manière prolongée sur l'élément (en mode Écran tactile), ou se concentre sur l'élément à l'aide des touches de navigation ou du trackball et doit appuyer de manière prolongée sur la touche "Entrée" appropriée ou appuie longuement sur le trackball (pendant une seconde).

onFocusChange()

À partir de View.OnFocusChangeListener. Cette méthode est appelée lorsque l'utilisateur accède à l'élément ou en sort à l'aide des touches de navigation ou du trackball.

onKey()

À partir de View.OnKeyListener. Cette méthode est appelée lorsque l'utilisateur sélectionne l'élément et appuie ou libère une touche matérielle sur l'appareil.

onTouch()

À partir de View.OnTouchListener. Elle est appelée lorsque l'utilisateur effectue une action qualifiée d'événement tactile, y compris une pression, un relâchement ou tout geste de mouvement à l'écran (dans les limites de l'élément).

onCreateContextMenu()

À partir de View.OnCreateContextMenuListener. Ce procédé est appelé lors de la création d'un menu contextuel (à la suite d'un "clic long" prolongé). Lire la discussion sur les menus contextuels des Menus guide du développeur.

Ces méthodes sont les seules utilisateurs de leur interface respective. Pour définir l'une de ces méthodes, et gérer vos événements, implémentez l'interface imbriquée dans votre Activity ou définissez-la en tant que classe anonyme. Ensuite, transmettez une instance de votre implémentation à la méthode View.set...Listener() correspondante. (par exemple, appeler setOnClickListener() et transmettez-lui votre implémentation de OnClickListener.)

L'exemple ci-dessous montre comment enregistrer un écouteur de clics pour un bouton.

protected void onCreate(savedValues: Bundle) {
    ...
    val button: Button = findViewById(R.id.corky)
    // Register the onClick listener with the implementation above
    button.setOnClickListener { view ->
        // do something when the button is clicked
    }
    ...
}

// Create an anonymous implementation of OnClickListener
private OnClickListener corkyListener = new OnClickListener() {
    public void onClick(View v) {
      // do something when the button is clicked
    }
};

protected void onCreate(Bundle savedValues) {
    ...
    // Capture our button from layout
    Button button = (Button)findViewById(R.id.corky);
    // Register the onClick listener with the implementation above
    button.setOnClickListener(corkyListener);
    ...
}

Il peut également s'avérer plus pratique d'implémenter OnClickListener dans votre Activity. Cela permet d'éviter le chargement de classe supplémentaire et l'allocation d'objets. Exemple :

class ExampleActivity : Activity(), OnClickListener {
  
    protected fun onCreate(savedValues: Bundle) {
        val button: Button = findViewById(R.id.corky)
        button.setOnClickListener(this)
    }

    // Implement the OnClickListener callback
    fun onClick(v: View) {
        // do something when the button is clicked
    }
}

public class ExampleActivity extends Activity implements OnClickListener {
    protected void onCreate(Bundle savedValues) {
        ...
        Button button = (Button)findViewById(R.id.corky);
        button.setOnClickListener(this);
    }

    // Implement the OnClickListener callback
    public void onClick(View v) {
      // do something when the button is clicked
    }
    ...
}

Notez que dans l'exemple ci-dessus, le rappel onClick() a aucune valeur renvoyée, mais d'autres méthodes d'écouteur d'événements doivent renvoyer une valeur booléenne. La raison dépend de l'événement. Voici pourquoi:

• onLongClick() – Cette méthode renvoie une valeur booléenne pour indiquer si vous avez consommé l'événement et si celui-ci ne doit pas être utilisé plus loin. Autrement dit, renvoyez true pour indiquer que vous avez géré l'événement et qu'il doit s'arrêter ici. renvoient false si vous ne l'avez pas géré et/ou si l'événement doit continuer à les écouteurs de clics.
• onKey() – Cette méthode renvoie une valeur booléenne pour indiquer si vous avez consommé l'événement et si celui-ci ne doit pas être utilisé plus loin. Autrement dit, renvoyez true pour indiquer que vous avez géré l'événement et qu'il doit s'arrêter ici. renvoient false si vous ne l'avez pas géré et/ou si l'événement doit continuer à des écouteurs sur les touches.
• onTouch() – Renvoie une valeur booléenne pour indiquer si votre écouteur utilise cet événement. Le plus important, c'est que cet événement peut avoir plusieurs actions qui se succèdent. Ainsi, si vous renvoyez false lorsque le d'action "vers le bas" est reçu, vous indiquez que vous n'avez pas consommé l'événement et que que les actions ultérieures de cet événement ne vous intéressent pas. Vous ne serez donc appelé à aucune autre action dans l'événement, comme un geste avec le doigt ou l'événement d'action final.

N'oubliez pas que les événements de touche matérielle sont toujours envoyés à la vue active. Elles sont envoyées en partant du haut de la hiérarchie des vues, puis vers le bas, jusqu'à ce qu'ils atteignent la destination appropriée. Si votre vue (ou un enfant de votre vue) est actuellement sélectionné, vous pouvez voir l'événement transiter par la méthode dispatchKeyEvent(). Au lieu de capturer des événements clés via votre vue, vous pouvez également recevoir tous les événements de votre activité avec onKeyDown() et onKeyUp().

De plus, lorsque vous réfléchissez à la saisie de texte pour votre application, n'oubliez pas que de nombreux appareils ne disposent que d'une entrée logicielle. méthodes. Ces méthodes ne doivent pas nécessairement être basées sur des clés. certaines peuvent utiliser la saisie vocale, l'écriture manuscrite, etc. Même si mode de saisie présente une interface semblable à un clavier, il ne déclenche généralement pas le Famille d'événements onKeyDown(). Vous ne devez jamais créer une UI qui nécessite de contrôler des pressions spécifiques sur des touches, sauf si vous souhaitez limiter votre application aux appareils avec un clavier physique. En particulier, ne vous fiez pas à ces méthodes pour valider la saisie lorsque l'utilisateur appuie sur le bouton return key; Utilisez plutôt des actions comme IME_ACTION_DONE pour signaler la manière dont votre application s'attend à réagir, ce qui peut modifier son UI de manière significative. Éviter les suppositions sur le fonctionnement d'un mode de saisie logiciel et faites-vous confiance pour fournir du texte déjà formaté à votre application.

Remarque:Android appelle d'abord les gestionnaires d'événements, puis les gestionnaires d'événements par défaut les gestionnaires de la définition de classe. Par conséquent, si vous renvoyez la valeur true à partir de ces écouteurs d'événements, la propagation de l'événement aux autres écouteurs d'événements et bloquera également le rappel vers gestionnaire d'événements par défaut dans la vue. Assurez-vous donc de vouloir arrêter l'événement lorsque vous renvoyez true.

Gestionnaires d'événements

Si vous créez un composant personnalisé à partir d'une vue, vous pourrez définir plusieurs méthodes de rappel utilisés comme gestionnaires d'événements par défaut. Dans le document sur les Règles Voir les composants, vous découvrirez certains des rappels courants utilisés pour la gestion des événements, y compris:

• onKeyDown(int, KeyEvent) : appelé lorsqu'un nouvel événement clé se produit.
• onKeyUp(int, KeyEvent) : appelé lorsqu'un événement de touche
• onTrackballEvent(MotionEvent) : appelé lorsqu'un événement de mouvement de trackball se produit.
• onTouchEvent(MotionEvent) : appelé en cas de mouvement de l'écran tactile.
• onFocusChanged(boolean, int, Rect) : appelé lorsque la vue gagne ou perd le focus.

Il existe d'autres méthodes que vous devez connaître, qui ne font pas partie de la classe View, mais cela peut avoir un impact direct sur la façon dont vous êtes en mesure de gérer les événements. Ainsi, lorsque vous gérez des événements plus complexes à l'intérieur une mise en page, envisagez ces autres méthodes:

• Activity.dispatchTouchEvent(MotionEvent) : cette option permet à votre Activity d'intercepter tous les événements tactiles avant qu'ils ne soient envoyés à la fenêtre.
• ViewGroup.onInterceptTouchEvent(MotionEvent) : permet à un ViewGroup de surveiller les événements lorsqu'ils sont envoyés aux vues enfants.
• ViewParent.requestDisallowInterceptTouchEvent(boolean) - Call this (Appeler cet élément) sur une vue parent pour indiquer qu'elle ne doit pas intercepter les événements tactiles avec onInterceptTouchEvent(MotionEvent).

Mode Écran tactile

Lorsqu'un utilisateur navigue dans une interface utilisateur à l'aide de touches directionnelles ou d'un trackball, il est nécessaire pour se concentrer sur les éléments exploitables (comme les boutons) afin que l'utilisateur puisse voir qui accepte la saisie. Toutefois, si l'appareil est doté de fonctionnalités tactiles et que l'utilisateur commence à interagir avec l'interface en la touchant, alors il n'est plus nécessaire de mettre en évidence des éléments ou se concentrer sur une vue en particulier. Il existe donc un mode pour une interaction appelée "mode tactile".

Pour un appareil tactile, une fois que l'utilisateur touche l'écran, l'appareil passe en mode tactile. Désormais, seules les vues pour lesquelles isFocusableInTouchMode() est défini sur "true", comme les widgets d'édition de texte. Les autres vues sur lesquelles il est possible d'appuyer, comme les boutons, ne sont pas mises en évidence lorsque l'utilisateur appuie dessus. elle fera déclenchez simplement leurs écouteurs de clics lorsque l'utilisateur appuie dessus.

Chaque fois qu'un utilisateur appuie sur une touche directionnelle ou fait un défilement avec un trackball, l'appareil quitter le mode tactile et trouver une vue pour faire la mise au point. L'utilisateur peut à nouveau interagir avec l'interface utilisateur sans toucher l'écran.

Le mode tactile est conservé dans l'ensemble du système (toutes les fenêtres et activités). Pour interroger l'état actuel, vous pouvez appeler isInTouchMode() pour voir si l'appareil est actuellement en mode Écran tactile.

Gérer la sélection

Le framework gère le mouvement de sélection de routine en réponse à l'entrée utilisateur. Par exemple, vous pouvez modifier le curseur lorsque des vues sont supprimées ou masquées, ou lorsque de nouvelles vues sont ajoutées. Des vues deviennent disponibles. Les vues indiquent qu'elles sont prêtes à se concentrer via la méthode isFocusable(). Pour définir si une vue peut prendre Sélectionner, appelez setFocusable(). En mode Écran tactile, vous pouvez demander si une vue autorise le focus avec isFocusableInTouchMode(). Vous pouvez modifier cela avec setFocusableInTouchMode().

Sur les appareils équipés d'Android 9 (niveau d'API 28) ou version ultérieure, les activités n'attribuent pas le focus initial. Au lieu de cela, vous devez demander explicitement la sélection initiale, si vous le souhaitez.

Le mouvement de mise au point est basé sur un algorithme qui trouve le voisin le plus proche dans un une direction donnée. Dans de rares cas, il se peut que l'algorithme par défaut ne corresponde pas au le comportement souhaité du développeur. Dans ces situations, vous pouvez fournir remplacements explicites par les attributs XML suivants dans le fichier de mise en page: nextFocusDown, nextFocusLeft, nextFocusRight et nextFocusUp Ajoutez l'un de ces attributs à la colonne View from, l'objectif est de partir. Définit la valeur de l'attribut comme étant l'identifiant de la vue. to l'élément à cibler. Exemple :

<LinearLayout
    android:orientation="vertical"
    ... >
  <Button android:id="@+id/top"
          android:nextFocusUp="@+id/bottom"
          ... />
  <Button android:id="@+id/bottom"
          android:nextFocusDown="@+id/top"
          ... />
</LinearLayout>

Habituellement, dans cette mise en page verticale, le fait de remonter à partir du premier bouton ne ni de descendre depuis le deuxième bouton. Maintenant que le bouton du haut a défini celui du bas comme nextFocusUp (et inversement), le focus de navigation de haut en bas et de bas en haut.

Si vous souhaitez déclarer une vue comme sélectionnable dans votre interface utilisateur (quand elle ne l'est généralement pas), Ajoutez l'attribut XML android:focusable à la vue dans votre déclaration de mise en page. Définissez la valeur true. Vous pouvez également déclarer une vue comme sélectionnable lorsque vous êtes en mode Écran tactile avec android:focusableInTouchMode.

Pour demander le focus d'une vue particulière, appelez requestFocus().

Pour écouter les événements de sélection (être averti lorsqu'une vue est sélectionnée ou non), utilisez onFocusChange(), comme indiqué dans la section Écouteurs d'événements.