Добавить меню

Попробуйте способ создания композиций.

Jetpack Compose — это рекомендуемый набор инструментов для создания пользовательского интерфейса для Android. Узнайте, как добавлять компоненты в Compose.

Меню →

Меню — распространенный компонент пользовательского интерфейса во многих типах приложений. Для обеспечения привычного и единообразного пользовательского опыта используйте API Menu для отображения действий пользователя и других параметров в ваших активностях.

В этом документе показано, как создавать три основных типа меню или презентаций действий во всех версиях Android:

Меню настроек и панель приложений

Меню параметров — это основной набор пунктов меню для конкретного действия. Здесь вы размещаете действия, которые оказывают глобальное влияние на приложение, такие как «Поиск», «Создать электронное письмо» и «Настройки».

См. раздел «Создание меню параметров» .

Контекстное меню и контекстный режим действий

Контекстное меню — это плавающее меню , которое появляется, когда пользователь нажимает и удерживает элемент. Оно предоставляет действия, влияющие на выбранный контент или контекстную рамку.

В режиме контекстных действий элементы управления, влияющие на выбранный контент, отображаются в панели в верхней части экрана и позволяют пользователю выбирать несколько элементов одновременно.

См. раздел «Создание контекстного меню» .

Всплывающее меню

Всплывающее меню отображает вертикальный список элементов, привязанный к представлению, которое вызывает это меню. Оно хорошо подходит для предоставления дополнительных действий, связанных с конкретным содержимым, или для предоставления вариантов для второй части команды. Действия во всплывающем меню не влияют напрямую на соответствующее содержимое — для этого существуют контекстные действия. Скорее, всплывающее меню предназначено для расширенных действий, связанных с областями содержимого в вашей активности.

См. раздел «Создание всплывающего меню» .

Определите меню в XML.

Для всех типов меню Android предоставляет стандартный XML-формат для определения пунктов меню. Вместо того чтобы создавать меню в коде вашей активности, определите меню и все его пункты в XML- ресурсе меню . Затем вы можете загрузить этот ресурс меню — в виде объекта Menu — в вашей активности или фрагменте.

Использование меню в качестве ресурса является хорошей практикой по следующим причинам:

• Визуализировать структуру меню проще в формате XML.
• Это позволяет отделить содержимое меню от кода, определяющего поведение вашего приложения.
• Это позволяет создавать альтернативные конфигурации меню для разных версий платформы, размеров экрана и других параметров, используя структуру ресурсов приложения .

Для определения меню создайте XML-файл в каталоге res/menu/ вашего проекта и соберите меню, включив в него следующие элементы:

<menu>

Определяет элемент Menu , который является контейнером для пунктов меню. Элемент <menu> должен быть корневым узлом файла и может содержать один или несколько элементов <item> и <group> .

<item>

Создает элемент MenuItem , представляющий собой отдельный пункт меню. Этот элемент может содержать вложенный элемент <menu> для создания подменю.

<group>

Необязательный, невидимый контейнер для элементов <item> . Он позволяет классифицировать пункты меню таким образом, чтобы они имели общие свойства, такие как активное состояние и видимость. Для получения дополнительной информации см. раздел «Создание группы меню» .

Вот пример меню с именем 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>

Элемент <item> поддерживает несколько атрибутов, которые можно использовать для определения внешнего вида и поведения элемента. Элементы в приведенном выше меню включают следующие атрибуты:

android:id

Уникальный идентификатор ресурса, позволяющий приложению распознавать элемент при его выборе пользователем.

android:icon

Ссылка на изображение, которое будет использоваться в качестве иконки элемента.

android:title

Ссылка на строку, которая будет использоваться в качестве заголовка элемента.

android:showAsAction

Указывается, когда и как этот элемент отображается в качестве элемента действия на панели приложения.

Это наиболее важные атрибуты, которые вы используете, но доступно гораздо больше. Информацию обо всех поддерживаемых атрибутах см. в документации по ресурсам меню .

