Làm thế nào để tắt / bật các nút tích cực tiêu cực của hộp thoại?

Vui lòng xem hộp thoại tùy chỉnh bên dưới. Tôi có một trường văn bản chỉnh sửa trên hộp thoại và nếu trường văn bản trống, tôi muốn tắt positiveButton. Tôi có thể nhận được một charListener cho trường văn bản nhưng tôi không chắc làm cách nào để thiết lập positivebuttontắt hoặc bật từ trình nghe đó? Tham chiếu cho các nút tích cực và tiêu cực là gì?

 case DIALOG_TEXT_ENTRY:
    // This example shows how to add a custom layout to an AlertDialog
    LayoutInflater factory = LayoutInflater.from(this);
    final View textEntryView = factory.inflate(R.layout.alert_dialog_text_entry, null);
    return new AlertDialog.Builder(AlertDialogSamples.this)
        .setIconAttribute(android.R.attr.alertDialogIcon)
        .setTitle(R.string.alert_dialog_text_entry)
        .setView(textEntryView)
        .setPositiveButton(R.string.alert_dialog_ok, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int whichButton) {
                /* User clicked OK so do some stuff */
            }
        })
        .setNegativeButton(R.string.alert_dialog_cancel, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int whichButton) {
                /* User clicked cancel so do some stuff */
            }
        })
        .create();
}

Chỉnh sửa để có giải pháp hoàn chỉnh ...

AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
builder.setIcon(android.R.drawable.ic_dialog_info);
builder.setTitle("Alert dialog title");
builder.setMessage("This is the example code snippet to disable button if edittext attached to dialog is empty.");
builder.setPositiveButton("PositiveButton",
        new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface arg0, int arg1) {
                // DO TASK
            }
        });
builder.setNegativeButton("NegativeButton",
        new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface arg0, int arg1) {
                // DO TASK
            }
        });

// Set `EditText` to `dialog`. You can add `EditText` from `xml` too.
final EditText input = new EditText(MainActivity.this);

LinearLayout.LayoutParams lp = new LinearLayout.LayoutParams(
        LinearLayout.LayoutParams.MATCH_PARENT,
        LinearLayout.LayoutParams.MATCH_PARENT
);
input.setLayoutParams(lp);


builder.setView(input);

final AlertDialog dialog = builder.create();
dialog.show();

// Initially disable the button
((AlertDialog) dialog).getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);

// OR you can use here setOnShowListener to disable button at first time.

// Now set the textchange listener for edittext
input.addTextChangedListener(new TextWatcher() {

    @Override
    public void onTextChanged(CharSequence s, int start, int before,
            int count) {
    }

    @Override
    public void beforeTextChanged(CharSequence s, int start, int count,
            int after) {
    }

    @Override
    public void afterTextChanged(Editable s) {

        // Check if edittext is empty
        if (TextUtils.isEmpty(s)) {
            // Disable ok button
            ((AlertDialog) dialog).getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);

        } else {
            // Something into edit text. Enable the button.
            ((AlertDialog) dialog).getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(true);
        }

    }
});

Dưới đây là lịch sử đã chỉnh sửa, có thể tham khảo thêm một số chi tiết

Đây là một mã mẫu, hãy thử cái này

AlertDialog.Builder builder = new AlertDialog.Builder(AddSchedule.this);
builder.setIcon(android.R.drawable.ic_dialog_info);
builder.setTitle("Alert dialog title");
builder.setMessage("Dialog message");
builder.setPositiveButton("Button1", new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface arg0, int arg1) {
        //DO TASK
    }
});
builder.setNegativeButton("Button2", new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface arg0, int arg1) {
        //DO TASK
    }
});

AlertDialog dialog = builder.create();
dialog.show();

// After calling show method, you need to check your condition and enable/disable the dialog buttons 
if (your_condition_true) {
    // BUTTON1 is the positive button
    dialog.getButton(AlertDialog.BUTTON1).setEnabled(false);
}

Đối với nút phủ định

dialog.getButton(AlertDialog.BUTTON2).setEnabled(false); //BUTTON2 is negative button

Đối với id nút : Tham chiếu alert_dialog.xml

Đã chỉnh sửa:

Và setOnShowListener kể từ API cấp 8 (FroYo), cũng làm như vậy,

AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setPositiveButton(android.R.string.ok, null);

AlertDialog dialog = builder.create();
dialog.setOnShowListener(new OnShowListener() {

    @Override
    public void onShow(DialogInterface dialog) {
        if (condition) {
            ((AlertDialog)dialog).getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);
        }
    }
});

dialog.show();

Đã chỉnh sửa

new AlertDialog.Builder(this)
    .setMessage("This may take a while")
    .setPositiveButton("OK", new android.content.DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int which) {
            ((AlertDialog)dialog).getButton(which).setVisibility(View.INVISIBLE);
            // the rest of your stuff
        }

    }).show();

Không có câu trả lời nào trong số này thực sự giải quyết được vấn đề.

Tôi thực hiện điều này bằng cách sử dụng bố cục tùy chỉnh với EditText trong đó và TextWatcher trên dạng xem đó.

