Inicio Android Notificaciones en Android (III): Diálogos

Notificaciones en Android (III): Diálogos

por sgoliver

Durante este curso ya hemos visto dos de las principales alternativas a la hora de mostrar notificaciones a los usuarios de nuestra aplicaciones: los toast y las notificaciones de la barra de estado. En este último artículo sobre notificaciones vamos a comentar otro mecanismo que podemos utilizar para mostrar o solicitar información puntual al usuario. El mecanismo del que hablamos son los cuadros de diálogo.

En principio, los diálogos de Android los podremos utilizar con distintos fines, en general:

  • Mostrar un mensaje.
  • Pedir una confirmación rápida.
  • Solicitar al usuario una elección (simple o múltiple) entre varias alternativas.

De cualquier forma, veremos también cómo personalizar completamente un diálogo para adaptarlo a cualquier otra necesidad.

El uso actual de los diálogos en Android se basa en fragmets, pero por suerte tenemos toda la funcionalidad implementada una vez más en la librería de compatibilidad android-support-v4.jar (que debe estar incluida por defecto en tu proyecto si lo has creado con una versión reciente del pluin de Eclipse) por lo que no tendremos problemas al ejecutar nuestra aplicación en versiones antiguas de Android. En este caso nos vamos a basar en la clase DialogFragment. Para crear un diálogo lo primero que haremos será crear una nueva clase que herede de DialogFragment y sobrescribiremos uno de sus métodos onCreateDialog(), que será el encargado de construir el diálogo con las opciones que necesitemos.

La forma de construir cada diálogo dependerá de la información y funcionalidad que necesitemos. A continuación mostraré algunas de las formas más habituales.

Diálogo de Alerta

Este tipo de diálogo se limita a mostrar un mensaje sencillo al usuario, y un único botón de OK para confirmar su lectura. Lo construiremos mediante la clase AlertDialog, y más concretamente su subclase AlertDialog.Builder, de forma similar a las notificaciones de barra de estado que ya hemos comentado en el capítulo anterior. Su utilización es muy sencilla, bastará con crear un objeto de tipo AlertDialog.Builder y establecer las propiedades del diálogo mediante sus métodos correspondientes: título [setTitle()], mensaje [setMessage()] y el texto y comportamiento del botón [setPositiveButton()]. Veamos un ejemplo:

public class DialogoAlerta extends DialogFragment {
    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {

        AlertDialog.Builder builder =
        		new AlertDialog.Builder(getActivity());

        builder.setMessage("Esto es un mensaje de alerta.")
        	   .setTitle("Información")
               .setPositiveButton("OK", new DialogInterface.OnClickListener() {
                   public void onClick(DialogInterface dialog, int id) {
                	   dialog.cancel();
                   }
               });

        return builder.create();
    }
}

Como vemos, al método setPositiveButton() le pasamos como argumentos el texto a mostrar en el botón, y la implementación del evento onClick en forma de objeto OnClickListener. Dentro de este evento, nos limitamos a cerrar el diálogo mediante su método cancel(), aunque podríamos realizar cualquier otra acción.

Para lanzar este diálogo por ejemplo desde nuestra actividad principal, obtendríamos una referencia al Fragment Manager mediante una llamada a getSupportFragmentManager(), creamos un nuevo objeto de tipo DialogoAlerta y por último mostramos el diálogo mediante el método show() pasándole la referencia al fragment manager y una etiqueta identificativa del diálogo.

btnAlerta.setOnClickListener(new View.OnClickListener() {
	public void onClick(View v) {
		FragmentManager fragmentManager = getSupportFragmentManager();
 	       DialogoAlerta dialogo = new DialogoAlerta();
		dialogo.show(fragmentManager, "tagAlerta");
	}
});

El aspecto de nuestro diálogo de alerta sería el siguiente:

dialogo-alerta

Diálogo de Confirmación

Un diálogo de confirmación es muy similar al anterior, con la diferencia de que lo utilizaremos para solicitar al usuario que nos confirme una determinada acción, por lo que las posibles respuestas serán del tipo Sí/No.

