Android पर हां / नहीं संवाद बॉक्स कैसे प्रदर्शित करें?


358

हां, मुझे पता है कि AlertDialog.Builder है, लेकिन मैं यह जानकर हैरान हूं कि एंड्रॉइड में एक संवाद प्रदर्शित करने के लिए कितना मुश्किल है (ठीक है, कम से कम प्रोग्रामर-अनुकूल नहीं)।

मैं एक .NET डेवलपर हुआ करता था, और मुझे आश्चर्य है कि निम्नलिखित में से कोई भी एंड्रॉइड-समतुल्य है?

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


3
मैं सभी स्क्रीन में AlertDialog कोड और हैंडल ईवेंट (हाँ, कोई क्रिया नहीं) को कैसे पुन: लिखूं? .Net में हम घटनाओं को संभालने के लिए एक्शन क्लास का उपयोग करते हैं, क्या इसे लागू करने का कोई तरीका है? मुझे पता है कि हम इंटरफेस का उपयोग करके ऐसा कर सकते हैं लेकिन कोई वैकल्पिक तरीका है?
रविकुमार

2
हाँ .... हम .net डेवलपर्स वास्तव में Android के साथ एक कठिन समय है .... मुझे आश्चर्य है कि अगर Xamarin एक महान उपकरण है?
डैनियल मोलर

जवाबों:


745

AlertDialog.Builder वास्तव में उपयोग करने के लिए मुश्किल नहीं है। यह सुनिश्चित करने के लिए पहली बार में थोड़ा डराने वाला है, लेकिन एक बार जब आप इसका उपयोग कर लेते हैं तो यह सरल और शक्तिशाली दोनों होता है। मुझे पता है कि आपने कहा है कि आप इसका उपयोग करना जानते हैं, लेकिन यहाँ एक सरल उदाहरण है:

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

आप यह भी पुन: उपयोग कर सकते हैं कि DialogInterface.OnClickListenerयदि आपके पास अन्य हां / नहीं बक्से हैं जो एक ही काम करना चाहिए।

यदि आप डायलॉग को एक के भीतर से बना रहे हैं View.OnClickListener, तो आप view.getContext()प्रसंग प्राप्त करने के लिए उपयोग कर सकते हैं । वैकल्पिक रूप से आप उपयोग कर सकते हैं yourFragmentName.getActivity()


3
new AlertDialog.Builder (यह); संकलन समय त्रुटि: 'कंस्ट्रक्टर AlertDialog.Builder (नया View.OnClickListener () {}) अपरिभाषित है'
एरिक लेसचिंस्की

3
उपयोगकर्ता के "YES" या "NO" बटन पर क्लिक करने के बाद सरल और उपयोगी, btw, संवाद खुद को खारिज कर देगा। आपको कुछ करने की जरूरत नहीं है।
आरआरटीडब्ल्यू

9
मुझे खुद, मैंने इसे बहुत बार इस्तेमाल किया है। लेकिन मैंने पाया है कि यह वास्तव में एसओ पर देखने के लिए आसान और तेज़ है। यहां दिया गया कोड नमूना इतना सरल है ... मैं वास्तव में चाहता हूं कि एंड्रॉइड प्रलेखन इस तरह दिखाई देगा।
राडू

4
@ EricLeschinski शायद "यह" एक संदर्भ नहीं है, इसे आज़माएं: AlertDialog.Builder builder = new AlertDialog.Builder(getView().getContext());
cldrr

1
@davidglorioso हां / नहीं या नहीं / हां का क्रम एंड्रॉइड के संस्करण पर निर्भर करता है, और आप इसे नियंत्रित नहीं कर सकते। मुझे याद नहीं है कि यह कब बदला है, लेकिन मुझे लगता है कि यह 4.x या 5 में था। यह कहते हुए कि, आपको इसे वैसे भी नहीं बदलना चाहिए। सभी ऐप जो मानक चेतावनी संवाद का उपयोग करते हैं, वही नो / यस बटन ऑर्डर का उपयोग करेंगे, और यह उपयोगकर्ताओं के लिए भ्रामक होगा यदि आपका अलग था। यदि आप वास्तव में इसे अलग बनाना चाहते हैं, तो आपको एंड्रॉइड वर्जन पर निर्भर अपने सकारात्मक / नकारात्मक बटन को मैन्युअल रूप से सेट करना होगा।
स्टीव हैली

163

इसे इस्तेमाल करे:

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

