Tema 7. Menus y ActionBar

CURSO DE DESARROLLO DE APLICACIONES ANDROID
Tema 7
Menús y ActionBar
TEMA 7. MENÚS Y ACTIONBAR
Introducción
Los menús son una parte importante de la interfaz de usuario de las actividades ya que
proporcionan una manera intuitiva de realizar acciones.
Android provee un conjunto de clases (un framework) que permitirá añadir menús a cualquier
aplicación.
Existen tres tipos de menús:
• Menú de Opciones. Colección de ítems asignados para cada actividad, la cual

aparecerá al pulsar la tecla física, o el icono de menú del dispositivo, en caso de que
exista. A partir de Android 3.0, se pueden crear accesos directos de estos ítems en la
ActionBar¸ convirtiéndose dichos ítmes en action items.
• Submenú. Lista flotante de opciones que aparece cuando el usuario selecciona un ítem
de menú que contiene otro menú anidado.
• Menú Contextual. Lista flotante de opciones que puede aparecer cuando el usuario
pulsa de forma mantenida sobre una actividad o componente de la aplicación.
Construcción de un Menú de Opciones
Aunque es posible crear menús vía código en una actividad, no es esta una buena práctica
programática, puesto que se trata de un componente visual y, como tal, debe ser definido vía
XML. Los menús, así como todos sus ítems (visibles o no inicialmente), se definirán en la
carpeta res/menu/ en archivos XML. Existirá un archivo XML por cada menú de la aplicación,
cuyo nombre será el identificador que utilizará la clase R para hacerlo accesible desde código.
La estructura de un menú se construye utilizando tres etiquetas XML: <menu>, <item> y

<group>. Cada etiqueta podrá contener diversos atributos, siendo los más comunes:
android:id, android:title o android:icon 1. Los iconos que se deseen utilizar deberán
ubicarse, al igual que el resto de recusos gráficos accesibles desde código, en la carpeta
res/drawable-*/.
En cada archivo XML de menú el elemento raíz será siempre un elemento <menu>, que
representará un objeto tipo Menu en el código. Dicho elemento contendrá uno o más
elementos <item> y <group>.
1
Existen más atributos asociados a la etiqueta <item>, incluyendo algunos que especifican cuál sería el aspecto del
ítem en la ActionBar, tal y como se verá más adelante.
CURSO DE DESARROLLO DE APLICACIONES ANDROID 2

El elemento <item> representará un objeto MenuItem en el código y podrá contener, a su vez,

un elemento anidado de tipo <menu> para definir un submenú.
Por último, el elemento <group> es un elemento invisible que se utilizará para agrupar
elementos <item> con el objeto de asignar al grupo de ítems propiedades comunes tales como
su visibilidad o su estado (activo o inactivo).
MenuInflater
Para convertir la fuente XML en un objeto Java, se utiliza la clase MenuInflater (que infla el
menú XML convirtiéndolo en un objeto menú). Se deberá implementar el método
onCreateOptionsMenu() en aquella actividad en la que se quiera asociar un menú de
opciones. Este método será invocado la primera vez que se solicite el menú, en dispositivos
con Android 2.3 o inferior, mientras que en dispositivos con Android 3.0 o superior, se invocará
en el momento en el que la actividad sea creada, con el objeto de poblar la ActionBar (visible
desde la creación de la actividad).
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.menu_musica, menu);
return true;
}
Acciones del menú
Cuando el usuario pulsa un ítem de un menú de opciones, el sistema invoca en la actividad al

método onOptionsItemSelected(), método que recibe como parámetro el MenuItem
seleccionado. Como cualquier elemento definido en la interfaz de usuario se identifica
unívocamente por su id (android:id, en XML), se podrá determinar qué ítem ha pulsado,
invocando al método getItemId(), para realizar una u otra operación.
El método onOptionsItemSelected() devolverá true en el caso de que gestione