final LinearLayout layout = (LinearLayout) inflator.inflate(R.layout.text_dialog, null);
final EditText text = (EditText) layout.findViewById(R.id.text_edit);
final AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setView(layout);
// Now add the buttons...
builder.setPositiveButton(R.string.ok, new AlertDialog.OnClickListener() {
    // Left out for brevity...
}
builder.setNegativeButton(R.string.cancel, new AlertDialog.OnClickListener() {
    // Left out for brevity...
}

// Create the dialog
final AlertDialog d = builder.create();

// Now add a TextWatcher that will handle enable/disable of save button
text.addTextChangedListener(new TextWatcher() {
    private void handleText() {
        // Grab the button
        final Button okButton = d.getButton(AlertDialog.BUTTON_POSITIVE);
        if(text.getText().length() == 0) {
            okButton.setEnabled(false);
        } else {
            okButton.setEnabled(true);
        }
    }
    @Override
    public void afterTextChanged(Editable arg0) {
        handleText();
    }
    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after) {
        // Nothing to do
    }
    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {
       // Nothing to do
    }
});

// show the dialog
d.show();
// and disable the button to start with
d.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);

Đây là mã hoàn chỉnh để bật và tắt nút tích cực của hộp thoại:

AlertDialog.Builder builder = new AlertDialog.Builder(this);
LayoutInflater layoutInflater = MainActivity.this.getLayoutInflater();
View view = layoutInflater.inflate(R.layout.dialog,null);

builder.setView(view);
builder.setTitle("Test");
builder.setPositiveButton("ok", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        Toast.makeText(MainActivity.this, "Ok clicked", Toast.LENGTH_SHORT).show();
        dialog.dismiss();
    }
});
builder.setNegativeButton("cancel", null);

final AlertDialog alertDialog = builder.create();

alertDialog.show();

EditText editText = (EditText)view.findViewById(R.id.mobile_number);
alertDialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);
editText.addTextChangedListener(new TextWatcher() {
    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after) {}

    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {}

    @Override
    public void afterTextChanged(Editable s) {
        if (s.length() >= 1) {
            alertDialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(true);
        } else {
            alertDialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);

        }
    }
});

Bạn có thể ghi một trình nghe vào hộp văn bản chỉnh sửa và cố gắng bật hoặc tắt các nút. Đây là mã mẫu cho xamarin.

var dialog = builder.Create();

dialog.Show();

var btnOk = dialog.GetButton((int)DialogButtonType.Positive).Enabled = false;

_enterTextDialogEditText.AfterTextChanged += (sender, e) => {
  if (!string.IsNullOrEmpty(_enterTextDialogEditText.Text)) {
    dialog.GetButton((int)DialogButtonType.Positive).Enabled = true;
  } else {
    dialog.GetButton((int)DialogButtonType.Positive).Enabled = false;
  }
};

Để xóa bản ghi khỏi chế độ xem danh sách cơ sở dữ liệu bằng trình giữ chế độ xem, bạn đã sử dụng mã này trong phương thức getview () của mình ..

viewHolder.btn.setOnClickListener (OnClickListener mới () {

                @Override
                public void onClick(View arg0) {
                    // TODO Auto-generated method stub
                    AlertDialog.Builder alertDialog2 = new AlertDialog.Builder(
                            Favorate.this.getParent());

                    // Setting Dialog Title
                    alertDialog2.setTitle("Confirm Delete...");

                    // Setting Dialog Message
                    alertDialog2
                            .setMessage("Are you sure you want delete ?");

                    // Setting Icon to Dialog
                    alertDialog2.setIcon(R.drawable.delete);

                    // Setting Positive "Yes" Btn
                    alertDialog2.setPositiveButton("YES",
                            new DialogInterface.OnClickListener() {
                                public void onClick(DialogInterface dialog,
                                        int which) {
                                    // Write your code here to execute after
                                    // dialog

                                    int id = _items.get(position).id;
                                    db.deleterecord(id);

                                    db.close();
                                }
                            });
                    // Setting Negative "NO" Btn
                    alertDialog2.setNegativeButton("NO",
                            new DialogInterface.OnClickListener() {
                                public void onClick(DialogInterface dialog,
                                        int which) {
                                    // Write your code here to execute after
                                    // dialog

                                    dialog.cancel();
                                }
                            });

                    // Showing Alert Dialog
                    alertDialog2.show();

                }
            });

Đọc thêm

Hộp thoại này sẽ thực hiện công việc cho bạn. Lưu ý rằng hộp thoại sẽ vẫn mở sau khi xoay màn hình, giữ nguyên bất kỳ văn bản nào mà người dùng đã nhập. Nếu không muốn điều đó xảy ra, bạn cần loại bỏ phân đoạn trong OnStop của hoạt động của mình. Chữ ký của phương thức newInstance có thể được thay đổi thành bất kỳ thứ gì bạn cần.

