Menús

En este capítulo, se cubrirá los siguientes temas:

Creación de un menú Opciones
Modificación de menús y elementos de menú durante el tiempo de ejecución
Activación del modo de acción contextual para una vista
Uso del modo de lote contextual con un ListView
Creación de un menú emergente

Introducción

El sistema operativo Android es un entorno en constante cambio. Los primeros dispositivos Android (antes de Android 3.0), necesitaban tener un botón de menú de hardware. Aunque un botón de hardware ya no es necesario, los menús siguen siendo tenidos en cuenta. De hecho, la API de menús se ha expandido para soportar ahora tres tipos diferentes de menús:

Menú de opciones y barra de acción: Este es el menú estándar, que se utiliza para las opciones globales de su aplicación. Utilícelo para funciones adicionales como búsqueda, configuración, etc.

Modo Contextual (Modo de Acción Contextual): Esto generalmente se activa pulsando una vez. (Piense en esto como similar a un clic derecho en el escritorio.) Esto se utiliza para realizar una acción en el elemento presionado, como responder a un correo electrónico o eliminar un archivo.

Menú emergente: Proporciona una selección emergente para una acción adicional. Las opciones de menú no tienen por objeto afectar al elemento pulsado, sino que utilizan el modo contextual como se ha descrito anteriormente. Un ejemplo sería pulsar el botón de compartir y obtener una lista adicional de opciones de acciones.

Los recursos de menú son similares a otros componentes de la interfaz de usuario de Android; generalmente se crean en XML, pero también se pueden crear en código. Nuestra primera receta, como se muestra en la siguiente sección, mostrará el formato del menú XML y cómo llenarlo.

Creación de un menú Opciones

Antes de crear y mostrar un menú, veamos un menú para ver el resultado final. A continuación, se muestra una captura de pantalla que muestra la sección de menú de Chrome:

La característica más obvia a tener en cuenta es que el menú se verá diferente con relación tamaño de la pantalla. De forma predeterminada, los elementos de menú se agregarán al menú Desbordamiento, es decir, el menú que se ve cuando se pulsan los tres puntos en el extremo derecho.

Normalmente, los menús se crean en archivos de recursos que utilizan XML (como muchos otros recursos de Android), pero se almacenan en el directorio res / menu aunque también pueden crearse en código. Para crear un recurso de menú, utilice el elemento <menu> como se muestra:

</menu>

El elemento <item> define cada elemento de menú individual y se incluye en el elemento <menu>. Un elemento de menú básico se muestra de la siguiente manera:

<item

android:id="@+id/settings"

android:title="@string/settings" />

Los atributos <item> más comunes son los siguientes:

Id: Este es el identificador de recurso estándar.
title: Indica el texto a mostrar.
icon: Este es un recurso de drawable.
enabled: Esta opción está activada de forma predeterminada.
showAsAction: Se explicará a continuación.

El atributo showAsAction controla cómo se muestra el elemento de menú. Las opciones incluyen lo siguiente:

ifRoom: Este elemento de menú debe incluirse en la barra de acción si hay espacio suficiente.

withText: Esto indica que tanto el título como el icono deben mostrarse.

never: Esto indica que el elemento de menú nunca debe incluirse en la Barra de Acción; Siempre se muestran en el menú de desbordamiento.

always: Esto indica que el elemento de menú debe estar siempre incluido en la Barra de Acción (use con moderación, ya que el espacio es limitado).

Se pueden combinar varias opciones utilizando el separador (|), como:

showAsAction = "ifRoom | withText".

Con los fundamentos del recurso de menú cubierto, ahora estamos listos para crear un menú de opciones estándar.

**Preparándose

Utilice Android Studio para crear un nuevo proyecto denominado OptionsMenu. Utilice la opción predeterminada Teléfono y tableta y seleccione la opción Actividad vacía cuando se le solicite el Tipo de actividad. Dado que el asistente no crea la carpeta res / menu de forma predeterminada, vaya a Archivo | Nuevo | Directorio para crearlo antes de continuar.

Cómo hacerlo...