Добавить подменю к элементу любого меню можно, добавив элемент <menu> в качестве дочернего элемента элемента <item> . Подменю полезны, когда ваше приложение содержит множество функций, которые можно организовать по темам, как элементы в строке меню приложения для ПК — например, «Файл» , «Правка» и «Вид» . См. следующий пример:

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

Чтобы использовать меню в вашем действии, _загрузите_ ресурс меню, преобразовав XML-ресурс в программируемый объект с помощью MenuInflater.inflate() . В следующих разделах показано, как загрузить меню для каждого типа меню.

Создайте меню параметров

Меню параметров, подобное показанному на рисунке 1, предназначено для выбора действий и других параметров, относящихся к текущему контексту активности, таких как «Поиск», «Создать электронное письмо» и «Настройки».

Вы можете объявлять элементы для меню параметров из подкласса Activity или Fragment . Если и Activity, и Fragment объявляют элементы для меню параметров, элементы объединяются в пользовательском интерфейсе. Сначала отображаются элементы Activity, затем элементы каждого фрагмента в порядке добавления фрагментов в Activity. При необходимости вы можете изменить порядок элементов меню с помощью атрибута android:orderInCategory для каждого <item> , который необходимо переместить.

Чтобы указать меню параметров для активности, переопределите метод onCreateOptionsMenu() . Фрагменты предоставляют собственный коллбэк onCreateOptionsMenu() . В этом методе вы можете преобразовать ресурс меню, определенный в XML , в Menu , предоставленное в коллбэке. Это показано в следующем примере:

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

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

Вы также можете добавлять пункты меню с помощью add() и получать элементы с помощью findItem() чтобы изменять их свойства с помощью API MenuItem .

Обработка событий клика

Когда пользователь выбирает пункт из меню параметров, включая пункты действий на панели приложения, система вызывает метод onOptionsItemSelected() вашего действия. В этот метод передается выбранный MenuItem . Вы можете идентифицировать пункт, вызвав метод getItemId() , который возвращает уникальный идентификатор пункта меню, определенный атрибутом android:id в ресурсе меню или целым числом, переданным методу add() . Вы можете сопоставить этот идентификатор с известными пунктами меню, чтобы выполнить соответствующее действие.

override fun onOptionsItemSelected(item: MenuItem): Boolean {
    // Handle item selection.
    return when (item.itemId) {
        R.id.new_game -> {
            newGame()
            true
        }
        R.id.help -> {
            showHelp()
            true
        }
        else -> super.onOptionsItemSelected(item)
    }
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    // Handle item selection.
    switch (item.getItemId()) {
        case R.id.new_game:
            newGame();
            return true;
        case R.id.help:
            showHelp();
            return true;
        default:
            return super.onOptionsItemSelected(item);
    }
}

Если пункт меню обработан успешно, верните true . Если же пункт меню не обработан, вызовите реализацию метода onOptionsItemSelected() из суперкласса. Реализация по умолчанию возвращает false.

Если ваше действие включает фрагменты, система сначала вызывает onOptionsItemSelected() для этого действия, затем для каждого фрагмента в порядке их добавления, пока один из методов не вернет true или не будут вызваны все фрагменты.

Изменение пунктов меню во время выполнения

После вызова метода onCreateOptionsMenu() система сохраняет экземпляр заполненного вами Menu и не вызывает onCreateOptionsMenu() снова, если только меню не будет аннулировано. Однако используйте onCreateOptionsMenu() только для создания начального состояния меню, а не для внесения изменений в течение жизненного цикла активности.

Если вы хотите изменять меню параметров в зависимости от событий, происходящих в течение жизненного цикла активности, вы можете сделать это в методе onPrepareOptionsMenu() . Этот метод передает вам объект Menu в его текущем состоянии, чтобы вы могли его изменять, например, добавлять, удалять или отключать элементы. Фрагменты также предоставляют функцию обратного вызова onPrepareOptionsMenu() .

Меню параметров считается всегда открытым, когда пункты меню отображаются на панели приложения. При возникновении события, требующего обновления меню, вызовите метод invalidateOptionsMenu() , чтобы система вызвала onPrepareOptionsMenu() .

Создайте контекстное меню

