Android横向ListView

深碍√TFBOYSˉ_ 2022-07-13 11:13 557阅读 0赞

在日常开发中经常会发现横向的ListView。下面讨论实现方案。
1.动态的添加布局。

  1. RelativeLayout view = (RelativeLayout) LayoutInflater.from(this)
  2.           .inflate(R.layout.demo, null);
  3. ListView.addView(view);

2.通过继承AdapterView（ListAdapter）自定义类实现
部分关键代码如下：
类名：HorizontalListView（这个类不是我实现的，我只是拿来用）

这里写图片描述
这里写图片描述

布局代码

  1. <HorizontalListView
  2.     android:id="@+id/listview"
  3.     android:layout_width="wrap_content"
  4.     android:layout_height="240dp"
  5.     android:clipToPadding="true"
  6.     android:paddingLeft="12dp"
  7.     app:dividerWidth="35dp"
  8.     />

继承自AdapterView（ListAdapter），用法和普通的ListView相似。

代码粘贴如下：

  1. package com.homelink.newlink.view;
  3. import android.annotation.SuppressLint;
  4. import android.annotation.TargetApi;
  5. import android.content.Context;
  6. import android.content.res.TypedArray;
  7. import android.database.DataSetObserver;
  8. import android.graphics.Canvas;
  9. import android.graphics.Rect;
  10. import android.graphics.drawable.Drawable;
  11. import android.os.Build;
  12. import android.os.Bundle;
  13. import android.os.Parcelable;
  14. import android.support.v4.view.ViewCompat;
  15. import android.support.v4.widget.EdgeEffectCompat;
  16. import android.util.AttributeSet;
  17. import android.view.GestureDetector;
  18. import android.view.HapticFeedbackConstants;
  19. import android.view.MotionEvent;
  20. import android.view.View;
  21. import android.view.ViewGroup;
  22. import android.widget.AdapterView;
  23. import android.widget.ListAdapter;
  24. import android.widget.ListView;
  25. import android.widget.ScrollView;
  26. import android.widget.Scroller;
  27. import com.homelink.newlink.R;
  28. import com.lianjia.common.utils.device.DensityUtil;
  29. import java.util.ArrayList;
  30. import java.util.LinkedList;
  31. import java.util.List;
  32. import java.util.Queue;
  34. /**
  35.  * Created by jou on 2017/1/4.
  36.  */
  38. public class HorizontalListView extends AdapterView<ListAdapter> {
  40.   /**
  41.    * Defines where to insert items into the ViewGroup, as defined in {@code ViewGroup
  42.    * #addViewInLayout(View, int, LayoutParams, boolean)}
  43.    */
  44.   private static final int INSERT_AT_END_OF_LIST = -1;
  45.   private static final int INSERT_AT_START_OF_LIST = 0;
  47.   /** The velocity to use for overscroll absorption */
  48.   private static final float FLING_DEFAULT_ABSORB_VELOCITY = 30f;
  50.   /** The friction amount to use for the fling tracker */
  51.   private static final float FLING_FRICTION = 0.009f;
  53.   /**
  54.    * Used for tracking the state data necessary to restore the HorizontalListView to its previous
  55.    * state after a rotation occurs
  56.    */
  57.   private static final String BUNDLE_ID_CURRENT_X = "BUNDLE_ID_CURRENT_X";
  59.   /**
  60.    * The bundle id of the parents state. Used to restore the parent's state after a rotation
  61.    * occurs
  62.    */
  63.   private static final String BUNDLE_ID_PARENT_STATE = "BUNDLE_ID_PARENT_STATE";
  65.   /** Tracks ongoing flings */
  66.   protected Scroller mFlingTracker = new Scroller(getContext());
  68.   /** Gesture listener to receive callbacks when gestures are detected */
  69.   private final GestureListener mGestureListener = new GestureListener();
  71.   /** Used for detecting gestures within this view so they can be handled */
  72.   private GestureDetector mGestureDetector;
  74.   /** This tracks the starting layout position of the leftmost view */
  75.   private int mDisplayOffset;
  77.   /** Holds a reference to the adapter bound to this view */
  78.   protected ListAdapter mAdapter;
  80.   /** Holds a cache of recycled views to be reused as needed */
  81.   private List<Queue<View>> mRemovedViewsCache = new ArrayList<Queue<View>>();
  83.   /** Flag used to mark when the adapters data has changed, so the view can be relaid out */
  84.   private boolean mDataChanged = false;
  86.   /** Temporary rectangle to be used for measurements */
  87.   private Rect mRect = new Rect();
  89.   /** Tracks the currently touched view, used to delegate touches to the view being touched */
  90.   private View mViewBeingTouched = null;
  92.   /** The width of the divider that will be used between list items */
  93.   private int mDividerWidth = 0;
  95.   /** The drawable that will be used as the list divider */
  96.   private Drawable mDivider = null;
  98.   /** The x position of the currently rendered view */
  99.   protected int mCurrentX;
  101.   /** The x position of the next to be rendered view */
  102.   protected int mNextX;
  104.   /** Used to hold the scroll position to restore to post rotate */
  105.   private Integer mRestoreX = null;
  107.   /**
  108.    * Tracks the maximum possible X position, stays at max value until last item is laid out and it
  109.    * can be determined
  110.    */
  111.   private int mMaxX = Integer.MAX_VALUE;
  113.   /** The adapter index of the leftmost view currently visible */
  114.   private int mLeftViewAdapterIndex;
  116.   /** The adapter index of the rightmost view currently visible */
  117.   private int mRightViewAdapterIndex;
  119.   /** This tracks the currently selected accessibility item */
  120.   private int mCurrentlySelectedAdapterIndex;
  122.   /**
  123.    * Callback interface to notify listener that the user has scrolled this view to the point that
  124.    * it is low on data.
  125.    */
  126.   private RunningOutOfDataListener mRunningOutOfDataListener = null;
  128.   /**
  129.    * This tracks the user value set of how many items from the end will be considered running out
  130.    * of data.
  131.    */
  132.   private int mRunningOutOfDataThreshold = 0;
  134.   /**
  135.    * Tracks if we have told the listener that we are running low on data. We only want to tell
  136.    * them once.
  137.    */
  138.   private boolean mHasNotifiedRunningLowOnData = false;
  140.   /**
  141.    * Callback interface to be invoked when the scroll state has changed.
  142.    */
  143.   private OnScrollStateChangedListener mOnScrollStateChangedListener = null;
  145.   /**
  146.    * Represents the current scroll state of this view. Needed so we can detect when the state
  147.    * changes so scroll listener can be notified.
  148.    */
  149.   private OnScrollStateChangedListener.ScrollState mCurrentScrollState =
  150.       OnScrollStateChangedListener.ScrollState.SCROLL_STATE_IDLE;
  152.   /**
  153.    * Tracks the state of the left edge glow.
  154.    */
  155.   private EdgeEffectCompat mEdgeGlowLeft;
  157.   /**
  158.    * Tracks the state of the right edge glow.
  159.    */
  160.   private EdgeEffectCompat mEdgeGlowRight;
  162.   /** The height measure spec for this view, used to help size children views */
  163.   private int mHeightMeasureSpec;
  165.   /** Used to track if a view touch should be blocked because it stopped a fling */
  166.   private boolean mBlockTouchAction = false;
  168.   /**
  169.    * Used to track if the parent vertically scrollable view has been told to
  170.    * DisallowInterceptTouchEvent
  171.    */
  172.   private boolean mIsParentVerticiallyScrollableViewDisallowingInterceptTouchEvent = false;
  174.   /**
  175.    * The listener that receives notifications when this view is clicked.
  176.    */
  177.   private OnClickListener mOnClickListener;
  179.   /**
  180.    * Recode the position of  press and loose
  181.    */
  182.   private MotionEvent mPressEvent;
  183.   private MotionEvent mLooseEvent;
  185.   /**
  186.    * MaoDian mode
  187.    */
  188.   private boolean mIsAnchorEnable;
  190.   /**
  191.    * Filing mode
  192.    */
  193.   private boolean mIsFilingEnable = true;
  195.   public HorizontalListView(Context context, AttributeSet attrs) {
  196.     super(context, attrs);
  197.     mEdgeGlowLeft = new EdgeEffectCompat(context);
  198.     mEdgeGlowRight = new EdgeEffectCompat(context);
  199.     mGestureDetector = new GestureDetector(context, mGestureListener);
  200.     bindGestureDetector();
  201.     initView();
  202.     retrieveXmlConfiguration(context, attrs);
  203.     setWillNotDraw(false);
  205.     // If the OS version is high enough then set the friction on the fling tracker */
  206.     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
  207.       HoneycombPlus.setFriction(mFlingTracker, FLING_FRICTION);
  208.     }
  209.   }
  211.   /** Registers the gesture detector to receive gesture notifications for this view */
  212.   private void bindGestureDetector() {
  213.     // Generic touch listener that can be applied to any view that needs to process gestures
  214.     final OnTouchListener gestureListenerHandler = new OnTouchListener() {
  215.       @Override public boolean onTouch(final View v, final MotionEvent event) {
  216.         // Delegate the touch event to our gesture detector
  217.         return mGestureDetector.onTouchEvent(event);
  218.       }
  219.     };
  221.     setOnTouchListener(gestureListenerHandler);
  222.   }
  224.   /**
  225.    * When this HorizontalListView is embedded within a vertical scrolling view it is important to
  226.    * disable the parent view from interacting with
  227.    * any touch events while the user is scrolling within this HorizontalListView. This will start
  228.    * at this view and go up the view tree looking
  229.    * for a vertical scrolling view. If one is found it will enable or disable parent touch
  230.    * interception.
  231.    *
  232.    * @param disallowIntercept If true the parent will be prevented from intercepting child touch
  233.    * events
  234.    */
  235.   private void requestParentListViewToNotInterceptTouchEvents(Boolean disallowIntercept) {
  236.     // Prevent calling this more than once needlessly
  237.     if (mIsParentVerticiallyScrollableViewDisallowingInterceptTouchEvent != disallowIntercept) {
  238.       View view = this;
  240.       while (view.getParent() instanceof View) {
  241.         // If the parent is a ListView or ScrollView then disallow intercepting of touch events
  242.         if (view.getParent() instanceof ListView || view.getParent() instanceof ScrollView) {
  243.           view.getParent().requestDisallowInterceptTouchEvent(disallowIntercept);
  244.           mIsParentVerticiallyScrollableViewDisallowingInterceptTouchEvent = disallowIntercept;
  245.           return;
  246.         }
  248.         view = (View) view.getParent();
  249.       }
  250.     }
  251.   }
  253.   /**
  254.    * Parse the XML configuration for this widget
  255.    *
  256.    * @param context Context used for extracting attributes
  257.    * @param attrs The Attribute Set containing the ColumnView attributes
  258.    */
  259.   private void retrieveXmlConfiguration(Context context, AttributeSet attrs) {
  260.     if (attrs != null) {
  261.       TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.HorizontalListView);
  263.       // Get the provided drawable from the XML
  264.       final Drawable d = a.getDrawable(R.styleable.HorizontalListView_android_divider);
  265.       if (d != null) {
  266.         // If a drawable is provided to use as the divider then use its intrinsic width for the divider width
  267.         setDivider(d);
  268.       }
  270.       // If a width is explicitly specified then use that width
  271.       final int dividerWidth =
  272.           a.getDimensionPixelSize(R.styleable.HorizontalListView_dividerWidth, 0);
  273.       if (dividerWidth != 0) {
  274.         setDividerWidth(dividerWidth);
  275.       }
  277.       a.recycle();
  278.     }
  279.   }
  281.   @Override public Parcelable onSaveInstanceState() {
  282.     Bundle bundle = new Bundle();
  284.     // Add the parent state to the bundle
  285.     bundle.putParcelable(BUNDLE_ID_PARENT_STATE, super.onSaveInstanceState());
  287.     // Add our state to the bundle
  288.     bundle.putInt(BUNDLE_ID_CURRENT_X, mCurrentX);
  290.     return bundle;
  291.   }
  293.   @Override public void onRestoreInstanceState(Parcelable state) {
  294.     if (state instanceof Bundle) {
  295.       Bundle bundle = (Bundle) state;
  297.       // Restore our state from the bundle
  298.       mRestoreX = Integer.valueOf((bundle.getInt(BUNDLE_ID_CURRENT_X)));
  300.       // Restore out parent's state from the bundle
  301.       super.onRestoreInstanceState(bundle.getParcelable(BUNDLE_ID_PARENT_STATE));
  302.     }
  303.   }
  305.   /**
  306.    * Sets the drawable that will be drawn between each item in the list. If the drawable does
  307.    * not have an intrinsic width, you should also call {@link #setDividerWidth(int)}
  308.    *
  309.    * @param divider The drawable to use.
  310.    */
  311.   public void setDivider(Drawable divider) {
  312.     mDivider = divider;
  314.     if (divider != null) {
  315.       setDividerWidth(divider.getIntrinsicWidth());
  316.     } else {
  317.       setDividerWidth(0);
  318.     }
  319.   }
  321.   /**
  322.    * Sets the width of the divider that will be drawn between each item in the list. Calling
  323.    * this will override the intrinsic width as set by {@link #setDivider(android.graphics.drawable.Drawable)}
  324.    *
  325.    * @param width The width of the divider in pixels.
  326.    */
  327.   public void setDividerWidth(int width) {
  328.     mDividerWidth = width;
  330.     // Force the view to rerender itself
  331.     requestLayout();
  332.     invalidate();
  333.   }
  335.   private void initView() {
  336.     mLeftViewAdapterIndex = -1;
  337.     mRightViewAdapterIndex = -1;
  338.     mDisplayOffset = 0;
  339.     mCurrentX = 0;
  340.     mNextX = 0;
  341.     mMaxX = Integer.MAX_VALUE;
  342.     setCurrentScrollState(OnScrollStateChangedListener.ScrollState.SCROLL_STATE_IDLE);
  343.   }
  345.   /**
  346.    * Will re-initialize the HorizontalListView to remove all child views rendered and reset to
  347.    * initial configuration.
  348.    */
  349.   private void reset() {
  350.     initView();
  351.     removeAllViewsInLayout();
  352.     requestLayout();
  353.   }
  355.   /** DataSetObserver used to capture adapter data change events */
  356.   private DataSetObserver mAdapterDataObserver = new DataSetObserver() {
  357.     @Override public void onChanged() {
  358.       mDataChanged = true;
  360.       // Clear so we can notify again as we run out of data
  361.       mHasNotifiedRunningLowOnData = false;
  363.       unpressTouchedChild();
  365.       // Invalidate and request layout to force this view to completely redraw itself
  366.       invalidate();
  367.       requestLayout();
  368.     }
  370.     @Override public void onInvalidated() {
  371.       // Clear so we can notify again as we run out of data
  372.       mHasNotifiedRunningLowOnData = false;
  374.       unpressTouchedChild();
  375.       reset();
  377.       // Invalidate and request layout to force this view to completely redraw itself
  378.       invalidate();
  379.       requestLayout();
  380.     }
  381.   };
  383.   @Override public void setSelection(int position) {
  384.     mCurrentlySelectedAdapterIndex = position;
  385.   }
  387.   @Override public View getSelectedView() {
  388.     return getChild(mCurrentlySelectedAdapterIndex);
  389.   }
  391.   @Override public void setAdapter(ListAdapter adapter) {
  392.     if (mAdapter != null) {
  393.       mAdapter.unregisterDataSetObserver(mAdapterDataObserver);
  394.     }
  396.     if (adapter != null) {
  397.       // Clear so we can notify again as we run out of data
  398.       mHasNotifiedRunningLowOnData = false;
  400.       mAdapter = adapter;
  401.       mAdapter.registerDataSetObserver(mAdapterDataObserver);
  402.     }
  404.     initializeRecycledViewCache(mAdapter.getViewTypeCount());
  405.     reset();
  406.   }
  408.   @Override public ListAdapter getAdapter() {
  409.     return mAdapter;
  410.   }
  412.   /**
  413.    * Will create and initialize a cache for the given number of different types of views.
  414.    *
  415.    * @param viewTypeCount - The total number of different views supported
  416.    */
  417.   private void initializeRecycledViewCache(int viewTypeCount) {
  418.     // The cache is created such that the response from mAdapter.getItemViewType is the array index to the correct cache for that item.
  419.     mRemovedViewsCache.clear();
  420.     for (int i = 0; i < viewTypeCount; i++) {
  421.       mRemovedViewsCache.add(new LinkedList<View>());
  422.     }
  423.   }
  425.   /**
  426.    * Returns a recycled view from the cache that can be reused, or null if one is not available.
  427.    */
  428.   private View getRecycledView(int adapterIndex) {
  429.     int itemViewType = mAdapter.getItemViewType(adapterIndex);
  431.     if (isItemViewTypeValid(itemViewType)) {
  432.       return mRemovedViewsCache.get(itemViewType).poll();
  433.     }
  435.     return null;
  436.   }
  438.   /**
  439.    * Adds the provided view to a recycled views cache.
  440.    */
  441.   private void recycleView(int adapterIndex, View view) {
  442.     // There is one Queue of views for each different type of view.
  443.     // Just add the view to the pile of other views of the same type.
  444.     // The order they are added and removed does not matter.
  445.     int itemViewType = mAdapter.getItemViewType(adapterIndex);
  446.     if (isItemViewTypeValid(itemViewType)) {
  447.       mRemovedViewsCache.get(itemViewType).offer(view);
  448.     }
  449.   }
  451.   private boolean isItemViewTypeValid(int itemViewType) {
  452.     return itemViewType < mRemovedViewsCache.size();
  453.   }
  455.   /** Adds a child to this viewgroup and measures it so it renders the correct size */
  456.   private void addAndMeasureChild(final View child, int viewPos) {
  457.     LayoutParams params = getLayoutParams(child);
  458.     addViewInLayout(child, viewPos, params, true);
  459.     measureChild(child);
  460.   }
  462.   /**
  463.    * Measure the provided child.
  464.    *
  465.    * @param child The child.
  466.    */
  467.   private void measureChild(View child) {
  468.     LayoutParams childLayoutParams = getLayoutParams(child);
  469.     int childHeightSpec =
  470.         ViewGroup.getChildMeasureSpec(mHeightMeasureSpec, getPaddingTop() + getPaddingBottom(),
  471.             childLayoutParams.height);
  473.     int childWidthSpec;
  474.     if (childLayoutParams.width > 0) {
  475.       childWidthSpec = MeasureSpec.makeMeasureSpec(childLayoutParams.width, MeasureSpec.EXACTLY);
  476.     } else {
  477.       childWidthSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
  478.     }
  480.     child.measure(childWidthSpec, childHeightSpec);
  481.   }
  483.   /** Gets a child's layout parameters, defaults if not available. */
  484.   private LayoutParams getLayoutParams(View child) {
  485.     LayoutParams layoutParams = child.getLayoutParams();
  486.     if (layoutParams == null) {
  487.       // Since this is a horizontal list view default to matching the parents height, and wrapping the width
  488.       layoutParams = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);
  489.     }
  491.     return layoutParams;
  492.   }
  494.   @SuppressLint("WrongCall") @Override
  495.   protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
  496.     super.onLayout(changed, left, top, right, bottom);
  498.     if (mAdapter == null) {
  499.       return;
  500.     }
  502.     // Force the OS to redraw this view
  503.     invalidate();
  505.     // If the data changed then reset everything and render from scratch at the same offset as last time
  506.     if (mDataChanged) {
  507.       int oldCurrentX = mCurrentX;
  508.       initView();
  509.       removeAllViewsInLayout();
  510.       mNextX = oldCurrentX;
  511.       mDataChanged = false;
  512.     }
  514.     // If restoring from a rotation
  515.     if (mRestoreX != null) {
  516.       mNextX = mRestoreX;
  517.       mRestoreX = null;
  518.     }
  520.     // If in a fling
  521.     if (mFlingTracker.computeScrollOffset()) {
  522.       // Compute the next position
  523.       mNextX = mFlingTracker.getCurrX();
  524.     }
  526.     // Prevent scrolling past 0 so you can't scroll past the end of the list to the left
  527.     if (mNextX < 0) {
  528.       mNextX = 0;
  530.       // Show an edge effect absorbing the current velocity
  531.       if (mEdgeGlowLeft.isFinished()) {
  532.         mEdgeGlowLeft.onAbsorb((int) determineFlingAbsorbVelocity());
  533.       }
  535.       mFlingTracker.forceFinished(true);
  536.       setCurrentScrollState(OnScrollStateChangedListener.ScrollState.SCROLL_STATE_IDLE);
  537.     } else if (mNextX > mMaxX) {
  538.       // Clip the maximum scroll position at mMaxX so you can't scroll past the end of the list to the right
  539.       mNextX = mMaxX;
  541.       // Show an edge effect absorbing the current velocity
  542.       if (mEdgeGlowRight.isFinished()) {
  543.         mEdgeGlowRight.onAbsorb((int) determineFlingAbsorbVelocity());
  544.       }
  546.       mFlingTracker.forceFinished(true);
  547.       setCurrentScrollState(OnScrollStateChangedListener.ScrollState.SCROLL_STATE_IDLE);
  548.     }
  550.     // Calculate our delta from the last time the view was drawn
  551.     int dx = mCurrentX - mNextX;
  552.     removeNonVisibleChildren(dx);
  553.     fillList(dx);
  554.     positionChildren(dx);
  556.     // Since the view has now been drawn, update our current position
  557.     mCurrentX = mNextX;
  559.     // If we have scrolled enough to lay out all views, then determine the maximum scroll position now
  560.     if (determineMaxX()) {
  561.       // Redo the layout pass since we now know the maximum scroll position
  562.       onLayout(changed, left, top, right, bottom);
  563.       return;
  564.     }
  566.     // If the fling has finished
  567.     if (mFlingTracker.isFinished()) {
  568.       // If the fling just ended
  569.       if (mCurrentScrollState == OnScrollStateChangedListener.ScrollState.SCROLL_STATE_FLING) {
  570.         setCurrentScrollState(OnScrollStateChangedListener.ScrollState.SCROLL_STATE_IDLE);
  571.       }
  572.     } else {
  573.       // Still in a fling so schedule the next frame
  574.       ViewCompat.postOnAnimation(this, mDelayedLayout);
  575.     }
  576.   }
  578.   @Override protected float getLeftFadingEdgeStrength() {
  579.     int horizontalFadingEdgeLength = getHorizontalFadingEdgeLength();
  581.     // If completely at the edge then disable the fading edge
  582.     if (mCurrentX == 0) {
  583.       return 0;
  584.     } else if (mCurrentX < horizontalFadingEdgeLength) {
  585.       // We are very close to the edge, so enable the fading edge proportional to the distance from the edge, and the width of the edge effect
  586.       return (float) mCurrentX / horizontalFadingEdgeLength;
  587.     } else {
  588.       // The current x position is more then the width of the fading edge so enable it fully.
  589.       return 1;
  590.     }
  591.   }
  593.   @Override protected float getRightFadingEdgeStrength() {
  594.     int horizontalFadingEdgeLength = getHorizontalFadingEdgeLength();
  596.     // If completely at the edge then disable the fading edge
  597.     if (mCurrentX == mMaxX) {
  598.       return 0;
  599.     } else if ((mMaxX - mCurrentX) < horizontalFadingEdgeLength) {
  600.       // We are very close to the edge, so enable the fading edge proportional to the distance from the ednge, and the width of the edge effect
  601.       return (float) (mMaxX - mCurrentX) / horizontalFadingEdgeLength;
  602.     } else {
  603.       // The distance from the maximum x position is more then the width of the fading edge so enable it fully.
  604.       return 1;
  605.     }
  606.   }
  608.   /** Determines the current fling absorb velocity */
  609.   private float determineFlingAbsorbVelocity() {
  610.     // If the OS version is high enough get the real velocity */
  611.     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
  612.       return IceCreamSandwichPlus.getCurrVelocity(mFlingTracker);
  613.     } else {
  614.       // Unable to get the velocity so just return a default.
  615.       // In actuality this is never used since EdgeEffectCompat does not draw anything unless the device is ICS+.
  616.       // Less then ICS EdgeEffectCompat essentially performs a NOP.
  617.       return FLING_DEFAULT_ABSORB_VELOCITY;
  618.     }
  619.   }
  621.   /** Use to schedule a request layout via a runnable */
  622.   private Runnable mDelayedLayout = new Runnable() {
  623.     @Override public void run() {
  624.       requestLayout();
  625.     }
  626.   };
  628.   @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  629.     super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  631.     // Cache off the measure spec
  632.     mHeightMeasureSpec = heightMeasureSpec;
  633.   }
  634.   /**
  635.    * Determine the Max X position. This is the farthest that the user can scroll the screen. Until
  636.    * the last adapter item has been
  637.    * laid out it is impossible to calculate; once that has occurred this will perform the
  638.    * calculation, and if necessary force a
  639.    * redraw and relayout of this view.
  640.    *
  641.    * @return true if the maxx position was just determined
  642.    */
  643.   private boolean determineMaxX() {
  644.     // If the last view has been laid out, then we can determine the maximum x position
  645.     if (isLastItemInAdapter(mRightViewAdapterIndex)) {
  646.       View rightView = getRightmostChild();
  648.       if (rightView != null) {
  649.         int oldMaxX = mMaxX;
  651.         // Determine the maximum x position
  652.         mMaxX = mCurrentX + (rightView.getRight() - getPaddingLeft()) - getRenderWidth();
  654.         // Handle the case where the views do not fill at least 1 screen
  655.         if (mMaxX < 0) {
  656.           mMaxX = 0;
  657.         }
  659.         if (mMaxX != oldMaxX) {
  660.           return true;
  661.         }
  662.       }
  663.     }
  665.     return false;
  666.   }
  668.   /** Adds children views to the left and right of the current views until the screen is full */
  669.   private void fillList(final int dx) {
  670.     // Get the rightmost child and determine its right edge
  671.     int edge = 0;
  672.     View child = getRightmostChild();
  673.     if (child != null) {
  674.       edge = child.getRight();
  675.     }
  677.     // Add new children views to the right, until past the edge of the screen
  678.     fillListRight(edge, dx);
  680.     // Get the leftmost child and determine its left edge
  681.     edge = 0;
  682.     child = getLeftmostChild();
  683.     if (child != null) {
  684.       edge = child.getLeft();
  685.     }
  687.     // Add new children views to the left, until past the edge of the screen
  688.     fillListLeft(edge, dx);
  689.   }
  691.   private void removeNonVisibleChildren(final int dx) {
  692.     View child = getLeftmostChild();
  694.     // Loop removing the leftmost child, until that child is on the screen
  695.     while (child != null && child.getRight() + dx <= 0) {
  696.       // The child is being completely removed so remove its width from the display offset and its divider if it has one.
  697.       // To remove add the size of the child and its divider (if it has one) to the offset.
  698.       // You need to add since its being removed from the left side, i.e. shifting the offset to the right.
  699.       mDisplayOffset += isLastItemInAdapter(mLeftViewAdapterIndex) ? child.getMeasuredWidth()
  700.           : mDividerWidth + child.getMeasuredWidth();
  702.       // Add the removed view to the cache
  703.       recycleView(mLeftViewAdapterIndex, child);
  705.       // Actually remove the view
  706.       removeViewInLayout(child);
  708.       // Keep track of the adapter index of the left most child
  709.       mLeftViewAdapterIndex++;
  711.       // Get the new leftmost child
  712.       child = getLeftmostChild();
  713.     }
  715.     child = getRightmostChild();
  717.     // Loop removing the rightmost child, until that child is on the screen
  718.     while (child != null && child.getLeft() + dx >= getWidth()) {
  719.       recycleView(mRightViewAdapterIndex, child);
  720.       removeViewInLayout(child);
  721.       mRightViewAdapterIndex--;
  722.       child = getRightmostChild();
  723.     }
  724.   }
  726.   private void fillListRight(int rightEdge, final int dx) {
  727.     // Loop adding views to the right until the screen is filled
  728.     while (rightEdge + dx + mDividerWidth < getWidth()
  729.         && mRightViewAdapterIndex + 1 < mAdapter.getCount()) {
  730.       mRightViewAdapterIndex++;
  732.       // If mLeftViewAdapterIndex < 0 then this is the first time a view is being added, and left == right
  733.       if (mLeftViewAdapterIndex < 0) {
  734.         mLeftViewAdapterIndex = mRightViewAdapterIndex;
  735.       }
  737.       // Get the view from the adapter, utilizing a cached view if one is available
  738.       View child =
  739.           mAdapter.getView(mRightViewAdapterIndex, getRecycledView(mRightViewAdapterIndex), this);
  740.       addAndMeasureChild(child, INSERT_AT_END_OF_LIST);
  742.       // If first view, then no divider to the left of it, otherwise add the space for the divider width
  743.       rightEdge += (mRightViewAdapterIndex == 0 ? 0 : mDividerWidth) + child.getMeasuredWidth();
  745.       // Check if we are running low on data so we can tell listeners to go get more
  746.       determineIfLowOnData();
  747.     }
  748.   }
  750.   private void fillListLeft(int leftEdge, final int dx) {
  751.     // Loop adding views to the left until the screen is filled
  752.     while (leftEdge + dx - mDividerWidth > 0 && mLeftViewAdapterIndex >= 1) {
  753.       mLeftViewAdapterIndex--;
  754.       View child =
  755.           mAdapter.getView(mLeftViewAdapterIndex, getRecycledView(mLeftViewAdapterIndex), this);
  756.       addAndMeasureChild(child, INSERT_AT_START_OF_LIST);
  758.       // If first view, then no divider to the left of it
  759.       leftEdge -= mLeftViewAdapterIndex == 0 ? child.getMeasuredWidth()
  760.           : mDividerWidth + child.getMeasuredWidth();
  762.       // If on a clean edge then just remove the child, otherwise remove the divider as well
  763.       mDisplayOffset -=
  764.           leftEdge + dx == 0 ? child.getMeasuredWidth() : mDividerWidth + child.getMeasuredWidth();
  765.     }
  766.   }
  768.   /** Loops through each child and positions them onto the screen */
  769.   private void positionChildren(final int dx) {
  770.     int childCount = getChildCount();
  772.     if (childCount > 0) {
  773.       mDisplayOffset += dx;
  774.       int leftOffset = mDisplayOffset;
  776.       // Loop each child view
  777.       for (int i = 0; i < childCount; i++) {
  778.         View child = getChildAt(i);
  779.         int left = leftOffset + getPaddingLeft();
  780.         int top = getPaddingTop();
  781.         int right = left + child.getMeasuredWidth();
  782.         int bottom = top + child.getMeasuredHeight();
  784.         // Layout the child
  785.         child.layout(left, top, right, bottom);
  787.         // Increment our offset by added child's size and divider width
  788.         leftOffset += child.getMeasuredWidth() + mDividerWidth;
  789.       }
  790.     }
  791.   }
  793.   /** Gets the current child that is leftmost on the screen. */
  794.   private View getLeftmostChild() {
  795.     return getChildAt(0);
  796.   }
  798.   /** Gets the current child that is rightmost on the screen. */
  799.   private View getRightmostChild() {
  800.     return getChildAt(getChildCount() - 1);
  801.   }
  803.   /**
  804.    * Finds a child view that is contained within this view, given the adapter index.
  805.    *
  806.    * @return View The child view, or or null if not found.
  807.    */
  808.   private View getChild(int adapterIndex) {
  809.     if (adapterIndex >= mLeftViewAdapterIndex && adapterIndex <= mRightViewAdapterIndex) {
  810.       return getChildAt(adapterIndex - mLeftViewAdapterIndex);
  811.     }
  813.     return null;
  814.   }
  816.   /**
  817.    * Returns the index of the child that contains the coordinates given.
  818.    * This is useful to determine which child has been touched.
  819.    * This can be used for a call to {@link #getChildAt(int)}
  820.    *
  821.    * @param x X-coordinate
  822.    * @param y Y-coordinate
  823.    * @return The index of the child that contains the coordinates. If no child is found then
  824.    * returns -1
  825.    */
  826.   private int getChildIndex(final int x, final int y) {
  827.     int childCount = getChildCount();
  829.     for (int index = 0; index < childCount; index++) {
  830.       getChildAt(index).getHitRect(mRect);
  831.       if (mRect.contains(x, y)) {
  832.         return index;
  833.       }
  834.     }
  836.     return -1;
  837.   }
  839.   /** Simple convenience method for determining if this index is the last index in the adapter */
  840.   private boolean isLastItemInAdapter(int index) {
  841.     return index == mAdapter.getCount() - 1;
  842.   }
  844.   /** Gets the height in px this view will be rendered. (padding removed) */
  845.   private int getRenderHeight() {
  846.     return getHeight() - getPaddingTop() - getPaddingBottom();
  847.   }
  849.   /** Gets the width in px this view will be rendered. (padding removed) */
  850.   private int getRenderWidth() {
  851.     return getWidth() - getPaddingLeft() - getPaddingRight();
  852.   }
  854.   /** Scroll to the provided offset */
  855.   public void scrollTo(int x) {
  856.     mFlingTracker.startScroll(mNextX, 0, x - mNextX, 0);
  857.     setCurrentScrollState(OnScrollStateChangedListener.ScrollState.SCROLL_STATE_FLING);
  858.     requestLayout();
  859.   }
  861.   @Override public int getFirstVisiblePosition() {
  862.     return mLeftViewAdapterIndex;
  863.   }
  865.   @Override public int getLastVisiblePosition() {
  866.     return mRightViewAdapterIndex;
  867.   }
  869.   /** Draws the overscroll edge glow effect on the left and right sides of the horizontal list */
  870.   private void drawEdgeGlow(Canvas canvas) {
  871.     if (mEdgeGlowLeft != null && !mEdgeGlowLeft.isFinished() && isEdgeGlowEnabled()) {
  872.       // The Edge glow is meant to come from the top of the screen, so rotate it to draw on the left side.
  873.       final int restoreCount = canvas.save();
  874.       final int height = getHeight();
  876.       canvas.rotate(-90, 0, 0);
  877.       canvas.translate(-height + getPaddingBottom(), 0);
  879.       mEdgeGlowLeft.setSize(getRenderHeight(), getRenderWidth());
  880.       if (mEdgeGlowLeft.draw(canvas)) {
  881.         invalidate();
  882.       }
  884.       canvas.restoreToCount(restoreCount);
  885.     } else if (mEdgeGlowRight != null && !mEdgeGlowRight.isFinished() && isEdgeGlowEnabled()) {
  886.       // The Edge glow is meant to come from the top of the screen, so rotate it to draw on the right side.
  887.       final int restoreCount = canvas.save();
  888.       final int width = getWidth();
  890.       canvas.rotate(90, 0, 0);
  891.       canvas.translate(getPaddingTop(), -width);
  892.       mEdgeGlowRight.setSize(getRenderHeight(), getRenderWidth());
  893.       if (mEdgeGlowRight.draw(canvas)) {
  894.         invalidate();
  895.       }
  897.       canvas.restoreToCount(restoreCount);
  898.     }
  899.   }
  901.   /** Draws the dividers that go in between the horizontal list view items */
  902.   private void drawDividers(Canvas canvas) {
  903.     final int count = getChildCount();
  905.     // Only modify the left and right in the loop, we set the top and bottom here since they are always the same
  906.     final Rect bounds = mRect;
  907.     mRect.top = getPaddingTop();
  908.     mRect.bottom = mRect.top + getRenderHeight();
  910.     // Draw the list dividers
  911.     for (int i = 0; i < count; i++) {
  912.       // Don't draw a divider to the right of the last item in the adapter
  913.       if (!(i == count - 1 && isLastItemInAdapter(mRightViewAdapterIndex))) {
  914.         View child = getChildAt(i);
  916.         bounds.left = child.getRight();
  917.         bounds.right = child.getRight() + mDividerWidth;
  919.         // Clip at the left edge of the screen
  920.         if (bounds.left < getPaddingLeft()) {
  921.           bounds.left = getPaddingLeft();
  922.         }
  924.         // Clip at the right edge of the screen
  925.         if (bounds.right > getWidth() - getPaddingRight()) {
  926.           bounds.right = getWidth() - getPaddingRight();
  927.         }
  929.         // Draw a divider to the right of the child
  930.         drawDivider(canvas, bounds);
  932.         // If the first view, determine if a divider should be shown to the left of it.
  933.         // A divider should be shown if the left side of this view does not fill to the left edge of the screen.
  934.         if (i == 0 && child.getLeft() > getPaddingLeft()) {
  935.           bounds.left = getPaddingLeft();
  936.           bounds.right = child.getLeft();
  937.           drawDivider(canvas, bounds);
  938.         }
  939.       }
  940.     }
  941.   }
  943.   /**
  944.    * Draws a divider in the given bounds.
  945.    *
  946.    * @param canvas The canvas to draw to.
  947.    * @param bounds The bounds of the divider.
  948.    */
  949.   private void drawDivider(Canvas canvas, Rect bounds) {
  950.     if (mDivider != null) {
  951.       mDivider.setBounds(bounds);
  952.       mDivider.draw(canvas);
  953.     }
  954.   }
  956.   @Override protected void onDraw(Canvas canvas) {
  957.     super.onDraw(canvas);
  958.     drawDividers(canvas);
  959.   }
  961.   @Override protected void dispatchDraw(Canvas canvas) {
  962.     super.dispatchDraw(canvas);
  963.     drawEdgeGlow(canvas);
  964.   }
  966.   @Override protected void dispatchSetPressed(boolean pressed) {
  967.     // Don't dispatch setPressed to our children. We call setPressed on ourselves to
  968.     // get the selector in the right state, but we don't want to press each child.
  969.   }
  971.   protected boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
  973.     if (mIsAnchorEnable && velocityX != 0) {
  974.       int scrollDistance = getWidth() - DensityUtil.dip2px(getContext(),30);
  975.       float distanceX = e1.getX() - e2.getX();
  976.       if (distanceX > 0) {
  977.         scrollTo((mLeftViewAdapterIndex + 1) * scrollDistance);
  978.       } else if (distanceX < 0) {
  979.         scrollTo((mRightViewAdapterIndex - 1) * scrollDistance);
  980.       }
  981.     } else {
  982.       mFlingTracker.fling(mNextX, 0, (int) -velocityX, 0, 0, mMaxX, 0, 0);
  983.     }
  984.     setCurrentScrollState(OnScrollStateChangedListener.ScrollState.SCROLL_STATE_FLING);
  985.     requestLayout();
  986.     return true;
  987.   }
  989.   protected boolean onDown(MotionEvent e) {
  990.     // If the user just caught a fling, then disable all touch actions until they release their finger
  991.     mBlockTouchAction = !mFlingTracker.isFinished();
  993.     // Allow a finger down event to catch a fling
  994.     mFlingTracker.forceFinished(true);
  995.     setCurrentScrollState(OnScrollStateChangedListener.ScrollState.SCROLL_STATE_IDLE);
  997.     unpressTouchedChild();
  999.     if (!mBlockTouchAction) {
  1000.       // Find the child that was pressed
  1001.       final int index = getChildIndex((int) e.getX(), (int) e.getY());
  1002.       if (index >= 0) {
  1003.         // Save off view being touched so it can later be released
  1004.         mViewBeingTouched = getChildAt(index);
  1006.         if (mViewBeingTouched != null) {
  1007.           // Set the view as pressed
  1008.           mViewBeingTouched.setPressed(true);
  1009.           refreshDrawableState();
  1010.         }
  1011.       }
  1012.     }
  1014.     return true;
  1015.   }
  1017.   /** If a view is currently pressed then unpress it */
  1018.   private void unpressTouchedChild() {
  1019.     if (mViewBeingTouched != null) {
  1020.       // Set the view as not pressed
  1021.       mViewBeingTouched.setPressed(false);
  1022.       refreshDrawableState();
  1024.       // Null out the view so we don't leak it
  1025.       mViewBeingTouched = null;
  1026.     }
  1027.   }
  1029.   private class GestureListener extends GestureDetector.SimpleOnGestureListener {
  1031.     @Override public boolean onDown(MotionEvent e) {
  1032.       return HorizontalListView.this.onDown(e);
  1033.     }
  1035.     @Override
  1036.     public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
  1037.       if (mIsFilingEnable) {
  1038.         HorizontalListView.this.onFling(e1, e2, velocityX, velocityY);
  1039.       }
  1040.       return true;
  1041.     }
  1043.     @Override
  1044.     public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
  1045.       // Lock the user into interacting just with this view
  1046.       requestParentListViewToNotInterceptTouchEvents(true);
  1048.       setCurrentScrollState(OnScrollStateChangedListener.ScrollState.SCROLL_STATE_TOUCH_SCROLL);
  1049.       unpressTouchedChild();
  1050.       mNextX += (int) distanceX;
  1051.       updateOverscrollAnimation(Math.round(distanceX));
  1052.       requestLayout();
  1053.       mPressEvent = e1;
  1054.       mLooseEvent = e2;
  1055.       return true;
  1056.     }
  1058.     @Override public boolean onSingleTapConfirmed(MotionEvent e) {
  1059.       unpressTouchedChild();
  1060.       OnItemClickListener onItemClickListener = getOnItemClickListener();
  1062.       final int index = getChildIndex((int) e.getX(), (int) e.getY());
  1064.       // If the tap is inside one of the child views, and we are not blocking touches
  1065.       if (index >= 0 && !mBlockTouchAction) {
  1066.         View child = getChildAt(index);
  1067.         int adapterIndex = mLeftViewAdapterIndex + index;
  1069.         if (onItemClickListener != null) {
  1070.           onItemClickListener.onItemClick(HorizontalListView.this, child, adapterIndex,
  1071.               mAdapter.getItemId(adapterIndex));
  1072.           return true;
  1073.         }
  1074.       }
  1076.       if (mOnClickListener != null && !mBlockTouchAction) {
  1077.         mOnClickListener.onClick(HorizontalListView.this);
  1078.       }
  1080.       return false;
  1081.     }
  1083.     @Override public void onLongPress(MotionEvent e) {
  1084.       unpressTouchedChild();
  1086.       final int index = getChildIndex((int) e.getX(), (int) e.getY());
  1087.       if (index >= 0 && !mBlockTouchAction) {
  1088.         View child = getChildAt(index);
  1089.         OnItemLongClickListener onItemLongClickListener = getOnItemLongClickListener();
  1090.         if (onItemLongClickListener != null) {
  1091.           int adapterIndex = mLeftViewAdapterIndex + index;
  1092.           boolean handled =
  1093.               onItemLongClickListener.onItemLongClick(HorizontalListView.this, child, adapterIndex,
  1094.                   mAdapter.getItemId(adapterIndex));
  1096.           if (handled) {
  1097.             // BZZZTT!!1!
  1098.             performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
  1099.           }
  1100.         }
  1101.       }
  1102.     }
  1103.   }
  1105.   @Override public boolean onTouchEvent(MotionEvent event) {
  1106.     // Detect when the user lifts their finger off the screen after a touch
  1107.     int scrollThreshold = (getWidth() - DensityUtil.dip2px(getContext(),90)) / 2;
  1108.     int scrollDistance = getWidth() - DensityUtil.dip2px(getContext(),30);
  1109.     if (event.getAction() == MotionEvent.ACTION_UP) {
  1110.       // If not flinging then we are idle now. The user just finished a finger scroll.
  1111.       if (mFlingTracker == null || mFlingTracker.isFinished()) {
  1112.         setCurrentScrollState(OnScrollStateChangedListener.ScrollState.SCROLL_STATE_IDLE);
  1113.       }
  1114.       if (mIsAnchorEnable && null != mPressEvent && null != mLooseEvent) {
  1115.         float distanceX = mPressEvent.getX() - mLooseEvent.getX();
  1116.         if (distanceX >= 0) {
  1117.           if (distanceX <= scrollThreshold) {
  1118.             scrollTo(mLeftViewAdapterIndex * scrollDistance);
  1119.           } else {
  1120.             scrollTo((mLeftViewAdapterIndex + 1) * scrollDistance);
  1121.           }
  1122.         } else {
  1123.           if (distanceX >= -scrollThreshold) {
  1124.             scrollTo(mRightViewAdapterIndex * scrollDistance);
  1125.           } else {
  1126.             scrollTo(mLeftViewAdapterIndex * scrollDistance);
  1127.           }
  1128.         }
  1129.       }
  1131.       // Allow the user to interact with parent views
  1132.       requestParentListViewToNotInterceptTouchEvents(false);
  1134.       releaseEdgeGlow();
  1135.     } else if (event.getAction() == MotionEvent.ACTION_CANCEL) {
  1136.       unpressTouchedChild();
  1137.       releaseEdgeGlow();
  1139.       // Allow the user to interact with parent views
  1140.       requestParentListViewToNotInterceptTouchEvents(false);
  1141.     }
  1143.     return super.onTouchEvent(event);
  1144.   }
  1146.   /** Release the EdgeGlow so it animates */
  1147.   private void releaseEdgeGlow() {
  1148.     if (mEdgeGlowLeft != null) {
  1149.       mEdgeGlowLeft.onRelease();
  1150.     }
  1152.     if (mEdgeGlowRight != null) {
  1153.       mEdgeGlowRight.onRelease();
  1154.     }
  1155.   }
  1157.   /**
  1158.    * Set MaoDian mode
  1159.    */
  1160.   public void enableAnchor(boolean isAnchorEnable) {
  1161.     mIsAnchorEnable = isAnchorEnable;
  1162.   }
  1164.   /**
  1165.    * Set Filing mode
  1166.    */
  1167.   public void enableFiling(boolean isFilingEnable) {
  1168.     mIsFilingEnable = isFilingEnable;
  1169.   }
  1171.   /**
  1172.    * Sets a listener to be called when the HorizontalListView has been scrolled to a point where
  1173.    * it is
  1174.    * running low on data. An example use case is wanting to auto download more data when the user
  1175.    * has scrolled to the point where only 10 items are left to be rendered off the right of the
  1176.    * screen. To get called back at that point just register with this function with a
  1177.    * numberOfItemsLeftConsideredLow value of 10. <br>
  1178.    * <br>
  1179.    * This will only be called once to notify that the HorizontalListView is running low on data.
  1180.    * Calling notifyDataSetChanged on the adapter will allow this to be called again once low on
  1181.    * data.
  1182.    *
  1183.    * @param listener The listener to be notified when the number of array adapters items left to
  1184.    * be shown is running low.
  1185.    * @param numberOfItemsLeftConsideredLow The number of array adapter items that have not yet
  1186.    * been displayed that is considered too low.
  1187.    */
  1188.   public void setRunningOutOfDataListener(RunningOutOfDataListener listener,
  1189.       int numberOfItemsLeftConsideredLow) {
  1190.     mRunningOutOfDataListener = listener;
  1191.     mRunningOutOfDataThreshold = numberOfItemsLeftConsideredLow;
  1192.   }
  1194.   /**
  1195.    * This listener is used to allow notification when the HorizontalListView is running low on
  1196.    * data to display.
  1197.    */
  1198.   public static interface RunningOutOfDataListener {
  1200.     /**
  1201.      * Called when the HorizontalListView is running out of data and has reached at least the
  1202.      * provided threshold.
  1203.      */
  1204.     void onRunningOutOfData();
  1205.   }
  1207.   /**
  1208.    * Determines if we are low on data and if so will call to notify the listener, if there is
  1209.    * one,
  1210.    * that we are running low on data.
  1211.    */
  1212.   private void determineIfLowOnData() {
  1213.     // Check if the threshold has been reached and a listener is registered
  1214.     if (mRunningOutOfDataListener != null && mAdapter != null &&
  1215.         mAdapter.getCount() - (mRightViewAdapterIndex + 1) < mRunningOutOfDataThreshold) {
  1217.       // Prevent notification more than once
  1218.       if (!mHasNotifiedRunningLowOnData) {
  1219.         mHasNotifiedRunningLowOnData = true;
  1220.         mRunningOutOfDataListener.onRunningOutOfData();
  1221.       }
  1222.     }
  1223.   }
  1225.   /**
  1226.    * Register a callback to be invoked when the HorizontalListView has been clicked.
  1227.    *
  1228.    * @param listener The callback that will be invoked.
  1229.    */
  1230.   @Override public void setOnClickListener(OnClickListener listener) {
  1231.     mOnClickListener = listener;
  1232.   }
  1234.   /**
  1235.    * Interface definition for a callback to be invoked when the view scroll state has changed.
  1236.    */
  1237.   public interface OnScrollStateChangedListener {
  1239.     public enum ScrollState {
  1240.       /**
  1241.        * The view is not scrolling. Note navigating the list using the trackball counts as
  1242.        * being
  1243.        * in the idle state since these transitions are not animated.
  1244.        */
  1245.       SCROLL_STATE_IDLE,
  1247.       /**
  1248.        * The user is scrolling using touch, and their finger is still on the screen
  1249.        */
  1250.       SCROLL_STATE_TOUCH_SCROLL,
  1252.       /**
  1253.        * The user had previously been scrolling using touch and had performed a fling. The
  1254.        * animation is now coasting to a stop
  1255.        */
  1256.       SCROLL_STATE_FLING
  1257.     }
  1259.     /**
  1260.      * Callback method to be invoked when the scroll state changes.
  1261.      *
  1262.      * @param scrollState The current scroll state.
  1263.      */
  1264.     public void onScrollStateChanged(ScrollState scrollState);
  1265.   }
  1267.   /**
  1268.    * Sets a listener to be invoked when the scroll state has changed.
  1269.    *
  1270.    * @param listener The listener to be invoked.
  1271.    */
  1272.   public void setOnScrollStateChangedListener(OnScrollStateChangedListener listener) {
  1273.     mOnScrollStateChangedListener = listener;
  1274.   }
  1276.   /**
  1277.    * Call to set the new scroll state.
  1278.    * If it has changed and a listener is registered then it will be notified.
  1279.    */
  1280.   private void setCurrentScrollState(OnScrollStateChangedListener.ScrollState newScrollState) {
  1281.     // If the state actually changed then notify listener if there is one
  1282.     if (mCurrentScrollState != newScrollState && mOnScrollStateChangedListener != null) {
  1283.       mOnScrollStateChangedListener.onScrollStateChanged(newScrollState);
  1284.     }
  1286.     mCurrentScrollState = newScrollState;
  1287.   }
  1289.   /**
  1290.    * Updates the over scroll animation based on the scrolled offset.
  1291.    *
  1292.    * @param scrolledOffset The scroll offset
  1293.    */
  1294.   private void updateOverscrollAnimation(final int scrolledOffset) {
  1295.     if (mEdgeGlowLeft == null || mEdgeGlowRight == null) {
  1296.       return;
  1297.     }
  1299.     // Calculate where the next scroll position would be
  1300.     int nextScrollPosition = mCurrentX + scrolledOffset;
  1302.     // If not currently in a fling (Don't want to allow fling offset updates to cause over scroll animation)
  1303.     if (mFlingTracker == null || mFlingTracker.isFinished()) {
  1304.       // If currently scrolled off the left side of the list and the adapter is not empty
  1305.       if (nextScrollPosition < 0) {
  1307.         // Calculate the amount we have scrolled since last frame
  1308.         int overscroll = Math.abs(scrolledOffset);
  1310.         // Tell the edge glow to redraw itself at the new offset
  1311.         mEdgeGlowLeft.onPull((float) overscroll / getRenderWidth());
  1313.         // Cancel animating right glow
  1314.         if (!mEdgeGlowRight.isFinished()) {
  1315.           mEdgeGlowRight.onRelease();
  1316.         }
  1317.       } else if (nextScrollPosition > mMaxX) {
  1318.         // Scrolled off the right of the list
  1320.         // Calculate the amount we have scrolled since last frame
  1321.         int overscroll = Math.abs(scrolledOffset);
  1323.         // Tell the edge glow to redraw itself at the new offset
  1324.         mEdgeGlowRight.onPull((float) overscroll / getRenderWidth());
  1326.         // Cancel animating left glow
  1327.         if (!mEdgeGlowLeft.isFinished()) {
  1328.           mEdgeGlowLeft.onRelease();
  1329.         }
  1330.       }
  1331.     }
  1332.   }
  1334.   /**
  1335.    * Checks if the edge glow should be used enabled.
  1336.    * The glow is not enabled unless there are more views than can fit on the screen at one time.
  1337.    */
  1338.   private boolean isEdgeGlowEnabled() {
  1339.     if (mAdapter == null || mAdapter.isEmpty()) {
  1340.       return false;
  1341.     }
  1343.     // If the maxx is more then zero then the user can scroll, so the edge effects should be shown
  1344.     return mMaxX > 0;
  1345.   }
  1347.   @TargetApi(11)
  1348.   /** Wrapper class to protect access to API version 11 and above features */ private static final class HoneycombPlus {
  1350.     static {
  1351.       if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
  1352.         throw new RuntimeException("Should not get to HoneycombPlus class unless sdk is >= 11!");
  1353.       }
  1354.     }
  1356.     /** Sets the friction for the provided scroller */
  1357.     public static void setFriction(Scroller scroller, float friction) {
  1358.       if (scroller != null) {
  1359.         scroller.setFriction(friction);
  1360.       }
  1361.     }
  1362.   }
  1364.   @TargetApi(14)
  1365.   /** Wrapper class to protect access to API version 14 and above features */ private static final class IceCreamSandwichPlus {
  1367.     static {
  1368.       if (Build.VERSION.SDK_INT < Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
  1369.         throw new RuntimeException(
  1370.             "Should not get to IceCreamSandwichPlus class unless sdk is >= 14!");
  1371.       }
  1372.     }
  1374.     /** Gets the velocity for the provided scroller */
  1375.     public static float getCurrVelocity(Scroller scroller) {
  1376.       return scroller.getCurrVelocity();
  1377.     }
  1378.   }
  1379. }

发表评论

表情：
评论列表 （有 0 条评论，557人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Android ListView

    ListView作为android的经常使用的控件，在使用时，经常会忘记一些使用要点，这里记录一下一些使用过程中的需求，以便后面使用查询： 设置 监听 使用

    素颜马尾好姑娘i素颜马尾好姑娘i/ 0 赞/ 310 阅读