Speisekarten hinzufügen

Schreiben Sie jetzt

Jetpack Compose ist das empfohlene UI-Toolkit für Android. Informationen zum Hinzufügen von Komponenten in Compose

<ph type="x-smartling-placeholder"></ph> TopAppBar →

Menüs sind eine gängige Komponente der Benutzeroberfläche in vielen Arten von Apps. Bis eine vertraute und einheitliche User Experience zu bieten, Menu APIs für Nutzeraktionen und andere Optionen in Ihren Aktivitäten zu präsentieren.

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

In diesem Dokument erfahren Sie, wie Sie die drei grundlegenden Arten von Menüs oder Aktionspräsentationen für alle Android-Versionen:

Optionsmenü und App-Leiste

Das Optionsmenü ist die primäre Sammlung von Menüelementen Aktivitäten. Hier setzen Sie Aktionen ein, die sich weltweit auf die zum Beispiel die Suche, „E-Mail schreiben“ und „Einstellungen“.

Weitere Informationen finden Sie im Abschnitt Optionen zum Erstellen eines Optionsmenüs. .

Kontextmenü und Modus für kontextbezogene Aktionen

Ein Kontextmenü ist ein unverankertes Menü die angezeigt wird, wenn der Nutzer auf ein Element halten. Es stellt Aktionen bereit, die sich auf den ausgewählten Inhalt oder Kontextframe auswirken.

Im Modus für kontextbezogene Aktionen werden Aufgaben angezeigt, die den ausgewählten Inhalt in einer Leiste oben auf dem Bildschirm beeinflussen. Nutzer mehrere Elemente auswählen.

Weitere Informationen finden Sie im Abschnitt Kontextmenü erstellen. .

Pop-up-Menü

Ein Pop-up-Menü mit einer vertikalen Liste von Elementen ist zum Aufrufen des Menüs. Es empfiehlt sich, einen Überlauf von Aktionen bereitzustellen. die sich auf bestimmte Inhalte beziehen oder Optionen für den zweiten Teil eines Befehls. Aktionen in einem Pop-up-Menü wirken sich nicht direkt auf das die entsprechenden Inhalte – dafür sind Kontextaktionen geeignet. Stattdessen Das Pop-up-Menü ist für erweiterte Aktionen gedacht, die sich auf Inhaltsbereiche in Ihre Aktivitäten.

Weitere Informationen finden Sie im Abschnitt Pop-up-Menü erstellen.

Menü in XML definieren

Android bietet für alle Menütypen ein Standard-XML-Format zur Definition der Speisekarte. Elemente. Anstatt ein Menü im Code Ihrer Aktivität zu erstellen, definieren Sie ein Menü und alle Elemente in einer XML-Datei Speisekarte. Sie können Maximieren Sie dann die Menüressource und laden Sie sie als Menu. in Ihrer Aktivität oder Ihrem Fragment.

Die Verwendung einer Menüressource ist aus folgenden Gründen empfehlenswert:

• Es ist einfacher, die Menüstruktur in XML zu visualisieren.
• Es trennt den Menüinhalt vom Inhalt deiner App Code.
• Sie können damit alternative Menükonfigurationen für verschiedene Plattformen erstellen. Versionen, Bildschirmgrößen und anderen Konfigurationen App-Ressourcen Framework.

Erstellen Sie zum Definieren eines Menüs eine XML-Datei im res/menu/-Verzeichnis und erstellen Sie das Menü mit Folgendem: Elemente:

<menu>

Definiert einen Menu, also einen Container für Menüelemente. A Das <menu>-Element muss der Stammknoten für die Datei sein und kann eine oder mehrere <item> und <group> enthalten Elemente.

<item>

Erstellt ein MenuItem, ein einzelnes Element in einem Menü. Dieses Element kann ein verschachteltes <menu>, um ein Untermenü zu erstellen.

<group>

Ein optionaler, unsichtbarer Container für <item> Elemente. Sie können Menüelemente so kategorisieren, dass sie gemeinsame Eigenschaften haben, z. B. als „Aktiv“ und „Sichtbarkeit“. Weitere Informationen finden Sie in der Bereich Menügruppe erstellen:

Hier sehen Sie ein Beispielmenü mit dem Namen 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>

Das <item>-Element unterstützt mehrere Attribute, die Sie verwenden können um Aussehen und Verhalten eines Elements zu definieren. Die Elemente im vorherigen Menü die folgenden Attribute enthalten:

android:id

