Cum să afișați o casetă de dialog Da/Nu pe Android? (Programare, Android, Android Alertdialog)

Solo a intrebat.

Da, știu că există AlertDialog.Builder, dar sunt șocat să aflu cât de dificil (ei bine, cel puțin nu este ușor de programat) să afișezi un dialog în Android.

Am fost dezvoltator .NET și mă întreb dacă există vreun echivalent pentru Android al următoarelor?

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

Comentarii

  • stackoverflow.com/questions/2028697/… –  > Por Mertuarez.
  • Cum pot să reiau codul AlertDialog și să gestionez evenimentele(da, fără acțiuni) în toate ecranele? În .Net folosim clasa Action pentru a gestiona evenimentele, există vreo modalitate de a implementa acest lucru? Știu că folosind interfețe putem face acest lucru, dar există vreo modalitate alternativă? –  > Por Ravikumar11.
  • Da…. noi, dezvoltatorii .NET, chiar ne este greu cu android…. Mă întreb dacă Xamarin este un instrument grozav? –  > Por Daniel Möller.
17 răspunsuri
Steve Haley

AlertDialog.Builder nu este chiar atât de greu de utilizat. Este puțin intimidant la început, cu siguranță, dar odată ce l-ați folosit puțin, este atât simplu, cât și puternic. Știu că ai spus că știi cum să îl folosești, dar iată un exemplu simplu oricum:

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

Puteți, de asemenea, să refolosiți acel DialogInterface.OnClickListener dacă aveți alte da/nu care ar trebui să facă același lucru.

Dacă creați Dialogul din cadrul unui fișier View.OnClickListener, puteți utiliza view.getContext() pentru a obține Contextul. Alternativ, puteți utiliza yourFragmentName.getActivity().

Comentarii

  • new AlertDialog.Builder(this); Eroare de compilare: „Constructorul AlertDialog.Builder(new View.OnClickListener(){}}) este nedefinit”.  > Por Eric Leschinski.
  • Simplu și util, btw, dialogul se va închide singur după ce utilizatorul va face clic pe butonul „DA” sau „NU”. Nu este nimic ce trebuie să faceți. –  > Por RRTW.
  • Eu însumi, l-am folosit de multe ori. Dar am constatat că este de fapt mai ușor și mai rapid să caut pe SO. Exemplul de cod oferit aici este atât de simplu… Chiar mi-aș dori ca documentația Android să arate așa. –  > Por Radu.
  • @EricLeschinski probabil că „this” nu este un context, încercați acesta: AlertDialog.Builder builder = new AlertDialog.Builder(getView().getContext()); –  > Por cldrr.
  • @davidglorioso Ordinea da/nu sau nu/da depinde de versiunea de Android și nu o poți controla. Nu-mi amintesc când s-a schimbat, dar cred că a fost în 4.x sau 5. Spunând asta, oricum nu ar trebui să o schimbi. Toate aplicațiile care folosesc dialoguri de alertă standard vor folosi aceeași ordine a butoanelor „nu/da” și ar fi derutant pentru utilizatori dacă a ta ar fi diferită. Dacă doriți cu adevărat să fie diferită, va trebui să setați manual butoanele pozitive/negative în funcție de versiunea Android. –  > Por Steve Haley.
nikki

Încearcă asta:

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

Comentarii

    26

  • Personal, îmi place acest fragment de cod mai mult decât răspunsul acceptat –  > Por John.
  • @nikki de ce ambele au dismiss() ? –  > Por likejudo.
  • The constructor AlertDialog.Builder(MainActivity.DrawerItemClickListener) is undefined –  > Por hash.
  • @likejiujitsu pentru că vrei să cureți dialogul din memorie în orice caz după ce îți faci treaba. –  > Por Avi Levin.
  • @nikki cum pot obține un argument personalizat în onClick? –  > Por Rohit Nishad.
Erich Douglass

Răspunsul lui Steve H este exact, dar iată câteva informații suplimentare: motivul pentru care dialogurile funcționează așa cum o fac este pentru că dialogurile din Android sunt asincrone (execuția nu se oprește atunci când dialogul este afișat). Din acest motiv, trebuie să folosiți un callback pentru a gestiona selecția utilizatorului.

Consultați această întrebare pentru o discuție mai lungă despre diferențele dintre Android și .NET (în ceea ce privește dialogurile): Dialoguri / AlertDialogs: Cum se poate „bloca execuția” în timp ce dialogul este activat (.NET-style)

Comentarii

  • Mulțumesc, faptul că dialogurile Android sunt asincrone face ca totul să fie clar (și rezonabil) acum. Se pare că trebuie să „gândesc din .Net” atunci când dezvolt aplicații pentru Android 🙂 –  > Por Solo.
  • FYI: ceea ce tu numești „dialog asincron” se numește „dialog fără model” în terminologia GUI, în timp ce „dialogul sincron” se numește „dialog modal”. Android nu dispune de dialoguri modale (cu excepția unor cazuri foarte excepționale). –  > Por Alex.
  • Android nu permite dialoguri modale de sistem dintr-un motiv foarte bun: nu este permis să interfereze cu alte aplicații de pe dispozitiv. –  > Por Renascienza.