Контекстное меню предлагает действия, влияющие на конкретный элемент или контекстный фрейм в пользовательском интерфейсе. Контекстное меню можно создать для любого представления, но чаще всего оно используется для элементов в RecylerView или других коллекциях представлений, в которых пользователь может выполнять прямые действия с каждым элементом.

Существует два способа предоставления контекстных действий:

• В плавающем контекстном меню . Меню отображается в виде плавающего списка пунктов, аналогичного диалоговому окну, когда пользователь нажимает и удерживает элемент, который объявляет о поддержке контекстного меню. Пользователи могут выполнять контекстное действие только с одним элементом за раз.
• В режиме контекстных действий . Этот режим представляет собой системную реализацию ActionMode , которая отображает панель контекстных действий (CAB) в верхней части экрана с элементами действий, влияющими на выбранный(е) элемент(ы). Когда этот режим активен, пользователи могут выполнять действия над несколькими элементами одновременно, если ваше приложение поддерживает эту функцию.

Примечание: Контекстное меню не поддерживает ярлыки элементов и значки элементов.

Создайте плавающее контекстное меню.

Чтобы отобразить плавающее контекстное меню, выполните следующие действия:

1. Зарегистрируйте View , с которым связано контекстное меню, вызвав метод registerForContextMenu() и передав ему это View .

   Если в вашем Activity используется RecyclerView , и вы хотите, чтобы каждый элемент предоставлял одно и то же контекстное меню, зарегистрируйте все элементы для контекстного меню, передав RecyclerView в registerForContextMenu() .

2. Реализуйте метод onCreateContextMenu() в вашей Activity или Fragment .

   Когда зарегистрированное представление получает событие касания и удержания, система вызывает ваш метод onCreateContextMenu() . Здесь вы определяете пункты меню, обычно путем создания ресурса меню, как в следующем примере:

   Котлин

       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 позволяет инициализировать контекстное меню из ресурса меню. Параметры метода обратного вызова включают в себя View , которое выбирает пользователь, и объект ContextMenu.ContextMenuInfo , предоставляющий дополнительную информацию о выбранном элементе. Если ваше действие содержит несколько представлений, каждое из которых предоставляет различное контекстное меню, вы можете использовать эти параметры, чтобы определить, какое именно контекстное меню следует инициализировать.

3. Реализуйте onContextItemSelected() , как показано в следующем примере. Когда пользователь выбирает пункт меню, система вызывает этот метод, чтобы вы могли выполнить соответствующее действие.

   Котлин

       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() запрашивает идентификатор выбранного пункта меню, который вы присваиваете каждому пункту меню в XML с помощью атрибута android:id , как показано в разделе «Определение меню в XML» .

   Если пункт меню успешно обработан, верните true . Если пункт меню не обработан, передайте его реализации суперкласса. Если ваша активность содержит фрагменты, активность получает этот коллбэк первой. Вызывая суперкласс при необработанном событии, система передает событие соответствующему методу коллбэка в каждом фрагменте по очереди, в порядке добавления фрагментов, пока не будет возвращено true или false . Реализации по умолчанию для Activity и android.app.Fragment возвращают false , поэтому всегда вызывайте суперкласс при необработанном событии.

Используйте контекстный режим действий.

Контекстный режим действий — это системная реализация режима ActionMode , которая фокусирует взаимодействие пользователя на выполнении контекстных действий. Когда пользователь включает этот режим, выбирая элемент, в верхней части экрана появляется контекстная панель действий , отображающая действия, которые пользователь может выполнить с выбранными элементами. В этом режиме пользователь может выбрать несколько элементов (если ваше приложение поддерживает это) и может отменить выбор элементов, продолжая навигацию внутри активности. Режим действий отключается, и контекстная панель действий исчезает, когда пользователь отменяет выбор всех элементов, нажимает кнопку «Назад» или нажимает кнопку « Готово » в левой части панели.

Для представлений, предоставляющих контекстные действия, режим контекстных действий обычно активируется при возникновении одного или обоих из следующих событий:

• Пользователь нажимает и удерживает палец на изображении.
• Пользователь выбирает флажок или аналогичный элемент пользовательского интерфейса в представлении.