Eine eindeutige Ressourcen-ID für den Artikel, mit der die App den Artikel erkennen, wenn wenn Nutzende es auswählen.

android:icon

Ein Verweis auf ein Drawable, das als Symbol des Elements verwendet werden soll.

android:title

Ein Verweis auf einen String, der als Titel des Elements verwendet werden soll.

android:showAsAction

Die Spezifikation dafür, wann und wie diese Aufgabe als Aufgabe angezeigt wird in der App-Leiste.

Dies sind die wichtigsten Attribute, die Sie verwenden, verfügbar. Informationen zu allen unterstützten Attributen finden Sie in der Ressourcen für die Speisekarte Dokumentation.

Sie können einem Element in einem beliebigen Menü ein Untermenü hinzufügen, indem Sie ein <menu>-Element als untergeordnetes Element von <item>. Untermenüs sind nützlich, wenn Ihre App viele Funktionen hat, die sich organisieren lassen Themen wie Elemente in der Menüleiste einer PC-App wie Datei, Bearbeiten und Ansehen: Hier ein Beispiel:

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

Um das Menü in Ihrer Aktivität zu verwenden, _inflammen_ Sie die Menüressource, indem Sie der XML-Ressource in ein programmierbares Objekt MenuInflater.inflate() In den folgenden Abschnitten wird beschrieben, wie Sie die Inflation eines Menüs für jeden Menütyp durchführen.

Optionsmenü erstellen

Im Optionsmenü, wie in Abbildung 1 gezeigt, fügen Sie Aktionen und andere Optionen, die für den aktuellen Aktivitätskontext relevant sind, zum Beispiel „Suche“, „E-Mail schreiben“ und „Einstellungen“.

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

Sie können Elemente für das Optionsmenü über Ihr Activity abgeleitete Klasse oder eine Fragment abgeleitete Klasse. Wenn sowohl Ihre Aktivität als auch Ihre Fragmente Elemente für die Optionsmenü, werden die Elemente in der Benutzeroberfläche kombiniert. Die Elemente der Aktivität werden gefolgt von denen jedes Fragments, und zwar in der Reihenfolge, in der die Fragmente werden der Aktivität hinzugefügt. Bei Bedarf können Sie die Menüpunkte mit das Attribut android:orderInCategory in jedem <item>, die Sie verschieben müssen.

Um das Optionsmenü für eine Aktivität festzulegen, onCreateOptionsMenu() Fragmente bieten eigene onCreateOptionsMenu() Callback des Nutzers an. Bei dieser Methode können Sie die Menüressource erhöhen, in XML definiert, in die Menu im Callback des Nutzers an. Dies wird im folgenden Beispiel gezeigt:

override fun onCreateOptionsMenu(menu: Menu): Boolean {
    val inflater: MenuInflater = menuInflater
    inflater.inflate(R.menu.game_menu, menu)
    return true
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.game_menu, menu);
    return true;
}

Sie können Menüpunkte auch mit add() und Elemente mit einer findItem() , um ihre Properties mit MenuItem APIs zu überarbeiten.

Click-Events verarbeiten

Wenn der Nutzer ein Element aus dem Optionsmenü auswählt, einschließlich Aufgaben in der App-Leiste aufrufen, ruft das System die onOptionsItemSelected() . Diese Methode übergibt die ausgewählten MenuItem. Sie können indem Sie auf der getItemId(), gibt die eindeutige ID für den Menüpunkt zurück, der vom Attribut android:id in der Menüressource oder mit einer angegebenen Ganzzahl add() hinzu. Du kannst diese ID mit bekannten Speisekarten abgleichen um die entsprechenden Maßnahmen durchzuführen.

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

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

Wenn ein Menüelement erfolgreich verarbeitet wurde, geben Sie true zurück. Wenn Sie nicht den Menüpunkt behandelt, rufen Sie die onOptionsItemSelected() Die Standardimplementierung gibt false festlegen.

Wenn Ihre Aktivität Fragmente enthält, ruft das System zuerst auf onOptionsItemSelected() für die Aktivität, dann für jedes Fragment in der Reihenfolge an, in der die Fragmente hinzugefügt werden, bis true oder werden alle Fragmente aufgerufen.

Menüelemente während der Laufzeit ändern

