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.
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".
![Una imagen que muestra la barra de la app de Hojas de cálculo de Google](https://developer.android.google.cn/static/images/training/appbar/appbar_sheets_2x.png?authuser=9&hl=es)
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.
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()
.
Crea un menú contextual
![Una imagen que muestra un menú contextual flotante](https://developer.android.google.cn/static/develop/ui/views/images/context_menu_no_icons.png?authuser=9&hl=es)
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:
- Registra el
View
con el que está asociado el menú contextual llamandoregisterForContextMenu()
y pásale elView
.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 elementoRecyclerView
alregisterForContextMenu()
- Implementa el
onCreateContextMenu()
en tuActivity
oFragment
.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 elView
que el usuario selecciona y unContextMenu.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. 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 atributoandroid: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, hastatrue
o Se muestrafalse
. Las implementaciones predeterminadas Devolución deActivity
yandroid.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
.
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:
- 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 deActionMode
para realizar varios cambios en la CAB, como revisar el título y el subtítulo consetTitle()
ysetSubtitle()
, que es útil para indicar cuántos elementos están seleccionados.En el ejemplo anterior, se establece la variable
actionMode
ennull
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. - 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 usaActionMode
para garantizar que La instanciaActionMode
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
![Una imagen que muestra un menú emergente en la app de Gmail, anclado al botón de menú ampliado en la esquina superior derecha.](https://developer.android.google.cn/static/images/ui/popupmenu.png?authuser=9&hl=es)
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.
- 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:
- Crea una instancia de
PopupMenu
con su constructor, que toma la app actualContext
y lasView
a la que se ancla el menú. - Usa
MenuInflater
para aumentar el recurso de menú en laMenu
objeto devuelto porPopupMenu.getMenu()
- 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
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.
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.
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:
- Cómo definir un intent con la categoría
CATEGORY_ALTERNATIVE
oCATEGORY_SELECTED_ALTERNATIVE
, o ambos, además de cualquier otro requisito. - 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.
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.
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.