MENU DE OPCIONES:

Existen varios tipos de menús que podemos manejar en proyectos de Android, que consisten
en una lista de items con formato desplegable y en particular el menú de opciones se
muestra en nuestro ActionBar, habitualmente en la sección derecha de la pantalla con un
icono de 3 puntos verticales. También podemos confgurar para que uno o más items de
nuestro menu se muestra como un “Action Button” que se muestra siempre en la ActionBar o
solamente cuando la misma tenga espacio disponible.

Un menú es un recurso en cuanto un archivo xml, de igual modo que un layout un archivo de
strings, por ello se debe generar un nuevo package (carpeta) dentro de la carpeta “res” de
nuestro proyecto, para almacenar todos los menús que necesitemos para nuestra aplicación.

Para generar un nuevo menú, debemos posicionarnos sobre la carpeta “res” y seleccionar un
nuevo “Android Resource File” y luego en el asistente seleccionar un “Resource Type” = menu.
<menu xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto">
<item android:id="@+id/mnuBuscar"
android:title="@string/menu_buscar"
android:orderInCategory="100"
android:icon="@mipmap/ic_buscar"
app:showAsAction="always"
/>
<item android:id="@+id/mnuTools"
android:title="@string/menu_tools"
android:orderInCategory="101"
android:icon="@mipmap/ic_tools"
/>

<item android:id="@+id/mnuCerrar"
android:title="@string/menu_cerrar"
android:orderInCategory="102"
android:icon="@mipmap/ic_cerrar"
/>
</menu>

Atributos del menú de opciones:

Id: identifca cada ítem del menú y nos permite luego establecer cual fue seleccionado.
Title: etiqueta visible que se muestra al usuario.
Icon: recurso de tipo mipmap, que se muestra cuando se muestra un ítem como Action.
OrderInCategory: establece orden dentro de lista del menu.
ShowAsAction: determina si un ítem, sera mostrado en forma independiente del menú en el
ActionBar. Puede tomar los valores: Always (siempre), ifRoom (solo si hay espacio disponible) y
Never (nunca se muestra en forma independiente).

Para implementar adecuadamente un “menú de opción” asociado a una activity, se deben

implementar (sobreescribir) los métodos:

• onCreateOptionsMenu()
• onOptionsItemSelected()

onCreateOptionsMenu():

Este método permite establecer el archivo de menú (XML) previamente defnido, que se usará
para mostrar el menú de opciones de nuestro activity. Se utiliza un objeto “MenuInfater”, para
infar o inyectar el menú en nuestro layout principal :

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

onOptionsItemSelected:

Método que permite capturar la selección de un ítem realizada por el usuario y dispara la
respuesta correspondiente a dicha selección.
 @Override
public boolean onOptionsItemSelected(MenuItem item) {

switch (item.getItemId()){
case R.id.mnuBuscar:
Toast.makeText(MainActivity.this,"Seleccione Buscar",Toast.LENGTH_SHORT).show();
return true;
case R.id.mnuTools:
Toast.makeText(MainActivity.this,"Seleccione Tools",Toast.LENGTH_SHORT).show();
return true;
case R.id.mnuCerrar:
finish();
return true;
default:
return super.onOptionsItemSelected(item);
}
}

Botones de Acción:

Podemos indicar que un ítem del menú se muestre fuera del mismo como, en una ubicación
anexa al menú y con las mismas posibilidades de respuesta de un ítem normal del menú.
Se utiliza la propiedad “showAsAction” con los siguientes valores posibles:
Never: nunca mostrar el ítem como Action.
Always: siempre mostrar el ítem como Action en la ActionBar.
ifRoom: solamente mostrar el ítem como Action si hay espacio disponible en la ActionBar.

MENU DE CONTEXTO:

Este tipo de menú, se muestra cuando mantenemos presionada la pantalla del dispositivo,
sobre un view (control) en particular, permitiéndonos implementar opciones especifcas para
el mismo a diferencia del menú de opciones que es general para la actividad en curso. Se
permite uno solo por activity y es posible asociarlo a layout principal de la actividad.

En forma paralela a lo observado en el caso del menú de opciones, ahora en el menú

contextual se deben implementar (sobreescribir) los métodos:

• onCreateContextMenu()
• onContextItemSelected()

En el método “onCreateContextMenu”, utilizaremos un objeto MenuInfater, para incluir el

archivo xml con el diseño del menu.
En el método “onContextItemSelected” se debe implementar la lógica que permita ejecutar
una acción al momento que el usuario seleccione un item del menu contextual.

Por ultimo para asociar el view que debe desplegar el menú contextual, en el método
“onCreate” de la actividad, se debe ejecutar el método “registerForContextMenu”, pasandole
como parámetro el view que debe mostrar el menú contextual.
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

ImageView imgAvatar = (ImageView) findViewById(R.id.imgAvatar);

//habilitamos soporte para menu contextual
registerForContextMenu(imgAvatar);

MENU EMERGENTE o POPUP:

Este tipo de mena se puede asociar a distintos views (controles) de nuestra actividad de modo
que podemos tener varios. La elaboración del recurso de diseño (xml) es la misma que en los
2 casos anteriores, solo cambia la forma en son llamados.
Para asociar un menú emergente a un control, en primer lugar debemos defnir un método
publico que se ocupe de infar el recurso de diseño del mismo y defnimos en su interior un
método onMenuItemClick para capturar la selección del usuario y ejecutar nuestras acciones
personalizadas:

public void mostrarPopup(View v){

ImageView imgAvatar = (ImageView) findViewById(R.id.imgAvatar);
PopupMenu popupMenu = new PopupMenu(this, imgAvatar);
popupMenu.getMenuInflater().inflate(R.menu.menu_popup,popupMenu.getMenu());

//metodo de escucha para evento click del menu popup

popupMenu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
@Override
public boolean onMenuItemClick(MenuItem item) {

switch (item.getItemId()){
case R.id.mnuImagen:
Toast.makeText(MainActivity.this,"Ver Imagen!!",Toast.LENGTH_SHORT).show();
break;
case R.id.mnuDetalleImagen:
Toast.makeText(MainActivity.this,"Ver Detalle
Imagen!!",Toast.LENGTH_SHORT).show();
break;
}
return true;
}
});

//mostramos el menu
popupMenu.show();
}

Luego en el control que nos interesa que se ejecute este menú emergente, desde el recurso
de diseño debemos defnir el atributo onClick, asignandole el método que creamos.

Material Adicional:
https://developer.android.com/guide/topics/ui/menus.html

Proyecto en GitHub:
https://github.com/federicotrani/MenuOpcionItes