Con el nuevo proyecto creado como se describe en la sección anterior, está listo para crear un menú. Sin embargo, en primer lugar, agregaremos un recurso de cadena al archivo strings.xml para el título del menú. Usaremos la nueva cadena para el título del menú cuando creemos el XML para el menú.

**Estos son los pasos:

Comience abriendo el archivo strings.xml y añada el siguiente elemento <string> al elemento <resources>:

<string name="menu_settings">Configuración</string>

Cree un archivo nuevo en el directorio res / menu y llámelo menu_main.xml.

Abra el archivo menu_main.xml y agregue el siguiente XML para definir el menú:

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

<menu xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto">

<item android:id="@+id/menu_settings"

android:title="@string/menu_settings"

app:showAsAction="never">

</item>

</menu>

Con el menú creado ahora, sólo tenemos que anular el método onCreateOptionsMenu () en ActivityMain.java para llenar el menú:

Ejecute el programa en un dispositivo o emulador para ver el menú en la barra de acciones.

Cómo funciona…

Hay dos pasos básicos aquí:

Defina el menú en XML.
Llenar el menú cuando se crea la actividad.

Como buen hábito de programación, definimos la cadena en el archivo strings.xml en lugar de codificar en el XML. A continuación, utilizamos el identificador de cadena estándar de Android para establecer el título del menú en el paso 3. Dado que se trata de un elemento de menú "Configuración", no queremos que se muestre en la barra de acciones. Para asegurarse de que nunca se muestre, utilice showAsAction = "never".

Con el menú definido, usaremos el inflado de menú en el paso 4 para cargar el menú durante la creación de la actividad. Observe la sintaxis de recursos del menú R.menu.menu_main? Esta es la razón por la que creamos el XML en el directorio res / menu - para que el sistema sepa que este es un recurso de menú.

En el paso 4, utilizamos app: showAsAction en lugar de Android: android: showAsAction. Esto se debe a que estamos utilizando la biblioteca AppCompat (también conocida como la Biblioteca de soporte de Android). De forma predeterminada, el asistente para nuevos proyectos de Android Studio incluye la biblioteca de soporte del proyecto.

Hay más...

Si ejecutó el programa en el paso 5, debe haber visto el elemento de menú Configuración cuando presionó el botón de desbordamiento de menú. Pero eso era todo. No pasó nada más. Obviamente, los elementos de menú no son muy útiles si la aplicación no responde a ellos. Responder al menú Opciones se realiza a través de la devolución de llamada onOptionsItemSelected ().

Agregue el siguiente método a la aplicación para ver un Toast cuando se selecciona el menú Configuración:

@Override

public boolean onOptionsItemSelected(MenuItem item)

{

if \(item.getItemId\(\) == R.id.menu\_settings\)

{

     Toast.makeText\(this, "Configuración",

     Toast.LENGTH\_LONG\).show\(\);

 }

else

{

      return super.onContextItemSelected\(item\);

 }

return true;

}

Eso es. Ahora tiene un menú de trabajo.

Uso de un elemento de menú para iniciar una actividad

En este ejemplo, mostramos un Toast para que podamos ver un ejemplo de trabajo; Sin embargo, podríamos lanzar fácilmente una nueva actividad si es necesario. Al igual que lo hizo en Iniciar una nueva actividad con una receta de objeto de intención del Capítulo 1, Actividades, cree una Intención y llámela con startActivity ().

Creación de submenús

Los submenús se crean y se acceden casi exactamente de la misma manera que otros elementos del menú y se pueden colocar en cualquiera de los menús proporcionados, aunque no se pueden colocar en otros submenús. Para definir un submenú, incluya un elemento <menu> dentro de un elemento <item>. Aquí está el formulario XML de esta receta con dos elementos de submenú añadidos:

<item android:id="@+id/menu_settings"

android:title="@string/menu_settings"

app:showAsAction="never">

<menu>

   &lt;item android:id="@+id/menu\_sub1"

       android:title="Configuración de almacenamiento" /&gt;

   &lt;item android:id="@+id/menu\_sub2"

       android:title="Configuración de pantalla" /&gt;