correctamente el ítem pulsado, y false en caso contrario.
A partir de Android 3.0, existe la opción de asignar un evento tipo on-click a cada ítem del
menú de forma que al pulsar un ítem, se invoque a un método concreto. Esto se consigue
usando el atributo android:onClick y especificando el método que será invocado.

Opciones en tiempo de ejecución
Tal y como ya se ha comentado, las mejores prácticas de programación establecen que el

diseño del menú radique en un archivo XML. Sin embargo, en ciertas ocasiones, será necesario
añadir o eliminar ítems del menú, activarlos, desactivarlos o modificarlos.
El método onCreateOptionsMenu() solo se invoca una vez, al crearse la actividad, y el

sistema mantendrá en memoria el objeto tipo Menu creado, para reutilizarlo. Por lo tanto, para
poder modificar los ítems del menú, se deberá sobreescribir el método
onPrepareOptionsMenu() que recibe como parámetro el objeto tipo Menu, tal y como existe
en ese momento. Este método es invocado inmediatamente antes de que el menú sea
mostrado, cada vez que se pulsa la tecla menú del dispositivo. Si devuelve false, el menú no
se mostrará.
A partir de Android 3.0, como la ActionBar (análogo al menú) se muestra siempre, para poder
modificar los ítems del menú se deberá invocar previamente a invalidateOptionsMenu(). A
continuación, el sistema invocará a onPrepareOptionsMenu().
Submenús
Cada elemento <item> podrá contener un elemento anidado de tipo <menu> para definir un
submenú. Del mismo modo que en el caso de los ítems de menú, cuando el usuario pulse sobre
una opción del submenú se invocará al método onOptionsItemSelected() del menú de
opciones.

Ejemplo 1. Menú Música!
Para aplicar los conceptos explicados hasta este punto, se va a implementar un menú que
contiene cuatro ítems de una hipotética aplicación para buscar, escuchar, grabar música y
elegir el formato de grabación, el cual será definido en el archivo menu_musica.xml. Además,
al pulsar la opción “Buscar” la aplicación mostrará un submenú con otras tres opciones:
“Grabaciones”, “Música en Móvil” y “Música en Internet”.
Se ha implementado una modificación en tiempo de ejecución sobre el cuarto ítem del menú
de forma que, si es pulsado, se cambia la imagen y el texto del mismo.

Código de menu_musica.xml
<?xml version="1.0" encoding="utf-8"?>

<menu xmlns:android="http://schemas.android.com/apk/res/android" >
<item
android:id="@+id/buscar"
android:title="@string/buscar"
android:icon="@drawable/note">
<menu>
<item
android:id="@+id/grabaciones"
android:title="@string/grabaciones" />
<item
android:id="@+id/movil"
android:title="@string/musica_movil" />
<item
android:id="@+id/internet"
android:title="@string/musica_internet" />
</menu>
</item>
<item
android:id="@+id/escuchar"
android:title="@string/escuchar"
android:icon="@drawable/listen"></item>
<item
android:id="@+id/grabar"
android:title="@string/grabar"
android:icon="@drawable/mic"></item>
<item
android:id="@+id/cd_vinilo"
android:title="@string/vinilo"
android:icon="@drawable/vinilo"></item>
</menu>
Código de EditorMusicaActivity.java (versión 1)
public class EditorMusicaActivity extends Activity {

static int CD_VINILO = 0;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
@Override
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {

// Se gestiona la opción seleccionada

switch (item.getItemId()) {
case R.id.buscar:
buscar();
return true;
case R.id.escuchar:
escuchar();
return true;
case R.id.grabar:
grabar();
return true;
case R.id.cd_vinilo:
cd_vinilo();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
// Método invocado inmediatamente antes de mostrarse el menú, cada
// vez. Recibe como parámetro el Menu, con la estructura tal y como
// esté justo antes de ser mostrado.
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
if (CD_VINILO == 1) {
menu.findItem(R.id.cd_vinilo).setIcon(R.drawable.cd);
menu.findItem(R.id.cd_vinilo).setTitle(R.string.cd);
}
else {
menu.findItem(R.id.cd_vinilo).setIcon(R.drawable.vinilo);
menu.findItem(R.id.cd_vinilo).setTitle(R.string.vinilo);
}
// return false: no muestra menú

// return true: se muestra menú.
// Buena práctica: delegar en clase padre.
return super.onPrepareOptionsMenu(menu);
}
private void cd_vinilo() {

if (CD_VINILO == 0)
CD_VINILO = 1;
else
CD_VINILO = 0;
}
private void buscar() {

// TODO
}
private void escuchar() {

// TODO
}
private void grabar() {

// TODO
}
}

Construcción de un menú contextual
Los menús contextuales se utilizan para proporcionar acceso a acciones al mantener pulsado
un elemento de la aplicación. Se puede añadir un menú contextual a cualquier elemento tipo
vista (View), siendo lo más común añadirlos en elementos del tipo ListView.
Para que una vista proporcione un menú contextual es necesario registrarla con el método
registerForContextMenu(), método al cual habrá que pasar, como parámetro, la propia
vista.
Del mismo modo que en el caso de los menús de opciones, para gestionar menús contextuales
se sobreescribirán los métodos onCreateContextMenu() y onContextItemSelected().
Mientras que el segundo método recibe un MenuItem como parámetro, el primer método
recibe el ContextMenu, la vista que muestra el menú contextual y un objeto de tipo
ContextMenuInfo, el cual proporcionará información adicional sobre el ítem que se
seleccione.
Para crear el menú contextual se deberá utilizar un MenuInflater al igual que en el caso de
los menús de opciones.
Ejemplo 2. Música y más música!
A continuación, se ampliarán las funcionalidades en la aplicación que se ha comenzado a

desarrollar en el Ejemplo 1, con el propósito de implementar un menú contextual sobre una
vista tipo ListView.
La vista ListView puede ser implementada fácilmente creando una actividad que herede de
ListActivity (subclase de Activity), que no necesitará asociar un layout (a través de
setContentView(id_layout)). Los ítems se insertan automáticamente en la lista gracias a un
ListAdapter, mediante el método setListAdapter(), que admite como único parámetro
un ArrayAdapter el cual gestionará el array de ítems que se dispondrán en la ListView. Los
parámetros que hay que pasar al constructor del ArrayAdapter son el contexto de la
aplicación (Context), un layout que define el aspecto de cada ítem y la lista de elementos que
se mostrarán en la ListView. ArrayAdapter construirá la pantalla con este layout que
define el aspecto de un único ítem de la lista, gracias a lo cual no es necesario establecer el
layout de la actividad en conjunto.
Una de las funcionalidades que ya implementa la vista ListView es la posibilidad de habilitar

un filtro de texto en función de lo que escriba el usuario e implementar un listener para cada
ítem de la lista, de forma que puedan realizarse acciones sobre dichos ítems.
En la aplicación de ejemplo, se utilizará una segunda actividad que herede de ListActivity y

que sea invocada vía Intent (tal y como ya se vio en el Tema 3). El Intent será creado al
pulsar sobre la opción del menú “Escuchar” o sobre cualquiera de las opciones del submenú

“Buscar”. Esta segunda actividad, ResultadosMusicaActivity.java, mostrará una lista de

grupos musicales que será cargada desde el fichero strings.xml. A la lista, de tipo ListView, se
le asignará un menú contextual con tres opciones (“Escuchar”, “Enviar” y “Borrar”). Además, a
la lista se le asignará el listener del evento on-item-click de forma que, cuando se pulse sobre
un elemento, se muestre un pequeño mensaje al usuario (Toast).
Nótese que, debido a que esta lista es un objeto tipo ListView, admite filtrados por texto.
Mantener pulsado

Pulsación sencilla
Filtro. Pulsación tecla “N”
Toast
Código de EditorMusicaActivity.java (versión 2)
public class EditorMusicaActivity extends Activity {
static int CD_VINILO = 0;
@Override
setContentView(R.layout.main);
}
@Override
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Se gestiona la opción seleccionada
case R.id.buscar:
buscar();
return true;
case R.id.escuchar:
escuchar();

return true;
case R.id.grabar:
grabar();
return true;
case R.id.cd_vinilo:
cd_vinilo();
return true;
// Las tres opciones del submenú de "Buscar" mostrarán el

// ListView (ResultadosMusicaActivity)
case R.id.grabaciones:
case R.id.internet:
case R.id.movil:
escuchar();
return true;
default:
return super.onOptionsItemSelected(item);
} // fin switch
}
// Método invocado inmediatamente antes de mostrarse el menú, cada

