Làm cách nào để hiển thị hộp thoại Có / Không trên Android?


358

Vâng, tôi biết có AlertDialog.Builder, nhưng tôi bị sốc khi biết mức độ khó (tốt, ít nhất là không thân thiện với lập trình viên) để hiển thị một hộp thoại trong Android.

Tôi đã từng là một nhà phát triển .NET và tôi tự hỏi liệu có bất kỳ tương đương với Android nào sau đây không?

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


3
Làm cách nào để tôi bán lại mã AlertDialog và xử lý các sự kiện (có, không có hành động) trong tất cả các màn hình? Trong .Net, chúng tôi sử dụng lớp Hành động để xử lý các sự kiện, có cách nào để thực hiện việc này không? Tôi biết sử dụng giao diện chúng ta có thể làm điều này nhưng có cách nào khác không?
Ravikumar11

2
Vâng .... chúng tôi các nhà phát triển .NET thực sự có một thời gian khó khăn với Android .... Tôi tự hỏi liệu Xamarin có phải là một công cụ tuyệt vời không?
Daniel Möller

Câu trả lời:


745

AlertDialog.Builder thực sự không khó sử dụng. Chắc chắn ban đầu hơi đáng sợ, nhưng một khi bạn đã sử dụng nó một chút thì nó vừa đơn giản vừa mạnh mẽ. Tôi biết bạn đã nói rằng bạn biết cách sử dụng nó, nhưng dù sao đây cũng chỉ là một ví dụ đơn giản:

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

Bạn cũng có thể sử dụng lại DialogInterface.OnClickListenernếu bạn có các hộp có / không khác nên làm điều tương tự.

Nếu bạn đang tạo Hộp thoại từ trong a View.OnClickListener, bạn có thể sử dụng view.getContext()để lấy Ngữ cảnh. Hoặc bạn có thể sử dụng yourFragmentName.getActivity().


3
AlertDialog.Builder mới (cái này); Biên dịch lỗi thời gian: 'Trình xây dựng AlertDialog.Builder (new View.OnClickListener () {}) không xác định'
Eric Leschinski

3
Đơn giản và hữu ích, btw, hộp thoại sẽ tự tắt sau khi người dùng nhấp vào nút "CÓ" hoặc "KHÔNG". Không có gì bạn cần làm.
RRTW

9
Bản thân tôi, tôi đã sử dụng nó rất nhiều lần. Nhưng tôi đã tìm thấy nó thực sự dễ dàng hơn và nhanh hơn để tìm kiếm nó trên SO. Mẫu mã được đưa ra ở đây rất đơn giản ... Tôi thực sự mong muốn tài liệu Android sẽ trông như thế này.
Radu

4
@EricLeschinski có lẽ "đây" không phải là một bối cảnh, hãy thử cái này: AlertDialog.Builder builder = new AlertDialog.Builder(getView().getContext());
cldrr

1
@davidglorioso Thứ tự có / không hoặc không / có tùy thuộc vào phiên bản Android và bạn không thể kiểm soát nó. Tôi không nhớ khi nào nó thay đổi, nhưng tôi nghĩ rằng nó đã ở 4.x hoặc 5. Nói rằng, dù sao bạn cũng không nên thay đổi nó. Tất cả các ứng dụng sử dụng hộp thoại cảnh báo tiêu chuẩn sẽ sử dụng cùng thứ tự nút không / có và sẽ gây nhầm lẫn cho người dùng nếu ứng dụng của bạn khác. Nếu bạn thực sự muốn nó khác biệt, bạn sẽ phải tự cài đặt các nút tích cực / tiêu cực tùy thuộc vào phiên bản Android.
Steve Haley

163

Thử cái này:

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
Cá nhân, tôi thích đoạn mã đó hơn câu trả lời được chấp nhận
John

1
@nikki tại sao cả hai đều loại bỏ ()?
likejudo

The constructor AlertDialog.Builder(MainActivity.DrawerItemClickListener) is undefined
băm

@likejiujitsu đó là vì bạn muốn dọn sạch hộp thoại khỏi bộ nhớ trong mọi trường hợp sau khi bạn thực hiện công việc của mình.
Avi Levin

32

Câu trả lời của Steve H được đưa ra, nhưng đây là một thông tin nữa: lý do các hộp thoại hoạt động theo cách của chúng là vì các hộp thoại trong Android không đồng bộ (thực thi không dừng khi hộp thoại được hiển thị). Vì điều này, bạn phải sử dụng một cuộc gọi lại để xử lý lựa chọn của người dùng.

Kiểm tra câu hỏi này để thảo luận lâu hơn giữa sự khác biệt trong Android và .NET (vì nó liên quan đến các hộp thoại): Hộp thoại / AlertDialogs: Cách "chặn thực thi" trong khi hộp thoại bật lên (kiểu .NET)


8
Cảm ơn, thực tế là các hộp thoại Android không đồng bộ giúp mọi thứ rõ ràng (và hợp lý) ngay bây giờ. Có vẻ như tôi cần "nghĩ ra .Net" khi phát triển ứng dụng cho Android :)
Solo

FYI: cái mà bạn gọi là "hộp thoại không đồng bộ" được gọi là "hộp thoại không chế độ" trong thuật ngữ GUI, trong khi "hộp thoại đồng bộ" được gọi là "hộp thoại phương thức". Android không có hộp thoại phương thức (trừ trường hợp rất đặc biệt).
Alex