</menu>

</item>

Agrupación de elementos de menú

Otra función de menú que admite Android es la agrupación de elementos de menú. Android ofrece varios métodos para grupos, entre los que se incluyen los siguientes:

setGroupVisible (): Mostrar u ocultar todos los elementos.
setGroupEnabled (): habilita o deshabilita todos los elementos.
setGroupCheckable (): Establece el comportamiento verificable.

Android mantendrá todos los elementos agrupados con showAsAction = "ifRoom" juntos. Esto significa que todos los elementos del grupo con showAsAction = "ifRoom" estarán en la barra de acción o todos los elementos estarán en el desbordamiento.

Para crear un grupo, agregue los elementos del menú <item> a un elemento <group>. Aquí hay un ejemplo usando el menú XML de esta receta con dos elementos adicionales en un grupo:

<item android:id="@+id/menu_item1"

   android:title="Item 1"

   app:showAsAction="ifRoom"/&gt;

<item android:id="@+id/menu_item2"

   android:title="Item 2"

   app:showAsAction="ifRoom"/&gt;

</group>

Modificación de menús y elementos de menú durante el tiempo de ejecución

Aunque se ha dicho muchas veces, se considera la "mejor" práctica de programación para crear una interfaz de usuario en XML en lugar de Java. Aún hay momentos en los que puede que tenga que hacerlo en código. Esto es especialmente cierto si quería que un elemento de menú estuviera visible (o activado) en función de algunos criterios externos. Los menús también se pueden incluir en carpetas de recursos, pero hay momentos en los que se necesita código para realizar la lógica. Un ejemplo podría ser si desea ofrecer un elemento de menú de subida sólo si el usuario inicia sesión en su aplicación.

En esta receta, vamos a crear y modificar el menú sólo a través de código.

**Preparándose

Cree un nuevo proyecto en Android Studio y llámelo RuntimeMenu con la opción predeterminada Teléfono y Tableta. Seleccione la opción Actividad vacía cuando se le solicite que agregue una actividad. Puesto que crearemos y modificaremos el menú completamente en código, no necesitaremos crear un directorio res / menu.

Cómo hacerlo...

Para empezar, vamos a añadir recursos de cadena para nuestros elementos de menú y un botón para cambiar la visibilidad del menú. Abra el archivo res / strings.xml y siga estos pasos:

Agregue las siguientes dos cadenas al elemento <resources> existente:

<String name = "menu_download"> Descargar </ string>

<String name = "menu_settings"> Configuración </ string>

2.Agregue un botón a activity_main.xml con onClick () configurado para toggleMenu como se muestra aquí:

<Button

android:id="@+id/buttonToggleMenu"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Toggle Menu"

android:layout_centerVertical="true"

android:layout_centerHorizontal="true"

android:onClick="toggleMenu"/>

Abra ActivityMain.java y agregue las siguientes tres líneas de código justo debajo de la declaración de clase:

private final int MENU_DOWNLOAD = 1;

private final int MENU_SETTINGS = 2;

private boolean showDownloadMenu = false;

Agregue el siguiente método para el botón para llamar:

public void toggleMenu(View view)

{

showDownloadMenu=!showDownloadMenu;

}

Cuando se crea la actividad por primera vez, Android invoca onCreateOptionsMenu () para crear el menú. Aquí está el código para construir dinámicamente el menú:

@Override

public boolean onCreateOptionsMenu(Menu menu)

{

menu.add(0, MENU_DOWNLOAD, 0, R.string.menu_download);

menu.add(0, MENU_SETTINGS, 0, R.string.menu_settings);

return true;

}

Para la mejor práctica de programación, no utilice onCreateOptionsMenu () para actualizar o cambiar su menú; En su lugar, use onPrepareOptionsMenu (). Aquí está el código para cambiar la visibilidad del elemento de menú Descargar basado en nuestro indicador:

@Override

public boolean onPrepareOptionsMenu(Menu menu)

