Desventuras con Android – 5. Malditos Diálogos

En cualquier lenguaje de programación decente, hay una forma sencilla de mostrar un mensaje en pantalla para que el usuario lo vea y luego pueda pulsar en el botón aceptar o cancelar (Diálogo). Es una tarea tan común que se puede hacer hasta con una simple instrucción.

Pero en el Java de Android, no se puede. Para mostrar un sencillo diálogo de tipo «Yes/No», hay que seguir un procedimiento más elaborado que para resolver una ecuación de 3 variables.

Quizá la forma más sencilla de mostrar un mensaje en pantalla, sea usar las tostadas, mejor dicho los «Toast».

Un mensaje típico sería :

Toast.makeText(getActivity(), "Hola soy una tostada", Toast.LENGTH_SHORT).show();

Esta instrucción hará que aparezca un pequeño mensaje en pantalla con fondo oscuro y texto claro. Este mensaje permanecerá visible solo unos segundos, luego se desvanecerá.

Diálogos con botones

Los diálogos más simples son los que incluyen los típicos botones «Aceptar» y/o «Cancelar».

Quizá el diálogo más sencillo sea el que solo muestra un mensaje y un botón para cerrar el diálogo. Para implementar este mensaje, debemos crear un objeto de la clase «AlertDialog.Builder» y a este diálogo, que podemos asumir que está en blanco, ir agregándole los botones o mensaje requeridos.

El siguiente código hace eso precisamente:

//Crea el diálogo
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle("Título de mensaje");  //define el título
builder.setMessage("Android dice ... ");  //define el mensaje
//Le agrega el botón "Sí"
builder.setPositiveButton("Aceptar", new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int id) {
        dialog.cancel();
    }
});
//Muestra el dialogo
builder.show();

El resultado en pantalla sería como la siguiente imagen:

Cualquiera que ha creado mensajes en pantalla usando Visual Basic, o C, podría decir «¿Qué ganas de complicarse la vida?». Pero Android es Android, y tenemos que aceptarlo tal cual.

El título del mensaje es opcional, así que puede obviarse. Además los métodos que se aplican al objeto «builder», devuelven una referencia al mismo objeto «builder», así que se pueden anidar los métodos que sobre él se apliquen. Esto en buen cristiano quiere decir que podemos hacer: «builder.hacerAlgo().hacerOtraCosa().hacerLoQueSea() … »

De modo que el código anterior pudimos haberlo escrito también así:

//Crea el diálogo
AlertDialog.Builder builder = new AlertDialog.Builder(this);
//Configura y muestra
builder.setMessage("Android dice ... ")
    .setPositiveButton("Aceptar", new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int id) {
        dialog.cancel();
        }
    }).show();

Con la diferencia de que aquí no se está poniendo un título al mensaje. La salida mostrada será:

El siguiente código muestra como crear un diálogo de tipo Si-No:

//Crea el diálogo
AlertDialog.Builder builder = new AlertDialog.Builder(this);
//Define el mensaje
builder.setMessage("Ya conoce Android. ¿Desea Continuar?");
//Le agrega el botón "Sí"
builder.setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int id) {
        Toast.makeText(getApplicationContext(), "Sí", Toast.LENGTH_SHORT).show();
    }
});
//Le agrega el botón "No"
builder.setNegativeButton(android.R.string.no, new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int id) {
        Toast.makeText(getApplicationContext(), "No", Toast.LENGTH_SHORT).show();
    }
});
//Muestra el dialogo
builder.show();

El resultado será como el mostrado en la siguiente imagen:

Observar que en este código, estamos extrayendo los textos de los botones de las cadenas de recursos, usando las referencias «android.R.string.yes»  y «android.R.string.no», en lugar de usar cadenas constantes .

 

Diálogos con listas

Se pueden crear diálogos que incluyan una lista de selección dentro de ellas. Para ello se hace uso del método setItems(), pasándole la lista de ítems que queremos mostrar en el diálogo. En nuestro ejemplo, usaremos un arreglo de cadenas.

El siguiente código muestra como crear una lista con los botones «Aceptar» y «Cancelar».

//Declara la lista de elementos
final String[] items = {"tiburones","pirañas","políticos"};
//Crea el diálogo
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle("Elegir elemento");
//Crea la lista de ítems en el diálogo
builder.setItems(items, new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int item) {
        Toast.makeText(getApplicationContext(), items[item], Toast.LENGTH_SHORT).show();
    }
});
//Muestra el dialogo
builder.show();

La salida sería similar a esta imagen:

En este tipo de diálogos, no es necesario incluir los botones «Aceptar» o «Cancelar», puesto que seleccionar una opción es equivalente a «Aceptar» y para Cancelar, se puede tocar en alguna parte fuera del diálogo. Sin embargo, es totalmente factible incluir los botones, como se mostrará en el siguiente ejemplo.

Al seleccionar cualquier opción, se ejecutará el método OnClick() y el parámetro ítem es el índice del elemento selecciondo. En nuestro ejemplo, solo mostramos un mensaje, indicando el texto seleccionado.

Tal vez podríamos desear que se muestre una opción pre-seleccionada o recordar la última selección. En este caso, es conveniente usar el método setSingleChoiceItems(), en lugar de setItems(), de modo que lo que tengamos sea una lista de opciones con indicación visual:

//Declara la lista de elementos
final String[] items = {"tiburones","pirañas","políticos"};
//Crea el diálogo
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle("¿Qué elemento no pertenece a la lista?");
//Crea la lista de ítems en el diálogo
builder.setSingleChoiceItems(items, -1, new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int item) {
        opcion = items[item];   //guarda opción seleccionada 
    }
});
//Le agrega el botón "Aceptar"
builder.setPositiveButton("Aceptar", new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int id) {
        //muestra la opción seleccionada
        Toast.makeText(getApplicationContext(), opcion, Toast.LENGTH_SHORT).show();
    }
});
//Le agrega el botón "Cancelar"
builder.setNegativeButton("Cancelar", new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int id) {
        Toast.makeText(getApplicationContext(), "Cancelado", Toast.LENGTH_SHORT).show();
    }
});
//Muestra el dialogo
builder.show();

Notar que el método setSingleChoiceItems(), contiene un parámetro más que es el que nos permitirá mostrar un ítem marcado. Notar que la variable «opcion» se debe declarar externamente como una cadena.

La salida se parecerá a esta pantalla: