Agregar menús

Prueba el método de Compose

Jetpack Compose es el kit de herramientas de IU recomendado para Android. Aprende a agregar componentes en Compose.

TopAppBar →

Los menús son un componente común de la interfaz de usuario en muchos tipos de apps. Para para brindar una experiencia del usuario familiar y coherente, Menu de APIs para presenta acciones de los usuarios y otras opciones en tus actividades.

Nota: Para obtener una mejor experiencia del usuario, consulta Material Design Menús

Figura 1: Un menú que se activa al presionar un ícono que aparece debajo del ícono del menú ampliado.

Este documento muestra cómo crear tres tipos fundamentales de menús o presentaciones de acciones en todas las versiones de Android:

Menú de opciones y barra de la app

El menú de opciones es la colección principal de elementos de un menú de una actividad. Es donde ubicas las acciones que tienen un impacto global en app, como "Buscar", "Redactar correo" y "Configuración".

Consulta el menú para crear opciones sección.

Menú contextual y modo de acción contextual

Un menú contextual es un menú flotante que aparece cuando el usuario toca y en un elemento. Integra proporciona acciones que afectan el contenido o el marco contextual seleccionados.

El modo de acción contextual muestra elementos de acción que afectará el contenido seleccionado en una barra en la parte superior de la pantalla y permite que la usuario selecciona varios elementos.

Consulta Cómo crear un menú contextual sección.

Menú emergente

Un menú emergente muestra una lista vertical de elementos anclados al que invoca el menú. Es una buena forma de proporcionar un exceso de acciones que se relacionen con contenido específico o que brinden opciones para la segunda parte de un comando. Las acciones de un menú emergente no afectan directamente el contenido correspondiente, para eso están las acciones contextuales. Más bien, el menú emergente es para acciones extendidas relacionadas con partes del contenido en tu actividad.

Consulta la sección Crea un menú emergente.

Cómo definir un menú en XML

Para todos los tipos de menús, Android proporciona un formato XML estándar para definir menús elementos. En lugar de crear un menú en el código de tu actividad, define un menú y todos los elementos en un archivo recurso de menú. Puedes Luego, aumenta el recurso de menú, cárgalo como Menu. objeto, en tu actividad o fragmento.

El uso de un recurso de menú es una práctica recomendada por las siguientes razones:

• Es más fácil visualizar la estructura del menú en XML.
• Separa el contenido del menú del comportamiento de la app código.
• Permite crear configuraciones de menú alternativas para diferentes plataformas. tamaños de pantalla y otros parámetros de configuración aprovechando el recursos de la app en un framework de aplicaciones.

Para definir un menú, crea un archivo XML dentro del res/menu/ y compila el menú con lo siguiente elementos:

<menu>

Define un Menu, que es un contenedor para elementos de menú. R El elemento <menu> debe ser el nodo raíz del archivo, y puede contener uno o más <item> y <group> o de terceros.

<item>

Crea un MenuItem, que representa un único elemento en un menú. Este elemento puede contener un valor anidado <menu> para crear un submenú.

<group>

Un contenedor opcional e invisible para <item> o de terceros. Te permite categorizar los elementos del menú para que compartan propiedades, como como estado activo y visibilidad. Para obtener más información, consulta la Sección Crea un grupo del menú.

Aquí presentamos un menú de ejemplo denominado 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>

El elemento <item> admite varios atributos que puedes usar para definir la apariencia y el comportamiento de un elemento. Los elementos del menú anterior incluyen los siguientes atributos:

android:id

Un ID de recurso que es único para el elemento y le permite a la app reconocer el elemento cuando el usuario la selecciona.

android:icon

Es la referencia a un elemento de diseño para usar como el ícono del elemento.

android:title

Es la referencia a una string para usar como el título del elemento.

android:showAsAction

La especificación sobre cuándo y cómo aparece este elemento como un elemento de acción en la barra de la aplicación.

