https://source.android.com/ 
/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.app;

import android.annotation.ArrayRes;
import android.annotation.AttrRes;
import android.annotation.DrawableRes;
import android.annotation.StringRes;
import android.annotation.StyleRes;
import android.content.Context;
import android.content.DialogInterface;
import android.content.res.ResourceId;
import android.database.Cursor;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Message;
import android.text.Layout;
import android.text.method.MovementMethod;
import android.util.TypedValue;
import android.view.ContextThemeWrapper;
import android.view.KeyEvent;
import android.view.View;
import android.widget.AdapterView;
import android.widget.Button;
import android.widget.ListAdapter;
import android.widget.ListView;

import com.android.internal.R;
import com.android.internal.app.AlertController;


A subclass of Dialog that can display one, two or three buttons. If you only want to
display a String in this dialog box, use the setMessage() method.  If you
want to display a more complex view, look up the FrameLayout called "custom"
and add your view to it:

FrameLayout fl = findViewById(android.R.id.custom);
fl.addView(myView, new LayoutParams(MATCH_PARENT, WRAP_CONTENT));



The AlertDialog class takes care of automatically setting 
WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM for you based on whether any views in the dialog return true from 
View.onCheckIsTextEditor(). Generally you want this set for a Dialog without text editors, so that it will be placed on top of the current input method UI. You can modify this behavior by forcing the flag to your desired mode after calling onCreate. 


Developer Guides


For more information about creating dialogs, read the
Dialogs developer guide.




/**
 * A subclass of Dialog that can display one, two or three buttons. If you only want to
 * display a String in this dialog box, use the setMessage() method.  If you
 * want to display a more complex view, look up the FrameLayout called "custom"
 * and add your view to it:
 *
 * <pre>
 * FrameLayout fl = findViewById(android.R.id.custom);
 * fl.addView(myView, new LayoutParams(MATCH_PARENT, WRAP_CONTENT));
 * </pre>
 *
 * <p>The AlertDialog class takes care of automatically setting
 * {@link android.view.WindowManager.LayoutParams#FLAG_ALT_FOCUSABLE_IM
 * WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM} for you based on whether
 * any views in the dialog return true from {@link View#onCheckIsTextEditor()
 * View.onCheckIsTextEditor()}.  Generally you want this set for a Dialog
 * without text editors, so that it will be placed on top of the current
 * input method UI.  You can modify this behavior by forcing the flag to your
 * desired mode after calling {@link #onCreate}.
 *
 * <div class="special reference">
 * <h3>Developer Guides</h3>
 * <p>For more information about creating dialogs, read the
 * <a href="{@docRoot}guide/topics/ui/dialogs.html">Dialogs</a> developer guide.</p>
 * </div>
 */
public class AlertDialog extends Dialog implements DialogInterface {
    private AlertController mAlert;

    
Special theme constant for AlertDialog(Context, int): use the traditional (pre-Holo) alert dialog theme. 
Deprecated:Use Theme_Material_Dialog_Alert.Theme_Material_Dialog_Alert.
/**
     * Special theme constant for {@link #AlertDialog(Context, int)}: use
     * the traditional (pre-Holo) alert dialog theme.
     *
     * @deprecated Use {@link android.R.style#Theme_Material_Dialog_Alert}.
     */
    @Deprecated
    public static final int THEME_TRADITIONAL = 1;

    
Special theme constant for AlertDialog(Context, int): use the holographic alert theme with a dark background. 
Deprecated:Use Theme_Material_Dialog_Alert.Theme_Material_Dialog_Alert.
/**
     * Special theme constant for {@link #AlertDialog(Context, int)}: use
     * the holographic alert theme with a dark background.
     *
     * @deprecated Use {@link android.R.style#Theme_Material_Dialog_Alert}.
     */
    @Deprecated
    public static final int THEME_HOLO_DARK = 2;

    
Special theme constant for AlertDialog(Context, int): use the holographic alert theme with a light background. 
Deprecated:Use Theme_Material_Light_Dialog_Alert.Theme_Material_Light_Dialog_Alert.
/**
     * Special theme constant for {@link #AlertDialog(Context, int)}: use
     * the holographic alert theme with a light background.
     *
     * @deprecated Use {@link android.R.style#Theme_Material_Light_Dialog_Alert}.
     */
    @Deprecated
    public static final int THEME_HOLO_LIGHT = 3;

    
Special theme constant for AlertDialog(Context, int): use the device's default alert theme with a dark background. 
Deprecated:Use Theme_DeviceDefault_Dialog_Alert.Theme_DeviceDefault_Dialog_Alert.
/**
     * Special theme constant for {@link #AlertDialog(Context, int)}: use
     * the device's default alert theme with a dark background.
     *
     * @deprecated Use {@link android.R.style#Theme_DeviceDefault_Dialog_Alert}.
     */
    @Deprecated
    public static final int THEME_DEVICE_DEFAULT_DARK = 4;

    
Special theme constant for AlertDialog(Context, int): use the device's default alert theme with a light background. 
Deprecated:Use Theme_DeviceDefault_Light_Dialog_Alert.Theme_DeviceDefault_Light_Dialog_Alert.
/**
     * Special theme constant for {@link #AlertDialog(Context, int)}: use
     * the device's default alert theme with a light background.
     *
     * @deprecated Use {@link android.R.style#Theme_DeviceDefault_Light_Dialog_Alert}.
     */
    @Deprecated
    public static final int THEME_DEVICE_DEFAULT_LIGHT = 5;

    
No layout hint.

@hide
/**
     * No layout hint.
     * @hide
     */
    public static final int LAYOUT_HINT_NONE = 0;

    
Hint layout to the side.

@hide
/**
     * Hint layout to the side.
     * @hide
     */
    public static final int LAYOUT_HINT_SIDE = 1;

    
Creates an alert dialog that uses the default alert dialog theme.

 The default alert dialog theme is defined by alertDialogTheme.alertDialogTheme within the parent context's theme. 
Params:
  • context – the parent context
See Also:
  • Theme_alertDialogTheme.Theme_alertDialogTheme
/**
     * Creates an alert dialog that uses the default alert dialog theme.
     * <p>
     * The default alert dialog theme is defined by
     * {@link android.R.attr#alertDialogTheme} within the parent
     * {@code context}'s theme.
     *
     * @param context the parent context
     * @see android.R.styleable#Theme_alertDialogTheme
     */
    protected AlertDialog(Context context) {
        this(context, 0);
    }

    
Creates an alert dialog that uses the default alert dialog theme and a
custom cancel listener.


This is functionally identical to:

    AlertDialog dialog = new AlertDialog(context);
    alertDialog.setCancelable(cancelable);
    alertDialog.setOnCancelListener(cancelListener);



