非常全的AlertDialog，简便弹出AlertDialog对话框

最新推荐文章于 2023-09-18 15:25:10 发布

乐帆

最新推荐文章于 2023-09-18 15:25:10 发布

阅读量348

点赞数 1

文章标签：对话框工具 Android 最全的工具简单易用

本文链接：https://blog.csdn.net/qq_18888607/article/details/86510223

版权

1. AlertDialogUtils

// 仅仅只是对{@link PDFDialogBuilder}构建器进行封装

public final class AlertDialogUtils {

    private final DialogBuilder builder;

    private AlertDialogUtils(DialogBuilder builder) {
        if (builder == null) {
            throw new IllegalArgumentException("Create builder fail");
        }
        this.builder = builder;
    }

    /**
     * 显示只带一个按钮的Alert对话框
     */
    public void show1ButtonDialog(String btText, OnClickListener clickListener) {
        builder.setPositiveButton(btText, clickListener).show();
    }

    /**
     * 显示带两个按钮的Alert对话框
     */
    public void show2ButtonDialog(String leftText, OnClickListener leftListener,
                                  String rightText, OnClickListener rightListener) {
        builder.setNegativeButton(leftText, leftListener)
                .setPositiveButton(rightText, rightListener)
                .show();
    }

    public void showInputDialog(CharSequence btText, OnEditClickListener listener) {
        showInputDialog(false, true, "", "", btText, listener, DialogInterface.BUTTON_POSITIVE);
    }

    public void showInputDialog(String inputContent, CharSequence btText, OnEditClickListener listener) {
        showInputDialog(false, true, inputContent, "", btText, listener, DialogInterface.BUTTON_POSITIVE);
    }

    /**
     * @param isPassword 是否是密码输入
     * @param single 是否是单行显示，如果是密码输入，则强制为单行显示
     * @param inputContent 输入框中已输入的信息
     * @param hint 输入框中的提示信息
     * @param btText 接受输入框中文案信息的按钮上的文案
     * @param listener 能够获取输入框中信息的点击事件
     * @param which 设置在那个按钮上面，eg：{@link DialogInterface#BUTTON_POSITIVE}
     */
    public void showInputDialog(boolean isPassword, boolean single, CharSequence inputContent,
                                CharSequence hint, CharSequence btText, OnEditClickListener listener, int which) {
        builder.setInputEditText(inputContent, hint, isPassword, single).setInputButton(btText, listener, which).show();
    }

    /**
     * 获取对话框构建器，用于自定义一些控件，但主题设置需要保持一致
     */
    public DialogBuilder getBuilder() {
        return builder;
    }

    /**
     * @see #getPDFAlertDialog(Context, String, String, int)
     */
    public static AlertDialogUtils getPDFAlertDialog(Context context, String title) {
        return getPDFAlertDialog(context, title, null, -1);
    }

    /**
     * 构建一个Alert创建器，这里方便统一管理Alert对话框的风格样式
     *
     * @param title 标题，可为空
     * @param message 信息正文，可为空
     */
    public static AlertDialogUtils getAlertDialog(Context context, String title, String message, int icon){
        DialogBuilder builder = new DialogBuilder(context);
        if (!TextUtils.isEmpty(title)) {
            builder.setTitle(title);
        }
        if (!TextUtils.isEmpty(message)) {
            builder.setMessage(message);
        }
        if (icon > 0) {
            builder.setIcon(icon);
        }
        return new AlertDialogUtils(builder);
    }
}

2、DialogBuilder