Estos son los atributos más importantes que usas, pero hay muchos más disponibles. Para obtener información sobre todos los atributos admitidos, consulta la Recurso de menú en la documentación de Google Cloud.

Puedes agregar un submenú a un elemento en cualquier menú agregando una <menu> como elemento secundario de un <item>. Los submenús son útiles cuando la app tiene muchas funciones que se pueden organizar por temas, como elementos en la barra de menú de una app para PC, como Archivo, Editar y Ver. Observa el siguiente ejemplo:

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

Para usar el menú en tu actividad, _aumenta_ el recurso de menú y convierte el recurso XML en un objeto programable usando MenuInflater.inflate() En las siguientes secciones, se muestra cómo aumentar un menú para cada tipo de menú.

Crea un menú de opciones

El menú de opciones, como el que se muestra en la figura 1, es donde incluyes acciones y otras opciones relevantes para el contexto de la actividad actual como "Buscar", "Redactar correo" y "Configuración".

Figura 2: La app de Hojas de cálculo de Google, que muestra varios botones, incluido el botón de ampliación de acciones.

Puedes declarar elementos para el menú de opciones desde tu Activity subclase o una Fragment subclase. Si tanto tu actividad como tus fragmentos declaran elementos para el el menú de opciones, los elementos se combinan en la IU. Aparecerán los elementos de la actividad y, luego, las de cada fragmento, en el orden en que a la actividad. Si es necesario, puedes reordenar los elementos del menú con el atributo android:orderInCategory en cada <item> debes moverte.

Para especificar el menú de opciones de una actividad, anula onCreateOptionsMenu() Los fragmentos proporcionan sus propios onCreateOptionsMenu() devolución de llamada. En este método, puedes aumentar el recurso de menú, definidas en XML, en el Menu proporcionado en la devolución de llamada. Esto se muestra en el siguiente ejemplo:

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

También puedes agregar elementos de menú con add() y recuperar elementos con findItem() para revisar sus propiedades con las APIs de MenuItem.

Cómo controlar eventos de clic

Cuando el usuario selecciona un elemento del menú de opciones, incluidos los elementos de acción en la barra de la aplicación, el sistema llama al onOptionsItemSelected() . Este método pasa el MenuItem seleccionado. Puedes identificar llamando al elemento getItemId(), que devuelve el ID único para el elemento de menú, definido por el Atributo android:id en el recurso de menú o con un número entero determinado al método add(). Puedes hacer coincidir este ID con el menú conocido elementos para realizar la acción adecuada.

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

Cuando controles correctamente un elemento de menú, muestra true. Si no controlas el elemento de menú, llama a la implementación de la superclase de onOptionsItemSelected() La implementación predeterminada devuelve false.

Si tu actividad incluye fragmentos, el sistema primero llama onOptionsItemSelected() para la actividad y, luego, para cada fragmento en el orden en que se agregan los fragmentos, hasta que uno muestre true o se llama a todos los fragmentos.

Sugerencia: Si la app contiene varias actividades y algunas de ellas el mismo menú de opciones, considera crear una actividad que implementa solo los objetos onCreateOptionsMenu() y onOptionsItemSelected(). Luego, extiende esta clase por cada actividad que comparte el mismo menú de opciones. Así, podrás administrar un conjunto de código para controlar las acciones del menú, y cada clase subordinada los comportamientos del menú. Si quieres agregar elementos de menú a una de las actividades subordinadas, anula >onCreateOptionsMenu() en ese actividad. Llama a super.onCreateOptionsMenu(menu) para que el original se crean elementos del menú y, luego, agrega nuevos elementos de menú con menu.add() También puedes anular el comportamiento de la superclase para elementos de menú individuales.

Cambia los elementos del menú en el tiempo de ejecución

Después de que el sistema llama a onCreateOptionsMenu(), retiene un de la Menu que propagas y no llama onCreateOptionsMenu() de nuevo, a menos que se invalide el menú. Sin embargo, usa onCreateOptionsMenu() solo para crear el menú inicial. y no hacer cambios durante el ciclo de vida de la actividad.