 The default alert dialog theme is defined by alertDialogTheme.alertDialogTheme within the parent context's theme. 
Params:
  • context – the parent context
See Also:
  • Theme_alertDialogTheme.Theme_alertDialogTheme
/**
     * Creates an alert dialog that uses the default alert dialog theme and a
     * custom cancel listener.
     * <p>
     * This is functionally identical to:
     * <pre>
     *     AlertDialog dialog = new AlertDialog(context);
     *     alertDialog.setCancelable(cancelable);
     *     alertDialog.setOnCancelListener(cancelListener);
     * </pre>
     * <p>
     * The default alert dialog theme is defined by
     * {@link android.R.attr#alertDialogTheme} within the parent
     * {@code context}'s theme.
     *
     * @param context the parent context
     * @see android.R.styleable#Theme_alertDialogTheme
     */
    protected AlertDialog(Context context, boolean cancelable, OnCancelListener cancelListener) {
        this(context, 0);

        setCancelable(cancelable);
        setOnCancelListener(cancelListener);
    }

    
Creates an alert dialog that uses an explicit theme resource.

 The specified theme resource (themeResId) is applied on top of the parent context's theme. It may be specified as a style resource containing a fully-populated theme, such as Theme_Material_Dialog.Theme_Material_Dialog, to replace all attributes in the parent context's theme including primary and accent colors. 
 To preserve attributes such as primary and accent colors, the themeResId may instead be specified as an overlay theme such as ThemeOverlay_Material_Dialog.ThemeOverlay_Material_Dialog. This will override only the window attributes necessary to style the alert window as a dialog. 
 Alternatively, the themeResId may be specified as 0 to use the parent context's resolved value for alertDialogTheme.alertDialogTheme. 
Params:
  • context – the parent context
  • themeResId – the resource ID of the theme against which to inflate this dialog, or 0 to use the parent context's default alert dialog theme
See Also:
  • Theme_alertDialogTheme.Theme_alertDialogTheme
/**
     * Creates an alert dialog that uses an explicit theme resource.
     * <p>
     * The specified theme resource ({@code themeResId}) is applied on top of
     * the parent {@code context}'s theme. It may be specified as a style
     * resource containing a fully-populated theme, such as
     * {@link android.R.style#Theme_Material_Dialog}, to replace all attributes
     * in the parent {@code context}'s theme including primary and accent
     * colors.
     * <p>
     * To preserve attributes such as primary and accent colors, the
     * {@code themeResId} may instead be specified as an overlay theme such as
     * {@link android.R.style#ThemeOverlay_Material_Dialog}. This will override
     * only the window attributes necessary to style the alert window as a
     * dialog.
     * <p>
     * Alternatively, the {@code themeResId} may be specified as {@code 0} to
     * use the parent {@code context}'s resolved value for
     * {@link android.R.attr#alertDialogTheme}.
     *
     * @param context the parent context
     * @param themeResId the resource ID of the theme against which to inflate
     *                   this dialog, or {@code 0} to use the parent
     *                   {@code context}'s default alert dialog theme
     * @see android.R.styleable#Theme_alertDialogTheme
     */
    protected AlertDialog(Context context, @StyleRes int themeResId) {
        this(context, themeResId, true);
    }

    AlertDialog(Context context, @StyleRes int themeResId, boolean createContextThemeWrapper) {
        super(context, createContextThemeWrapper ? resolveDialogTheme(context, themeResId) : 0,
                createContextThemeWrapper);

        mWindow.alwaysReadCloseOnTouchAttr();
        mAlert = AlertController.create(getContext(), this, getWindow());
    }

    static @StyleRes int resolveDialogTheme(Context context, @StyleRes int themeResId) {
        if (themeResId == THEME_TRADITIONAL) {
            return R.style.Theme_Dialog_Alert;
        } else if (themeResId == THEME_HOLO_DARK) {
            return R.style.Theme_Holo_Dialog_Alert;
        } else if (themeResId == THEME_HOLO_LIGHT) {
            return R.style.Theme_Holo_Light_Dialog_Alert;
        } else if (themeResId == THEME_DEVICE_DEFAULT_DARK) {
            return R.style.Theme_DeviceDefault_Dialog_Alert;
        } else if (themeResId == THEME_DEVICE_DEFAULT_LIGHT) {
            return R.style.Theme_DeviceDefault_Light_Dialog_Alert;
        } else if (ResourceId.isValid(themeResId)) {
            // start of real resource IDs.
            return themeResId;
        } else {
            final TypedValue outValue = new TypedValue();
            context.getTheme().resolveAttribute(R.attr.alertDialogTheme, outValue, true);
            return outValue.resourceId;
        }
    }

    
Gets one of the buttons used in the dialog. Returns null if the specified button does not exist or the dialog has not yet been fully created (for example, via Dialog.show() or Dialog.create()). 
Params:
Returns:The button from the dialog, or null if a button does not exist.
/**
     * Gets one of the buttons used in the dialog. Returns null if the specified
     * button does not exist or the dialog has not yet been fully created (for
     * example, via {@link #show()} or {@link #create()}).
     *
     * @param whichButton The identifier of the button that should be returned.
     *            For example, this can be
     *            {@link DialogInterface#BUTTON_POSITIVE}.
     * @return The button from the dialog, or null if a button does not exist.
     */
    public Button getButton(int whichButton) {
        return mAlert.getButton(whichButton);
    }

    
Gets the list view used in the dialog.

Returns:The ListView from the dialog.
/**
     * Gets the list view used in the dialog.
     *
     * @return The {@link ListView} from the dialog.
     */
    public ListView getListView() {
        return mAlert.getListView();
    }

    @Override
    public void setTitle(CharSequence title) {
        super.setTitle(title);
        mAlert.setTitle(title);
    }

    
See Also:
  • setCustomTitle.setCustomTitle(View)
/**
     * @see Builder#setCustomTitle(View)
     */
    public void setCustomTitle(View customTitleView) {
        mAlert.setCustomTitle(customTitleView);
    }

