Comment afficher une boîte de dialogue Oui / Non sur Android?
Oui, je sais qu’il existe AlertDialog.Builder, mais je suis choqué de savoir à quel point il est difficile (du moins, ce n’est pas convivial pour les programmeurs) d’afficher une boîte de dialogue sous Android.
J'avais l'habitude d'être un développeur .NET, et je me demande s'il existe un équivalent Android du suivant.
if (MessageBox.Show("Sure?", "", MessageBoxButtons.YesNo) == DialogResult.Yes){
// Do something...
}
AlertDialog.Builder n’est vraiment pas si difficile à utiliser. C'est certes un peu intimidant au début, mais une fois que vous l'avez utilisé, c'est à la fois simple et puissant. Je sais que vous avez dit que vous savez comment l'utiliser, mais voici simplement un exemple 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();
Vous pouvez également réutiliser ce DialogInterface.OnClickListener si vous avez d'autres boîtes oui/non qui devraient faire la même chose.
Si vous créez le dialogue à partir d'un View.OnClickListener, vous pouvez utiliser view.getContext() pour obtenir le contexte. Vous pouvez également utiliser yourFragmentName.getActivity().
Essaye ça:
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 réponse de Steve H est exacte, mais voici un peu plus d'informations: les dialogues fonctionnent comme ils le font parce que les dialogues dans Android sont asynchrones (l'exécution ne s'arrête pas lorsque le dialogue est affiché). De ce fait, vous devez utiliser un rappel pour gérer la sélection de l'utilisateur.
Consultez cette question pour une discussion plus longue entre les différences entre Android et .NET (en ce qui concerne les boîtes de dialogue): Dialogs/AlertDialogs: Comment "bloquer l’exécution" lorsque la boîte de dialogue est active (. NET-style)
Cela fonctionne pour moi:
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();
Demander à une personne si elle veut appeler ou non 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();
}
}
La réponse de Steves est correcte mais obsolète avec des fragments. Voici un exemple avec FragmentDialog.
La classe:
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();
}
}
Pour démarrer le dialogue:
FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
// Create and show the dialog.
SomeDialog newFragment = new SomeDialog ();
newFragment.show(ft, "dialog");
Vous pouvez également laisser la classe implémenter onClickListener et l'utiliser à la place des écouteurs incorporés.
Merci Nikki, ta réponse m'a aidé à améliorer un existant simplement en ajoutant l'action souhaitée comme suit
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();
À 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()
Afficher la boîte de dialogue de manière anonyme en chaîne de commandes et sans définir d’autre objet:
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();
Vous pouvez le faire facilement à Kotlin:
alert("Testing alerts") {
title = "Alert"
yesButton { toast("Yess!!!") }
noButton { }
}.show()
Toutes les réponses ici se résument à un code long et difficile à lire: exactement ce que la personne qui demandait essayait d'éviter. Pour moi, l’approche la plus simple consiste à employer des lambdas ici:
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();
Les Lambdas dans Android requièrent le plugin retrolambda ( https://github.com/evant/gradle-retrolambda ), mais il est extrêmement utile pour écrire du code plus propre.
Merci. J'utilise l'API Level 2 (Android 1.1) et au lieu de BUTTON_POSITIVE et BUTTON_NEGATIVE, je dois utiliser BUTTON1 et BUTTON2.
1.Créez le message, le titre et le bouton Positif, Négatif:
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.Maintenant trouvez les deux boutons sur DialogInterface Cliquez ensuite sur setOnClickListener ():
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.Pour afficher Alertdialog:
alertDialog.show();
Remarque: n'oubliez pas le mot-clé final avec AlertDialog.
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();
vous pouvez implémenter une solution générique pour les décisions et l'utiliser dans un autre cas, pas seulement pour oui/non et personnaliser l'alerte avec des animations ou une présentation:
Quelque chose comme ça; commencez par créer votre classe pour le transfert de données:
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;
}
}
après une interface pour retourner le résultat
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);
}
Vous pouvez maintenant créer facilement des utilitaires d’accès (dans cette classe, vous pouvez implémenter une animation ou une présentation personnalisée pour l’alerte):
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();
}
}
et le dernier appel en activité ou fragment; vous pouvez l'utiliser dans votre cas ou pour une autre tâche:
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 ...
}
};
}
}