Menu to typowy element interfejsu w wielu rodzajach aplikacji. Do
zapewniają użytkownikom znajome i spójne wrażenia, używaj
Menu
interfejsów API do
przedstawiaj działania użytkowników i inne opcje w swoich działaniach.
W tym dokumencie opisujemy, jak stworzyć trzy podstawowe typy menu lub prezentacje akcji na wszystkich wersjach Androida:
- Menu opcji i pasek aplikacji
- Menu opcji to podstawowy zbiór dań menu
działania. To w nich podejmujesz działania o globalnym wpływie
aplikacji, np. „Wyszukiwarka”, „Napisz e-maila”, i „Ustawienia”.
Zobacz Tworzenie menu opcji. .
- Menu kontekstowe i tryb czynności kontekstowych
- Menu kontekstowe jest pływającym menu
który pojawia się, gdy użytkownik kliknie przycisk trzymając element. it
udostępnia działania, które wpływają na wybraną treść lub ramkę kontekstu.
Tryb działań kontekstowych wyświetla działania, które: wpływa na zaznaczone treści na pasku u góry ekranu. użytkownik wybierze kilka elementów.
Zapoznaj się z sekcją Tworzenie menu kontekstowego. .
- Wyskakujące menu
- W wyskakującym menu wyświetla się pionowa lista elementów zakotwiczonych w
który wywołuje menu. To dobry sposób na zwiększenie liczby działań
powiązane z konkretnymi treściami lub z opcjami dotyczącymi drugiej części,
polecenia. Czynności, które można wykonać w wyskakującym menu, nie wpływają bezpośrednio na
odpowiednie treści — od tego służą działania kontekstowe. Zamiast tego
wyskakujące menu dotyczy działań rozszerzonych, które odnoszą się do regionów treści
Twojej aktywności.
Zapoznaj się z sekcją Tworzenie wyskakującego menu.
Zdefiniuj menu w pliku XML
Dla wszystkich typów menu Android zapewnia standardowy format XML do definiowania menu.
elementy(ów). Zamiast tworzyć menu w kodzie aktywności, zdefiniuj menu
wszystkie jego elementy w pliku XML
zasobu menu. Dostępne opcje
a następnie zwiększ zasób menu, ładując go jako Menu
w swojej aktywności lub we fragmencie.
Korzystanie z zasobu menu jest dobrym rozwiązaniem z tych powodów:
- Struktura menu jest łatwiejsza do przedstawienia w formacie XML.
- Oddziela zawartość menu od sposobu działania aplikacji w kodzie.
- Umożliwia tworzenie alternatywnych konfiguracji menu dla różnych platform. wersji, rozmiarów ekranu i innych konfiguracji, wykorzystując zasoby aplikacji platformy.
Aby zdefiniować menu, utwórz plik XML w folderze
res/menu/
i utwórz menu z podanymi niżej opcjami
elementy:
<menu>
- Definiuje element
Menu
, który jest kontenerem dla pozycji menu. O Element<menu>
musi być węzłem głównym pliku, może zawierać co najmniej jeden<item>
i<group>
. <item>
- Tworzy plik
MenuItem
, reprezentujący pojedynczy element menu. Ten element może zawierać zagnieżdżony element<menu>
element, aby utworzyć menu podrzędne. <group>
- Opcjonalny, niewidoczny kontener dla użytkownika
<item>
. Pozwala dzielić pozycje menu na kategorie, by miały wspólne właściwości, takie jak jako stan aktywności i widoczność. Więcej informacji: Utwórz sekcję menu.
Oto przykładowe menu o nazwie 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>
Element <item>
obsługuje kilka atrybutów, których możesz użyć
aby określić wygląd i zachowanie elementu. Pozycje w poprzednim menu
zawierają te atrybuty:
android:id
- Unikalny identyfikator zasobu, który umożliwia aplikacji rozpoznaj element, gdy użytkownik wybiera dany element.
android:icon
- Odwołanie do elementu rysowanego, który ma być używany jako ikona elementu.
android:title
- Odwołanie do ciągu znaków, które zostanie użyte jako tytuł elementu.
android:showAsAction
- Specyfikacja określająca, kiedy i w jaki sposób dany element pojawia się jako działanie na pasku aplikacji.
To są najważniejsze atrybuty, których używasz, ale jest ich znacznie więcej i dostępności informacji. Informacje o wszystkich obsługiwanych atrybutach znajdziesz w dokumentacji Zasób menu dokumentacji.
Możesz dodać podmenu do elementu w dowolnym menu, dodając element
Element <menu>
jako element podrzędny elementu <item>
.
Podmenu są przydatne, gdy aplikacja ma wiele funkcji, które można uporządkować
w tematy, takie jak pozycje na pasku menu aplikacji na komputer, takie jak Plik,
Edytuj i Wyświetl. Zobacz ten przykład:
<?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>
Aby używać menu w aktywności, _inflate_ należy użyć zasobu menu
zasobu XML w programowalny obiekt przy użyciu
MenuInflater.inflate()
W sekcjach poniżej znajdziesz informacje o tym, jak zwiększać rozmiar menu w przypadku każdego typu menu.
Utwórz menu opcji
W menu opcji, takim jak to pokazane na ilustracji 1, należy podać działania i inne opcje, które mają znaczenie w bieżącym kontekście działań, na przykład „Wyszukiwarka”, „Napisz e-maila”, i „Ustawienia”.
![Ilustracja pokazująca pasek aplikacji Arkusze Google](https://developer.android.com/static/images/training/appbar/appbar_sheets_2x.png?authuser=19&hl=pl)
Dla menu opcji możesz zadeklarować
Activity
podklasa lub
Fragment
podklasa. Jeśli zarówno Twoja aktywność, jak i fragmenty deklarują elementy dla parametru
opcje, elementy zostaną połączone w interfejsie. Pojawią się elementy aktywności
a po nim te dla każdego fragmentu, w kolejności, w jakiej
są dodawane do aktywności. W razie potrzeby możesz zmienić kolejność pozycji menu za pomocą
android:orderInCategory
w każdym
<item>
, które musisz przenieść.
Aby określić menu opcji aktywności, zastąp
onCreateOptionsMenu()
Fragmenty kodu przedstawiają własne dane
onCreateOptionsMenu()
oddzwanianie. Dzięki tej metodzie możesz
zwiększyć ilość menu,
zdefiniowanej w pliku XML, do pola Menu
w pliku
oddzwanianie. Widać to w tym przykładzie:
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; }
Możesz też dodać dania w menu za pomocą
add()
i pobieraj elementy za pomocą
findItem()
aby zmodyfikować swoje właściwości za pomocą interfejsów API MenuItem
.
Obsługa zdarzeń kliknięcia
Gdy użytkownik wybierze element z menu opcji, w tym działania
na pasku aplikacji system wywołuje
onOptionsItemSelected()
. Ta metoda przekazuje wybraną MenuItem
. Możesz zidentyfikować
produktu, wywołując
getItemId()
,
zwracający unikalny identyfikator pozycji menu, zdefiniowany przez
atrybut android:id
w zasobie menu lub z podaną liczbą całkowitą
do metody add()
. Możesz dopasować ten identyfikator do znanego menu
Wykonanie odpowiedniej czynności.
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); } }
Gdy przejdziesz do pozycji menu, zwróć true
. Jeśli
nie obsługuje pozycji menu, wywołaj implementację superklasy
onOptionsItemSelected()
Zwracana jest implementacja domyślna
false (fałsz).
Jeśli aktywność obejmuje fragmenty, system najpierw wywołuje
onOptionsItemSelected()
dla aktywności, a następnie dla każdego fragmentu
w kolejności dodawania fragmentów, aż jeden zwróci wartość true
lub
wszystkie fragmenty.
Zmieniaj pozycje menu podczas działania
Po wywołaniu przez system onCreateOptionsMenu()
zachowuje on
wystąpienia pola Menu
, które wypełniasz i nie wywołujesz
onCreateOptionsMenu()
, chyba że menu jest nieprawidłowe.
Pamiętaj jednak, że do utworzenia menu początkowego używaj tylko opcji onCreateOptionsMenu()
i nie wprowadzać zmian w trakcie cyklu życia działania.
Jeśli chcesz zmodyfikować menu opcji w zależności od zdarzeń występujących w
cyklu życia aktywności, możesz to zrobić na stronie
onPrepareOptionsMenu()
. Ta metoda przekazuje Ci obiekt Menu
w obecnej postaci,
więc można ją modyfikować, np. dodawać, usuwać lub wyłączać elementy.
Fragmenty kodu zapewniają też
onPrepareOptionsMenu()
oddzwanianie.
Menu opcji jest zawsze otwarte, gdy elementy menu są prezentowane w
na pasku aplikacji. Gdy wystąpi jakieś zdarzenie i chcesz zaktualizować menu, wywołaj
invalidateOptionsMenu()
aby zażądać wywołania systemowego onPrepareOptionsMenu()
.
Tworzenie menu kontekstowego
![Obraz przedstawiający pływające menu kontekstowe](https://developer.android.com/static/develop/ui/views/images/context_menu_no_icons.png?authuser=19&hl=pl)
Menu kontekstowe oferuje działania, które wpływają na konkretny element lub kontekst
w ramce w interfejsie. Możesz dodać menu kontekstowe dla każdego widoku, ale najbardziej
często używane w przypadku
RecylerView
lub
inne kolekcje widoku, w których użytkownik może wykonywać bezpośrednie działania na każdej z nich
elementu.
Działania kontekstowe można udostępniać na 2 sposoby:
- w pływającym menu kontekstowym – Menu ma postać pływającej listy pozycji menu, podobnie jak w oknie, gdy użytkownik wykonuje dotknięcie obejmują widok, który deklaruje obsługę kontekstu . Użytkownicy mogą wykonywać działania kontekstowe na jednym elemencie naraz.
- w trybie działań kontekstowych, Ten tryb jest systemem
implementacja
ActionMode
wyświetlający pasek działań kontekstowych (CAB) u góry ekran z działaniami, które wpływają na wybrane elementy. Gdy ten tryb jest aktywny, użytkownicy mogą wykonywać działania na wielu elementach jednocześnie, jeśli aplikacja obsługuje tę funkcję.
Uwaga: menu kontekstowe nie obsługuje skrótów elementów ani ikon elementów.
Tworzenie pływającego menu kontekstowego
Aby udostępnić pływające menu kontekstowe, wykonaj te czynności:
- Zarejestruj element
View
, z którym powiązane jest menu kontekstowe połączeniaregisterForContextMenu()
i przekazujeView
.Jeśli Twoja aktywność używa
RecyclerView
i chcesz, aby były element, aby zapewnić to samo menu kontekstowe, zarejestruj wszystkie elementy dla kontekstu menu, przekazującRecyclerView
doregisterForContextMenu()
- Zaimplementuj tag
onCreateContextMenu()
w tabeliActivity
lubFragment
.Gdy zarejestrowany widok zostanie dotknięty znakiem & zdarzenie zawieszenia, system wywołuje metody
onCreateContextMenu()
. W tym miejscu określasz pozycje menu, zazwyczaj przez powiększenie zasobu menu, jak w poniższym przykładzie przykład: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
pozwala rozszerzyć menu kontekstowe z poziomu zasobu menu. Metoda wywołania zwrotnego obejmują poleView
wybrane przez użytkownika orazContextMenu.ContextMenuInfo
, który zawiera dodatkowe informacje o wybranym elemencie. Jeśli masz kilka widoków, z których każdy ma inne menu kontekstowe, możesz użyć tych parametrów, by określić, które menu kontekstowe rozszerzać. Wdrażaj
onContextItemSelected()
, jak w poniższym przykładzie. Gdy użytkownik wybierze pozycję w menu, system wywołuje tę metodę, możesz więc wykonać odpowiednie działanie.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()
wysyła zapytanie o identyfikator wybranej pozycji menu, który przypisujesz elementu menu w pliku XML przy użyciu atrybutuandroid:id
, jak pokazano w Zdefiniuj menu w pliku XML.Gdy przejdziesz do pozycji menu, zwróć
true
. Jeśli nie obsługujesz pozycji menu, przekaż ją do klasy nadrzędnej implementacji. Jeśli aktywność obejmuje fragmenty, otrzymuje ona najpierw to wywołanie zwrotne. Dzięki nieobsłudze przez wywołanie klasy nadrzędnej system przekazuje zdarzenie do odpowiedniej metody wywołania zwrotnego w każdym fragmencie, po jednej w czasu, w kolejności dodania poszczególnych fragmentów, aż dotrue
lub Wartośćfalse
jest zwracana. Implementacje domyślne dlaActivity
iandroid.app.Fragment
wracająfalse
, więc zawsze wywołaj superklasę, gdy nie jest obsługiwana.
Użyj trybu czynności kontekstowej
Tryb działania kontekstowego to implementacja systemowa
ActionMode
, który skupia interakcje użytkownika na skuteczności
działań kontekstowych. Gdy użytkownik włączy ten tryb, wybierając element,
pasek działań kontekstowych pojawia się u góry ekranu, by wyświetlić prezentację.
Czynności, które użytkownik może wykonać na wybranych elementach. Gdy ten tryb jest włączony,
użytkownik może zaznaczyć kilka elementów, jeśli aplikacja to obsługuje, i odznaczyć tę funkcję.
elementy i dalej poruszać się w obrębie aktywności. Tryb działania jest wyłączony.
a pasek działań kontekstowych znika, gdy użytkownik odznaczy wszystkie elementy.
klika przycisk Wstecz albo przycisk Gotowe po lewej stronie
przeglądarki.
W przypadku widoków, które udostępniają działania kontekstowe, zwykle wywołujesz widok kontekstowy. tryb działania, gdy wystąpi jedno lub oba z tych 2 zdarzeń:
- Użytkownik wykonuje dotknięcie, i zatrzymać widok.
- Użytkownik zaznacza pole wyboru lub podobny komponent interfejsu w widoku.
Jak aplikacja wywołuje tryb działania kontekstowego i definiuje zachowanie każdego działania zależy od projektu. Są 2 wzory:
- Dla działań kontekstowych dotyczących poszczególnych, dowolnych widoków.
- Aby zbiorczo wykonywać działania kontekstowe na grupach elementów w
RecyclerView
, umożliwiając użytkownikowi wybranie wielu elementów wykonać na nich dowolną czynność.
W sekcjach poniżej opisano konfigurację wymaganą w każdym scenariuszu.
Włącz tryb działań kontekstowych w poszczególnych widokach
Jeśli chcesz wywoływać tryb działania kontekstowego tylko wtedy, gdy użytkownik wybierze opcję wykonaj te czynności:
- Wdróż interfejs
ActionMode.Callback
w sposób pokazany w z tego przykładu. W metodach wywołania zwrotnego możesz określić działania dla paska działań kontekstowych, reagowania na zdarzenia kliknięcia określonych działań oraz obsługuje inne zdarzenia cyklu życia dla trybu działania.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; } };
Te wywołania zwrotne zdarzeń są prawie dokładnie takie same jak wywołania zwrotne dla menu opcji, z tym że każda z tych opcji przekazuje też obiekt
ActionMode
powiązany ze zdarzeniem. Za pomocą interfejsów APIActionMode
możesz wprowadzać różne zmiany w interfejsie CAB, np. zmianę tytułu i podtytułu za pomocąsetTitle()
orazsetSubtitle()
, co pomaga określić liczbę wybranych elementów.Poprzedni przykład ustawia zmienną
actionMode
nanull
po zniszczeniu trybu działania. W następnym kroku zobacz jak jest zainicjowana i jak zapisać zmienną członkowską w aktywności lub fragment. - Zadzwoń do nas
startActionMode()
gdy chcesz wyświetlić pasek, na przykład wtedy, gdy użytkownik kliknie przycisk i zatrzymać widok.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; } });
Gdy wywołujesz funkcję
startActionMode()
, system zwraca UtworzonoActionMode
. Zapisując go w zmiennej uczestnika, może wprowadzać zmiany w pasku działań kontekstowych w odpowiedzi na inne zdarzenia. W poprzednim przykładzieActionMode
jest używany do zapewnienia, że instancjaActionMode
nie jest odtworzona, jeśli już istnieje aktywny, sprawdzając przed rozpoczęciem działania, czy użytkownik ma wartość null. i trybu uzyskiwania zgody.
Utwórz wyskakujące menu
![Obraz przedstawiający wyskakujące menu w aplikacji Gmail zakotwiczone do rozszerzonego przycisku w prawym górnym rogu.](https://developer.android.com/static/images/ui/popupmenu.png?authuser=19&hl=pl)
PopupMenu
to menu modalne powiązane z elementem View
. Jest ona widoczna pod reklamą zakotwiczoną
(jeśli jest dość miejsca, lub nad widokiem). Jest to przydatne dla
:
- udostępnianie rozszerzonego menu z działaniami dotyczącymi określonych treści, takich jak nagłówki e-maili w Gmailu, które pokazano na rys. 4.
- Druga część zdania polecenia, np. przycisk oznaczony przycisk Dodaj, który tworzy wyskakujące menu z opcją Dodaj, .
- Udostępnianie menu podobnego do
Spinner
który nie zachowuje trwałego wyboru.
Jeśli zdefiniujesz menu w formacie XML, wykonaj poniższe czynności, aby pokazać menu:
- Utwórz instancję
PopupMenu
za pomocą konstruktora, który zajmuje bieżąca aplikacjaContext
orazView
, z którym menu jest zakotwiczone. - Użyj polecenia
MenuInflater
, aby rozszerzyć zasób menu naMenu
obiekt zwrócony przezPopupMenu.getMenu()
- Będziesz dzwonić pod numer
PopupMenu.show()
.
Oto przykład:
<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" />
Działanie może wtedy wyświetlić wyskakujące menu:
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(); });
Menu jest zamykane, gdy użytkownik wybierze pozycję lub kliknie poza menu
w pobliżu. Aby nasłuchiwać zdarzenia odrzucenia, użyj polecenia
PopupMenu.OnDismissListener
Obsługa zdarzeń kliknięcia
Aby wykonać działanie, gdy użytkownik wybierze pozycję menu, zaimplementuj funkcję
PopupMenu.OnMenuItemClickListener
i zarejestruj ją w PopupMenu
, wywołując
setOnMenuItemclickListener()
Gdy użytkownik wybiera dany element, system wywołuje metodę
onMenuItemClick()
wywołanie zwrotne w interfejsie.
Widać to w tym przykładzie:
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; } }
Utwórz grupę menu
Grupa menu to zbiór pozycji menu, które mają wspólne cechy. Dzięki grupy, możesz wykonać te czynności:
- Pokaż lub ukryj wszystkie elementy za pomocą atrybutu
setGroupVisible()
- Włącz lub wyłącz wszystkie elementy używające argumentu
setGroupEnabled()
- Określ, czy wszystkie elementy można zaznaczyć za pomocą funkcji
setGroupCheckable()
Aby utworzyć grupę, możesz zagnieździć w środku elementy <item>
<group>
w zasobie menu albo przez określenie
z identyfikatorem grupy
add()
.
Oto przykład zasobu menu zawierającego grupę:
<?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>
Elementy w grupie wyświetlają się na tym samym poziomie co pierwszy
element – wszystkie trzy elementy w menu to elementy równorzędne. Można jednak zmienić
właściwości obu elementów w grupie, podając identyfikator grupy
poprzednich metod. System nigdy nie rozdziela też zgrupowanych elementów. Dla:
Jeśli na przykład zadeklarujesz android:showAsAction="ifRoom"
dla każdego
pojawiają się na pasku działań lub
overflow.
Używaj pozycji menu, które można zaznaczyć
Menu może służyć jako interfejs do włączania i wyłączania opcji, a także pola wyboru samodzielnych opcji lub przycisków opcji dla grup wzajemnie opcje dostępne tylko w tych wersjach. Rysunek 5 przedstawia menu podrzędne z elementami, które można zaznaczyć przycisków opcji.
Działanie, które można sprawdzić dla poszczególnych pozycji menu, możesz określić za pomocą
Atrybut android:checkable
w <item>
elementu lub całej grupy z tagiem android:checkableBehavior
w elemencie <group>
. Na przykład wszystkie elementy w
tę grupę menu można zaznaczyć za pomocą opcji:
<?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>
Atrybut android:checkableBehavior
akceptuje jeden z
:
single
- Można zaznaczyć tylko jeden element z grupy, co skutkuje wybraniem opcji przyciskami.
all
- Można zaznaczyć wszystkie elementy, co spowoduje wyświetlenie pól wyboru.
none
- Brak elementów do sprawdzenia.
Domyślnie do elementu możesz zastosować stan „zaznaczony” za pomocą
Atrybut android:checked
w elemencie <item>
i zmień go w kodzie za pomocą
setChecked()
.
Po zaznaczeniu elementu, który można zaznaczyć, system wywołuje odpowiednie
wybrana przez produkt metoda wywołania zwrotnego, np. onOptionsItemSelected()
.
W tym miejscu ustawia się stan pola wyboru, ponieważ pole wyboru lub opcja
Stan przycisku nie zmienia się automatycznie. Możesz przesłać zapytanie o bieżący stan
– w taki sam sposób, w jaki użytkownik go wybrał – przy użyciu
isChecked()
a następnie ustaw stan zaznaczenia za pomocą setChecked()
. Komunikaty te pojawiają się tutaj:
następujący przykład:
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); } }
Jeśli nie ustawisz tej zasady w ten sposób, widoczny stan nie zmieniają się, gdy użytkownik je zaznaczy. Kiedy to zrobisz ustawi stan, działanie zachowuje zaznaczony stan elementu, tak aby gdy użytkownik otworzy menu później, wybrany stan to widoczne.
Dodaj pozycje menu na podstawie intencji
Czasami chcesz, by pozycja menu uruchamiała działanie za pomocą
Intent
,
niezależnie od tego, czy chodzi o aktywność w aplikacji, czy w innej. Gdy
określić intencję, której chcesz użyć, i określić element menu, który inicjuje
możesz wykonać intencję za pomocą
startActivity()
podczas odpowiedniej metody wywołania zwrotnego wybranej pozycji, takiej jak
onOptionsItemSelected()
oddzwonienie.
Jeśli jednak nie masz pewności, że na urządzeniu użytkownika znajduje się aplikacja, obsługuje intencję, a dodanie elementu menu, który ją wywołuje, może spowodować niedziałająca pozycja menu, ponieważ intencja może nie prowadzić do działania. Aby rozwiązać ten problem, Android pozwala dynamicznie dodawać pozycje do menu, gdy Android znajduje na urządzeniu działania, które obsługują Twoje intencje.
Aby dodać pozycje menu na podstawie dostępnych działań, które akceptują intencję, wykonaj następujące:
- Zdefiniuj intencję za pomocą kategorii
CATEGORY_ALTERNATIVE
lubCATEGORY_SELECTED_ALTERNATIVE
, lub oba te warunki, a także dodatkowe wymagania. - Zadzwoń do nas
Menu.addIntentOptions()
Android wyszuka aplikacje, które mogą zrealizować intencję spowoduje dodanie ich do menu.
Jeśli nie masz zainstalowanych aplikacji, które pasują do tej intencji, nie zobaczysz menu. dodano elementy.
Widać to w tym przykładzie:
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; }
Dla każdego znalezionego działania, które dostarcza filtr intencji pasujący do intencji
zdefiniowane jest dodanie elementu menu, który korzysta z wartości w filtrze intencji
android:label
jako tytuł pozycji menu i ikonę aplikacji jako menu.
ikonę elementu. Metoda addIntentOptions()
zwraca liczbę
Dodano pozycje menu.
Pozwól na dodawanie aktywności do innych menu
Możesz oferować innym aplikacjom usługi związane z aktywnością w celu umożliwienia dostępu do aplikacji w menu innych osób, cofając role opisane wcześniej.
Aby znaleźć się w menu innych aplikacji, zdefiniuj filtr intencji w zwykły sposób,
ale uwzględnij CATEGORY_ALTERNATIVE
lub
Wartości CATEGORY_SELECTED_ALTERNATIVE
lub obie dla intencji
kategorię filtra. Widać to w tym przykładzie:
<intent-filter label="@string/resize_image"> ... <category android:name="android.intent.category.ALTERNATIVE" /> <category android:name="android.intent.category.SELECTED_ALTERNATIVE" /> ... </intent-filter>
Więcej informacji o tworzeniu filtrów intencji: Intencje i zamiary filtrów.