Aggiungi menu

Prova il metodo Scrivi
Jetpack Compose è il toolkit consigliato per la UI per Android. Scopri come aggiungere componenti in Compose.
BarraApp superiore → .

I menu sono un componente dell'interfaccia utente comune in molti tipi di app. A per offrire un'esperienza utente familiare e coerente, utilizza Menu API per presentano azioni dell'utente e altre opzioni nelle tue attività.

di Gemini Advanced.
Un'immagine che mostra un esempio di menu extra
Figura 1. Un menu attivato dal tocco di un'icona sotto l'icona del menu extra.

Questo documento mostra come creare i tre tipi fondamentali di menu o presentazioni di azioni su tutte le versioni di Android:

Menu Opzioni e barra delle app
Il menu Opzioni è la raccolta principale di portate principali per una attività. È la piattaforma in cui vengono inserite le azioni che hanno un impatto globale sui come "Ricerca", "Scrivi email" e "Impostazioni".

Vedi il menu Crea un opzioni .

Menu contestuale e modalità di azione contestuale
Un menu contestuale è un menu mobile che appare quando l'utente esegue un tocco e tieni premuto un elemento. it fornisce azioni che influiscono sui contenuti o sul frame di contesto selezionati.

La modalità di azione contestuale mostra le attività che influisce sui contenuti selezionati in una barra nella parte superiore dello schermo e consente selezionare più elementi dall'utente.

Consulta la sezione Creare un menu contestuale .

Menu popup
Un menu popup mostra un elenco verticale di elementi ancorati allo che richiama il menu. È utile per offrire tantissime azioni che riguardano contenuti specifici o che offrono opzioni per la seconda parte di un comando. Le azioni in un menu popup non influiscono direttamente sul contenuti corrispondenti: è a questo che servono le azioni contestuali. Piuttosto, il menu popup è dedicato alle azioni estese relative alle regioni di contenuti in la tua attività.

Consulta la sezione Creare un menu popup.

Definisci un menu in XML

Per tutti i tipi di menu, Android fornisce un formato XML standard per definire il menù elementi. Anziché creare un menu nel codice dell'attività, definisci un menu e tutti gli elementi in un file XML risorsa del menu. Puoi quindi gonfia la risorsa del menu, caricandola come Menu nell'attività o nel frammento.

L'utilizzo di una risorsa di menu è una buona prassi per i seguenti motivi:

  • È più facile visualizzare la struttura dei menu in XML.
  • I contenuti del menu vengono separati dai comportamenti dell'app le API nel tuo codice.
  • Consente di creare configurazioni di menu alternative per piattaforme diverse versioni, dimensioni dello schermo e altre configurazioni, risorse per app il modello di machine learning.

Per definire un menu, crea un file XML all'interno della cartella res/menu/ e crea il menu con quanto segue elementi:

<menu>
Definisci un Menu, che è un contenitore per le voci di menu. R L'elemento <menu> deve essere il nodo radice del file e può contenere uno o più <item> e <group> elementi.
<item>
Crea un MenuItem, che rappresenta una singola voce di un menu. Questo elemento può contenere un elemento nidificato <menu> elemento per creare un sottomenu.
<group>
Un contenitore invisibile facoltativo per <item> elementi. Ti permette di classificare le voci di menu in modo che condividano le proprietà, come come stato attivo e visibilità. Per ulteriori informazioni, consulta Sezione Crea un gruppo di menu.

Ecco un menu di esempio denominato 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'elemento <item> supporta diversi attributi che puoi utilizzare per definire l'aspetto e il comportamento di un articolo. Le voci del menu precedente includono i seguenti attributi:

android:id
Un ID risorsa univoco dell'elemento, che consente all'app riconoscere l'elemento quando l'utente lo seleziona.
android:icon
Un riferimento a un elemento disegnabile da utilizzare come icona dell'elemento.
android:title
Un riferimento a una stringa da utilizzare come titolo dell'elemento.
android:showAsAction
La specifica relativa a quando e come questo elemento viene visualizzato come attività nella barra delle app.

Questi sono gli attributi più importanti che utilizzi, ma ce ne sono molti altri disponibili. Per informazioni su tutti gli attributi supportati, consulta Risorsa del menu documentazione.

Puoi aggiungere un sottomenu a una voce in qualsiasi menu aggiungendo un'opzione <menu> come elemento secondario di un <item>. I sottomenu sono utili quando l'app ha molte funzioni che possono essere organizzate in argomenti, come gli elementi nella barra dei menu di un'app per PC, come File, Modifica e Visualizza. Vedi l'esempio che segue:

<?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>

Per usare il menu nella tua attività, _inflate_ la risorsa del menu, convertendo la risorsa XML in un oggetto programmabile MenuInflater.inflate(). Le seguenti sezioni mostrano come aumentare in modo artificioso un menu per ogni tipo di menu.

Crea un menu opzioni

Nel menu delle opzioni, come quello mostrato nella figura 1, puoi includere azioni e altre opzioni pertinenti al contesto dell'attività corrente, ad esempio "Ricerca", "Scrivi email" e "Impostazioni".

Un&#39;immagine che mostra la barra delle app per l&#39;app Fogli Google
. Figura 2. L'app Fogli Google, che mostra diversi pulsanti, incluso il pulsante di overflow di azioni.

Puoi dichiarare gli elementi del menu opzioni dal tuo Activity o una sottoclasse Fragment sottoclasse del modello. Se sia l'attività che i frammenti dichiarano elementi per gli elementi vengono combinati nell'interfaccia utente. Gli elementi dell'attività vengono visualizzati seguite da quelle di ogni frammento, nell'ordine in cui i frammenti vengono aggiunti all'attività. Se necessario, puoi riordinare le voci del menu con l'attributo android:orderInCategory in ogni <item> da spostare.

Per specificare il menu opzioni per un'attività, sostituisci onCreateOptionsMenu(). I frammenti forniscono il proprio onCreateOptionsMenu() di Google. Con questo metodo puoi gonfiare la risorsa del menu, definita in XML, nel Menu fornito in di Google. Ciò è mostrato nell'esempio seguente:

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;
}

Puoi aggiungere voci di menu anche utilizzando add() e recuperare elementi findItem() di rivedere le proprietà con le API di MenuItem.

Gestire gli eventi di clic

Quando l'utente seleziona un elemento dal menu opzioni, incluse le attività nella barra delle app, il sistema chiama la tua attività onOptionsItemSelected() . Questo metodo trasmette il valore MenuItem selezionato. Puoi identificare dell'elemento richiamando getItemId(), che restituisce l'ID univoco della voce di menu, definito dal Attributo android:id nella risorsa di menu o con un numero intero specificato al metodo add(). Puoi associare questo ID al menu noto per eseguire l'azione appropriata.

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);
    }
}

Quando gestisci correttamente una voce di menu, restituisci true. Se non gestire la voce di menu, chiama l'implementazione superclass onOptionsItemSelected(). L'implementazione predefinita restituisce false.

Se l'attività include frammenti, il sistema prima chiama onOptionsItemSelected() per l'attività, poi per ogni frammento nell'ordine in cui vengono aggiunti i frammenti, finché uno non restituisce true o vengono chiamati tutti i frammenti.

Modificare le voci di menu in fase di esecuzione

Dopo che il sistema chiama onCreateOptionsMenu(), conserva un dell'istanza di Menu che compili e non chiama onCreateOptionsMenu() di nuovo a meno che il menu non venga invalidato. Tuttavia, usa onCreateOptionsMenu() solo per creare il menu iniziale e non apportare modifiche durante il ciclo di vita dell'attività.

Se vuoi modificare il menu opzioni in base agli eventi che si verificano durante ciclo di vita dell'attività, puoi farlo onPrepareOptionsMenu() . Questo metodo ti trasmette l'oggetto Menu così come è attualmente esiste in modo che tu possa modificarlo, ad esempio aggiungendo, rimuovendo o disattivando elementi. I frammenti forniscono anche onPrepareOptionsMenu() di Google.

Il menu opzioni è considerato sempre aperto quando le voci di menu sono presentate in la barra delle app. Quando si verifica un evento e vuoi eseguire un aggiornamento del menu, chiama invalidateOptionsMenu() per richiedere che il sistema chiami onPrepareOptionsMenu().

Creare un menu contestuale

Un&#39;immagine che mostra un menu contestuale mobile
. Figura 3. Un menu contestuale mobile.

Un menu contestuale offre azioni che hanno effetto su un elemento o un contesto specifico nell'interfaccia utente. Puoi fornire un menu contestuale per qualsiasi visualizzazione, ma in genere sono spesso utilizzato per gli elementi in RecylerView o altre raccolte in cui l'utente può eseguire azioni dirette molto utile.

