Dodaj menu

Wypróbuj sposób tworzenia wiadomości
Jetpack Compose to zalecany zestaw narzędzi UI na Androida. Dowiedz się, jak dodawać komponenty w narzędziu Compose
TopAppBar → .

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.

.
Ilustracja pokazująca przykład rozszerzonego menu
. Rysunek 1. Menu wyświetlane po kliknięciu ikony widoczna pod ikoną rozszerzonego menu.

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
Rysunek 2. Aplikacja Arkusze Google kilka przycisków, w tym dodatkowy przycisk działania.

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
Rysunek 3. Pływające menu kontekstowe.

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:

  1. Zarejestruj element View, z którym powiązane jest menu kontekstowe połączenia registerForContextMenu() i przekazuje View.

    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ąc RecyclerView do registerForContextMenu()

  2. Zaimplementuj tag onCreateContextMenu() w tabeli Activity lub Fragment.

    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ą pole View wybrane przez użytkownika oraz ContextMenu.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ć.

  3. 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 atrybutu android: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ż do true lub Wartość false jest zwracana. Implementacje domyślne dla Activity i android.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:

  1. 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 API ActionMode możesz wprowadzać różne zmiany w interfejsie CAB, np. zmianę tytułu i podtytułu za pomocą setTitle() oraz setSubtitle(), co pomaga określić liczbę wybranych elementów.

    Poprzedni przykład ustawia zmienną actionMode na null po zniszczeniu trybu działania. W następnym kroku zobacz jak jest zainicjowana i jak zapisać zmienną członkowską w aktywności lub fragment.

  2. 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 Utworzono ActionMode. Zapisując go w zmiennej uczestnika, może wprowadzać zmiany w pasku działań kontekstowych w odpowiedzi na inne zdarzenia. W poprzednim przykładzie ActionMode jest używany do zapewnienia, że instancja ActionMode 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.
Rysunek 4. w wyskakującym menu w aplikacji Gmail, jest zakotwiczona na przycisku rozszerzonego w prawym górnym rogu.

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:

  1. Utwórz instancję PopupMenu za pomocą konstruktora, który zajmuje bieżąca aplikacja Context oraz View, z którym menu jest zakotwiczone.
  2. Użyj polecenia MenuInflater, aby rozszerzyć zasób menu na Menu obiekt zwrócony przez PopupMenu.getMenu()
  3. 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:

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ć

Rysunek 5. Podmenu z elementy do zaznaczenia.

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:

  1. Zdefiniuj intencję za pomocą kategorii CATEGORY_ALTERNATIVE lub CATEGORY_SELECTED_ALTERNATIVE, lub oba te warunki, a także dodatkowe wymagania.
  2. 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.