// vez. Recibe como parámetro el Menu, con la estructura tal y como
// esté justo antes de ser mostrado.
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
if (CD_VINILO == 1) {
menu.findItem(R.id.cd_vinilo).setIcon(R.drawable.cd);
menu.findItem(R.id.cd_vinilo).setTitle(R.string.cd);
}
else {
menu.findItem(R.id.cd_vinilo).setIcon(R.drawable.vinilo);
menu.findItem(R.id.cd_vinilo).setTitle(R.string.vinilo);
}
return super.onPrepareOptionsMenu(menu);
}
private void cd_vinilo() {

if (CD_VINILO == 0)
CD_VINILO = 1;
else
CD_VINILO = 0;
}
private void buscar() {

// TODO
}
private void escuchar() {

// Se solicita al sistema iniciar la actividad
// ResultadosMusicaActivity
Intent intent = new Intent(EditorMusicaActivity.this,
ResultadosMusicaActivity.class);
startActivity(intent);}
private void grabar() {

// TODO
}
}

Código de ResultadosMusicaActivity.java
// Esta actividad no extiende de Activity, si no de la subclase

// ListActivity, que crea automáticamente una lista de ítems a pantalla
// completa
public class ResultadosMusicaActivity extends ListActivity {
@Override
// La lista de items se cargan en un array. Los elementos a
// cargar están en el archivo strings.xml
String[] resultadosMusica =
getResources().getStringArray(R.array.musica_array);
// Cada elemento de la lista será una TextView, definida en el
// layout resultado_musica.xml
setListAdapter(new ArrayAdapter<String>(this,
R.layout.resultado_musica, resultadosMusica));
// NOTA: se pueden utilizar layouts predefinidos como
// "android.R.layout.simple_list_item_1"
// setListAdapter(new ArrayAdapter<String>(this,
// android.R.layout.simple_list_item_1, resultadosMusica));
// Se obtiene la vista tipo lista

ListView lv = getListView();
// Cuando el usuario comience a escribir, la lista se filtrará
// automáticamente
lv.setTextFilterEnabled(true);
// Se mostrará un pequeño mensaje flotante al usuario (Toast)

// cuando se haga click en un ítem
// Este método define el listener tipo on-click para cada
// elemento de la lista.
// Cuando se pulse un elemento de la lista, se invocará al
// método onItemClick y se mostrará la Toast
lv.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView<?> parent, View view, int

position, long id) {
Toast.makeText(getApplicationContext(),
((TextView) view).getText(),
Toast.LENGTH_SHORT).show();
}
});
// Con este método se asigna el menú contextual a la ListView

registerForContextMenu(lv);
}
// Método que creará el menú contextual para el ListView

// El menú contextual está definido en menu_lista_musica.xml
@Override
public void onCreateContextMenu(ContextMenu menu, View v,
ContextMenuInfo menuInfo) {

super.onCreateContextMenu(menu, v, menuInfo);
inflater.inflate(R.menu.menu_lista_musica, menu);
}
// Acciones que se realizarán al seleccionar un ítem del menú

