Как отключить / включить в диалоге отрицательные положительные кнопки?

111

Пожалуйста, посмотрите на настраиваемый диалог ниже. У меня есть поле редактирования текста в диалоговом окне, и если текстовое поле пусто, я бы хотел отключить расширение positiveButton. Я могу получить charListener для текстового поля, но я не уверен, как я собираюсь positivebuttonотключить или включить для этого слушателя? Каковы ссылки для положительных и отрицательных кнопок?

 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();
}
АКД
источник
Я думаю, этот ответ отвечает на ваш вопрос [ stackoverflow.com/questions/4291548/… [1]: stackoverflow.com/questions/4291548/…
Александр Куляхтин
спасибо, но это не ответ. это может помочь. потому что он отключает кнопку после нажатия. чего я не хочу. Я хотел бы показать, что он отключен, зависит от текстового поля.
AKD
1
if (editTextEmailAddress.getText (). toString (). length () == 0)
САЛМАН
По сути, вы создаете объект с анонимной ссылкой, когда он создан, вы не можете ссылаться на него снова. Спасибо.
SALMAN

Ответы:

207

Изменить для полного решения ...

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

    }
});

Ниже представлена ​​отредактированная история, которую можно назвать более подробной информацией.

Вот пример кода, попробуйте это

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

Для отрицательной кнопки

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

Для идентификаторов кнопок : ссылка alert_dialog.xml

Отредактировано:

И setOnShowListener, начиная с уровня 8 API (FroYo), делает то же самое,

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

Отредактировано

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

Панкадж Кумар
источник
поправьте меня, если я ошибаюсь, но когда вы снова вызываете AlertDialog, он снова вызывает свой объект или все еще использует тот же самый. Мне не известен этот метод. Не могли бы вы объяснить вкратце? Спасибо :)
NovusMobile
Для скиммеров я хотел бы добавить, что dialog.getButton () работает только для AlertDialogs, поэтому вам, возможно, придется передать диалог в AlertDialog, как вы это делаете дальше в посте.
Noumenon
не работают - также я читал код минимум 5 раз, и все еще не имеет смысла, почему он должен работать :) Правильный ответ ниже от Ника Палмера
qkx
@qkx Можете объяснить, что вы пытаетесь сделать. Можете показать соответствующий код? И не иронируйте и голосуйте против.
Панкадж Кумар
1
Я не хотел быть ироничным, грубым. Я также попытался отменить голосование, но это невозможно ... Однако еще раз к проблеме - где у вас есть текстовый слушатель в вашем коде, вы можете мне сказать? Неважно, что это за условие, если оно вызывается только один раз. Если у вас нет слушателя текста, как у Ника ниже, ваше решение просто не может работать ... Или я что-то пропустил. Или пришлите мне какой-нибудь простой проект для Android, чтобы доказать, что он работает;)
qkx
25

Ни один из этих ответов не решает проблему.

Я делаю это с помощью настраиваемого макета с EditText в нем и TextWatcher в этом представлении.

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);
Ник Палмер
источник
Этот ответ неполный, нет объявленияd
androidguy
Отредактировано для добавления конструкции d.
Ник Палмер
4

Вот полный код для включения и отключения положительной кнопки диалога:

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

        }
    }
});
Калпеш Кумават
источник
1

Вы можете написать слушателя в текстовое поле редактирования и попытаться включить или отключить кнопки. Это пример кода для 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;
  }
};
Рави Киран
источник
0

Для удаления записи из представления списка базы данных с помощью держателя представления вы использовали этот код в своем методе getview () ..

viewHolder.btn.setOnClickListener (новый OnClickListener () {

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

                }
            });

Читать далее

Roadies
источник
0

Этот dialogFragment сделает всю работу за вас. Обратите внимание, что диалоговое окно останется открытым после поворота экрана с сохранением любого текста, который пользователь уже ввел. Если вы не хотите, чтобы это произошло, вам нужно отклонить фрагмент в onStop вашей операции. Подпись метода newInstance может быть изменена на все, что вам нужно.

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

Добавьте к своей деятельности орудия (подойдет любой вид деятельности):

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

Создайте diaglogFragment в своей деятельности следующим образом:

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

Обработайте результат своей деятельности следующим образом:

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

Вам нужно создать идентификатор ресурса, поэтому добавьте этот ресурс где-нибудь под res / values

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <item name="dialog_edit_text" type="id"/>
</resources> 
Стив Уоринг
источник
-1
if (editTextEmailAddress.getText().toString().length() == 0) {
    btnCancelCross.setEnabled(false);
} else {
    btnCancelCross.setEnabled(true);
}

Это может вам помочь, спасибо.

Салман
источник
спасибо, но это не то, что я ищу. Я могу сделать это с помощью настраиваемого диалогового окна и создать макет с помощью кнопки и включить их, отключить. Я ищу способ отключить или включить встроенные положительные и отрицательные кнопки диалога? Если вы посмотрите на код, которым я поделился, вы увидите, что я ищу. Но еще раз спасибо за код.
AKD
2
Пожалуйста, опубликуйте один исчерпывающий ответ по теме (просто отредактируйте существующий ответ, не продолжайте публиковать дополнительные ответы).
Тим Пост