单击按钮时如何防止对话框关闭

Question

我有一个EditText输入对话框.当我单击对话框上的"是"按钮时,它将验证输入,然后关闭对话框.但是,如果输入错误,我想保持在同一个对话框中.每次无论输入是什么,当我点击"否"按钮时,对话框应自动关闭.我怎么能禁用它？顺便说一句,我已经使用PositiveButton和NegativeButton作为对话框上的按钮.

Answer 1

编辑:这仅适用于API 8+,如某些评论所述.

这是一个迟到的答案,但您可以将一个onShowListener添加到AlertDialog,然后您可以覆盖该按钮的onClickListener.

final AlertDialog dialog = new AlertDialog.Builder(context)
        .setView(v)
        .setTitle(R.string.my_title)
        .setPositiveButton(android.R.string.ok, null) //Set to null. We override the onclick
        .setNegativeButton(android.R.string.cancel, null)
        .create();

dialog.setOnShowListener(new DialogInterface.OnShowListener() {

    @Override
    public void onShow(DialogInterface dialogInterface) {

        Button button = ((AlertDialog) dialog).getButton(AlertDialog.BUTTON_POSITIVE);
        button.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View view) {
                // TODO Do something

                //Dismiss once everything is OK.
                dialog.dismiss();
            }
        });
    }
});
dialog.show();

Answer 2

以下是针对所有类型对话框的一些解决方案,包括适用于所有API级别的AlertDialog.Builder解决方案(在API 8下工作,其他答案不在此处).AlertDialogs有使用AlertDialog.Builder,DialogFragment和DialogPreference的解决方案.

下面是代码示例,演示如何覆盖默认的公共按钮处理程序,并防止对话框关闭这些不同形式的对话框.所有示例都显示了如何防止正面按钮关闭对话框.

注意:对于那些想要了解更多细节的人来说,对于基本的android类以及如何选择以下方法,对话框关闭的工作方式的说明如下:

AlertDialog.Builder - 在show()之后立即更改默认按钮处理程序

AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
builder.setMessage("Test for preventing dialog close");
builder.setPositiveButton("Test", 
        new DialogInterface.OnClickListener()
        {
            @Override
            public void onClick(DialogInterface dialog, int which)
            {
                //Do nothing here because we override this button later to change the close behaviour. 
                //However, we still need this because on older versions of Android unless we 
                //pass a handler the button doesn't get instantiated
            }
        });
final AlertDialog dialog = builder.create();
dialog.show();
//Overriding the handler immediately after show is probably a better approach than OnShowListener as described below
dialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener(new View.OnClickListener()
      {            
          @Override
          public void onClick(View v)
          {
              Boolean wantToCloseDialog = false;
              //Do stuff, possibly set wantToCloseDialog to true then...
              if(wantToCloseDialog)
                  dialog.dismiss();
              //else dialog stays open. Make sure you have an obvious way to close the dialog especially if you set cancellable to false.
          }
      });

DialogFragment - 覆盖onResume()

@Override
public Dialog onCreateDialog(Bundle savedInstanceState)
{
    AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
    builder.setMessage("Test for preventing dialog close");
    builder.setPositiveButton("Test", 
        new DialogInterface.OnClickListener()
        {
            @Override
            public void onClick(DialogInterface dialog, int which)
            {
                //Do nothing here because we override this button later to change the close behaviour. 
                //However, we still need this because on older versions of Android unless we 
                //pass a handler the button doesn't get instantiated
            }
        });
    return builder.create();
}

//onStart() is where dialog.show() is actually called on 
//the underlying dialog, so we have to do it there or 
//later in the lifecycle.
//Doing it in onResume() makes sure that even if there is a config change 
//environment that skips onStart then the dialog will still be functioning
//properly after a rotation.
@Override
public void onResume()
{
    super.onResume();    
    final AlertDialog d = (AlertDialog)getDialog();
    if(d != null)
    {
        Button positiveButton = (Button) d.getButton(Dialog.BUTTON_POSITIVE);
        positiveButton.setOnClickListener(new View.OnClickListener()
                {
                    @Override
                    public void onClick(View v)
                    {
                        Boolean wantToCloseDialog = false;
                        //Do stuff, possibly set wantToCloseDialog to true then...
                        if(wantToCloseDialog)
                            d.dismiss();
                        //else dialog stays open. Make sure you have an obvious way to close the dialog especially if you set cancellable to false.
                    }
                });
    }
}

DialogPreference - 覆盖showDialog()

@Override
protected void onPrepareDialogBuilder(Builder builder)
{
    super.onPrepareDialogBuilder(builder);
    builder.setPositiveButton("Test", this);   //Set the button here so it gets created
}

@Override
protected void showDialog(Bundle state)
{       
    super.showDialog(state);    //Call show on default first so we can override the handlers

    final AlertDialog d = (AlertDialog) getDialog();
    d.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener(new View.OnClickListener()
            {            
                @Override
                public void onClick(View v)
                {
                    Boolean wantToCloseDialog = false;
                    //Do stuff, possibly set wantToCloseDialog to true then...
                    if(wantToCloseDialog)
                        d.dismiss();
                    //else dialog stays open. Make sure you have an obvious way to close the dialog especially if you set cancellable to false.
                }
            });
}

方法说明:

查看Android源代码,AlertDialog默认实现通过向OnCreate()中的所有实际按钮注册一个公共按钮处理程序来工作.当单击一个按钮时,公共按钮处理程序将click事件转发到您在setButton()中传递的任何处理程序,然后调用解除对话框.

如果您希望在按下其中一个按钮时阻止关闭对话框,则必须替换按钮实际视图的公共按钮处理程序.因为它是在OnCreate()中分配的,所以必须在调用默认的OnCreate()实现后替换它.在show()方法的过程中调用OnCreate.您可以创建一个自定义Dialog类并重写OnCreate()以调用super.OnCreate()然后覆盖按钮处理程序,但是如果您创建一个自定义对话框,则不会免费获得Builder,在这种情况下有什么意义？

因此,在按照设计方式使用对话框但是在解除它时进行控制时,一种方法是首先调用dialog.Show(),然后使用dialog.getButton()获取对按钮的引用以覆盖单击处理程序.另一种方法是使用setOnShowListener()并实现查找按钮视图并替换OnShowListener中的处理程序.两者之间的功能差异是"差不多",这取决于最初创建对话框实例的线程.浏览源代码,onShowListener将被发布到在创建该对话框的线程上运行的处理程序的消息调用.因此,由于OnShowListener是由消息队列上发布的消息调用的,因此技术上可能在show完成后调用您的侦听器一段时间.

因此,我认为最安全的方法是第一种:调用show.Dialog(),然后立即在同一个执行路径中替换按钮处理程序.由于调用show()的代码将在主GUI线程上运行,这意味着你所遵循的任何代码show()将在该线程上的任何其他代码之前执行,而OnShowListener方法的时间由于消息队列.

Answer 3

我编写了一个简单的类(AlertDialogBu​​ilder),可以在按下对话框的按钮时禁用自动关闭功能.

它也与Android 1.6兼容,因此它不使用OnShowListener(只有API> = 8).

因此,您可以使用此CustomAlertDialogBu​​ilder,而不是使用AlertDialog.Builder.最重要的部分是你不应该调用create(),而只调用show()方法.我添加了setCanceledOnTouchOutside()和setOnDismissListener等方法,以便您仍然可以直接在构建器上设置它们.

我在Android 1.6,2.x,3.x和4.x上进行了测试,所以它应该可以正常工作.如果您发现一些问题,请在此处评论.

package com.droidahead.lib.utils;

import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.view.View;
import android.view.View.OnClickListener;

public class CustomAlertDialogBuilder extends AlertDialog.Builder {
    /**
     * Click listeners
     */
    private DialogInterface.OnClickListener mPositiveButtonListener = null;
    private DialogInterface.OnClickListener mNegativeButtonListener = null;
    private DialogInterface.OnClickListener mNeutralButtonListener = null;

    /**
     * Buttons text
     */
    private CharSequence mPositiveButtonText = null;
    private CharSequence mNegativeButtonText = null;
    private CharSequence mNeutralButtonText = null;

    private DialogInterface.OnDismissListener mOnDismissListener = null;

    private Boolean mCancelOnTouchOutside = null;

    public CustomAlertDialogBuilder(Context context) {
        super(context);
    }

    public CustomAlertDialogBuilder setOnDismissListener (DialogInterface.OnDismissListener listener) {
        mOnDismissListener = listener;
        return this;
    }

    @Override
    public CustomAlertDialogBuilder setNegativeButton(CharSequence text, DialogInterface.OnClickListener listener) {
        mNegativeButtonListener = listener;
        mNegativeButtonText = text;
        return this;
    }

    @Override
    public CustomAlertDialogBuilder setNeutralButton(CharSequence text, DialogInterface.OnClickListener listener) {
        mNeutralButtonListener = listener;
        mNeutralButtonText = text;
        return this;
    }

    @Override
    public CustomAlertDialogBuilder setPositiveButton(CharSequence text, DialogInterface.OnClickListener listener) {
        mPositiveButtonListener = listener;
        mPositiveButtonText = text;
        return this;
    }

    @Override
    public CustomAlertDialogBuilder setNegativeButton(int textId, DialogInterface.OnClickListener listener) {
        setNegativeButton(getContext().getString(textId), listener);
        return this;
    }

    @Override
    public CustomAlertDialogBuilder setNeutralButton(int textId, DialogInterface.OnClickListener listener) {
        setNeutralButton(getContext().getString(textId), listener);
        return this;
    }

    @Override
    public CustomAlertDialogBuilder setPositiveButton(int textId, DialogInterface.OnClickListener listener) {
        setPositiveButton(getContext().getString(textId), listener);
        return this;
    }

    public CustomAlertDialogBuilder setCanceledOnTouchOutside (boolean cancelOnTouchOutside) {
        mCancelOnTouchOutside = cancelOnTouchOutside;
        return this;
    }



    @Override
    public AlertDialog create() {
        throw new UnsupportedOperationException("CustomAlertDialogBuilder.create(): use show() instead..");
    }

    @Override
    public AlertDialog show() {
        final AlertDialog alertDialog = super.create();

        DialogInterface.OnClickListener emptyOnClickListener = new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) { }
        };


        // Enable buttons (needed for Android 1.6) - otherwise later getButton() returns null
        if (mPositiveButtonText != null) {
            alertDialog.setButton(AlertDialog.BUTTON_POSITIVE, mPositiveButtonText, emptyOnClickListener);
        }

        if (mNegativeButtonText != null) {
            alertDialog.setButton(AlertDialog.BUTTON_NEGATIVE, mNegativeButtonText, emptyOnClickListener);
        }

        if (mNeutralButtonText != null) {
            alertDialog.setButton(AlertDialog.BUTTON_NEUTRAL, mNeutralButtonText, emptyOnClickListener);
        }

        // Set OnDismissListener if available
        if (mOnDismissListener != null) {
            alertDialog.setOnDismissListener(mOnDismissListener);
        }

        if (mCancelOnTouchOutside != null) {
            alertDialog.setCanceledOnTouchOutside(mCancelOnTouchOutside);
        }

        alertDialog.show();

        // Set the OnClickListener directly on the Button object, avoiding the auto-dismiss feature
        // IMPORTANT: this must be after alert.show(), otherwise the button doesn't exist..
        // If the listeners are null don't do anything so that they will still dismiss the dialog when clicked
        if (mPositiveButtonListener != null) {
            alertDialog.getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener(new OnClickListener() {

                @Override
                public void onClick(View v) {
                    mPositiveButtonListener.onClick(alertDialog, AlertDialog.BUTTON_POSITIVE);
                }
            });
        }

        if (mNegativeButtonListener != null) {
            alertDialog.getButton(AlertDialog.BUTTON_NEGATIVE).setOnClickListener(new OnClickListener() {

                @Override
                public void onClick(View v) {
                    mNegativeButtonListener.onClick(alertDialog, AlertDialog.BUTTON_NEGATIVE);
                }
            });
        }

        if (mNeutralButtonListener != null) {
            alertDialog.getButton(AlertDialog.BUTTON_NEUTRAL).setOnClickListener(new OnClickListener() {

                @Override
                public void onClick(View v) {
                    mNeutralButtonListener.onClick(alertDialog, AlertDialog.BUTTON_NEUTRAL);
                }
            });
        }

        return alertDialog;
    }   
}