import android.app.Activity;
import android.app.Dialog;
import android.app.DialogFragment;
import android.content.DialogInterface;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AlertDialog;
import android.text.Editable;
import android.text.TextWatcher;
import android.widget.EditText;

public class TextViewDialogFragment extends DialogFragment implements DialogInterface.OnClickListener, DialogInterface.OnShowListener, TextWatcher
{
    final static private String TITLE = "title", MESSAGE = "message", IDENTIFIER = "identifier", INPUT_TYPE = "inputType", POSITIVE_TEXT = "pText", NEGATIVE_TEXT = "nText", CANCELABLE = "cancelable";

    public TextViewDialogFragment()
    {
        super();
    }

    static public TextViewDialogFragment newInstance(int title, @Nullable String message, int identifier, int inputType, int positiveText, int negativeText, boolean cancelable)
    {
        TextViewDialogFragment fragement = new TextViewDialogFragment();
        Bundle args = new Bundle();
        args.putInt(TITLE, title);
        args.putString(MESSAGE, message);
        args.putInt(IDENTIFIER, identifier);
        args.putInt(INPUT_TYPE, inputType);
        args.putInt(POSITIVE_TEXT, positiveText);
        args.putInt(NEGATIVE_TEXT, negativeText);
        args.putBoolean(CANCELABLE, cancelable);
        fragement.setArguments(args);
        return fragement;
    }

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState)
    {
        Activity activity =  getActivity();
        Bundle args = getArguments();
        EditText input = new EditText(activity);
        input.setInputType(args.getInt(INPUT_TYPE));
        input.setId(R.id.dialog_edit_text);
        input.addTextChangedListener(this);
        AlertDialog.Builder alert = new AlertDialog.Builder(activity);
        alert.setCancelable(args.getBoolean(CANCELABLE)).setTitle(args.getInt(TITLE)).setMessage(args.getString(MESSAGE)).setView(input).setPositiveButton(args.getInt(POSITIVE_TEXT), this);
        int negativeText = args.getInt(NEGATIVE_TEXT);
        if (negativeText != 0)
        {
            alert.setNegativeButton(negativeText, this);
        }
        AlertDialog dialog = alert.create();
        dialog.setOnShowListener(this);
        return dialog;
    }

    @Override
    public void onShow(DialogInterface dialog)
    {
        // After device rotation there may be some text present.
        if (((EditText)((AlertDialog) dialog).findViewById(R.id.dialog_edit_text)).length() == 0)
        {
            ((AlertDialog) dialog).getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);
        }
    }

    @Override
    public void onClick(DialogInterface dialog, int which)
    {
        String text = ((EditText)((AlertDialog) dialog).findViewById(R.id.dialog_edit_text)).getText().toString();
        ((Callbacks) getActivity()).onTextViewDialogResult(which, getArguments().getInt(IDENTIFIER), text);
    }

    @Override
    public void onCancel(DialogInterface dialog)
    {
        ((Callbacks) getActivity()).onTextViewDialogActivityCancelled(getArguments().getInt(IDENTIFIER));
        super.onCancel(dialog);
    }

    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after)
    {
    }

    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count)
    {
    }

    @Override
    public void afterTextChanged(Editable s)
    {
        ((AlertDialog) getDialog()).getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(s.length() > 0);
    }

    void setMessage(String message)
    {
        Bundle args = getArguments();
        args.putString(MESSAGE, message);
        setArguments(args);
    }

    interface Callbacks
    {
        void onTextViewDialogResult(int which, int identity, String text);
        void onTextViewDialogActivityCancelled(int identity);
    }
}

Thêm dụng cụ vào hoạt động của bạn (bất kỳ loại Hoạt động nào cũng được):

public class Myctivity extends AppCompatActivity implements TextViewDialogFragment.Callbacks
{
...
}

Tạo DiaglogFragment trong hoạt động của bạn như sau:

final static int SOMETHING = 1;
myDF = TextViewDialogFragment.newInstance(R.string.my_title, "my message", SOMETHING, InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_FLAG_CAP_WORDS | InputType.TYPE_TEXT_FLAG_CAP_SENTENCES, /* Whatever is best for your user. */    R.string.yay, android.R.string.cancel, true);

Xử lý kết quả trong hoạt động của bạn như sau:

@Override
public void onTextViewDialogResult(int which, int identity, String text)
{
    if (which == AlertDialog.BUTTON_NEGATIVE)
    {
        // User did not want to do anything.
        return;
    }
    // text now holds the users answer.
    // Identity can be used if you use the same fragment for more than one type of question.
}
@Override
public void onTextViewDialogActivityCancelled(int identity)
{
    // This is invoked if you set cancelable to true and the user pressed the back button.
}

Bạn cần tạo mã định danh tài nguyên vì vậy hãy thêm tài nguyên này vào một nơi nào đó dưới res / giá trị

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <item name="dialog_edit_text" type="id"/>
</resources> 

if(editTextEmailAddress.getText().toString().length()==0)
 {
 btnCancelCross.setEnabled(false);
}
else
{
 btnCancelCross.setEnabled(true);

}

Điều đó có thể giúp bạn cảm ơn.