Si deseas modificar el menú de opciones en función de los eventos que ocurran durante la del ciclo de vida de la actividad, onPrepareOptionsMenu() . Este método te pasa el objeto Menu como está actualmente existe para que puedas modificarlo, por ejemplo, agregando, quitando o inhabilitando elementos. Los fragmentos también proporcionan un onPrepareOptionsMenu() devolución de llamada.

El menú de opciones se considera que está siempre abierto cuando se presentan los elementos del menú la barra de la aplicación. Cuando ocurra un evento y desees actualizar el menú, llama invalidateOptionsMenu() para solicitar que el sistema llame a onPrepareOptionsMenu().

Nota: Nunca cambies los elementos del menú de opciones según el View en foco. En el modo táctil, cuando el usuario no está usando una bola de seguimiento o Pad direccional: las vistas no pueden enfocarse, así que nunca lo usen como base para modificar elementos en el menú de opciones. Si deseas proporcionar elementos de menú que son sensibles al contexto de un View, usa un menú contextual como que se describe en la siguiente sección.

Crea un menú contextual

Figura 3: Un menú contextual flotante.

Un menú contextual ofrece acciones que afectan un elemento o contexto específico marco en la IU. Puedes proporcionar un menú contextual para cualquier vista, pero a menudo se usan para elementos en un RecylerView o otras colecciones de vistas en las que el usuario puede realizar acciones directas sobre cada una elemento.

Existen dos maneras de proporcionar acciones contextuales:

• En un menú contextual flotante. Un menú aparece como una lista flotante de elementos de menú, similar a un diálogo, cuando el usuario realiza un toque y retener una vista que declara compatibilidad con un contexto . Los usuarios pueden realizar una acción contextual en un elemento por vez.
• En el modo de acción contextual. Este modo es un sistema implementación de ActionMode que muestre una barra de acciones contextuales, o CAB, en la parte superior de la pantalla con elementos de acción que afectan a los elementos seleccionados. Cuando este modo está activa, los usuarios pueden realizar una acción en varios elementos a la vez, si tu la aplicación es compatible.

Nota: El menú contextual no admite accesos directos de elementos ni íconos de elementos.

Cómo crear un menú contextual flotante

Para proporcionar un menú contextual flotante, haz lo siguiente:

1. Registra el View con el que está asociado el menú contextual llamando registerForContextMenu() y pásale el View.

   Si tu actividad usa un RecyclerView y quieres que cada uno elemento para proporcionar el mismo menú contextual, registra todos los elementos para un contexto menú pasando el elemento RecyclerView al registerForContextMenu()

2. Implementa el onCreateContextMenu() en tu Activity o Fragment.

   Cuando la vista registrada recibe un toque y evento de espera, el sistema llama tu método onCreateContextMenu() Aquí es donde defines los elementos del menú, por lo general, aumentando un recurso de menú, como en el siguiente ejemplo:

   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 te permite aumentar el menú contextual de un recurso de menú. El método de devolución de llamada Los parámetros incluyen el View que el usuario selecciona y un ContextMenu.ContextMenuInfo que proporciona información adicional sobre el elemento seleccionado. Si tu actividad tiene varias vistas, cada una de las cuales proporciona un menú contextual diferente, puedes usar estos parámetros para determinar qué menú contextual inflar.

3. Implementación onContextItemSelected(), como se muestra en el siguiente ejemplo. Cuando el usuario selecciona un elemento del menú, el sistema llama a este método para que puedas realizar la acción apropiada.

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

   El getItemId() método consulta el ID del elemento de menú seleccionado, que asignas a cada elemento de menú en XML usando el atributo android:id, como se muestra en Define un menú en XML.

   Cuando controles correctamente un elemento de menú, muestra true. Si no manejas el elemento de menú, pásalo a la superclase para implementarlos. Si tu actividad incluye fragmentos, esta recibe esta devolución de llamada primero. Cuando se llama a la superclase cuando no se controla, el sistema pasa el evento al método de devolución de llamada correspondiente en cada fragmento, uno en una hora, en el orden en que se agrega cada fragmento, hasta true o Se muestra false. Las implementaciones predeterminadas Devolución de Activity y android.app.Fragment false, por lo que siempre debes llamar a la superclase cuando no esté controlada.