La implementación de estos diálogos será prácticamente igual a la ya comentada para las alertas, salvo que en esta ocasión añadiremos dos botones, uno de ellos para la respuesta afirmativa (setPositiveButton()), y el segundo para la respuesta negativa (setNegativeButton()). Veamos un ejemplo:

public class DialogoConfirmacion extends DialogFragment {
    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {

        AlertDialog.Builder builder =
        		new AlertDialog.Builder(getActivity());

        builder.setMessage("¿Confirma la acción seleccionada?")
        .setTitle("Confirmacion")
        .setPositiveButton("Aceptar", new DialogInterface.OnClickListener()  {
               public void onClick(DialogInterface dialog, int id) {
             	   	Log.i("Dialogos", "Confirmacion Aceptada.");
      					dialog.cancel();
                   }
               })
        .setNegativeButton("Cancelar", new DialogInterface.OnClickListener() {
               public void onClick(DialogInterface dialog, int id) {
                	   	Log.i("Dialogos", "Confirmacion Cancelada.");
       					dialog.cancel();
                   }
               });

        return builder.create();
    }
}

En este caso, generamos a modo de ejemplo dos mensajes de log para poder verificar qué botón pulsamos en el diálogo. El aspecto visual de nuestro diálogo de confirmación sería el siguiente:

dialogo-confirmacion

Diálogo de Selección

Cuando las opciones a seleccionar por el usuario no son sólo dos, como en los diálogos de confirmación, sino que el conjunto es mayor podemos utilizar los diálogos de selección para mostrar una lista de opciones entre las que el usuario pueda elegir.

Para ello también utilizaremos la clase AlertDialog, pero esta vez no asignaremos ningún mensaje ni definiremos las acciones a realizar por cada botón individual, sino que directamente indicaremos la lista de opciones a mostrar (mediante el método setItems()) y proporcionaremos la implementación del evento onClick() sobre dicha lista (mediante un listener de tipo DialogInterface.OnClickListener), evento en el que realizaremos las acciones oportunas según la opción elegida. La lista de opciones la definiremos como un array tradicional. Veamos cómo:

public class DialogoSeleccion extends DialogFragment {
    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {

	 final String[] items = {"Español", "Inglés", "Francés"};

        AlertDialog.Builder builder =
        		new AlertDialog.Builder(getActivity());

        builder.setTitle("Selección")
           .setItems(items, new DialogInterface.OnClickListener() {
	    	    public void onClick(DialogInterface dialog, int item) {
	    	        Log.i("Dialogos", "Opción elegida: " + items[item]);
	    	    }
	    	});

        return builder.create();
    }
}

En este caso el diálogo tendrá un aspecto similar a la interfaz mostrada para los controles Spinner.

dialogo-seleccion

Este diálogo permite al usuario elegir entre las opciones disponibles cada vez que se muestra en pantalla. Pero, ¿y si quisiéramos recordar cuál es la opción u opciones seleccionadas por el usuario para que aparezcan marcadas al visualizar de nuevo el cuadro de diálogo? Para ello podemos utilizar los métodos setSingleChoiceItems() o setMultiChiceItems(), en vez de el setItems() utilizado anteriormente. La diferencia entre ambos métodos, tal como se puede suponer por su nombre, es que el primero de ellos permitirá una selección simple y el segundo una selección múltiple, es decir, de varias opciones al mismo tiempo, mediante controles CheckBox.

La forma de utilizarlos es muy similar a la ya comentada. En el caso de setSingleChoiceItems(), el método tan sólo se diferencia de setItems() en que recibe un segundo parámetro adicional que indica el índice de la opción marcada por defecto. Si no queremos tener ninguna de ellas marcadas inicialmente pasaremos el valor -1.

builder.setTitle("Selección")
      .setSingleChoiceItems(items, -1,
    		   new DialogInterface.OnClickListener() {
    	    public void onClick(DialogInterface dialog, int item) {
    	        Log.i("Dialogos", "Opción elegida: " + items[item]);
    	    }
    	});

De esta forma conseguiríamos un diálogo como el de la siguiente imagen:

dialogo-seleccion-single