    public void setMessage(CharSequence message) {
        mAlert.setMessage(message);
    }

    
@hide
/** @hide */
    public void setMessageMovementMethod(MovementMethod movementMethod) {
        mAlert.setMessageMovementMethod(movementMethod);
    }

    
@hide
/** @hide */
    public void setMessageHyphenationFrequency(
            @Layout.HyphenationFrequency int hyphenationFrequency) {
        mAlert.setMessageHyphenationFrequency(hyphenationFrequency);
    }

    
Set the view to display in that dialog.

/**
     * Set the view to display in that dialog.
     */
    public void setView(View view) {
        mAlert.setView(view);
    }

    
Set the view to display in that dialog, specifying the spacing to appear around that
view.

Params:
  • view – The view to show in the content area of the dialog
  • viewSpacingLeft – Extra space to appear to the left of view
  • viewSpacingTop – Extra space to appear above view
  • viewSpacingRight – Extra space to appear to the right of view
  • viewSpacingBottom – Extra space to appear below view
/**
     * Set the view to display in that dialog, specifying the spacing to appear around that
     * view.
     *
     * @param view The view to show in the content area of the dialog
     * @param viewSpacingLeft Extra space to appear to the left of {@code view}
     * @param viewSpacingTop Extra space to appear above {@code view}
     * @param viewSpacingRight Extra space to appear to the right of {@code view}
     * @param viewSpacingBottom Extra space to appear below {@code view}
     */
    public void setView(View view, int viewSpacingLeft, int viewSpacingTop, int viewSpacingRight,
            int viewSpacingBottom) {
        mAlert.setView(view, viewSpacingLeft, viewSpacingTop, viewSpacingRight, viewSpacingBottom);
    }

    
Internal api to allow hinting for the best button panel layout.

@hide
/**
     * Internal api to allow hinting for the best button panel layout.
     * @hide
     */
    void setButtonPanelLayoutHint(int layoutHint) {
        mAlert.setButtonPanelLayoutHint(layoutHint);
    }

    
Set a message to be sent when a button is pressed.

Params:
/**
     * Set a message to be sent when a button is pressed.
     *
     * @param whichButton Which button to set the message for, can be one of
     *            {@link DialogInterface#BUTTON_POSITIVE},
     *            {@link DialogInterface#BUTTON_NEGATIVE}, or
     *            {@link DialogInterface#BUTTON_NEUTRAL}
     * @param text The text to display in positive button.
     * @param msg The {@link Message} to be sent when clicked.
     */
    public void setButton(int whichButton, CharSequence text, Message msg) {
        mAlert.setButton(whichButton, text, null, msg);
    }

    
Set a listener to be invoked when the positive button of the dialog is pressed.

Params:
/**
     * Set a listener to be invoked when the positive button of the dialog is pressed.
     *
     * @param whichButton Which button to set the listener on, can be one of
     *            {@link DialogInterface#BUTTON_POSITIVE},
     *            {@link DialogInterface#BUTTON_NEGATIVE}, or
     *            {@link DialogInterface#BUTTON_NEUTRAL}
     * @param text The text to display in positive button.
     * @param listener The {@link DialogInterface.OnClickListener} to use.
     */
    public void setButton(int whichButton, CharSequence text, OnClickListener listener) {
        mAlert.setButton(whichButton, text, listener, null);
    }

    
Deprecated:Use setButton(int, CharSequence, Message) with DialogInterface.BUTTON_POSITIVE.
/**
     * @deprecated Use {@link #setButton(int, CharSequence, Message)} with
     *             {@link DialogInterface#BUTTON_POSITIVE}.
     */
    @Deprecated
    public void setButton(CharSequence text, Message msg) {
        setButton(BUTTON_POSITIVE, text, msg);
    }

    
Deprecated:Use setButton(int, CharSequence, Message) with DialogInterface.BUTTON_NEGATIVE.
/**
     * @deprecated Use {@link #setButton(int, CharSequence, Message)} with
     *             {@link DialogInterface#BUTTON_NEGATIVE}.
     */
    @Deprecated
    public void setButton2(CharSequence text, Message msg) {
        setButton(BUTTON_NEGATIVE, text, msg);
    }

    
Deprecated:Use setButton(int, CharSequence, Message) with DialogInterface.BUTTON_NEUTRAL.
/**
     * @deprecated Use {@link #setButton(int, CharSequence, Message)} with
     *             {@link DialogInterface#BUTTON_NEUTRAL}.
     */
    @Deprecated
    public void setButton3(CharSequence text, Message msg) {
        setButton(BUTTON_NEUTRAL, text, msg);
    }

    
Set a listener to be invoked when button 1 of the dialog is pressed.

Params:
  • text – The text to display in button 1.
  • listener – The OnClickListener to use.
Deprecated:Use setButton(int, CharSequence, OnClickListener) with DialogInterface.BUTTON_POSITIVE
/**
     * Set a listener to be invoked when button 1 of the dialog is pressed.
     *
     * @param text The text to display in button 1.
     * @param listener The {@link DialogInterface.OnClickListener} to use.
     * @deprecated Use
     *             {@link #setButton(int, CharSequence, android.content.DialogInterface.OnClickListener)}
     *             with {@link DialogInterface#BUTTON_POSITIVE}
     */
    @Deprecated
    public void setButton(CharSequence text, final OnClickListener listener) {
        setButton(BUTTON_POSITIVE, text, listener);
    }

    
Set a listener to be invoked when button 2 of the dialog is pressed.

Params:
  • text – The text to display in button 2.
  • listener – The OnClickListener to use.
Deprecated:Use setButton(int, CharSequence, OnClickListener) with DialogInterface.BUTTON_NEGATIVE
/**
     * Set a listener to be invoked when button 2 of the dialog is pressed.
     * @param text The text to display in button 2.
     * @param listener The {@link DialogInterface.OnClickListener} to use.
     * @deprecated Use
     *             {@link #setButton(int, CharSequence, android.content.DialogInterface.OnClickListener)}
     *             with {@link DialogInterface#BUTTON_NEGATIVE}
     */
    @Deprecated
    public void setButton2(CharSequence text, final OnClickListener listener) {
        setButton(BUTTON_NEGATIVE, text, listener);
    }

    
Set a listener to be invoked when button 3 of the dialog is pressed.

Params:
  • text – The text to display in button 3.
  • listener – The OnClickListener to use.
Deprecated:Use setButton(int, CharSequence, OnClickListener) with DialogInterface.BUTTON_NEUTRAL
/**
     * Set a listener to be invoked when button 3 of the dialog is pressed.
     * @param text The text to display in button 3.
     * @param listener The {@link DialogInterface.OnClickListener} to use.
     * @deprecated Use
     *             {@link #setButton(int, CharSequence, android.content.DialogInterface.OnClickListener)}
     *             with {@link DialogInterface#BUTTON_NEUTRAL}
     */
    @Deprecated
    public void setButton3(CharSequence text, final OnClickListener listener) {
        setButton(BUTTON_NEUTRAL, text, listener);
    }

    
Set resId to 0 if you don't want an icon.

Params:
  • resId – the resourceId of the drawable to use as the icon or 0
if you don't want an icon.
/**
     * Set resId to 0 if you don't want an icon.
     * @param resId the resourceId of the drawable to use as the icon or 0
     * if you don't want an icon.
     */
    public void setIcon(@DrawableRes int resId) {
        mAlert.setIcon(resId);
    }

    public void setIcon(Drawable icon) {
        mAlert.setIcon(icon);
    }

    
Set an icon as supplied by a theme attribute. e.g. android.R.attr.alertDialogIcon

Params:
  • attrId – ID of a theme attribute that points to a drawable resource.
/**
     * Set an icon as supplied by a theme attribute. e.g. android.R.attr.alertDialogIcon
     *
     * @param attrId ID of a theme attribute that points to a drawable resource.
     */
    public void setIconAttribute(@AttrRes int attrId) {
        TypedValue out = new TypedValue();
        mContext.getTheme().resolveAttribute(attrId, out, true);
        mAlert.setIcon(out.resourceId);
    }