Esistono due modi per fornire azioni contestuali:

  • In un menu contestuale mobile. Un menu appare come un elenco mobile di voci di menu, simile a una finestra di dialogo, quando l'utente esegue un tocco e una vista che dichiara il supporto di un contesto o dal menu Fogli Google. Gli utenti possono eseguire un'azione contestuale su un elemento alla volta.
  • In modalità di azione contestuale. Questa modalità è un sistema dell'implementazione ActionMode che visualizza una barra delle azioni contestuali, o CAB, nella parte superiore della schermata con le attività che hanno effetto sugli elementi selezionati. Quando questa modalità sia attiva, gli utenti possono eseguire un'azione su più elementi contemporaneamente, se l'app supporta questa funzionalità.

Nota:il menu contestuale non supporta le scorciatoie degli elementi e le icone degli elementi.

Creare un menu contestuale mobile

Per fornire un menu contestuale mobile, procedi nel seguente modo:

  1. Registra il View a cui è associato il menu contestuale chiamata registerForContextMenu() passando View.

    Se per la tua attività viene usato un RecyclerView e vuoi che per fornire lo stesso menu contestuale, registra tutti gli elementi per un contesto passando RecyclerView a registerForContextMenu().

  2. Implementa il onCreateContextMenu() in Activity o Fragment.

    Quando la visualizzazione registrata riceve un tocco e di attesa, il sistema chiama il tuo metodo onCreateContextMenu(). È qui che definisci le voci di menu, di solito gonfiando una risorsa di menu, come nell'esempio seguente esempio:

    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 consente di gonfiare il menu contestuale da una risorsa di menu. Il metodo di callback includono il valore View selezionato dall'utente e un valore ContextMenu.ContextMenuInfo che fornisce informazioni aggiuntive sull'elemento selezionato. Se la tua attività ha diverse visualizzazioni, ciascuna delle quali fornisce un diverso menu contestuale, puoi utilizzare questi parametri per stabilire quale menu contestuale gonfiare.

  3. Implementa onContextItemSelected(), come mostrato nell'esempio seguente. Quando l'utente seleziona una voce di menu, il sistema chiama questo metodo affinché tu possa eseguire l'azione appropriata.

    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() esegue query sull'ID della voce di menu selezionata, che assegni a ogni una voce di menu in XML utilizzando l'attributo android:id, come mostrato in Definisci un menu in XML.

    Quando gestisci correttamente una voce di menu, restituisci true. Se non gestisci la voce di menu, passala alla superclasse implementazione. Se l'attività include frammenti, l'attività riceve prima questo callback. Chiamando la superclasse se non gestita, il sistema passa l'evento al rispettivo metodo di callback in ogni frammento, uno in volta, nell'ordine di aggiunta di ogni frammento, fino a true o Viene restituito false. Le implementazioni predefinite per Reso di Activity e android.app.Fragment false, quindi chiama sempre la superclasse se non viene gestita.

Utilizzare la modalità di azione contestuale

La modalità di azione contestuale è un'implementazione ActionMode che concentra l'interazione dell'utente sul rendimento azioni contestuali. Quando un utente attiva questa modalità selezionando un elemento, viene visualizzata una La barra delle azioni contestuali viene visualizzata nella parte superiore dello schermo per presentare azioni che l'utente può eseguire sugli elementi selezionati. Quando questa modalità è attiva, l'utente può selezionare più elementi, se la tua app supporta questa funzionalità, e può deselezionare articoli e continua a navigare all'interno dell'attività. La modalità di azione è disattivata e la barra delle azioni contestuali scompare quando l'utente deseleziona tutti gli elementi. tocca il pulsante Indietro o l'azione Fatto sul lato sinistro .

Per le visualizzazioni che forniscono azioni contestuali, di solito richiami modalità di azione quando si verifica uno o entrambi questi due eventi:

  • L'utente esegue un tocco e tieni premuto sulla vista.
  • L'utente seleziona una casella di controllo o un componente dell'interfaccia utente simile all'interno della vista.

Il modo in cui l'app richiama la modalità di azione contestuale e definisce il comportamento di ogni azione dipende dalla progettazione. Esistono due design:

  • Per azioni contestuali su singole visualizzazioni arbitrarie.
  • Per azioni contestuali collettive su gruppi di elementi in un RecyclerView, che consente all'utente di selezionare più elementi e eseguire un'azione su tutti questi elementi.

Le seguenti sezioni descrivono la configurazione richiesta per ogni scenario.

Attivare la modalità di azione contestuale per le singole visualizzazioni