{

MenuItem menuItem = menu.findItem(MENU_DOWNLOAD);

menuItem.setVisible(showDownloadMenu);

return true;

}

Aunque no es técnicamente necesario para esta receta, este código onOptionsItemSelected () muestra cómo responder a cada elemento de menú:

@Override

public boolean onOptionsItemSelected(MenuItem item)

{

switch \(item.getItemId\(\)\)

{

    case MENU\_DOWNLOAD:

        Toast.makeText\(this, R.string.menu\_download,

            Toast.LENGTH\_LONG\).show\(\);

        break;

    case MENU\_SETTINGS:

        Toast.makeText\(this, R.string.menu\_settings,

            Toast.LENGTH\_LONG\).show\(\);

        break;

    default:

        return super.onContextItemSelected\(item\);

}

return true;

}

Ejecute el programa en un dispositivo o emulador para ver los cambios de menú.

Cómo funciona...

Hemos creado un override para onCreateOptionsMenu (), al igual que lo hicimos en la receta anterior, Crear un menú de opciones. Pero en lugar de inflar un recurso de menú existente, creamos el menú utilizando el método Menu.add (). Puesto que queremos modificar los elementos del menú más tarde y responder a los eventos del elemento de menú, hemos definido nuestros propios ID de menú y los hemos pasado al método add ().

OnOptionsItemSelected () se llama para todos los elementos del menú, así que obtenemos el ID del menú y usamos una sentencia switch basada en los IDs que creamos. Devolvemos true si estamos manejando el evento del menú, de lo contrario pasamos el evento a la clase super.

Cambiar el menú se produce en el método onPrepareOptionsMenu (). Para simular un evento externo, creamos un botón para alternar un indicador booleano. La visibilidad del menú de descarga está determinada por el indicador. Aquí es donde desea crear su código personalizado basado en cualquier criterio que establezca. Su bandera se podría fijar usando el nivel actual del jugador o quizás cuando un nuevo nivel está listo para la liberación; Usted envía un mensaje Push, que habilita el elemento de menú.

Hay más...

¿Qué pasa si queremos que esta opción de descarga se note fácilmente para indicar si está disponible? Podríamos decirle a Android que queremos el menú en la barra de acción añadiendo el siguiente código a onPrepareOptionsMenu () (antes de la declaración de devolución):

menuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);

Ahora bien, si se ejecuta el código, verá el elemento de descarga de menú en la barra de acción, pero el comportamiento no es correcto.

Anteriormente, cuando no teníamos un elemento de menú en la barra de acciones, Android llamó onPrepareOptionsMenu () cada vez que abrimos el menú de desbordamiento para que la visibilidad se actualizara siempre. Para corregir este comportamiento, agregue la siguiente línea de código al método toggleMenu () llamado por el botón:

invalidateOptionsMenu();

La invocación invalidateOptionsMenu () indica a Android que nuestro menú de opciones ya no es válido, que entonces obliga a una llamada a onPrepareOptionsMenu () dándonos el comportamiento que esperamos.

Android considera el menú como siempre abierto si se muestra un elemento de menú en la barra de acciones.

Habilitación del modo de acción contextual para una vista .

Un menú contextual ofrece opciones adicionales relacionadas con una vista específica, el mismo concepto que un clic derecho en el escritorio. Actualmente, Android admite dos enfoques diferentes: el menú contextual flotante y el modo contextual. El modo de acción contextual se introdujo en Android 3.0. El Menú contextual flotante más antiguo podría provocar confusión ya que no hay indicación del elemento seleccionado actualmente y no admite acciones en varios elementos, como la selección de varios correos electrónicos para eliminarlos en una acción.

Creación de un menú de contexto flotante.

Si necesita usar el Menú contextual de estilo antiguo, por ejemplo, para admitir dispositivos preAndroid 3.0, es muy similar a la API del menú de opciones, solo nombres de métodos diferentes. Para crear el menú, use onCreateContextMenu () en lugar de onCreateOptionsMenu (). Para manejar la selección de elementos de menú, use onContextItemSelected () en lugar de onOptionsItemSelected (). Por último, llame a registerForContextMenu () para que el sistema sepa que desea eventos de menú contextual para la vista.

