Inicio Android Menús en Android (I): Conceptos básicos

Menús en Android (I): Conceptos básicos

por sgoliver

En los dos siguientes artículos del Curso de Programación Android nos vamos a centrar en la creación de menús de opciones en sus diferentes variantes.

NOTA IMPORTANTE: A partir de la versión 3 de Android los menús han caido en desuso debido a la aparición de la Action Bar. De hecho, si compilas tu aplicación con un target igual o superior a la API 11 (Android 3.0) verás como los menús que definas aparecen, no en su lugar habitual en la parte inferior de la pantalla, sino en el menú desplegable de la action bar en la parte superior derecha. Por todo esto, lo que leerás en este artículo sobre menús y submenús aplica tan sólo a aplicaciones realizadas para Android 2.x o inferior. Si quieres conocer más detalles sobre la action bar tienes dos artículos dedicados a ello en el índice del curso. De cualquier forma, este artículo sigue siendo útil ya que la forma de trabajar con la action bar se basa en la API de menús y en los recursos que comentaremos en este texto.

En Android podemos encontrar 3 tipos diferentes de menús:

  • Menús Principales. Los más habituales, aparecen en la zona inferior de la pantalla al pulsar el botón ‘menu’ del teléfono.
  • Submenús. Son menús secundarios que se pueden mostrar al pulsar sobre una opción de un menú principal.
  • Menús Contextuales. Útiles en muchas ocasiones, aparecen al realizar una pulsación larga sobre algún elemento de la pantalla.

En este primer artículo sobre el tema veremos cómo trabajar con los dos primeros tipos de menús. En el siguiente, comentaremos los menús contextuales y algunos características más avanzadas.

Como casi siempre, vamos a tener dos alternativas a la hora de mostrar un menú en nuestra aplicación Android. La primera de ellas mediante la definición del menú en un fichero XML, y la segunda creando el menú directamente mediante código. En este artículo veremos ambas alternativas.

Veamos en primer lugar cómo crear un menú a partir de su definición en XML. Los ficheros XML de menú se deben colocar en la carpeta «res\menu» de nuestro proyecto y tendrán una estructura análoga a la del siguiente ejemplo (si hemos creado el proyecto con una versión reciente del plugin de Android para Eclipse es posible que ya tengamos un menú por defecto creado en esta carpeta, por lo que simplemente tendremos que modificarlo):

<menu xmlns:android="http://schemas.android.com/apk/res/android" >
	<item android:id="@+id/MnuOpc1" android:title="Opcion1"
	      android:icon="@android:drawable/ic_menu_preferences"></item>
	<item android:id="@+id/MnuOpc2" android:title="Opcion2"
	      android:icon="@android:drawable/ic_menu_compass"></item>
	<item android:id="@+id/MnuOpc3" android:title="Opcion3"
	      android:icon="@android:drawable/ic_menu_agenda"></item>
</menu>

Como vemos, la estructura básica de estos ficheros es muy sencilla. Tendremos un elemento principal <menu> que contendrá una serie de elementos <item> que se corresponderán con las distintas opciones a mostrar en el menú. Estos elementos <item> tendrán a su vez varias propiedades básicas, como su ID (android:id), su texto (android:title) o su icono (android:icon). Los iconos utilizados deberán estar por supuesto en las carpetas «res\drawable-…» de nuestro proyecto (al final del artículo os paso unos enlaces donde podéis conseguir algunos iconos de menú Android gratuitos) o bien utilizar alguno de los que ya vienen «de fábrica» con la plataforma Android. En nuestro caso de ejemplo he utilizado esta segunda opción, por lo que haremos referencia a los recursos con el prefijo «@android:drawable/…«. Si quisiéramos utilizar un recurso propio escribiríamos directamente «@drawable/…» seguido del nombre del recurso.

Una vez definido el menú en el fichero XML, tendremos que implementar el evento onCreateOptionsMenu() de la actividad que queremos que lo muestre (esto también es posible que lo tengamos ya incluido por defecto en nuestra actividad principal). En este evento deberemos «inflar» el menú de forma parecida a cómo ya hemos hecho otras veces con otro tipo de layouts. Primero obtendremos una referencia al inflater mediante el método getMenuInflater() y posteriormente generaremos la estructura del menú llamando a su método infate() pasándole como parámetro el ID del menu definido en XML, que mi nuestro caso será R.menu.activity_main. Por último devolveremos el valor true para confirmar que debe mostrarse el menú.

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    //Alternativa 1
    getMenuInflater().inflate(R.menu.activity_main, menu);
    return true;
}

