Java tutorial
/* * 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 android.annotation.DrawableRes; import android.annotation.Nullable; import android.annotation.TestApi; import android.annotation.UnsupportedAppUsage; import android.annotation.Widget; import android.app.AlertDialog; 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.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.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); 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 */ 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 */ 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 */ 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 */ 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 */ 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(); } @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 */ 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); } } } @Override public PointerIcon onResolvePointerIcon(MotionEvent event, int pointerIndex) { if (getPointerIcon() == null && isClickable() && isEnabled()) { return PointerIcon.getSystemIcon(getContext(), PointerIcon.TYPE_HAND); } 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 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 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 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); } } }); } } } }