Способ активации контекстного режима действий и определения поведения для каждого действия в вашем приложении зависит от вашего дизайна. Существует два варианта дизайна:

• Для контекстных действий в отношении отдельных, произвольных точек зрения.
• Для пакетных контекстных действий над группами элементов в RecyclerView , позволяющих пользователю выбрать несколько элементов и выполнить действие над всеми ними.

В следующих разделах описывается настройка, необходимая для первого сценария.

Включите режим контекстных действий для отдельных представлений.

Если вы хотите, чтобы режим контекстных действий активировался только тогда, когда пользователь выбирает определенные представления, выполните следующие действия:

1. Реализуйте интерфейс ActionMode.Callback как показано в следующем примере. В его методах обратного вызова вы можете указать действия для контекстной панели действий, реагировать на события клика по элементам действий и обрабатывать другие события жизненного цикла режима действий.

   Котлин

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

   Эти обработчики событий практически идентичны обработчикам событий для меню параметров , за исключением того, что каждый из них также передает объект ActionMode связанный с событием. Вы можете использовать API ActionMode для внесения различных изменений в CAB, например, для изменения заголовка и подзаголовка с помощью setTitle() и setSubtitle() , что полезно для указания количества выбранных элементов.

   В приведенном выше примере переменная actionMode устанавливается в значение null при уничтожении режима действия. На следующем шаге мы рассмотрим, как она инициализируется и как может быть полезно сохранять эту переменную-член в вашей активности или фрагменте.

2. Вызывайте startActionMode() , когда хотите отобразить панель, например, когда пользователь нажимает и удерживает палец на элементе интерфейса.

   Котлин

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

   При вызове startActionMode() система возвращает созданный ActionMode . Сохранив его в переменной-члене, вы можете вносить изменения в контекстную панель действий в ответ на другие события. В приведенном выше примере ActionMode используется для того, чтобы гарантировать, что экземпляр ActionMode не будет создан заново, если он уже активен, путем проверки того, является ли член переменной нулевым перед запуском режима действия.

Создать всплывающее меню

PopupMenu — это модальное меню, привязанное к View . Оно отображается под привязанным элементом View, если есть место, или над ним в противном случае. Оно полезно в следующих случаях:

• Предоставление меню, расширяющего список действий, связанных с конкретным содержимым, например, заголовками писем Gmail, как показано на рисунке 4.
• Указание второй части командной строки, например, кнопки с пометкой « Добавить» , которая вызывает всплывающее меню с различными вариантами добавления .
• Предоставление меню, похожего на Spinner , которое не сохраняет постоянное значение выбранного пункта.

Если вы определяете меню в формате XML , вот как можно отобразить всплывающее меню:

1. Создайте экземпляр класса PopupMenu с конструктором, который принимает текущий Context приложения и View , к которому привязано меню.
2. Используйте MenuInflater для преобразования ресурса меню в объект Menu , возвращаемый методом PopupMenu.getMenu() .
3. Вызовите метод PopupMenu.show() .

Например, вот кнопка, которая отображает всплывающее меню:

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

В этом случае всплывающее меню может выглядеть следующим образом:

findViewById<ImageButton>(R.id.dropdown_menu).setOnClickListener {
    val popup = PopupMenu(this, it)
    val inflater: MenuInflater = popup.menuInflater
    inflater.inflate(R.menu.actions, popup.menu)
    popup.show()
}

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

Меню закрывается, когда пользователь выбирает пункт или нажимает за пределами области меню. Вы можете отслеживать событие закрытия с помощью PopupMenu.OnDismissListener .

Обработка событий клика

Чтобы выполнить действие при выборе пользователем пункта меню, реализуйте интерфейс PopupMenu.OnMenuItemClickListener и зарегистрируйте его в вашем PopupMenu , вызвав setOnMenuItemclickListener() . Когда пользователь выбирает пункт, система вызывает функцию обратного вызова onMenuItemClick() из вашего интерфейса.

Это показано в следующем примере:

fun showMenu(v: View) {
    PopupMenu(this, v).apply {
        // MainActivity implements OnMenuItemClickListener.
        setOnMenuItemClickListener(this@MainActivity)
        inflate(R.menu.actions)
        show()
    }
}

