Wie wird ein Ja / Nein-Dialogfeld unter Android angezeigt?

358

Ja, ich weiß, dass es AlertDialog.Builder gibt, aber ich bin schockiert zu wissen, wie schwierig (zumindest nicht programmiererfreundlich) es ist, einen Dialog in Android anzuzeigen.

Ich war früher ein .NET-Entwickler und frage mich, ob es ein Android-Äquivalent der folgenden gibt?

if (MessageBox.Show("Sure?", "", MessageBoxButtons.YesNo) == DialogResult.Yes){
    // Do something...
}
Solo
quelle
3
Wie speichere ich AlertDialog-Code und behandle Ereignisse (Ja, Nein-Aktionen) in allen Bildschirmen? In .Net verwenden wir die Action-Klasse, um die Ereignisse zu behandeln. Gibt es eine Möglichkeit, dies zu implementieren? Ich weiß, mit Schnittstellen können wir dies tun, aber auf irgendeine andere Weise?
Ravikumar11
2
Ja ... wir .NET-Entwickler haben es wirklich schwer mit Android ... Ich frage mich, ob Xamarin ein großartiges Tool ist.
Daniel Möller

Antworten:

745

AlertDialog.Builder ist wirklich nicht so schwer zu bedienen. Anfangs ist es sicher ein bisschen einschüchternd, aber wenn Sie es einmal benutzt haben, ist es sowohl einfach als auch mächtig. Ich weiß, dass Sie gesagt haben, Sie wissen, wie man es benutzt, aber hier ist trotzdem nur ein einfaches Beispiel:

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

Sie können dies auch wiederverwenden, DialogInterface.OnClickListenerwenn Sie andere Ja / Nein- Felder haben, die dasselbe tun sollten.

Wenn Sie den Dialog innerhalb von a erstellen View.OnClickListener, können view.getContext()Sie den Kontext abrufen. Alternativ können Sie verwenden yourFragmentName.getActivity().

Steve Haley
quelle
3
neuer AlertDialog.Builder (this); Fehler bei der Kompilierung: 'Der Konstruktor AlertDialog.Builder (neuer View.OnClickListener () {}) ist undefiniert'
Eric Leschinski
3
Der einfache und nützliche Dialog wird sich übrigens selbst schließen, nachdem der Benutzer auf "JA" oder "NEIN" geklickt hat. Sie müssen nichts tun.
RRTW
9
Ich selbst habe es oft benutzt. Aber ich habe festgestellt, dass es tatsächlich einfacher und schneller ist, es auf SO nachzuschlagen. Das hier angegebene Codebeispiel ist so einfach ... Ich wünschte wirklich, die Android-Dokumentation würde so aussehen.
Radu
4
@EricLeschinski wahrscheinlich "dies" ist kein Kontext, versuchen Sie diesen: AlertDialog.Builder builder = new AlertDialog.Builder(getView().getContext());
cldrr
1
@davidglorioso Die Reihenfolge von Ja / Nein oder Nein / Ja hängt von der Version von Android ab und kann nicht gesteuert werden. Ich erinnere mich nicht, wann es sich geändert hat, aber ich denke, es war in 4.x oder 5. Wenn du das sagst, solltest du es sowieso nicht ändern. Alle Apps, die Standard-Warndialoge verwenden, verwenden dieselbe Nein / Ja-Tastenreihenfolge, und es wäre für Benutzer verwirrend, wenn Ihre anders wären. Wenn Sie wirklich möchten, dass es anders ist, müssen Sie Ihre positiven / negativen Schaltflächen abhängig von der Android-Version manuell einstellen.
Steve Haley
163

Versuche dies:

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();
Nikki
quelle
25
Persönlich mag ich diesen Code-Ausschnitt mehr als die akzeptierte Antwort
John
1
@nikki warum haben beide entlassen ()?
Likejudo
The constructor AlertDialog.Builder(MainActivity.DrawerItemClickListener) is undefined
Hash
@likejiujitsu, weil Sie den Dialog auf jeden Fall nach Ihrer Arbeit aus dem Speicher löschen möchten.
Avi Levin
32

Die Antwort von Steve H ist genau richtig, aber hier sind ein paar weitere Informationen: Der Grund dafür, dass Dialoge so funktionieren, wie sie funktionieren, ist, dass Dialoge in Android asynchron sind (die Ausführung stoppt nicht, wenn der Dialog angezeigt wird). Aus diesem Grund müssen Sie einen Rückruf verwenden, um die Auswahl des Benutzers zu handhaben.

In dieser Frage finden Sie eine längere Diskussion zwischen den Unterschieden zwischen Android und .NET (in Bezug auf Dialoge): Dialoge / AlertDialogs: So blockieren Sie die Ausführung, während der Dialog aktiv ist (.NET-Stil)

Erich Douglass
quelle
8
Dank der Tatsache, dass Android-Dialoge asynchron sind, wird jetzt alles klar (und vernünftig). Scheint, als müsste ich bei der Entwicklung von Apps für Android "aus .Net herausdenken" :)
Solo
Zu Ihrer Information: Was Sie als "asynchroner Dialog" bezeichnen, wird in der GUI-Terminologie als "modellloser Dialog" bezeichnet, während "synchroner Dialog" als "modaler Dialog" bezeichnet wird. Android bietet keine modalen Dialoge (außer in Ausnahmefällen).
Alex
Android erlaubt aus einem sehr guten Grund keine systemmodalen Dialoge: Es ist nicht gestattet, andere Apps auf dem Gerät zu stören.
Renascienza
14

Das funktioniert bei mir:

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

Fragen Sie eine Person, ob sie Dialog anrufen möchte oder nicht.

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();
    }    
}
Zar E Ahmer
quelle
5

Steves Antwort ist richtig, obwohl sie mit Fragmenten veraltet ist. Hier ist ein Beispiel mit FragmentDialog.

Die Klasse:

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

So starten Sie den Dialog:

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

Sie können die Klasse auch implementieren onClickListenerund verwenden lassen, anstatt eingebettete Listener.

Warpzit
quelle
@likejiujitsu oben ist ausreichend.
Warpzit
Das Erstellen einer FragmentDialog-Klasse, nur um ein Nein / Ja-Feld zu erstellen, ist etwas übertrieben ... :) Ein Standard-AlertDialog ist noch fair genug.
Renascienza
@ Renascienza ja, aber ich glaube, es ist veraltet.
Warpzit
Nicht wirklich. FragmentDialog wurde als nützliche Funktion hinzugefügt, damit Sie ein Fragment in einem Dialogfeld wiederverwenden können. Bei Fragmenten dreht sich alles um die Wiederverwendung der Benutzeroberfläche. Da Sie keine Fragmente verwenden müssen, nur weil dies neu ist (Fragmente ersetzen keine Aktivitäten), müssen Sie FragmentDialog nicht in Fällen verwenden, in denen kein Gewinn zu erzielen ist. Zum Beispiel einfache Ja / Nein-Warnungen.
Renascienza
2
Meine Empfehlung lautet: Wenn Sie nicht nur ein Layout, sondern auch Hintergrund- und Lebenszykluscode wiederverwenden müssen, verwenden Sie ein Fragment-Dialogfeld. Mit dem Fragment haben Sie die zugehörige Steuerung des Aktivitätslebenszyklus und können auf Ereignisse wie Erstellen (da die Benutzeroberfläche neu erstellt wird, wenn der Benutzer sein Gerät dreht), Pause, Fortsetzen usw. Kurz gesagt, ein Dialog mit einer ausgearbeiteten Benutzeroberfläche. Wenn Sie dies nicht benötigen und Ihr Dialog ziemlich einfach ist, funktionieren reguläre Dialoge einwandfrei.
Renascienza
5