public final class DialogBuilder extends AlertDialog.Builder {

private TextInputLayout mInputLayout;
private TextInputEditText mInputEditText;
private int inputButtonIndex = Integer.MIN_VALUE;

private boolean dismissAfterOnClick = true;
private SparseArray<DialogInterface.OnClickListener> clickListenerSparseArray = new SparseArray<>(3);
private SparseIntArray buttonColors = new SparseIntArray(3);
private WeakReference<Button> inputPressButton;

private DialogInterface.OnDismissListener dismissListener;
private DialogInterface.OnCancelListener cancelListener;

public DialogBuilder(@NonNull Context context) {
super(context, R.style.PDFCommonDialogStyle);
super.setOnDismissListener(new DialogInterface.OnDismissListener() {
@Override
public void onDismiss(DialogInterface dialog) {
dismissDestroy();
if (dismissListener != null) {
dismissListener.onDismiss(dialog);
}
}
});

super.setOnCancelListener(new DialogInterface.OnCancelListener() {
@Override
public void onCancel(DialogInterface dialog) {
dismissDestroy();
if (cancelListener != null) {
cancelListener.onCancel(dialog);
}
}
});

}

@Deprecated DialogBuilder(@NonNull Context context, int themeResId) {
super(context, themeResId);
throw new IllegalArgumentException("Can't customize theme");
}

/**
* 普通输入框，多行显示
*
* @see #setInputEditText(CharSequence, CharSequence, boolean, boolean)
*/
public DialogBuilder setInputEditText(CharSequence content, CharSequence hint) {
return setInputEditText(content, hint, false, false);
}

/**
* 普通输入框，设置是否单行显示
*
* @see #setInputEditText(CharSequence, CharSequence, boolean, boolean)
*/
public DialogBuilder setInputEditText(CharSequence content, boolean single) {
return setInputEditText(content, null, false, single);
}

/**
* 开启输入框模式
*
* @param content 输入框中已经输入的文案
* @param hint 输入框的提示信息
* @param isPassword 是否是密码输入，如果是密码输入，则右边会自动新增一个小图标，并且自动单行输入
* @param single 输入框是否是单行显示，如果是密码输入，则强制单行输入
*/
public DialogBuilder setInputEditText(CharSequence content, CharSequence hint, boolean isPassword, boolean single) {
return (DialogBuilder) super.setView(getEditLayout(content, hint, isPassword, single));
}

/**
* 设置输入框的点击对话框，如果不是输入框状态下，则会抛出异常信息
*
* @param text 按钮上的文本
* @param listener 点击之后获取到输入框中的文案回调
* @param which 设置那个按钮为点击按钮，eg：{@link DialogInterface#BUTTON_POSITIVE}
* @throws IllegalArgumentException
*/
public DialogBuilder setInputButton(CharSequence text, OnEditClickListener listener, int which) {
mInputEditText = ObjectsUtils.requireNonNull(mInputEditText, "Please call setInputEditText method to set input view, or call setNegativeButton(), " +
"setPositiveButton(), setNeutralButton() to set button");
if (listener != null) {
listener.setInput(mInputLayout, mInputEditText);
}
inputButtonIndex = which;
switch (which) {
case DialogInterface.BUTTON_NEUTRAL:
setNeutralButton(text, listener);
break;
case DialogInterface.BUTTON_NEGATIVE:
setNegativeButton(text, listener);
break;
case DialogInterface.BUTTON_POSITIVE:
setPositiveButton(text, listener);
break;
}
return this;
}

/**
* 设置输入框的过滤规则
*/
public DialogBuilder setInputFilters(InputFilter[] inputFilters) {
mInputEditText = ObjectsUtils.requireNonNull(mInputEditText, "Please call setInputEditText method to set input view, or call setNegativeButton(), " +
"setPositiveButton(), setNeutralButton() to set button");
if (inputFilters != null && inputFilters.length > 0) {
mInputEditText.setFilters(inputFilters);
}
return this;
}

/**
* 设置软件盘点击确定时的动作,只有在单行模式下才有用,所以如果设置了此属性,会强制输入框单行显示,该按钮只针对
* 设置过捕获输入框事件的按钮,如果输入框没有关联任何一个按钮,则点击之后无反应
*
* @see EditorInfo
* @see TextView#getInputType()
*/
public DialogBuilder setImeOptions(final int type, final int imeOptions, final KeyListener digitsKeyListener) {
mInputEditText = ObjectsUtils.requireNonNull(mInputEditText, "Please call setInputEditText method to set input view, or call setNegativeButton(), " +
"setPositiveButton(), setNeutralButton() to set button");
if (imeOptions >= 0) {
mInputEditText.setImeOptions(imeOptions);
}
if (type >= 0) {
mInputEditText.setInputType(type);
}
if (digitsKeyListener != null) {
mInputEditText.setKeyListener(digitsKeyListener);
}
mInputEditText.setSingleLine(true);
mInputEditText.setOnEditorActionListener(new TextView.OnEditorActionListener() {
@Override public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
if (actionId == imeOptions) {
if (inputPressButton != null && inputPressButton.get() != null && !TextUtils.isEmpty(mInputEditText.getEditableText()){
return inputPressButton.get().performClick();
}
}
return false;
}
});
return this;
}

/**
* 设置对话框的返回按键事件，如果不设置则按照默认处理
*
* @param listener 返回按键点击回调，注意，为了和‘取消’、‘确定’等按钮保持一致，该事件也绑定一个id，为{@link KeyEvent#KEYCODE_BACK}
*/
public DialogBuilder setOnBackPressed(DialogInterface.OnClickListener listener) {
clickListenerSparseArray.put(KeyEvent.KEYCODE_BACK, listener);
return this;
}

/**
* 设置对话框在点击任意一个按钮之后是否关闭对话框，如果设置了该属性，则对话框中三个任意按钮都需要自行处理对话框的主动关闭
*
* @param dismiss true表示点击之后进行关闭，默认是true
*/
public DialogBuilder setDismissAfterClick(boolean dismiss) {
this.dismissAfterOnClick = dismiss;
return this;
}

/**
* 设置对话框按钮颜色
*/
public DialogBuilder setButtonColor(int which, @ColorRes int color) {
buttonColors.put(which, color);
return this;
}

private void dismissDestroy() {
if (mInputEditText != null) {
HandlerUtil.getInstance().postUIDelayed(new Runnable() {
@Override public void run() {
SoftKeyboardUtil.hideSoftKeyboard(mInputEditText);
}
}, 500);
}
clickListenerSparseArray.clear();
mInputLayout = null;
mInputEditText = null;
}

private void adjustLayoutParams(View view, int gravity, int value, boolean cover) {
if (view.getLayoutParams() != null && view.getLayoutParams() instanceof ViewGroup.MarginLayoutParams) {
ViewGroup.MarginLayoutParams lp = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
switch (gravity) {
case Gravity.TOP:
lp.topMargin = cover ? value : (lp.topMargin + value);
break;
case Gravity.BOTTOM:
lp.bottomMargin = cover ? value : (lp.bottomMargin + value);
break;
case Gravity.START:
lp.leftMargin = cover ? value : (lp.leftMargin + value);
break;
case Gravity.END:
lp.rightMargin = cover ? value : (lp.rightMargin + value);
break;
}
view.setLayoutParams(lp);
}
}

private CheckableImageButton getCheckableImageButton() {
if (mInputLayout != null) {
try {
Field field = mInputLayout.getClass().getDeclaredField("mPasswordToggleView");
field.setAccessible(true);
return (CheckableImageButton) field.get(mInputLayout);
} catch (Exception e) {
e.printStackTrace();
}
}
return null;
}

private View getEditLayout(CharSequence content, CharSequence hint, final boolean isPassword, boolean single) {
mInputLayout = (TextInputLayout) View.inflate(getContext(), R.layout.share_alert_input_layout, null);
mInputEditText = mInputLayout.findViewById(R.id.alert_input);
if (isPassword || single) {
mInputEditText.setSingleLine(true);
} else {
mInputEditText.setMaxLines(12); // 在多行模式下，最多只能输入12行
}
if (isPassword) {
mInputEditText.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
}
mInputEditText.setHint(TextUtils.isEmpty(hint) ? "" : hint);
mInputEditText.setText(TextUtils.isEmpty(content) ? "" : content);
mInputEditText.setSelection(TextUtils.isEmpty(content) ? 0 : content.length());
mInputEditText.requestFocus();
mInputEditText.postDelayed(new Runnable() {
@Override
public void run() {
SoftKeyboardUtil.showSoftKeyboard(mInputEditText);
}
}, 100);

mInputLayout.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
@Override public void onGlobalLayout() {
// 这里需要强制设置一下输入框的最小边距，因为在TextInputLayout中，如果是密码输入，它会强制设置输入框的最小高度为48dp，对我们而言显然偏大
// 在design_text_input_password_icon.xml文件中被定义
mInputLayout.getViewTreeObserver().removeOnGlobalLayoutListener(this);
final int minSize = getContext().getResources().getDimensionPixelSize(R.dimen.public_alert_toggle_min_size);
if (isPassword) {
CheckableImageButton imageButton = getCheckableImageButton();
if (imageButton != null) {
imageButton.setMinimumHeight(minSize);
imageButton.setMinimumWidth(minSize);
}
}
mInputEditText.setMinimumHeight(minSize);
mInputLayout.requestLayout();
}
});
return mInputLayout;
}