编辑这是一个关于如何使用CustomAlertDialogBu​​ilder的小例子:

// Create the CustomAlertDialogBuilder
CustomAlertDialogBuilder dialogBuilder = new CustomAlertDialogBuilder(context);

// Set the usual data, as you would do with AlertDialog.Builder
dialogBuilder.setIcon(R.drawable.icon);
dialogBuilder.setTitle("Dialog title");
dialogBuilder.setMessage("Some text..");

// Set your buttons OnClickListeners
dialogBuilder.setPositiveButton ("Button 1", new DialogInterface.OnClickListener() {
    public void onClick (DialogInterface dialog, int which) {
        // Do something...

        // Dialog will not dismiss when the button is clicked
        // call dialog.dismiss() to actually dismiss it.
    }
});

// By passing null as the OnClickListener the dialog will dismiss when the button is clicked.               
dialogBuilder.setNegativeButton ("Close", null);

// Set the OnDismissListener (if you need it)       
dialogBuilder.setOnDismissListener(new DialogInterface.OnDismissListener() {
    public void onDismiss(DialogInterface dialog) {
        // dialog was just dismissed..
    }
});

// (optional) set whether to dismiss dialog when touching outside
dialogBuilder.setCanceledOnTouchOutside(false);

// Show the dialog
dialogBuilder.show();

干杯,

Yuvi

Answer 4

另一种解决方案

我想从UX的角度提出另一个答案.

为什么要在单击按钮时阻止对话框关闭？大概是因为你有一个自定义对话框,用户没有做出选择或者还没有完全填满所有内容.如果它们没有完成,那么你不应该让它们完全点击肯定按钮.只需禁用它,直到一切准备就绪.

这里的其他答案提供了许多技巧来覆盖正面按钮点击.如果这很重要,Android会不会做出方便的方法呢？他们没有.

相反,Dialogs设计指南显示了这种情况的一个例子.在用户做出选择之前,"确定"按钮被禁用.根本不需要压倒一切的技巧.对用户来说显而易见的是,在继续之前还需要做一些事情.

如何禁用正面按钮

请参阅Android文档以创建自定义对话框布局.它建议你放在AlertDialog里面DialogFragment.然后,您需要做的就是在布局元素上设置侦听器,以了解何时启用或禁用肯定按钮.

• 如果您的自定义对话框有单选按钮,则使用RadioGroup.OnCheckedChangeListener.
• 如果您的自定义对话框有复选框,则使用CompoundButton.OnCheckedChangeListener.
• 如果您的自定义对话框有EditText,则使用TextWatcher.

正面按钮可以像这样禁用:

AlertDialog dialog = (AlertDialog) getDialog();
dialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);

这是一个完整的工作DialogFragment与禁用的正面按钮,如可能在上面的图像中使用.

import android.support.v4.app.DialogFragment;
import android.support.v7.app.AlertDialog;