// contextual. Por el momento, ninguna
@Override
public boolean onContextItemSelected(MenuItem item) {
// El menuItem recibido es sobre el que se ha mantenido la
// pulsación para mostrar el menú contextual.
// "info" contiene el identificador del menuItem seleccionado,
//sobre el que se realizará la acción del menú contextual.
AdapterContextMenuInfo info =
(AdapterContextMenuInfo) item.getMenuInfo();
case R.id.escuchar:
//escuchar(info.id);
return true;
case R.id.enviar:
//enviar(info.id);
return true;
case R.id.borrar:
//borrar(info.id);
return true;
default:
return super.onContextItemSelected(item);
}
}
}
Código de main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<TextView
android:layout_height="wrap_content"
android:text="@string/hello" />
</LinearLayout>

Código de menu_lista_musica.xml (Menú Contextual)

<item
android:title="@string/escuchar">
</item>
<item
android:id="@+id/enviar"
android:title="@string/enviar">
</item>
<item
android:id="@+id/borrar"
android:title="@string/borrar">
</item>
</menu>
Código de resultado_musica.xml (ítem list de ListView)

<TextView xmlns:android="http://schemas.android.com/apk/res/android"
android:padding="12dp"
android:textSize="18sp" >
</TextView>
Extracto de código de strings.xml (incluye textos para elemento de lista)

<resources>
<string name="hello">Ejemplos Menús. Música y más música!</string>
<string name="app_name">MenusYActionBar</string>
<string name="buscar">Buscar</string>
<string name="grabar">Grabar</string>
<string name="escuchar">Escuchar</string>
<string name="vinilo">Vinilo</string>
<string name="enviar">Enviar</string>
<string name="borrar">Borrar</string>
<string name="cd">CD</string>
<string name="grabaciones">Grabaciones</string>
<string name="musica_movil">Música en Móvil</string>
<string name="musica_internet">Música en Internet</string>
<string-array name="musica_array">
<item>Foo Fighters</item>
<item>Fun Lovin Criminals</item>
<item>Garbaje</item>
…
</string-array>
</resources>

Características avanzadas de los menús
Existen otras características que se pueden aplicar a la mayor parte de los ítems de menú:
• Grupos. Conjuntos de ítems que comparten características.

• Ítems seleccionables. Ítems de menú a los que se puede añadir chekboxes o
radiobuttons.
• Atajos de teclado. Posibilidad de asignar atajos de teclado a ítems, que podrán ser
útiles en dispositivos con teclado físico.
Grupos
En la sección anterior ya se anticipó la existencia del elemento <group>, elemento invisible

que se utilizará para agrupar elementos <item> con el objeto de asignar al grupo de ítems
propiedades comunes. Estas propiedades son las siguientes:
• Mostrar u ocultar todos los ítems del grupo con setGroupVisible().

• Activar o desactivar todos los ítems del grupo con setGroupEnabled().
• Hacer que los ítems del grupo sean seleccionables o no con setGroupCheckable().
Para crear un grupo de ítems en el archivo XML bastará con anidar con la etiqueta <group> el
conjunto de elementos <item> deseado. En código, se utilizará un ID común al invocar al
método Menu.add() 2.
En el siguiente código de ejemplo, es parte del archivo menu_lista_musica.xml utilizado en la

sección anterior, se ha añadido un submenú “Reproductores” al primer ítem del menú
contextual del listado de grupos musicales, que mostrará una lista con posibles reproductores
para escuchar el autor seleccionado.
<item
android:title="@string/escuchar">
<menu>
<item android:id="@+id/reproductor_defecto"
android:title="@string/rep_0" />
<group android:id="@+id/reproductores">
<item android:id="@+id/reproductor1"
<item android:id="@+id/reproductor2"
…
</group>
</menu>
</item>
2
Tal y como ya se ha mencionado, salvo excepciones, no es una buena práctica añadir ítems de menú dentro del
código Java. Deberán ser definidos en el archivo XML siempre que sea posible.