Cómo usar el modo de acción contextual

El modo de acción contextual es una implementación del sistema de ActionMode que enfoque la interacción del usuario en el rendimiento acciones contextuales. Cuando un usuario habilita este modo seleccionando un elemento, se barra de acciones contextuales en la parte superior de la pantalla para presentar acciones que el usuario puede realizar en los elementos seleccionados. Mientras este modo esté habilitado, el usuario puede seleccionar varios elementos, si tu app lo admite, y puede anular la selección y seguir navegando dentro de la actividad. El modo de acción está inhabilitado y la barra de acciones contextuales desaparece cuando el usuario anula la selección de todos los elementos, presiona el botón Atrás o presiona la acción Listo del lado izquierdo de .

Nota: La barra de acciones contextuales no está necesariamente asociada con la barra de la aplicación. Funcionan de forma independiente, aunque la barra de acciones contextuales ocupa visualmente la posición de la barra de la aplicación.

En el caso de las vistas que proporcionan acciones contextuales, por lo general, se invocan las vistas el modo de acción cuando ocurre uno o ambos de estos dos eventos:

• El usuario realiza un toque y mantener la vista.
• El usuario selecciona una casilla de verificación o un componente similar de la IU en la vista.

La manera en que tu app invoca el modo de acción contextual y define la el comportamiento de cada acción depende de tu diseño. Hay dos diseños:

• Para acciones contextuales en vistas individuales arbitrarias
• Para acciones contextuales por lotes sobre grupos de elementos en una RecyclerView, lo que le permite al usuario seleccionar varios elementos y realizar una acción en todos ellos.

Las siguientes secciones describen la configuración necesaria para cada escenario.

Habilitar el modo de acción contextual para vistas individuales

Si deseas invocar el modo de acción contextual solo cuando el usuario selecciona vistas específicas, haz lo siguiente:

1. Implementa la interfaz ActionMode.Callback como se muestra en el siguiente ejemplo. En sus métodos de devolución de llamada, puedes especificar las acciones para la barra de acciones contextuales, responder a eventos de clic en elementos de acción y otros eventos de ciclo de vida para el modo de acción.

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

   Estas devoluciones de llamada de eventos son casi exactamente las mismas que las devoluciones de llamada para el menú de opciones, con la excepción de que cada una También pasa el objeto ActionMode asociado con el evento. Puedes usar las APIs de ActionMode para realizar varios cambios en la CAB, como revisar el título y el subtítulo con setTitle() y setSubtitle(), que es útil para indicar cuántos elementos están seleccionados.

   En el ejemplo anterior, se establece la variable actionMode en null cuando se destruye el modo de acción. En el siguiente paso, consulta cómo se inicializa y cómo guardar la variable de miembro en tu actividad o puede ser útil.

2. Llamada startActionMode() cuándo quieres mostrar la barra, como cuando el usuario toca y mantener la vista.

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

   Cuando llamas a startActionMode(), el sistema muestra Se creó ActionMode. Si guardas esto en una variable de miembro, puede realizar cambios en la barra de acciones contextuales en respuesta a otros eventos. En el ejemplo anterior, se usa ActionMode para garantizar que La instancia ActionMode no se vuelve a crear si ya se encontró activo, verificando si el miembro es nulo antes de iniciar la acción .

Cómo crear un menú emergente

Figura 4: Un menú emergente en la app de Gmail anclada al botón de menú ampliado en la esquina superior derecha.