Android không cho phép các hộp thoại phương thức hệ thống vì một lý do rất chính đáng: không được phép can thiệp vào các ứng dụng khác trên thiết bị.
Renascienza

14

Điều này làm việc cho tôi:

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

Hỏi một người xem anh ta có muốn gọi hay không 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();
    }    
}

5

Câu trả lời của Steves là đúng mặc dù đã lỗi thời với những mảnh vỡ. Dưới đây là một ví dụ với FragmentDialog.

Lớp:

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

Để bắt đầu hộp thoại:

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

Bạn cũng có thể để lớp thực hiện onClickListenervà sử dụng nó thay vì các trình nghe được nhúng.


@likejiujitsu ở trên là đủ.
Warpzit 16/03 '

Tạo một lớp FragmentDialog chỉ để làm một hộp không / có là một chút quá mức ... :) Một AlertDialog mặc định là đủ công bằng, chưa.
Renascienza

@Renascienza có nhưng tôi tin nó đã lỗi thời.
Warpzit

Không hẳn vậy. FragmentDialog đã được thêm vào như một điều hữu ích để cho phép bạn sử dụng lại một đoạn trên hộp thoại. Mảnh vỡ là tất cả về tái sử dụng UI. Vì bạn không cần sử dụng các đoạn chỉ vì là một điều mới (các đoạn không đến để thay thế các hoạt động), bạn không cần sử dụng FragmentDialog trong các trường hợp không có lợi ích gì. Đơn giản Có / Không có thông báo, ví dụ.
Renascienza

2
Đề nghị của tôi là: nếu bạn cần sử dụng lại không chỉ là bố cục, mà cả mã nền và mã vòng đời, hãy sử dụng hộp thoại Fragment. Với đoạn bạn có điều khiển vòng đời hoạt động liên quan và có thể phản ứng với các sự kiện như tạo (vì UI được tạo lại khi người dùng xoay thiết bị của mình), tạm dừng, tiếp tục, v.v. Tóm lại, một hộp thoại với một số UI được xây dựng. Nếu bạn không cần điều này và hộp thoại của bạn khá đơn giản, các hộp thoại thông thường hoạt động tốt.
Renascienza

5

Cảm ơn nikki câu trả lời của bạn đã giúp tôi cải thiện hiện tại chỉ bằng cách thêm hành động mong muốn của mình như sau

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

Tôi có ấn tượng rằng OP không muốn sử dụng AlertDialog.Builder. OP muốn biết liệu có một phương pháp tiện ích tắt hay không,
walrii

1
Tôi đã viết cùng một mã nhưng KHÔNG xuất hiện đầu tiên và sau đó CÓ về cơ bản đó là hộp thoại KHÔNG / CÓ nhưng tôi cần hộp thoại CÓ / KHÔNG Làm thế nào để tôi làm điều đó
Sagar Devanga

Đối với CÓ / KHÔNG so với KHÔNG / CÓ, hãy xem câu trả lời này: stackoverflow.com/a/13644589/1815624 bạn có thể thao tác nó như được ghi trong câu trả lời này: stackoverflow.com/a/13644536/1815624
CrandellWS

4

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

3

Hiển thị hộp thoại ẩn danh dưới dạng chuỗi lệnh & không xác định đối tượng khác:

 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

Tất cả các câu trả lời ở đây rút gọn thành mã dài và không thân thiện với người đọc: chỉ những gì người hỏi đang cố tránh. Đối với tôi, cách tiếp cận dễ nhất là sử dụng lambdas ở đây:

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 trong Android yêu cầu plugin retrolambda ( https://github.com/evant/gradle-retrolambda ), nhưng nó rất hữu ích trong việc viết mã sạch hơn.


1

Cảm ơn. Tôi sử dụng API cấp 2 (Android 1.1) và thay vì BUTTON_POSITIVEBUTTON_NEGATIVEtôi phải sử dụng BUTTON1BUTTON2.


1

1. Tạo thông báo cài đặt AlertDialog, tiêu đề và Nút tích cực, tiêu cực:

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.Bây giờ hãy tìm cả hai nút trên DialogInterface Nhấp vào sau đó 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.Để hiển thị Alertdialog:

alertDialog.show();

Lưu ý: Đừng quên từ khóa cuối cùng với 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

bạn có thể triển khai một giải pháp chung cho các quyết định và sử dụng trong trường hợp khác không chỉ cho có / không và tùy chỉnh cảnh báo bằng hình động hoặc bố cục:

Một cái gì đó như thế này; đầu tiên tạo lớp của bạn để chuyển dữ liệu:

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

sau một giao diện trả về kết quả

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

Bây giờ bạn có thể tạo một tiện ích để truy cập dễ dàng (trong lớp này, bạn có thể triển khai hoạt ảnh hoặc bố cục tùy chỉnh khác nhau cho cảnh báo):

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

và cuộc gọi cuối cùng trong hoạt động hoặc đoạn; bạn có thể sử dụng điều này trong trường hợp của bạn hoặc cho các nhiệm vụ khác:

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

Bạn có thể làm điều đó thật dễ dàng trong Kotlin:

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

0

Dành cho Kotlin trong 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

Thực hiện Kotlin.

Bạn có thể tạo một chức năng đơn giản như thế này:

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

và gọi nó như thế này:

dialogYesOrNo(
  this,
  "Question",
  "Would you like to eat?",
  DialogInterface.OnClickListener { dialog, id ->
    // do whatever you need to do when user presses "Yes"
  }
})
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.