Dado que el modo contextual se considera la forma preferida de mostrar opciones de contexto, esta receta se centrará en la API más reciente. El modo contextual ofrece las mismas características que el menú contextual flotante, pero también añade funcionalidad adicional al permitir la selección de elementos múltiples cuando se utiliza el modo por lotes.

Esta receta demostrará la configuración del Modo Contextual para una sola vista. Una vez activada, con una pulsación larga, una Barra de Acción Contextual (CAB) reemplazará la Barra de Acción hasta que se termine el Modo Contextual.

La Barra de Acción Contextual no es la misma que la Barra de Acción y su actividad no necesita incluir una Barra de Acción.

Preparándose .

Utilice Android Studio para crear un nuevo proyecto y llámelo ContextualMode. Utilice la opción Teléfono y tableta predeterminada y seleccione Actividad vacía cuando se le solicite que agregue una actividad. Crear un directorio de menú (res / menú) como lo hicimos en la primera receta, Crear un menú de opciones, para almacenar el XML para el menú contextual.

Cómo hacerlo…

Vamos a crear un ImageView para servir como la vista del host para inicializar el Modo Contextual. Dado que el modo Contextual suele ser activado con una pulsación larga, configuraremos un oyente de clic largo en onCreate () para ImageView. Cuando se llama, iniciaremos el Modo Contextual y pasaremos una devolución de llamada ActionMode para manejar los eventos del Modo Contextual. Estos son los pasos:

Comenzaremos agregando dos nuevos recursos de cadena. Abra el archivo strings.xml y agregue lo siguiente:

<string name="menu_cast">Emitir</string>

<string name="menu_print">Imprimir</string>

With the strings created, we can now create the menu by creating a new file in res/menu called context_menu.xml using the following XML:

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

<menu

xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto">

<item android:id="@+id/menu_cast"

android:title="@string/menu_cast" />

<item android:id="@+id/menu_print"

android:title="@string/menu_print" />

</menu>

Ahora agregue un ImageView a activity_main.xml para servir como fuente para iniciar el Modo Contextual. Aquí está el XML para el ImageView:

<ImageView

android:id="@+id/imageView"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_centerVertical="true"

android:layout_centerHorizontal="true"

android:src="@mipmap/ic_launcher"/>

Con la interfaz de usuario ahora configurada, podemos agregar el código para el modo contextual. En primer lugar, necesitamos una variable global para almacenar la instancia ActionMode devuelta cuando llamamos startActionMode (). Agregue la siguiente línea de código a MainActivity.java debajo del constructor de clase:

ActionMode mActionMode;

A continuación, cree una devolución de llamada ActionMode para pasar a startActionMode (). Agregue el siguiente código a la clase MainActivity debajo del código en el paso anterior:

private ActionMode.Callback mActionModeCallback = new ActionMode.Callback()

{

    @Override

    public boolean onCreateActionMode\(ActionMode mode, Menu menu\)

    {

        mode.getMenuInflater\(\).inflate\(R.menu.context\_menu, menu\);

        return true;

    }

    @Override

    public boolean onPrepareActionMode\(ActionMode mode, Menu menu\)

    {

        return false;

    }

    @Override

    public boolean onActionItemClicked\(ActionMode mode, MenuItem item\) {

        switch \(item.getItemId\(\)\)

        {

            case R.id. menu\_cast:

                Toast.makeText\(MainActivity.this, "Cast",

                        Toast.LENGTH\_SHORT\).show\(\);

                mode.finish\(\);

                return true;

            case R.id. menu\_print:

                Toast.makeText\(MainActivity.this, "Print",

                        Toast.LENGTH\_SHORT\).show\(\);

                mode.finish\(\);

                return true;

            default:

                return false;

        }

    }

    @Override

    public void onDestroyActionMode\(ActionMode mode\)

    {

        mActionMode = null;

    }

};