Y ya hemos terminado, con estos sencillos pasos nuestra aplicación ya debería mostrar sin problemas el menú que hemos construído, aunque todavía nos faltaría implementar la funcionalidad de cada una de las opciones mostradas.

android-menus1

Como hemos comentado antes, este mismo menú también lo podríamos crear directamente mediante código, también desde el evento onCreateOptionsMenu(). Para ello, para añadir cada opción del menú podemos utilizar el método add() sobre el objeto de tipo Menu que nos llega como parámetro del evento. Este método recibe 4 parámetros: ID del grupo asociado a la opción (veremos qué es esto en un próximo artículo, por ahora utilizaremos Menu.NONE), un ID único para la opción (que declararemos como constantes de la clase), el orden de la opción (que no nos interesa por ahora, utilizaremos Menu.NONE) y el texto de la opción. Por otra parte, el icono de cada opción lo estableceremos mediante el método setIcon() pasándole el ID del recurso. Veamos cómo quedaría el código utilizando esta alternativa, que generaría un menú exactamente igual al del ejemplo anterior:

private static final int MNU_OPC1 = 1;
private static final int MNU_OPC2 = 2;
private static final int MNU_OPC3 = 3;

//...

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    //Alternativa 2
    menu.add(Menu.NONE, MNU_OPC1, Menu.NONE, "Opcion1")
      		.setIcon(android.R.drawable.ic_menu_preferences);
    menu.add(Menu.NONE, MNU_OPC2, Menu.NONE, "Opcion2")
       		.setIcon(android.R.drawable.ic_menu_compass);
    menu.add(Menu.NONE, MNU_OPC3, Menu.NONE, "Opcion3")
       		.setIcon(android.R.drawable.ic_menu_agenda);
    return true;
}

Construido el menú, la implementación de cada una de las opciones se incluirá en el evento onOptionsItemSelected() de la actividad que mostrará el menú. Este evento recibe como parámetro el item de menú que ha sido pulsado por el usuario, cuyo ID podemos recuperar con el método getItemId(). Según este ID podremos saber qué opción ha sido pulsada y ejecutar unas acciones u otras. En nuestro caso de ejemplo, lo único que haremos será modificar el texto de una etiqueta (lblMensaje) colocada en la pantalla principal de la aplicación.

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
        case R.id.MnuOpc1:
            lblMensaje.setText("Opcion 1 pulsada!");
            return true;
        case R.id.MnuOpc2:
            lblMensaje.setText("Opcion 2 pulsada!");;
            return true;
        case R.id.MnuOpc3:
            lblMensaje.setText("Opcion 3 pulsada!");;
            return true;
        default:
            return super.onOptionsItemSelected(item);
    }
}

Ojo, el código anterior sería válido para el menú creado mediante XML. Si hubiéramos utilizado la implementación por código tendríamos que sustituir las constantes R.id.MnuOpc_ por nuestras constantes MNU_OPC_.

Con esto, hemos conseguido ya un menú completamente funcional. Si ejecutamos el proyecto en el emulador comprobaremos cómo al pulsar el botón de ‘menu‘ del teléfono aparece el menú que hemos definido y que al pulsar cada opción se muestra el mensaje de ejemplo.

Pasemos ahora a comentar los submenús. Un submenú no es más que un menú secundario que se muestra al pulsar una opción determinada de un menú principal. Los submenús en Android se muestran en forma de lista emergente, cuyo título contiene el texto de la opción elegida en el menú principal. Como ejemplo, vamos a añadir un submenú a la Opción 3 del ejemplo anterior, al que añadiremos dos nuevas opciones secundarias. Para ello, bastará con insertar en el XML de menú un nuevo elemento <menu> dentro del item correspondiente a la opción 3. De esta forma, el XML quedaría ahora como sigue:

<menu xmlns:android="http://schemas.android.com/apk/res/android" >
	<item android:id="@+id/MnuOpc1" android:title="Opcion1"
	      android:icon="@android:drawable/ic_menu_preferences"></item>
	<item android:id="@+id/MnuOpc2" android:title="Opcion2"
	      android:icon="@android:drawable/ic_menu_compass"></item>
	<item android:id="@+id/MnuOpc3" android:title="Opcion3"
	      android:icon="@android:drawable/ic_menu_agenda">
		<menu>
			<item android:id="@+id/SubMnuOpc1"
				  android:title="Opcion 3.1" />
			<item android:id="@+id/SubMnuOpc2"
				  android:title="Opcion 3.2" />
		</menu>
	</item>
</menu>

Si volvemos a ejecutar ahora el proyecto y pulsamos la opción 3 nos aparecerá el correspondiente submenú con las dos nuevas opciones añadidas. Lo vemos en la siguiente imagen:

android-submenus1

Comprobamos como efectivamente aparecen las dos nuevas opciones en la lista emergente, y que el título de la lista se corresponde con el texto de la opción elegida en el menú principal («Opcion3«).

Para conseguir esto mismo mediante código procederíamos de forma similar a la anterior, con la única diferencia de que la opción de menú 3 la añadiremos utilizando el método addSubMenu() en vez de add(), y guardando una referencia al submenu. Sobre el submenú añadido insertaremos las dos nuevas opciones utilizando una vez más el método add(). Vemos cómo quedaría:

//Alternativa 2
menu.add(Menu.NONE, MNU_OPC1, Menu.NONE, "Opcion1")
	.setIcon(android.R.drawable.ic_menu_preferences);
menu.add(Menu.NONE, MNU_OPC2, Menu.NONE, "Opcion2")
	.setIcon(android.R.drawable.ic_menu_compass);

SubMenu smnu = menu.
	addSubMenu(Menu.NONE, MNU_OPC1, Menu.NONE, "Opcion3")
		.setIcon(android.R.drawable.ic_menu_agenda);
smnu.add(Menu.NONE, SMNU_OPC1, Menu.NONE, "Opcion 3.1");
smnu.add(Menu.NONE, SMNU_OPC2, Menu.NONE, "Opcion 3.2");

En cuanto a la implementación de estas opciones de submenú no habría diferencia con todo lo comentado anteriormente ya que también se tratan desde el evento onOptionsItemSelected(), identificándolas por su ID.

Por tanto, con esto habríamos terminado de comentar las opciones básicas a la hora de crear menús y submenus en nuestras aplicaciones Android. En el siguiente artículo veremos algunas opciones algo más avanzadas que, aunque menos frecuentes, puede que nos hagan falta para desarrollar determinadas aplicaciones.

Puedes consultar y/o descargar el código completo de los ejemplos desarrollados en este artículo accediendo a la pagina del curso en GitHub.

Si necesitáis iconos para mostrar en los menús aquí tenéis varios enlaces con algunos gratuitos que podéis utilizar en vuestras aplicaciones Android:

Curso de Programación Android en PDF

Este curso también está disponible en PDF. Descubre cómo conseguirlo…

¿Te ha sido de utilidad el Curso de Programación Android? ¿Quieres colaborar de forma económica con el proyecto? Puedes contribuir con cualquier cantidad, unos céntimos, unos euros, cualquier aportación será bienvenida. Además, si tu aportación es superior a una pequeña cantidad simbólica recibirás como agradecimiento un documento con la última versión del curso disponible en formato PDF. Sea como sea, muchas gracias por colaborar!

Más información:

También te puede interesar

33 comentarios

Desarrollo en Android | sgoliver.net blog 21/03/2011 - 13:44

[…] Menús en Android (I): Conceptos básicos [Nuevo!] […]

Responder
Ignacio 21/03/2011 - 21:17

Muy bueno el aporte :)

Responder
Menús en Android (II): Menús Contextuales | sgoliver.net blog 30/03/2011 - 16:09

[…] el artículo anterior del curso ya vimos cómo crear menús y submenús básicos para nuestras aplicaciones Android. Sin […]

Responder
Jose Antonio 11/05/2011 - 9:47

Hola:

he seguido el ejemplo. Éste y muchos sobre creación de menús, pero ninguno me funciona. El Log Cat dice de la activity «already focused» y que ignora la pulsación del item del menú (cvualquiera). Mi interfaz tiene seis botones cada uno con su OnclickListener correspondiente. Creo que se debe a una «duplicidad» de algún método que se lía con los botones del activity y con las opciones del menú.
¿Cómo puedo solucionar ésto?, ya no sé donde buscar.

Responder
Jose Antonio 12/05/2011 - 11:55

Ya lo he solucionado. En el menú Archivo de Eclipse hay una opción que se llama limpiar. La he seleccionado y después re-escrito el código del menú y….Voilá! aparece en pantalla.

Responder
desenfoque 15/11/2011 - 13:26

Sweet!

Qué fácil! Gracias por la ayuda…

Responder
Notificaciones en Android (III): Diálogos | sgoliver.net blog 21/11/2011 - 20:12

[…] uso de diálogos en Android guarda muchas semejanzas con el funcionamiento ya comentado de los menús, ya que se basa en la implementación de dos métodos de la propia actividad que los muestra, uno […]

Responder
Daniel 04/01/2012 - 22:34

holas
muy buen manual….tengo el siguiente inconveniente quisiera q el menu principal fuera fijo q aparesca apenas cargue el activity y q se quede fijo …agredeceria mucho su inmediata respuesta gracias

Responder
Bea 18/01/2012 - 10:48

Eres un máquina! Me encanta el manual!

Responder
Jorge 10/02/2012 - 2:04

Gracias por este excelente tutorial!,

Solo me queda la duda de cual es la mejor opcion a usar mediante el xml o directamente en codigo?

Saludos

Responder
angelin 18/02/2012 - 17:17

Para que me funcione este ejemplo he tenido que modificar este codigo:

@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.MnuOpc1:
lblMensaje.setText(«Opcion 1 pulsada!»);
return true;
case R.id.MnuOpc2:
lblMensaje.setText(«Opcion 2 pulsada!»);;
return true;
case R.id.MnuOpc3:
lblMensaje.setText(«Opcion 3 pulsada!»);;
return true;
default:
return super.onOptionsItemSelected(item);
}
}

Donde pone R.id.MnuOpc1 lo he sustituido por MNU_OPC1

Responder
Eoy 22/02/2012 - 11:15

Antes de nada, decir que el tutorial está de la leche. Muy bien estructurado y sencillo de comprender, muchas gracias!

Como mera información, tienes un par de errores en los ejemplos de código:

@Override
public boolean onCreateOptionsMenu(Menu menu) {
//Alternativa 2
menu.add(Menu.NONE, MNU_OPC1, Menu.NONE, «Opcion1»).setIcon(R.drawable.tag);
menu.add(Menu.NONE, MNU_OPC1, Menu.NONE, «Opcion2»).setIcon(R.drawable.filter);
menu.add(Menu.NONE, MNU_OPC1, Menu.NONE, «Opcion3»).setIcon(R.drawable.chart);
return true;
}

En los 3 menús les asignas el ID MNU_OPC1, deberían ser, 1,2 y 3 :D

Lo mismo en el ejemplo con los submenús.

Un saludo!!

Responder
Mari 19/03/2012 - 5:24

Gracias! Muy buena ayuda :)

Responder
juliostyle77 29/03/2012 - 17:35

no funciona…

Responder
juliostyle77 29/03/2012 - 17:37

Sin funciona ¬¬, solo debes presionar la tecla menú del emulador y aparecen.

Responder
jose luis 31/03/2012 - 21:09

A mi me aparece pero el fondo del menú se queda negro, como hago para que salga en el tono gris que te aparece a ti?

Responder
Jorge 25/04/2012 - 16:49

¡Buenas!

No consigo que me aparezcan los iconos que he asignado a un menú en el XML. Es un menú contextual, no creo que sea algo inviable puesto que he visto iconos en algún menú contextual de aplicaciones que tengo en el teléfono.

¿Hay que asignarlos de forma distinta a otros menús? Lo he hecho igual que para el menú «estándar», el que aparece al pulsar la tecla MENU. En ese no tuve ningún problema…

Un saludo y gracias una vez más por este grandísimo tutorial.

Responder
Jorge 22/06/2012 - 12:45