25
व्यक्तिगत रूप से, मुझे स्वीकार किए गए उत्तर से अधिक उस कोड स्निपेट को पसंद है
जॉन

1
@ मिक्की दोनों को बर्खास्तगी () क्यों है?
जैसे

The constructor AlertDialog.Builder(MainActivity.DrawerItemClickListener) is undefined
हैश

@likejiujitsu thats आप अपने काम करने के बाद किसी भी मामले में स्मृति से संवाद को साफ करना चाहते हैं।
एवि लेविन

32

स्टीव एच का जवाब हाजिर है, लेकिन यहां थोड़ी अधिक जानकारी है: कारण यह है कि डायलॉग जिस तरह से काम करते हैं वह इसलिए है क्योंकि एंड्रॉइड में डायलॉग अतुल्यकालिक हैं (डायलॉग प्रदर्शित होने पर निष्पादन बंद नहीं होता है)। इस वजह से, आपको उपयोगकर्ता के चयन को संभालने के लिए कॉलबैक का उपयोग करना होगा।

Android और .NET में अंतर के बारे में लंबी चर्चा के लिए इस प्रश्न को देखें (जैसा कि यह संवादों से संबंधित है): डायलॉग्स / AlertDialogs: डायलॉग ".NET निष्पादन" कैसे करें (.NET-style)


8
धन्यवाद, यह तथ्य कि एंड्रॉइड संवाद अतुल्यकालिक हैं, अब सब कुछ स्पष्ट (और उचित) करता है। लगता है कि मुझे एंड्रॉइड के लिए ऐप विकसित करते समय ".Net से बाहर सोचने की ज़रूरत है"
सोलो

FYI करें: जिसे आप "एसिंक्रोनस डायलॉग" कहते हैं, उसे GUI शब्दावली में "मॉडललेस डायलॉग" कहा जाता है, जबकि "सिंक्रोनस डायलॉग" को "मोडल डायलॉग" कहा जाता है। एंड्रॉइड में मोडल डायलॉग (बहुत असाधारण मामलों को छोड़कर) की सुविधा नहीं है।
एलेक्स

एंड्रॉइड सिस्टम मोडल संवादों को एक बहुत अच्छे कारण के लिए अनुमति नहीं देता है: डिवाइस पर अन्य एप्लिकेशन के साथ हस्तक्षेप करने की अनुमति नहीं है।
Renascienza

14

यह मेरे लिए काम कर रहा है:

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

7

एक व्यक्ति से पूछ रहा है कि क्या वह कॉल करना चाहता है या नहीं डायलॉग ।।

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

5

टुकड़ों के साथ पुराना होने पर स्टीव्स उत्तर सही है। यहाँ FragmentDialog के साथ एक उदाहरण है।

कक्षा:

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

संवाद शुरू करने के लिए:

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

आप क्लास onClickListenerको एम्बेडेड श्रोताओं के बजाय लागू करने और उपयोग करने दे सकते हैं ।


@likejiujitsu ऊपर पर्याप्त है।
वारपज़िट

एक FragmentDialog क्लास बनाएं बस एक नो / हां बॉक्स में करें ओवरडिजाइन का एक सा ... :) डिफॉल्ट AlertDialog काफी फेयर है, फिर भी।
Renascienza

@ रेनासिंज़ा हाँ, लेकिन मेरा मानना ​​है कि यह पुरानी है।
वारपज़िट

ज़रुरी नहीं। FragmentDialog आपको एक संवाद पर एक पुन: उपयोग करने की अनुमति देने के लिए एक उपयोगी चीज के रूप में जोड़ा गया था। Fragments UI पुन: उपयोग के बारे में है। जैसा कि आपको केवल टुकड़ों का उपयोग करने की आवश्यकता नहीं है क्योंकि एक नई चीज है (टुकड़े गतिविधियों को बदलने के लिए नहीं आते हैं), आपको उन मामलों पर FragmentDialog का उपयोग करने की आवश्यकता नहीं है, जहां कोई लाभ नहीं है। उदाहरण के लिए सरल हां / नहीं अलर्ट।
Renascienza