// 设置按钮间距
private void setAlertButtonAppearances(final AlertDialog dialog) {
int[] buttonArray = new int[]{DialogInterface.BUTTON_POSITIVE, DialogInterface.BUTTON_NEGATIVE, DialogInterface.BUTTON_NEUTRAL};
ViewGroup parent = null;
for (int i : buttonArray) {
final Button bt = dialog.getButton(i);
if (bt != null) {
bt.setTextAppearance(getContext(), R.style.AlertDialog_Button);
Integer btColor = buttonColors.get(i);
if (btColor > 0) {
bt.setTextColor(dialog.getContext().getResources().getColor(btColor));
}
if (i != DialogInterface.BUTTON_POSITIVE) {
adjustLayoutParams(bt, Gravity.END, getContext().getResources().getDimensionPixelOffset(R.dimen.public_alert_button_left_margin), true);
}
if (i != DialogInterface.BUTTON_NEGATIVE) {
adjustLayoutParams(bt, Gravity.END, getContext().getResources().getDimensionPixelOffset(R.dimen.public_alert_button_midd_margin), true);
}
if (parent == null) {
if (bt.getParent() != null && bt.getParent() instanceof ViewGroup) {
parent = (ViewGroup) bt.getParent();
}
}
}
}
if (parent != null) {
ViewGroup.MarginLayoutParams lp = (ViewGroup.MarginLayoutParams) parent.getLayoutParams();
if (lp != null) {
lp.bottomMargin = DisplayUtil.dip2px(getContext(), 3);
parent.setLayoutParams(lp);
}
}
}