Si por el contrario optamos por la opción de selección múltiple, la diferencia principal estará en que tendremos que implementar un listener del tipo DialogInterface.OnMultiChoiceClickListener. En este caso, en el evento onClick recibiremos tanto la opción seleccionada (item) como el estado en el que ha quedado (isChecked). Además, en esta ocasión, el segundo parámetro adicional que indica el estado por defecto de las opciones ya no será un simple número entero, sino que tendrá que ser un array de booleanos. En caso de no querer ninguna opción seleccionada por defecto pasaremos el valor null.

builder.setTitle("Selección")
    .setMultiChoiceItems(items, null,
    	new DialogInterface.OnMultiChoiceClickListener() {
      	public void onClick(DialogInterface dialog, int item, boolean isChecked) {
             Log.i("Dialogos", "Opción elegida: " + items[item]);
       }
});

Y el diálogo nos quedaría de la siguiente forma:

dialogo-seleccion-multi

Tanto si utilizamos la opción de selección simple como la de selección múltiple, para salir del diálogo tendremos que pulsar la tecla «Atrás» de nuestro dispositivo.

Diálogos Personalizados

Por último, vamos a comentar cómo podemos establecer completamente el aspecto de un cuadro de diálogo. Para esto vamos a actuar como si estuviéramos definiendo la interfaz de una actividad, es decir, definiremos un layout XML con los elementos a mostrar en el diálogo. En mi caso voy a definir un layout de ejemplo llamado dialog_personal.xml que colocaré como siempre en la carpeta res/layout. Contendrá por ejemplo una imagen a la izquierda y dos líneas de texto a la derecha:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal"
    android:padding="3dp" >

    <ImageView
        android:id="@+id/imageView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@drawable/ic_launcher" />

    <LinearLayout
        android:layout_width="wrap_content"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:padding="3dp">

        <TextView
            android:id="@+id/textView1"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/dialogo_linea_1" />

        <TextView
            android:id="@+id/textView2"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="@string/dialogo_linea_2" />

    </LinearLayout>

</LinearLayout>

Por su parte, en el método onCreateDialog() correspondiente utilizaremos el método setView() del builder para asociarle nuestro layout personalizado, que previamente tendremos que inflar como ya hemos comentado otras veces utilizando el método inflate(). Finalmente podremos incluir botones tal como vimos para los diálogos de alerta o confirmación. En este caso de ejemplo incluiremos un botón de Aceptar.

public class DialogoPersonalizado extends DialogFragment {
    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {

	AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
	LayoutInflater inflater = getActivity().getLayoutInflater();

	builder.setView(inflater.inflate(R.layout.dialog_personal, null))
	   .setPositiveButton("Aceptar", new DialogInterface.OnClickListener() {
	       public void onClick(DialogInterface dialog, int id) {
	              dialog.cancel();
	       }
	});

	return builder.create();
    }
}

De esta forma, si ejecutamos de nuevo nuestra aplicación de ejemplo y lanzamos el diálogo personalizado veremos algo como lo siguiente:

dialogo-personalizado

Y con esto terminamos con el apartado dedicado a notificaciones en Android. Hemos comentado los tres principales mecanismos de Android a la hora de mostrar mensajes y notificaciones al usuario (Toast, Barra de Estado, y Diálogos), todos ellos muy útiles para cualquier tipo de aplicación y que es importante conocer bien para poder decidir entre ellos dependiendo de las necesidades que tengamos.

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

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

30 comentarios

Desarrollo en Android | sgoliver.net blog 05/11/2011 - 13:53

[…] Notificaciones en Android (III): Diálogos [Nuevo!] […]

Responder
César 14/11/2011 - 10:56