En el ejemplo anterior, todos los ítems del menú (agrupados o no) son hermanos y tendrán el
mismo aspecto. Por otro lado, se podrá modificar exclusivamente el aspecto de los ítems del
grupo, referenciando al identificador del grupo, reproductores.
Ítems seleccionables
Exceptuando los menús de opciones (o de iconos), que se muestran pulsando el botón menú
(físico o soft) del dispositivo, cualquier otro ítem de menú puede tener asociada una checkbox
o un radiobutton. Esta característica es útil cuando se quiere utilizar un menú para mostrar
opciones cuyo estado pueda ser eleccionado por el usuario. En el caso de que todos los ítems
de una lista puedan ser seleccionados, se utilizarán checkboxes. En cambio, si se trata de una
lista de elementos mutuamente excluyentes, se utilizarán radiobuttons.
Para activar esta característica de forma individual se utilizará la propiedad del elemento
<item>, android:checkable="true"; para crear una lista de ítems mutuamente excluyentes,
estos deberán agruparse en un <group android:checkableBehaviour="single"> 3
A continuación, se muestra el código del archivo menu_musica.xml de la sección anterior, en el

cual se han añadido ítems seleccionables de los dos tipos en un submenú del ítem “Grabar”:
<item
android:icon="@drawable/mic">
<menu>
<item
android:id="@+id/calidad_alta"
android:title="@string/calidad_alta"
android:checkable="true"
android:checked="false" />
<group android:checkableBehavior="single">
<item
android:id="@+id/mp3"
android:title="@string/mp3" />
<item
android:id="@+id/aac"
android:title="@string/aac" />
<item
android:id="@+id/wma"
android:title="@string/wma" />
</group>
</menu>
</item>
3
Si android:checkableBehaviour="all", se creará un grupo de ítems con checkboxes asociados. Todos podrán
ser seleccionados.

El resultado es el siguiente:
Es importante tener en cuenta que, en Android, el estado de una checkbox o de un

radiobutton no cambia automáticamente al ser seleccionado. En cambio, cuando un ítem es
pulsado, se invoca al método onOptionsItemSelected(). Es en este método donde se
tendrá que controlar manualmente el estado de estos ítems, consultando su estado actual y
cambiándolo.
Para implementar este comportamiento en la aplicación de ejemplo, se añadirá este código en

el método antes mencionado:
case R.id.calidad_alta:
if (item.isChecked())
item.setChecked(false);
else
item.setChecked(true);
return true;
case R.id.mp3:
case R.id.aac:
case R.id.wma:
item.setChecked(true);
return true;
Con este código, se conseguirá mantener las opciones seleccionadas previamente. Por
ejemplo, si en el menú “Grabar” se pulsa en “Alta calidad” y, posteriormente en “AAC”, al
abrirlo por tercera vez, dichos ítems estarán activados:

Los ítems que se hayan seleccionado sólo serán recordados mientras la actividad no finalice,
por lo que, si se desea conservar su estado la próxima vez que se inicie la aplicación, deberán
almacenarse dichos datos a través de la clase SharedPreferences, lo cual se estudiará en un
próximo tema.
Atajos de teclado
Se pueden definir atajos de teclado para aquellos dispositivos con teclado físico, que
permitirán un acceso rápido a diferentes opciones del menú. Para implementar estos atajos, se
utilizarán las propiedades android:alphabeticShortcut o android:numericShortcut, en
el elemento <item>, o bien los métodos setAphabeticShortcut() o
setNumericShortcut(), que admiten un carácter como parámetro.
Estos atajos no distinguen entre mayúsculas y minúsculas.
Debido a la tendencia evolutiva del sistema Android, que aboga por crear una interfaz con el
usuario completamente táctil, sin botones físicos en los dispositivos, los atajos de teclado
serán cada vez menos usados.

ActionBar
La ActionBar aparece en la versión 3.0 de Android (Honeycomb, nivel 11 de API) y sustituye al

menú de opciones (o iconos) típico en versiones anteriores del sistema. Esta barra, superior,
identifica la aplicación y la ubicación del usuario en la misma, haciendo accesibles las opciones
de menú más importantes (siempre en función del espacio disponible, o del tamaño de la
pantalla del dispositivo), mientras que el resto permanecerán ocultas en un menú desplegable,
a la derecha de la ActionBar.
Gracias a este nuevo elemento, se puede dar acceso instantáneo a acciones importantes, al
colocar ítems del menú de opciones en la ActionBar, convirtiéndolos en action items los cuales,
a su vez, proverán action views, widgets que hacen accesibles comportamientos concretos de
forma inmediata.
Para incluir la ActionBar en una aplicación es necesario establecer en el manifiesto la versión

mínima o versión objetivo de la SDK como 11 (android:minSdkVersion="11" o
android:targetSdkVersion="11").
Para colocar un ítem de menú en la ActionBar convirtiéndolo en un action item, será necesario
añadir a la etiqueta <item>, en el archivo XML que define el menú, el atributo
android:showAsAction="ifRoom" o bien android:showAsAction="ifRoom|withText" 4. En
el primer caso se mostrará solamente el icono del ítem (en caso de haber espacio suficiente en
la ActionBar), mientras que en el segundo caso, se mostrará tanto el icono como el texto
asociado al ítem (de nuevo, en función del espacio disponible, y prevaleciendo siempre el
icono). Por otro lado, el resto de ítems que no sean mostrados en la ActionBar serán accesibles
desde el menú desplegable derecho 5, y nunca mostrarán su icono asociado.
En el ejemplo utilizado en este tema, se han introducido los mínimos cambios necesarios para
mostrar la ActionBar. Para poder visualizar la aplicación, es necesario utilizar AVDs con Android
3.0 o superior.
En el código mostrado a continuación, se han modificado solo pequeñas partes, además de

añadirse iconos de mayor resolución en la carpeta res/drawable-hdpi/.
4
Estos atributos solo están disponibles a partir de Android 3.0.
5
o inferior, en el caso de dispositivos móviles con la versión ICS (Android 4.0)

Código de main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" >
<TextView android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/hello"
android:textAppearance="?android:attr/textAppearanceLarge" />
</LinearLayout>
Código de menu_musica.xml

<item
android:id="@+id/buscar"
android:title="@string/buscar"
android:icon="@drawable/note"
android:showAsAction="ifRoom">
<menu>
…
</menu>
</item>
<item
android:title="@string/escuchar"
android:icon="@drawable/listen"
</item>
<item
android:icon="@drawable/mic"
android:showAsAction="ifRoom|withText">
<menu>
…
</menu>
</item>
<item
android:id="@+id/cd_vinilo"
android:title="@string/vinilo"
android:icon="@drawable/vinilo"
</item>
</menu>

Código de AndroidManifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.especialcursos.menus"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk android:minSdkVersion="11" android:targetSdkVersion="11" />
<application
android:icon="@drawable/app_icon"
android:label="@string/app_name" >
<activity
android:name=".EditorMusicaActivity"
android:label="@string/app_name"
android:theme="@android:style/Theme.Holo">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name="ResultadosMusicaActivity"></activity>
</application>
</manifest>
Una vez realizadas las modificaciones señaladas en negrita, será necesario crear nuevos AVDs
para poder visualizar el resultado.
En las imágenes siguientes se muestra la configuración de tres AVDs diferentes, así como el
aspecto del menú sobre dichas versiones.

AVD HoneyComb
El resultado será el siguiente:

AVD Honeycomb (Phone)
Resultado:

AVD ICS
Resultado:

Tema 7. Menus y ActionBar

Diunggah oleh

Informasi Dokumen

Hak Cipta

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Tema 7. Menus y ActionBar