override fun onMenuItemClick(item: MenuItem): Boolean {
    return when (item.itemId) {
        R.id.archive -> {
            archive(item)
            true
        }
        R.id.delete -> {
            delete(item)
            true
        }
        else -> false
    }
}

public void showMenu(View v) {
    PopupMenu popup = new PopupMenu(this, v);

    // This activity implements OnMenuItemClickListener.
    popup.setOnMenuItemClickListener(this);
    popup.inflate(R.menu.actions);
    popup.show();
}

@Override
public boolean onMenuItemClick(MenuItem item) {
    switch (item.getItemId()) {
        case R.id.archive:
            archive(item);
            return true;
        case R.id.delete:
            delete(item);
            return true;
        default:
            return false;
    }
}

Создать группу меню

Группа меню — это набор пунктов меню, обладающих определенными общими характеристиками. С помощью группы можно выполнить следующие действия:

• Показать или скрыть все элементы можно с помощью setGroupVisible() .
• Включайте или отключайте все элементы с помощью setGroupEnabled() .
• Укажите, можно ли отметить все элементы, используя setGroupCheckable() .

Вы можете создать группу, вложив элементы <item> в элемент <group> в ресурсе меню или указав идентификатор группы с помощью метода add() .

Вот пример ресурса меню, который включает в себя группу:

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

Элементы, входящие в группу, отображаются на том же уровне, что и первый элемент — все три элемента меню являются соседними. Однако вы можете изменить характеристики двух элементов в группе, указав идентификатор группы и используя описанные выше методы. Система также никогда не разделяет сгруппированные элементы. Например, если вы объявите android:showAsAction="ifRoom" для каждого элемента, они оба отобразятся в панели действий или оба — в области переполнения действий.

Используйте пункты меню, которые можно отметить галочкой.

Меню может быть полезно в качестве интерфейса для включения и выключения параметров, используя флажки для отдельных параметров или переключатели для групп взаимоисключающих параметров. На рисунке 5 показано подменю с пунктами, которые можно отметить с помощью переключателей.

Вы можете определить поведение выбора для отдельных пунктов меню, используя атрибут android:checkable в элементе <item> , или для всей группы, используя атрибут android:checkableBehavior в элементе <group> . Например, все пункты в этой группе меню можно выбрать с помощью переключателя:

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

Атрибут android:checkableBehavior принимает одно из следующих значений:

single

Из группы можно отметить только один элемент, в результате чего появятся переключатели.

all

Все пункты можно отметить галочкой, в результате чего появятся флажки.

none

Проверить наличие товаров невозможно.

Вы можете установить для элемента состояние "отмечено" по умолчанию, используя атрибут android:checked в элементе <item> , и изменить его в коде с помощью метода setChecked() .

Когда выбирается элемент, который можно отметить, система вызывает соответствующий метод обратного вызова для выбранного элемента, например, onOptionsItemSelected() . Здесь вы устанавливаете состояние флажка, поскольку флажок или переключатель не меняют свое состояние автоматически. Вы можете запросить текущее состояние элемента — каким оно было до того, как пользователь его выбрал — с помощью isChecked() , а затем установить состояние "отмечено" с помощью setChecked() . Это показано в следующем примере:

override fun onOptionsItemSelected(item: MenuItem): Boolean {
    return when (item.itemId) {
        R.id.vibrate, R.id.dont_vibrate -> {
            item.isChecked = !item.isChecked
            true
        }
        else -> super.onOptionsItemSelected(item)
    }
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
        case R.id.vibrate:
        case R.id.dont_vibrate:
            if (item.isChecked()) item.setChecked(false);
            else item.setChecked(true);
            return true;
        default:
            return super.onOptionsItemSelected(item);
    }
}

Если вы не зададите состояние "отмечено" таким образом, то видимое состояние флажка или переключателя не изменится, когда пользователь его выберет. Если же вы зададите состояние, активность сохранит отмеченное состояние элемента, так что когда пользователь откроет меню позже, видимое состояние будет задано вами.