// 设置输入框与那个按钮相关联
private void setAlertButtonAssociation(final AlertDialog dialog, final int inputIndex) {
int[] buttonArray = new int[]{DialogInterface.BUTTON_POSITIVE, DialogInterface.BUTTON_NEGATIVE, DialogInterface.BUTTON_NEUTRAL};
for (int i : buttonArray) {
final Button bt = dialog.getButton(i);
boolean isClickInput = (inputIndex == i);
if (bt != null) {
if (mInputEditText != null && isClickInput) {
inputPressButton = new WeakReference<>(bt);
bt.setEnabled(!TextUtils.isEmpty(mInputEditText.getText()));
Integer btColor = buttonColors.get(i);
if (btColor > 0) {
bt.setTextColor(dialog.getContext().getResources().getColor(btColor));
} else {
bt.setTextColor(getContext().getResources().getColorStateList(R.color.public_alert_dialog_button_color));
}
mInputEditText.addTextChangedListener(new TextWatcherWrap() {
@Override
public void afterTextChanged(Editable s) {
bt.setEnabled(!TextUtils.isEmpty(s));
}
});
}
}
}
}

// 设置物理返回按键按下时的动作
private void setBackPressListener(final AlertDialog dialog, final DialogInterface.OnClickListener listener) {
dialog.setOnKeyListener(new DialogInterface.OnKeyListener() {
@Override public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
if (keyCode == KeyEvent.KEYCODE_BACK) {
listener.onClick(dialog, keyCode);
return true;
}
return false;
}
});
}

// 设置按钮点击之后对话框是否关闭，如果选择不关闭，则需要调用端自己调用dismiss方法进行关闭
private void setDismissAfterOnClick(final AlertDialog dialog) {
int[] buttonArray = new int[]{DialogInterface.BUTTON_POSITIVE, DialogInterface.BUTTON_NEGATIVE, DialogInterface.BUTTON_NEUTRAL};
for (int i : buttonArray) {
final int btIndex = i;
final Button bt = dialog.getButton(btIndex);
final DialogInterface.OnClickListener clickListener = clickListenerSparseArray.get(btIndex);
if (bt != null && clickListener != null) {
bt.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
clickListener.onClick(dialog, btIndex);
}
});
}
}
}

// 对对话框中标题、正文等进行颜色、间距等属性的调整，在调整过程中可能出现控件没定义，空指针异常
private void setAlertControllerAttributes(final AlertDialog dialog) {
try {
TextView title = dialog.findViewById(R.id.alertTitle);
boolean hasTitle = false;
if (title != null) {
// 预先给标题栏设置一个上下间距，后面再根据情况进行细节微调
title.setTextAppearance(getContext(), R.style.AlertDialog_Title);
title.setPadding(title.getPaddingLeft(), title.getPaddingTop() + getContext().getResources().getDimensionPixelOffset(R.dimen.public_alert_title_top),
title.getPaddingRight(), title.getPaddingBottom() + getContext().getResources().getDimensionPixelOffset(R.dimen.public_alert_title_bottom));
hasTitle = title.getVisibility() == View.VISIBLE && !TextUtils.isEmpty(title.getText());
}
View contentPanel = dialog.findViewById(R.id.contentPanel);
if (contentPanel != null) {
contentPanel.setMinimumHeight(0); // 去掉多余空隙
TextView content = contentPanel.findViewById(android.R.id.message);
if (content != null) {
content.setTextAppearance(getContext(), R.style.AlertDialog_Message);
if (mInputEditText != null && mInputEditText.getInputType() == (InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD)) {
// 如果是密码输入，则强制设置消息正文为灰色提示信息，并且隐藏掉顶部的空白部分
content.setTextColor(getContext().getResources().getColor(R.color.public_alert_gray));
}
}
boolean hasMessageView = (content != null && content.getVisibility() == View.VISIBLE && !TextUtils.isEmpty(content.getText()));
if (mInputEditText != null) {
if (hasTitle && !hasMessageView) { // 标题+输入框
title.setPadding(title.getPaddingLeft(), title.getPaddingTop(), title.getPaddingRight(),
title.getPaddingBottom() + getContext().getResources().getDimensionPixelOffset(R.dimen.public_alert_title_bottom_adjustment_1));
} else if (!hasTitle && hasMessageView) { // 正文消息+输入框
adjustLayoutParams(mInputLayout, Gravity.TOP, getContext().getResources().getDimensionPixelOffset(R.dimen.public_alert_title_bottom_adjustment_2), false);
} else if (hasTitle && hasMessageView) { // 标题+正文消息+输入框
title.setPadding(title.getPaddingLeft(), title.getPaddingTop(), title.getPaddingRight(),
title.getPaddingBottom() - getContext().getResources().getDimensionPixelOffset(R.dimen.public_alert_title_bottom_adjustment_3_1));
adjustLayoutParams(mInputLayout, Gravity.TOP, getContext().getResources().getDimensionPixelOffset(R.dimen.public_alert_title_bottom_adjustment_3_2), false);
} else { // 只有输入框，这个就好尴尬了，但还是要处理一下
adjustLayoutParams(mInputLayout, Gravity.TOP, getContext().getResources().getDimensionPixelOffset(R.dimen.public_alert_title_bottom_adjustment_4), false);
}
} else {
if (hasTitle && !hasMessageView) { // 只有标题

} else if (!hasTitle && hasMessageView) { // 只有正文
adjustLayoutParams(content, Gravity.TOP, getContext().getResources().getDimensionPixelOffset(R.dimen.public_alert_title_bottom_adjustment_6), false);
} else if (hasTitle && hasMessageView) { // 标题 + 正文
title.setPadding(title.getPaddingLeft(), title.getPaddingTop(), title.getPaddingRight(),
title.getPaddingBottom() - getContext().getResources().getDimensionPixelOffset(R.dimen.public_alert_title_bottom_adjustment_5));
}
}
}
View buttonPanel = dialog.findViewById(R.id.buttonPanel);
if (buttonPanel != null) {
buttonPanel.setPadding(buttonPanel.getPaddingLeft(), buttonPanel.getPaddingTop() + getContext().getResources().getDimensionPixelOffset(R.dimen.public_alert_button_top),
buttonPanel.getPaddingRight(), buttonPanel.getPaddingBottom());
}
View customPanel = dialog.findViewById(R.id.customPanel);
if (customPanel != null) {
customPanel.setMinimumHeight(0);
}
} catch (NullPointerException e) {
// 出现空指针不作处理，属性设置失败，表现形式和普通Alert一致
}
}

/**
* 不要直接调用该方法，否则按钮的所有设置会无效，和普通的{@link AlertDialog}一样
*/
@Deprecated
@Override
public AlertDialog create() {
return super.create();
}

@Override
public AlertDialog show() {
if (mInputEditText != null) {
if (inputButtonIndex == Integer.MIN_VALUE) {
// 如果设置了输入框，则在没有设置按钮的情况下需要强制设置一个按钮来接受输入框的输入
setInputButton(getContext().getResources().getString(android.R.string.ok), new OnEditClickListener() {
@Override
public void onInputClick(DialogInterface dialog, int which, TextInputLayout errorHandler, CharSequence inputString) {
// Do nothing
}
}, DialogInterface.BUTTON_POSITIVE);
}
}
AlertDialog dialog = super.show();
// 以下调用顺序不要颠倒
setAlertButtonAppearances(dialog);
if (mInputEditText != null) {
setAlertButtonAssociation(dialog, inputButtonIndex);
}
if (!dismissAfterOnClick) {
setDismissAfterOnClick(dialog);
}
if (clickListenerSparseArray.get(KeyEvent.KEYCODE_BACK) != null) {
setBackPressListener(dialog, clickListenerSparseArray.get(KeyEvent.KEYCODE_BACK));
}
clickListenerSparseArray.clear();
setAlertControllerAttributes(dialog);
return dialog;
}