Diunggah oleh

Hak Cipta:

CURSO DE DESARROLLO DE APLICACIONES ANDROID

Existen tres tipos de menús:

• Menú de Opciones. Colección de ítems asignados para cada actividad, la cual

Construcción de un Menú de Opciones

La estructura de un menú se construye utilizando tres etiquetas XML: <menu>, <item> y

CURSO DE DESARROLLO DE APLICACIONES ANDROID 2

El elemento <item> representará un objeto MenuItem en el código y podrá contener, a su vez,

Acciones del menú

Cuando el usuario pulsa un ítem de un menú de opciones, el sistema invoca en la actividad al

El método onOptionsItemSelected() devolverá true en el caso de que gestione

CURSO DE DESARROLLO DE APLICACIONES ANDROID 3

Opciones en tiempo de ejecución

Tal y como ya se ha comentado, las mejores prácticas de programación establecen que el

El método onCreateOptionsMenu() solo se invoca una vez, al crearse la actividad, y el

CURSO DE DESARROLLO DE APLICACIONES ANDROID 4

Ejemplo 1. Menú Música!

CURSO DE DESARROLLO DE APLICACIONES ANDROID 5

<?xml version="1.0" encoding="utf-8"?>

Código de EditorMusicaActivity.java (versión 1)

public class EditorMusicaActivity extends Activity {

CURSO DE DESARROLLO DE APLICACIONES ANDROID 6

// Se gestiona la opción seleccionada

// return false: no muestra menú

private void cd_vinilo() {

private void buscar() {

private void escuchar() {

private void grabar() {

CURSO DE DESARROLLO DE APLICACIONES ANDROID 7

Construcción de un menú contextual

Ejemplo 2. Música y más música!

A continuación, se ampliarán las funcionalidades en la aplicación que se ha comenzado a

Una de las funcionalidades que ya implementa la vista ListView es la posibilidad de habilitar

En la aplicación de ejemplo, se utilizará una segunda actividad que herede de ListActivity y

CURSO DE DESARROLLO DE APLICACIONES ANDROID 8

“Buscar”. Esta segunda actividad, ResultadosMusicaActivity.java, mostrará una lista de

CURSO DE DESARROLLO DE APLICACIONES ANDROID 9

Filtro. Pulsación tecla “N”

Código de EditorMusicaActivity.java (versión 2)

public class EditorMusicaActivity extends Activity {

static int CD_VINILO = 0;

CURSO DE DESARROLLO DE APLICACIONES ANDROID 10

// Las tres opciones del submenú de "Buscar" mostrarán el

// Método invocado inmediatamente antes de mostrarse el menú, cada

private void cd_vinilo() {

private void buscar() {

private void escuchar() {

private void grabar() {

CURSO DE DESARROLLO DE APLICACIONES ANDROID 11

// Esta actividad no extiende de Activity, si no de la subclase

// Se obtiene la vista tipo lista

// Se mostrará un pequeño mensaje flotante al usuario (Toast)

public void onItemClick(AdapterView<?> parent, View view, int

// Con este método se asigna el menú contextual a la ListView

// Método que creará el menú contextual para el ListView

CURSO DE DESARROLLO DE APLICACIONES ANDROID 12

// Acciones que se realizarán al seleccionar un ítem del menú

<?xml version="1.0" encoding="utf-8"?>

CURSO DE DESARROLLO DE APLICACIONES ANDROID 13

Código de menu_lista_musica.xml (Menú Contextual)

<?xml version="1.0" encoding="utf-8"?>

Código de resultado_musica.xml (ítem list de ListView)

<?xml version="1.0" encoding="utf-8"?>

Extracto de código de strings.xml (incluye textos para elemento de lista)

<?xml version="1.0" encoding="utf-8"?>

CURSO DE DESARROLLO DE APLICACIONES ANDROID 14

Características avanzadas de los menús

• Grupos. Conjuntos de ítems que comparten características.