Ajouter des menus

Essayer Compose
Jetpack Compose est le kit d'outils d'interface utilisateur recommandé pour Android. Découvrez comment ajouter des composants dans Compose.
<ph type="x-smartling-placeholder"></ph> TopAppBar →

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.

<ph type="x-smartling-placeholder"> <ph type="x-smartling-placeholder">
</ph> Image montrant un exemple de menu à développer <ph type="x-smartling-placeholder">
</ph> Figure 1 : Un menu déclenché par un appui sur une icône, sous l'icône du menu à développer.

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&#39;application de l&#39;application Google Sheets
Figure 2 : L'application Google Sheets affichant plusieurs boutons, dont le bouton d'action à développer.

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.

<ph type="x-smartling-placeholder">

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().

<ph type="x-smartling-placeholder">

Créer un menu contextuel

Image montrant un menu contextuel flottant
Figure 3 : Un menu contextuel flottant

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:

  1. Enregistrez le View auquel le menu contextuel est associé par Appel en cours registerForContextMenu() et en lui transmettant View.

    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 transmettant RecyclerView à registerForContextMenu()

  2. Implémentez le onCreateContextMenu() dans votre Activity ou votre Fragment.

    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ément View sélectionné par l'utilisateur et un ContextMenu.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.

  3. 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'attribut android:id, comme indiqué dans Définir un menu en XML

    Lorsque 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 ou false est renvoyé. Les implémentations par défaut Retour de Activity et android.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.

<ph type="x-smartling-placeholder">

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:

  1. 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 API ActionMode pour apporter diverses modifications aux CAB, comme la révision du titre et du sous-titre avec setTitle() et setSubtitle(), ce qui est utile pour indiquer le nombre d'éléments sélectionnés.

    L'exemple précédent définit la variable actionMode sur null 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.

  2. 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 la ActionMode 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'instance ActionMode 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&#39;application Gmail, ancré au bouton à développer en haut à droite.
Figure 4 : Dans un menu pop-up dans l'application Gmail, ancrée au bouton de débordement dans le coin supérieur droit.

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:

  1. Instanciez un PopupMenu avec son constructeur, qui prend l'application actuelle Context et les View auquel le menu est ancré.
  2. Utilisez MenuInflater pour gonfler votre ressource de menu dans le Objet Menu renvoyé par PopupMenu.getMenu()
  3. 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:

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

<ph type="x-smartling-placeholder">
Figure 5. Un sous-menu avec éléments 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:

  1. Définir un intent avec la catégorie CATEGORY_ALTERNATIVE ou CATEGORY_SELECTED_ALTERNATIVE, ou les deux, ainsi que toute autre condition requise.
  2. 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.

<ph type="x-smartling-placeholder">

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.