Un PopupMenu es un menú modal anclado a una View. Aparece debajo del ancla vista si hay espacio o, de lo contrario, sobre ella. Es útil para lo siguiente:

• Proporcionar un menú de estilo ampliado para las acciones que se relacionan con contenido específico, como los encabezados de correo electrónico de Gmail, que se muestran en la Figura 4.
  Nota: No es lo mismo que un menú contextual. que, por lo general, se usa para acciones que afectan al contenido seleccionado. Para las acciones que afectan el contenido seleccionado, usa el modo de acción contextual o menú contextual flotante.
• Proporcionar la segunda parte de una oración de comandos, como un botón marcado Add, que genera un menú emergente con diferentes Add opciones de estado.
• Ofrecer un menú similar a un Spinner que no retiene una selección persistente.

Si defines el menú en XML, puedes mostrar lo siguiente: el menú emergente:

1. Crea una instancia de PopupMenu con su constructor, que toma la app actual Context y las View a la que se ancla el menú.
2. Usa MenuInflater para aumentar el recurso de menú en la Menu objeto devuelto por PopupMenu.getMenu()
3. Llamar a PopupMenu.show()

Por ejemplo, aquí hay un botón que muestra un menú emergente:

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

La actividad puede mostrar el menú emergente de la siguiente manera:

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

El menú se descarta cuando el usuario selecciona un elemento o presiona fuera del menú en una sola área de almacenamiento en etapa intermedia. Puedes escuchar el evento de descarte con PopupMenu.OnDismissListener

Cómo controlar eventos de clic

Para realizar una acción cuando el usuario selecciona un elemento de menú, implementa PopupMenu.OnMenuItemClickListener y regístrala con tu PopupMenu llamando a setOnMenuItemclickListener() Cuando el usuario selecciona un elemento, el sistema llama al onMenuItemClick() en la interfaz.

Esto se muestra en el siguiente ejemplo:

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

Crea un grupo del menú

Un grupo de menú es una colección de elementos de menú que comparten ciertas características. Con un en un grupo, puedes hacer lo siguiente:

• Mostrar u ocultar todos los elementos con setGroupVisible()
• Habilitar o inhabilitar todos los elementos con setGroupEnabled()
• Especifica si todos los elementos se pueden marcar con setGroupCheckable()

Puedes crear un grupo anidando elementos <item> en su interior. un elemento <group> en el recurso de menú o especificando una el ID del grupo add() .

Este es un ejemplo de un recurso de menú que incluye un grupo:

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

Los elementos que están en el grupo aparecen en el mismo nivel que los primeros los tres elementos del menú son elementos del mismo nivel. Sin embargo, puedes modificar los rasgos de los dos elementos del grupo haciendo referencia al ID del grupo y usando con los métodos anteriores. El sistema nunca separa los elementos agrupados. Para Por ejemplo, si declaras android:showAsAction="ifRoom" para cada ambos aparecen en la barra de acciones o en la acción desbordamiento.

Usar elementos del menú que se pueden activar

Figura 5: Un submenú con elementos que se pueden marcar.

Un menú puede ser una interfaz útil para activar y desactivar opciones, mediante una casilla de verificación para opciones independientes o botones de selección para grupos de opciones exclusivas. En la figura 5, se muestra un submenú con elementos que se pueden activar botones de selección.

Nota: Los elementos del menú de opciones no pueden mostrar casillas de verificación ni botón de selección. Si permites que se marquen los elementos de un menú de opciones, indicar el estado activado intercambiando el ícono o el texto, o ambos, cada vez cambia el estado.

Puedes definir el comportamiento de activación para elementos individuales del menú con el Atributo android:checkable en <item> o para un grupo completo con el elemento android:checkableBehavior en el elemento <group>. Por ejemplo, todos los elementos de este grupo de menús se pueden activar con un botón de selección:

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

El atributo android:checkableBehavior acepta uno de los siguientes lo siguiente:

single

Solo un elemento del grupo se puede marcar, lo que provoca una radio botones.

