¿Cómo mostrar un cuadro de diálogo Sí / No en Android?

Sí, sé que hay AlertDialog.Builder, pero estoy sorprendido de saber lo difícil (bueno, al menos no amigable para los progtwigdores) de mostrar un diálogo en Android.

Solía ​​ser un desarrollador de .NET, y me pregunto si existe algún equivalente de Android de lo siguiente.

if (MessageBox.Show("Sure?", "", MessageBoxButtons.YesNo) == DialogResult.Yes){ // Do something... } 

AlertDialog.Builder realmente no es tan difícil de usar. Es un poco intimidante al principio seguro, pero una vez que lo has usado un poco es simple y poderoso. Sé que has dicho que sabes cómo usarlo, pero aquí solo hay un ejemplo simple:

 DialogInterface.OnClickListener dialogClickListener = new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { switch (which){ case DialogInterface.BUTTON_POSITIVE: //Yes button clicked break; case DialogInterface.BUTTON_NEGATIVE: //No button clicked break; } } }; AlertDialog.Builder builder = new AlertDialog.Builder(context); builder.setMessage("Are you sure?").setPositiveButton("Yes", dialogClickListener) .setNegativeButton("No", dialogClickListener).show(); 

También puede reutilizar DialogInterface.OnClickListener si tiene otros cuadros de sí / no que deberían hacer lo mismo.

Si está creando el View.OnClickListener de diálogo desde View.OnClickListener , puede usar view.getContext() para obtener el contexto. Alternativamente, puede usar yourFragmentName.getActivity() .

Prueba esto:

 AlertDialog.Builder builder = new AlertDialog.Builder(this); builder.setTitle("Confirm"); builder.setMessage("Are you sure?"); builder.setPositiveButton("YES", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { // Do nothing but close the dialog dialog.dismiss(); } }); builder.setNegativeButton("NO", new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { // Do nothing dialog.dismiss(); } }); AlertDialog alert = builder.create(); alert.show(); 

La respuesta de Steve H es acertada, pero aquí hay un poco más de información: la razón por la que los diálogos funcionan de la forma en que lo hacen es porque los diálogos en Android son asincrónicos (la ejecución no se detiene cuando se muestra el diálogo). Debido a esto, debe usar una callback para manejar la selección del usuario.

Vea esta pregunta para una discusión más larga entre las diferencias en Android y .NET (en lo que se refiere a los diálogos): Diálogos / AlertDialogs: Cómo “bloquear la ejecución” mientras el diálogo está activo (estilo .NET)

Esto es trabajo para mí:

 AlertDialog.Builder builder = new AlertDialog.Builder(getApplicationContext()); builder.setTitle("Confirm"); builder.setMessage("Are you sure?"); builder.setPositiveButton("YES", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { // Do nothing, but close the dialog dialog.dismiss(); } }); builder.setNegativeButton("NO", new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { // Do nothing dialog.dismiss(); } }); AlertDialog alert = builder.create(); alert.show(); 

Gracias, Nikki, tu respuesta me ha ayudado a mejorar una existente simplemente agregando mi acción deseada de la siguiente manera

 AlertDialog.Builder builder = new AlertDialog.Builder(this); builder.setTitle("Do this action"); builder.setMessage("do you want confirm this action?"); builder.setPositiveButton("YES", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { // Do do my action here dialog.dismiss(); } }); builder.setNegativeButton("NO", new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { // I do not need any action here you might dialog.dismiss(); } }); AlertDialog alert = builder.create(); alert.show(); 

La respuesta de Steves es correcta aunque anticuada con fragmentos. Aquí hay un ejemplo con FragmentDialog.

La clase:

 public class SomeDialog extends DialogFragment { @Override public Dialog onCreateDialog(Bundle savedInstanceState) { return new AlertDialog.Builder(getActivity()) .setTitle("Title") .setMessage("Sure you wanna do this!") .setNegativeButton(android.R.string.no, new OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { // do nothing (will close dialog) } }) .setPositiveButton(android.R.string.yes, new OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { // do something } }) .create(); } } 

Para iniciar el diálogo:

  FragmentTransaction ft = getSupportFragmentManager().beginTransaction(); // Create and show the dialog. SomeDialog newFragment = new SomeDialog (); newFragment.show(ft, "dialog"); 

También podría permitir que la clase implemente onClickListener y usar eso en lugar de oyentes incrustados.

Preguntarle a una persona si quiere llamar o no dialogar …

 import android.app.Activity; import android.app.AlertDialog; import android.content.DialogInterface; import android.content.Intent; import android.net.Uri; import android.os.Bundle; import android.view.View; import android.view.View.OnClickListener; import android.widget.ImageView; import android.widget.Toast; public class Firstclass extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.first); ImageView imageViewCall = (ImageView) findViewById(R.id.ring_mig); imageViewCall.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { try { showDialog("0728570527"); } catch (Exception e) { e.printStackTrace(); } } }); } public void showDialog(final String phone) throws Exception { AlertDialog.Builder builder = new AlertDialog.Builder(Firstclass.this); builder.setMessage("Ring: " + phone); builder.setPositiveButton("Ring", new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { Intent callIntent = new Intent(Intent.ACTION_DIAL);// (Intent.ACTION_CALL); callIntent.setData(Uri.parse("tel:" + phone)); startActivity(callIntent); dialog.dismiss(); } }); builder.setNegativeButton("Abort", new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { dialog.dismiss(); } }); builder.show(); } } 

En Kotlin:

 AlertDialog.Builder(this) .setTitle(R.string.question_title) .setMessage(R.string.question_message) .setPositiveButton(android.R.string.yes) { _, _ -> yesClicked() } .setNegativeButton(android.R.string.no) { _, _ -> noClicked() } .show() 

Gracias. Utilizo API Level 2 (Android 1.1) y en lugar de BUTTON_POSITIVE y BUTTON_NEGATIVE tengo que usar BUTTON1 y BUTTON2 .

Todas las respuestas aquí se reducen a un código extenso y no de fácil lectura: justo lo que la persona que pregunta estaba tratando de evitar. Para mí, el enfoque más fácil es emplear lambdas aquí:

 new AlertDialog.Builder(this) .setTitle("Are you sure?") .setMessage("If you go back you will loose any changes.") .setPositiveButton("Yes", (dialog, which) -> { doSomething(); dialog.dismiss(); }) .setNegativeButton("No", (dialog, which) -> dialog.dismiss()) .show(); 

Lambdas en Android requiere el plugin de retrolambda ( https://github.com/evant/gradle-retrolambda ), pero de todos modos es muy útil para escribir un código más limpio.

Mostrar diálogo anónimamente como cadena de comandos y sin definir otro objeto:

  new AlertDialog.Builder(this).setTitle("Confirm Delete?") .setMessage("Are you sure?") .setPositiveButton("YES", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { // Perform Action & Dismiss dialog dialog.dismiss(); } }) .setNegativeButton("NO", new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { // Do nothing dialog.dismiss(); } }) .create() .show(); 
 AlertDialog.Builder altBx = new AlertDialog.Builder(this); altBx.setTitle("My dialog box"); altBx.setMessage("Welcome, Please Enter your name"); altBx.setIcon(R.drawable.logo); altBx.setPositiveButton("Ok", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { if(edt.getText().toString().length()!=0) { // Show any message } else { } } }); altBx.setNeutralButton("Cancel", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { //show any message } }); altBx.show(); 

puede implementar una solución genérica para decisiones y utilizarla en otro caso no solo para sí / no y personalizar la alerta con animaciones o diseño:

Algo como esto; primero crea tu clase para los datos de transferencia:

 public class AlertDecision { private String question = ""; private String strNegative = ""; private String strPositive = ""; public AlertDecision question(@NonNull String question) { this.question = question; return this; } public AlertDecision ansPositive(@NonNull String strPositive) { this.strPositive = strPositive; return this; } public AlertDecision ansNegative(@NonNull String strNegative) { this.strNegative = strNegative; return this; } public String getQuestion() { return question; } public String getAnswerNegative() { return strNegative; } public String getAnswerPositive() { return strPositive; } } 

después de una interfaz para devolver el resultado

 public interface OnAlertDecisionClickListener { /** * Interface definition for a callback to be invoked when a view is clicked. * * @param dialog the dialog that was clicked * @param object The object in the position of the view */ void onPositiveDecisionClick(DialogInterface dialog, Object object); void onNegativeDecisionClick(DialogInterface dialog, Object object); } 

Ahora puede crear fácilmente un utils para acceder (en esta clase puede implementar diferentes animaciones o diseños personalizados para la alerta):

 public class AlertViewUtils { public static void showAlertDecision(Context context, @NonNull AlertDecision decision, final OnAlertDecisionClickListener listener, final Object object) { AlertDialog.Builder builder = new AlertDialog.Builder(context); builder.setMessage(decision.getQuestion()); builder.setPositiveButton(decision.getAnswerPositive(), new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { listener.onPositiveDecisionClick(dialog, object); } }); builder.setNegativeButton(decision.getAnswerNegative(), new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { listener.onNegativeDecisionClick(dialog, object); } }); android.support.v7.app.AlertDialog dialog = builder.create(); dialog.show(); } } 

y la última llamada en actividad o fragmento; puede usar esto en su caso o para otra tarea:

 public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity); initResources(); } public void initResources() { Button doSomething = (Button) findViewById(R.id.btn); doSomething.setOnClickListener(getDecisionListener()); } private View.OnClickListener getDecisionListener() { return new View.OnClickListener() { @Override public void onClick(View v) { AlertDecision decision = new AlertDecision() .question("question ...") .ansNegative("negative action...") .ansPositive("positive action... "); AlertViewUtils.showAlertDecision(MainActivity.this, decision, getOnDecisionListener(), v); } }; } private OnAlertDecisionClickListener getOnDecisionListener() { return new OnAlertDecisionClickListener() { @Override public void onPositiveDecisionClick(DialogInterface dialog, Object object) { //do something like create, show views, etc... } @Override public void onNegativeDecisionClick(DialogInterface dialog, Object object) { //do something like delete, close session, etc ... } }; } } 

1.Create AlertDialog set message, title y Positive, Negative Button:

 final AlertDialog alertDialog = new AlertDialog.Builder(this) .setCancelable(false) .setTitle("Confirmation") .setMessage("Do you want to remove this Picture?") .setPositiveButton("Yes",null) .setNegativeButton("No",null) .create(); 

2.Ahora encuentre ambos botones en DialogInterface Haga clic en y luego configureOnClickListener ():

 alertDialog.setOnShowListener(new DialogInterface.OnShowListener() { @Override public void onShow(DialogInterface dialogInterface) { Button yesButton = (alertDialog).getButton(android.app.AlertDialog.BUTTON_POSITIVE); Button noButton = (alertDialog).getButton(android.app.AlertDialog.BUTTON_NEGATIVE); yesButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { //Now Background Class To Update Operator State alertDialog.dismiss(); Toast.makeText(GroundEditActivity.this, "Click on Yes", Toast.LENGTH_SHORT).show(); //Do Something here } }); noButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { alertDialog.dismiss(); Toast.makeText(GroundEditActivity.this, "Click on No", Toast.LENGTH_SHORT).show(); //Do Some Thing Here } }); } }); 

3. Para mostrar Alertdialog:

 alertDialog.show(); 

Nota: no olvide la palabra clave final con AlertDialog.

Puedes hacerlo tan fácil en Kotlin:

  alert("Testing alerts") { title = "Alert" yesButton { toast("Yess!!!") } noButton { } }.show()