| /* |
| * 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.widget; |
| |
| import static android.view.flags.Flags.enableArrowIconOnHoverWhenClickable; |
| import static android.view.flags.Flags.FLAG_ENABLE_ARROW_ICON_ON_HOVER_WHEN_CLICKABLE; |
| |
| import android.annotation.DrawableRes; |
| import android.annotation.FlaggedApi; |
| import android.annotation.Nullable; |
| import android.annotation.TestApi; |
| import android.annotation.Widget; |
| import android.app.AlertDialog; |
| import android.compat.annotation.UnsupportedAppUsage; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.DialogInterface.OnClickListener; |
| import android.content.res.Resources; |
| import android.content.res.Resources.Theme; |
| import android.content.res.TypedArray; |
| import android.database.DataSetObserver; |
| import android.graphics.Rect; |
| import android.graphics.drawable.Drawable; |
| import android.os.Build; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.util.AttributeSet; |
| import android.util.Log; |
| import android.view.ContextThemeWrapper; |
| import android.view.Gravity; |
| import android.view.InputDevice; |
| import android.view.MotionEvent; |
| import android.view.PointerIcon; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.ViewTreeObserver; |
| import android.view.ViewTreeObserver.OnGlobalLayoutListener; |
| import android.view.accessibility.AccessibilityNodeInfo; |
| import android.view.inspector.InspectableProperty; |
| import android.widget.PopupWindow.OnDismissListener; |
| |
| import com.android.internal.R; |
| import com.android.internal.view.menu.ShowableListMenu; |
| |
| /** |
| * A view that displays one child at a time and lets the user pick among them. |
| * The items in the Spinner come from the {@link Adapter} associated with |
| * this view. |
| * |
| * <p>See the <a href="{@docRoot}guide/topics/ui/controls/spinner.html">Spinners</a> guide.</p> |
| * |
| * @attr ref android.R.styleable#Spinner_dropDownSelector |
| * @attr ref android.R.styleable#Spinner_dropDownWidth |
| * @attr ref android.R.styleable#Spinner_gravity |
| * @attr ref android.R.styleable#Spinner_popupBackground |
| * @attr ref android.R.styleable#Spinner_prompt |
| * @attr ref android.R.styleable#Spinner_spinnerMode |
| * @attr ref android.R.styleable#ListPopupWindow_dropDownVerticalOffset |
| * @attr ref android.R.styleable#ListPopupWindow_dropDownHorizontalOffset |
| */ |
| @Widget |
| public class Spinner extends AbsSpinner implements OnClickListener { |
| private static final String TAG = "Spinner"; |
| |
| // Only measure this many items to get a decent max width. |
| private static final int MAX_ITEMS_MEASURED = 15; |
| |
| /** |
| * Use a dialog window for selecting spinner options. |
| */ |
| public static final int MODE_DIALOG = 0; |
| |
| /** |
| * Use a dropdown anchored to the Spinner for selecting spinner options. |
| */ |
| public static final int MODE_DROPDOWN = 1; |
| |
| /** |
| * Use the theme-supplied value to select the dropdown mode. |
| */ |
| private static final int MODE_THEME = -1; |
| |
| private final Rect mTempRect = new Rect(); |
| |
| /** Context used to inflate the popup window or dialog. */ |
| private final Context mPopupContext; |
| |
| /** Forwarding listener used to implement drag-to-open. */ |
| @UnsupportedAppUsage |
| private ForwardingListener mForwardingListener; |
| |
| /** Temporary holder for setAdapter() calls from the super constructor. */ |
| private SpinnerAdapter mTempAdapter; |
| |
| @UnsupportedAppUsage |
| private SpinnerPopup mPopup; |
| int mDropDownWidth; |
| |
| private int mGravity; |
| private boolean mDisableChildrenWhenDisabled; |
| |
| /** |
| * Constructs a new spinner with the given context's theme. |
| * |
| * @param context The Context the view is running in, through which it can |
| * access the current theme, resources, etc. |
| */ |
| public Spinner(Context context) { |
| this(context, null); |
| } |
| |
| /** |
| * Constructs a new spinner with the given context's theme and the supplied |
| * mode of displaying choices. <code>mode</code> may be one of |
| * {@link #MODE_DIALOG} or {@link #MODE_DROPDOWN}. |
| * |
| * @param context The Context the view is running in, through which it can |
| * access the current theme, resources, etc. |
| * @param mode Constant describing how the user will select choices from |
| * the spinner. |
| * |
| * @see #MODE_DIALOG |
| * @see #MODE_DROPDOWN |
| */ |
| public Spinner(Context context, int mode) { |
| this(context, null, com.android.internal.R.attr.spinnerStyle, mode); |
| } |
| |
| /** |
| * Constructs a new spinner with the given context's theme and the supplied |
| * attribute set. |
| * |
| * @param context The Context the view is running in, through which it can |
| * access the current theme, resources, etc. |
| * @param attrs The attributes of the XML tag that is inflating the view. |
| */ |
| public Spinner(Context context, AttributeSet attrs) { |
| this(context, attrs, com.android.internal.R.attr.spinnerStyle); |
| } |
| |
| /** |
| * Constructs a new spinner with the given context's theme, the supplied |
| * attribute set, and default style attribute. |
| * |
| * @param context The Context the view is running in, through which it can |
| * access the current theme, resources, etc. |
| * @param attrs The attributes of the XML tag that is inflating the view. |
| * @param defStyleAttr An attribute in the current theme that contains a |
| * reference to a style resource that supplies default |
| * values for the view. Can be 0 to not look for |
| * defaults. |
| */ |
| public Spinner(Context context, AttributeSet attrs, int defStyleAttr) { |
| this(context, attrs, defStyleAttr, 0, MODE_THEME); |
| } |
| |
| /** |
| * Constructs a new spinner with the given context's theme, the supplied |
| * attribute set, and default style attribute. <code>mode</code> may be one |
| * of {@link #MODE_DIALOG} or {@link #MODE_DROPDOWN} and determines how the |
| * user will select choices from the spinner. |
| * |
| * @param context The Context the view is running in, through which it can |
| * access the current theme, resources, etc. |
| * @param attrs The attributes of the XML tag that is inflating the view. |
| * @param defStyleAttr An attribute in the current theme that contains a |
| * reference to a style resource that supplies default |
| * values for the view. Can be 0 to not look for defaults. |
| * @param mode Constant describing how the user will select choices from the |
| * spinner. |
| * |
| * @see #MODE_DIALOG |
| * @see #MODE_DROPDOWN |
| */ |
| public Spinner(Context context, AttributeSet attrs, int defStyleAttr, int mode) { |
| this(context, attrs, defStyleAttr, 0, mode); |
| } |
| |
| /** |
| * Constructs a new spinner with the given context's theme, the supplied |
| * attribute set, and default styles. <code>mode</code> may be one of |
| * {@link #MODE_DIALOG} or {@link #MODE_DROPDOWN} and determines how the |
| * user will select choices from the spinner. |
| * |
| * @param context The Context the view is running in, through which it can |
| * access the current theme, resources, etc. |
| * @param attrs The attributes of the XML tag that is inflating the view. |
| * @param defStyleAttr An attribute in the current theme that contains a |
| * reference to a style resource that supplies default |
| * values for the view. Can be 0 to not look for |
| * defaults. |
| * @param defStyleRes A resource identifier of a style resource that |
| * supplies default values for the view, used only if |
| * defStyleAttr is 0 or can not be found in the theme. |
| * Can be 0 to not look for defaults. |
| * @param mode Constant describing how the user will select choices from |
| * the spinner. |
| * |
| * @see #MODE_DIALOG |
| * @see #MODE_DROPDOWN |
| */ |
| public Spinner(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes, |
| int mode) { |
| this(context, attrs, defStyleAttr, defStyleRes, mode, null); |
| } |
| |
| /** |
| * Constructs a new spinner with the given context, the supplied attribute |
| * set, default styles, popup mode (one of {@link #MODE_DIALOG} or |
| * {@link #MODE_DROPDOWN}), and the theme against which the popup should be |
| * inflated. |
| * |
| * @param context The context against which the view is inflated, which |
| * provides access to the current theme, resources, etc. |
| * @param attrs The attributes of the XML tag that is inflating the view. |
| * @param defStyleAttr An attribute in the current theme that contains a |
| * reference to a style resource that supplies default |
| * values for the view. Can be 0 to not look for |
| * defaults. |
| * @param defStyleRes A resource identifier of a style resource that |
| * supplies default values for the view, used only if |
| * defStyleAttr is 0 or can not be found in the theme. |
| * Can be 0 to not look for defaults. |
| * @param mode Constant describing how the user will select choices from |
| * the spinner. |
| * @param popupTheme The theme against which the dialog or dropdown popup |
| * should be inflated. May be {@code null} to use the |
| * view theme. If set, this will override any value |
| * specified by |
| * {@link android.R.styleable#Spinner_popupTheme}. |
| * |
| * @see #MODE_DIALOG |
| * @see #MODE_DROPDOWN |
| */ |
| public Spinner(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes, int mode, |
| Theme popupTheme) { |
| super(context, attrs, defStyleAttr, defStyleRes); |
| |
| final TypedArray a = context.obtainStyledAttributes( |
| attrs, R.styleable.Spinner, defStyleAttr, defStyleRes); |
| saveAttributeDataForStyleable(context, R.styleable.Spinner, |
| attrs, a, defStyleAttr, defStyleRes); |
| |
| if (popupTheme != null) { |
| mPopupContext = new ContextThemeWrapper(context, popupTheme); |
| } else { |
| final int popupThemeResId = a.getResourceId(R.styleable.Spinner_popupTheme, 0); |
| if (popupThemeResId != 0) { |
| mPopupContext = new ContextThemeWrapper(context, popupThemeResId); |
| } else { |
| mPopupContext = context; |
| } |
| } |
| |
| if (mode == MODE_THEME) { |
| mode = a.getInt(R.styleable.Spinner_spinnerMode, MODE_DIALOG); |
| } |
| |
| switch (mode) { |
| case MODE_DIALOG: { |
| mPopup = new DialogPopup(); |
| mPopup.setPromptText(a.getString(R.styleable.Spinner_prompt)); |
| break; |
| } |
| |
| case MODE_DROPDOWN: { |
| final DropdownPopup popup = new DropdownPopup( |
| mPopupContext, attrs, defStyleAttr, defStyleRes); |
| final TypedArray pa = mPopupContext.obtainStyledAttributes( |
| attrs, R.styleable.Spinner, defStyleAttr, defStyleRes); |
| mDropDownWidth = pa.getLayoutDimension(R.styleable.Spinner_dropDownWidth, |
| ViewGroup.LayoutParams.WRAP_CONTENT); |
| if (pa.hasValueOrEmpty(R.styleable.Spinner_dropDownSelector)) { |
| popup.setListSelector(pa.getDrawable( |
| R.styleable.Spinner_dropDownSelector)); |
| } |
| popup.setBackgroundDrawable(pa.getDrawable(R.styleable.Spinner_popupBackground)); |
| popup.setPromptText(a.getString(R.styleable.Spinner_prompt)); |
| pa.recycle(); |
| |
| mPopup = popup; |
| mForwardingListener = new ForwardingListener(this) { |
| @Override |
| public ShowableListMenu getPopup() { |
| return popup; |
| } |
| |
| @Override |
| public boolean onForwardingStarted() { |
| if (!mPopup.isShowing()) { |
| mPopup.show(getTextDirection(), getTextAlignment()); |
| } |
| return true; |
| } |
| }; |
| break; |
| } |
| } |
| |
| mGravity = a.getInt(R.styleable.Spinner_gravity, Gravity.CENTER); |
| mDisableChildrenWhenDisabled = a.getBoolean( |
| R.styleable.Spinner_disableChildrenWhenDisabled, false); |
| |
| a.recycle(); |
| |
| // Base constructor can call setAdapter before we initialize mPopup. |
| // Finish setting things up if this happened. |
| if (mTempAdapter != null) { |
| setAdapter(mTempAdapter); |
| mTempAdapter = null; |
| } |
| } |
| |
| /** |
| * @return the context used to inflate the Spinner's popup or dialog window |
| */ |
| public Context getPopupContext() { |
| return mPopupContext; |
| } |
| |
| /** |
| * Set the background drawable for the spinner's popup window of choices. |
| * Only valid in {@link #MODE_DROPDOWN}; this method is a no-op in other modes. |
| * |
| * @param background Background drawable |
| * |
| * @attr ref android.R.styleable#Spinner_popupBackground |
| */ |
| public void setPopupBackgroundDrawable(Drawable background) { |
| if (!(mPopup instanceof DropdownPopup)) { |
| Log.e(TAG, "setPopupBackgroundDrawable: incompatible spinner mode; ignoring..."); |
| return; |
| } |
| mPopup.setBackgroundDrawable(background); |
| } |
| |
| /** |
| * Set the background drawable for the spinner's popup window of choices. |
| * Only valid in {@link #MODE_DROPDOWN}; this method is a no-op in other modes. |
| * |
| * @param resId Resource ID of a background drawable |
| * |
| * @attr ref android.R.styleable#Spinner_popupBackground |
| */ |
| public void setPopupBackgroundResource(@DrawableRes int resId) { |
| setPopupBackgroundDrawable(getPopupContext().getDrawable(resId)); |
| } |
| |
| /** |
| * Get the background drawable for the spinner's popup window of choices. |
| * Only valid in {@link #MODE_DROPDOWN}; other modes will return null. |
| * |
| * @return background Background drawable |
| * |
| * @attr ref android.R.styleable#Spinner_popupBackground |
| */ |
| @InspectableProperty |
| public Drawable getPopupBackground() { |
| return mPopup.getBackground(); |
| } |
| |
| /** |
| * @hide |
| */ |
| @TestApi |
| public boolean isPopupShowing() { |
| return (mPopup != null) && mPopup.isShowing(); |
| } |
| |
| /** |
| * Set a vertical offset in pixels for the spinner's popup window of choices. |
| * Only valid in {@link #MODE_DROPDOWN}; this method is a no-op in other modes. |
| * |
| * @param pixels Vertical offset in pixels |
| * |
| * @attr ref android.R.styleable#ListPopupWindow_dropDownVerticalOffset |
| */ |
| public void setDropDownVerticalOffset(int pixels) { |
| mPopup.setVerticalOffset(pixels); |
| } |
| |
| /** |
| * Get the configured vertical offset in pixels for the spinner's popup window of choices. |
| * Only valid in {@link #MODE_DROPDOWN}; other modes will return 0. |
| * |
| * @return Vertical offset in pixels |
| * |
| * @attr ref android.R.styleable#ListPopupWindow_dropDownVerticalOffset |
| */ |
| @InspectableProperty |
| public int getDropDownVerticalOffset() { |
| return mPopup.getVerticalOffset(); |
| } |
| |
| /** |
| * Set a horizontal offset in pixels for the spinner's popup window of choices. |
| * Only valid in {@link #MODE_DROPDOWN}; this method is a no-op in other modes. |
| * |
| * @param pixels Horizontal offset in pixels |
| * |
| * @attr ref android.R.styleable#ListPopupWindow_dropDownHorizontalOffset |
| */ |
| public void setDropDownHorizontalOffset(int pixels) { |
| mPopup.setHorizontalOffset(pixels); |
| } |
| |
| /** |
| * Get the configured horizontal offset in pixels for the spinner's popup window of choices. |
| * Only valid in {@link #MODE_DROPDOWN}; other modes will return 0. |
| * |
| * @return Horizontal offset in pixels |
| * |
| * @attr ref android.R.styleable#ListPopupWindow_dropDownHorizontalOffset |
| */ |
| @InspectableProperty |
| public int getDropDownHorizontalOffset() { |
| return mPopup.getHorizontalOffset(); |
| } |
| |
| /** |
| * Set the width of the spinner's popup window of choices in pixels. This value |
| * may also be set to {@link android.view.ViewGroup.LayoutParams#MATCH_PARENT} |
| * to match the width of the Spinner itself, or |
| * {@link android.view.ViewGroup.LayoutParams#WRAP_CONTENT} to wrap to the measured size |
| * of contained dropdown list items. |
| * |
| * <p>Only valid in {@link #MODE_DROPDOWN}; this method is a no-op in other modes.</p> |
| * |
| * @param pixels Width in pixels, WRAP_CONTENT, or MATCH_PARENT |
| * |
| * @attr ref android.R.styleable#Spinner_dropDownWidth |
| */ |
| public void setDropDownWidth(int pixels) { |
| if (!(mPopup instanceof DropdownPopup)) { |
| Log.e(TAG, "Cannot set dropdown width for MODE_DIALOG, ignoring"); |
| return; |
| } |
| mDropDownWidth = pixels; |
| } |
| |
| /** |
| * Get the configured width of the spinner's popup window of choices in pixels. |
| * The returned value may also be {@link android.view.ViewGroup.LayoutParams#MATCH_PARENT} |
| * meaning the popup window will match the width of the Spinner itself, or |
| * {@link android.view.ViewGroup.LayoutParams#WRAP_CONTENT} to wrap to the measured size |
| * of contained dropdown list items. |
| * |
| * @return Width in pixels, WRAP_CONTENT, or MATCH_PARENT |
| * |
| * @attr ref android.R.styleable#Spinner_dropDownWidth |
| */ |
| @InspectableProperty |
| public int getDropDownWidth() { |
| return mDropDownWidth; |
| } |
| |
| @Override |
| public void setEnabled(boolean enabled) { |
| super.setEnabled(enabled); |
| if (mDisableChildrenWhenDisabled) { |
| final int count = getChildCount(); |
| for (int i = 0; i < count; i++) { |
| getChildAt(i).setEnabled(enabled); |
| } |
| } |
| } |
| |
| /** |
| * Describes how the selected item view is positioned. Currently only the horizontal component |
| * is used. The default is determined by the current theme. |
| * |
| * @param gravity See {@link android.view.Gravity} |
| * |
| * @attr ref android.R.styleable#Spinner_gravity |
| */ |
| public void setGravity(int gravity) { |
| if (mGravity != gravity) { |
| if ((gravity & Gravity.HORIZONTAL_GRAVITY_MASK) == 0) { |
| gravity |= Gravity.START; |
| } |
| mGravity = gravity; |
| requestLayout(); |
| } |
| } |
| |
| /** |
| * Describes how the selected item view is positioned. The default is determined by the |
| * current theme. |
| * |
| * @return A {@link android.view.Gravity Gravity} value |
| */ |
| @InspectableProperty(valueType = InspectableProperty.ValueType.GRAVITY) |
| public int getGravity() { |
| return mGravity; |
| } |
| |
| /** |
| * Sets the {@link SpinnerAdapter} used to provide the data which backs |
| * this Spinner. |
| * <p> |
| * If this Spinner has a popup theme set in XML via the |
| * {@link android.R.styleable#Spinner_popupTheme popupTheme} attribute, the |
| * adapter should inflate drop-down views using the same theme. The easiest |
| * way to achieve this is by using {@link #getPopupContext()} to obtain a |
| * layout inflater for use in |
| * {@link SpinnerAdapter#getDropDownView(int, View, ViewGroup)}. |
| * <p> |
| * Spinner overrides {@link Adapter#getViewTypeCount()} on the |
| * Adapter associated with this view. Calling |
| * {@link Adapter#getItemViewType(int) getItemViewType(int)} on the object |
| * returned from {@link #getAdapter()} will always return 0. Calling |
| * {@link Adapter#getViewTypeCount() getViewTypeCount()} will always return |
| * 1. On API {@link Build.VERSION_CODES#LOLLIPOP} and above, attempting to set an |
| * adapter with more than one view type will throw an |
| * {@link IllegalArgumentException}. |
| * |
| * @param adapter the adapter to set |
| * |
| * @see AbsSpinner#setAdapter(SpinnerAdapter) |
| * @throws IllegalArgumentException if the adapter has more than one view |
| * type |
| */ |
| @Override |
| public void setAdapter(SpinnerAdapter adapter) { |
| // The super constructor may call setAdapter before we're prepared. |
| // Postpone doing anything until we've finished construction. |
| if (mPopup == null) { |
| mTempAdapter = adapter; |
| return; |
| } |
| |
| super.setAdapter(adapter); |
| |
| mRecycler.clear(); |
| |
| final int targetSdkVersion = mContext.getApplicationInfo().targetSdkVersion; |
| if (targetSdkVersion >= Build.VERSION_CODES.LOLLIPOP |
| && adapter != null && adapter.getViewTypeCount() != 1) { |
| throw new IllegalArgumentException("Spinner adapter view type count must be 1"); |
| } |
| |
| final Context popupContext = mPopupContext == null ? mContext : mPopupContext; |
| mPopup.setAdapter(new DropDownAdapter(adapter, popupContext.getTheme())); |
| } |
| |
| @Override |
| public int getBaseline() { |
| View child = null; |
| |
| if (getChildCount() > 0) { |
| child = getChildAt(0); |
| } else if (mAdapter != null && mAdapter.getCount() > 0) { |
| child = makeView(0, false); |
| mRecycler.put(0, child); |
| } |
| |
| if (child != null) { |
| final int childBaseline = child.getBaseline(); |
| return childBaseline >= 0 ? child.getTop() + childBaseline : -1; |
| } else { |
| return -1; |
| } |
| } |
| |
| @Override |
| protected void onDetachedFromWindow() { |
| super.onDetachedFromWindow(); |
| |
| if (mPopup != null && mPopup.isShowing()) { |
| mPopup.dismiss(); |
| } |
| } |
| |
| /** |
| * <p>A spinner does not support item click events. Calling this method |
| * will raise an exception.</p> |
| * <p>Instead use {@link AdapterView#setOnItemSelectedListener}. |
| * |
| * @param l this listener will be ignored |
| */ |
| @Override |
| public void setOnItemClickListener(OnItemClickListener l) { |
| throw new RuntimeException("setOnItemClickListener cannot be used with a spinner."); |
| } |
| |
| /** |
| * @hide internal use only |
| */ |
| @UnsupportedAppUsage |
| public void setOnItemClickListenerInt(OnItemClickListener l) { |
| super.setOnItemClickListener(l); |
| } |
| |
| @Override |
| public boolean onTouchEvent(MotionEvent event) { |
| if (mForwardingListener != null && mForwardingListener.onTouch(this, event)) { |
| return true; |
| } |
| |
| return super.onTouchEvent(event); |
| } |
| |
| @Override |
| protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { |
| super.onMeasure(widthMeasureSpec, heightMeasureSpec); |
| if (mPopup != null && MeasureSpec.getMode(widthMeasureSpec) == MeasureSpec.AT_MOST) { |
| final int measuredWidth = getMeasuredWidth(); |
| setMeasuredDimension(Math.min(Math.max(measuredWidth, |
| measureContentWidth(getAdapter(), getBackground())), |
| MeasureSpec.getSize(widthMeasureSpec)), |
| getMeasuredHeight()); |
| } |
| } |
| |
| /** |
| * @see android.view.View#onLayout(boolean,int,int,int,int) |
| * |
| * Creates and positions all views |
| * |
| */ |
| @Override |
| protected void onLayout(boolean changed, int l, int t, int r, int b) { |
| super.onLayout(changed, l, t, r, b); |
| mInLayout = true; |
| layout(0, false); |
| mInLayout = false; |
| } |
| |
| /** |
| * Creates and positions all views for this Spinner. |
| * |
| * @param delta Change in the selected position. +1 means selection is moving to the right, |
| * so views are scrolling to the left. -1 means selection is moving to the left. |
| */ |
| @Override |
| void layout(int delta, boolean animate) { |
| int childrenLeft = mSpinnerPadding.left; |
| int childrenWidth = mRight - mLeft - mSpinnerPadding.left - mSpinnerPadding.right; |
| |
| if (mDataChanged) { |
| handleDataChanged(); |
| } |
| |
| // Handle the empty set by removing all views |
| if (mItemCount == 0) { |
| resetList(); |
| return; |
| } |
| |
| if (mNextSelectedPosition >= 0) { |
| setSelectedPositionInt(mNextSelectedPosition); |
| } |
| |
| recycleAllViews(); |
| |
| // Clear out old views |
| removeAllViewsInLayout(); |
| |
| // Make selected view and position it |
| mFirstPosition = mSelectedPosition; |
| |
| if (mAdapter != null) { |
| View sel = makeView(mSelectedPosition, true); |
| int width = sel.getMeasuredWidth(); |
| int selectedOffset = childrenLeft; |
| final int layoutDirection = getLayoutDirection(); |
| final int absoluteGravity = Gravity.getAbsoluteGravity(mGravity, layoutDirection); |
| switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) { |
| case Gravity.CENTER_HORIZONTAL: |
| selectedOffset = childrenLeft + (childrenWidth / 2) - (width / 2); |
| break; |
| case Gravity.RIGHT: |
| selectedOffset = childrenLeft + childrenWidth - width; |
| break; |
| } |
| sel.offsetLeftAndRight(selectedOffset); |
| } |
| |
| // Flush any cached views that did not get reused above |
| mRecycler.clear(); |
| |
| invalidate(); |
| |
| checkSelectionChanged(); |
| |
| mDataChanged = false; |
| mNeedSync = false; |
| setNextSelectedPositionInt(mSelectedPosition); |
| } |
| |
| /** |
| * Obtain a view, either by pulling an existing view from the recycler or |
| * by getting a new one from the adapter. If we are animating, make sure |
| * there is enough information in the view's layout parameters to animate |
| * from the old to new positions. |
| * |
| * @param position Position in the spinner for the view to obtain |
| * @param addChild true to add the child to the spinner, false to obtain and configure only. |
| * @return A view for the given position |
| */ |
| private View makeView(int position, boolean addChild) { |
| View child; |
| |
| if (!mDataChanged) { |
| child = mRecycler.get(position); |
| if (child != null) { |
| // Position the view |
| setUpChild(child, addChild); |
| |
| return child; |
| } |
| } |
| |
| // Nothing found in the recycler -- ask the adapter for a view |
| child = mAdapter.getView(position, null, this); |
| |
| // Position the view |
| setUpChild(child, addChild); |
| |
| return child; |
| } |
| |
| /** |
| * Helper for makeAndAddView to set the position of a view |
| * and fill out its layout paramters. |
| * |
| * @param child The view to position |
| * @param addChild true if the child should be added to the Spinner during setup |
| */ |
| private void setUpChild(View child, boolean addChild) { |
| |
| // Respect layout params that are already in the view. Otherwise |
| // make some up... |
| ViewGroup.LayoutParams lp = child.getLayoutParams(); |
| if (lp == null) { |
| lp = generateDefaultLayoutParams(); |
| } |
| |
| addViewInLayout(child, 0, lp); |
| |
| child.setSelected(hasFocus()); |
| if (mDisableChildrenWhenDisabled) { |
| child.setEnabled(isEnabled()); |
| } |
| |
| // Get measure specs |
| int childHeightSpec = ViewGroup.getChildMeasureSpec(mHeightMeasureSpec, |
| mSpinnerPadding.top + mSpinnerPadding.bottom, lp.height); |
| int childWidthSpec = ViewGroup.getChildMeasureSpec(mWidthMeasureSpec, |
| mSpinnerPadding.left + mSpinnerPadding.right, lp.width); |
| |
| // Measure child |
| child.measure(childWidthSpec, childHeightSpec); |
| |
| int childLeft; |
| int childRight; |
| |
| // Position vertically based on gravity setting |
| int childTop = mSpinnerPadding.top |
| + ((getMeasuredHeight() - mSpinnerPadding.bottom - |
| mSpinnerPadding.top - child.getMeasuredHeight()) / 2); |
| int childBottom = childTop + child.getMeasuredHeight(); |
| |
| int width = child.getMeasuredWidth(); |
| childLeft = 0; |
| childRight = childLeft + width; |
| |
| child.layout(childLeft, childTop, childRight, childBottom); |
| |
| if (!addChild) { |
| removeViewInLayout(child); |
| } |
| } |
| |
| @Override |
| public boolean performClick() { |
| boolean handled = super.performClick(); |
| |
| if (!handled) { |
| handled = true; |
| |
| if (!mPopup.isShowing()) { |
| mPopup.show(getTextDirection(), getTextAlignment()); |
| } |
| } |
| |
| return handled; |
| } |
| |
| @Override |
| public void onClick(DialogInterface dialog, int which) { |
| setSelection(which); |
| dialog.dismiss(); |
| } |
| |
| /** |
| * Sets selection and dismisses the spinner's popup if it can be dismissed. |
| * For ease of use in tests, where publicly obtaining the spinner's popup is difficult. |
| * |
| * @param which index of the item to be selected. |
| * @hide |
| */ |
| @TestApi |
| public void onClick(int which) { |
| setSelection(which); |
| if (mPopup != null && mPopup.isShowing()) { |
| mPopup.dismiss(); |
| } |
| } |
| |
| @Override |
| public CharSequence getAccessibilityClassName() { |
| return Spinner.class.getName(); |
| } |
| |
| /** @hide */ |
| @Override |
| public void onInitializeAccessibilityNodeInfoInternal(AccessibilityNodeInfo info) { |
| super.onInitializeAccessibilityNodeInfoInternal(info); |
| |
| if (mAdapter != null) { |
| info.setCanOpenPopup(true); |
| } |
| } |
| |
| /** |
| * Sets the prompt to display when the dialog is shown. |
| * @param prompt the prompt to set |
| */ |
| public void setPrompt(CharSequence prompt) { |
| mPopup.setPromptText(prompt); |
| } |
| |
| /** |
| * Sets the prompt to display when the dialog is shown. |
| * @param promptId the resource ID of the prompt to display when the dialog is shown |
| */ |
| public void setPromptId(int promptId) { |
| setPrompt(getContext().getText(promptId)); |
| } |
| |
| /** |
| * @return The prompt to display when the dialog is shown |
| */ |
| @InspectableProperty |
| public CharSequence getPrompt() { |
| return mPopup.getHintText(); |
| } |
| |
| int measureContentWidth(SpinnerAdapter adapter, Drawable background) { |
| if (adapter == null) { |
| return 0; |
| } |
| |
| int width = 0; |
| View itemView = null; |
| int itemType = 0; |
| final int widthMeasureSpec = |
| MeasureSpec.makeSafeMeasureSpec(getMeasuredWidth(), MeasureSpec.UNSPECIFIED); |
| final int heightMeasureSpec = |
| MeasureSpec.makeSafeMeasureSpec(getMeasuredHeight(), MeasureSpec.UNSPECIFIED); |
| |
| // Make sure the number of items we'll measure is capped. If it's a huge data set |
| // with wildly varying sizes, oh well. |
| int start = Math.max(0, getSelectedItemPosition()); |
| final int end = Math.min(adapter.getCount(), start + MAX_ITEMS_MEASURED); |
| final int count = end - start; |
| start = Math.max(0, start - (MAX_ITEMS_MEASURED - count)); |
| for (int i = start; i < end; i++) { |
| final int positionType = adapter.getItemViewType(i); |
| if (positionType != itemType) { |
| itemType = positionType; |
| itemView = null; |
| } |
| itemView = adapter.getView(i, itemView, this); |
| if (itemView.getLayoutParams() == null) { |
| itemView.setLayoutParams(new ViewGroup.LayoutParams( |
| ViewGroup.LayoutParams.WRAP_CONTENT, |
| ViewGroup.LayoutParams.WRAP_CONTENT)); |
| } |
| itemView.measure(widthMeasureSpec, heightMeasureSpec); |
| width = Math.max(width, itemView.getMeasuredWidth()); |
| } |
| |
| // Add background padding to measured width |
| if (background != null) { |
| background.getPadding(mTempRect); |
| width += mTempRect.left + mTempRect.right; |
| } |
| |
| return width; |
| } |
| |
| @Override |
| public Parcelable onSaveInstanceState() { |
| final SavedState ss = new SavedState(super.onSaveInstanceState()); |
| ss.showDropdown = mPopup != null && mPopup.isShowing(); |
| return ss; |
| } |
| |
| @Override |
| public void onRestoreInstanceState(Parcelable state) { |
| SavedState ss = (SavedState) state; |
| |
| super.onRestoreInstanceState(ss.getSuperState()); |
| |
| if (ss.showDropdown) { |
| ViewTreeObserver vto = getViewTreeObserver(); |
| if (vto != null) { |
| final OnGlobalLayoutListener listener = new OnGlobalLayoutListener() { |
| @Override |
| public void onGlobalLayout() { |
| if (!mPopup.isShowing()) { |
| mPopup.show(getTextDirection(), getTextAlignment()); |
| } |
| final ViewTreeObserver vto = getViewTreeObserver(); |
| if (vto != null) { |
| vto.removeOnGlobalLayoutListener(this); |
| } |
| } |
| }; |
| vto.addOnGlobalLayoutListener(listener); |
| } |
| } |
| } |
| |
| @FlaggedApi(FLAG_ENABLE_ARROW_ICON_ON_HOVER_WHEN_CLICKABLE) |
| @Override |
| public PointerIcon onResolvePointerIcon(MotionEvent event, int pointerIndex) { |
| if (getPointerIcon() == null && isClickable() && isEnabled() |
| && event.isFromSource(InputDevice.SOURCE_MOUSE)) { |
| int pointerIcon = enableArrowIconOnHoverWhenClickable() |
| ? PointerIcon.TYPE_ARROW |
| : PointerIcon.TYPE_HAND; |
| return PointerIcon.getSystemIcon(getContext(), pointerIcon); |
| } |
| return super.onResolvePointerIcon(event, pointerIndex); |
| } |
| |
| static class SavedState extends AbsSpinner.SavedState { |
| boolean showDropdown; |
| |
| SavedState(Parcelable superState) { |
| super(superState); |
| } |
| |
| private SavedState(Parcel in) { |
| super(in); |
| showDropdown = in.readByte() != 0; |
| } |
| |
| @Override |
| public void writeToParcel(Parcel out, int flags) { |
| super.writeToParcel(out, flags); |
| out.writeByte((byte) (showDropdown ? 1 : 0)); |
| } |
| |
| public static final @android.annotation.NonNull Parcelable.Creator<SavedState> CREATOR = |
| new Parcelable.Creator<SavedState>() { |
| public SavedState createFromParcel(Parcel in) { |
| return new SavedState(in); |
| } |
| |
| public SavedState[] newArray(int size) { |
| return new SavedState[size]; |
| } |
| }; |
| } |
| |
| /** |
| * <p>Wrapper class for an Adapter. Transforms the embedded Adapter instance |
| * into a ListAdapter.</p> |
| */ |
| private static class DropDownAdapter implements ListAdapter, SpinnerAdapter { |
| private SpinnerAdapter mAdapter; |
| private ListAdapter mListAdapter; |
| |
| /** |
| * Creates a new ListAdapter wrapper for the specified adapter. |
| * |
| * @param adapter the SpinnerAdapter to transform into a ListAdapter |
| * @param dropDownTheme the theme against which to inflate drop-down |
| * views, may be {@null} to use default theme |
| */ |
| public DropDownAdapter(@Nullable SpinnerAdapter adapter, |
| @Nullable Resources.Theme dropDownTheme) { |
| mAdapter = adapter; |
| |
| if (adapter instanceof ListAdapter) { |
| mListAdapter = (ListAdapter) adapter; |
| } |
| |
| if (dropDownTheme != null && adapter instanceof ThemedSpinnerAdapter) { |
| final ThemedSpinnerAdapter themedAdapter = (ThemedSpinnerAdapter) adapter; |
| if (themedAdapter.getDropDownViewTheme() == null) { |
| themedAdapter.setDropDownViewTheme(dropDownTheme); |
| } |
| } |
| } |
| |
| public int getCount() { |
| return mAdapter == null ? 0 : mAdapter.getCount(); |
| } |
| |
| public Object getItem(int position) { |
| return mAdapter == null ? null : mAdapter.getItem(position); |
| } |
| |
| public long getItemId(int position) { |
| return mAdapter == null ? -1 : mAdapter.getItemId(position); |
| } |
| |
| public View getView(int position, View convertView, ViewGroup parent) { |
| return getDropDownView(position, convertView, parent); |
| } |
| |
| public View getDropDownView(int position, View convertView, ViewGroup parent) { |
| return (mAdapter == null) ? null : mAdapter.getDropDownView(position, convertView, parent); |
| } |
| |
| public boolean hasStableIds() { |
| return mAdapter != null && mAdapter.hasStableIds(); |
| } |
| |
| public void registerDataSetObserver(DataSetObserver observer) { |
| if (mAdapter != null) { |
| mAdapter.registerDataSetObserver(observer); |
| } |
| } |
| |
| public void unregisterDataSetObserver(DataSetObserver observer) { |
| if (mAdapter != null) { |
| mAdapter.unregisterDataSetObserver(observer); |
| } |
| } |
| |
| /** |
| * If the wrapped SpinnerAdapter is also a ListAdapter, delegate this call. |
| * Otherwise, return true. |
| */ |
| public boolean areAllItemsEnabled() { |
| final ListAdapter adapter = mListAdapter; |
| if (adapter != null) { |
| return adapter.areAllItemsEnabled(); |
| } else { |
| return true; |
| } |
| } |
| |
| /** |
| * If the wrapped SpinnerAdapter is also a ListAdapter, delegate this call. |
| * Otherwise, return true. |
| */ |
| public boolean isEnabled(int position) { |
| final ListAdapter adapter = mListAdapter; |
| if (adapter != null) { |
| return adapter.isEnabled(position); |
| } else { |
| return true; |
| } |
| } |
| |
| public int getItemViewType(int position) { |
| return 0; |
| } |
| |
| public int getViewTypeCount() { |
| return 1; |
| } |
| |
| public boolean isEmpty() { |
| return getCount() == 0; |
| } |
| } |
| |
| /** |
| * Implements some sort of popup selection interface for selecting a spinner option. |
| * Allows for different spinner modes. |
| */ |
| private interface SpinnerPopup { |
| public void setAdapter(ListAdapter adapter); |
| |
| /** |
| * Show the popup |
| */ |
| public void show(int textDirection, int textAlignment); |
| |
| /** |
| * Dismiss the popup |
| */ |
| public void dismiss(); |
| |
| /** |
| * @return true if the popup is showing, false otherwise. |
| */ |
| @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553) |
| public boolean isShowing(); |
| |
| /** |
| * Set hint text to be displayed to the user. This should provide |
| * a description of the choice being made. |
| * @param hintText Hint text to set. |
| */ |
| public void setPromptText(CharSequence hintText); |
| public CharSequence getHintText(); |
| |
| public void setBackgroundDrawable(Drawable bg); |
| public void setVerticalOffset(int px); |
| public void setHorizontalOffset(int px); |
| public Drawable getBackground(); |
| public int getVerticalOffset(); |
| public int getHorizontalOffset(); |
| } |
| |
| private class DialogPopup implements SpinnerPopup, DialogInterface.OnClickListener { |
| private AlertDialog mPopup; |
| private ListAdapter mListAdapter; |
| private CharSequence mPrompt; |
| |
| public void dismiss() { |
| if (mPopup != null) { |
| mPopup.dismiss(); |
| mPopup = null; |
| } |
| } |
| |
| @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553) |
| public boolean isShowing() { |
| return mPopup != null ? mPopup.isShowing() : false; |
| } |
| |
| public void setAdapter(ListAdapter adapter) { |
| mListAdapter = adapter; |
| } |
| |
| public void setPromptText(CharSequence hintText) { |
| mPrompt = hintText; |
| } |
| |
| public CharSequence getHintText() { |
| return mPrompt; |
| } |
| |
| public void show(int textDirection, int textAlignment) { |
| if (mListAdapter == null) { |
| return; |
| } |
| AlertDialog.Builder builder = new AlertDialog.Builder(getPopupContext()); |
| if (mPrompt != null) { |
| builder.setTitle(mPrompt); |
| } |
| mPopup = builder.setSingleChoiceItems(mListAdapter, |
| getSelectedItemPosition(), this).create(); |
| final ListView listView = mPopup.getListView(); |
| listView.setTextDirection(textDirection); |
| listView.setTextAlignment(textAlignment); |
| mPopup.show(); |
| } |
| |
| public void onClick(DialogInterface dialog, int which) { |
| setSelection(which); |
| if (mOnItemClickListener != null) { |
| performItemClick(null, which, mListAdapter.getItemId(which)); |
| } |
| dismiss(); |
| } |
| |
| @Override |
| public void setBackgroundDrawable(Drawable bg) { |
| Log.e(TAG, "Cannot set popup background for MODE_DIALOG, ignoring"); |
| } |
| |
| @Override |
| public void setVerticalOffset(int px) { |
| Log.e(TAG, "Cannot set vertical offset for MODE_DIALOG, ignoring"); |
| } |
| |
| @Override |
| public void setHorizontalOffset(int px) { |
| Log.e(TAG, "Cannot set horizontal offset for MODE_DIALOG, ignoring"); |
| } |
| |
| @Override |
| public Drawable getBackground() { |
| return null; |
| } |
| |
| @Override |
| public int getVerticalOffset() { |
| return 0; |
| } |
| |
| @Override |
| public int getHorizontalOffset() { |
| return 0; |
| } |
| } |
| |
| private class DropdownPopup extends ListPopupWindow implements SpinnerPopup { |
| private CharSequence mHintText; |
| private ListAdapter mAdapter; |
| |
| public DropdownPopup( |
| Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) { |
| super(context, attrs, defStyleAttr, defStyleRes); |
| |
| setAnchorView(Spinner.this); |
| setModal(true); |
| setPromptPosition(POSITION_PROMPT_ABOVE); |
| setOnItemClickListener(new OnItemClickListener() { |
| public void onItemClick(AdapterView parent, View v, int position, long id) { |
| Spinner.this.setSelection(position); |
| if (mOnItemClickListener != null) { |
| Spinner.this.performItemClick(v, position, mAdapter.getItemId(position)); |
| } |
| dismiss(); |
| } |
| }); |
| } |
| |
| @Override |
| public void setAdapter(ListAdapter adapter) { |
| super.setAdapter(adapter); |
| mAdapter = adapter; |
| } |
| |
| public CharSequence getHintText() { |
| return mHintText; |
| } |
| |
| public void setPromptText(CharSequence hintText) { |
| // Hint text is ignored for dropdowns, but maintain it here. |
| mHintText = hintText; |
| } |
| |
| void computeContentWidth() { |
| final Drawable background = getBackground(); |
| int hOffset = 0; |
| if (background != null) { |
| background.getPadding(mTempRect); |
| hOffset = isLayoutRtl() ? mTempRect.right : -mTempRect.left; |
| } else { |
| mTempRect.left = mTempRect.right = 0; |
| } |
| |
| final int spinnerPaddingLeft = Spinner.this.getPaddingLeft(); |
| final int spinnerPaddingRight = Spinner.this.getPaddingRight(); |
| final int spinnerWidth = Spinner.this.getWidth(); |
| |
| if (mDropDownWidth == WRAP_CONTENT) { |
| int contentWidth = measureContentWidth( |
| (SpinnerAdapter) mAdapter, getBackground()); |
| final int contentWidthLimit = mContext.getResources() |
| .getDisplayMetrics().widthPixels - mTempRect.left - mTempRect.right; |
| if (contentWidth > contentWidthLimit) { |
| contentWidth = contentWidthLimit; |
| } |
| setContentWidth(Math.max( |
| contentWidth, spinnerWidth - spinnerPaddingLeft - spinnerPaddingRight)); |
| } else if (mDropDownWidth == MATCH_PARENT) { |
| setContentWidth(spinnerWidth - spinnerPaddingLeft - spinnerPaddingRight); |
| } else { |
| setContentWidth(mDropDownWidth); |
| } |
| |
| if (isLayoutRtl()) { |
| hOffset += spinnerWidth - spinnerPaddingRight - getWidth(); |
| } else { |
| hOffset += spinnerPaddingLeft; |
| } |
| setHorizontalOffset(hOffset); |
| } |
| |
| public void show(int textDirection, int textAlignment) { |
| final boolean wasShowing = isShowing(); |
| |
| computeContentWidth(); |
| |
| setInputMethodMode(ListPopupWindow.INPUT_METHOD_NOT_NEEDED); |
| super.show(); |
| final ListView listView = getListView(); |
| listView.setChoiceMode(ListView.CHOICE_MODE_SINGLE); |
| listView.setTextDirection(textDirection); |
| listView.setTextAlignment(textAlignment); |
| setSelection(Spinner.this.getSelectedItemPosition()); |
| |
| if (wasShowing) { |
| // Skip setting up the layout/dismiss listener below. If we were previously |
| // showing it will still stick around. |
| return; |
| } |
| |
| // Make sure we hide if our anchor goes away. |
| // TODO: This might be appropriate to push all the way down to PopupWindow, |
| // but it may have other side effects to investigate first. (Text editing handles, etc.) |
| final ViewTreeObserver vto = getViewTreeObserver(); |
| if (vto != null) { |
| final OnGlobalLayoutListener layoutListener = new OnGlobalLayoutListener() { |
| @Override |
| public void onGlobalLayout() { |
| if (!Spinner.this.isVisibleToUser()) { |
| dismiss(); |
| } else { |
| computeContentWidth(); |
| |
| // Use super.show here to update; we don't want to move the selected |
| // position or adjust other things that would be reset otherwise. |
| DropdownPopup.super.show(); |
| } |
| } |
| }; |
| vto.addOnGlobalLayoutListener(layoutListener); |
| setOnDismissListener(new OnDismissListener() { |
| @Override public void onDismiss() { |
| final ViewTreeObserver vto = getViewTreeObserver(); |
| if (vto != null) { |
| vto.removeOnGlobalLayoutListener(layoutListener); |
| } |
| } |
| }); |
| } |
| } |
| } |
| |
| } |
