Les menus sont un composant d'interface utilisateur courant dans de nombreux types d'applications. À
une expérience utilisateur cohérente et familière, utilisez le
Menu
d'API pour
présenter les actions des utilisateurs et
d'autres options dans vos activités.
Ce document montre comment créer les trois principaux types de menus ou sur toutes les versions d'Android:
- Menu d'options et barre d'application
- Le menu d'options est le groupe principal d'éléments de menu
activité. C'est là que vous mettez en place des actions qui ont un impact mondial
application, comme
« Recherche », « Rédiger un e-mail », et "Paramètres".
Consultez le menu Créer une option. .
- Menu contextuel et mode d'action contextuelle
- Un menu contextuel est un menu flottant
qui apparaît lorsque l'utilisateur appuie sur un élément. Il
propose des actions qui affectent le contenu ou le cadre de contexte sélectionné.
Le mode d'action contextuelle affiche les tâches affecte le contenu sélectionné dans une barre en haut de l'écran et permet l'utilisateur sélectionne plusieurs éléments.
Consultez l'article Créer un menu contextuel. .
- Menu pop-up
- Un menu pop-up affiche une liste verticale d'éléments ancrés au
qui appelle le menu. Il est utile pour fournir un débordement d'actions
en lien avec un contenu spécifique ou pour proposer des options pour la deuxième partie
d'une commande. Les actions proposées dans un menu pop-up n'affectent pas directement
le contenu correspondant, c'est à cela que servent les actions contextuelles. Il s'agit plutôt
le menu pop-up permet d'effectuer des actions étendues relatives à des zones de contenu dans
votre activité.
Consultez la section Créer un menu pop-up.
Définir un menu en XML
Pour tous les types de menus, Android fournit un format XML standard pour définir les éléments de menu
éléments. Au lieu de créer un menu dans le code de votre activité, définissez un menu et
tous ses articles dans un fichier XML
ressource de menu. Vous pouvez
Gonfler la ressource de menu en la chargeant en tant que Menu
dans votre activité ou fragment.
Il est recommandé d'utiliser une ressource de menu pour les raisons suivantes:
- Il est plus facile de visualiser la structure du menu au format XML.
- Elle sépare le contenu du menu de l'attribut comportemental de votre application du code source.
- Il vous permet de créer d’autres configurations de menu pour différentes plateformes versions, tailles d'écran et autres configurations, en tirant parti des ressources de l'appli d'infrastructure.
Pour définir un menu, créez un fichier XML dans le fichier
Répertoire res/menu/
et créez le menu avec les éléments suivants :
éléments:
<menu>
- Définit un
Menu
, qui est un conteneur pour les éléments de menu. A L'élément<menu>
doit être le nœud racine du fichier. peut contenir un ou plusieurs<item>
et<group>
éléments. <item>
- Crée un
MenuItem
, qui représente un seul élément dans un menu. Cet élément peut contenir un élément<menu>
pour créer un sous-menu. <group>
- Conteneur facultatif et invisible pour
<item>
éléments. Il vous permet de catégoriser les éléments de menu afin qu’ils partagent des propriétés, comme comme l'état actif et la visibilité. Pour en savoir plus, consultez les Section Créer un groupe de menus
Voici un exemple de menu nommé game_menu.xml
:
<?xml version="1.0" encoding="utf-8"?> <menu xmlns:android="http://schemas.android.com/apk/res/android"> <item android:id="@+id/new_game" android:icon="@drawable/ic_new_game" android:title="@string/new_game" app:showAsAction="ifRoom"/> <item android:id="@+id/help" android:icon="@drawable/ic_help" android:title="@string/help" /> </menu>
L'élément <item>
accepte plusieurs attributs que vous pouvez utiliser
pour définir l'apparence et le comportement d'un élément. Les éléments du menu précédent
inclure les attributs suivants:
android:id
- ID de ressource propre à l'élément, ce qui permet à l'application reconnaître l'élément lorsque l'utilisateur la sélectionne.
android:icon
- Référence à un drawable à utiliser comme icône de l'élément.
android:title
- Référence à une chaîne à utiliser comme titre de l'élément.
android:showAsAction
- Préciser quand et comment cet élément doit apparaître comme une tâche dans la barre d'application.
Ce sont les attributs les plus importants que vous utilisez, mais il en existe beaucoup d'autres disponibles. Pour en savoir plus sur tous les attributs acceptés, consultez les Ressource de menu dans la documentation Google Cloud.
Vous pouvez ajouter un sous-menu à un élément de n'importe quel menu en ajoutant une
L'élément <menu>
en tant qu'enfant d'un élément <item>
.
Les sous-menus sont utiles lorsque votre application comporte de nombreuses fonctions qui peuvent être organisées
selon différents sujets, tels que les éléments de la barre de menu d'une application de PC (Fichier,
Edit (Modifier) et View (Afficher). Consultez l'exemple suivant :
<?xml version="1.0" encoding="utf-8"?> <menu xmlns:android="http://schemas.android.com/apk/res/android"> <item android:id="@+id/file" android:title="@string/file" > <!-- "file" submenu --> <menu> <item android:id="@+id/create_new" android:title="@string/create_new" /> <item android:id="@+id/open" android:title="@string/open" /> </menu> </item> </menu>
Pour utiliser le menu dans votre activité, _inflate_ la ressource de menu, en convertissant
la ressource XML en un objet programmable à l'aide de
MenuInflater.inflate()
Les sections suivantes expliquent comment gonfler un menu pour chaque type de menu.
Créer un menu d'options
Dans le menu d'options, comme celui illustré à la figure 1, des actions et d'autres options adaptées au contexte de l'activité en cours, telles que « Recherche », « Rédiger un e-mail », et "Paramètres".
![Image montrant la barre d'application de l'application Google Sheets](https://developer.android.google.cn/static/images/training/appbar/appbar_sheets_2x.png?authuser=19&hl=fr)
Vous pouvez déclarer des éléments dans le menu d'options à partir de votre
Activity
ou une sous-classe
Fragment
. Si votre activité et vos fragments déclarent tous deux des éléments pour
d'options, les éléments sont combinés dans l'interface utilisateur. Les éléments de l'activité s'affichent
en premier, suivis de ceux de chaque fragment, dans l'ordre dans lequel les fragments
sont ajoutés à l'activité. Si nécessaire, vous pouvez réorganiser
les éléments du menu avec
l'attribut android:orderInCategory
dans chaque
<item>
à déplacer.
Pour spécifier le menu d'options d'une activité, remplacez
onCreateOptionsMenu()
Les fragments fournissent leurs propres
onCreateOptionsMenu()
. Avec cette méthode, vous pouvez gonfler votre ressource de menu,
définis en XML, dans le Menu
fourni dans le
. Ce processus est illustré dans l'exemple suivant :
Kotlin
override fun onCreateOptionsMenu(menu: Menu): Boolean { val inflater: MenuInflater = menuInflater inflater.inflate(R.menu.game_menu, menu) return true }
Java
@Override public boolean onCreateOptionsMenu(Menu menu) { MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.game_menu, menu); return true; }
Vous pouvez également ajouter des éléments de menu à l'aide de
add()
et récupérer des éléments avec
findItem()
de réviser leurs propriétés avec les API MenuItem
.
Gérer les événements de clic
Lorsque l'utilisateur sélectionne un élément, y compris des tâches dans le menu d'options
dans la barre d'application, le système appelle le numéro de
onOptionsItemSelected()
. Cette méthode transmet l'élément MenuItem
sélectionné. Vous pouvez identifier
l'élément en appelant
getItemId()
,
qui renvoie l'identifiant unique de l'élément de menu, défini par
android:id
dans la ressource de menu ou avec un nombre entier donné
à la méthode add()
. Vous pouvez faire correspondre cet ID au menu connu
pour effectuer l'action appropriée.
Kotlin
override fun onOptionsItemSelected(item: MenuItem): Boolean { // Handle item selection. return when (item.itemId) { R.id.new_game -> { newGame() true } R.id.help -> { showHelp() true } else -> super.onOptionsItemSelected(item) } }
Java
@Override public boolean onOptionsItemSelected(MenuItem item) { // Handle item selection. switch (item.getItemId()) { case R.id.new_game: newGame(); return true; case R.id.help: showHelp(); return true; default: return super.onOptionsItemSelected(item); } }
Lorsque vous gérez un élément de menu, renvoyez true
. Si vous
ne gèrent pas l'élément de menu, appelez l'implémentation de super-classe de
onOptionsItemSelected()
L'implémentation par défaut renvoie
"false".
Si votre activité inclut des fragments, le système appelle d'abord
onOptionsItemSelected()
pour l'activité, puis pour chaque fragment
dans l'ordre dans lequel les fragments sont ajoutés, jusqu'à ce que l'un renvoie true
ou
tous les fragments sont appelés.
Modifier les éléments de menu au moment de l'exécution
Une fois que le système a appelé onCreateOptionsMenu()
, il conserve une
une instance de Menu
que vous remplissez et n'appelez pas ;
onCreateOptionsMenu()
à nouveau, sauf si le menu n'est plus valide.
Toutefois, n'utilisez onCreateOptionsMenu()
que pour créer le menu initial.
et de ne pas apporter de modifications
pendant le cycle de vie de l'activité.
Si vous souhaitez modifier le menu d'options en fonction d'événements ayant lieu pendant le
cycle de vie d'une activité, vous pouvez
onPrepareOptionsMenu()
. Cette méthode vous transmet l'objet Menu
tel qu'il est actuellement
existante afin de pouvoir la modifier, par exemple en ajoutant, en supprimant ou en désactivant des éléments.
Les fragments fournissent également
onPrepareOptionsMenu()
.
Le menu d'options est considéré comme toujours ouvert lorsque les éléments de menu sont présentés dans
la barre d’application. Lorsqu'un événement se produit et que vous souhaitez effectuer une mise à jour du menu, appelez
invalidateOptionsMenu()
pour demander au système d'appeler onPrepareOptionsMenu()
.
Créer un menu contextuel
![Image montrant un menu contextuel flottant](https://developer.android.google.cn/static/develop/ui/views/images/context_menu_no_icons.png?authuser=19&hl=fr)
Un menu contextuel propose des actions qui affectent un élément ou un contexte spécifique
dans l'UI. Vous pouvez fournir un menu contextuel pour chaque vue,
souvent utilisé pour les éléments
RecylerView
ou
d'autres collections de vues dans lesquelles l'utilisateur peut effectuer des actions directes sur chaque
élément.
Il existe deux façons de proposer des actions contextuelles:
- Dans un menu contextuel flottant Un menu apparaît sous la forme d'une liste flottante d'éléments de menu, semblable à une boîte de dialogue, lorsque l'utilisateur appuie sur conserver une vue qui déclare la prise en charge d'un contexte . Les utilisateurs peuvent effectuer une action contextuelle sur un élément à la fois.
- En mode d'action contextuelle Ce mode est un système
la mise en œuvre
ActionMode
affichant une barre d'action contextuelle (CAB) en haut de la sur l'écran affichant les tâches qui concernent le ou les éléments sélectionnés. Lorsque ce mode est actif, les utilisateurs peuvent effectuer une action sur plusieurs éléments à la fois, si votre l'application prend en charge cela.
Remarque:Le menu contextuel n'est pas compatible avec les raccourcis ni les icônes d'éléments.
Créer un menu contextuel flottant
Pour afficher un menu contextuel flottant, procédez comme suit:
- Enregistrez le
View
auquel le menu contextuel est associé par Appel en coursregisterForContextMenu()
et en lui transmettantView
.Si votre activité utilise un
RecyclerView
et que vous souhaitez pour fournir le même menu contextuel, enregistrer tous les éléments pour un contexte en transmettantRecyclerView
àregisterForContextMenu()
- Implémentez le
onCreateContextMenu()
dans votreActivity
ou votreFragment
.Lorsque la vue enregistrée reçoit une pression de mise en attente, le système appelle votre méthode
onCreateContextMenu()
. C'est là que vous définissez des éléments de menu, généralement en gonflant une ressource de menu, comme dans Exemple:Kotlin
override fun onCreateContextMenu(menu: ContextMenu, v: View, menuInfo: ContextMenu.ContextMenuInfo) { super.onCreateContextMenu(menu, v, menuInfo) val inflater: MenuInflater = menuInflater inflater.inflate(R.menu.context_menu, menu) }
Java
@Override public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) { super.onCreateContextMenu(menu, v, menuInfo); MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.context_menu, menu); }
MenuInflater
vous permet de gonfler le menu contextuel à partir d'une ressource de menu. Méthode de rappel incluent l'élémentView
sélectionné par l'utilisateur et unContextMenu.ContextMenuInfo
qui fournit des informations supplémentaires sur l'élément sélectionné. Si votre activité comporte plusieurs vues, chacune proposant un menu contextuel différent, vous pouvez utiliser ces paramètres pour déterminer quel menu contextuel gonfler. Implémentation
onContextItemSelected()
, comme illustré dans l'exemple suivant. Lorsque l'utilisateur sélectionne un élément de menu, appelle cette méthode pour que vous puissiez effectuer l'action appropriée.Kotlin
override fun onContextItemSelected(item: MenuItem): Boolean { val info = item.menuInfo as AdapterView.AdapterContextMenuInfo return when (item.itemId) { R.id.edit -> { editNote(info.id) true } R.id.delete -> { deleteNote(info.id) true } else -> super.onContextItemSelected(item) } }
Java
@Override public boolean onContextItemSelected(MenuItem item) { AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo(); switch (item.getItemId()) { case R.id.edit: editNote(info.id); return true; case R.id.delete: deleteNote(info.id); return true; default: return super.onContextItemSelected(item); } }
getItemId()
interroge l'ID de l'élément de menu sélectionné, que vous attribuez à chaque élément de menu XML à l'aide de l'attributandroid:id
, comme indiqué dans Définir un menu en XMLLorsque vous gérez un élément de menu, renvoyez
true
. Si vous ne gérez pas l'élément de menu, transmettez-le à la super-classe la mise en œuvre. Si votre activité inclut des fragments, elle reçoit ce rappel. En appelant la super-classe lorsqu'elle n'est pas gérée, le système transmet l'événement à la méthode de rappel correspondante dans chaque fragment, une à la fois une heure, dans l'ordre dans lequel chaque fragment est ajouté, jusqu'àtrue
oufalse
est renvoyé. Les implémentations par défaut Retour deActivity
etandroid.app.Fragment
false
. Par conséquent, appelez toujours la super-classe lorsqu'elle n'est pas gérée.
Utiliser le mode d'action contextuelle
Le mode d'action contextuelle est une implémentation système
ActionMode
qui favorise l'interaction de l'utilisateur
des actions contextuelles. Lorsqu'un utilisateur active ce mode en sélectionnant un élément, une
La barre d'action contextuelle s'affiche en haut de l'écran pour présenter vos diapositives
actions que l'utilisateur peut effectuer sur les éléments sélectionnés. Lorsque ce mode est activé,
l'utilisateur peut sélectionner plusieurs éléments (si votre application le permet) et en désélectionner
éléments et continuer à naviguer dans l'activité. Le mode d'action est désactivé
et la barre d'action contextuelle disparaît
lorsque l'utilisateur désélectionne tous les éléments,
appuie sur le bouton "Retour" ou sur l'action OK située à gauche de
sur la barre d'adresse.
Pour les vues qui proposent des actions contextuelles, vous appelez généralement la vue lorsque l'un de ces deux événements, ou les deux, se produit:
- L'utilisateur effectue une pression et maintenir la vue.
- L'utilisateur sélectionne une case à cocher ou un composant d'interface utilisateur similaire dans la vue.
Comment votre application appelle le mode d'action contextuelle et définit le le comportement de chaque action dépend de votre conception. Il existe deux conceptions:
- Pour les actions contextuelles sur des vues arbitraires et individuelles.
- Pour les actions contextuelles par lot sur des groupes d'éléments dans un
RecyclerView
, qui permet à l'utilisateur de sélectionner plusieurs éléments et effectuer une action sur chacun d’eux.
Les sections suivantes décrivent la configuration requise pour chaque scénario.
Activer le mode d'action contextuelle pour des vues spécifiques
Si vous souhaitez appeler le mode d'action contextuelle uniquement lorsque l'utilisateur sélectionne des vues spécifiques, procédez comme suit:
- Implémentez l'interface
ActionMode.Callback
comme indiqué dans les dans l'exemple suivant. Dans ses méthodes de rappel, vous pouvez spécifier les actions la barre d'action contextuelle, répondre aux événements de clic sur des tâches gérer d'autres événements de cycle de vie pour le mode Action.Kotlin
private val actionModeCallback = object : ActionMode.Callback { // Called when the action mode is created. startActionMode() is called. override fun onCreateActionMode(mode: ActionMode, menu: Menu): Boolean { // Inflate a menu resource providing context menu items. val inflater: MenuInflater = mode.menuInflater inflater.inflate(R.menu.context_menu, menu) return true } // Called each time the action mode is shown. Always called after // onCreateActionMode, and might be called multiple times if the mode // is invalidated. override fun onPrepareActionMode(mode: ActionMode, menu: Menu): Boolean { return false // Return false if nothing is done } // Called when the user selects a contextual menu item. override fun onActionItemClicked(mode: ActionMode, item: MenuItem): Boolean { return when (item.itemId) { R.id.menu_share -> { shareCurrentItem() mode.finish() // Action picked, so close the CAB. true } else -> false } } // Called when the user exits the action mode. override fun onDestroyActionMode(mode: ActionMode) { actionMode = null } }
Java
private ActionMode.Callback actionModeCallback = new ActionMode.Callback() { // Called when the action mode is created. startActionMode() is called. @Override public boolean onCreateActionMode(ActionMode mode, Menu menu) { // Inflate a menu resource providing context menu items. MenuInflater inflater = mode.getMenuInflater(); inflater.inflate(R.menu.context_menu, menu); return true; } // Called each time the action mode is shown. Always called after // onCreateActionMode, and might be called multiple times if the mode // is invalidated. @Override public boolean onPrepareActionMode(ActionMode mode, Menu menu) { return false; // Return false if nothing is done. } // Called when the user selects a contextual menu item. @Override public boolean onActionItemClicked(ActionMode mode, MenuItem item) { switch (item.getItemId()) { case R.id.menu_share: shareCurrentItem(); mode.finish(); // Action picked, so close the CAB. return true; default: return false; } } // Called when the user exits the action mode. @Override public void onDestroyActionMode(ActionMode mode) { actionMode = null; } };
Ces rappels d'événements sont presque identiques à ceux utilisés pour menu d'options, sauf que chacune de ces transmet également l'objet
ActionMode
associé à l'événement. Vous pouvez utiliser les APIActionMode
pour apporter diverses modifications aux CAB, comme la révision du titre et du sous-titre avecsetTitle()
etsetSubtitle()
, ce qui est utile pour indiquer le nombre d'éléments sélectionnés.L'exemple précédent définit la variable
actionMode
surnull
lorsque le mode d'action est détruit. À l'étape suivante, consultez comment elle est initialisée et comment enregistrer la variable membre dans votre activité ou peut être utile. - Appeler
startActionMode()
lorsque vous souhaitez afficher la barre, par exemple lorsque l'utilisateur appuie sur une touche & maintenir la vue.Kotlin
someView.setOnLongClickListener { view -> // Called when the user performs a touch & hold on someView. when (actionMode) { null -> { // Start the CAB using the ActionMode.Callback defined earlier. actionMode = activity?.startActionMode(actionModeCallback) view.isSelected = true true } else -> false } }
Java
someView.setOnLongClickListener(new View.OnLongClickListener() { // Called when the user performs a touch & hold on someView. public boolean onLongClick(View view) { if (actionMode != null) { return false; } // Start the CAB using the ActionMode.Callback defined earlier. actionMode = getActivity().startActionMode(actionModeCallback); view.setSelected(true); return true; } });
Lorsque vous appelez
startActionMode()
, le système renvoie laActionMode
créé. En enregistrant ceci dans une variable de membre, peut modifier la barre d'action contextuelle en réponse à d'autres événements. Dans l'exemple précédent,ActionMode
permet de s'assurer que l'instanceActionMode
n'est pas recréée si elle a déjà été actif, en vérifiant si le membre est nul avant de lancer l'action .
Créer un menu pop-up
![Image montrant un menu pop-up dans l'application Gmail, ancré au bouton à développer en haut à droite.](https://developer.android.google.cn/static/images/ui/popupmenu.png?authuser=19&hl=fr)
PopupMenu
est un menu modal ancré à un View
. Il s'affiche sous l'ancre.
vue s'il y a de la place, ou au-dessus de la vue dans le cas contraire. Il est utile pour
suivantes:
- Menu à développer pour les actions liées à contenu spécifique, comme les en-têtes d'e-mail Gmail, comme illustré dans la figure 4.
- Fournit une deuxième partie d'une phrase de commande, comme un bouton marqué Add (Ajouter), qui affiche un menu pop-up avec différentes options Add (Ajouter). options.
- Fournir un menu semblable à un
Spinner
qui ne conserve pas de sélection persistante.
Si vous définissez votre menu en XML, voici comment afficher le menu pop-up:
- Instanciez un
PopupMenu
avec son constructeur, qui prend l'application actuelleContext
et lesView
auquel le menu est ancré. - Utilisez
MenuInflater
pour gonfler votre ressource de menu dans le ObjetMenu
renvoyé parPopupMenu.getMenu()
- Appelez
PopupMenu.show()
.
Par exemple, voici un bouton qui affiche un menu contextuel:
<ImageButton android:id="@+id/dropdown_menu" android:layout_width="wrap_content" android:layout_height="wrap_content" android:contentDescription="@string/descr_overflow_button" android:src="@drawable/arrow_drop_down" />
L'activité peut alors afficher le menu pop-up comme suit:
Kotlin
findViewById<ImageButton>(R.id.dropdown_menu).setOnClickListener { val popup = PopupMenu(this, it) val inflater: MenuInflater = popup.menuInflater inflater.inflate(R.menu.actions, popup.menu) popup.show() }
Java
findViewById(R.id.dropdown_menu).setOnClickListener(v -> { PopupMenu popup = new PopupMenu(this, v); popup.getMenuInflater().inflate(R.menu.actions, popup.getMenu()); popup.show(); });
Le menu se ferme lorsque l'utilisateur sélectionne un élément ou appuie en dehors du menu
dans une zone géographique spécifique. Vous pouvez écouter l'événement de fermeture à l'aide de
PopupMenu.OnDismissListener
Gérer les événements de clic
Pour effectuer une action lorsque l'utilisateur sélectionne un élément de menu, implémentez la méthode
PopupMenu.OnMenuItemClickListener
interface et enregistrez-la avec votre PopupMenu
en appelant
setOnMenuItemclickListener()
Lorsque l'utilisateur sélectionne un élément, le système appelle la méthode
onMenuItemClick()
dans votre interface.
Ce processus est illustré dans l'exemple suivant :
Kotlin
fun showMenu(v: View) { PopupMenu(this, v).apply { // MainActivity implements OnMenuItemClickListener. setOnMenuItemClickListener(this@MainActivity) inflate(R.menu.actions) show() } } override fun onMenuItemClick(item: MenuItem): Boolean { return when (item.itemId) { R.id.archive -> { archive(item) true } R.id.delete -> { delete(item) true } else -> false } }
Java
public void showMenu(View v) { PopupMenu popup = new PopupMenu(this, v); // This activity implements OnMenuItemClickListener. popup.setOnMenuItemClickListener(this); popup.inflate(R.menu.actions); popup.show(); } @Override public boolean onMenuItemClick(MenuItem item) { switch (item.getItemId()) { case R.id.archive: archive(item); return true; case R.id.delete: delete(item); return true; default: return false; } }
Créer un groupe de menus
Un groupe de menu est une collection d'éléments de menu qui partagent certaines caractéristiques. Avec un vous pouvez effectuer les opérations suivantes:
- Afficher ou masquer tous les éléments à l'aide de
setGroupVisible()
- Activer ou désactiver tous les éléments à l'aide de
setGroupEnabled()
- Indiquez si tous les éléments peuvent être cochés à l'aide de
setGroupCheckable()
Vous pouvez créer un groupe en imbriquant des éléments <item>
à l'intérieur
un élément <group>
dans votre ressource de menu ou en spécifiant un
ID de groupe avec le
add()
.
Voici un exemple de ressource de menu qui inclut un groupe:
<?xml version="1.0" encoding="utf-8"?> <menu xmlns:android="http://schemas.android.com/apk/res/android"> <item android:id="@+id/menu_save" android:icon="@drawable/menu_save" android:title="@string/menu_save" /> <!-- menu group --> <group android:id="@+id/group_delete"> <item android:id="@+id/menu_archive" android:title="@string/menu_archive" /> <item android:id="@+id/menu_delete" android:title="@string/menu_delete" /> </group> </menu>
Les éléments du groupe apparaissent au même niveau que le premier
l’élément - les trois éléments du menu sont des frères et sœurs. Toutefois, vous pouvez modifier
les caractéristiques des deux éléments du groupe en référençant l'ID de groupe et en utilisant
des méthodes précédentes. En outre, le système ne sépare jamais les éléments groupés. Pour
Par exemple, si vous déclarez android:showAsAction="ifRoom"
pour chaque
s'affichent tous les deux dans la barre d'action ou dans l'action
overflow.
Utiliser des éléments de menu cochés
Un menu peut servir d'interface pour activer et désactiver des options, à l'aide d'un des options autonomes, ou des cases d'option pour les groupes des options exclusives. La figure 5 montre un sous-menu contenant des éléments qu’il est possible de cocher avec des cases d'option.
<ph type="x-smartling-placeholder">Vous pouvez définir le comportement coché pour des éléments de menu individuels à l'aide de la propriété
Attribut android:checkable
dans <item>
ou pour un groupe entier avec la propriété android:checkableBehavior
dans l'élément <group>
. Par exemple, tous les éléments dans
ce groupe de menu peuvent être cochés à l'aide d'une case d'option:
<?xml version="1.0" encoding="utf-8"?> <menu xmlns:android="http://schemas.android.com/apk/res/android"> <group android:checkableBehavior="single"> <item android:id="@+id/red" android:title="@string/red" /> <item android:id="@+id/blue" android:title="@string/blue" /> </group> </menu>
L'attribut android:checkableBehavior
accepte l'un des
suivantes:
single
- Seul un élément du groupe peut être coché, ce qui donne lieu à une case d'option .
all
- Tous les éléments peuvent être cochés, ce qui signifie que des cases sont cochées.
none
- Aucun élément ne peut être coché.
Vous pouvez appliquer l'état coché par défaut à un élément à l'aide de la méthode
Attribut android:checked
dans l'élément <item>
et le modifier dans le code à l'aide de la commande
setChecked()
.
Lorsqu'un élément coché est sélectionné, le système appelle votre
méthode de rappel sélectionnée par l'élément, telle que onOptionsItemSelected()
.
C'est ici que vous définissez l'état de la case à cocher, car une case à cocher ou une case d'option
le bouton ne change pas automatiquement d'état. Vous pouvez interroger l'état actuel
de l'élément, tel qu'il était avant que l'utilisateur ne le sélectionne,
isChecked()
puis définissez l'état coché avec setChecked()
. Ceci est illustré dans
l'exemple suivant:
Kotlin
override fun onOptionsItemSelected(item: MenuItem): Boolean { return when (item.itemId) { R.id.vibrate, R.id.dont_vibrate -> { item.isChecked = !item.isChecked true } else -> super.onOptionsItemSelected(item) } }
Java
@Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case R.id.vibrate: case R.id.dont_vibrate: if (item.isChecked()) item.setChecked(false); else item.setChecked(true); return true; default: return super.onOptionsItemSelected(item); } }
Si vous ne définissez pas l'état coché de cette façon, l'état visible la case à cocher ou la case d'option ne change pas lorsque l'utilisateur la sélectionne. Dans ce cas, définir l'état, l'activité conserve l'état coché de l'élément afin que lorsque l'utilisateur ouvre le menu ultérieurement, l'état coché que vous définissez est visible.
<ph type="x-smartling-placeholder">Ajouter des éléments de menu en fonction d'un intent
Parfois, vous souhaitez qu'un élément de menu lance une activité à l'aide d'un
Intent
,
qu'il s'agisse d'une activité
dans votre application ou dans une autre. Lorsque vous
connaître l'intent que vous souhaitez utiliser et avoir un élément de menu spécifique qui lance
vous pouvez l'exécuter
startActivity()
lors de la méthode de rappel appropriée, sélectionnée sur l'élément, par exemple
onOptionsItemSelected()
.
Toutefois, si vous n'êtes pas certain que l'appareil de l'utilisateur contient une application qui gère l'intent, l'ajout d'un élément de menu qui l'appelle peut entraîner une élément de menu non fonctionnel, car l'intent peut ne pas renvoyer vers une activité. Pour résoudre ce problème, Android vous permet d'ajouter dynamiquement des éléments de menu à votre menu lorsque Android trouve sur l'appareil les activités qui gèrent votre intent.
Pour ajouter des éléments de menu en fonction des activités disponibles qui acceptent un intent, procédez comme suit : les éléments suivants:
- Définir un intent avec la catégorie
CATEGORY_ALTERNATIVE
ouCATEGORY_SELECTED_ALTERNATIVE
, ou les deux, ainsi que toute autre condition requise. - Appeler
Menu.addIntentOptions()
Android recherche ensuite toutes les applications pouvant exécuter l'intent et les ajoute à votre menu.
Si aucune application installée ne répond à l'intent, aucun menu éléments sont ajoutés.
<ph type="x-smartling-placeholder">Ce processus est illustré dans l'exemple suivant :
Kotlin
override fun onCreateOptionsMenu(menu: Menu): Boolean { super.onCreateOptionsMenu(menu) // Create an Intent that describes the requirements to fulfill, to be // included in the menu. The offering app must include a category value // of Intent.CATEGORY_ALTERNATIVE. val intent = Intent(null, dataUri).apply { addCategory(Intent.CATEGORY_ALTERNATIVE) } // Search and populate the menu with acceptable offering apps. menu.addIntentOptions( R.id.intent_group, // Menu group to which new items are added. 0, // Unique item ID (none). 0, // Order for the items (none). this.componentName, // The current activity name. null, // Specific items to place first (none). intent, // Intent created above that describes the requirements. 0, // Additional flags to control items (none). null) // Array of MenuItems that correlate to specific items (none). return true }
Java
@Override public boolean onCreateOptionsMenu(Menu menu){ super.onCreateOptionsMenu(menu); // Create an Intent that describes the requirements to fulfill, to be // included in the menu. The offering app must include a category value // of Intent.CATEGORY_ALTERNATIVE. Intent intent = new Intent(null, dataUri); intent.addCategory(Intent.CATEGORY_ALTERNATIVE); // Search and populate the menu with acceptable offering apps. menu.addIntentOptions( R.id.intent_group, // Menu group to which new items are added. 0, // Unique item ID (none). 0, // Order for the items (none). this.getComponentName(), // The current activity name. null, // Specific items to place first (none). intent, // Intent created above that describes the requirements. 0, // Additional flags to control items (none). null); // Array of MenuItems that correlate to specific items (none). return true; }
Pour chaque activité qui fournit un filtre d'intent correspondant à l'intent
définie, un élément de menu est ajouté à l'aide de la valeur de l'objet
android:label
comme titre de l'élément de menu et icône de l'application comme menu.
. La méthode addIntentOptions()
renvoie le nombre de
éléments de menu ajoutés.
Autoriser l'ajout de votre activité à d'autres menus
Vous pouvez proposer les services liés à votre activité à d'autres applis afin que votre appli puisse être inclus dans le menu d'autres rôles, en inversant les rôles décrits précédemment.
Pour être inclus dans d'autres menus d'application, définissez un filtre d'intent comme d'habitude,
mais incluez CATEGORY_ALTERNATIVE
ou
Les valeurs CATEGORY_SELECTED_ALTERNATIVE
, ou les deux, pour l'intent
catégorie de filtre. Ce processus est illustré dans l'exemple suivant :
<intent-filter label="@string/resize_image"> ... <category android:name="android.intent.category.ALTERNATIVE" /> <category android:name="android.intent.category.SELECTED_ALTERNATIVE" /> ... </intent-filter>
Pour en savoir plus sur l'écriture de filtres d'intent, consultez Intents et intents filtres.