Nach dem Aufrufen von onCreateOptionsMenu() behält es ein Instanz von Menu, die Sie füllen und nicht aufrufen onCreateOptionsMenu() noch einmal, es sei denn, das Menü wird ungültig gemacht. Verwenden Sie onCreateOptionsMenu() jedoch nur, um das anfängliche Menü zu erstellen. und keine Änderungen während des Aktivitätslebenszyklus vorzunehmen.

Wenn Sie das Optionsmenü basierend auf den Ereignissen während des können Sie dies in den onPrepareOptionsMenu() . Bei dieser Methode wird das Menu-Objekt in der aktuellen Form übergeben. vorhanden ist, damit Sie sie ändern können, z. B. durch Hinzufügen, Entfernen oder Deaktivieren von Elementen. Fragmente bieten auch eine onPrepareOptionsMenu() Callback des Nutzers an.

Das Optionsmenü gilt als immer geöffnet, wenn Menüpunkte in in der App-Leiste. Wenn ein Ereignis eintritt und Sie eine Speisekarte aktualisieren möchten, rufen Sie invalidateOptionsMenu() um anzufordern, dass das System onPrepareOptionsMenu() aufruft.

Kontextmenü erstellen

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

Ein Kontextmenü bietet Aktionen, die sich auf ein bestimmtes Element oder einen bestimmten Kontext auswirken Frame in der Benutzeroberfläche. Sie können für jede Ansicht ein Kontextmenü bereitstellen. Dies ist jedoch für Elemente in einer RecylerView oder andere Ansichtensammlungen, in denen der Nutzer direkte Aktionen ausführen kann. ein.

Es gibt zwei Möglichkeiten, Kontextaktionen bereitzustellen:

• In einem unverankerten Kontextmenü Ein Menü wird ähnlich wie ein Dialogfeld als unverankerte Liste von Menüpunkten angezeigt, wenn eine Berührung und auf eine Ansicht zurückhalten, in der ein Kontext unterstützt wird . Nutzer können jeweils nur eine Kontextaktion für ein Element durchführen.
• Im Modus für kontextbezogene Aktionen Dieser Modus ist ein Systemmodus, Implementierung von ActionMode mit einer Kontextaktionsleiste (CAB) über der mit Aufgaben, die sich auf die ausgewählten Elemente auswirken. Wenn dieser Modus aktiv ist, können Nutzer eine Aktion für mehrere Elemente gleichzeitig durchführen. die App unterstützt.

Hinweis:Das Kontextmenü unterstützt keine Tastenkombinationen und Symbole.

Unverankertes Kontextmenü erstellen

So stellen Sie ein unverankertes Kontextmenü bereit:

1. View registrieren, mit dem das Kontextmenü verknüpft ist Anrufen registerForContextMenu() und übergeben das View.

   Wenn für Ihre Aktivität ein RecyclerView verwendet wird und Sie diese Funktion nutzen möchten , um dasselbe Kontextmenü bereitzustellen, alle Elemente für einen Kontext registrieren indem Sie RecyclerView an registerForContextMenu().

2. Implementieren Sie die onCreateContextMenu() in Activity oder Fragment.

   Wenn die registrierte Ansicht eine Berührung & Warteschleifenereignis ist, ruft das System Ihre onCreateContextMenu()-Methode. Hier definieren Sie die Menüelemente, in der Regel durch Aufblähen einer Menüressource, z. B. Beispiel:

   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 ermöglicht die Inflation des Kontextmenüs von einer Menüressource. Die Callback-Methode Zu den Parametern gehören die vom Nutzer ausgewählte View und ein ContextMenu.ContextMenuInfo Objekt, das zusätzliche Informationen zum ausgewählten Element bereitstellt. Wenn gibt es für Ihre Aktivität mehrere Ansichten, die jeweils ein anderes Kontextmenü bieten. können Sie mit diesen Parametern bestimmen, welches Kontextmenü aufblähen.

3. Implementieren onContextItemSelected(), wie im folgenden Beispiel gezeigt. Wenn der Nutzer einen Artikel auf der Speisekarte auswählt, wird diese Methode aufgerufen, damit Sie die entsprechende Aktion ausführen können.

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

   Das getItemId() fragt die ID für das ausgewählte Menüelement ab, das Sie jedem Element zuweisen. in XML mit dem Attribut android:id, wie in Definieren Sie ein Menü in XML.

   Wenn ein Menüelement erfolgreich verarbeitet wurde, geben Sie true zurück. Wenn Sie den Menüpunkt nicht bearbeiten, übergeben Sie das Menüelement an die Basisklasse Implementierung. Enthält Ihre Aktivität Fragmente, erhält die Aktivität dieser Callback zuerst. Wenn die Basisklasse nicht verarbeitet wird, ruft das System übergibt das Ereignis an die entsprechende Callback-Methode in jedem Fragment, eines unter eine Zeit in der Reihenfolge, in der die einzelnen Fragmente hinzugefügt werden, bis true oder false wird zurückgegeben. Die Standardimplementierungen für Rückgabe von Activity und android.app.Fragment false. Rufen Sie deshalb immer die übergeordnete Klasse auf, wenn sie nicht verarbeitet wird.