public class MyDialogFragment extends DialogFragment {

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {

        // inflate the custom dialog layout
        LayoutInflater inflater = getActivity().getLayoutInflater();
        View view = inflater.inflate(R.layout.my_dialog_layout, null);

        // add a listener to the radio buttons
        RadioGroup radioGroup = (RadioGroup) view.findViewById(R.id.radio_group);
        radioGroup.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(RadioGroup radioGroup, int i) {
                // enable the positive button after a choice has been made
                AlertDialog dialog = (AlertDialog) getDialog();
                dialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(true);
            }
        });

        // build the alert dialog
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
        builder.setView(view)
                .setPositiveButton("OK", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int id) {
                        // TODO: use an interface to pass the user choice back to the activity
                    }
                })
                .setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int id) {
                        MyDialogFragment.this.getDialog().cancel();
                    }
                });
        return builder.create();
    }

    @Override
    public void onResume() {
        super.onResume();

        // disable positive button by default
        AlertDialog dialog = (AlertDialog) getDialog();
        dialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);
    }
}

可以从以下活动运行自定义对话框:

MyDialogFragment dialog = new MyDialogFragment();
dialog.show(getFragmentManager(), "MyTag");

笔记

• 为简洁起见,我省略了通信接口以将用户选择信息传递回活动.但是,文档显示了如何完成此操作.

• 按钮仍在null,onCreateDialog所以我禁用了它onResume.如果用户切换到另一个应用程序然后返回而不关闭对话框,则会产生不希望的再次禁用它的效果.这可以通过取消选择任何用户选择或通过调用Runnablefrom onCreateDialog来禁用下一个运行循环上的按钮来解决.

  view.post(new Runnable() {
      @Override
      public void run() {
          AlertDialog dialog = (AlertDialog) getDialog();
          dialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);
      }
  });
  

有关

• 带有一个,两个和三个按钮的Android Alert对话框
• 如何在Android警报对话框中显示列表视图？

Answer 5

如果您正在使用DialogFragment,这里有一些东西- 无论如何,这是处理Dialogs的推荐方法.

使用AlertDialog的setButton()方法会发生什么(我想象的AlertDialogBuilder是setPositiveButton()和s 一样setNegativeButton())是你AlertDialog.BUTTON_POSITIVE用它设置的按钮(例如)OnClickListener按下时实际上会触发两个不同的对象.

第一个是DialogInterface.OnClickListener,这是一个参数setButton(),setPositiveButton()和setNegativeButton().

另一个是View.OnClickListener,它将设置为AlertDialog在按下任何按钮时自动关闭- 并由AlertDialog其自身设置.

你可以做的是使用setButton()with null作为DialogInterface.OnClickListener创建按钮,然后在里面调用你的自定义动作方法View.OnClickListener.例如,

@Override
public Dialog onCreateDialog(Bundle savedInstanceState)
{
    AlertDialog alertDialog = new AlertDialog(getActivity());
    // set more items...
    alertDialog.setButton(AlertDialog.BUTTON_POSITIVE, "OK", null);

    return alertDialog;
}

然后,您可以覆盖默认AlertDialog的按钮" View.OnClickListener的(否则关闭该对话框)DialogFragment的onResume()方法:

@Override
public void onResume()
{
    super.onResume();
    AlertDialog alertDialog = (AlertDialog) getDialog();
    Button okButton = alertDialog.getButton(AlertDialog.BUTTON_POSITIVE);
    okButton.setOnClickListener(new View.OnClickListener() { 
        @Override
        public void onClick(View v)
        {
            performOkButtonAction();
        }
    });
}

private void performOkButtonAction() {
    // Do your stuff here
}

您需要在onResume()方法中设置它,因为getButton()将null在对话框显示之后返回!

这应该导致您的自定义操作方法只被调用一次,默认情况下不会解除对话框.

Answer 6

受Tom的回答启发,我相信这里的想法是:

• onClickListener在创建对话框期间设置null
• 然后onClickListener在显示对话框后设置.

您可以覆盖onShowListener类似Tom.或者,你可以

1. 调用AlertDialog后获取按钮 show()
2. 设置按钮onClickListener如下(我认为稍微可读).

码:

AlertDialog.Builder builder = new AlertDialog.Builder(context);
// ...
final AlertDialog dialog = builder.create();
dialog.show();
// now you can override the default onClickListener
Button b = dialog.getButton(AlertDialog.BUTTON_POSITIVE);
b.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        Log.i(TAG, "ok button is clicked");
        handleClick(dialog);
    }
});

Answer 7

超级简单的 Kotlin 方法

 with(AlertDialog.Builder(this)) {
        setTitle("Title")
        setView(R.layout.dialog_name)
        setPositiveButton("Ok", null)
        setNegativeButton("Cancel") { _, _ -> }
        create().apply {
            setOnShowListener {
                getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener {
                    //Validate and dismiss
                    dismiss()
                }
            }
        }
    }.show()

Answer 8

对于API 8之前,我使用布尔标志,解除侦听器和再次调用dialog.show来解决问题,如果editText的内容不正确的话.像这样:

case ADD_CLIENT:
        LayoutInflater factoryClient = LayoutInflater.from(this);
        final View EntryViewClient = factoryClient.inflate(
                R.layout.alert_dialog_add_client, null);

        EditText ClientText = (EditText) EntryViewClient
                .findViewById(R.id.client_edit);

        AlertDialog.Builder builderClient = new AlertDialog.Builder(this);
        builderClient
                .setTitle(R.string.alert_dialog_client)
                .setCancelable(false)
                .setView(EntryViewClient)
                .setPositiveButton("Save",
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog,
                                    int whichButton) {
                                EditText newClient = (EditText) EntryViewClient
                                        .findViewById(R.id.client_edit);
                                String newClientString = newClient
                                        .getText().toString();
                                if (checkForEmptyFields(newClientString)) {
                                    //If field is empty show toast and set error flag to true;
                                    Toast.makeText(getApplicationContext(),
                                            "Fields cant be empty",
                                            Toast.LENGTH_SHORT).show();
                                    add_client_error = true;
                                } else {
                                    //Here save the info and set the error flag to false
                                    add_client_error = false;
                                }
                            }
                        })
                .setNegativeButton("Cancel",
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog,
                                    int id) {
                                add_client_error = false;
                                dialog.cancel();
                            }
                        });
        final AlertDialog alertClient = builderClient.create();
        alertClient.show();

        alertClient
                .setOnDismissListener(new DialogInterface.OnDismissListener() {

                    @Override
                    public void onDismiss(DialogInterface dialog) {
                        //If the error flag was set to true then show the dialog again
                        if (add_client_error == true) {
                            alertClient.show();
                        } else {
                            return;
                        }

                    }
                });
        return true;

Answer 9

这个链接的答案是一个简单的解决方案,它可以直接与API 3兼容.它与Tom Bollwitt的解决方案非常相似,但不使用兼容性较差的OnShowListener.

是的你可以.你基本上需要:

1. 使用DialogBu​​ilder创建对话框
2. show()对话框
3. 在显示的对话框中找到按钮并覆盖它们的onClickListener

自从我扩展EditTextPreference以来,我对Kamen的代码做了一些小修改.

@Override
protected void showDialog(Bundle state) {
  super.showDialog(state);

  class mocl implements OnClickListener{
    private final AlertDialog dialog;
    public mocl(AlertDialog dialog) {
          this.dialog = dialog;
      }
    @Override
    public void onClick(View v) {

        //checks if EditText is empty, and if so tells the user via Toast
        //otherwise it closes dialog and calls the EditTextPreference's onClick
        //method to let it know that the button has been pressed

        if (!IntPreference.this.getEditText().getText().toString().equals("")){
        dialog.dismiss();
        IntPreference.this.onClick(dialog,DialogInterface.BUTTON_POSITIVE);
        }
        else {
            Toast t = Toast.makeText(getContext(), "Enter a number!", Toast.LENGTH_SHORT);
            t.show();
        }

    }
  }

  AlertDialog d = (AlertDialog) getDialog();
  Button b = d.getButton(DialogInterface.BUTTON_POSITIVE);
  b.setOnClickListener(new mocl((d)));
}

好好玩!