Con la devolución de llamada de ActionMode creada, solo necesitamos llamar a startActionMode () para comenzar el Modo Contextual. Agregue el código siguiente al método onCreate () para configurar el oyente de clic largo:

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

    imageView.setOnLongClickListener\(new View.OnLongClickListener\(\)

    {

        public boolean onLongClick\(View view\)

        {

            if \(mActionMode != null\)

                return false;

            mActionMode = startActionMode\(mActionModeCallback\);

                return true;

        }

    }\);

Ejecute el programa en un dispositivo o emulador para ver el CAB en acción.

Cómo funciona...

Como se vio en el Paso 2, hemos utilizado el mismo menú XML para definir el menú contextual como los otros menús.

La parte principal del código a entender es la devolución de llamada ActionMode. Aquí es donde manejamos los eventos del Modo Contextual: inicializando el menú, manejando selecciones de elementos de menú y limpiando. Iniciamos el Modo Contextual en el evento de presionado largo con una llamada a startActionMode () pasando la devolución de llamada ActionMode creada en el Paso 5.

Cuando se activa el modo de acción, el sistema llama a callback onCreateActionMode (), que infla el menú y lo muestra en la Barra de Acción Contextual. El usuario puede descartar la Barra de Acción Contextual presionando la flecha de retroceso o la tecla de retroceso. El CAB también se descarta cuando el usuario hace una selección de menú. Demostramos un brindis para dar una regeneración visual para esta receta pero éste es donde usted pondría en ejecución su funcionalidad.

Uso del modo de lote contextual con un ListView

El modo contextual admite dos formas de uso: modo de vista único (como se ha demostrado) y modo de selección múltiple (o de lotes). El modo por lotes es donde el modo contextual supera el menú contextual de estilo antiguo, ya que no se admiten varias selecciones.

Si alguna vez has utilizado una aplicación de correo electrónico como Gmail o un explorador de archivos, probablemente has visto el Modo contextual al seleccionar varios elementos. Aquí hay una captura de pantalla de Solid Explorer, que muestra una excelente implementación de Material Theme y Contextual Mode:

En esta receta, crearemos un ListView lleno de varios nombres de país para demostrar selecciones múltiples o modo por lotes. En este ejemplo se usará el evento de presionado normal largo y también el evento de clic de artículo para iniciar el Modo Contextual.

Preparándose

Cree un nuevo proyecto en Android Studio y llámelo ContextualBatchMode. Utilice la opción Teléfono y tableta predeterminada y seleccione Actividad vacía cuando se le solicite que agregue una actividad. Cree un directorio de menús (res / menu) para el menú contextual.

Cómo hacerlo...

Similar a la receta anterior, comenzamos por crear un menú en XML para inflar cuando se inicia el modo Contextual. Necesitamos definir MultiChoiceModeListener para manejar el modo batch con ListView. A continuación, configuramos el ListView para permitir múltiples selecciones y pasar en el MultiChoiceModeListener. Estos son los pasos:

Abra el archivo strings.xml y agregue dos nuevos recursos de cadena para los elementos del menú de la siguiente manera:

<string name="menu_move">Mover</string>

<string name="menu_delete">Eliminar</string>

Cree un nuevo archivo denominado contextual_menu.xml en la carpeta res / menu con el siguiente XML:

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

<menu

xmlns:android="http://schemas.android.com/apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto">

<item android:id="@+id/menu_move"

   android:title="@string/menu\_move" /&gt;

<item android:id="@+id/menu_delete"

   android:title="@string/menu\_delete" /&gt;

</menu>

Ya que necesitamos un ListView, vamos a cambiar MainActivity para extender desde ListActivity de la siguiente manera:

Cree un MultiChoiceModeListener para manejar los eventos Barra de Acción Contextual. Agregue el siguiente código a MainActivity.java debajo del constructor de clase:

AbsListView.MultiChoiceModeListener