Vielen Dank, Nikki. Ihre Antwort hat mir geholfen, eine bestehende zu verbessern, indem Sie einfach meine gewünschte Aktion wie folgt hinzugefügt haben

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();
CrandellWS
quelle
Ich hatte den Eindruck, dass das OP AlertDialog.Builder nicht verwenden wollte. OP wats zu wissen, ob es eine Verknüpfungsdienstprogrammmethode gibt,
walrii
1
Ich habe den gleichen Code geschrieben , aber NEIN erscheint zuerst und dann JA im Grunde ist es ein NO / YES Dialogfeld , aber ich brauche ein JA / NEIN Dialogfeld Wie kann ich es tun
Sagar Devanga
Was das JA / NEIN vs NEIN / JA betrifft, siehe diese Antwort: stackoverflow.com/a/13644589/1815624 Sie können es wie in dieser Antwort beschrieben manipulieren: stackoverflow.com/a/13644536/1815624
CrandellWS
4

In 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()
Cristan
quelle
3

Dialog anonym als Befehlskette anzeigen & ohne ein anderes Objekt zu definieren:

 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();
Hitesh Sahu
quelle
2

Alle Antworten hier beschränken sich auf langwierigen und nicht leserfreundlichen Code: genau das, was die fragende Person zu vermeiden versuchte. Für mich war es am einfachsten, hier Lambdas einzusetzen:

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 in Android benötigen das Retrolambda-Plugin ( https://github.com/evant/gradle-retrolambda ), aber es ist trotzdem sehr hilfreich, um saubereren Code zu schreiben.

Javaxian
quelle
1

Vielen Dank. Ich benutze die API Level 2 (Android 1.1) und statt BUTTON_POSITIVEund muss BUTTON_NEGATIVEich BUTTON1und verwenden BUTTON2.

Christian
quelle
1

1.Create AlertDialog set message, title und 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.Jetzt finden Sie beide Schaltflächen auf DialogInterface. Klicken Sie dann auf 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.Um Alertdialog anzuzeigen:

alertDialog.show();

Hinweis: Vergessen Sie das endgültige Schlüsselwort mit AlertDialog nicht.

Wajid Khan
quelle
0
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();  
Singhak
quelle
0

Sie können eine generische Lösung für Entscheidungen implementieren und in einem anderen Fall nicht nur für Ja / Nein verwenden und die Warnung mit Animationen oder Layout anpassen:

Etwas wie das; Erstellen Sie zuerst Ihre Klasse für die Übertragung von Daten:

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

nach einer Schnittstelle zur Rückgabe des Ergebnisses

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

Jetzt können Sie auf einfache Weise Dienstprogramme für den Zugriff erstellen (in dieser Klasse können Sie verschiedene Animationen oder benutzerdefinierte Layouts für die Warnung implementieren):

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

und der letzte Aufruf in Aktivität oder Fragment; Sie können dies in Ihrem Fall oder für andere Aufgaben verwenden:

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 ...
            }
        };
    }
} 
Alex Zaraos
quelle
0

In Kotlin geht das ganz einfach:

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

Für Kotlin in Android ::

    override fun onBackPressed() {
        confirmToCancel()
    }

    private fun confirmToCancel() {
        AlertDialog.Builder(this)
            .setTitle("Title")
            .setMessage("Do you want to cancel?")
            .setCancelable(false)
            .setPositiveButton("Yes") {
                dialog: DialogInterface, _: Int ->
                dialog.dismiss()
                // for sending data to previous activity use
                // setResult(response code, data)
                finish()
            }
            .setNegativeButton("No") {
                dialog: DialogInterface, _: Int ->
                dialog.dismiss()
            }
            .show()
    } 
Partha Paul
quelle
0

Kotlin Implementierung.

Sie können eine einfache Funktion wie folgt erstellen:

fun dialogYesOrNo(
        activity: Activity,
        title: String,
        message: String,
        listener: DialogInterface.OnClickListener
    ) {
        val builder = AlertDialog.Builder(activity)
        builder.setPositiveButton("Yes", DialogInterface.OnClickListener { dialog, id ->
            dialog.dismiss()
            listener.onClick(dialog, id)
        })
        builder.setNegativeButton("No", null)
        val alert = builder.create()
        alert.setTitle(title)
        alert.setMessage(message)
        alert.show()
    }

und nenne es so:

dialogYesOrNo(
  this,
  "Question",
  "Would you like to eat?",
  DialogInterface.OnClickListener { dialog, id ->
    // do whatever you need to do when user presses "Yes"
  }
})
Christian
quelle