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

tipos de dialogos en android studio

Question

Sí, sé que hay AlertDialog.Builder, pero me sorprende saber lo difícil (bueno, al menos no es fácil de programar) mostrar un diálogo en Android.

Solía ​​ser un desarrollador .NET, y me pregunto si hay algún equivalente de Android de los siguientes?

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

Answer 1

1.Crear 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 y luego establezcaOnClickListener ():

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.

Answer 2

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í hay un simple ejemplo de todos modos:

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 ese DialogInterface.OnClickListener si tiene otros cuadros de sí / no que deberían hacer lo mismo.

Si está creando el Diálogo desde dentro de View.OnClickListener , puede usar view.getContext() para obtener el Contexto. Alternativamente, puedes usar yourFragmentName.getActivity() .

Answer 3

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()

Answer 4

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();

Answer 5

Gracias, nikki, su respuesta me ha ayudado a mejorar una existente simplemente agregando la 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();

Answer 6

Gracias. Uso la API Nivel 2 (Android 1.1) y en lugar de BUTTON_POSITIVE y BUTTON_NEGATIVE tengo que usar BUTTON1 y BUTTON2 .

Answer 7

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 como lo hacen es porque los diálogos en Android son asíncronos (la ejecución no se detiene cuando se muestra el diálogo). Debido a esto, tiene que usar una devolución de llamada para manejar la selección del usuario.

Echa un vistazo a esta pregunta para una discusión más larga entre las diferencias en Android y .NET (en relación con los diálogos): Diálogos / Alertas: Cómo "bloquear la ejecución" mientras el diálogo está activo (estilo .NET)

Answer 8

La respuesta de Steves es correcta aunque desactualizada 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 dejar que la clase implementara onClickListener y usar eso en lugar de escuchas integradas.

Answer 9

Mostrar el diálogo de forma anónima como una 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();

Answer 10

Preguntar a una persona si quiere llamar o no a Dialog.

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();
}
}

Answer 11

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();

Answer 12

Puedes hacerlo tan fácil en Kotlin:

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

Answer 13

Todas las respuestas aquí se reducen a un código largo y no fácil de leer: lo que la persona que preguntaba 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 complemento retrolambda ( https://github.com/evant/gradle-retrolambda ), pero es muy útil para escribir un código más limpio de todos modos.

Answer 14

puede implementar una solución genérica para decisiones y usarla 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 transferir datos:

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 utilidades 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; Puedes usar esto en tu 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 ...
}
};
}
}

Answer 15

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();