Una pregunta sobre la fragmentación que afecta a los menús. He probado mi app en Froyo y en Gingerbread y el menú se ve bien, pero en un Samsung Galaxy SII el menú que aparece es oscuro y mis iconos son oscuros, con lo cual apenas se distingue nada… ¿Cómo distinguir los iconos para que sean usados según el sistema en el que corra la aplicación?

Saludos.

Responder
Alex Chozas 29/06/2012 - 15:12

Al main.xml le faltaban muchos ids, y claro no compilaba la Activity…

Responder
Alex Chozas 29/06/2012 - 15:28

Solucionado lo de los id, la aplicación arranca sin errores pero no salen los menús. Tengo Android 2.2.1 y la verdad es que tampoco me salían en otro tutorial. Sí que sale el texto Hello World, AndroidMenus, pero en la parte inferior de la pantalla todo está negro.

Responder
Alex Chozas 29/06/2012 - 15:30

Un momento! Las opciones salen al apretar el botón izquierdo del menú de mi LG OPtimus One!

Responder
Andrés Rodriguez 19/10/2012 - 0:19

muy buen tutorial… de verdad me sirvió de mucho

Responder
Lauper 07/11/2012 - 17:39

Todo muy claro y bien explicado.

Mil gracias !!!

Responder
Miguel 21/11/2012 - 23:40

muy bien explicado.
solo quisiera hacer una consulta. Cómo haría para que el menú aparesca sin tener que pulsar la tecla Menú del emulador, por defecto se vería bacan cuando carga la pantalla de prueba. gracias

Responder
Albert 20/12/2012 - 3:02

Hola, me ha gustado mucho el tutorial, muy claro, lo que ocurre es que no me funciona. He visto que no soy el unico. ¿Como lo hago funcionar en android 4?

Responder
saul 20/12/2012 - 20:23

Hola.
la verdad la que buen tutorial, me ha ayudado mucho pero ahora tengo un problema.
tengo 5 items para mi menu, me lo muestra en 2 lineas una de 3 items y otra de 2.
Yo quisiera saber como le hago para que sean tres lineas de menu es decir:

—–item1—-
item2–item3
item4–item5

de antemano muchas gracias por el tutorial y espero alguien me pueda ayudar gracias nuevamente.

Responder
Action Bar en Android (I) | sgoliver.net blog 12/03/2013 - 19:37

[…] bien, ¿cómo se define un menú de aplicación? Pues en el curso hay un artículo dedicado exclusivamente a ello donde poder profundizar, pero de cualquier forma, en este artículo […]

Responder
Mr. Q 16/05/2013 - 15:28

alguien sabe porqué al programar la funcionalidad al botón del menú (todo mediante código java) me marcar el error

unknown member «id» of «com.dev.test.R»

estoy programando con la app «AIDE» en un LG Optimus 2x, gracias!!!

Responder
vyro 28/08/2013 - 3:09

Te agradezco el tiempo para explicar esto y el links de los botones al final.

Responder
Alberto Saucedo 18/09/2013 - 17:56

Pues ya estamos en 2013 y tus ejemplos siguen funcionando. Te agradezco muchísimo lo que has escrito. Yo quiero aprender android y he comprado muchos libros en inglés sobre android. El último fue Beginning Android de Mark Murphy y este mismo tema que tú has descrito brillantemente me costó bastante trabajo entenderlo en dicho libro.
Esto me hace pensar que el idioma es un impedimento para aprender tecnología ya que generalmente viene en inglés. Y también pienso que la respuesta debe de venir de personas como tú y el trabajo que realizas.
Gracias y muchos saludos.

Responder
Actionbar / Appbar / Toolbar en Android (I) | sgoliver.net blog 08/05/2015 - 19:28

[…] cómo se define un menú de aplicación? Pues en el curso hay un artículo dedicado exclusivamente a ello donde poder profundizar, pero de cualquier forma, en este artículo […]

Responder
Curso Programación Android por Salvador Gómez – Indice de Contenidos | Miguel Moyetones 17/06/2015 - 17:52

[…] Menús en Android (I): Menús y Submenús básicos [v3] […]

Responder
vero 15/10/2015 - 18:06

hola saludos.
Todo funciona bien.
El problema que tengo es que al poner el icono no sale el texto.

Responder

Responder a desenfoque Cancelar respuesta

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información. Aceptar Más Información

Política de Privacidad y Cookies