android-12.0.0_r34/s

/*
 * Copyright (C) 2019 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 com.android.car.ui;

import static android.view.WindowInsets.Type.ime;

import static com.android.car.ui.imewidescreen.CarUiImeWideScreenController.ADD_DESC_TITLE_TO_CONTENT_AREA;
import static com.android.car.ui.imewidescreen.CarUiImeWideScreenController.ADD_DESC_TO_CONTENT_AREA;
import static com.android.car.ui.imewidescreen.CarUiImeWideScreenController.WIDE_SCREEN_ACTION;

import android.app.AlertDialog;
import android.app.Dialog;
import android.content.Context;
import android.content.DialogInterface;
import android.database.Cursor;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.os.Bundle;
import android.text.Editable;
import android.text.InputFilter;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.text.method.LinkMovementMethod;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.inputmethod.InputMethodManager;
import android.widget.AdapterView;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.ListAdapter;
import android.widget.TextView;

import androidx.annotation.ArrayRes;
import androidx.annotation.AttrRes;
import androidx.annotation.DrawableRes;
import androidx.annotation.NonNull;
import androidx.annotation.StringRes;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;

import com.android.car.ui.recyclerview.CarUiListItemAdapter;
import com.android.car.ui.recyclerview.CarUiRadioButtonListItemAdapter;
import com.android.car.ui.utils.CarUiUtils;

/**
 * Wrapper for AlertDialog.Builder
 */
public class AlertDialogBuilder {

    private AlertDialog.Builder mBuilder;
    private Context mContext;
    private boolean mPositiveButtonSet;
    private boolean mNeutralButtonSet;
    private boolean mNegativeButtonSet;
    private CharSequence mTitle;
    private CharSequence mSubtitle;
    private Drawable mIcon;
    private boolean mIconTinted;
    private EditText mCarUiEditText;
    private InputMethodManager mInputMethodManager;
    private String mWideScreenTitle;
    private String mWideScreenTitleDesc;
    private ViewGroup mRoot;
    private boolean mAllowDismissButton = true;
    private boolean mHasSingleChoiceBodyButton = false;

    private final TextWatcher mTextWatcherWideScreen = new TextWatcher() {
        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {

        }

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {
            Bundle bundle = new Bundle();
            String titleString = mWideScreenTitle != null ? mWideScreenTitle : mTitle.toString();
            bundle.putString(ADD_DESC_TITLE_TO_CONTENT_AREA, titleString);
            bundle.putString(ADD_DESC_TO_CONTENT_AREA, s.toString());
            mInputMethodManager.sendAppPrivateCommand(mCarUiEditText, WIDE_SCREEN_ACTION,
                    bundle);
        }

        @Override
        public void afterTextChanged(Editable s) {

        }
    };

    // Whenever the IME is closed and opened again, the title and desc information needs to be
    // passed to the IME to be rendered. If the information is not passed to the IME the content
    // area of the IME will render nothing into the content area.
    private final View.OnApplyWindowInsetsListener mOnApplyWindowInsetsListener = (v, insets) -> {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
            // WindowInsets.isVisible() is only available on R or above
            return v.onApplyWindowInsets(insets);
        }