2
मेरी सिफारिश है: यदि आपको न केवल एक लेआउट, बल्कि पृष्ठभूमि और जीवन चक्र कोड का पुन: उपयोग करने की आवश्यकता है, तो एक फ़्रैगमेंट संवाद का उपयोग करें। टुकड़े के साथ आपके पास संबंधित गतिविधि जीवन चक्र नियंत्रण होता है और क्रिएट जैसी घटनाओं पर प्रतिक्रिया दे सकता है (जैसे कि यूआई फिर से बनाया जाता है जब उपयोगकर्ता अपने डिवाइस को घुमाता है), ठहराव, फिर से शुरू, आदि। संक्षेप में, कुछ विस्तृत यूआई के साथ एक संवाद। यदि आपको इसकी आवश्यकता नहीं है और आपका संवाद बहुत सरल है, तो नियमित संवाद ठीक काम करता है।
Renascienza

5

धन्यवाद निक्की आपके उत्तर ने मुझे अपनी इच्छा के अनुसार अपनी मौजूदा क्रिया को सुधारने में मदद की है

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

मुझे यह आभास हो गया कि ओपी AlertDialog.Builder का उपयोग नहीं करना चाहता था। ओपी यह जानना चाहता है कि क्या कोई शॉर्टकट उपयोगिता विधि है,
व्रिी

1
मैंने एक ही कोड लिखा है, लेकिन NO पहले दिखाई देता है और फिर YES मूल रूप से यह NO / YES डायलॉग बॉक्स है, लेकिन मुझे YES / NO डायलॉग बॉक्स की आवश्यकता है मैं इसे कैसे करूं
सागर देवंगा

यस / NO बनाम NO / YES के लिए यह उत्तर देखें: stackoverflow.com/a/13644589/1815624 आप इस उत्तर में दिए गए अनुसार इसे हेरफेर कर सकते हैं: stackoverflow.com/a/13644536/1815624
CrandellWS

4

कोटलिन में:

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

3

संवाद को गुमनाम रूप से आदेशों की श्रृंखला के रूप में और दूसरी वस्तु को परिभाषित किए बिना दिखाएं:

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

2

यहाँ सभी उत्तर लम्बे और पाठक के अनुकूल नहीं होने के कारण उबलते हैं: बस पूछने वाला व्यक्ति बचने की कोशिश कर रहा था। मेरे लिए, सबसे आसान तरीका यह था कि यहां लंबोदर को रोजगार दिया जाए:

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

एंड्रॉइड में लैम्ब्डा को रेट्रोलंबा प्लगइन ( https://github.com/evant/gradle-retrolambda ) की आवश्यकता होती है , लेकिन यह क्लीनर कोड वैसे भी लिखने में बेहद मददगार है।


1

धन्यवाद। मैं एपीआई स्तर 2 (एंड्रॉइड 1.1) का उपयोग करता हूं और इसके बजाय BUTTON_POSITIVEऔर BUTTON_NEGATIVEमुझे उपयोग करना है BUTTON1और BUTTON2


1

1.Create AlertDialog सेट संदेश, शीर्षक और सकारात्मक, नकारात्मक बटन:

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.अब DialogInterface पर दोनों बटन खोजें क्लिक करें फिर 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. शो Alertdialog:

alertDialog.show();

नोट: अंतिम कीवर्ड AlertDialog के साथ मत भूलना।


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

0

आप निर्णयों के लिए एक सामान्य समाधान लागू कर सकते हैं और किसी अन्य मामले में न केवल हां / ना के लिए उपयोग कर सकते हैं और एनिमेशन या लेआउट के साथ अलर्ट कस्टम कर सकते हैं:

कुछ इस तरह; ट्रांसफर डेटा के लिए पहले अपनी कक्षा बनाएं:

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

परिणाम वापस करने के लिए एक इंटरफ़ेस के बाद

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

अब आप आसानी से पहुंच के लिए एक बर्तन बना सकते हैं (इस वर्ग में आप अलर्ट के लिए अलग एनीमेशन या कस्टम लेआउट लागू कर सकते हैं):

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

और गतिविधि या टुकड़े में अंतिम कॉल; आप इस मामले में या अन्य कार्य के लिए इसका उपयोग कर सकते हैं:

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

0

आप इसे कोटलिन में इतना आसान कर सकते हैं:

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

0

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

0

कोटलिन कार्यान्वयन।

आप इस तरह से एक साधारण फ़ंक्शन बना सकते हैं:

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

और इसे इस तरह से कॉल करें:

dialogYesOrNo(
  this,
  "Question",
  "Would you like to eat?",
  DialogInterface.OnClickListener { dialog, id ->
    // do whatever you need to do when user presses "Yes"
  }
})
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.