Se vuoi richiamare la modalità di azione contestuale solo quando l'utente seleziona viste specifiche, procedi nel seguente modo:

  1. Implementa l'interfaccia ActionMode.Callback come mostrato in dall'esempio seguente. Nei suoi metodi di callback, puoi specificare le azioni per la barra delle azioni contestuali, rispondere agli eventi di clic sulle attività e e gestire altri eventi del ciclo di vita per la modalità di azione.

    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;
        }
    };

    Questi callback di eventi sono quasi esattamente uguali ai callback per il menu opzioni, tranne che per ciascuna trasmette anche l'oggetto ActionMode associato all'evento. Puoi utilizzare le API di ActionMode per apportare varie modifiche alle CAB, ad esempio la revisione del titolo e dei sottotitoli con setTitle() e setSubtitle(), il che è utile per indicare quanti elementi sono stati selezionati.

    L'esempio precedente imposta la variabile actionMode su null quando la modalità di azione viene eliminata. Nel passaggio successivo, come viene inizializzata e come viene salvata la variabile membro nell'attività o può essere utile.

  2. Chiama startActionMode() quando vuoi mostrare la barra, ad esempio quando l'utente esegue un tocco e tieni premuto sulla vista.

    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;
        }
    });

    Quando chiami startActionMode(), il sistema restituisce il ActionMode creato. Se salvi questa opzione in una variabile membro, può apportare modifiche alla barra delle azioni contestuali in risposta ad altri eventi. Nell'esempio precedente, ActionMode viene utilizzato per garantire che l'istanza ActionMode non viene ricreata se è già sia attiva, controllando se il membro è nullo prima di iniziare l'azione. .

Crea un menu popup

Un&#39;immagine che mostra un menu popup nell&#39;app Gmail, ancorato al pulsante del menu extra in alto a destra.
. Figura 4. Un menu popup nell'app Gmail ancorato al pulsante del menu extra nell'angolo in alto a destra.

PopupMenu è un menu modale ancorato a View. Appare sotto l'ancoraggio se c'è spazio, oppure sopra la vista. È utile per seguenti:

  • Offrire un menu in stile extra per le azioni relative a contenuti specifici, come le intestazioni delle email di Gmail, mostrati nella Figura 4.
  • Fornire una seconda parte di una frase di comando, ad esempio un pulsante contrassegnato Aggiungi, che produce un menu popup con diverse opzioni Aggiungi le opzioni di CPU e memoria disponibili.
  • Fornire un menu simile a Spinner che non conserva una selezione permanente.

Se definisci il tuo menu in XML, ecco come puoi mostrare il menu popup:

  1. Crea un'istanza di PopupMenu con il relativo costruttore, che prende l'app corrente Context e View a cui è ancorato il menu.
  2. Usa MenuInflater per aumentare in modo artificioso la risorsa di menu nel Oggetto Menu restituito da PopupMenu.getMenu().
  3. Chiama il numero PopupMenu.show().

Ad esempio, ecco un pulsante che mostra un menu popup:

<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'attività può quindi mostrare un menu popup in questo modo:

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();
});

Il menu viene ignorato quando l'utente seleziona un elemento o tocca un punto fuori dal menu geografica specifica. Puoi rimanere in ascolto dell'evento ignora utilizzando PopupMenu.OnDismissListener.

Gestire gli eventi di clic

Per eseguire un'azione quando l'utente seleziona una voce di menu, implementa l'oggetto PopupMenu.OnMenuItemClickListener e registrala con il tuo PopupMenu chiamando setOnMenuItemclickListener(). Quando l'utente seleziona un elemento, il sistema chiama la onMenuItemClick() nell'interfaccia.

Ciò è mostrato nell'esempio seguente:

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;
    }
}

Creare un gruppo di menu

Un gruppo di menu è una raccolta di portate del menù che condividono determinate caratteristiche. Con un di Google, puoi effettuare le seguenti operazioni:

Puoi creare un gruppo nidificando <item> elementi all'interno un elemento <group> nella risorsa di menu o specificando ID gruppo con add() .

Ecco un esempio di risorsa di menu che include un gruppo:

<?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>

Gli elementi presenti nel gruppo vengono visualizzati allo stesso livello del primo voce: tutti e tre gli elementi nel menu sono elementi di pari livello. Tuttavia, puoi modificare le caratteristiche dei due elementi del gruppo, facendo riferimento all'ID gruppo e utilizzando metodi precedenti. Inoltre, il sistema non separa mai gli elementi raggruppati. Per Ad esempio, se dichiari android:showAsAction="ifRoom" per ogni dell'elemento, vengono visualizzati entrambi nella barra delle azioni oppure entrambi vengono visualizzati nell'azione dell'overflow.

Utilizza voci di menu selezionabili

Figura 5. Un sottomenu con elementi controllabili.