Modus für kontextbezogene Aktionen verwenden

Der kontextbezogene Aktionsmodus ist eine Systemimplementierung ActionMode, bei denen die Nutzerinteraktion auf eine gute Leistung ausgerichtet ist Kontextaktionen. Wenn ein Nutzer diesen Modus durch Auswählen eines Elements aktiviert, wird ein Leiste für kontextbezogene Aktionen oben auf dem Bildschirm, um Aktionen, die der Nutzer für die ausgewählten Elemente ausführen kann Wenn dieser Modus aktiviert ist, Der Nutzer kann mehrere Elemente auswählen, sofern Ihre App dies unterstützt, und kann die Auswahl und navigieren Sie weiter innerhalb der Aktivität. Der Aktionsmodus ist deaktiviert und die Leiste für Kontextaktionen verschwindet, wenn Nutzende die Auswahl aller Elemente aufheben. auf die Schaltfläche „Zurück“ oder links auf dem Bildschirm auf Fertig. .

Bei Ansichten, die Kontextaktionen bereitstellen, rufen Sie in der Regel den kontextbezogenen wenn eines oder beide der folgenden Ereignisse eintreten:

• Der Nutzer führt eine Berührung die Ansicht nicht verlassen.
• Der Nutzer wählt ein Kontrollkästchen oder eine ähnliche UI-Komponente in der Ansicht aus.

Wie Ihre App den Modus für kontextbezogene Aktionen aufruft und den Modus definiert Verhalten für jede Aktion von Ihrem Design abhängt. Es gibt zwei Designs:

• Für Kontextaktionen für einzelne, beliebige Ansichten.
• Für kontextbezogene Batch-Aktionen für Elementgruppen in einer RecyclerView, sodass der Nutzer mehrere Elemente auswählen und eine Aktion an allen ausführen.

In den folgenden Abschnitten wird die für jedes Szenario erforderliche Einrichtung beschrieben.

Kontextbezogene Aktionsmodus für einzelne Ansichten aktivieren

Wenn Sie den Modus für kontextbezogene Aktionen nur dann aufrufen möchten, wenn der Nutzer für bestimmte Ansichten:

1. Implementieren Sie die ActionMode.Callback-Schnittstelle wie in der folgenden Beispiel. In den Callback-Methoden können Sie die Aktionen für der kontextbezogenen Aktionsleiste, reagieren auf Click-Events für Aktionselemente und andere Lebenszyklus-Ereignisse für den Aktionsmodus verarbeiten.

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

   Diese Ereignis-Callbacks sind fast identisch mit den Callbacks für Optionen, nur dass jede dieser Optionen übergibt auch das mit dem Ereignis verknüpfte ActionMode-Objekt. Mit den ActionMode-APIs können Sie verschiedene Änderungen am CAB, z. B. durch das Anpassen des Titels und der Untertitel mit setTitle() und setSubtitle(), Damit wird angegeben, wie viele Elemente ausgewählt sind.

   Im vorherigen Beispiel wird die Variable actionMode auf null, wenn der Aktionsmodus gelöscht wird. Im nächsten Schritt sehen Sie wie sie initialisiert wird und wie Sie die Member-Variable in Ihrer Aktivität Fragment nützlich sein.

2. Anruf startActionMode() wenn die Leiste angezeigt werden soll, z. B. wenn der Nutzer auf die Schaltfläche die Ansicht nicht verlassen.

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

   Wenn Sie startActionMode() aufrufen, gibt das System den Fehlerwert ActionMode erstellt. Indem Sie dies in einer Member-Variable speichern, kann als Reaktion auf andere Ereignisse Änderungen an der kontextbezogenen Aktionsleiste vornehmen. Im vorherigen Beispiel wird mit ActionMode sichergestellt, dass Die Instanz ActionMode wird nicht neu erstellt, wenn sie bereits aktiv, indem geprüft wird, ob das Mitglied null ist, bevor die Aktion gestartet wird .

Pop-up-Menü erstellen

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

Ein PopupMenu ist ein modales Menü, das mit View verknüpft ist. Es wird unterhalb des Ankers angezeigt. wenn Platz vorhanden ist, andernfalls über der Ansicht. Sie ist nützlich für Folgendes:

• Überlaufmenü für Aktionen zu bereitstellen bestimmte Inhalte, wie E-Mail-Header in Gmail, wie in Abbildung 4 dargestellt.
• Die Angabe eines zweiten Teils eines Befehlssatzes, z. B. eine Schaltfläche mit der Klicken Sie auf Add (Hinzufügen), um ein Pop-up-Menü mit verschiedenen Optionen zum Add (Hinzufügen) zu öffnen. Optionen.
• Die Bereitstellung eines Menüs ähnlich einem Spinner die keine dauerhafte Auswahl beibehält.

Wenn Sie Ihr Menü in XML definieren, können Sie Pop-up-Menü öffnen:

1. Instanziieren Sie eine PopupMenu mit ihrem Konstruktor, der die aktuelle App Context und die View, mit dem das Menü verknüpft ist.
2. Verwenden Sie MenuInflater, um Ihre Menüressource in die Menu-Objekt, das von zurückgegeben wird PopupMenu.getMenu()
3. PopupMenu.show() anrufen.

Hier sehen Sie als Beispiel eine Schaltfläche mit einem Pop-up-Menü:

<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" />

Die Aktivität kann dann das Pop-up-Menü wie folgt anzeigen:

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

findViewById(R.id.dropdown_menu).setOnClickListener(v -> {
    PopupMenu popup = new PopupMenu(this, v);
    popup.getMenuInflater().inflate(R.menu.actions, popup.getMenu());
    popup.show();
});

Das Menü wird geschlossen, wenn der Nutzer ein Element auswählt oder außerhalb des Menüs tippt Bereich. Sie können den Listener für das Schließen-Ereignis nutzen, PopupMenu.OnDismissListener

Click-Events verarbeiten

Um eine Aktion auszuführen, wenn die Nutzenden einen Menüpunkt auswählen, implementieren Sie die PopupMenu.OnMenuItemClickListener und registrieren Sie es bei Ihrer PopupMenu, indem Sie setOnMenuItemclickListener() Wenn der Nutzer ein Element auswählt, ruft das System die onMenuItemClick() auf Ihrer Benutzeroberfläche.

Dies wird im folgenden Beispiel gezeigt:

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

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

Menügruppe erstellen

Eine Menügruppe ist eine Sammlung von Menüelementen, die bestimmte Merkmale gemeinsam haben. Mit einem haben, können Sie Folgendes tun:

• Alle Elemente mit ein- oder ausblenden setGroupVisible()
• Aktivieren oder deaktivieren Sie alle Elemente mit setGroupEnabled()
• Geben Sie mit dem folgenden Befehl an, ob alle Elemente prüfbar sind: setGroupCheckable()

Du kannst eine Gruppe erstellen, indem du <item>-Elemente darin verschachtelst durch ein <group>-Element in Ihrer Menüressource oder durch Angabe eines Gruppen-ID mit dem add() .

Hier ein Beispiel für eine Menüressource, die eine Gruppe enthält:

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

Die Elemente in der Gruppe werden auf derselben Ebene wie das erste angezeigt Element – alle drei Elemente im Menü sind gleichgeordnete Elemente. Sie können jedoch der Merkmale der beiden Artikel in der Gruppe anhand der Gruppen-ID und den vorherigen Methoden. Außerdem trennt das System niemals gruppierte Elemente. Für Wenn Sie beispielsweise android:showAsAction="ifRoom" für jede angezeigt wird, erscheinen beide entweder in der Aktionsleiste oder beide in der Aktionsleiste. Überlauf.

Anpassbare Menüpunkte verwenden

Ein Menü kann als Oberfläche zum Aktivieren und Deaktivieren von Optionen mit einem für eigenständige Optionen oder Optionsfelder für Gruppen exklusive Optionen. Abbildung 5 zeigt ein Untermenü mit Elementen, die mit Optionsfeldern.

Sie können das prüfbare Verhalten für einzelne Menüelemente mit der Eigenschaft Attribut android:checkable in <item> oder für eine ganze Gruppe mit dem android:checkableBehavior-Element im Element <group>. Beispielsweise werden alle Elemente in diese Menügruppe mithilfe eines Optionsfelds eingesehen werden können:

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