        if (insets.isVisible(ime())) {
            Bundle bundle = new Bundle();
            String title = mWideScreenTitle != null ? mWideScreenTitle : mTitle.toString();
            bundle.putString(ADD_DESC_TITLE_TO_CONTENT_AREA, title);
            if (mWideScreenTitleDesc != null) {
                bundle.putString(ADD_DESC_TO_CONTENT_AREA, mWideScreenTitleDesc);
            }
            mInputMethodManager.sendAppPrivateCommand(mCarUiEditText, WIDE_SCREEN_ACTION,
                    bundle);
        }
        return v.onApplyWindowInsets(insets);
    };

    private final AlertDialog.OnDismissListener mOnDismissListener = dialog -> {
        if (mRoot != null) {
            mRoot.setOnApplyWindowInsetsListener(null);
        }
    };

    public AlertDialogBuilder(Context context) {
        // Resource id specified as 0 uses the parent contexts resolved value for alertDialogTheme.
        this(context, /* themeResId= */0);
    }

    public AlertDialogBuilder(Context context, int themeResId) {
        mBuilder = new AlertDialog.Builder(context, themeResId);
        mInputMethodManager = (InputMethodManager)
                context.getSystemService(Context.INPUT_METHOD_SERVICE);
        mContext = context;
    }

    public Context getContext() {
        return mBuilder.getContext();
    }

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

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

    /**
     * Sets a subtitle to be displayed in the {@link Dialog}.
     *
     * @return This Builder object to allow for chaining of calls to set methods
     */
    public AlertDialogBuilder setSubtitle(@StringRes int subtitle) {
        return setSubtitle(mContext.getString(subtitle));
    }

    /**
     * Sets a subtitle to be displayed in the {@link Dialog}.
     *
     * @return This Builder object to allow for chaining of calls to set methods
     */
    public AlertDialogBuilder setSubtitle(CharSequence subtitle) {
        mSubtitle = subtitle;
        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 AlertDialogBuilder setMessage(@StringRes int messageId) {
        mBuilder.setMessage(messageId);
        return this;
    }

    /**
     * Set the message to display.
     *
     * @return This Builder object to allow for chaining of calls to set methods
     */
    public AlertDialogBuilder setMessage(CharSequence message) {
        mBuilder.setMessage(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 AlertDialogBuilder setIcon(@DrawableRes int iconId) {
        return setIcon(mContext.getDrawable(iconId));
    }

    /**
     * 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 AlertDialogBuilder setIcon(Drawable icon) {
        mIcon = icon;
        return this;
    }

    /**
     * Whether the icon provided by {@link #setIcon(Drawable)} should be
     * tinted with the default system color.
     *
     * @return this Builder object to allow for chaining of calls to set
     * methods.
     */
    public AlertDialogBuilder setIconTinted(boolean tinted) {
        mIconTinted = tinted;
        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(Drawable)}.
     *
     * @param attrId ID of a theme attribute that points to a drawable resource.
     */
    public AlertDialogBuilder setIconAttribute(@AttrRes int attrId) {
        mBuilder.setIconAttribute(attrId);
        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 AlertDialogBuilder setPositiveButton(@StringRes int textId,
            final DialogInterface.OnClickListener listener) {
        mBuilder.setPositiveButton(textId, listener);
        mPositiveButtonSet = true;
        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 AlertDialogBuilder setPositiveButton(CharSequence text,
            final DialogInterface.OnClickListener listener) {
        mBuilder.setPositiveButton(text, listener);
        mPositiveButtonSet = true;
        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 AlertDialogBuilder setNegativeButton(@StringRes int textId,
            final DialogInterface.OnClickListener listener) {
        mBuilder.setNegativeButton(textId, listener);
        mNegativeButtonSet = true;
        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 AlertDialogBuilder setNegativeButton(CharSequence text,
            final DialogInterface.OnClickListener listener) {
        mBuilder.setNegativeButton(text, listener);
        mNegativeButtonSet = true;
        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 AlertDialogBuilder setNeutralButton(@StringRes int textId,
            final DialogInterface.OnClickListener listener) {
        mBuilder.setNeutralButton(textId, listener);
        mNeutralButtonSet = true;
        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 AlertDialogBuilder setNeutralButton(CharSequence text,
            final DialogInterface.OnClickListener listener) {
        mBuilder.setNeutralButton(text, listener);
        mNeutralButtonSet = true;
        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 AlertDialogBuilder setCancelable(boolean cancelable) {
        mBuilder.setCancelable(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>
     *
     * @return This Builder object to allow for chaining of calls to set methods
     * @see #setCancelable(boolean)
     * @see #setOnDismissListener(android.content.DialogInterface.OnDismissListener)
     */
    public AlertDialogBuilder setOnCancelListener(
            DialogInterface.OnCancelListener onCancelListener) {
        mBuilder.setOnCancelListener(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 AlertDialogBuilder setOnDismissListener(
            DialogInterface.OnDismissListener onDismissListener) {
        mBuilder.setOnDismissListener(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 AlertDialogBuilder setOnKeyListener(DialogInterface.OnKeyListener onKeyListener) {
        mBuilder.setOnKeyListener(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 AlertDialogBuilder setItems(@ArrayRes int itemsId,
            final DialogInterface.OnClickListener listener) {
        mBuilder.setItems(itemsId, listener);
        mHasSingleChoiceBodyButton = 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.
     *
     * @return This Builder object to allow for chaining of calls to set methods
     */
    public AlertDialogBuilder setItems(CharSequence[] items,
            final DialogInterface.OnClickListener listener) {
        mBuilder.setItems(items, listener);
        mHasSingleChoiceBodyButton = true;
        return this;
    }

    /**
     * This was not supposed to be in the Chassis API because it allows custom views.
     *
     * @deprecated Use {@link #setAdapter(CarUiListItemAdapter)} instead.
     */
    @Deprecated
    public AlertDialogBuilder setAdapter(final ListAdapter adapter,
            final DialogInterface.OnClickListener listener) {
        mBuilder.setAdapter(adapter, listener);
        mHasSingleChoiceBodyButton = true;
        return this;
    }

    /**
     * Display all the {@link com.android.car.ui.recyclerview.CarUiListItem CarUiListItems} in a
     * {@link CarUiListItemAdapter}. You should set click listeners on the CarUiListItems as
     * opposed to a callback in this function.
     */
    public AlertDialogBuilder setAdapter(final CarUiListItemAdapter adapter) {
        setCustomList(adapter);
        mHasSingleChoiceBodyButton = true;
        return this;
    }

    private void setCustomList(@NonNull CarUiListItemAdapter adapter) {
        View customList = LayoutInflater.from(mContext).inflate(
                R.layout.car_ui_alert_dialog_list, null);
        RecyclerView mList = CarUiUtils.requireViewByRefId(customList, R.id.list);
        mList.setLayoutManager(new LinearLayoutManager(mContext));
        mList.setAdapter(adapter);
        mBuilder.setView(customList);
    }

    /**
     * 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 AlertDialogBuilder setCursor(final Cursor cursor,
            final DialogInterface.OnClickListener listener,
            String labelColumn) {
        mBuilder.setCursor(cursor, listener, labelColumn);
        mHasSingleChoiceBodyButton = 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, 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 AlertDialogBuilder setMultiChoiceItems(@ArrayRes int itemsId, boolean[] checkedItems,
            final DialogInterface.OnMultiChoiceClickListener listener) {
        mBuilder.setMultiChoiceItems(itemsId, checkedItems, listener);
        mHasSingleChoiceBodyButton = false;
        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 AlertDialogBuilder setMultiChoiceItems(CharSequence[] items, boolean[] checkedItems,
            final DialogInterface.OnMultiChoiceClickListener listener) {
        mBuilder.setMultiChoiceItems(items, checkedItems, listener);
        mHasSingleChoiceBodyButton = false;
        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 AlertDialogBuilder setMultiChoiceItems(Cursor cursor, String isCheckedColumn,
            String labelColumn,
            final DialogInterface.OnMultiChoiceClickListener listener) {
        mBuilder.setMultiChoiceItems(cursor, isCheckedColumn, labelColumn, listener);
        mHasSingleChoiceBodyButton = false;
        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 AlertDialogBuilder setSingleChoiceItems(@ArrayRes int itemsId, int checkedItem,
            final DialogInterface.OnClickListener listener) {
        mBuilder.setSingleChoiceItems(itemsId, checkedItem, listener);
        mHasSingleChoiceBodyButton = 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 AlertDialogBuilder setSingleChoiceItems(Cursor cursor, int checkedItem,
            String labelColumn,
            final DialogInterface.OnClickListener listener) {
        mBuilder.setSingleChoiceItems(cursor, checkedItem, labelColumn, listener);
        mHasSingleChoiceBodyButton = 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 AlertDialogBuilder setSingleChoiceItems(CharSequence[] items, int checkedItem,
            final DialogInterface.OnClickListener listener) {
        mBuilder.setSingleChoiceItems(items, checkedItem, listener);
        mHasSingleChoiceBodyButton = true;
        return this;
    }

    /**
     * This was not supposed to be in the Chassis API because it allows custom views.
     *
     * @deprecated Use {@link #setSingleChoiceItems(CarUiRadioButtonListItemAdapter,
     * DialogInterface.OnClickListener)} instead.
     */
    @Deprecated
    public AlertDialogBuilder setSingleChoiceItems(ListAdapter adapter, int checkedItem,
            final DialogInterface.OnClickListener listener) {
        mBuilder.setSingleChoiceItems(adapter, checkedItem, listener);
        mHasSingleChoiceBodyButton = 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 CarUiRadioButtonListItemAdapter} to supply the list 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
     * @deprecated Use {@link #setSingleChoiceItems(CarUiRadioButtonListItemAdapter)} instead.
     */
    @Deprecated
    public AlertDialogBuilder setSingleChoiceItems(CarUiRadioButtonListItemAdapter adapter,
            final DialogInterface.OnClickListener listener) {
        setCustomList(adapter);
        mHasSingleChoiceBodyButton = false;
        return this;
    }

    /**
     * Set a list of items to be displayed in the dialog as the content,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 CarUiRadioButtonListItemAdapter} to supply the list of items
     *                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 AlertDialogBuilder setSingleChoiceItems(CarUiRadioButtonListItemAdapter adapter) {
        setCustomList(adapter);
        mHasSingleChoiceBodyButton = false;
        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 AlertDialogBuilder setOnItemSelectedListener(
            final AdapterView.OnItemSelectedListener listener) {
        mBuilder.setOnItemSelectedListener(listener);
        mHasSingleChoiceBodyButton = true;
        return this;
    }

    /**
     * Sets a custom edit text box within the alert dialog.
     *
     * @param prompt              the string that will be set on the edit text view
     * @param textChangedListener textWatcher whose methods are called whenever this TextView's text
     *                            changes {@link null} otherwise.
     * @param inputFilters        list of input filters, {@link null} if no filter is needed
     * @param inputType           See {@link EditText#setInputType(int)}, except
     *                            {@link android.text.InputType#TYPE_NULL} will not be set.
     * @return this Builder object to allow for chaining of calls to set methods
     */
    public AlertDialogBuilder setEditBox(String prompt, TextWatcher textChangedListener,
            InputFilter[] inputFilters, int inputType) {
        View contentView = LayoutInflater.from(mContext).inflate(
                R.layout.car_ui_alert_dialog_edit_text, null);

        mCarUiEditText = CarUiUtils.requireViewByRefId(contentView, R.id.textbox);
        mCarUiEditText.setText(prompt);

        if (textChangedListener != null) {
            mCarUiEditText.addTextChangedListener(textChangedListener);
        }

        if (inputFilters != null) {
            mCarUiEditText.setFilters(inputFilters);
        }

        if (inputType != 0) {
            mCarUiEditText.setInputType(inputType);
        }

        mBuilder.setView(contentView);
        return this;
    }

    /**
     * Sets a custom edit text box within the alert dialog.
     *
     * @param prompt              the string that will be set on the edit text view
     * @param textChangedListener textWatcher whose methods are called whenever this TextView's text
     *                            changes {@link null} otherwise.
     * @param inputFilters        list of input filters, {@link null} if no filter is needed
     * @return this Builder object to allow for chaining of calls to set methods
     */
    public AlertDialogBuilder setEditBox(String prompt, TextWatcher textChangedListener,
            InputFilter[] inputFilters) {
        return setEditBox(prompt, textChangedListener, inputFilters, 0);
    }

    /**
     * Sets the title and desc related to the dialog within the IMS templates.
     *
     * @param title title to be set.
     * @param desc  description related to the dialog.
     * @return this Builder object to allow for chaining of calls to set methods
     */
    public AlertDialogBuilder setEditTextTitleAndDescForWideScreen(String title, String desc) {
        mWideScreenTitle = title;
        mWideScreenTitleDesc = desc;

        return this;
    }

    /**
     * By default, the AlertDialogBuilder will just display the static text in the content area of
     * widescreen IME provided by {@link #setEditTextTitleAndDescForWideScreen(String, String)}. To
     * display the text typed by the user in the description set this to true.
     *
     * @return this Builder object to allow for chaining of calls to set methods
     */
    public AlertDialogBuilder setAutoDescUpdateForWidescreen(boolean autoUpdateDesc) {
        if (autoUpdateDesc) {
            mCarUiEditText.addTextChangedListener(mTextWatcherWideScreen);
        } else {
            mCarUiEditText.removeTextChangedListener(mTextWatcherWideScreen);
        }
        return this;
    }

    /**
     * By default, the AlertDialogBuilder may add a "Dismiss" button if you don't provide
     * a positive/negative/neutral button. This is so that the dialog is still dismissible
     * using the rotary controller. If however, you add buttons that can close the dialog via
     * {@link #setAdapter(CarUiListItemAdapter)} or a similar method, then you may wish to
     * suppress the addition of the dismiss button, which this method allows for.
     *
     * @param allowDismissButton If true, a "Dismiss" button may be added to the dialog.
     *                           If false, it will never be added.
     * @return this Builder object to allow for chaining of calls to set methods
     */
    public AlertDialogBuilder setAllowDismissButton(boolean allowDismissButton) {
        mAllowDismissButton = allowDismissButton;
        return this;
    }

    /** Final steps common to both {@link #create()} and {@link #show()} */
    private void prepareDialog() {
        View customTitle = LayoutInflater.from(mContext).inflate(
                R.layout.car_ui_alert_dialog_title_with_subtitle, null);

        TextView mTitleView = CarUiUtils.requireViewByRefId(customTitle, R.id.car_ui_alert_title);
        TextView mSubtitleView =
                CarUiUtils.requireViewByRefId(customTitle, R.id.car_ui_alert_subtitle);
        mSubtitleView.setMovementMethod(LinkMovementMethod.getInstance());
        ImageView mIconView = CarUiUtils.requireViewByRefId(customTitle, R.id.car_ui_alert_icon);

        mTitleView.setText(mTitle);
        mTitleView.setVisibility(TextUtils.isEmpty(mTitle) ? View.GONE : View.VISIBLE);
        mSubtitleView.setText(mSubtitle);
        mSubtitleView.setVisibility(TextUtils.isEmpty(mSubtitle) ? View.GONE : View.VISIBLE);
        mIconView.setImageDrawable(mIcon);
        mIconView.setVisibility(mIcon != null ? View.VISIBLE : View.GONE);
        if (mIconTinted) {
            mIconView.setImageTintList(
                    mContext.getColorStateList(R.color.car_ui_dialog_icon_color));
        }
        mBuilder.setCustomTitle(customTitle);

        if (!mAllowDismissButton && !mHasSingleChoiceBodyButton
                && !mNeutralButtonSet && !mNegativeButtonSet && !mPositiveButtonSet) {
            throw new RuntimeException(
                    "The dialog must have at least one button to disable the dismiss button");
        }
        if (mContext.getResources().getBoolean(R.bool.car_ui_alert_dialog_force_dismiss_button)
                && !mNeutralButtonSet && !mNegativeButtonSet && !mPositiveButtonSet
                && mAllowDismissButton) {
            String mDefaultButtonText = mContext.getString(
                    R.string.car_ui_alert_dialog_default_button);
            mBuilder.setNegativeButton(mDefaultButtonText, (dialog, which) -> {
            });
        }
    }

    /**
     * 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() {
        prepareDialog();
        AlertDialog alertDialog = mBuilder.create();

        // Put a FocusParkingView at the end of dialog window to prevent rotary controller
        // wrap-around. Android will focus on the first view automatically when the dialog is shown,
        // and we want it to focus on the title instead of the FocusParkingView, so we put the
        // FocusParkingView at the end of dialog window.
        mRoot = (ViewGroup) alertDialog.getWindow().getDecorView().getRootView();
        FocusParkingView fpv = new FocusParkingView(mContext);
        mRoot.addView(fpv);

        // apply window insets listener to know when IME is visible so we can set title and desc.
        mRoot.setOnApplyWindowInsetsListener(mOnApplyWindowInsetsListener);
        setOnDismissListener(mOnDismissListener);

        return alertDialog;
    }

    /**
     * Creates an {@link AlertDialog} with the arguments supplied to this
     * builder and immediately displays the dialog.
     */
    public AlertDialog show() {
        AlertDialog alertDialog = create();
        alertDialog.show();
        return alertDialog;
    }
}