Un menu può essere utile come interfaccia per attivare e disattivare le opzioni, utilizzando una casella di controllo per le opzioni autonome o pulsanti di opzione per gruppi di ed esclusive. La figura 5 mostra un sottomenu con voci selezionabili con pulsanti di opzione.

Puoi definire il comportamento verificabile per singole voci di menu utilizzando il Attributo android:checkable in <item> o per un intero gruppo con l'elemento android:checkableBehavior nell'elemento <group>. Ad esempio, tutti gli elementi in questo gruppo di menu è controllabile con un pulsante di opzione:

<?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'attributo android:checkableBehavior accetta uno dei seguenti:

single
È possibile selezionare solo un elemento del gruppo, con conseguente selezione di pulsanti pulsanti.
all
È possibile selezionare tutti gli elementi, quindi anche le caselle di controllo.
none
Nessun elemento selezionabile.

Puoi applicare uno stato selezionato predefinito a un elemento utilizzando il metodo Attributo android:checked nell'elemento <item> e modificarlo nel codice con setChecked() .

Quando è selezionato un elemento selezionabile, il sistema chiama il rispettivo metodo di callback selezionato dall'elemento, ad esempio onOptionsItemSelected(). È qui che imposti lo stato della casella di controllo, perché una casella di controllo o un pulsante di opzione non cambia automaticamente lo stato. Puoi eseguire query sullo stato attuale dell'articolo, com'era prima che l'utente lo selezionasse, con isChecked() quindi imposta lo stato selezionato con setChecked(). Ciò viene mostrato in nell'esempio seguente:

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);
    }
}

Se non imposti lo stato selezionato in questo modo, lo stato visibile la casella di controllo o il pulsante di opzione non cambia quando l'utente lo seleziona. Se lo fai lo stato, l'attività conserva lo stato selezionato dell'elemento in modo quando l'utente aprirà il menu in un secondo momento, lo stato selezionato che hai impostato è visibile.

Aggiungere voci di menu in base a un'intenzione

A volte desideri che una voce di menu avvii un'attività utilizzando un Intent, che si tratti di un'attività nella tua app o in un'altra app. Quando l'intento che vuoi usare e avere una voce di menu specifica che avvia l'intent, lo puoi eseguire startActivity() durante il metodo di callback appropriato all'elemento selezionato, come il Chiamata onOptionsItemSelected().

Tuttavia, se non hai la certezza che il dispositivo dell'utente contenga un'app che gestisce l'intent, quindi l'aggiunta di una voce di menu che lo richiami può comportare voce di menu non funzionante perché l'intento potrebbe non corrispondere a un'attività. Per risolvere il problema, Android ti consente di aggiungere dinamicamente voci di menu al menu quando Android trova sul dispositivo le attività che gestiscono le tue intenzioni.

Per aggiungere voci di menu in base alle attività disponibili che accettano un intento, procedi nel seguente modo: le seguenti:

  1. Definisci un intent con la categoria CATEGORY_ALTERNATIVE o CATEGORY_SELECTED_ALTERNATIVE, o entrambi, più eventuali altri requisiti.
  2. Chiama Menu.addIntentOptions(). Android cerca quindi tutte le app in grado di eseguire l'intento le aggiunge al tuo menu.

Se non ci sono app installate che soddisfano l'intento, non verrà visualizzato alcun menu. vengono aggiunti.

Ciò è mostrato nell'esempio seguente:

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;
}

Per ogni attività trovata che fornisce un filtro di intent corrispondente all'intent definita, viene aggiunta una voce di menu utilizzando il valore nel filtro per intent android:label come titolo della voce di menu e icona dell'app come menu icona elemento. Il metodo addIntentOptions() restituisce il numero di voci di menu aggiunte.

Consenti di aggiungere la tua attività ad altri menu

Puoi offrire i servizi della tua attività ad altre app in modo che la tua app possa nel menu di altri, invertendo i ruoli descritti in precedenza.

Da includere in altri menu delle app, definisci un filtro per intent come di consueto, ma includi i campi CATEGORY_ALTERNATIVE o Valori di CATEGORY_SELECTED_ALTERNATIVE, o entrambi, per l'intento categoria di filtro. Ciò è mostrato nell'esempio seguente:

<intent-filter label="@string/resize_image">
    ...
    <category android:name="android.intent.category.ALTERNATIVE" />
    <category android:name="android.intent.category.SELECTED_ALTERNATIVE" />
    ...
</intent-filter>

Scopri di più sulla scrittura di filtri per intent in Intenzioni e intenzione filtri.