    public void setInverseBackgroundForced(boolean forceInverseBackground) {
        mAlert.setInverseBackgroundForced(forceInverseBackground);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mAlert.installContent();
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (mAlert.onKeyDown(keyCode, event)) return true;
        return super.onKeyDown(keyCode, event);
    }

    @Override
    public boolean onKeyUp(int keyCode, KeyEvent event) {
        if (mAlert.onKeyUp(keyCode, event)) return true;
        return super.onKeyUp(keyCode, event);
    }

    public static class Builder {
        private final AlertController.AlertParams P;

        
Creates a builder for an alert dialog that uses the default alert
dialog theme.

 The default alert dialog theme is defined by alertDialogTheme.alertDialogTheme within the parent context's theme. 
Params:
  • context – the parent context
/**
         * Creates a builder for an alert dialog that uses the default alert
         * dialog theme.
         * <p>
         * The default alert dialog theme is defined by
         * {@link android.R.attr#alertDialogTheme} within the parent
         * {@code context}'s theme.
         *
         * @param context the parent context
         */
        public Builder(Context context) {
            this(context, resolveDialogTheme(context, ResourceId.ID_NULL));
        }

        
Creates a builder for an alert dialog that uses an explicit theme
resource.

 The specified theme resource (themeResId) is applied on top of the parent context's theme. It may be specified as a style resource containing a fully-populated theme, such as Theme_Material_Dialog.Theme_Material_Dialog, to replace all attributes in the parent context's theme including primary and accent colors. 
 To preserve attributes such as primary and accent colors, the themeResId may instead be specified as an overlay theme such as ThemeOverlay_Material_Dialog.ThemeOverlay_Material_Dialog. This will override only the window attributes necessary to style the alert window as a dialog. 
 Alternatively, the themeResId may be specified as 0 to use the parent context's resolved value for alertDialogTheme.alertDialogTheme. 
Params:
  • context – the parent context
  • themeResId – the resource ID of the theme against which to inflate this dialog, or 0 to use the parent context's default alert dialog theme
/**
         * Creates a builder for an alert dialog that uses an explicit theme
         * resource.
         * <p>
         * The specified theme resource ({@code themeResId}) is applied on top
         * of the parent {@code context}'s theme. It may be specified as a
         * style resource containing a fully-populated theme, such as
         * {@link android.R.style#Theme_Material_Dialog}, to replace all
         * attributes in the parent {@code context}'s theme including primary
         * and accent colors.
         * <p>
         * To preserve attributes such as primary and accent colors, the
         * {@code themeResId} may instead be specified as an overlay theme such
         * as {@link android.R.style#ThemeOverlay_Material_Dialog}. This will
         * override only the window attributes necessary to style the alert
         * window as a dialog.
         * <p>
         * Alternatively, the {@code themeResId} may be specified as {@code 0}
         * to use the parent {@code context}'s resolved value for
         * {@link android.R.attr#alertDialogTheme}.
         *
         * @param context the parent context
         * @param themeResId the resource ID of the theme against which to inflate
         *                   this dialog, or {@code 0} to use the parent
         *                   {@code context}'s default alert dialog theme
         */
        public Builder(Context context, int themeResId) {
            P = new AlertController.AlertParams(new ContextThemeWrapper(
                    context, resolveDialogTheme(context, themeResId)));
        }

        
Returns a Context with the appropriate theme for dialogs created by this Builder. Applications should use this Context for obtaining LayoutInflaters for inflating views that will be used in the resulting dialogs, as it will cause views to be inflated with the correct theme. 
Returns:A Context for built Dialogs.
/**
         * Returns a {@link Context} with the appropriate theme for dialogs created by this Builder.
         * Applications should use this Context for obtaining LayoutInflaters for inflating views
         * that will be used in the resulting dialogs, as it will cause views to be inflated with
         * the correct theme.
         *
         * @return A Context for built Dialogs.
         */
        public Context getContext() {
            return P.mContext;
        }

        
Set the title using the given resource id.

Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set the title using the given resource id.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setTitle(@StringRes int titleId) {
            P.mTitle = P.mContext.getText(titleId);
            return this;
        }

        
Set the title displayed in the Dialog. 
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set the title displayed in the {@link Dialog}.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setTitle(CharSequence title) {
            P.mTitle = title;
            return this;
        }

        
Set the title using the custom view customTitleView. 
 The methods setTitle(int) and setIcon(int) should be sufficient for most titles, but this is provided if the title needs more customization. Using this will replace the title and icon set via the other methods. 

Note: To ensure consistent styling, the custom view should be inflated or constructed using the alert dialog's themed context obtained via getContext(). 
Params:
  • customTitleView – the custom view to use as the title
Returns:this Builder object to allow for chaining of calls to set
        methods
/**
         * Set the title using the custom view {@code customTitleView}.
         * <p>
         * The methods {@link #setTitle(int)} and {@link #setIcon(int)} should
         * be sufficient for most titles, but this is provided if the title
         * needs more customization. Using this will replace the title and icon
         * set via the other methods.
         * <p>
         * <strong>Note:</strong> To ensure consistent styling, the custom view
         * should be inflated or constructed using the alert dialog's themed
         * context obtained via {@link #getContext()}.
         *
         * @param customTitleView the custom view to use as the title
         * @return this Builder object to allow for chaining of calls to set
         *         methods
         */
        public Builder setCustomTitle(View customTitleView) {
            P.mCustomTitleView = customTitleView;
            return this;
        }

        
Set the message to display using the given resource id.

Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set the message to display using the given resource id.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setMessage(@StringRes int messageId) {
            P.mMessage = P.mContext.getText(messageId);
            return this;
        }

        
Set the message to display.

Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set the message to display.
          *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setMessage(CharSequence message) {
            P.mMessage = message;
            return this;
        }

        
Set the resource id of the Drawable to be used in the title. 
 Takes precedence over values set using setIcon(Drawable). 
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set the resource id of the {@link Drawable} to be used in the title.
         * <p>
         * Takes precedence over values set using {@link #setIcon(Drawable)}.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setIcon(@DrawableRes int iconId) {
            P.mIconId = iconId;
            return this;
        }

        
Set the Drawable to be used in the title. 

Note: To ensure consistent styling, the drawable should be inflated or constructed using the alert dialog's themed context obtained via getContext(). 
Returns:this Builder object to allow for chaining of calls to set
        methods
/**
         * Set the {@link Drawable} to be used in the title.
         * <p>
         * <strong>Note:</strong> To ensure consistent styling, the drawable
         * should be inflated or constructed using the alert dialog's themed
         * context obtained via {@link #getContext()}.
         *
         * @return this Builder object to allow for chaining of calls to set
         *         methods
         */
        public Builder setIcon(Drawable icon) {
            P.mIcon = icon;
            return this;
        }

        
Set an icon as supplied by a theme attribute. e.g. alertDialogIcon.alertDialogIcon. 
 Takes precedence over values set using setIcon(int) or setIcon(Drawable). 
Params:
  • attrId – ID of a theme attribute that points to a drawable resource.
/**
         * Set an icon as supplied by a theme attribute. e.g.
         * {@link android.R.attr#alertDialogIcon}.
         * <p>
         * Takes precedence over values set using {@link #setIcon(int)} or
         * {@link #setIcon(Drawable)}.
         *
         * @param attrId ID of a theme attribute that points to a drawable resource.
         */
        public Builder setIconAttribute(@AttrRes int attrId) {
            TypedValue out = new TypedValue();
            P.mContext.getTheme().resolveAttribute(attrId, out, true);
            P.mIconId = out.resourceId;
            return this;
        }

        
Set a listener to be invoked when the positive button of the dialog is pressed.

Params:
  • textId – The resource id of the text to display in the positive button
  • listener – The OnClickListener to use.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a listener to be invoked when the positive button of the dialog is pressed.
         * @param textId The resource id of the text to display in the positive button
         * @param listener The {@link DialogInterface.OnClickListener} to use.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setPositiveButton(@StringRes int textId, final OnClickListener listener) {
            P.mPositiveButtonText = P.mContext.getText(textId);
            P.mPositiveButtonListener = listener;
            return this;
        }

        
Set a listener to be invoked when the positive button of the dialog is pressed.

Params:
  • text – The text to display in the positive button
  • listener – The OnClickListener to use.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a listener to be invoked when the positive button of the dialog is pressed.
         * @param text The text to display in the positive button
         * @param listener The {@link DialogInterface.OnClickListener} to use.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setPositiveButton(CharSequence text, final OnClickListener listener) {
            P.mPositiveButtonText = text;
            P.mPositiveButtonListener = listener;
            return this;
        }

        
Set a listener to be invoked when the negative button of the dialog is pressed.

Params:
  • textId – The resource id of the text to display in the negative button
  • listener – The OnClickListener to use.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a listener to be invoked when the negative button of the dialog is pressed.
         * @param textId The resource id of the text to display in the negative button
         * @param listener The {@link DialogInterface.OnClickListener} to use.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setNegativeButton(@StringRes int textId, final OnClickListener listener) {
            P.mNegativeButtonText = P.mContext.getText(textId);
            P.mNegativeButtonListener = listener;
            return this;
        }

        
Set a listener to be invoked when the negative button of the dialog is pressed.

Params:
  • text – The text to display in the negative button
  • listener – The OnClickListener to use.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a listener to be invoked when the negative button of the dialog is pressed.
         * @param text The text to display in the negative button
         * @param listener The {@link DialogInterface.OnClickListener} to use.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setNegativeButton(CharSequence text, final OnClickListener listener) {
            P.mNegativeButtonText = text;
            P.mNegativeButtonListener = listener;
            return this;
        }

        
Set a listener to be invoked when the neutral button of the dialog is pressed.

Params:
  • textId – The resource id of the text to display in the neutral button
  • listener – The OnClickListener to use.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a listener to be invoked when the neutral button of the dialog is pressed.
         * @param textId The resource id of the text to display in the neutral button
         * @param listener The {@link DialogInterface.OnClickListener} to use.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setNeutralButton(@StringRes int textId, final OnClickListener listener) {
            P.mNeutralButtonText = P.mContext.getText(textId);
            P.mNeutralButtonListener = listener;
            return this;
        }

        
Set a listener to be invoked when the neutral button of the dialog is pressed.

Params:
  • text – The text to display in the neutral button
  • listener – The OnClickListener to use.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a listener to be invoked when the neutral button of the dialog is pressed.
         * @param text The text to display in the neutral button
         * @param listener The {@link DialogInterface.OnClickListener} to use.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setNeutralButton(CharSequence text, final OnClickListener listener) {
            P.mNeutralButtonText = text;
            P.mNeutralButtonListener = listener;
            return this;
        }

        
Sets whether the dialog is cancelable or not.  Default is true.

Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Sets whether the dialog is cancelable or not.  Default is true.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setCancelable(boolean cancelable) {
            P.mCancelable = cancelable;
            return this;
        }

        
Sets the callback that will be called if the dialog is canceled.

Even in a cancelable dialog, the dialog may be dismissed for reasons other than being canceled or one of the supplied choices being selected. If you are interested in listening for all cases where the dialog is dismissed and not just when it is canceled, see setOnDismissListener.


See Also:
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Sets the callback that will be called if the dialog is canceled.
         *
         * <p>Even in a cancelable dialog, the dialog may be dismissed for reasons other than
         * being canceled or one of the supplied choices being selected.
         * If you are interested in listening for all cases where the dialog is dismissed
         * and not just when it is canceled, see
         * {@link #setOnDismissListener(android.content.DialogInterface.OnDismissListener) setOnDismissListener}.</p>
         * @see #setCancelable(boolean)
         * @see #setOnDismissListener(android.content.DialogInterface.OnDismissListener)
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setOnCancelListener(OnCancelListener onCancelListener) {
            P.mOnCancelListener = onCancelListener;
            return this;
        }

        
Sets the callback that will be called when the dialog is dismissed for any reason.

Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Sets the callback that will be called when the dialog is dismissed for any reason.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setOnDismissListener(OnDismissListener onDismissListener) {
            P.mOnDismissListener = onDismissListener;
            return this;
        }

        
Sets the callback that will be called if a key is dispatched to the dialog.

Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Sets the callback that will be called if a key is dispatched to the dialog.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setOnKeyListener(OnKeyListener onKeyListener) {
            P.mOnKeyListener = onKeyListener;
            return this;
        }

        
Set a list of items to be displayed in the dialog as the content, you will be notified of the
selected item via the supplied listener. This should be an array type i.e. R.array.foo

Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a list of items to be displayed in the dialog as the content, you will be notified of the
         * selected item via the supplied listener. This should be an array type i.e. R.array.foo
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setItems(@ArrayRes int itemsId, final OnClickListener listener) {
            P.mItems = P.mContext.getResources().getTextArray(itemsId);
            P.mOnClickListener = listener;
            return this;
        }

        
Set a list of items to be displayed in the dialog as the content, you will be notified of the
selected item via the supplied listener.

Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a list of items to be displayed in the dialog as the content, you will be notified of the
         * selected item via the supplied listener.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setItems(CharSequence[] items, final OnClickListener listener) {
            P.mItems = items;
            P.mOnClickListener = listener;
            return this;
        }

        
Set a list of items, which are supplied by the given ListAdapter, to be displayed in the dialog as the content, you will be notified of the selected item via the supplied listener. 
Params:
  • adapter – The ListAdapter to supply the list of items
  • listener – The listener that will be called when an item is clicked.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a list of items, which are supplied by the given {@link ListAdapter}, to be
         * displayed in the dialog as the content, you will be notified of the
         * selected item via the supplied listener.
         *
         * @param adapter The {@link ListAdapter} to supply the list of items
         * @param listener The listener that will be called when an item is clicked.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setAdapter(final ListAdapter adapter, final OnClickListener listener) {
            P.mAdapter = adapter;
            P.mOnClickListener = listener;
            return this;
        }

        
Set a list of items, which are supplied by the given Cursor, to be displayed in the dialog as the content, you will be notified of the selected item via the supplied listener. 
Params:
  • cursor – The Cursor to supply the list of items
  • listener – The listener that will be called when an item is clicked.
  • labelColumn – The column name on the cursor containing the string to display
         in the label.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a list of items, which are supplied by the given {@link Cursor}, to be
         * displayed in the dialog as the content, you will be notified of the
         * selected item via the supplied listener.
         *
         * @param cursor The {@link Cursor} to supply the list of items
         * @param listener The listener that will be called when an item is clicked.
         * @param labelColumn The column name on the cursor containing the string to display
         *          in the label.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setCursor(final Cursor cursor, final OnClickListener listener,
                String labelColumn) {
            P.mCursor = cursor;
            P.mLabelColumn = labelColumn;
            P.mOnClickListener = listener;
            return this;
        }

        
Set a list of items to be displayed in the dialog as the content,
you will be notified of the selected item via the supplied listener.
This should be an array type, e.g. R.array.foo. The list will have
a check mark displayed to the right of the text for each checked
item. Clicking on an item in the list will not dismiss the dialog.
Clicking on a button will dismiss the dialog.

Params:
  • itemsId – the resource id of an array i.e. R.array.foo
  • checkedItems – specifies which items are checked. It should be null in which case no
       items are checked. If non null it must be exactly the same length as the array of
       items.
  • listener – notified when an item on the list is clicked. The dialog will not be
       dismissed when an item is clicked. It will only be dismissed if clicked on a
       button, if no buttons are supplied it's up to the user to dismiss the dialog.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a list of items to be displayed in the dialog as the content,
         * you will be notified of the selected item via the supplied listener.
         * This should be an array type, e.g. R.array.foo. The list will have
         * a check mark displayed to the right of the text for each checked
         * item. Clicking on an item in the list will not dismiss the dialog.
         * Clicking on a button will dismiss the dialog.
         *
         * @param itemsId the resource id of an array i.e. R.array.foo
         * @param checkedItems specifies which items are checked. It should be null in which case no
         *        items are checked. If non null it must be exactly the same length as the array of
         *        items.
         * @param listener notified when an item on the list is clicked. The dialog will not be
         *        dismissed when an item is clicked. It will only be dismissed if clicked on a
         *        button, if no buttons are supplied it's up to the user to dismiss the dialog.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setMultiChoiceItems(@ArrayRes int itemsId, boolean[] checkedItems,
                final OnMultiChoiceClickListener listener) {
            P.mItems = P.mContext.getResources().getTextArray(itemsId);
            P.mOnCheckboxClickListener = listener;
            P.mCheckedItems = checkedItems;
            P.mIsMultiChoice = true;
            return this;
        }

        
Set a list of items to be displayed in the dialog as the content,
you will be notified of the selected item via the supplied listener.
The list will have a check mark displayed to the right of the text
for each checked item. Clicking on an item in the list will not
dismiss the dialog. Clicking on a button will dismiss the dialog.

Params:
  • items – the text of the items to be displayed in the list.
  • checkedItems – specifies which items are checked. It should be null in which case no
       items are checked. If non null it must be exactly the same length as the array of
       items.
  • listener – notified when an item on the list is clicked. The dialog will not be
       dismissed when an item is clicked. It will only be dismissed if clicked on a
       button, if no buttons are supplied it's up to the user to dismiss the dialog.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a list of items to be displayed in the dialog as the content,
         * you will be notified of the selected item via the supplied listener.
         * The list will have a check mark displayed to the right of the text
         * for each checked item. Clicking on an item in the list will not
         * dismiss the dialog. Clicking on a button will dismiss the dialog.
         *
         * @param items the text of the items to be displayed in the list.
         * @param checkedItems specifies which items are checked. It should be null in which case no
         *        items are checked. If non null it must be exactly the same length as the array of
         *        items.
         * @param listener notified when an item on the list is clicked. The dialog will not be
         *        dismissed when an item is clicked. It will only be dismissed if clicked on a
         *        button, if no buttons are supplied it's up to the user to dismiss the dialog.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setMultiChoiceItems(CharSequence[] items, boolean[] checkedItems,
                final OnMultiChoiceClickListener listener) {
            P.mItems = items;
            P.mOnCheckboxClickListener = listener;
            P.mCheckedItems = checkedItems;
            P.mIsMultiChoice = true;
            return this;
        }

        
Set a list of items to be displayed in the dialog as the content,
you will be notified of the selected item via the supplied listener.
The list will have a check mark displayed to the right of the text
for each checked item. Clicking on an item in the list will not
dismiss the dialog. Clicking on a button will dismiss the dialog.

Params:
  • cursor – the cursor used to provide the items.
  • isCheckedColumn – specifies the column name on the cursor to use to determine
       whether a checkbox is checked or not. It must return an integer value where 1
       means checked and 0 means unchecked.
  • labelColumn – The column name on the cursor containing the string to display in the
       label.
  • listener – notified when an item on the list is clicked. The dialog will not be
       dismissed when an item is clicked. It will only be dismissed if clicked on a
       button, if no buttons are supplied it's up to the user to dismiss the dialog.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a list of items to be displayed in the dialog as the content,
         * you will be notified of the selected item via the supplied listener.
         * The list will have a check mark displayed to the right of the text
         * for each checked item. Clicking on an item in the list will not
         * dismiss the dialog. Clicking on a button will dismiss the dialog.
         *
         * @param cursor the cursor used to provide the items.
         * @param isCheckedColumn specifies the column name on the cursor to use to determine
         *        whether a checkbox is checked or not. It must return an integer value where 1
         *        means checked and 0 means unchecked.
         * @param labelColumn The column name on the cursor containing the string to display in the
         *        label.
         * @param listener notified when an item on the list is clicked. The dialog will not be
         *        dismissed when an item is clicked. It will only be dismissed if clicked on a
         *        button, if no buttons are supplied it's up to the user to dismiss the dialog.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setMultiChoiceItems(Cursor cursor, String isCheckedColumn, String labelColumn,
                final OnMultiChoiceClickListener listener) {
            P.mCursor = cursor;
            P.mOnCheckboxClickListener = listener;
            P.mIsCheckedColumn = isCheckedColumn;
            P.mLabelColumn = labelColumn;
            P.mIsMultiChoice = true;
            return this;
        }

        
Set a list of items to be displayed in the dialog as the content, you will be notified of
the selected item via the supplied listener. This should be an array type i.e.
R.array.foo The list will have a check mark displayed to the right of the text for the
checked item. Clicking on an item in the list will not dismiss the dialog. Clicking on a
button will dismiss the dialog.

Params:
  • itemsId – the resource id of an array i.e. R.array.foo
  • checkedItem – specifies which item is checked. If -1 no items are checked.
  • listener – notified when an item on the list is clicked. The dialog will not be
       dismissed when an item is clicked. It will only be dismissed if clicked on a
       button, if no buttons are supplied it's up to the user to dismiss the dialog.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a list of items to be displayed in the dialog as the content, you will be notified of
         * the selected item via the supplied listener. This should be an array type i.e.
         * R.array.foo The list will have a check mark displayed to the right of the text for the
         * checked item. Clicking on an item in the list will not dismiss the dialog. Clicking on a
         * button will dismiss the dialog.
         *
         * @param itemsId the resource id of an array i.e. R.array.foo
         * @param checkedItem specifies which item is checked. If -1 no items are checked.
         * @param listener notified when an item on the list is clicked. The dialog will not be
         *        dismissed when an item is clicked. It will only be dismissed if clicked on a
         *        button, if no buttons are supplied it's up to the user to dismiss the dialog.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setSingleChoiceItems(@ArrayRes int itemsId, int checkedItem,
                final OnClickListener listener) {
            P.mItems = P.mContext.getResources().getTextArray(itemsId);
            P.mOnClickListener = listener;
            P.mCheckedItem = checkedItem;
            P.mIsSingleChoice = true;
            return this;
        }

        
Set a list of items to be displayed in the dialog as the content, you will be notified of
the selected item via the supplied listener. The list will have a check mark displayed to
the right of the text for the checked item. Clicking on an item in the list will not
dismiss the dialog. Clicking on a button will dismiss the dialog.

Params:
  • cursor – the cursor to retrieve the items from.
  • checkedItem – specifies which item is checked. If -1 no items are checked.
  • labelColumn – The column name on the cursor containing the string to display in the
       label.
  • listener – notified when an item on the list is clicked. The dialog will not be
       dismissed when an item is clicked. It will only be dismissed if clicked on a
       button, if no buttons are supplied it's up to the user to dismiss the dialog.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a list of items to be displayed in the dialog as the content, you will be notified of
         * the selected item via the supplied listener. The list will have a check mark displayed to
         * the right of the text for the checked item. Clicking on an item in the list will not
         * dismiss the dialog. Clicking on a button will dismiss the dialog.
         *
         * @param cursor the cursor to retrieve the items from.
         * @param checkedItem specifies which item is checked. If -1 no items are checked.
         * @param labelColumn The column name on the cursor containing the string to display in the
         *        label.
         * @param listener notified when an item on the list is clicked. The dialog will not be
         *        dismissed when an item is clicked. It will only be dismissed if clicked on a
         *        button, if no buttons are supplied it's up to the user to dismiss the dialog.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setSingleChoiceItems(Cursor cursor, int checkedItem, String labelColumn,
                final OnClickListener listener) {
            P.mCursor = cursor;
            P.mOnClickListener = listener;
            P.mCheckedItem = checkedItem;
            P.mLabelColumn = labelColumn;
            P.mIsSingleChoice = true;
            return this;
        }

        
Set a list of items to be displayed in the dialog as the content, you will be notified of
the selected item via the supplied listener. The list will have a check mark displayed to
the right of the text for the checked item. Clicking on an item in the list will not
dismiss the dialog. Clicking on a button will dismiss the dialog.

Params:
  • items – the items to be displayed.
  • checkedItem – specifies which item is checked. If -1 no items are checked.
  • listener – notified when an item on the list is clicked. The dialog will not be
       dismissed when an item is clicked. It will only be dismissed if clicked on a
       button, if no buttons are supplied it's up to the user to dismiss the dialog.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a list of items to be displayed in the dialog as the content, you will be notified of
         * the selected item via the supplied listener. The list will have a check mark displayed to
         * the right of the text for the checked item. Clicking on an item in the list will not
         * dismiss the dialog. Clicking on a button will dismiss the dialog.
         *
         * @param items the items to be displayed.
         * @param checkedItem specifies which item is checked. If -1 no items are checked.
         * @param listener notified when an item on the list is clicked. The dialog will not be
         *        dismissed when an item is clicked. It will only be dismissed if clicked on a
         *        button, if no buttons are supplied it's up to the user to dismiss the dialog.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setSingleChoiceItems(CharSequence[] items, int checkedItem, final OnClickListener listener) {
            P.mItems = items;
            P.mOnClickListener = listener;
            P.mCheckedItem = checkedItem;
            P.mIsSingleChoice = true;
            return this;
        }

        
Set a list of items to be displayed in the dialog as the content, you will be notified of
the selected item via the supplied listener. The list will have a check mark displayed to
the right of the text for the checked item. Clicking on an item in the list will not
dismiss the dialog. Clicking on a button will dismiss the dialog.

Params:
  • adapter – The ListAdapter to supply the list of items
  • checkedItem – specifies which item is checked. If -1 no items are checked.
  • listener – notified when an item on the list is clicked. The dialog will not be
       dismissed when an item is clicked. It will only be dismissed if clicked on a
       button, if no buttons are supplied it's up to the user to dismiss the dialog.
Returns:This Builder object to allow for chaining of calls to set methods
/**
         * Set a list of items to be displayed in the dialog as the content, you will be notified of
         * the selected item via the supplied listener. The list will have a check mark displayed to
         * the right of the text for the checked item. Clicking on an item in the list will not
         * dismiss the dialog. Clicking on a button will dismiss the dialog.
         *
         * @param adapter The {@link ListAdapter} to supply the list of items
         * @param checkedItem specifies which item is checked. If -1 no items are checked.
         * @param listener notified when an item on the list is clicked. The dialog will not be
         *        dismissed when an item is clicked. It will only be dismissed if clicked on a
         *        button, if no buttons are supplied it's up to the user to dismiss the dialog.
         *
         * @return This Builder object to allow for chaining of calls to set methods
         */
        public Builder setSingleChoiceItems(ListAdapter adapter, int checkedItem, final OnClickListener listener) {
            P.mAdapter = adapter;
            P.mOnClickListener = listener;
            P.mCheckedItem = checkedItem;
            P.mIsSingleChoice = true;
            return this;
        }

        
Sets a listener to be invoked when an item in the list is selected.

Params:
  • listener – the listener to be invoked
See Also:
Returns:this Builder object to allow for chaining of calls to set methods
/**
         * Sets a listener to be invoked when an item in the list is selected.
         *
         * @param listener the listener to be invoked
         * @return this Builder object to allow for chaining of calls to set methods
         * @see AdapterView#setOnItemSelectedListener(android.widget.AdapterView.OnItemSelectedListener)
         */
        public Builder setOnItemSelectedListener(final AdapterView.OnItemSelectedListener listener) {
            P.mOnItemSelectedListener = listener;
            return this;
        }

        
Set a custom view resource to be the contents of the Dialog. The
resource will be inflated, adding all top-level views to the screen.

Params:
  • layoutResId – Resource ID to be inflated.
Returns:this Builder object to allow for chaining of calls to set
        methods
/**
         * Set a custom view resource to be the contents of the Dialog. The
         * resource will be inflated, adding all top-level views to the screen.
         *
         * @param layoutResId Resource ID to be inflated.
         * @return this Builder object to allow for chaining of calls to set
         *         methods
         */
        public Builder setView(int layoutResId) {
            P.mView = null;
            P.mViewLayoutResId = layoutResId;
            P.mViewSpacingSpecified = false;
            return this;
        }

        
Sets a custom view to be the contents of the alert dialog.

 When using a pre-Holo theme, if the supplied view is an instance of a ListView then the light background will be used. 

Note: To ensure consistent styling, the custom view should be inflated or constructed using the alert dialog's themed context obtained via getContext(). 
Params:
  • view – the view to use as the contents of the alert dialog
Returns:this Builder object to allow for chaining of calls to set
        methods
/**
         * Sets a custom view to be the contents of the alert dialog.
         * <p>
         * When using a pre-Holo theme, if the supplied view is an instance of
         * a {@link ListView} then the light background will be used.
         * <p>
         * <strong>Note:</strong> To ensure consistent styling, the custom view
         * should be inflated or constructed using the alert dialog's themed
         * context obtained via {@link #getContext()}.
         *
         * @param view the view to use as the contents of the alert dialog
         * @return this Builder object to allow for chaining of calls to set
         *         methods
         */
        public Builder setView(View view) {
            P.mView = view;
            P.mViewLayoutResId = 0;
            P.mViewSpacingSpecified = false;
            return this;
        }

        
Sets a custom view to be the contents of the alert dialog and
specifies additional padding around that view.

 When using a pre-Holo theme, if the supplied view is an instance of a ListView then the light background will be used. 

Note: To ensure consistent styling, the custom view should be inflated or constructed using the alert dialog's themed context obtained via getContext(). 
Params:
  • view – the view to use as the contents of the alert dialog
  • viewSpacingLeft – spacing between the left edge of the view and
                       the dialog frame
  • viewSpacingTop – spacing between the top edge of the view and
                      the dialog frame
  • viewSpacingRight – spacing between the right edge of the view
                        and the dialog frame
  • viewSpacingBottom – spacing between the bottom edge of the view
                         and the dialog frame
Returns:this Builder object to allow for chaining of calls to set
        methods
@hideRemove once the framework usages have been replaced.
Deprecated:Set the padding on the view itself.
/**
         * Sets a custom view to be the contents of the alert dialog and
         * specifies additional padding around that view.
         * <p>
         * When using a pre-Holo theme, if the supplied view is an instance of
         * a {@link ListView} then the light background will be used.
         * <p>
         * <strong>Note:</strong> To ensure consistent styling, the custom view
         * should be inflated or constructed using the alert dialog's themed
         * context obtained via {@link #getContext()}.
         *
         * @param view the view to use as the contents of the alert dialog
         * @param viewSpacingLeft spacing between the left edge of the view and
         *                        the dialog frame
         * @param viewSpacingTop spacing between the top edge of the view and
         *                       the dialog frame
         * @param viewSpacingRight spacing between the right edge of the view
         *                         and the dialog frame
         * @param viewSpacingBottom spacing between the bottom edge of the view
         *                          and the dialog frame
         * @return this Builder object to allow for chaining of calls to set
         *         methods
         *
         * @hide Remove once the framework usages have been replaced.
         * @deprecated Set the padding on the view itself.
         */
        @Deprecated
        public Builder setView(View view, int viewSpacingLeft, int viewSpacingTop,
                int viewSpacingRight, int viewSpacingBottom) {
            P.mView = view;
            P.mViewLayoutResId = 0;
            P.mViewSpacingSpecified = true;
            P.mViewSpacingLeft = viewSpacingLeft;
            P.mViewSpacingTop = viewSpacingTop;
            P.mViewSpacingRight = viewSpacingRight;
            P.mViewSpacingBottom = viewSpacingBottom;
            return this;
        }

        
Sets the alert dialog to use the inverse background, regardless of
what the contents is.

Params:
  • useInverseBackground – whether to use the inverse background
Returns:this Builder object to allow for chaining of calls to set methods
Deprecated:This flag is only used for pre-Material themes. Instead,
            specify the window background using on the alert dialog
            theme.
/**
         * Sets the alert dialog to use the inverse background, regardless of
         * what the contents is.
         *
         * @param useInverseBackground whether to use the inverse background
         * @return this Builder object to allow for chaining of calls to set methods
         * @deprecated This flag is only used for pre-Material themes. Instead,
         *             specify the window background using on the alert dialog
         *             theme.
         */
        @Deprecated
        public Builder setInverseBackgroundForced(boolean useInverseBackground) {
            P.mForceInverseBackground = useInverseBackground;
            return this;
        }

        
@hide
/**
         * @hide
         */
        public Builder setRecycleOnMeasureEnabled(boolean enabled) {
            P.mRecycleOnMeasure = enabled;
            return this;
        }


        
Creates an AlertDialog with the arguments supplied to this builder. 
 Calling this method does not display the dialog. If no additional processing is needed, show() may be called instead to both create and display the dialog. 
/**
         * Creates an {@link AlertDialog} with the arguments supplied to this
         * builder.
         * <p>
         * Calling this method does not display the dialog. If no additional
         * processing is needed, {@link #show()} may be called instead to both
         * create and display the dialog.
         */
        public AlertDialog create() {
            // Context has already been wrapped with the appropriate theme.
            final AlertDialog dialog = new AlertDialog(P.mContext, 0, false);
            P.apply(dialog.mAlert);
            dialog.setCancelable(P.mCancelable);
            if (P.mCancelable) {
                dialog.setCanceledOnTouchOutside(true);
            }
            dialog.setOnCancelListener(P.mOnCancelListener);
            dialog.setOnDismissListener(P.mOnDismissListener);
            if (P.mOnKeyListener != null) {
                dialog.setOnKeyListener(P.mOnKeyListener);
            }
            return dialog;
        }

        
Creates an AlertDialog with the arguments supplied to this builder and immediately displays the dialog. 

Calling this method is functionally identical to:

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



/**
         * Creates an {@link AlertDialog} with the arguments supplied to this
         * builder and immediately displays the dialog.
         * <p>
         * Calling this method is functionally identical to:
         * <pre>
         *     AlertDialog dialog = builder.create();
         *     dialog.show();
         * </pre>
         */
        public AlertDialog show() {
            final AlertDialog dialog = create();
            dialog.show();
            return dialog;
        }
    }

}