// =============================================================================================
// 下面是复写的方法，强制将返回对象从AlertDialog.Builder改为当前对象
// =============================================================================================

@Override
public DialogBuilder setTitle(int titleId) {
return (DialogBuilder) super.setTitle(titleId);
}

@Override
public DialogBuilder setTitle(@Nullable CharSequence title) {
return (DialogBuilder) super.setTitle(title);
}

/**
* 不要自定义标题栏，自定义标题栏可能出现ui上的大片空白，所以不建议使用
*/
@Override
@Deprecated
public DialogBuilder setCustomTitle(@Nullable View customTitleView) {
return (DialogBuilder) super.setCustomTitle(customTitleView);
}

@Override
public DialogBuilder setMessage(int messageId) {
return (DialogBuilder) super.setMessage(messageId);
}

@Override
public DialogBuilder setMessage(@Nullable CharSequence message) {
return (DialogBuilder) super.setMessage(message);
}

@Override
public DialogBuilder setIcon(int iconId) {
return (DialogBuilder) super.setIcon(iconId);
}

@Override
public DialogBuilder setIcon(@Nullable Drawable icon) {
return (DialogBuilder) super.setIcon(icon);
}

@Override
public DialogBuilder setIconAttribute(int attrId) {
return (DialogBuilder) super.setIconAttribute(attrId);
}

@Override
public DialogBuilder setPositiveButton(int textId, DialogInterface.OnClickListener listener) {
clickListenerSparseArray.put(DialogInterface.BUTTON_POSITIVE, listener);
return (DialogBuilder) super.setPositiveButton(textId, listener);
}

@Override
public DialogBuilder setPositiveButton(CharSequence text, DialogInterface.OnClickListener listener) {
clickListenerSparseArray.put(DialogInterface.BUTTON_POSITIVE, listener);
return (DialogBuilder) super.setPositiveButton(text, listener);
}

@Override
public DialogBuilder setPositiveButtonIcon(Drawable icon) {
return (DialogBuilder) super.setPositiveButtonIcon(icon);
}

@Override
public DialogBuilder setNegativeButton(int textId, DialogInterface.OnClickListener listener) {
clickListenerSparseArray.put(DialogInterface.BUTTON_NEGATIVE, listener);
return (DialogBuilder) super.setNegativeButton(textId, listener);
}

@Override
public DialogBuilder setNegativeButton(CharSequence text, DialogInterface.OnClickListener listener) {
clickListenerSparseArray.put(DialogInterface.BUTTON_NEGATIVE, listener);
return (DialogBuilder) super.setNegativeButton(text, listener);
}

@Override
public DialogBuilder setNegativeButtonIcon(Drawable icon) {
return (DialogBuilder) super.setNegativeButtonIcon(icon);
}

@Override
public DialogBuilder setNeutralButton(int textId, DialogInterface.OnClickListener listener) {
clickListenerSparseArray.put(DialogInterface.BUTTON_NEUTRAL, listener);
return (DialogBuilder) super.setNeutralButton(textId, listener);
}

@Override
public DialogBuilder setNeutralButton(CharSequence text, DialogInterface.OnClickListener listener) {
clickListenerSparseArray.put(DialogInterface.BUTTON_NEUTRAL, listener);
return (DialogBuilder) super.setNeutralButton(text, listener);
}

@Override
public DialogBuilder setNeutralButtonIcon(Drawable icon) {
return (DialogBuilder) super.setNeutralButtonIcon(icon);
}

@Override
public DialogBuilder setCancelable(boolean cancelable) {
return (DialogBuilder) super.setCancelable(cancelable);
}

@Override
public DialogBuilder setOnCancelListener(DialogInterface.OnCancelListener onCancelListener) {
cancelListener = onCancelListener;
return this;
}

@Override
public DialogBuilder setOnDismissListener(DialogInterface.OnDismissListener onDismissListener) {
dismissListener = onDismissListener;
return this;
}

