content: /*
   * 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.annotation.UnsupportedAppUsage;
  import android.content.Context;
  import android.content.DialogInterface;
  import android.content.res.ResourceId;
  import android.content.res.Resources;
  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:
   *
   * <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 {
      @UnsupportedAppUsage
      private AlertController mAlert;
  
      /**
       * 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 {@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 {@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 {@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 {@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
       */
      public static final int LAYOUT_HINT_NONE = 0;
  
      /**
       * 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.
       * <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.
       * <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.
       * <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 {@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.
       *
       * @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 Builder#setCustomTitle(View)
       */
      public void setCustomTitle(View customTitleView) {
          mAlert.setCustomTitle(customTitleView);
      }
  
      public void setMessage(CharSequence message) {
          mAlert.setMessage(message);
      }
  
      /** @hide */
      public void setMessageMovementMethod(MovementMethod movementMethod) {
          mAlert.setMessageMovementMethod(movementMethod);
      }
  
      /** @hide */
      public void setMessageHyphenationFrequency(
              @Layout.HyphenationFrequency int hyphenationFrequency) {
          mAlert.setMessageHyphenationFrequency(hyphenationFrequency);
      }
  
      /**
       * 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.
       *
       * @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
       */
      void setButtonPanelLayoutHint(int layoutHint) {
          mAlert.setButtonPanelLayoutHint(layoutHint);
      }
  
      /**
       * 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.
       *
       * @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 {@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 {@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 {@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.
       *
       * @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.
       * @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.
       * @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.
       * @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
       *
       * @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 {
          @UnsupportedAppUsage
          private final AlertController.AlertParams P;
  
          /**
           * 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, Resources.ID_NULL));
          }
  
          /**
           * 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 {@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.
           *
           * @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 {@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 {@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.
           *
           * @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.
            *
           * @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 {@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 {@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.
           * {@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.
           * @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.
           * @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.
           * @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.
           * @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.
           * @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.
           * @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.
           *
           * @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.
           *
           * <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.
           *
           * @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.
           *
           * @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
           *
           * @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.
           *
           * @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 {@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 {@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.
           *
           * @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.
           *
           * @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.
           *
           * @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.
           *
           * @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.
           *
           * @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.
           *
           * @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.
           *
           * @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.
           *
           * @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.
           *
           * @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.
           * <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.
           * <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
          @UnsupportedAppUsage
          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.
           *
           * @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
           */
          @UnsupportedAppUsage
          public Builder setRecycleOnMeasureEnabled(boolean enabled) {
              P.mRecycleOnMeasure = enabled;
              return this;
          }
  
  
          /**
           * 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 {@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;
          }
      }
  
  }
  