Duda. Cuando implemento el AlertBox, recibo el siguiente error cuando hacemos el builder.setPositiveButton(«ok», new OnClickListener (…)

Multiple markers at this line
– The method setPositiveButton(int, DialogInterface.OnClickListener) in the type AlertDialog.Builder is not applicable for the arguments
(String, new View.OnClickListener(){})
– The type new View.OnClickListener(){} must implement the inherited abstract method View.OnClickListener.onClick(View)

¿Alguna idea? ¿Podría ser por estar implementándolo sobre Android 2.2 y no la 2.3 ?

Responder
sgoliver 14/11/2011 - 12:01

Hola Cesar,

los errores están causados porque el segundo parámetro de setPositiveButton() no es del tipo View.OnClickListener (tal como lo está entendiendo el compilador), sino de tipo DialogInterface.OnClickListener.

El problema estará en los import que tengas definidos al principio del código. Probáblemente tengas incluido un «import android.view.OnClickListener» o «import android.view.*» para utilizarlo en los eventos de los botones, de ahí que el compilador piense que es ése el que pretendes utilizar. Cambia tu código por algo así como:

builder.setPositiveButton(«OK», new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {

}
});

Si revisas el código fuente que proporciono con mi articulo verás que yo defino los import justo al revés, de ahí que tenga que usar «View.OnClickListener» en los eventos de los botones y simplemente «OnClickListener» en los eventos del AlertDialog.

Responder
Cristian Garrido 16/11/2011 - 20:28

Como hago para lanzar un dialog desde un boton??
al entrar en la escritura del metodo onClick() el contexto ya no es el mismo. lo guardo en una variale fuera de este,pero aun asi no me resulta

Responder
sgoliver 16/11/2011 - 22:01

Hola Cristian, en el código fuente de este artículo hago exactamente lo que estas preguntando. Revísalo por si te sirve.

Responder
Cristian Garrido 16/11/2011 - 21:00

ya lo hice :D
tenia que anteponer el nombre del activity (main.this)

ahora.. se puede agragar una imagen entre el texto y el radiobutton?

Responder
Cristian Garrido 17/11/2011 - 3:03

si ya lo vi gracias por la respuesta.

pero a lo segundo. se puede poner una imagen en la opcion del dialog?

Responder
zackis 19/12/2011 - 3:47

Hola:

Estoy tratando de implementar un Dialog del tipo Text Entry para hacer un inicio de sesión (lo típico de rellenar dos cajas para nombre de usuario y contraseña)
Pero no llego a conseguir capturar los textos de las cajas al pulsar en el botón OK del Dialog. La parte programada para el botón de Cancelar, en cambio si funciona.

¿Podría darme alguna sugerencia o poner algún ejemplo de este tipo de Dialog?

Responder
zackis 19/12/2011 - 11:49

Hola:
Ya resolví en principio el problema en mi Dialog del tipo Text Entry.
El error estaba en haberme equivocado al poner IDs en el XML que carga el Dialog. Había puesto un ID a un TextView que tenía que ser para un EditText.
Claro luego me daba error porque desde la Actividad asignaba una variable EditText a ese ID que erróneamente se refería a un TextView y por eso saltaba el error.

Responder
Jose 12/02/2012 - 13:46

Hola:
Estoy empezando con android, estoy con un manual y tu curso y he creado un menú de opciones que de momento no hace nada pero me gustaría mostrar un mensaje sencillo (simplemente para practicar y saber si se puede hacer) pero no me muestra nada, sin embargo un toast si que lo muestra, mi duda es: ¿si se puede mostrar este mensaje al hacer click sobre el ítem de menú o simplemente no se puede? Ahí va mi trozo de código:

public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
MenuInflater inflater = getMenuInflater();//menu inflater objeto capaz de leer de un fichero xml de tipo menu
inflater.inflate(R.menu.main_menu, menu);
return true;
}
public boolean onOptionsItemSelected(MenuItem item){
switch (item.getItemId()){
case R.id.m_player:
// showPlayer();
//Toast.makeText(getApplicationContext(), «Has pulsado usuario»,Toast.LENGTH_LONG).show();
AlertDialog.Builder ventana = new AlertDialog.Builder(this);
ventana.setTitle(«Informacion»)
.setMessage(«esto es un mensaje de alerta»)
.setPositiveButton(«OK», new OnClickListener() {

public void onClick(DialogInterface dialog, int which) {
dialog.cancel();
}
});
AlertDialog alerta = ventana.create();
break;
case R.id.m_howto:
showHowto();
break;
case R.id.m_about:
showAbout();
break;
}
return true;

}
El case son los 3 items de menú en los dos últimos no debe hacer nada