Das Attribut android:checkableBehavior akzeptiert eine der folgenden Folgendes:

single

Es kann nur ein Element aus der Gruppe ausgewählt werden, sodass das Optionsfeld aktiviert ist Schaltflächen.

all

Es können alle Elemente ausgewählt werden. Daraufhin werden Kästchen angezeigt.

none

Es können keine Elemente ausgewählt werden.

Sie können einen standardmäßig ausgewählten Status auf ein Element anwenden. Verwenden Sie dazu die Attribut android:checked im Element <item> und ändern Sie ihn im Code mit der setChecked() .

Wenn ein auswählbares Element ausgewählt ist, ruft das System Ihr entsprechendes mit einem Element ausgewählte Callback-Methode wie onOptionsItemSelected(). Hier legen Sie den Status des Kästchens fest, Schaltfläche ändert ihren Status nicht automatisch. Sie können den aktuellen Status abfragen des Elements (wie vor der Auswahl durch den Nutzer) mit isChecked() und legen dann den Status „Geprüft“ mit setChecked() fest. Dies wird in im folgenden Beispiel:

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

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

Wird der Status "Geprüft" nicht auf diese Weise festgelegt, erscheint der sichtbare Status des Kontrollkästchen oder Optionsfeld ändert sich nicht, wenn der Nutzer es auswählt. Wenn Sie festgelegt haben, behält die Aktivität den Status des geprüften Elements bei, sodass Wenn der Nutzer das Menü später öffnet, ist der von Ihnen festgelegte Status sichtbar sind.

Menüpunkte basierend auf einem Intent hinzufügen

Manchmal soll ein Menüelement mithilfe eines Intent, unabhängig davon, ob es sich um eine Aktivität in Ihrer App oder einer anderen App handelt. Wenn Sie wissen, welchen Intent Sie verwenden möchten, und haben einen speziellen Menüpunkt, können Sie den Intent mit startActivity() während der entsprechenden Callback-Methode, die für das Element ausgewählt wurde, onOptionsItemSelected()-Callback.

Wenn Sie jedoch nicht sicher sind, ob sich auf dem Gerät des Nutzers eine App befindet, den Intent verarbeitet, kann das Hinzufügen eines Menüelements, das ihn aufruft, zu einer nicht funktionierenden Menüpunkt, weil der Intent möglicherweise nicht zu einer Aktivität aufgelöst wird. Um dieses Problem zu lösen, können Sie in Android Ihrem Menü Menüelemente dynamisch hinzufügen, wenn Android findet Aktivitäten auf dem Gerät, die deine Absicht verarbeiten.

So fügen Sie Menüpunkte basierend auf verfügbaren Aktivitäten hinzu, die einen Intent akzeptieren: Folgendes:

1. Intent mit der Kategorie definieren CATEGORY_ALTERNATIVE oder CATEGORY_SELECTED_ALTERNATIVE, oder beides sowie weitere Anforderungen.
2. Anruf Menu.addIntentOptions() Android sucht dann nach Apps, die diesen Intent ausführen, und werden sie Ihrem Menü hinzugefügt.

Wenn keine Apps installiert sind, die den Intent erfüllen, wird kein Menü Elemente hinzugefügt werden.

Dies wird im folgenden Beispiel gezeigt:

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
}

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

Für jede gefundene Aktivität, die einen mit dem Intent übereinstimmenden Intent-Filter bereitstellt definiert haben, wird ein Menüpunkt hinzugefügt. Dazu wird der Wert in der android:label als Titel des Menüpunkts und das App-Symbol als Menü Elementsymbol. Die Methode addIntentOptions() gibt die Anzahl der Menüpunkte hinzugefügt.

Aktivitäten können anderen Menüs hinzugefügt werden

Sie können die Dienste Ihrer Aktivitäten anderen Apps anbieten, damit Ihre App im Menü der anderen enthalten – wodurch die zuvor beschriebenen Rollen umgekehrt werden.

Um in andere App-Menüs aufgenommen zu werden, definieren Sie wie gewohnt einen Intent-Filter. aber mit CATEGORY_ALTERNATIVE oder CATEGORY_SELECTED_ALTERNATIVE-Werte oder beide Werte für den Intent Filterkategorie. Dies wird im folgenden Beispiel gezeigt:

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

Weitere Informationen zum Schreiben von Intent-Filtern finden Sie hier: Intents und Absichten Filter.