Добавление пунктов меню на основе намерения.

Иногда вам нужно, чтобы пункт меню запускал активность с помощью Intent , будь то активность в вашем приложении или в другом. Если вы знаете, какой Intent хотите использовать, и у вас есть конкретный пункт меню, который его инициирует, вы можете выполнить Intent с помощью startActivity() во время соответствующего метода обратного вызова on-item-selected, например, onOptionsItemSelected() .

Однако, если вы не уверены, что на устройстве пользователя установлено приложение, обрабатывающее ваш интент, добавление пункта меню, вызывающего его, может привести к неработоспособности пункта меню, поскольку интент может не привести к активности. Для решения этой проблемы Android позволяет динамически добавлять пункты меню, когда Android находит на устройстве активности, обрабатывающие ваш интент.

Чтобы добавить пункты меню на основе доступных действий, принимающих Intent, выполните следующие действия:

1. Определите намерение с категорией CATEGORY_ALTERNATIVE или CATEGORY_SELECTED_ALTERNATIVE , или обеими, а также с учетом любых других требований.
2. Вызовите Menu.addIntentOptions() . Затем Android выполнит поиск приложений, способных выполнить указанное намерение, и добавит их в ваше меню.

Если не установлены приложения, соответствующие заданным параметрам, то пункты меню не добавляются.

Это показано в следующем примере:

override fun onCreateOptionsMenu(menu: Menu): Boolean {
    super.onCreateOptionsMenu(menu)

    // Create an Intent that describes the requirements to fulfill, to be
    // included in the menu. The offering app must include a category value
    // of Intent.CATEGORY_ALTERNATIVE.
    val intent = Intent(null, dataUri).apply {
        addCategory(Intent.CATEGORY_ALTERNATIVE)
    }

    // Search and populate the menu with acceptable offering apps.
    menu.addIntentOptions(
            R.id.intent_group,  // Menu group to which new items are added.
            0,                  // Unique item ID (none).
            0,                  // Order for the items (none).
            this.componentName, // The current activity name.
            null,               // Specific items to place first (none).
            intent,             // Intent created above that describes the requirements.
            0,                  // Additional flags to control items (none).
            null)               // Array of MenuItems that correlate to specific items (none).

    return true
}

@Override
public boolean onCreateOptionsMenu(Menu menu){
    super.onCreateOptionsMenu(menu);

    // Create an Intent that describes the requirements to fulfill, to be
    // included in the menu. The offering app must include a category value
    // of Intent.CATEGORY_ALTERNATIVE.
    Intent intent = new Intent(null, dataUri);
    intent.addCategory(Intent.CATEGORY_ALTERNATIVE);

    // Search and populate the menu with acceptable offering apps.
    menu.addIntentOptions(
         R.id.intent_group,         // Menu group to which new items are added.
         0,                         // Unique item ID (none).
         0,                         // Order for the items (none).
         this.getComponentName(),   // The current activity name.
         null,                      // Specific items to place first (none).
         intent,                    // Intent created above that describes the requirements.
         0,                         // Additional flags to control items (none).
         null);                     // Array of MenuItems that correlate to specific items (none).

    return true;
}

Для каждого найденного действия, предоставляющего фильтр намерений, соответствующий определенному намерению, добавляется пункт меню, в котором в качестве заголовка пункта меню используется значение из атрибута android:label фильтра намерений, а в качестве значка пункта меню — значок приложения. Метод addIntentOptions() возвращает количество добавленных пунктов меню.

Разрешите добавление вашей активности в другие меню.

Вы можете предлагать услуги, основанные на вашей активности, другим приложениям, чтобы ваше приложение могло быть включено в меню других приложений — таким образом, роли меняются местами по сравнению с описанными ранее.

Чтобы фильтр намерений отображался в меню других приложений, определите его как обычно, но укажите значения CATEGORY_ALTERNATIVE или CATEGORY_SELECTED_ALTERNATIVE , или оба значения, для категории фильтра намерений. Это показано в следующем примере:

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

Подробнее о написании фильтров намерений можно прочитать в разделе «Намерения и фильтры намерений» .