mMultiChoiceModeListener = new

    AbsListView.MultiChoiceModeListener\(\) {

@Override

public void onItemCheckedStateChanged\(ActionMode mode,int position, long id, boolean checked\)

{



}

@Override

public boolean onCreateActionMode\(ActionMode mode, Menu menu\)

{

    // Inflate the menu for the CAB

    MenuInflater inflater = mode.getMenuInflater\(\);

    inflater.inflate\(R.menu.contextual\_menu, menu\);

    return true;

}

@Override

public boolean onPrepareActionMode\(ActionMode mode,Menu menu\)

{

    return false;

}

@Override

public boolean onActionItemClicked\(ActionMode mode,MenuItem item\)

{

    // Handle menu selections

    switch \(item.getItemId\(\)\)

    {

        case R.id.menu\_move

            Toast.makeText\(MainActivity.this, "Move",

                Toast.LENGTH\_SHORT\).show\(\);

            mode.finish\(\);

            return true;

        case R.id.menu\_delete

            Toast.makeText\(MainActivity.this, "Delete",

                Toast.LENGTH\_SHORT\).show\(\);

            mode.finish\(\);

            return true;

        default:

            return false;

    }

}

@Override

public void onDestroyActionMode\(ActionMode mode\)

{

}

};

A continuación, cambiaremos el onCreate () para configurar el ListView y rellenar un ListAdapter utilizando una matriz de cadenas de nombres de países, de la siguiente manera:

@Override

protected void onCreate(Bundle savedInstanceState)

{

super.onCreate\(savedInstanceState\);

String\[\] countries = new String\[\]{"China", "France",

"Germany", "India", "Russia", "United Kingdom",

"United States"};

ListAdapter countryAdapter = new ArrayAdapter&lt;String&gt;\(

this, android.R.layout.simple\_list\_item\_checked,

countries\);

setListAdapter\(countryAdapter\);

getListView\(\).setChoiceMode\(

ListView.CHOICE\_MODE\_MULTIPLE\_MODAL\);

getListView\(\).setMultiChoiceModeListener\(

mMultiChoiceModeListener\);

getListView\(\).setOnItemClickListener\(new

AdapterView.OnItemClickListener\(\) {

@Override

public void onItemClick\(AdapterView&lt;?&gt; parent, View

view, int position, long id\) {

\(\(ListView\)parent\).setItemChecked\(position,

true\);

}

});

}

Cómo funciona…

Los tres elementos clave para que el Modo de acción funcione en modo por lotes son:

Creación de un menú contextual para inflar.
Definición de MultiChoiceModeListener para pasar a setMultiChoiceModeListener ().
Establezca ChoiceMode de ListView en CHOICE_MODE_MULTIPLE_MODAL.

MultiChoiceModeListener tiene el mismo propósito que el callback de ActionMode utilizado en modo contextual de vista única y, de hecho, implementa ActionMode.Callback. Al igual que con ActionMode.Callback, el menú se infla cuando MultiChoiceModeListener llama aCreateActionMode ().

De forma predeterminada, el modo de contexto se inicia con una pulsación prolongada en un elemento de ListView. Daremos un paso más adelante iniciando el Modo Contextual cuando el elemento se compruebe mediante el evento onItemClick (). Si no lo hacemos, la única manera de iniciar el Modo Contextual sería con un clic largo, lo que puede dejar a muchos usuarios inconscientes de la funcionalidad adicional.

Hay más...

Como se mencionó en la introducción a este capítulo, su actividad no necesita incluir una Barra de Acción para usar una Barra de Acción Contextual. Si usted tiene una barra de acción y es visible, será superpuesto con el CAB. Si no tiene una Barra de Acción como predeterminada con esta receta, el diseño será rediseñado para incluir el CAB (y volverá a dibujarse cuando se retire el CAB). Si desea que la barra de acciones esté visible, cambie el tema de la actividad o cambie la clase base y configure manualmente ListView.

Creating a pop-up menu .

Un menú emergente se adjunta a una vista similar a la lista desplegable de un hilandero. La idea de un menú emergente es proporcionar opciones adicionales para completar una acción. Un ejemplo común podría ser un botón Responder en una aplicación de correo electrónico. Cuando se pulsa, se muestran varias opciones de respuesta, como:

Responder, Responder a todos y Reenviar.