all

Se pueden marcar todos los elementos, lo que genera casillas de verificación.

none

No se puede marcar ningún elemento.

Puedes aplicar un estado activado predeterminado a un elemento usando el Atributo android:checked en el elemento <item> y cambiarla en el código con el setChecked() .

Cuando se selecciona un elemento que se puede activar, el sistema llama a tu Es el método de devolución de llamada que selecciona el elemento, como onOptionsItemSelected(). Aquí es donde estableces el estado de la casilla de verificación, porque una casilla de verificación o no cambia su estado automáticamente. Puedes consultar el estado actual del elemento, como estaba antes de que el usuario lo seleccionara, con isChecked() y, luego, establece el estado activado con setChecked(). Esto se muestra en el siguiente ejemplo:

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

Si no estableces el estado activado de esta manera, el estado visible de la la casilla de verificación o el botón de selección no cambia cuando el usuario lo selecciona. Cuando lo hagas establece el estado, la actividad preserva el estado activado del elemento para que Cuando el usuario abra el menú más tarde, el estado activado que establezcas será sean visibles.

Nota: Los elementos del menú que se pueden activar están diseñados para usarse solo en un por sesión y no se guardan después de la destrucción de la app. Si tienes parámetros de configuración de la app que quieres guardar para el usuario, datos con almacenamiento compartido.

Agrega elementos de menú en función de un intent

A veces, deseas que un elemento de menú inicie una actividad con un Intent, ya sea una actividad en tu app u otra app. Cuando conoces el intent que quieres usar y tienes un elemento de menú específico que se inicia el intent, puedes ejecutarlo con startActivity() durante el método de devolución de llamada correspondiente en el elemento seleccionado, como la Devolución de llamada onOptionsItemSelected().

Sin embargo, si no estás seguro de que el dispositivo del usuario contenga una app que controla el intent, agregar un elemento de menú que lo invoque puede generar una un elemento de menú que no funciona, ya que el intent podría no resolverse en una actividad. Para solucionar esto, Android te permite agregar dinámicamente elementos del menú al menú cuando Android encuentra actividades en el dispositivo que controlan tu intent.

Para agregar elementos de menú basados en actividades disponibles que aceptan un intent, haz lo siguiente: lo siguiente:

1. Cómo definir un intent con la categoría CATEGORY_ALTERNATIVE o CATEGORY_SELECTED_ALTERNATIVE, o ambos, además de cualquier otro requisito.
2. Llamada Menu.addIntentOptions() Android busca las apps que puedan realizar el intent los agregará a tu menú.

Si no hay apps instaladas que satisfagan el intent, no aparece ningún menú se agregan elementos.

Nota: CATEGORY_SELECTED_ALTERNATIVE se usa para controlar el elemento seleccionado en la pantalla. Úsalo solo cuando crees un menú en onCreateContextMenu()

Esto se muestra en el siguiente ejemplo:

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

Para cada actividad encontrada que proporcione un filtro de intents que coincida con el intent definido, se agrega un elemento de menú, con el valor en la capa android:label como título del elemento de menú y el ícono de la app como menú ícono del elemento. El método addIntentOptions() devuelve la cantidad de elementos de menú agregados.

Nota: Cuando llamas a addIntentOptions(), se anula. todos los elementos de menú del grupo de menús especificado en el primer argumento.

Permite que tu actividad se agregue a otros menús

Puedes ofrecer los servicios de tu actividad a otras apps para que tu app pueda incluido en el menú de los demás, revirtiendo los roles que se describieron anteriormente.

Para que se incluya en los menús de otras apps, define un filtro de intents como de costumbre. pero incluye los elementos CATEGORY_ALTERNATIVE o Valores CATEGORY_SELECTED_ALTERNATIVE, o ambos, para el intent categoría de filtro. Esto se muestra en el siguiente ejemplo:

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

Obtén más información sobre cómo escribir filtros de intents en Intents e intents filtros.