@Override
public DialogBuilder setOnKeyListener(DialogInterface.OnKeyListener onKeyListener) {
return (DialogBuilder) super.setOnKeyListener(onKeyListener);
}

@Override
public DialogBuilder setItems(int itemsId, DialogInterface.OnClickListener listener) {
return (DialogBuilder) super.setItems(itemsId, listener);
}

@Override
public DialogBuilder setItems(CharSequence[] items, DialogInterface.OnClickListener listener) {
return (DialogBuilder) super.setItems(items, listener);
}

@Override
public DialogBuilder setAdapter(ListAdapter adapter, DialogInterface.OnClickListener listener) {
return (DialogBuilder) super.setAdapter(adapter, listener);
}

@Override
public DialogBuilder setCursor(Cursor cursor, DialogInterface.OnClickListener listener, String labelColumn) {
return (DialogBuilder) super.setCursor(cursor, listener, labelColumn);
}

@Override
public DialogBuilder setMultiChoiceItems(int itemsId, boolean[] checkedItems, DialogInterface.OnMultiChoiceClickListener listener) {
return (DialogBuilder) super.setMultiChoiceItems(itemsId, checkedItems, listener);
}

@Override
public DialogBuilder setMultiChoiceItems(CharSequence[] items, boolean[] checkedItems, DialogInterface.OnMultiChoiceClickListener listener) {
return (DialogBuilder) super.setMultiChoiceItems(items, checkedItems, listener);
}

@Override
public DialogBuilder setMultiChoiceItems(Cursor cursor, String isCheckedColumn, String labelColumn, DialogInterface.OnMultiChoiceClickListener listener) {
return (DialogBuilder) super.setMultiChoiceItems(cursor, isCheckedColumn, labelColumn, listener);
}

@Override
public DialogBuilder setSingleChoiceItems(int itemsId, int checkedItem, DialogInterface.OnClickListener listener) {
return (DialogBuilder) super.setSingleChoiceItems(itemsId, checkedItem, listener);
}

@Override
public DialogBuilder setSingleChoiceItems(Cursor cursor, int checkedItem, String labelColumn, DialogInterface.OnClickListener listener) {
return (DialogBuilder) super.setSingleChoiceItems(cursor, checkedItem, labelColumn, listener);
}

@Override
public DialogBuilder setSingleChoiceItems(CharSequence[] items, int checkedItem, DialogInterface.OnClickListener listener) {
return (DialogBuilder) super.setSingleChoiceItems(items, checkedItem, listener);
}

@Override
public DialogBuilder setSingleChoiceItems(ListAdapter adapter, int checkedItem, DialogInterface.OnClickListener listener) {
return (DialogBuilder) super.setSingleChoiceItems(adapter, checkedItem, listener);
}

@Override
public DialogBuilder setOnItemSelectedListener(AdapterView.OnItemSelectedListener listener) {
return (DialogBuilder) super.setOnItemSelectedListener(listener);
}

/**
* @deprecated 不推荐自定义布局文件，如果使用自定义布局，则输入框所有设置都将不可用
*/
@Deprecated
@Override
public DialogBuilder setView(int layoutResId) {
return (DialogBuilder) super.setView(layoutResId);
}

/**
* @deprecated 不推荐自定义布局文件，否则输入框所有设置都将不可用
*/
@Deprecated
@Override
public DialogBuilder setView(View view) {
return (DialogBuilder) super.setView(view);
}

@Override
public DialogBuilder setInverseBackgroundForced(boolean useInverseBackground) {
return (DialogBuilder) super.setInverseBackgroundForced(useInverseBackground);
}

private class TextWatcherWrap implements 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) {

}
}
}

3、调用方式

public void showDialogOne() {
    AlertDialogUtils alertDialog = AlertDialogUtils.getAlertDialog(getActivity(),
            "", "You have no email client，please download in android market"), 0);
    pdfAlertDialog.show1ButtonDialog(getActivity().getResources().getString(R.string.public_ok), new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int which) {   //弹出只有一个按钮的 对话框
        }
    });
}

乐帆

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
非常全的AlertDialog，简便弹出AlertDialog对话框

1. AlertDialogUtils // 仅仅只是对{@link PDFDialogBuilder}构建器进行封装public final class AlertDialogUtils { private final DialogBuilder builder; private AlertDialogUtils(DialogBuilder builder) {...
复制链接

扫一扫