Android mostrará las opciones de menú debajo de la vista de anclaje si hay espacio; De lo contrario, se mostrará por encima de la vista.

Un menú emergente no está destinado a afectar a la vista en sí. Ese es el propósito de un menú contextual. En su lugar, consulte el menú flotante / modo de contexto descrito en el modo de acción contextual habilitante para una receta de vista.

En esta receta, crearemos el menú emergente mostrado anteriormente, usando ImageButton como la vista de anclaje.

Preparándose

Cree un nuevo proyecto en Android Studio y llámelo PopupMenu. Utilice la opción Teléfono y tableta predeterminada y seleccione Actividad vacía cuando se le solicite que agregue una actividad. Como antes, cree un directorio de menú (res / menu) para almacenar el menú XML.

Cómo hacerlo...

Comenzamos por crear el menú XML para inflar en la pulsación del botón. Después de inflar el menú emergente, llamamos a setOnMenuItemClickListener () pasando la devolución de llamada para manejar la selección del elemento de menú. Estos son los pasos:

Agregue las siguientes cadenas a strings.xml:

<string name="menu_reply">Reply</string>

<string name="menu_reply_all">Reply All</string>

<string name="menu_forward">Forward</string>

Cree un archivo nuevo en el directorio res / menu denominado menu_popup.xml utilizando el siguiente XML:

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

<menu

xmlns:android="http://schemas.android.com/

apk/res/android"

xmlns:app="http://schemas.android.com/apk/res-auto">

<item android:id="@+id/menu_reply

android:title="@string/menu_reply" />

<item android:id="@+id/menu_reply_all

android:title="@string/menu_reply_all" />

<item android:id="@+id/menu_forward

android:title="@string/menu_forward" />

</menu>

Cree un ImageButton en activity_main.xml para proporcionar la vista de anclaje del menú emergente. Crearlo como se muestra en el siguiente código XML:

<ImageButton

android:id="@+id/imageButtonReply"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_centerVertical="true"

android:layout_centerHorizontal="true"

android:src="@android:drawable/ic_menu_revert"

android:onClick="showPopupMenu"/>

Abra MainActivity.java y agregue el siguiente OnMenuItemClickListener debajo del constructor de clase:

private PopupMenu.OnMenuItemClickListener mOnMenuItemClickListener = new PopupMenu.OnMenuItemClickListener()

{

    @Override

    public boolean onMenuItemClick\(MenuItem item\)

    {

        switch \(item.getItemId\(\)\)

        {

            case R.id.menu\_reply:

                Toast.makeText\(MainActivity.this, "Reply", Toast.LENGTH\_SHORT\).show\(\);

                return true;

            case R.id.menu\_reply\_all:

                Toast.makeText\(MainActivity.this,"Reply All",Toast.LENGTH\_SHORT\).show\(\);

                return true;

            case R.id.menu\_forward:

                Toast.makeText\(MainActivity.this, "Forward", Toast.LENGTH\_SHORT\).show\(\);

                return true;

            default:

                return false;

        }

    }

};

El código final es manejar el evento onClick () del botón, de la siguiente manera:

public void showPopupMenu(View view)

{

PopupMenu popupMenu = new PopupMenu\(MainActivity.this,view\);

popupMenu.inflate\(R.menu.menu\_popup\);

popupMenu.setOnMenuItemClickListener\(mOnMenuItemClickListener\);

popupMenu.show\(\);

}

Ejecute el programa en un dispositivo o emulador para ver el menú emergente.

Cómo funciona...

Si usted ha leído las recetas del menú anterior, esto parecerá probablemente muy familiar. Básicamente, sólo inflar un menú emergente cuando se presiona el ImageButton. Configuramos un escucha de elementos de menú para responder a la selección del menú.

La clave es entender cada una de las opciones de menú disponibles en Android para que pueda utilizar el tipo de menú correcto para un escenario dado. Esto ayudará a su aplicación proporcionando una experiencia de usuario consistente y reduciendo la curva de aprendizaje.

Menus

results matching ""

No results matching ""