Responder
Jordi 01/03/2012 - 17:15

Para incluir un icono debes añadir un –> builder.setIcon(R.drawable.NOMBRE_ICONO);

Justo hoy me creé una clase para hacer dialogs sencillos de error/aviso (título, cuerpo, botón). No hace más que enseñar el diálogo y disiparse.

Por si a alguien le sirve.. os la adjunto, tened en cuenta que el título y mensaje de botón lo tengo por archivo Strings.

desde la actividad que se quiera llamar
————————————————-
private DialegError dialogo = new DialegError(this); //importante, si no estás en una actividad, no te funcionará, necesitas ponerle la referencia a la actividad.

dialogo.crearDialeg(«Esto es un aviso»);

CLASSE DEL DIÁLOGO ‘DialegError’
———————————————–
public class DialegError {
Activity activitat;

public DialegError(Activity activitat){
this.activitat=activitat;
}
public void crearDialeg(String cos){
new AlertDialog.Builder(this.activitat)
.setTitle( this.activitat.getString(R.string.error_dialeg_error_majuscula) )
.setMessage( cos )
// .setIcon(R.drawable.ICONO) //añadir icono
.setPositiveButton( this.activitat.getString(R.string.error_dialeg_acceptar_majuscula), new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
Log.d( «AlertDialog», «Acceptat» );
return; //cierra el diálogo. Siempre puedes hacerle hacer algo.
}
})
.show();
}

——————————–

sgoliver gracias por tu trabajo, me ha ayudado mucho a aprender :D

Responder
Alberto 18/04/2012 - 12:05

Hola. En una actividad, tengo un método que hace dos cosas: primero mostrar un alertDialog, y luego cerrar la actividad e iniciar otra. Antes tenía un Toast y me sobrevivía, es decir, permanecía al cambiar de activity, que es lo que quiero, ya que le tenía puesto getApplicationContext(). En el alertDialog no puedo ponerlo, y entonces se me cierra instantáneamente al finalizar la actividad justo después. ¿Cómo puedo hacer para que no dependa de la actividad donde lo creo? Gracias!

Responder
Alvaro 29/07/2012 - 12:53

Buenas, me gustaría poder usar un AlertDialog y que en su interior, en vez de aparecer texto apareciera un ratingBar para dar una votación, pero no se como podría hacerlo,

alguien que me ayude?

Responder
Fernando 16/04/2013 - 13:49

Hola,
Estoy intentando hacer lo siguiente.
En un momento de mi aplicación, genero un dialog de confirmación para terminar la acción.
Este dialog, solo salta en determinadas ocasiones. Lo que quiero hacer es que cuando salte el dialog, se «pare» la ejecución hasta que el usuario clicke en si o en no, y recuperar el valor pulsado para entonces continuar con el programa en función de la elección del usuario.
Un saludo,

Responder
Junior Placencia 30/05/2013 - 0:10

Hola estoy intentando agregar un EditText dentro del AlertDialog y hacer una conversión, pero no me arroja nada, lo estoy llamando desde un boton. Ayuda :c

AlertDialog.Builder mensaje = new AlertDialog.Builder(this);
mensaje.setTitle(«Cantidad»);
mensaje.setMessage(«Favor de Ingresar la Cantidad:»);

EditText editable = new EditText(this);
mensaje.setView(editable);
cantidad = editable.getText().toString();

mensaje.setPositiveButton(«Aceptar», new DialogInterface.OnClickListener() {

@Override
public void onClick(DialogInterface dialog, int which) {
// TODO Auto-generated method stub
}
});

mensaje.setNegativeButton(«Cancelar», new DialogInterface.OnClickListener() {

@Override
public void onClick(DialogInterface dialog, int which) {
// TODO Auto-generated method stub
}
});

AlertDialog alertDialog = mensaje.create();
alertDialog.show();

Responder
john 24/08/2013 - 6:00

Hola.
estoy intentando desde un dialogo, que me muestre una actividad….. pero no lo consigo.
El dialogo tiene 2 botones, si y no, al hacer click en si, que muestre la otra actividad…
gracias x la ayuda.

