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.
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 type="x-smartling-placeholder">![Ein Bild, auf dem die App-Leiste für die Google Tabellen App zu sehen ist](https://developer.android.com/static/images/training/appbar/appbar_sheets_2x.png?authuser=9&hl=de)
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:
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; }
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.
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); } }
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 type="x-smartling-placeholder">![Ein Bild, das ein unverankertes Kontextmenü zeigt](https://developer.android.com/static/develop/ui/views/images/context_menu_no_icons.png?authuser=9&hl=de)
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:
View
registrieren, mit dem das Kontextmenü verknüpft ist AnrufenregisterForContextMenu()
und übergeben dasView
.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 SieRecyclerView
anregisterForContextMenu()
.- Implementieren Sie die
onCreateContextMenu()
inActivity
oderFragment
.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ählteView
und einContextMenu.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. 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 Attributandroid: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, bistrue
oderfalse
wird zurückgegeben. Die Standardimplementierungen für Rückgabe vonActivity
undandroid.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:
- 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 denActionMode
-APIs können Sie verschiedene Änderungen am CAB, z. B. durch das Anpassen des Titels und der Untertitel mitsetTitle()
undsetSubtitle()
, Damit wird angegeben, wie viele Elemente ausgewählt sind.Im vorherigen Beispiel wird die Variable
actionMode
aufnull
, 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. - 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 FehlerwertActionMode
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 mitActionMode
sichergestellt, dass Die InstanzActionMode
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 type="x-smartling-placeholder">![Ein Bild, das ein Pop-up-Menü in der Gmail App zeigt, verankert am Dreipunkt-Menü oben rechts.](https://developer.android.com/static/images/ui/popupmenu.png?authuser=9&hl=de)
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:
- Instanziieren Sie eine
PopupMenu
mit ihrem Konstruktor, der die aktuelle AppContext
und dieView
, mit dem das Menü verknüpft ist. - Verwenden Sie
MenuInflater
, um Ihre Menüressource in dieMenu
-Objekt, das von zurückgegeben wirdPopupMenu.getMenu()
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:
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(); });
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:
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; } }
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.
<ph type="x-smartling-placeholder">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:
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); } }
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.
<ph type="x-smartling-placeholder">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:
- Intent mit der Kategorie definieren
CATEGORY_ALTERNATIVE
oderCATEGORY_SELECTED_ALTERNATIVE
, oder beides sowie weitere Anforderungen. - 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.
<ph type="x-smartling-placeholder">Dies wird im folgenden Beispiel gezeigt:
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; }
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.