hash

Acest lucru funcționează pentru mine:

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

AndroidGeek

Întrebarea unei persoane dacă vrea să sune sau nu 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();
    }    
}

Warpzit

Răspunsul lui Steves este corect, deși depășit cu fragmente. Iată un exemplu cu FragmentDialog.

Clasa:

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

Pentru a începe dialogul:

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

De asemenea, ați putea lăsa clasa să implementeze onClickListener și să folosiți acest lucru în locul ascultătorilor încorporați.

Comentarii

  • @likejiujitsu de mai sus este suficient. –  > Por Warpzit.
  • Crearea unei clase FragmentDialog doar pentru a face o casetă nu/da este un pic de supraproiectare… 🙂 Un AlertDialog implicit este destul de corect, totuși. –  > Por Renascienza.
  • @Renascienza da, dar cred că este învechit. –  > Por Warpzit.
  • Nu chiar. FragmentDialog a fost adăugat ca un lucru util pentru a vă permite să reutilizați un fragment pe un dialog. Fragments se referă la reutilizarea interfeței de utilizare. Deoarece nu este nevoie să folosiți fragmente doar pentru că este un lucru nou (fragmentele nu au venit să înlocuiască activitățile), nu este nevoie să folosiți FragmentDialog în cazurile în care nu este un câștig de făcut. De exemplu, alerte simple de tip Da/Nu. –  > Por Renascienza.
  • Recomandarea mea este: dacă aveți nevoie să reutilizați nu doar un aspect, ci și codul de fundal și de ciclu de viață, utilizați un Fragment dialog. Cu ajutorul fragmentului aveți controlul ciclului de viață al activității aferente și puteți reacționa la evenimente precum crearea (deoarece interfața de utilizare este recreată atunci când utilizatorul își rotește dispozitivul), pauză, reluare etc. Pe scurt, un dialog cu o interfață de utilizator elaborată. Dacă nu aveți nevoie de acest lucru și dialogul dvs. este destul de simplu, dialogurile obișnuite funcționează bine. –  > Por Renascienza.
CrandellWS

Mulțumesc nikki răspunsul tău m-a ajutat să îmbunătățesc un existent pur și simplu prin adăugarea acțiunii dorite de mine după cum urmează

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

Comentarii

  • Am avut impresia că OP nu a vrut să folosească AlertDialog.Builder. OP vrea să știe dacă există o metodă utilitară de scurtătură, -.  > Por walrii.
  • Am scris același cod dar apare mai întâi NU și apoi DA practic este o casetă de dialog NU / DA dar am nevoie de o casetă de dialog DA / NU Cum procedez, –  > Por Sagar Devanga.
  • În ceea ce privește DA / NU vs NU / DA, vedeți acest răspuns: stackoverflow.com/a/13644589/1815624 puteți să o manipulați așa cum este descris în acest răspuns: stackoverflow.com/a/13644536/1815624 –  > Por CrandellWS.
Cristan

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

javaxian

Toate răspunsurile de aici se rezumă la un cod lung și nu ușor de citit: exact ceea ce persoana care a întrebat a încercat să evite. Pentru mine, a fost cea mai simplă abordare este să folosesc lambdas aici:

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 în Android necesită plugin-ul retrolambda (https://github.com/evant/gradle-retrolambda), dar este extrem de util pentru a scrie oricum un cod mai curat.

Hitesh Sahu

Afișați dialogul în mod anonim ca lanț de comenzi & fără a defini un alt obiect:

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

Christian

Mulțumesc. Eu folosesc API Level 2 (Android 1.1) și în loc de BUTTON_POSITIVE și BUTTON_NEGATIVE trebuie să folosesc BUTTON1 și BUTTON2.

Wajid khan

1.Creați AlertDialog setați mesajul, titlul și butonul pozitiv, negativ:

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.Acum găsiți ambele butoane pe DialogInterface Faceți clic apoi 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.Pentru a afișa Alertdialog:

alertDialog.show();

Notă: Nu uitați cuvântul cheie final cu AlertDialog.

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

Alex Zaraos

puteți să implementați o soluție generică pentru decizii și să o utilizați într-un alt caz nu doar pentru da / nu și să personalizați alerta cu animații sau layout:

Ceva de genul acesta; mai întâi creați clasa dvs. pentru transferul de date:

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

după o interfață pentru returnarea rezultatului

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

Acum puteți crea un utilitar pentru acces ușor (în această clasă puteți implementa diferite animații sau un aspect personalizat pentru alertă):

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

și ultimul apel în activitate sau fragment; puteți utiliza acest lucru în cazul dumneavoastră sau pentru alte sarcini:

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

Serg Burlaka

Puteți face acest lucru atât de ușor în Kotlin:

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

Partha Paul

Pentru Kotlin în 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()
    } 

Christian

Implementarea Kotlin.

Puteți crea o funcție simplă ca aceasta:

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

și să o apelați astfel:

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