Responder
Jose 30/08/2013 - 12:48

Hola a ver si alguien puede ayudarme ya que no encuentro la solución. Estoy llamando al dialogo desde un listview y quiero que al llamar el dialog pasarle un string. Me podria indicar alguien como se puede hacer? Un saludo y gracias :D

Responder
Diego 25/12/2013 - 23:57

Hola, mi pregunta es sencilla,el código del dialogo lo creo en un archivo .java aparte del que tengo con la activity, mi pregunto es como puedo que el dialogo interactue con la activity principal, como por ejemplo hacer un clear a un adapter.

Responder
Tino 14/04/2014 - 17:59

Buenas,
tengo un problema, me gustaria meter un listview dentro del dialog, cada item de la lista tiene una imagen. ¿Es posible?
Gracias.

Responder
PotterChains 10/07/2014 - 17:25

Amigo, muchas gracias por estos tutos, me han sido de mucha utilidad. :)

Responder
Miguel 18/12/2014 - 19:27

Hola, muchas gracias por el aporte. Tengo una duda respecto a los dialogos de confirmacion …

Si yo quiero que aparezca el cuadro de dialogo en un evento del tipo setOnItemLongClickListener de un elemento de una listView, como se haria?

Responder
Emiliano 05/01/2015 - 15:55

Hola he logrado lanzar el dialogo personalizado con el codigo:

btnPersonalizado.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
FragmentManager fragmentManager = getSupportFragmentManager();
DialogoPersonalizado dialogo = new DialogoPersonalizado();
dialogo.show(fragmentManager, «tagPersonalizado»);
}
});

lo que estoy intentando hace tiempo es modificar el texto de los textView que contiene este dialogo
y no pude lograrlo. Intenté de la siguiete forma:

View vista = inflater.inflate(R.layout.dialogo_materias, null, false);
TextView textView = (TextView) vista.findViewById(R.id.textView1);
textView.setText(«prueba»);

pero no pasa nada

Responder
Emi 08/01/2015 - 21:00

Hola funciona muy bien
pero cuando el dialogo esta abierto y se gira la pantalla la aplicación se detiene (dialogo personalizado)
como podría cerrarlo cuando el usuario gira la pantalla?

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

[…] Notificaciones en Android (III): Diálogos [v3] […]

Responder
Josep 22/11/2015 - 14:08

un cuadro de seleccion personalizado que tenga en cada seleccion una imagen seguido del texto existe?? o ya seria un listview??, si existe como se podria hacer para agregar el icono a cada item del cuadro de seleccion?
gracias!

Responder
leonardo 25/11/2015 - 14:04

Buenos días, hice la clase para el dialogo en la cual le pregunto al usuario si desea eliminar un registro, pero, no sé cómo leer la opción seleccionada en el activity para saber si selecciono aceptar o cancelar y de esta manera seguir con la ejecución.
Si me pudiesen orientar se los agradecería.

Responder
JeFNDZ 07/02/2016 - 22:51

Gracias por tu esfuerzo!

Responder
Jonathan 22/04/2016 - 2:59

Quizás sea algo tarde para pedir una explicación pero no tengo idea de como llamar al dialogo personalizado.
Cuando intento hacerlo con .show me sale que debo agregarle unos parametros pero desconozco cuales son.
Si alguien me puede ayudar, se lo agradecería mucho.

Saludos!

Responder
Joaquín 22/08/2016 - 14:57

Muy buenos tutoriales. mi pregunta es si en un Diálogo de Confirmación ¿se puede cambiar el orden en que aparecen los botones, es decir, que primero aparezca Aceptar y luego Cancelar?

Responder
Roller 15/05/2017 - 7:14

Que tal no se si alguien me pueda ayudar con una duda que tengo, lo que pasa que quiero usar un alert dialog el que me da los valores de yes o no, mi problema es que no se como programar el boton de yes para que al precionar YES me mande a una pagina de internet. No se si alguien me puede ayudar. De antemano Gracias

Responder

Responder a Desarrollo en Android | sgoliver.net blog 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