The Tor Browser: mobile/android/base/widget/TwoWayView.java@b8a032363ba2 (annotated)

mobile/android/base/widget/TwoWayView.java@b8a032363ba2 (annotated)

mobile/android/base/widget/TwoWayView.java

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /*
  * Copyright (C) 2013 Lucas Rocha
  *
  * This code is based on bits and pieces of Android's AbsListView,
  * Listview, and StaggeredGridView.
  *
  * Copyright (C) 2012 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 org.mozilla.gecko.widget;
 import org.mozilla.gecko.R;
 import android.annotation.TargetApi;
 import android.content.Context;
 import android.content.res.TypedArray;
 import android.database.DataSetObserver;
 import android.graphics.Canvas;
 import android.graphics.Rect;
 import android.graphics.drawable.Drawable;
 import android.graphics.drawable.TransitionDrawable;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.os.SystemClock;
 import android.support.v4.util.LongSparseArray;
 import android.support.v4.util.SparseArrayCompat;
 import android.support.v4.view.AccessibilityDelegateCompat;
 import android.support.v4.view.KeyEventCompat;
 import android.support.v4.view.MotionEventCompat;
 import android.support.v4.view.VelocityTrackerCompat;
 import android.support.v4.view.ViewCompat;
 import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat;
 import android.support.v4.widget.EdgeEffectCompat;
 import android.util.AttributeSet;
 import android.util.Log;
 import android.util.SparseBooleanArray;
 import android.view.ContextMenu.ContextMenuInfo;
 import android.view.FocusFinder;
 import android.view.HapticFeedbackConstants;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.SoundEffectConstants;
 import android.view.VelocityTracker;
 import android.view.View;
 import android.view.ViewConfiguration;
 import android.view.ViewGroup;
 import android.view.ViewParent;
 import android.view.ViewTreeObserver;
 import android.view.accessibility.AccessibilityEvent;
 import android.view.accessibility.AccessibilityNodeInfo;
 import android.widget.AdapterView;
 import android.widget.Checkable;
 import android.widget.ListAdapter;
 import android.widget.Scroller;
 import java.util.ArrayList;
 import java.util.List;
 /*
  * Implementation Notes:
  *
  * Some terminology:
  *
  *     index    - index of the items that are currently visible
  *     position - index of the items in the cursor
  *
  * Given the bi-directional nature of this view, the source code
  * usually names variables with 'start' to mean 'top' or 'left'; and
  * 'end' to mean 'bottom' or 'right', depending on the current
  * orientation of the widget.
  */
 /**
  * A view that shows items in a vertical or horizontal scrolling list.
  * The items come from the {@link ListAdapter} associated with this view.
  */
 public class TwoWayView extends AdapterView<ListAdapter> implements
         ViewTreeObserver.OnTouchModeChangeListener {
     private static final String LOGTAG = "TwoWayView";
     private static final int NO_POSITION = -1;
     private static final int INVALID_POINTER = -1;
     public static final int[] STATE_NOTHING = new int[] { 0 };
     private static final int TOUCH_MODE_REST = -1;
     private static final int TOUCH_MODE_DOWN = 0;
     private static final int TOUCH_MODE_TAP = 1;
     private static final int TOUCH_MODE_DONE_WAITING = 2;
     private static final int TOUCH_MODE_DRAGGING = 3;
     private static final int TOUCH_MODE_FLINGING = 4;
     private static final int TOUCH_MODE_OVERSCROLL = 5;
     private static final int TOUCH_MODE_UNKNOWN = -1;
     private static final int TOUCH_MODE_ON = 0;
     private static final int TOUCH_MODE_OFF = 1;
     private static final int LAYOUT_NORMAL = 0;
     private static final int LAYOUT_FORCE_TOP = 1;
     private static final int LAYOUT_SET_SELECTION = 2;
     private static final int LAYOUT_FORCE_BOTTOM = 3;
     private static final int LAYOUT_SPECIFIC = 4;
     private static final int LAYOUT_SYNC = 5;
     private static final int LAYOUT_MOVE_SELECTION = 6;
     private static final int SYNC_SELECTED_POSITION = 0;
     private static final int SYNC_FIRST_POSITION = 1;
     private static final int SYNC_MAX_DURATION_MILLIS = 100;
     private static final int CHECK_POSITION_SEARCH_DISTANCE = 20;
     private static final float MAX_SCROLL_FACTOR = 0.33f;
     private static final int MIN_SCROLL_PREVIEW_PIXELS = 10;
     public static enum ChoiceMode {
         NONE,
         SINGLE,
         MULTIPLE
     }
     public static enum Orientation {
         HORIZONTAL,
         VERTICAL;
     };
     private ListAdapter mAdapter;
     private boolean mIsVertical;
     private int mItemMargin;
     private boolean mInLayout;
     private boolean mBlockLayoutRequests;
     private boolean mIsAttached;
     private final RecycleBin mRecycler;
     private AdapterDataSetObserver mDataSetObserver;
     private boolean mItemsCanFocus;
     final boolean[] mIsScrap = new boolean[1];
     private boolean mDataChanged;
     private int mItemCount;
     private int mOldItemCount;
     private boolean mHasStableIds;
     private boolean mAreAllItemsSelectable;
     private int mFirstPosition;
     private int mSpecificStart;
     private SavedState mPendingSync;
     private final int mTouchSlop;
     private final int mMaximumVelocity;
     private final int mFlingVelocity;
     private float mLastTouchPos;
     private float mTouchRemainderPos;
     private int mActivePointerId;
     private final Rect mTempRect;
     private final ArrowScrollFocusResult mArrowScrollFocusResult;
     private Rect mTouchFrame;
     private int mMotionPosition;
     private CheckForTap mPendingCheckForTap;
     private CheckForLongPress mPendingCheckForLongPress;
     private CheckForKeyLongPress mPendingCheckForKeyLongPress;
     private PerformClick mPerformClick;
     private Runnable mTouchModeReset;
     private int mResurrectToPosition;
     private boolean mIsChildViewEnabled;
     private boolean mDrawSelectorOnTop;
     private Drawable mSelector;
     private int mSelectorPosition;
     private final Rect mSelectorRect;
     private int mOverScroll;
     private final int mOverscrollDistance;
     private boolean mDesiredFocusableState;
     private boolean mDesiredFocusableInTouchModeState;
     private SelectionNotifier mSelectionNotifier;
     private boolean mNeedSync;
     private int mSyncMode;
     private int mSyncPosition;
     private long mSyncRowId;
     private long mSyncHeight;
     private int mSelectedStart;
     private int mNextSelectedPosition;
     private long mNextSelectedRowId;
     private int mSelectedPosition;
     private long mSelectedRowId;
     private int mOldSelectedPosition;
     private long mOldSelectedRowId;
     private ChoiceMode mChoiceMode;
     private int mCheckedItemCount;
     private SparseBooleanArray mCheckStates;
     LongSparseArray<Integer> mCheckedIdStates;
     private ContextMenuInfo mContextMenuInfo;
     private int mLayoutMode;
     private int mTouchMode;
     private int mLastTouchMode;
     private VelocityTracker mVelocityTracker;
     private final Scroller mScroller;
     private EdgeEffectCompat mStartEdge;
     private EdgeEffectCompat mEndEdge;
     private OnScrollListener mOnScrollListener;
     private int mLastScrollState;
     private View mEmptyView;
     private ListItemAccessibilityDelegate mAccessibilityDelegate;
     private int mLastAccessibilityScrollEventFromIndex;
     private int mLastAccessibilityScrollEventToIndex;
     public interface OnScrollListener {
         /**
          * The view is not scrolling. Note navigating the list using the trackball counts as
          * being in the idle state since these transitions are not animated.
          */
         public static int SCROLL_STATE_IDLE = 0;
         /**
          * The user is scrolling using touch, and their finger is still on the screen
          */
         public static int SCROLL_STATE_TOUCH_SCROLL = 1;
         /**
          * The user had previously been scrolling using touch and had performed a fling. The
          * animation is now coasting to a stop
          */
         public static int SCROLL_STATE_FLING = 2;
         /**
          * Callback method to be invoked while the list view or grid view is being scrolled. If the
          * view is being scrolled, this method will be called before the next frame of the scroll is
          * rendered. In particular, it will be called before any calls to
          * {@link Adapter#getView(int, View, ViewGroup)}.
          *
          * @param view The view whose scroll state is being reported
          *
          * @param scrollState The current scroll state. One of {@link #SCROLL_STATE_IDLE},
          * {@link #SCROLL_STATE_TOUCH_SCROLL} or {@link #SCROLL_STATE_IDLE}.
          */
         public void onScrollStateChanged(TwoWayView view, int scrollState);
         /**
          * Callback method to be invoked when the list or grid has been scrolled. This will be
          * called after the scroll has completed
          * @param view The view whose scroll state is being reported
          * @param firstVisibleItem the index of the first visible cell (ignore if
          *        visibleItemCount == 0)
          * @param visibleItemCount the number of visible cells
          * @param totalItemCount the number of items in the list adaptor
          */
         public void onScroll(TwoWayView view, int firstVisibleItem, int visibleItemCount,
                 int totalItemCount);
     }
     /**
      * A RecyclerListener is used to receive a notification whenever a View is placed
      * inside the RecycleBin's scrap heap. This listener is used to free resources
      * associated to Views placed in the RecycleBin.
      *
      * @see TwoWayView.RecycleBin
      * @see TwoWayView#setRecyclerListener(TwoWayView.RecyclerListener)
      */
     public static interface RecyclerListener {
         /**
          * Indicates that the specified View was moved into the recycler's scrap heap.
          * The view is not displayed on screen any more and any expensive resource
          * associated with the view should be discarded.
          *
          * @param view
          */
         void onMovedToScrapHeap(View view);
     }
     public TwoWayView(Context context) {
         this(context, null);
     }
     public TwoWayView(Context context, AttributeSet attrs) {
         this(context, attrs, 0);
     }
     public TwoWayView(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
         mNeedSync = false;
         mVelocityTracker = null;
         mLayoutMode = LAYOUT_NORMAL;
         mTouchMode = TOUCH_MODE_REST;
         mLastTouchMode = TOUCH_MODE_UNKNOWN;
         mIsAttached = false;
         mContextMenuInfo = null;
         mOnScrollListener = null;
         mLastScrollState = OnScrollListener.SCROLL_STATE_IDLE;
         final ViewConfiguration vc = ViewConfiguration.get(context);
         mTouchSlop = vc.getScaledTouchSlop();
         mMaximumVelocity = vc.getScaledMaximumFlingVelocity();
         mFlingVelocity = vc.getScaledMinimumFlingVelocity();
         mOverscrollDistance = getScaledOverscrollDistance(vc);
         mOverScroll = 0;
         mScroller = new Scroller(context);
         mIsVertical = true;
         mItemsCanFocus = false;
         mTempRect = new Rect();
         mArrowScrollFocusResult = new ArrowScrollFocusResult();
         mSelectorPosition = INVALID_POSITION;
         mSelectorRect = new Rect();
         mSelectedStart = 0;
         mResurrectToPosition = INVALID_POSITION;
         mSelectedStart = 0;
         mNextSelectedPosition = INVALID_POSITION;
         mNextSelectedRowId = INVALID_ROW_ID;
         mSelectedPosition = INVALID_POSITION;
         mSelectedRowId = INVALID_ROW_ID;
         mOldSelectedPosition = INVALID_POSITION;
         mOldSelectedRowId = INVALID_ROW_ID;
         mChoiceMode = ChoiceMode.NONE;
         mCheckedItemCount = 0;
         mCheckedIdStates = null;
         mCheckStates = null;
         mRecycler = new RecycleBin();
         mDataSetObserver = null;
         mAreAllItemsSelectable = true;
         mStartEdge = null;
         mEndEdge = null;
         setClickable(true);
         setFocusableInTouchMode(true);
         setWillNotDraw(false);
         setAlwaysDrawnWithCacheEnabled(false);
         setWillNotDraw(false);
         setClipToPadding(false);
         ViewCompat.setOverScrollMode(this, ViewCompat.OVER_SCROLL_IF_CONTENT_SCROLLS);
         TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.TwoWayView, defStyle, 0);
         initializeScrollbars(a);
         mDrawSelectorOnTop = a.getBoolean(
                 R.styleable.TwoWayView_android_drawSelectorOnTop, false);
         Drawable d = a.getDrawable(R.styleable.TwoWayView_android_listSelector);
         if (d != null) {
             setSelector(d);
         }
         int orientation = a.getInt(R.styleable.TwoWayView_android_orientation, -1);
         if (orientation >= 0) {
             setOrientation(Orientation.values()[orientation]);
         }
         int choiceMode = a.getInt(R.styleable.TwoWayView_android_choiceMode, -1);
         if (choiceMode >= 0) {
             setChoiceMode(ChoiceMode.values()[choiceMode]);
         }
         a.recycle();
         updateScrollbarsDirection();
     }
     public void setOrientation(Orientation orientation) {
         final boolean isVertical = (orientation.compareTo(Orientation.VERTICAL) == 0);
         if (mIsVertical == isVertical) {
             return;
         }
         mIsVertical = isVertical;
         updateScrollbarsDirection();
         resetState();
         mRecycler.clear();
         requestLayout();
     }
     public Orientation getOrientation() {
         return (mIsVertical ? Orientation.VERTICAL : Orientation.HORIZONTAL);
     }
     public void setItemMargin(int itemMargin) {
         if (mItemMargin == itemMargin) {
             return;
         }
         mItemMargin = itemMargin;
         requestLayout();
     }
     public int getItemMargin() {
         return mItemMargin;
     }
     /**
      * Indicates that the views created by the ListAdapter can contain focusable
      * items.
      *
      * @param itemsCanFocus true if items can get focus, false otherwise
      */
     public void setItemsCanFocus(boolean itemsCanFocus) {
         mItemsCanFocus = itemsCanFocus;
         if (!itemsCanFocus) {
             setDescendantFocusability(ViewGroup.FOCUS_BLOCK_DESCENDANTS);
         }
     }
     /**
      * @return Whether the views created by the ListAdapter can contain focusable
      * items.
      */
     public boolean getItemsCanFocus() {
         return mItemsCanFocus;
     }
     /**
      * Set the listener that will receive notifications every time the list scrolls.
      *
      * @param l the scroll listener
      */
     public void setOnScrollListener(OnScrollListener l) {
         mOnScrollListener = l;
         invokeOnItemScrollListener();
     }
     /**
      * Sets the recycler listener to be notified whenever a View is set aside in
      * the recycler for later reuse. This listener can be used to free resources
      * associated to the View.
      *
      * @param listener The recycler listener to be notified of views set aside
      *        in the recycler.
      *
      * @see TwoWayView.RecycleBin
      * @see TwoWayView.RecyclerListener
      */
     public void setRecyclerListener(RecyclerListener l) {
         mRecycler.mRecyclerListener = l;
     }
     /**
      * Controls whether the selection highlight drawable should be drawn on top of the item or
      * behind it.
      *
      * @param onTop If true, the selector will be drawn on the item it is highlighting. The default
      *        is false.
      *
      * @attr ref android.R.styleable#AbsListView_drawSelectorOnTop
      */
     public void setDrawSelectorOnTop(boolean drawSelectorOnTop) {
         mDrawSelectorOnTop = drawSelectorOnTop;
     }
     /**
      * Set a Drawable that should be used to highlight the currently selected item.
      *
      * @param resID A Drawable resource to use as the selection highlight.
      *
      * @attr ref android.R.styleable#AbsListView_listSelector
      */
     public void setSelector(int resID) {
         setSelector(getResources().getDrawable(resID));
     }
     /**
      * Set a Drawable that should be used to highlight the currently selected item.
      *
      * @param selector A Drawable to use as the selection highlight.
      *
      * @attr ref android.R.styleable#AbsListView_listSelector
      */
     public void setSelector(Drawable selector) {
         if (mSelector != null) {
             mSelector.setCallback(null);
             unscheduleDrawable(mSelector);
         }
         mSelector = selector;
         Rect padding = new Rect();
         selector.getPadding(padding);
         selector.setCallback(this);
         updateSelectorState();
     }
     /**
      * Returns the selector {@link android.graphics.drawable.Drawable} that is used to draw the
      * selection in the list.
      *
      * @return the drawable used to display the selector
      */
     public Drawable getSelector() {
         return mSelector;
     }
     /**
      * {@inheritDoc}
      */
     @Override
     public int getSelectedItemPosition() {
         return mNextSelectedPosition;
     }
     /**
      * {@inheritDoc}
      */
     @Override
     public long getSelectedItemId() {
         return mNextSelectedRowId;
     }
     /**
      * Returns the number of items currently selected. This will only be valid
      * if the choice mode is not {@link #CHOICE_MODE_NONE} (default).
      *
      * <p>To determine the specific items that are currently selected, use one of
      * the <code>getChecked*</code> methods.
      *
      * @return The number of items currently selected
      *
      * @see #getCheckedItemPosition()
      * @see #getCheckedItemPositions()
      * @see #getCheckedItemIds()
      */
     public int getCheckedItemCount() {
         return mCheckedItemCount;
     }
     /**
      * Returns the checked state of the specified position. The result is only
      * valid if the choice mode has been set to {@link #CHOICE_MODE_SINGLE}
      * or {@link #CHOICE_MODE_MULTIPLE}.
      *
      * @param position The item whose checked state to return
      * @return The item's checked state or <code>false</code> if choice mode
      *         is invalid
      *
      * @see #setChoiceMode(int)
      */
     public boolean isItemChecked(int position) {
         if (mChoiceMode.compareTo(ChoiceMode.NONE) == 0 && mCheckStates != null) {
             return mCheckStates.get(position);
         }
         return false;
     }
     /**
      * Returns the currently checked item. The result is only valid if the choice
      * mode has been set to {@link #CHOICE_MODE_SINGLE}.
      *
      * @return The position of the currently checked item or
      *         {@link #INVALID_POSITION} if nothing is selected
      *
      * @see #setChoiceMode(int)
      */
     public int getCheckedItemPosition() {
         if (mChoiceMode.compareTo(ChoiceMode.SINGLE) == 0 &&
                 mCheckStates != null && mCheckStates.size() == 1) {
             return mCheckStates.keyAt(0);
         }
         return INVALID_POSITION;
     }
     /**
      * Returns the set of checked items in the list. The result is only valid if
      * the choice mode has not been set to {@link #CHOICE_MODE_NONE}.
      *
      * @return  A SparseBooleanArray which will return true for each call to
      *          get(int position) where position is a position in the list,
      *          or <code>null</code> if the choice mode is set to
      *          {@link #CHOICE_MODE_NONE}.
      */
     public SparseBooleanArray getCheckedItemPositions() {
         if (mChoiceMode.compareTo(ChoiceMode.NONE) != 0) {
             return mCheckStates;
         }
         return null;
     }
     /**
      * Returns the set of checked items ids. The result is only valid if the
      * choice mode has not been set to {@link #CHOICE_MODE_NONE} and the adapter
      * has stable IDs. ({@link ListAdapter#hasStableIds()} == {@code true})
      *
      * @return A new array which contains the id of each checked item in the
      *         list.
      */
     public long[] getCheckedItemIds() {
         if (mChoiceMode.compareTo(ChoiceMode.NONE) == 0 ||
                 mCheckedIdStates == null || mAdapter == null) {
             return new long[0];
         }
         final LongSparseArray<Integer> idStates = mCheckedIdStates;
         final int count = idStates.size();
         final long[] ids = new long[count];
         for (int i = 0; i < count; i++) {
             ids[i] = idStates.keyAt(i);
         }
         return ids;
     }
     /**
      * Sets the checked state of the specified position. The is only valid if
      * the choice mode has been set to {@link #CHOICE_MODE_SINGLE} or
      * {@link #CHOICE_MODE_MULTIPLE}.
      *
      * @param position The item whose checked state is to be checked
      * @param value The new checked state for the item
      */
     public void setItemChecked(int position, boolean value) {
         if (mChoiceMode.compareTo(ChoiceMode.NONE) == 0) {
             return;
         }
         if (mChoiceMode.compareTo(ChoiceMode.MULTIPLE) == 0) {
             boolean oldValue = mCheckStates.get(position);
             mCheckStates.put(position, value);
             if (mCheckedIdStates != null && mAdapter.hasStableIds()) {
                 if (value) {
                     mCheckedIdStates.put(mAdapter.getItemId(position), position);
                 } else {
                     mCheckedIdStates.delete(mAdapter.getItemId(position));
                 }
             }
             if (oldValue != value) {
                 if (value) {
                     mCheckedItemCount++;
                 } else {
                     mCheckedItemCount--;
                 }
             }
         } else {
             boolean updateIds = mCheckedIdStates != null && mAdapter.hasStableIds();
             // Clear all values if we're checking something, or unchecking the currently
             // selected item
             if (value || isItemChecked(position)) {
                 mCheckStates.clear();
                 if (updateIds) {
                     mCheckedIdStates.clear();
                 }
             }
             // This may end up selecting the value we just cleared but this way
             // we ensure length of mCheckStates is 1, a fact getCheckedItemPosition relies on
             if (value) {
                 mCheckStates.put(position, true);
                 if (updateIds) {
                     mCheckedIdStates.put(mAdapter.getItemId(position), position);
                 }
                 mCheckedItemCount = 1;
             } else if (mCheckStates.size() == 0 || !mCheckStates.valueAt(0)) {
                 mCheckedItemCount = 0;
             }
         }
         // Do not generate a data change while we are in the layout phase
         if (!mInLayout && !mBlockLayoutRequests) {
             mDataChanged = true;
             rememberSyncState();
             requestLayout();
         }
     }
     /**
      * Clear any choices previously set
      */
     public void clearChoices() {
         if (mCheckStates != null) {
             mCheckStates.clear();
         }
         if (mCheckedIdStates != null) {
             mCheckedIdStates.clear();
         }
         mCheckedItemCount = 0;
     }
     /**
      * @see #setChoiceMode(int)
      *
      * @return The current choice mode
      */
     public ChoiceMode getChoiceMode() {
         return mChoiceMode;
     }
     /**
      * Defines the choice behavior for the List. By default, Lists do not have any choice behavior
      * ({@link #CHOICE_MODE_NONE}). By setting the choiceMode to {@link #CHOICE_MODE_SINGLE}, the
      * List allows up to one item to  be in a chosen state. By setting the choiceMode to
      * {@link #CHOICE_MODE_MULTIPLE}, the list allows any number of items to be chosen.
      *
      * @param choiceMode One of {@link #CHOICE_MODE_NONE}, {@link #CHOICE_MODE_SINGLE}, or
      * {@link #CHOICE_MODE_MULTIPLE}
      */
     public void setChoiceMode(ChoiceMode choiceMode) {
         mChoiceMode = choiceMode;
         if (mChoiceMode.compareTo(ChoiceMode.NONE) != 0) {
             if (mCheckStates == null) {
                 mCheckStates = new SparseBooleanArray();
             }
             if (mCheckedIdStates == null && mAdapter != null && mAdapter.hasStableIds()) {
                 mCheckedIdStates = new LongSparseArray<Integer>();
             }
         }
     }
     @Override
     public ListAdapter getAdapter() {
         return mAdapter;
     }
     @Override
     public void setAdapter(ListAdapter adapter) {
         if (mAdapter != null && mDataSetObserver != null) {
             mAdapter.unregisterDataSetObserver(mDataSetObserver);
         }
         resetState();
         mRecycler.clear();
         mAdapter = adapter;
         mDataChanged = true;
         mOldSelectedPosition = INVALID_POSITION;
         mOldSelectedRowId = INVALID_ROW_ID;
         if (mCheckStates != null) {
             mCheckStates.clear();
         }
         if (mCheckedIdStates != null) {
             mCheckedIdStates.clear();
         }
         if (mAdapter != null) {
             mOldItemCount = mItemCount;
             mItemCount = adapter.getCount();
             mDataSetObserver = new AdapterDataSetObserver();
             mAdapter.registerDataSetObserver(mDataSetObserver);
             mRecycler.setViewTypeCount(adapter.getViewTypeCount());
             mHasStableIds = adapter.hasStableIds();
             mAreAllItemsSelectable = adapter.areAllItemsEnabled();
             if (mChoiceMode.compareTo(ChoiceMode.NONE) != 0 && mHasStableIds &&
                     mCheckedIdStates == null) {
                 mCheckedIdStates = new LongSparseArray<Integer>();
             }
             final int position = lookForSelectablePosition(0);
             setSelectedPositionInt(position);
             setNextSelectedPositionInt(position);
             if (mItemCount == 0) {
                 checkSelectionChanged();
             }
         } else {
             mItemCount = 0;
             mHasStableIds = false;
             mAreAllItemsSelectable = true;
             checkSelectionChanged();
         }
         checkFocus();
         requestLayout();
     }
     @Override
     public int getFirstVisiblePosition() {
         return mFirstPosition;
     }
     @Override
     public int getLastVisiblePosition() {
         return mFirstPosition + getChildCount() - 1;
     }
     @Override
     public int getCount() {
         return mItemCount;
     }
     @Override
     public int getPositionForView(View view) {
         View child = view;
         try {
             View v;
             while (!(v = (View) child.getParent()).equals(this)) {
                 child = v;
             }
         } catch (ClassCastException e) {
             // We made it up to the window without find this list view
             return INVALID_POSITION;
         }
         // Search the children for the list item
         final int childCount = getChildCount();
         for (int i = 0; i < childCount; i++) {
             if (getChildAt(i).equals(child)) {
                 return mFirstPosition + i;
             }
         }
         // Child not found!
         return INVALID_POSITION;
     }
     @Override
     public void getFocusedRect(Rect r) {
         View view = getSelectedView();
         if (view != null && view.getParent() == this) {
             // The focused rectangle of the selected view offset into the
             // coordinate space of this view.
             view.getFocusedRect(r);
             offsetDescendantRectToMyCoords(view, r);
         } else {
             super.getFocusedRect(r);
         }
     }
     @Override
     protected void onFocusChanged(boolean gainFocus, int direction, Rect previouslyFocusedRect) {
         super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);
         if (gainFocus && mSelectedPosition < 0 && !isInTouchMode()) {
             if (!mIsAttached && mAdapter != null) {
                 // Data may have changed while we were detached and it's valid
                 // to change focus while detached. Refresh so we don't die.
                 mDataChanged = true;
                 mOldItemCount = mItemCount;
                 mItemCount = mAdapter.getCount();
             }
             resurrectSelection();
         }
         final ListAdapter adapter = mAdapter;
         int closetChildIndex = INVALID_POSITION;
         int closestChildStart = 0;
         if (adapter != null && gainFocus && previouslyFocusedRect != null) {
             previouslyFocusedRect.offset(getScrollX(), getScrollY());
             // Don't cache the result of getChildCount or mFirstPosition here,
             // it could change in layoutChildren.
             if (adapter.getCount() < getChildCount() + mFirstPosition) {
                 mLayoutMode = LAYOUT_NORMAL;
                 layoutChildren();
             }
             // Figure out which item should be selected based on previously
             // focused rect.
             Rect otherRect = mTempRect;
             int minDistance = Integer.MAX_VALUE;
             final int childCount = getChildCount();
             final int firstPosition = mFirstPosition;
             for (int i = 0; i < childCount; i++) {
                 // Only consider selectable views
                 if (!adapter.isEnabled(firstPosition + i)) {
                     continue;
                 }
                 View other = getChildAt(i);
                 other.getDrawingRect(otherRect);
                 offsetDescendantRectToMyCoords(other, otherRect);
                 int distance = getDistance(previouslyFocusedRect, otherRect, direction);
                 if (distance < minDistance) {
                     minDistance = distance;
                     closetChildIndex = i;
                     closestChildStart = (mIsVertical ? other.getTop() : other.getLeft());
                 }
             }
         }
         if (closetChildIndex >= 0) {
             setSelectionFromOffset(closetChildIndex + mFirstPosition, closestChildStart);
         } else {
             requestLayout();
         }
     }
     @Override
     protected void onAttachedToWindow() {
         super.onAttachedToWindow();
         final ViewTreeObserver treeObserver = getViewTreeObserver();
         treeObserver.addOnTouchModeChangeListener(this);
         if (mAdapter != null && mDataSetObserver == null) {
             mDataSetObserver = new AdapterDataSetObserver();
             mAdapter.registerDataSetObserver(mDataSetObserver);
             // Data may have changed while we were detached. Refresh.
             mDataChanged = true;
             mOldItemCount = mItemCount;
             mItemCount = mAdapter.getCount();
         }
         mIsAttached = true;
     }
     @Override
     protected void onDetachedFromWindow() {
         super.onDetachedFromWindow();
         // Detach any view left in the scrap heap
         mRecycler.clear();
         final ViewTreeObserver treeObserver = getViewTreeObserver();
         treeObserver.removeOnTouchModeChangeListener(this);
         if (mAdapter != null) {
             mAdapter.unregisterDataSetObserver(mDataSetObserver);
             mDataSetObserver = null;
         }
         if (mPerformClick != null) {
             removeCallbacks(mPerformClick);
         }
         if (mTouchModeReset != null) {
             removeCallbacks(mTouchModeReset);
             mTouchModeReset.run();
         }
         mIsAttached = false;
     }
     @Override
     public void onWindowFocusChanged(boolean hasWindowFocus) {
         super.onWindowFocusChanged(hasWindowFocus);
         final int touchMode = isInTouchMode() ? TOUCH_MODE_ON : TOUCH_MODE_OFF;
         if (!hasWindowFocus) {
             if (touchMode == TOUCH_MODE_OFF) {
                 // Remember the last selected element
                 mResurrectToPosition = mSelectedPosition;
             }
         } else {
             // If we changed touch mode since the last time we had focus
             if (touchMode != mLastTouchMode && mLastTouchMode != TOUCH_MODE_UNKNOWN) {
                 // If we come back in trackball mode, we bring the selection back
                 if (touchMode == TOUCH_MODE_OFF) {
                     // This will trigger a layout
                     resurrectSelection();
                 // If we come back in touch mode, then we want to hide the selector
                 } else {
                     hideSelector();
                     mLayoutMode = LAYOUT_NORMAL;
                     layoutChildren();
                 }
             }
         }
         mLastTouchMode = touchMode;
     }
     @Override
     protected void onOverScrolled(int scrollX, int scrollY, boolean clampedX, boolean clampedY) {
         boolean needsInvalidate = false;
         if (mIsVertical && mOverScroll != scrollY) {
             onScrollChanged(getScrollX(), scrollY, getScrollX(), mOverScroll);
             mOverScroll = scrollY;
             needsInvalidate = true;
         } else if (!mIsVertical && mOverScroll != scrollX) {
             onScrollChanged(scrollX, getScrollY(), mOverScroll, getScrollY());
             mOverScroll = scrollX;
             needsInvalidate = true;
         }
         if (needsInvalidate) {
             invalidate();
             awakenScrollbarsInternal();
         }
     }
     @TargetApi(9)
     private boolean overScrollByInternal(int deltaX, int deltaY,
             int scrollX, int scrollY,
             int scrollRangeX, int scrollRangeY,
             int maxOverScrollX, int maxOverScrollY,
             boolean isTouchEvent) {
         if (Build.VERSION.SDK_INT < 9) {
             return false;
         }
         return super.overScrollBy(deltaX, deltaY, scrollX, scrollY, scrollRangeX,
                 scrollRangeY, maxOverScrollX, maxOverScrollY, isTouchEvent);
     }
     @Override
     @TargetApi(9)
     public void setOverScrollMode(int mode) {
         if (Build.VERSION.SDK_INT < 9) {
             return;
         }
         if (mode != ViewCompat.OVER_SCROLL_NEVER) {
             if (mStartEdge == null) {
                 Context context = getContext();
                 mStartEdge = new EdgeEffectCompat(context);
                 mEndEdge = new EdgeEffectCompat(context);
             }
         } else {
             mStartEdge = null;
             mEndEdge = null;
         }
         super.setOverScrollMode(mode);
     }
     public int pointToPosition(int x, int y) {
         Rect frame = mTouchFrame;
         if (frame == null) {
             mTouchFrame = new Rect();
             frame = mTouchFrame;
         }
         final int count = getChildCount();
         for (int i = count - 1; i >= 0; i--) {
             final View child = getChildAt(i);
             if (child.getVisibility() == View.VISIBLE) {
                 child.getHitRect(frame);
                 if (frame.contains(x, y)) {
                     return mFirstPosition + i;
                 }
             }
         }
         return INVALID_POSITION;
     }
     @Override
     protected int computeVerticalScrollExtent() {
         final int count = getChildCount();
         if (count == 0) {
             return 0;
         }
         int extent = count * 100;
         View child = getChildAt(0);
         final int childTop = child.getTop();
         int childHeight = child.getHeight();
         if (childHeight > 0) {
             extent += (childTop * 100) / childHeight;
         }
         child = getChildAt(count - 1);
         final int childBottom = child.getBottom();
         childHeight = child.getHeight();
         if (childHeight > 0) {
             extent -= ((childBottom - getHeight()) * 100) / childHeight;
         }
         return extent;
     }
     @Override
     protected int computeHorizontalScrollExtent() {
         final int count = getChildCount();
         if (count == 0) {
             return 0;
         }
         int extent = count * 100;
         View child = getChildAt(0);
         final int childLeft = child.getLeft();
         int childWidth = child.getWidth();
         if (childWidth > 0) {
             extent += (childLeft * 100) / childWidth;
         }
         child = getChildAt(count - 1);
         final int childRight = child.getRight();
         childWidth = child.getWidth();
         if (childWidth > 0) {
             extent -= ((childRight - getWidth()) * 100) / childWidth;
         }
         return extent;
     }
     @Override
     protected int computeVerticalScrollOffset() {
         final int firstPosition = mFirstPosition;
         final int childCount = getChildCount();
         if (firstPosition < 0 || childCount == 0) {
             return 0;
         }
         final View child = getChildAt(0);
         final int childTop = child.getTop();
         int childHeight = child.getHeight();
         if (childHeight > 0) {
             return Math.max(firstPosition * 100 - (childTop * 100) / childHeight, 0);
         }
         return 0;
     }
     @Override
     protected int computeHorizontalScrollOffset() {
         final int firstPosition = mFirstPosition;
         final int childCount = getChildCount();
         if (firstPosition < 0 || childCount == 0) {
             return 0;
         }
         final View child = getChildAt(0);
         final int childLeft = child.getLeft();
         int childWidth = child.getWidth();
         if (childWidth > 0) {
             return Math.max(firstPosition * 100 - (childLeft * 100) / childWidth, 0);
         }
         return 0;
     }
     @Override
     protected int computeVerticalScrollRange() {
         int result = Math.max(mItemCount * 100, 0);
         if (mIsVertical && mOverScroll != 0) {
             // Compensate for overscroll
             result += Math.abs((int) ((float) mOverScroll / getHeight() * mItemCount * 100));
         }
         return result;
     }
     @Override
     protected int computeHorizontalScrollRange() {
         int result = Math.max(mItemCount * 100, 0);
         if (!mIsVertical && mOverScroll != 0) {
             // Compensate for overscroll
             result += Math.abs((int) ((float) mOverScroll / getWidth() * mItemCount * 100));
         }
         return result;
     }
     @Override
     public boolean showContextMenuForChild(View originalView) {
         final int longPressPosition = getPositionForView(originalView);
         if (longPressPosition >= 0) {
             final long longPressId = mAdapter.getItemId(longPressPosition);
             boolean handled = false;
             OnItemLongClickListener listener = getOnItemLongClickListener();
             if (listener != null) {
                 handled = listener.onItemLongClick(TwoWayView.this, originalView,
                         longPressPosition, longPressId);
             }
             if (!handled) {
                 mContextMenuInfo = createContextMenuInfo(
                         getChildAt(longPressPosition - mFirstPosition),
                         longPressPosition, longPressId);
                 handled = super.showContextMenuForChild(originalView);
             }
             return handled;
         }
         return false;
     }
     @Override
     public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
         if (disallowIntercept) {
             recycleVelocityTracker();
         }
         super.requestDisallowInterceptTouchEvent(disallowIntercept);
     }
     @Override
     public boolean onInterceptTouchEvent(MotionEvent ev) {
         if (!mIsAttached) {
             return false;
         }
         final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
         switch (action) {
         case MotionEvent.ACTION_DOWN:
             initOrResetVelocityTracker();
             mVelocityTracker.addMovement(ev);
             mScroller.abortAnimation();
             final float x = ev.getX();
             final float y = ev.getY();
             mLastTouchPos = (mIsVertical ? y : x);
             final int motionPosition = findMotionRowOrColumn((int) mLastTouchPos);
             mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
             mTouchRemainderPos = 0;
             if (mTouchMode == TOUCH_MODE_FLINGING) {
                 return true;
             } else if (motionPosition >= 0) {
                 mMotionPosition = motionPosition;
                 mTouchMode = TOUCH_MODE_DOWN;
             }
             break;
         case MotionEvent.ACTION_MOVE: {
             if (mTouchMode != TOUCH_MODE_DOWN) {
                 break;
             }
             initVelocityTrackerIfNotExists();
             mVelocityTracker.addMovement(ev);
             final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
             if (index < 0) {
                 Log.e(LOGTAG, "onInterceptTouchEvent could not find pointer with id " +
                         mActivePointerId + " - did TwoWayView receive an inconsistent " +
                         "event stream?");
                 return false;
             }
             final float pos;
             if (mIsVertical) {
                 pos = MotionEventCompat.getY(ev, index);
             } else {
                 pos = MotionEventCompat.getX(ev, index);
             }
             final float diff = pos - mLastTouchPos + mTouchRemainderPos;
             final int delta = (int) diff;
             mTouchRemainderPos = diff - delta;
             if (maybeStartScrolling(delta)) {
                 return true;
             }
             break;
         }
         case MotionEvent.ACTION_CANCEL:
         case MotionEvent.ACTION_UP:
             mActivePointerId = INVALID_POINTER;
             mTouchMode = TOUCH_MODE_REST;
             recycleVelocityTracker();
             reportScrollStateChange(OnScrollListener.SCROLL_STATE_IDLE);
             break;
         }
         return false;
     }
     @Override
     public boolean onTouchEvent(MotionEvent ev) {
         if (!isEnabled()) {
             // A disabled view that is clickable still consumes the touch
             // events, it just doesn't respond to them.
             return isClickable() || isLongClickable();
         }
         if (!mIsAttached) {
             return false;
         }
         boolean needsInvalidate = false;
         initVelocityTrackerIfNotExists();
         mVelocityTracker.addMovement(ev);
         final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
         switch (action) {
         case MotionEvent.ACTION_DOWN: {
             if (mDataChanged) {
                 break;
             }
             mVelocityTracker.clear();
             mScroller.abortAnimation();
             final float x = ev.getX();
             final float y = ev.getY();
             mLastTouchPos = (mIsVertical ? y : x);
             int motionPosition = pointToPosition((int) x, (int) y);
             mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
             mTouchRemainderPos = 0;
             if (mDataChanged) {
                 break;
             }
             if (mTouchMode == TOUCH_MODE_FLINGING) {
                 mTouchMode = TOUCH_MODE_DRAGGING;
                 reportScrollStateChange(OnScrollListener.SCROLL_STATE_TOUCH_SCROLL);
                 motionPosition = findMotionRowOrColumn((int) mLastTouchPos);
                 return true;
             } else if (mMotionPosition >= 0 && mAdapter.isEnabled(mMotionPosition)) {
                 mTouchMode = TOUCH_MODE_DOWN;
                 triggerCheckForTap();
             }
             mMotionPosition = motionPosition;
             break;
         }
         case MotionEvent.ACTION_MOVE: {
             final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
             if (index < 0) {
                 Log.e(LOGTAG, "onInterceptTouchEvent could not find pointer with id " +
                         mActivePointerId + " - did TwoWayView receive an inconsistent " +
                         "event stream?");
                 return false;
             }
             final float pos;
             if (mIsVertical) {
                 pos = MotionEventCompat.getY(ev, index);
             } else {
                 pos = MotionEventCompat.getX(ev, index);
             }
             if (mDataChanged) {
                 // Re-sync everything if data has been changed
                 // since the scroll operation can query the adapter.
                 layoutChildren();
             }
             final float diff = pos - mLastTouchPos + mTouchRemainderPos;
             final int delta = (int) diff;
             mTouchRemainderPos = diff - delta;
             switch (mTouchMode) {
             case TOUCH_MODE_DOWN:
             case TOUCH_MODE_TAP:
             case TOUCH_MODE_DONE_WAITING:
                 // Check if we have moved far enough that it looks more like a
                 // scroll than a tap
                 maybeStartScrolling(delta);
                 break;
             case TOUCH_MODE_DRAGGING:
             case TOUCH_MODE_OVERSCROLL:
                 mLastTouchPos = pos;
                 maybeScroll(delta);
                 break;
             }
             break;
         }
         case MotionEvent.ACTION_CANCEL:
             cancelCheckForTap();
             mTouchMode = TOUCH_MODE_REST;
             reportScrollStateChange(OnScrollListener.SCROLL_STATE_IDLE);
             setPressed(false);
             View motionView = this.getChildAt(mMotionPosition - mFirstPosition);
             if (motionView != null) {
                 motionView.setPressed(false);
             }
             if (mStartEdge != null && mEndEdge != null) {
                 needsInvalidate = mStartEdge.onRelease() | mEndEdge.onRelease();
             }
             recycleVelocityTracker();
             break;
         case MotionEvent.ACTION_UP: {
             switch (mTouchMode) {
             case TOUCH_MODE_DOWN:
             case TOUCH_MODE_TAP:
             case TOUCH_MODE_DONE_WAITING: {
                 final int motionPosition = mMotionPosition;
                 final View child = getChildAt(motionPosition - mFirstPosition);
                 final float x = ev.getX();
                 final float y = ev.getY();
                 boolean inList = false;
                 if (mIsVertical) {
                     inList = x > getPaddingLeft() && x < getWidth() - getPaddingRight();
                 } else {
                     inList = y > getPaddingTop() && y < getHeight() - getPaddingBottom();
                 }
                 if (child != null && !child.hasFocusable() && inList) {
                     if (mTouchMode != TOUCH_MODE_DOWN) {
                         child.setPressed(false);
                     }
                     if (mPerformClick == null) {
                         mPerformClick = new PerformClick();
                     }
                     final PerformClick performClick = mPerformClick;
                     performClick.mClickMotionPosition = motionPosition;
                     performClick.rememberWindowAttachCount();
                     mResurrectToPosition = motionPosition;
                     if (mTouchMode == TOUCH_MODE_DOWN || mTouchMode == TOUCH_MODE_TAP) {
                         if (mTouchMode == TOUCH_MODE_DOWN) {
                             cancelCheckForTap();
                         } else {
                             cancelCheckForLongPress();
                         }
                         mLayoutMode = LAYOUT_NORMAL;
                         if (!mDataChanged && mAdapter.isEnabled(motionPosition)) {
                             mTouchMode = TOUCH_MODE_TAP;
                             setPressed(true);
                             positionSelector(mMotionPosition, child);
                             child.setPressed(true);
                             if (mSelector != null) {
                                 Drawable d = mSelector.getCurrent();
                                 if (d != null && d instanceof TransitionDrawable) {
                                     ((TransitionDrawable) d).resetTransition();
                                 }
                             }
                             if (mTouchModeReset != null) {
                                 removeCallbacks(mTouchModeReset);
                             }
                             mTouchModeReset = new Runnable() {
                                 @Override
                                 public void run() {
                                     mTouchMode = TOUCH_MODE_REST;
                                     setPressed(false);
                                     child.setPressed(false);
                                     if (!mDataChanged) {
                                         performClick.run();
                                     }
                                     mTouchModeReset = null;
                                 }
                             };
                             postDelayed(mTouchModeReset,
                                     ViewConfiguration.getPressedStateDuration());
                         } else {
                             mTouchMode = TOUCH_MODE_REST;
                             updateSelectorState();
                         }
                     } else if (!mDataChanged && mAdapter.isEnabled(motionPosition)) {
                         performClick.run();
                     }
                 }
                 mTouchMode = TOUCH_MODE_REST;
                 updateSelectorState();
                 break;
             }
             case TOUCH_MODE_DRAGGING:
                 if (contentFits()) {
                     mTouchMode = TOUCH_MODE_REST;
                     reportScrollStateChange(OnScrollListener.SCROLL_STATE_IDLE);
                     break;
                 }
                 mVelocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
                 final float velocity;
                 if (mIsVertical) {
                     velocity = VelocityTrackerCompat.getYVelocity(mVelocityTracker,
                             mActivePointerId);
                 } else {
                     velocity = VelocityTrackerCompat.getXVelocity(mVelocityTracker,
                             mActivePointerId);
                 }
                 if (Math.abs(velocity) >= mFlingVelocity) {
                     mTouchMode = TOUCH_MODE_FLINGING;
                     reportScrollStateChange(OnScrollListener.SCROLL_STATE_FLING);
                     mScroller.fling(0, 0,
                                     (int) (mIsVertical ? 0 : velocity),
                                     (int) (mIsVertical ? velocity : 0),
                                     (mIsVertical ? 0 : Integer.MIN_VALUE),
                                     (mIsVertical ? 0 : Integer.MAX_VALUE),
                                     (mIsVertical ? Integer.MIN_VALUE : 0),
                                     (mIsVertical ? Integer.MAX_VALUE : 0));
                     mLastTouchPos = 0;
                     needsInvalidate = true;
                 } else {
                     mTouchMode = TOUCH_MODE_REST;
                     reportScrollStateChange(OnScrollListener.SCROLL_STATE_IDLE);
                 }
                 break;
             case TOUCH_MODE_OVERSCROLL:
                 mTouchMode = TOUCH_MODE_REST;
                 reportScrollStateChange(OnScrollListener.SCROLL_STATE_IDLE);
                 break;
             }
             cancelCheckForTap();
             cancelCheckForLongPress();
             setPressed(false);
             if (mStartEdge != null && mEndEdge != null) {
                 needsInvalidate |= mStartEdge.onRelease() | mEndEdge.onRelease();
             }
             recycleVelocityTracker();
             break;
         }
         }
         if (needsInvalidate) {
             ViewCompat.postInvalidateOnAnimation(this);
         }
         return true;
     }
     @Override
     public void onTouchModeChanged(boolean isInTouchMode) {
         if (isInTouchMode) {
             // Get rid of the selection when we enter touch mode
             hideSelector();
             // Layout, but only if we already have done so previously.
             // (Otherwise may clobber a LAYOUT_SYNC layout that was requested to restore
             // state.)
             if (getWidth() > 0 && getHeight() > 0 && getChildCount() > 0) {
                 layoutChildren();
             }
             updateSelectorState();
         } else {
             final int touchMode = mTouchMode;
             if (touchMode == TOUCH_MODE_OVERSCROLL) {
                 if (mOverScroll != 0) {
                     mOverScroll = 0;
                     finishEdgeGlows();
                     invalidate();
                 }
             }
         }
     }
     @Override
     public boolean onKeyDown(int keyCode, KeyEvent event) {
         return handleKeyEvent(keyCode, 1, event);
     }
     @Override
     public boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event) {
         return handleKeyEvent(keyCode, repeatCount, event);
     }
     @Override
     public boolean onKeyUp(int keyCode, KeyEvent event) {
         return handleKeyEvent(keyCode, 1, event);
     }
     @Override
     public void sendAccessibilityEvent(int eventType) {
         // Since this class calls onScrollChanged even if the mFirstPosition and the
         // child count have not changed we will avoid sending duplicate accessibility
         // events.
         if (eventType == AccessibilityEvent.TYPE_VIEW_SCROLLED) {
             final int firstVisiblePosition = getFirstVisiblePosition();
             final int lastVisiblePosition = getLastVisiblePosition();
             if (mLastAccessibilityScrollEventFromIndex == firstVisiblePosition
                     && mLastAccessibilityScrollEventToIndex == lastVisiblePosition) {
                 return;
             } else {
                 mLastAccessibilityScrollEventFromIndex = firstVisiblePosition;
                 mLastAccessibilityScrollEventToIndex = lastVisiblePosition;
             }
         }
         super.sendAccessibilityEvent(eventType);
     }
     @Override
     @TargetApi(14)
     public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
         super.onInitializeAccessibilityEvent(event);
         event.setClassName(TwoWayView.class.getName());
     }
     @Override
     @TargetApi(14)
     public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
         super.onInitializeAccessibilityNodeInfo(info);
         info.setClassName(TwoWayView.class.getName());
         AccessibilityNodeInfoCompat infoCompat = new AccessibilityNodeInfoCompat(info);
         if (isEnabled()) {
             if (getFirstVisiblePosition() > 0) {
                 infoCompat.addAction(AccessibilityNodeInfoCompat.ACTION_SCROLL_BACKWARD);
             }
             if (getLastVisiblePosition() < getCount() - 1) {
                 infoCompat.addAction(AccessibilityNodeInfoCompat.ACTION_SCROLL_FORWARD);
             }
         }
     }
     @Override
     @TargetApi(16)
     public boolean performAccessibilityAction(int action, Bundle arguments) {
         if (super.performAccessibilityAction(action, arguments)) {
             return true;
         }
         switch (action) {
         case AccessibilityNodeInfo.ACTION_SCROLL_FORWARD:
             if (isEnabled() && getLastVisiblePosition() < getCount() - 1) {
                 final int viewportSize;
                 if (mIsVertical) {
                     viewportSize = getHeight() - getPaddingTop() - getPaddingBottom();
                 } else {
                     viewportSize = getWidth() - getPaddingLeft() - getPaddingRight();
                 }
                 // TODO: Use some form of smooth scroll instead
                 trackMotionScroll(viewportSize);
                 return true;
             }
             return false;
         case AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD:
             if (isEnabled() && mFirstPosition > 0) {
                 final int viewportSize;
                 if (mIsVertical) {
                     viewportSize = getHeight() - getPaddingTop() - getPaddingBottom();
                 } else {
                     viewportSize = getWidth() - getPaddingLeft() - getPaddingRight();
                 }
                 // TODO: Use some form of smooth scroll instead
                 trackMotionScroll(-viewportSize);
                 return true;
             }
             return false;
         }
         return false;
     }
     /**
      * Return true if child is an ancestor of parent, (or equal to the parent).
      */
     private boolean isViewAncestorOf(View child, View parent) {
         if (child == parent) {
             return true;
         }
         final ViewParent theParent = child.getParent();
         return (theParent instanceof ViewGroup) &&
                  isViewAncestorOf((View) theParent, parent);
     }
     private void forceValidFocusDirection(int direction) {
         if (mIsVertical && direction != View.FOCUS_UP && direction != View.FOCUS_DOWN)  {
             throw new IllegalArgumentException("Focus direction must be one of"
                     + " {View.FOCUS_UP, View.FOCUS_DOWN} for vertical orientation");
         } else if (!mIsVertical && direction != View.FOCUS_LEFT && direction != View.FOCUS_RIGHT)  {
             throw new IllegalArgumentException("Focus direction must be one of"
                     + " {View.FOCUS_LEFT, View.FOCUS_RIGHT} for vertical orientation");
         }
     }
     private void forceValidInnerFocusDirection(int direction) {
         if (mIsVertical && direction != View.FOCUS_LEFT && direction != View.FOCUS_RIGHT)  {
             throw new IllegalArgumentException("Direction must be one of"
                     + " {View.FOCUS_LEFT, View.FOCUS_RIGHT} for vertical orientation");
         } else if (!mIsVertical && direction != View.FOCUS_UP && direction != View.FOCUS_DOWN)  {
             throw new IllegalArgumentException("direction must be one of"
                     + " {View.FOCUS_UP, View.FOCUS_DOWN} for horizontal orientation");
         }
     }
     /**
      * Scrolls up or down by the number of items currently present on screen.
      *
      * @param direction either {@link View#FOCUS_UP} or {@link View#FOCUS_DOWN} or
      *        {@link View#FOCUS_LEFT} or {@link View#FOCUS_RIGHT} depending on the
      *        current view orientation.
      *
      * @return whether selection was moved
      */
     boolean pageScroll(int direction) {
         forceValidFocusDirection(direction);
         boolean forward = false;
         int nextPage = -1;
         if (direction == View.FOCUS_UP || direction == View.FOCUS_LEFT) {
             nextPage = Math.max(0, mSelectedPosition - getChildCount() - 1);
         } else if (direction == View.FOCUS_DOWN || direction == View.FOCUS_RIGHT) {
             nextPage = Math.min(mItemCount - 1, mSelectedPosition + getChildCount() - 1);
             forward = true;
         }
         if (nextPage < 0) {
             return false;
         }
         final int position = lookForSelectablePosition(nextPage, forward);
         if (position >= 0) {
             mLayoutMode = LAYOUT_SPECIFIC;
             mSpecificStart = (mIsVertical ? getPaddingTop() : getPaddingLeft());
             if (forward && position > mItemCount - getChildCount()) {
                 mLayoutMode = LAYOUT_FORCE_BOTTOM;
             }
             if (!forward && position < getChildCount()) {
                 mLayoutMode = LAYOUT_FORCE_TOP;
             }
             setSelectionInt(position);
             invokeOnItemScrollListener();
             if (!awakenScrollbarsInternal()) {
                 invalidate();
             }
             return true;
         }
         return false;
     }
     /**
      * Go to the last or first item if possible (not worrying about panning across or navigating
      * within the internal focus of the currently selected item.)
      *
      * @param direction either {@link View#FOCUS_UP} or {@link View#FOCUS_DOWN} or
      *        {@link View#FOCUS_LEFT} or {@link View#FOCUS_RIGHT} depending on the
      *        current view orientation.
      *
      * @return whether selection was moved
      */
     boolean fullScroll(int direction) {
         forceValidFocusDirection(direction);
         boolean moved = false;
         if (direction == View.FOCUS_UP || direction == View.FOCUS_LEFT) {
             if (mSelectedPosition != 0) {
                 int position = lookForSelectablePosition(0, true);
                 if (position >= 0) {
                     mLayoutMode = LAYOUT_FORCE_TOP;
                     setSelectionInt(position);
                     invokeOnItemScrollListener();
                 }
                 moved = true;
             }
         } else if (direction == View.FOCUS_DOWN || direction == View.FOCUS_RIGHT) {
             if (mSelectedPosition < mItemCount - 1) {
                 int position = lookForSelectablePosition(mItemCount - 1, true);
                 if (position >= 0) {
                     mLayoutMode = LAYOUT_FORCE_BOTTOM;
                     setSelectionInt(position);
                     invokeOnItemScrollListener();
                 }
                 moved = true;
             }
         }
         if (moved && !awakenScrollbarsInternal()) {
             awakenScrollbarsInternal();
             invalidate();
         }
         return moved;
     }
     /**
      * To avoid horizontal/vertical focus searches changing the selected item,
      * we manually focus search within the selected item (as applicable), and
      * prevent focus from jumping to something within another item.
      *
      * @param direction either {@link View#FOCUS_UP} or {@link View#FOCUS_DOWN} or
      *        {@link View#FOCUS_LEFT} or {@link View#FOCUS_RIGHT} depending on the
      *        current view orientation.
      *
      * @return Whether this consumes the key event.
      */
     private boolean handleFocusWithinItem(int direction) {
         forceValidInnerFocusDirection(direction);
         final int numChildren = getChildCount();
         if (mItemsCanFocus && numChildren > 0 && mSelectedPosition != INVALID_POSITION) {
             final View selectedView = getSelectedView();
             if (selectedView != null && selectedView.hasFocus() &&
                     selectedView instanceof ViewGroup) {
                 final View currentFocus = selectedView.findFocus();
                 final View nextFocus = FocusFinder.getInstance().findNextFocus(
                         (ViewGroup) selectedView, currentFocus, direction);
                 if (nextFocus != null) {
                     // Do the math to get interesting rect in next focus' coordinates
                     currentFocus.getFocusedRect(mTempRect);
                     offsetDescendantRectToMyCoords(currentFocus, mTempRect);
                     offsetRectIntoDescendantCoords(nextFocus, mTempRect);
                     if (nextFocus.requestFocus(direction, mTempRect)) {
                         return true;
                     }
                 }
                 // We are blocking the key from being handled (by returning true)
                 // if the global result is going to be some other view within this
                 // list. This is to achieve the overall goal of having horizontal/vertical
                 // d-pad navigation remain in the current item depending on the current
                 // orientation in this view.
                 final View globalNextFocus = FocusFinder.getInstance().findNextFocus(
                         (ViewGroup) getRootView(), currentFocus, direction);
                 if (globalNextFocus != null) {
                     return isViewAncestorOf(globalNextFocus, this);
                 }
             }
         }
         return false;
     }
     /**
      * Scrolls to the next or previous item if possible.
      *
      * @param direction either {@link View#FOCUS_UP} or {@link View#FOCUS_DOWN} or
      *        {@link View#FOCUS_LEFT} or {@link View#FOCUS_RIGHT} depending on the
      *        current view orientation.
      *
      * @return whether selection was moved
      */
     private boolean arrowScroll(int direction) {
         forceValidFocusDirection(direction);
         try {
             mInLayout = true;
             final boolean handled = arrowScrollImpl(direction);
             if (handled) {
                 playSoundEffect(SoundEffectConstants.getContantForFocusDirection(direction));
             }
             return handled;
         } finally {
             mInLayout = false;
         }
     }
     /**
      * When selection changes, it is possible that the previously selected or the
      * next selected item will change its size.  If so, we need to offset some folks,
      * and re-layout the items as appropriate.
      *
      * @param selectedView The currently selected view (before changing selection).
      *   should be <code>null</code> if there was no previous selection.
      * @param direction either {@link View#FOCUS_UP} or {@link View#FOCUS_DOWN} or
      *        {@link View#FOCUS_LEFT} or {@link View#FOCUS_RIGHT} depending on the
      *        current view orientation.
      * @param newSelectedPosition The position of the next selection.
      * @param newFocusAssigned whether new focus was assigned.  This matters because
      *        when something has focus, we don't want to show selection (ugh).
      */
     private void handleNewSelectionChange(View selectedView, int direction, int newSelectedPosition,
             boolean newFocusAssigned) {
         forceValidFocusDirection(direction);
         if (newSelectedPosition == INVALID_POSITION) {
             throw new IllegalArgumentException("newSelectedPosition needs to be valid");
         }
         // Whether or not we are moving down/right or up/left, we want to preserve the
         // top/left of whatever view is at the start:
         // - moving down/right: the view that had selection
         // - moving up/left: the view that is getting selection
         final int selectedIndex = mSelectedPosition - mFirstPosition;
         final int nextSelectedIndex = newSelectedPosition - mFirstPosition;
         int startViewIndex, endViewIndex;
         boolean topSelected = false;
         View startView;
         View endView;
         if (direction == View.FOCUS_UP || direction == View.FOCUS_LEFT) {
             startViewIndex = nextSelectedIndex;
             endViewIndex = selectedIndex;
             startView = getChildAt(startViewIndex);
             endView = selectedView;
             topSelected = true;
         } else {
             startViewIndex = selectedIndex;
             endViewIndex = nextSelectedIndex;
             startView = selectedView;
             endView = getChildAt(endViewIndex);
         }
         final int numChildren = getChildCount();
         // start with top view: is it changing size?
         if (startView != null) {
             startView.setSelected(!newFocusAssigned && topSelected);
             measureAndAdjustDown(startView, startViewIndex, numChildren);
         }
         // is the bottom view changing size?
         if (endView != null) {
             endView.setSelected(!newFocusAssigned && !topSelected);
             measureAndAdjustDown(endView, endViewIndex, numChildren);
         }
     }
     /**
      * Re-measure a child, and if its height changes, lay it out preserving its
      * top, and adjust the children below it appropriately.
      *
      * @param child The child
      * @param childIndex The view group index of the child.
      * @param numChildren The number of children in the view group.
      */
     private void measureAndAdjustDown(View child, int childIndex, int numChildren) {
         int oldHeight = child.getHeight();
         measureChild(child);
         if (child.getMeasuredHeight() == oldHeight) {
             return;
         }
         // lay out the view, preserving its top
         relayoutMeasuredChild(child);
         // adjust views below appropriately
         final int heightDelta = child.getMeasuredHeight() - oldHeight;
         for (int i = childIndex + 1; i < numChildren; i++) {
             getChildAt(i).offsetTopAndBottom(heightDelta);
         }
     }
     /**
      * Do an arrow scroll based on focus searching.  If a new view is
      * given focus, return the selection delta and amount to scroll via
      * an {@link ArrowScrollFocusResult}, otherwise, return null.
      *
      * @param direction either {@link View#FOCUS_UP} or {@link View#FOCUS_DOWN} or
      *        {@link View#FOCUS_LEFT} or {@link View#FOCUS_RIGHT} depending on the
      *        current view orientation.
      *
      * @return The result if focus has changed, or <code>null</code>.
      */
     private ArrowScrollFocusResult arrowScrollFocused(final int direction) {
         forceValidFocusDirection(direction);
         final View selectedView = getSelectedView();
         final View newFocus;
         final int searchPoint;
         if (selectedView != null && selectedView.hasFocus()) {
             View oldFocus = selectedView.findFocus();
             newFocus = FocusFinder.getInstance().findNextFocus(this, oldFocus, direction);
         } else {
             if (direction == View.FOCUS_DOWN || direction == View.FOCUS_RIGHT) {
                 final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft());
                 final int selectedStart;
                 if (selectedView != null) {
                     selectedStart = (mIsVertical ? selectedView.getTop() : selectedView.getLeft());
                 } else {
                     selectedStart = start;
                 }
                 searchPoint = Math.max(selectedStart, start);
             } else {
                 final int end = (mIsVertical ? getHeight() - getPaddingBottom() :
                     getWidth() - getPaddingRight());
                 final int selectedEnd;
                 if (selectedView != null) {
                     selectedEnd = (mIsVertical ? selectedView.getBottom() : selectedView.getRight());
                 } else {
                     selectedEnd = end;
                 }
                 searchPoint = Math.min(selectedEnd, end);
             }
             final int x = (mIsVertical ? 0 : searchPoint);
             final int y = (mIsVertical ? searchPoint : 0);
             mTempRect.set(x, y, x, y);
             newFocus = FocusFinder.getInstance().findNextFocusFromRect(this, mTempRect, direction);
         }
         if (newFocus != null) {
             final int positionOfNewFocus = positionOfNewFocus(newFocus);
             // If the focus change is in a different new position, make sure
             // we aren't jumping over another selectable position.
             if (mSelectedPosition != INVALID_POSITION && positionOfNewFocus != mSelectedPosition) {
                 final int selectablePosition = lookForSelectablePositionOnScreen(direction);
                 final boolean movingForward =
                         (direction == View.FOCUS_DOWN || direction == View.FOCUS_RIGHT);
                 final boolean movingBackward =
                         (direction == View.FOCUS_UP || direction == View.FOCUS_LEFT);
                 if (selectablePosition != INVALID_POSITION &&
                         ((movingForward && selectablePosition < positionOfNewFocus) ||
                          (movingBackward && selectablePosition > positionOfNewFocus))) {
                     return null;
                 }
             }
             int focusScroll = amountToScrollToNewFocus(direction, newFocus, positionOfNewFocus);
             final int maxScrollAmount = getMaxScrollAmount();
             if (focusScroll < maxScrollAmount) {
                 // Not moving too far, safe to give next view focus
                 newFocus.requestFocus(direction);
                 mArrowScrollFocusResult.populate(positionOfNewFocus, focusScroll);
                 return mArrowScrollFocusResult;
             } else if (distanceToView(newFocus) < maxScrollAmount){
                 // Case to consider:
                 // Too far to get entire next focusable on screen, but by going
                 // max scroll amount, we are getting it at least partially in view,
                 // so give it focus and scroll the max amount.
                 newFocus.requestFocus(direction);
                 mArrowScrollFocusResult.populate(positionOfNewFocus, maxScrollAmount);
                 return mArrowScrollFocusResult;
             }
         }
         return null;
     }
     /**
      * @return The maximum amount a list view will scroll in response to
      *   an arrow event.
      */
     public int getMaxScrollAmount() {
         return (int) (MAX_SCROLL_FACTOR * getHeight());
     }
     /**
      * @return The amount to preview next items when arrow scrolling.
      */
     private int getArrowScrollPreviewLength() {
         // FIXME: TwoWayView has no fading edge support just yet but using it
         // makes it convenient for defining the next item's previous length.
         int fadingEdgeLength =
                 (mIsVertical ? getVerticalFadingEdgeLength() : getHorizontalFadingEdgeLength());
         return mItemMargin + Math.max(MIN_SCROLL_PREVIEW_PIXELS, fadingEdgeLength);
     }
     /**
      * @param newFocus The view that would have focus.
      * @return the position that contains newFocus
      */
     private int positionOfNewFocus(View newFocus) {
         final int numChildren = getChildCount();
         for (int i = 0; i < numChildren; i++) {
             final View child = getChildAt(i);
             if (isViewAncestorOf(newFocus, child)) {
                 return mFirstPosition + i;
             }
         }
         throw new IllegalArgumentException("newFocus is not a child of any of the"
                 + " children of the list!");
     }
     /**
      * Handle an arrow scroll going up or down.  Take into account whether items are selectable,
      * whether there are focusable items, etc.
      *
      * @param direction either {@link View#FOCUS_UP} or {@link View#FOCUS_DOWN} or
      *        {@link View#FOCUS_LEFT} or {@link View#FOCUS_RIGHT} depending on the
      *        current view orientation.
      *
      * @return Whether any scrolling, selection or focus change occurred.
      */
     private boolean arrowScrollImpl(int direction) {
         forceValidFocusDirection(direction);
         if (getChildCount() <= 0) {
             return false;
         }
         View selectedView = getSelectedView();
         int selectedPos = mSelectedPosition;
         int nextSelectedPosition = lookForSelectablePositionOnScreen(direction);
         int amountToScroll = amountToScroll(direction, nextSelectedPosition);
         // If we are moving focus, we may OVERRIDE the default behaviour
         final ArrowScrollFocusResult focusResult = (mItemsCanFocus ? arrowScrollFocused(direction) : null);
         if (focusResult != null) {
             nextSelectedPosition = focusResult.getSelectedPosition();
             amountToScroll = focusResult.getAmountToScroll();
         }
         boolean needToRedraw = (focusResult != null);
         if (nextSelectedPosition != INVALID_POSITION) {
             handleNewSelectionChange(selectedView, direction, nextSelectedPosition, focusResult != null);
             setSelectedPositionInt(nextSelectedPosition);
             setNextSelectedPositionInt(nextSelectedPosition);
             selectedView = getSelectedView();
             selectedPos = nextSelectedPosition;
             if (mItemsCanFocus && focusResult == null) {
                 // There was no new view found to take focus, make sure we
                 // don't leave focus with the old selection.
                 final View focused = getFocusedChild();
                 if (focused != null) {
                     focused.clearFocus();
                 }
             }
             needToRedraw = true;
             checkSelectionChanged();
         }
         if (amountToScroll > 0) {
             trackMotionScroll(direction == View.FOCUS_UP || direction == View.FOCUS_LEFT ?
                     amountToScroll : -amountToScroll);
             needToRedraw = true;
         }
         // If we didn't find a new focusable, make sure any existing focused
         // item that was panned off screen gives up focus.
         if (mItemsCanFocus && focusResult == null &&
                 selectedView != null && selectedView.hasFocus()) {
             final View focused = selectedView.findFocus();
             if (!isViewAncestorOf(focused, this) || distanceToView(focused) > 0) {
                 focused.clearFocus();
             }
         }
         // If the current selection is panned off, we need to remove the selection
         if (nextSelectedPosition == INVALID_POSITION && selectedView != null
                 && !isViewAncestorOf(selectedView, this)) {
             selectedView = null;
             hideSelector();
             // But we don't want to set the ressurect position (that would make subsequent
             // unhandled key events bring back the item we just scrolled off)
             mResurrectToPosition = INVALID_POSITION;
         }
         if (needToRedraw) {
             if (selectedView != null) {
                 positionSelector(selectedPos, selectedView);
                 mSelectedStart = selectedView.getTop();
             }
             if (!awakenScrollbarsInternal()) {
                 invalidate();
             }
             invokeOnItemScrollListener();
             return true;
         }
         return false;
     }
     /**
      * Determine how much we need to scroll in order to get the next selected view
      * visible. The amount is capped at {@link #getMaxScrollAmount()}.
      *
      * @param direction either {@link View#FOCUS_UP} or {@link View#FOCUS_DOWN} or
      *        {@link View#FOCUS_LEFT} or {@link View#FOCUS_RIGHT} depending on the
      *        current view orientation.
      * @param nextSelectedPosition The position of the next selection, or
      *        {@link #INVALID_POSITION} if there is no next selectable position
      *
      * @return The amount to scroll. Note: this is always positive!  Direction
      *         needs to be taken into account when actually scrolling.
      */
     private int amountToScroll(int direction, int nextSelectedPosition) {
         forceValidFocusDirection(direction);
         final int numChildren = getChildCount();
         if (direction == View.FOCUS_DOWN || direction == View.FOCUS_RIGHT) {
             final int end = (mIsVertical ? getHeight() - getPaddingBottom() :
                 getWidth() - getPaddingRight());
             int indexToMakeVisible = numChildren - 1;
             if (nextSelectedPosition != INVALID_POSITION) {
                 indexToMakeVisible = nextSelectedPosition - mFirstPosition;
             }
             final int positionToMakeVisible = mFirstPosition + indexToMakeVisible;
             final View viewToMakeVisible = getChildAt(indexToMakeVisible);
             int goalEnd = end;
             if (positionToMakeVisible < mItemCount - 1) {
                 goalEnd -= getArrowScrollPreviewLength();
             }
             final int viewToMakeVisibleStart =
                     (mIsVertical ? viewToMakeVisible.getTop() : viewToMakeVisible.getLeft());
             final int viewToMakeVisibleEnd =
                     (mIsVertical ? viewToMakeVisible.getBottom() : viewToMakeVisible.getRight());
             if (viewToMakeVisibleEnd <= goalEnd) {
                 // Target item is fully visible
                 return 0;
             }
             if (nextSelectedPosition != INVALID_POSITION &&
                     (goalEnd - viewToMakeVisibleStart) >= getMaxScrollAmount()) {
                 // Item already has enough of it visible, changing selection is good enough
                 return 0;
             }
             int amountToScroll = (viewToMakeVisibleEnd - goalEnd);
             if (mFirstPosition + numChildren == mItemCount) {
                 final View lastChild = getChildAt(numChildren - 1);
                 final int lastChildEnd = (mIsVertical ? lastChild.getBottom() : lastChild.getRight());
                 // Last is last in list -> Make sure we don't scroll past it
                 final int max = lastChildEnd - end;
                 amountToScroll = Math.min(amountToScroll, max);
             }
             return Math.min(amountToScroll, getMaxScrollAmount());
         } else {
             final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft());
             int indexToMakeVisible = 0;
             if (nextSelectedPosition != INVALID_POSITION) {
                 indexToMakeVisible = nextSelectedPosition - mFirstPosition;
             }
             final int positionToMakeVisible = mFirstPosition + indexToMakeVisible;
             final View viewToMakeVisible = getChildAt(indexToMakeVisible);
             int goalStart = start;
             if (positionToMakeVisible > 0) {
                 goalStart += getArrowScrollPreviewLength();
             }
             final int viewToMakeVisibleStart =
                     (mIsVertical ? viewToMakeVisible.getTop() : viewToMakeVisible.getLeft());
             final int viewToMakeVisibleEnd =
                     (mIsVertical ? viewToMakeVisible.getBottom() : viewToMakeVisible.getRight());
             if (viewToMakeVisibleStart >= goalStart) {
                 // Item is fully visible
                 return 0;
             }
             if (nextSelectedPosition != INVALID_POSITION &&
                     (viewToMakeVisibleEnd - goalStart) >= getMaxScrollAmount()) {
                 // Item already has enough of it visible, changing selection is good enough
                 return 0;
             }
             int amountToScroll = (goalStart - viewToMakeVisibleStart);
             if (mFirstPosition == 0) {
                 final View firstChild = getChildAt(0);
                 final int firstChildStart = (mIsVertical ? firstChild.getTop() : firstChild.getLeft());
                 // First is first in list -> make sure we don't scroll past it
                 final int max = start - firstChildStart;
                 amountToScroll = Math.min(amountToScroll,  max);
             }
             return Math.min(amountToScroll, getMaxScrollAmount());
         }
     }
     /**
      * Determine how much we need to scroll in order to get newFocus in view.
      *
      * @param direction either {@link View#FOCUS_UP} or {@link View#FOCUS_DOWN} or
      *        {@link View#FOCUS_LEFT} or {@link View#FOCUS_RIGHT} depending on the
      *        current view orientation.
      * @param newFocus The view that would take focus.
      * @param positionOfNewFocus The position of the list item containing newFocus
      *
      * @return The amount to scroll. Note: this is always positive! Direction
      *   needs to be taken into account when actually scrolling.
      */
     private int amountToScrollToNewFocus(int direction, View newFocus, int positionOfNewFocus) {
         forceValidFocusDirection(direction);
         int amountToScroll = 0;
         newFocus.getDrawingRect(mTempRect);
         offsetDescendantRectToMyCoords(newFocus, mTempRect);
         if (direction == View.FOCUS_UP || direction == View.FOCUS_LEFT) {
             final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft());
             final int newFocusStart = (mIsVertical ? mTempRect.top : mTempRect.left);
             if (newFocusStart < start) {
                 amountToScroll = start - newFocusStart;
                 if (positionOfNewFocus > 0) {
                     amountToScroll += getArrowScrollPreviewLength();
                 }
             }
         } else {
             final int end = (mIsVertical ? getHeight() - getPaddingBottom() :
                 getWidth() - getPaddingRight());
             final int newFocusEnd = (mIsVertical ? mTempRect.bottom : mTempRect.right);
             if (newFocusEnd > end) {
                 amountToScroll = newFocusEnd - end;
                 if (positionOfNewFocus < mItemCount - 1) {
                     amountToScroll += getArrowScrollPreviewLength();
                 }
             }
         }
         return amountToScroll;
     }
     /**
      * Determine the distance to the nearest edge of a view in a particular
      * direction.
      *
      * @param descendant A descendant of this list.
      * @return The distance, or 0 if the nearest edge is already on screen.
      */
     private int distanceToView(View descendant) {
         descendant.getDrawingRect(mTempRect);
         offsetDescendantRectToMyCoords(descendant, mTempRect);
         final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft());
         final int end = (mIsVertical ? getHeight() - getPaddingBottom() :
             getWidth() - getPaddingRight());
         final int viewStart = (mIsVertical ? mTempRect.top : mTempRect.left);
         final int viewEnd = (mIsVertical ? mTempRect.bottom : mTempRect.right);
         int distance = 0;
         if (viewEnd < start) {
             distance = start - viewEnd;
         } else if (viewStart > end) {
             distance = viewStart - end;
         }
         return distance;
     }
     private boolean handleKeyScroll(KeyEvent event, int count, int direction) {
         boolean handled = false;
         if (KeyEventCompat.hasNoModifiers(event)) {
             handled = resurrectSelectionIfNeeded();
             if (!handled) {
                 while (count-- > 0) {
                     if (arrowScroll(direction)) {
                         handled = true;
                     } else {
                         break;
                     }
                 }
             }
         } else if (KeyEventCompat.hasModifiers(event, KeyEvent.META_ALT_ON)) {
             handled = resurrectSelectionIfNeeded() || fullScroll(direction);
         }
         return handled;
     }
     private boolean handleKeyEvent(int keyCode, int count, KeyEvent event) {
         if (mAdapter == null || !mIsAttached) {
             return false;
         }
         if (mDataChanged) {
             layoutChildren();
         }
         boolean handled = false;
         final int action = event.getAction();
         if (action != KeyEvent.ACTION_UP) {
             switch (keyCode) {
             case KeyEvent.KEYCODE_DPAD_UP:
                 if (mIsVertical) {
                     handled = handleKeyScroll(event, count, View.FOCUS_UP);
                 } else if (KeyEventCompat.hasNoModifiers(event)) {
                     handled = handleFocusWithinItem(View.FOCUS_UP);
                 }
                 break;
             case KeyEvent.KEYCODE_DPAD_DOWN: {
                 if (mIsVertical) {
                     handled = handleKeyScroll(event, count, View.FOCUS_DOWN);
                 } else if (KeyEventCompat.hasNoModifiers(event)) {
                     handled = handleFocusWithinItem(View.FOCUS_DOWN);
                 }
                 break;
             }
             case KeyEvent.KEYCODE_DPAD_LEFT:
                 if (!mIsVertical) {
                     handled = handleKeyScroll(event, count, View.FOCUS_LEFT);
                 } else if (KeyEventCompat.hasNoModifiers(event)) {
                     handled = handleFocusWithinItem(View.FOCUS_LEFT);
                 }
                 break;
             case KeyEvent.KEYCODE_DPAD_RIGHT:
                 if (!mIsVertical) {
                     handled = handleKeyScroll(event, count, View.FOCUS_RIGHT);
                 } else if (KeyEventCompat.hasNoModifiers(event)) {
                     handled = handleFocusWithinItem(View.FOCUS_RIGHT);
                 }
                 break;
             case KeyEvent.KEYCODE_DPAD_CENTER:
             case KeyEvent.KEYCODE_ENTER:
                 if (KeyEventCompat.hasNoModifiers(event)) {
                     handled = resurrectSelectionIfNeeded();
                     if (!handled
                             && event.getRepeatCount() == 0 && getChildCount() > 0) {
                         keyPressed();
                         handled = true;
                     }
                 }
                 break;
             case KeyEvent.KEYCODE_SPACE:
                 if (KeyEventCompat.hasNoModifiers(event)) {
                     handled = resurrectSelectionIfNeeded() ||
                             pageScroll(mIsVertical ? View.FOCUS_DOWN : View.FOCUS_RIGHT);
                 } else if (KeyEventCompat.hasModifiers(event, KeyEvent.META_SHIFT_ON)) {
                     handled = resurrectSelectionIfNeeded() ||
                             fullScroll(mIsVertical ? View.FOCUS_UP : View.FOCUS_LEFT);
                 }
                 handled = true;
                 break;
             case KeyEvent.KEYCODE_PAGE_UP:
                 if (KeyEventCompat.hasNoModifiers(event)) {
                     handled = resurrectSelectionIfNeeded() ||
                             pageScroll(mIsVertical ? View.FOCUS_UP : View.FOCUS_LEFT);
                 } else if (KeyEventCompat.hasModifiers(event, KeyEvent.META_ALT_ON)) {
                     handled = resurrectSelectionIfNeeded() ||
                             fullScroll(mIsVertical ? View.FOCUS_UP : View.FOCUS_LEFT);
                 }
                 break;
             case KeyEvent.KEYCODE_PAGE_DOWN:
                 if (KeyEventCompat.hasNoModifiers(event)) {
                     handled = resurrectSelectionIfNeeded() ||
                             pageScroll(mIsVertical ? View.FOCUS_DOWN : View.FOCUS_RIGHT);
                 } else if (KeyEventCompat.hasModifiers(event, KeyEvent.META_ALT_ON)) {
                     handled = resurrectSelectionIfNeeded() ||
                             fullScroll(mIsVertical ? View.FOCUS_DOWN : View.FOCUS_RIGHT);
                 }
                 break;
             case KeyEvent.KEYCODE_MOVE_HOME:
                 if (KeyEventCompat.hasNoModifiers(event)) {
                     handled = resurrectSelectionIfNeeded() ||
                             fullScroll(mIsVertical ? View.FOCUS_UP : View.FOCUS_LEFT);
                 }
                 break;
             case KeyEvent.KEYCODE_MOVE_END:
                 if (KeyEventCompat.hasNoModifiers(event)) {
                     handled = resurrectSelectionIfNeeded() ||
                             fullScroll(mIsVertical ? View.FOCUS_DOWN : View.FOCUS_RIGHT);
                 }
                 break;
             }
         }
         if (handled) {
             return true;
         }
         switch (action) {
         case KeyEvent.ACTION_DOWN:
             return super.onKeyDown(keyCode, event);
         case KeyEvent.ACTION_UP:
             if (!isEnabled()) {
                 return true;
             }
             if (isClickable() && isPressed() &&
                     mSelectedPosition >= 0 && mAdapter != null &&
                     mSelectedPosition < mAdapter.getCount()) {
                 final View child = getChildAt(mSelectedPosition - mFirstPosition);
                 if (child != null) {
                     performItemClick(child, mSelectedPosition, mSelectedRowId);
                     child.setPressed(false);
                 }
                 setPressed(false);
                 return true;
             }
             return false;
         case KeyEvent.ACTION_MULTIPLE:
             return super.onKeyMultiple(keyCode, count, event);
         default:
             return false;
         }
     }
     private void initOrResetVelocityTracker() {
         if (mVelocityTracker == null) {
             mVelocityTracker = VelocityTracker.obtain();
         } else {
             mVelocityTracker.clear();
         }
     }
     private void initVelocityTrackerIfNotExists() {
         if (mVelocityTracker == null) {
             mVelocityTracker = VelocityTracker.obtain();
         }
     }
     private void recycleVelocityTracker() {
         if (mVelocityTracker != null) {
             mVelocityTracker.recycle();
             mVelocityTracker = null;
         }
     }
     /**
      * Notify our scroll listener (if there is one) of a change in scroll state
      */
     private void invokeOnItemScrollListener() {
         if (mOnScrollListener != null) {
             mOnScrollListener.onScroll(this, mFirstPosition, getChildCount(), mItemCount);
         }
         // Dummy values, View's implementation does not use these.
         onScrollChanged(0, 0, 0, 0);
     }
     private void reportScrollStateChange(int newState) {
         if (newState == mLastScrollState) {
             return;
         }
         if (mOnScrollListener != null) {
             mLastScrollState = newState;
             mOnScrollListener.onScrollStateChanged(this, newState);
         }
     }
     private boolean maybeStartScrolling(int delta) {
         final boolean isOverScroll = (mOverScroll != 0);
         if (Math.abs(delta) <= mTouchSlop && !isOverScroll) {
             return false;
         }
         if (isOverScroll) {
             mTouchMode = TOUCH_MODE_OVERSCROLL;
         } else {
             mTouchMode = TOUCH_MODE_DRAGGING;
         }
         // Time to start stealing events! Once we've stolen them, don't
         // let anyone steal from us.
         final ViewParent parent = getParent();
         if (parent != null) {
             parent.requestDisallowInterceptTouchEvent(true);
         }
         cancelCheckForLongPress();
         setPressed(false);
         View motionView = getChildAt(mMotionPosition - mFirstPosition);
         if (motionView != null) {
             motionView.setPressed(false);
         }
         reportScrollStateChange(OnScrollListener.SCROLL_STATE_TOUCH_SCROLL);
         return true;
     }
     private void maybeScroll(int delta) {
         if (mTouchMode == TOUCH_MODE_DRAGGING) {
             handleDragChange(delta);
         } else if (mTouchMode == TOUCH_MODE_OVERSCROLL) {
             handleOverScrollChange(delta);
         }
     }
     private void handleDragChange(int delta) {
         // Time to start stealing events! Once we've stolen them, don't
         // let anyone steal from us.
         final ViewParent parent = getParent();
         if (parent != null) {
             parent.requestDisallowInterceptTouchEvent(true);
         }
         final int motionIndex;
         if (mMotionPosition >= 0) {
             motionIndex = mMotionPosition - mFirstPosition;
         } else {
             // If we don't have a motion position that we can reliably track,
             // pick something in the middle to make a best guess at things below.
             motionIndex = getChildCount() / 2;
         }
         int motionViewPrevStart = 0;
         View motionView = this.getChildAt(motionIndex);
         if (motionView != null) {
             motionViewPrevStart = (mIsVertical ? motionView.getTop() : motionView.getLeft());
         }
         boolean atEdge = trackMotionScroll(delta);
         motionView = this.getChildAt(motionIndex);
         if (motionView != null) {
             final int motionViewRealStart =
                     (mIsVertical ? motionView.getTop() : motionView.getLeft());
             if (atEdge) {
                 final int overscroll = -delta - (motionViewRealStart - motionViewPrevStart);
                 updateOverScrollState(delta, overscroll);
             }
         }
     }
     private void updateOverScrollState(int delta, int overscroll) {
         overScrollByInternal((mIsVertical ? 0 : overscroll),
                              (mIsVertical ? overscroll : 0),
                              (mIsVertical ? 0 : mOverScroll),
                              (mIsVertical ? mOverScroll : 0),
 , 0,
                              (mIsVertical ? 0 : mOverscrollDistance),
                              (mIsVertical ? mOverscrollDistance : 0),
                              true);
         if (Math.abs(mOverscrollDistance) == Math.abs(mOverScroll)) {
             // Break fling velocity if we impacted an edge
             if (mVelocityTracker != null) {
                 mVelocityTracker.clear();
             }
         }
         final int overscrollMode = ViewCompat.getOverScrollMode(this);
         if (overscrollMode == ViewCompat.OVER_SCROLL_ALWAYS ||
                 (overscrollMode == ViewCompat.OVER_SCROLL_IF_CONTENT_SCROLLS && !contentFits())) {
             mTouchMode = TOUCH_MODE_OVERSCROLL;
             float pull = (float) overscroll / (mIsVertical ? getHeight() : getWidth());
             if (delta > 0) {
                 mStartEdge.onPull(pull);
                 if (!mEndEdge.isFinished()) {
                     mEndEdge.onRelease();
                 }
             } else if (delta < 0) {
                 mEndEdge.onPull(pull);
                 if (!mStartEdge.isFinished()) {
                     mStartEdge.onRelease();
                 }
             }
             if (delta != 0) {
                 ViewCompat.postInvalidateOnAnimation(this);
             }
         }
     }
     private void handleOverScrollChange(int delta) {
         final int oldOverScroll = mOverScroll;
         final int newOverScroll = oldOverScroll - delta;
         int overScrollDistance = -delta;
         if ((newOverScroll < 0 && oldOverScroll >= 0) ||
                 (newOverScroll > 0 && oldOverScroll <= 0)) {
             overScrollDistance = -oldOverScroll;
             delta += overScrollDistance;
         } else {
             delta = 0;
         }
         if (overScrollDistance != 0) {
             updateOverScrollState(delta, overScrollDistance);
         }
         if (delta != 0) {
             if (mOverScroll != 0) {
                 mOverScroll = 0;
                 ViewCompat.postInvalidateOnAnimation(this);
             }
             trackMotionScroll(delta);
             mTouchMode = TOUCH_MODE_DRAGGING;
             // We did not scroll the full amount. Treat this essentially like the
             // start of a new touch scroll
             mMotionPosition = findClosestMotionRowOrColumn((int) mLastTouchPos);
             mTouchRemainderPos = 0;
         }
     }
     /**
      * What is the distance between the source and destination rectangles given the direction of
      * focus navigation between them? The direction basically helps figure out more quickly what is
      * self evident by the relationship between the rects...
      *
      * @param source the source rectangle
      * @param dest the destination rectangle
      * @param direction the direction
      * @return the distance between the rectangles
      */
     private static int getDistance(Rect source, Rect dest, int direction) {
         int sX, sY; // source x, y
         int dX, dY; // dest x, y
         switch (direction) {
         case View.FOCUS_RIGHT:
             sX = source.right;
             sY = source.top + source.height() / 2;
             dX = dest.left;
             dY = dest.top + dest.height() / 2;
             break;
         case View.FOCUS_DOWN:
             sX = source.left + source.width() / 2;
             sY = source.bottom;
             dX = dest.left + dest.width() / 2;
             dY = dest.top;
             break;
         case View.FOCUS_LEFT:
             sX = source.left;
             sY = source.top + source.height() / 2;
             dX = dest.right;
             dY = dest.top + dest.height() / 2;
             break;
         case View.FOCUS_UP:
             sX = source.left + source.width() / 2;
             sY = source.top;
             dX = dest.left + dest.width() / 2;
             dY = dest.bottom;
             break;
         case View.FOCUS_FORWARD:
         case View.FOCUS_BACKWARD:
             sX = source.right + source.width() / 2;
             sY = source.top + source.height() / 2;
             dX = dest.left + dest.width() / 2;
             dY = dest.top + dest.height() / 2;
             break;
         default:
             throw new IllegalArgumentException("direction must be one of "
                     + "{FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, FOCUS_RIGHT, "
                     + "FOCUS_FORWARD, FOCUS_BACKWARD}.");
         }
         int deltaX = dX - sX;
         int deltaY = dY - sY;
         return deltaY * deltaY + deltaX * deltaX;
     }
     private int findMotionRowOrColumn(int motionPos) {
         int childCount = getChildCount();
         if (childCount == 0) {
             return INVALID_POSITION;
         }
         for (int i = 0; i < childCount; i++) {
             View v = getChildAt(i);
             if ((mIsVertical && motionPos <= v.getBottom()) ||
                     (!mIsVertical && motionPos <= v.getRight())) {
                 return mFirstPosition + i;
             }
         }
         return INVALID_POSITION;
     }
     private int findClosestMotionRowOrColumn(int motionPos) {
         final int childCount = getChildCount();
         if (childCount == 0) {
             return INVALID_POSITION;
         }
         final int motionRow = findMotionRowOrColumn(motionPos);
         if (motionRow != INVALID_POSITION) {
             return motionRow;
         } else {
             return mFirstPosition + childCount - 1;
         }
     }
     @TargetApi(9)
     private int getScaledOverscrollDistance(ViewConfiguration vc) {
         if (Build.VERSION.SDK_INT < 9) {
             return 0;
         }
         return vc.getScaledOverscrollDistance();
     }
     private boolean contentFits() {
         final int childCount = getChildCount();
         if (childCount == 0) {
             return true;
         }
         if (childCount != mItemCount) {
             return false;
         }
         View first = getChildAt(0);
         View last = getChildAt(childCount - 1);
         if (mIsVertical) {
             return first.getTop() >= getPaddingTop() &&
                     last.getBottom() <= getHeight() - getPaddingBottom();
         } else {
             return first.getLeft() >= getPaddingLeft() &&
                     last.getRight() <= getWidth() - getPaddingRight();
         }
     }
     private void updateScrollbarsDirection() {
         setHorizontalScrollBarEnabled(!mIsVertical);
         setVerticalScrollBarEnabled(mIsVertical);
     }
     private void triggerCheckForTap() {
         if (mPendingCheckForTap == null) {
             mPendingCheckForTap = new CheckForTap();
         }
         postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
     }
     private void cancelCheckForTap() {
         if (mPendingCheckForTap == null) {
             return;
         }
         removeCallbacks(mPendingCheckForTap);
     }
     private void triggerCheckForLongPress() {
         if (mPendingCheckForLongPress == null) {
             mPendingCheckForLongPress = new CheckForLongPress();
         }
         mPendingCheckForLongPress.rememberWindowAttachCount();
         postDelayed(mPendingCheckForLongPress,
                 ViewConfiguration.getLongPressTimeout());
     }
     private void cancelCheckForLongPress() {
         if (mPendingCheckForLongPress == null) {
             return;
         }
         removeCallbacks(mPendingCheckForLongPress);
     }
     boolean trackMotionScroll(int incrementalDelta) {
         final int childCount = getChildCount();
         if (childCount == 0) {
             return true;
         }
         final View first = getChildAt(0);
         final int firstStart = (mIsVertical ? first.getTop() : first.getLeft());
         final View last = getChildAt(childCount - 1);
         final int lastEnd = (mIsVertical ? last.getBottom() : last.getRight());
         final int paddingTop = getPaddingTop();
         final int paddingBottom = getPaddingBottom();
         final int paddingLeft = getPaddingLeft();
         final int paddingRight = getPaddingRight();
         final int paddingStart = (mIsVertical ? paddingTop : paddingLeft);
         final int spaceBefore = paddingStart - firstStart;
         final int end = (mIsVertical ? getHeight() - paddingBottom :
             getWidth() - paddingRight);
         final int spaceAfter = lastEnd - end;
         final int size;
         if (mIsVertical) {
             size = getHeight() - paddingBottom - paddingTop;
         } else {
             size = getWidth() - paddingRight - paddingLeft;
         }
         if (incrementalDelta < 0) {
             incrementalDelta = Math.max(-(size - 1), incrementalDelta);
         } else {
             incrementalDelta = Math.min(size - 1, incrementalDelta);
         }
         final int firstPosition = mFirstPosition;
         final boolean cannotScrollDown = (firstPosition == 0 &&
                 firstStart >= paddingStart && incrementalDelta >= 0);
         final boolean cannotScrollUp = (firstPosition + childCount == mItemCount &&
                 lastEnd <= end && incrementalDelta <= 0);
         if (cannotScrollDown || cannotScrollUp) {
             return incrementalDelta != 0;
         }
         final boolean inTouchMode = isInTouchMode();
         if (inTouchMode) {
             hideSelector();
         }
         int start = 0;
         int count = 0;
         final boolean down = (incrementalDelta < 0);
         if (down) {
             int childrenStart = -incrementalDelta + paddingStart;
             for (int i = 0; i < childCount; i++) {
                 final View child = getChildAt(i);
                 final int childEnd = (mIsVertical ? child.getBottom() : child.getRight());
                 if (childEnd >= childrenStart) {
                     break;
                 }
                 count++;
                 mRecycler.addScrapView(child, firstPosition + i);
             }
         } else {
             int childrenEnd = end - incrementalDelta;
             for (int i = childCount - 1; i >= 0; i--) {
                 final View child = getChildAt(i);
                 final int childStart = (mIsVertical ? child.getTop() : child.getLeft());
                 if (childStart <= childrenEnd) {
                     break;
                 }
                 start = i;
                 count++;
                 mRecycler.addScrapView(child, firstPosition + i);
             }
         }
         mBlockLayoutRequests = true;
         if (count > 0) {
             detachViewsFromParent(start, count);
         }
         // invalidate before moving the children to avoid unnecessary invalidate
         // calls to bubble up from the children all the way to the top
         if (!awakenScrollbarsInternal()) {
            invalidate();
         }
         offsetChildren(incrementalDelta);
         if (down) {
             mFirstPosition += count;
         }
         final int absIncrementalDelta = Math.abs(incrementalDelta);
         if (spaceBefore < absIncrementalDelta || spaceAfter < absIncrementalDelta) {
             fillGap(down);
         }
         if (!inTouchMode && mSelectedPosition != INVALID_POSITION) {
             final int childIndex = mSelectedPosition - mFirstPosition;
             if (childIndex >= 0 && childIndex < getChildCount()) {
                 positionSelector(mSelectedPosition, getChildAt(childIndex));
             }
         } else if (mSelectorPosition != INVALID_POSITION) {
             final int childIndex = mSelectorPosition - mFirstPosition;
             if (childIndex >= 0 && childIndex < getChildCount()) {
                 positionSelector(INVALID_POSITION, getChildAt(childIndex));
             }
         } else {
             mSelectorRect.setEmpty();
         }
         mBlockLayoutRequests = false;
         invokeOnItemScrollListener();
         return false;
     }
     @TargetApi(14)
     private final float getCurrVelocity() {
         if (Build.VERSION.SDK_INT >= 14) {
             return mScroller.getCurrVelocity();
         }
         return 0;
     }
     @TargetApi(5)
     private boolean awakenScrollbarsInternal() {
         if (Build.VERSION.SDK_INT >= 5) {
             return super.awakenScrollBars();
         } else {
             return false;
         }
     }
     @Override
     public void computeScroll() {
         if (!mScroller.computeScrollOffset()) {
             return;
         }
         final int pos;
         if (mIsVertical) {
             pos = mScroller.getCurrY();
         } else {
             pos = mScroller.getCurrX();
         }
         final int diff = (int) (pos - mLastTouchPos);
         mLastTouchPos = pos;
         final boolean stopped = trackMotionScroll(diff);
         if (!stopped && !mScroller.isFinished()) {
             ViewCompat.postInvalidateOnAnimation(this);
         } else {
             if (stopped) {
                 final int overScrollMode = ViewCompat.getOverScrollMode(this);
                 if (overScrollMode != ViewCompat.OVER_SCROLL_NEVER) {
                     final EdgeEffectCompat edge =
                             (diff > 0 ? mStartEdge : mEndEdge);
                     boolean needsInvalidate =
                             edge.onAbsorb(Math.abs((int) getCurrVelocity()));
                     if (needsInvalidate) {
                         ViewCompat.postInvalidateOnAnimation(this);
                     }
                 }
                 mScroller.abortAnimation();
             }
             mTouchMode = TOUCH_MODE_REST;
             reportScrollStateChange(OnScrollListener.SCROLL_STATE_IDLE);
         }
     }
     private void finishEdgeGlows() {
         if (mStartEdge != null) {
             mStartEdge.finish();
         }
         if (mEndEdge != null) {
             mEndEdge.finish();
         }
     }
     private boolean drawStartEdge(Canvas canvas) {
         if (mStartEdge.isFinished()) {
             return false;
         }
         if (mIsVertical) {
             return mStartEdge.draw(canvas);
         }
         final int restoreCount = canvas.save();
         final int height = getHeight() - getPaddingTop() - getPaddingBottom();
         canvas.translate(0, height);
         canvas.rotate(270);
         final boolean needsInvalidate = mStartEdge.draw(canvas);
         canvas.restoreToCount(restoreCount);
         return needsInvalidate;
     }
     private boolean drawEndEdge(Canvas canvas) {
         if (mEndEdge.isFinished()) {
             return false;
         }
         final int restoreCount = canvas.save();
         final int width = getWidth() - getPaddingLeft() - getPaddingRight();
         final int height = getHeight() - getPaddingTop() - getPaddingBottom();
         if (mIsVertical) {
             canvas.translate(-width, height);
             canvas.rotate(180, width, 0);
         } else {
             canvas.translate(width, 0);
             canvas.rotate(90);
         }
         final boolean needsInvalidate = mEndEdge.draw(canvas);
         canvas.restoreToCount(restoreCount);
         return needsInvalidate;
     }
     private void drawSelector(Canvas canvas) {
         if (!mSelectorRect.isEmpty()) {
             final Drawable selector = mSelector;
             selector.setBounds(mSelectorRect);
             selector.draw(canvas);
         }
     }
     private void useDefaultSelector() {
         setSelector(getResources().getDrawable(
                 android.R.drawable.list_selector_background));
     }
     private boolean shouldShowSelector() {
         return (hasFocus() && !isInTouchMode()) || touchModeDrawsInPressedState();
     }
     private void positionSelector(int position, View selected) {
         if (position != INVALID_POSITION) {
             mSelectorPosition = position;
         }
         mSelectorRect.set(selected.getLeft(), selected.getTop(), selected.getRight(),
                 selected.getBottom());
         final boolean isChildViewEnabled = mIsChildViewEnabled;
         if (selected.isEnabled() != isChildViewEnabled) {
             mIsChildViewEnabled = !isChildViewEnabled;
             if (getSelectedItemPosition() != INVALID_POSITION) {
                 refreshDrawableState();
             }
         }
     }
     private void hideSelector() {
         if (mSelectedPosition != INVALID_POSITION) {
             if (mLayoutMode != LAYOUT_SPECIFIC) {
                 mResurrectToPosition = mSelectedPosition;
             }
             if (mNextSelectedPosition >= 0 && mNextSelectedPosition != mSelectedPosition) {
                 mResurrectToPosition = mNextSelectedPosition;
             }
             setSelectedPositionInt(INVALID_POSITION);
             setNextSelectedPositionInt(INVALID_POSITION);
             mSelectedStart = 0;
         }
     }
     private void setSelectedPositionInt(int position) {
         mSelectedPosition = position;
         mSelectedRowId = getItemIdAtPosition(position);
     }
     private void setSelectionInt(int position) {
         setNextSelectedPositionInt(position);
         boolean awakeScrollbars = false;
         final int selectedPosition = mSelectedPosition;
         if (selectedPosition >= 0) {
             if (position == selectedPosition - 1) {
                 awakeScrollbars = true;
             } else if (position == selectedPosition + 1) {
                 awakeScrollbars = true;
             }
         }
         layoutChildren();
         if (awakeScrollbars) {
             awakenScrollbarsInternal();
         }
     }
     private void setNextSelectedPositionInt(int position) {
         mNextSelectedPosition = position;
         mNextSelectedRowId = getItemIdAtPosition(position);
         // If we are trying to sync to the selection, update that too
         if (mNeedSync && mSyncMode == SYNC_SELECTED_POSITION && position >= 0) {
             mSyncPosition = position;
             mSyncRowId = mNextSelectedRowId;
         }
     }
     private boolean touchModeDrawsInPressedState() {
         switch (mTouchMode) {
         case TOUCH_MODE_TAP:
         case TOUCH_MODE_DONE_WAITING:
             return true;
         default:
             return false;
         }
     }
     /**
      * Sets the selector state to "pressed" and posts a CheckForKeyLongPress to see if
      * this is a long press.
      */
     private void keyPressed() {
         if (!isEnabled() || !isClickable()) {
             return;
         }
         final Drawable selector = mSelector;
         final Rect selectorRect = mSelectorRect;
         if (selector != null && (isFocused() || touchModeDrawsInPressedState())
                 && !selectorRect.isEmpty()) {
             final View child = getChildAt(mSelectedPosition - mFirstPosition);
             if (child != null) {
                 if (child.hasFocusable()) {
                     return;
                 }
                 child.setPressed(true);
             }
             setPressed(true);
             final boolean longClickable = isLongClickable();
             final Drawable d = selector.getCurrent();
             if (d != null && d instanceof TransitionDrawable) {
                 if (longClickable) {
                     ((TransitionDrawable) d).startTransition(
                             ViewConfiguration.getLongPressTimeout());
                 } else {
                     ((TransitionDrawable) d).resetTransition();
                 }
             }
             if (longClickable && !mDataChanged) {
                 if (mPendingCheckForKeyLongPress == null) {
                     mPendingCheckForKeyLongPress = new CheckForKeyLongPress();
                 }
                 mPendingCheckForKeyLongPress.rememberWindowAttachCount();
                 postDelayed(mPendingCheckForKeyLongPress, ViewConfiguration.getLongPressTimeout());
             }
         }
     }
     private void updateSelectorState() {
         if (mSelector != null) {
             if (shouldShowSelector()) {
                 mSelector.setState(getDrawableState());
             } else {
                 mSelector.setState(STATE_NOTHING);
             }
         }
     }
     private void checkSelectionChanged() {
         if ((mSelectedPosition != mOldSelectedPosition) || (mSelectedRowId != mOldSelectedRowId)) {
             selectionChanged();
             mOldSelectedPosition = mSelectedPosition;
             mOldSelectedRowId = mSelectedRowId;
         }
     }
     private void selectionChanged() {
         OnItemSelectedListener listener = getOnItemSelectedListener();
         if (listener == null) {
             return;
         }
         if (mInLayout || mBlockLayoutRequests) {
             // If we are in a layout traversal, defer notification
             // by posting. This ensures that the view tree is
             // in a consistent state and is able to accommodate
             // new layout or invalidate requests.
             if (mSelectionNotifier == null) {
                 mSelectionNotifier = new SelectionNotifier();
             }
             post(mSelectionNotifier);
         } else {
             fireOnSelected();
             performAccessibilityActionsOnSelected();
         }
     }
     private void fireOnSelected() {
         OnItemSelectedListener listener = getOnItemSelectedListener();
         if (listener == null) {
             return;
         }
         final int selection = getSelectedItemPosition();
         if (selection >= 0) {
             View v = getSelectedView();
             listener.onItemSelected(this, v, selection,
                     mAdapter.getItemId(selection));
         } else {
             listener.onNothingSelected(this);
         }
     }
     private void performAccessibilityActionsOnSelected() {
         final int position = getSelectedItemPosition();
         if (position >= 0) {
             // We fire selection events here not in View
             sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_SELECTED);
         }
     }
     private int lookForSelectablePosition(int position) {
         return lookForSelectablePosition(position, true);
     }
     private int lookForSelectablePosition(int position, boolean lookDown) {
         final ListAdapter adapter = mAdapter;
         if (adapter == null || isInTouchMode()) {
             return INVALID_POSITION;
         }
         final int itemCount = mItemCount;
         if (!mAreAllItemsSelectable) {
             if (lookDown) {
                 position = Math.max(0, position);
                 while (position < itemCount && !adapter.isEnabled(position)) {
                     position++;
                 }
             } else {
                 position = Math.min(position, itemCount - 1);
                 while (position >= 0 && !adapter.isEnabled(position)) {
                     position--;
                 }
             }
             if (position < 0 || position >= itemCount) {
                 return INVALID_POSITION;
             }
             return position;
         } else {
             if (position < 0 || position >= itemCount) {
                 return INVALID_POSITION;
             }
             return position;
         }
     }
     /**
      * @param direction either {@link View#FOCUS_UP} or {@link View#FOCUS_DOWN} or
      *        {@link View#FOCUS_LEFT} or {@link View#FOCUS_RIGHT} depending on the
      *        current view orientation.
      *
      * @return The position of the next selectable position of the views that
      *         are currently visible, taking into account the fact that there might
      *         be no selection.  Returns {@link #INVALID_POSITION} if there is no
      *         selectable view on screen in the given direction.
      */
     private int lookForSelectablePositionOnScreen(int direction) {
         forceValidFocusDirection(direction);
         final int firstPosition = mFirstPosition;
         final ListAdapter adapter = getAdapter();
         if (direction == View.FOCUS_DOWN || direction == View.FOCUS_RIGHT) {
             int startPos = (mSelectedPosition != INVALID_POSITION ?
                     mSelectedPosition + 1 : firstPosition);
             if (startPos >= adapter.getCount()) {
                 return INVALID_POSITION;
             }
             if (startPos < firstPosition) {
                 startPos = firstPosition;
             }
             final int lastVisiblePos = getLastVisiblePosition();
             for (int pos = startPos; pos <= lastVisiblePos; pos++) {
                 if (adapter.isEnabled(pos)
                         && getChildAt(pos - firstPosition).getVisibility() == View.VISIBLE) {
                     return pos;
                 }
             }
         } else {
             final int last = firstPosition + getChildCount() - 1;
             int startPos = (mSelectedPosition != INVALID_POSITION) ?
                     mSelectedPosition - 1 : firstPosition + getChildCount() - 1;
             if (startPos < 0 || startPos >= adapter.getCount()) {
                 return INVALID_POSITION;
             }
             if (startPos > last) {
                 startPos = last;
             }
             for (int pos = startPos; pos >= firstPosition; pos--) {
                 if (adapter.isEnabled(pos)
                         && getChildAt(pos - firstPosition).getVisibility() == View.VISIBLE) {
                     return pos;
                 }
             }
         }
         return INVALID_POSITION;
     }
     @Override
     protected void drawableStateChanged() {
         super.drawableStateChanged();
         updateSelectorState();
     }
     @Override
     protected int[] onCreateDrawableState(int extraSpace) {
         // If the child view is enabled then do the default behavior.
         if (mIsChildViewEnabled) {
             // Common case
             return super.onCreateDrawableState(extraSpace);
         }
         // The selector uses this View's drawable state. The selected child view
         // is disabled, so we need to remove the enabled state from the drawable
         // states.
         final int enabledState = ENABLED_STATE_SET[0];
         // If we don't have any extra space, it will return one of the static state arrays,
         // and clearing the enabled state on those arrays is a bad thing!  If we specify
         // we need extra space, it will create+copy into a new array that safely mutable.
         int[] state = super.onCreateDrawableState(extraSpace + 1);
         int enabledPos = -1;
         for (int i = state.length - 1; i >= 0; i--) {
             if (state[i] == enabledState) {
                 enabledPos = i;
                 break;
             }
         }
         // Remove the enabled state
         if (enabledPos >= 0) {
             System.arraycopy(state, enabledPos + 1, state, enabledPos,
                     state.length - enabledPos - 1);
         }
         return state;
     }
     @Override
     protected boolean canAnimate() {
         return (super.canAnimate() && mItemCount > 0);
     }
     @Override
     protected void dispatchDraw(Canvas canvas) {
         final boolean drawSelectorOnTop = mDrawSelectorOnTop;
         if (!drawSelectorOnTop) {
             drawSelector(canvas);
         }
         super.dispatchDraw(canvas);
         if (drawSelectorOnTop) {
             drawSelector(canvas);
         }
     }
     @Override
     public void draw(Canvas canvas) {
         super.draw(canvas);
         boolean needsInvalidate = false;
         if (mStartEdge != null) {
             needsInvalidate |= drawStartEdge(canvas);
         }
         if (mEndEdge != null) {
             needsInvalidate |= drawEndEdge(canvas);
         }
         if (needsInvalidate) {
             ViewCompat.postInvalidateOnAnimation(this);
         }
     }
     @Override
     public void requestLayout() {
         if (!mInLayout && !mBlockLayoutRequests) {
             super.requestLayout();
         }
     }
     @Override
     public View getSelectedView() {
         if (mItemCount > 0 && mSelectedPosition >= 0) {
             return getChildAt(mSelectedPosition - mFirstPosition);
         } else {
             return null;
         }
     }
     @Override
     public void setSelection(int position) {
         setSelectionFromOffset(position, 0);
     }
     public void setSelectionFromOffset(int position, int offset) {
         if (mAdapter == null) {
             return;
         }
         if (!isInTouchMode()) {
             position = lookForSelectablePosition(position);
             if (position >= 0) {
                 setNextSelectedPositionInt(position);
             }
         } else {
             mResurrectToPosition = position;
         }
         if (position >= 0) {
             mLayoutMode = LAYOUT_SPECIFIC;
             if (mIsVertical) {
                 mSpecificStart = getPaddingTop() + offset;
             } else {
                 mSpecificStart = getPaddingLeft() + offset;
             }
             if (mNeedSync) {
                 mSyncPosition = position;
                 mSyncRowId = mAdapter.getItemId(position);
             }
             requestLayout();
         }
     }
     @Override
     public boolean dispatchKeyEvent(KeyEvent event) {
         // Dispatch in the normal way
         boolean handled = super.dispatchKeyEvent(event);
         if (!handled) {
             // If we didn't handle it...
             final View focused = getFocusedChild();
             if (focused != null && event.getAction() == KeyEvent.ACTION_DOWN) {
                 // ... and our focused child didn't handle it
                 // ... give it to ourselves so we can scroll if necessary
                 handled = onKeyDown(event.getKeyCode(), event);
             }
         }
         return handled;
     }
     @Override
     protected void dispatchSetPressed(boolean pressed) {
         // Don't dispatch setPressed to our children. We call setPressed on ourselves to
         // get the selector in the right state, but we don't want to press each child.
     }
     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         if (mSelector == null) {
             useDefaultSelector();
         }
         int widthMode = MeasureSpec.getMode(widthMeasureSpec);
         int heightMode = MeasureSpec.getMode(heightMeasureSpec);
         int widthSize = MeasureSpec.getSize(widthMeasureSpec);
         int heightSize = MeasureSpec.getSize(heightMeasureSpec);
         int childWidth = 0;
         int childHeight = 0;
         mItemCount = (mAdapter == null ? 0 : mAdapter.getCount());
         if (mItemCount > 0 && (widthMode == MeasureSpec.UNSPECIFIED ||
                 heightMode == MeasureSpec.UNSPECIFIED)) {
             final View child = obtainView(0, mIsScrap);
             final int secondaryMeasureSpec =
                     (mIsVertical ? widthMeasureSpec : heightMeasureSpec);
             measureScrapChild(child, 0, secondaryMeasureSpec);
             childWidth = child.getMeasuredWidth();
             childHeight = child.getMeasuredHeight();
             if (recycleOnMeasure()) {
                 mRecycler.addScrapView(child, -1);
             }
         }
         if (widthMode == MeasureSpec.UNSPECIFIED) {
             widthSize = getPaddingLeft() + getPaddingRight() + childWidth;
             if (mIsVertical) {
                 widthSize += getVerticalScrollbarWidth();
             }
         }
         if (heightMode == MeasureSpec.UNSPECIFIED) {
             heightSize = getPaddingTop() + getPaddingBottom() + childHeight;
             if (!mIsVertical) {
                 heightSize += getHorizontalScrollbarHeight();
             }
         }
         if (mIsVertical && heightMode == MeasureSpec.AT_MOST) {
             heightSize = measureHeightOfChildren(widthMeasureSpec, 0, NO_POSITION, heightSize, -1);
         }
         if (!mIsVertical && widthMode == MeasureSpec.AT_MOST) {
             widthSize = measureWidthOfChildren(heightMeasureSpec, 0, NO_POSITION, widthSize, -1);
         }
         setMeasuredDimension(widthSize, heightSize);
     }
     @Override
     protected void onLayout(boolean changed, int l, int t, int r, int b) {
         mInLayout = true;
         if (changed) {
             final int childCount = getChildCount();
             for (int i = 0; i < childCount; i++) {
                 getChildAt(i).forceLayout();
             }
             mRecycler.markChildrenDirty();
         }
         layoutChildren();
         mInLayout = false;
         final int width = r - l - getPaddingLeft() - getPaddingRight();
         final int height = b - t - getPaddingTop() - getPaddingBottom();
         if (mStartEdge != null && mEndEdge != null) {
             if (mIsVertical) {
                 mStartEdge.setSize(width, height);
                 mEndEdge.setSize(width, height);
             } else {
                 mStartEdge.setSize(height, width);
                 mEndEdge.setSize(height, width);
             }
         }
     }
     private void layoutChildren() {
         if (getWidth() == 0 || getHeight() == 0) {
             return;
         }
         final boolean blockLayoutRequests = mBlockLayoutRequests;
         if (!blockLayoutRequests) {
             mBlockLayoutRequests = true;
         } else {
             return;
         }
         try {
             invalidate();
             if (mAdapter == null) {
                 resetState();
                 return;
             }
             final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft());
             final int end =
                     (mIsVertical ? getHeight() - getPaddingBottom() : getWidth() - getPaddingRight());
             int childCount = getChildCount();
             int index = 0;
             int delta = 0;
             View focusLayoutRestoreView = null;
             View selected = null;
             View oldSelected = null;
             View newSelected = null;
             View oldFirstChild = null;
             switch (mLayoutMode) {
             case LAYOUT_SET_SELECTION:
                 index = mNextSelectedPosition - mFirstPosition;
                 if (index >= 0 && index < childCount) {
                     newSelected = getChildAt(index);
                 }
                 break;
             case LAYOUT_FORCE_TOP:
             case LAYOUT_FORCE_BOTTOM:
             case LAYOUT_SPECIFIC:
             case LAYOUT_SYNC:
                 break;
             case LAYOUT_MOVE_SELECTION:
             default:
                 // Remember the previously selected view
                 index = mSelectedPosition - mFirstPosition;
                 if (index >= 0 && index < childCount) {
                     oldSelected = getChildAt(index);
                 }
                 // Remember the previous first child
                 oldFirstChild = getChildAt(0);
                 if (mNextSelectedPosition >= 0) {
                     delta = mNextSelectedPosition - mSelectedPosition;
                 }
                 // Caution: newSelected might be null
                 newSelected = getChildAt(index + delta);
             }
             final boolean dataChanged = mDataChanged;
             if (dataChanged) {
                 handleDataChanged();
             }
             // Handle the empty set by removing all views that are visible
             // and calling it a day
             if (mItemCount == 0) {
                 resetState();
                 return;
             } else if (mItemCount != mAdapter.getCount()) {
                 throw new IllegalStateException("The content of the adapter has changed but "
                         + "TwoWayView did not receive a notification. Make sure the content of "
                         + "your adapter is not modified from a background thread, but only "
                         + "from the UI thread. [in TwoWayView(" + getId() + ", " + getClass()
                         + ") with Adapter(" + mAdapter.getClass() + ")]");
             }
             setSelectedPositionInt(mNextSelectedPosition);
             // Reset the focus restoration
             View focusLayoutRestoreDirectChild = null;
             // Pull all children into the RecycleBin.
             // These views will be reused if possible
             final int firstPosition = mFirstPosition;
             final RecycleBin recycleBin = mRecycler;
             if (dataChanged) {
                 for (int i = 0; i < childCount; i++) {
                     recycleBin.addScrapView(getChildAt(i), firstPosition + i);
                 }
             } else {
                 recycleBin.fillActiveViews(childCount, firstPosition);
             }
             // Take focus back to us temporarily to avoid the eventual
             // call to clear focus when removing the focused child below
             // from messing things up when ViewAncestor assigns focus back
             // to someone else.
             final View focusedChild = getFocusedChild();
             if (focusedChild != null) {
                 // We can remember the focused view to restore after relayout if the
                 // data hasn't changed, or if the focused position is a header or footer.
                 if (!dataChanged) {
                     focusLayoutRestoreDirectChild = focusedChild;
                     // Remember the specific view that had focus
                     focusLayoutRestoreView = findFocus();
                     if (focusLayoutRestoreView != null) {
                         // Tell it we are going to mess with it
                         focusLayoutRestoreView.onStartTemporaryDetach();
                     }
                 }
                 requestFocus();
             }
             // FIXME: We need a way to save current accessibility focus here
             // so that it can be restored after we re-attach the children on each
             // layout round.
             detachAllViewsFromParent();
             switch (mLayoutMode) {
             case LAYOUT_SET_SELECTION:
                 if (newSelected != null) {
                     final int newSelectedStart =
                             (mIsVertical ? newSelected.getTop() : newSelected.getLeft());
                     selected = fillFromSelection(newSelectedStart, start, end);
                 } else {
                     selected = fillFromMiddle(start, end);
                 }
                 break;
             case LAYOUT_SYNC:
                 selected = fillSpecific(mSyncPosition, mSpecificStart);
                 break;
             case LAYOUT_FORCE_BOTTOM:
                 selected = fillBefore(mItemCount - 1, end);
                 adjustViewsStartOrEnd();
                 break;
             case LAYOUT_FORCE_TOP:
                 mFirstPosition = 0;
                 selected = fillFromOffset(start);
                 adjustViewsStartOrEnd();
                 break;
             case LAYOUT_SPECIFIC:
                 selected = fillSpecific(reconcileSelectedPosition(), mSpecificStart);
                 break;
             case LAYOUT_MOVE_SELECTION:
                 selected = moveSelection(oldSelected, newSelected, delta, start, end);
                 break;
             default:
                 if (childCount == 0) {
                     final int position = lookForSelectablePosition(0);
                     setSelectedPositionInt(position);
                     selected = fillFromOffset(start);
                 } else {
                     if (mSelectedPosition >= 0 && mSelectedPosition < mItemCount) {
                         int offset = start;
                         if (oldSelected != null) {
                             offset = (mIsVertical ? oldSelected.getTop() : oldSelected.getLeft());
                         }
                         selected = fillSpecific(mSelectedPosition, offset);
                     } else if (mFirstPosition < mItemCount) {
                         int offset = start;
                         if (oldFirstChild != null) {
                             offset = (mIsVertical ? oldFirstChild.getTop() : oldFirstChild.getLeft());
                         }
                         selected = fillSpecific(mFirstPosition, offset);
                     } else {
                         selected = fillSpecific(0, start);
                     }
                 }
                 break;
             }
             recycleBin.scrapActiveViews();
             if (selected != null) {
                 if (mItemsCanFocus && hasFocus() && !selected.hasFocus()) {
                     final boolean focusWasTaken = (selected == focusLayoutRestoreDirectChild &&
                             focusLayoutRestoreView != null &&
                             focusLayoutRestoreView.requestFocus()) || selected.requestFocus();
                     if (!focusWasTaken) {
                         // Selected item didn't take focus, fine, but still want
                         // to make sure something else outside of the selected view
                         // has focus
                         final View focused = getFocusedChild();
                         if (focused != null) {
                             focused.clearFocus();
                         }
                         positionSelector(INVALID_POSITION, selected);
                     } else {
                         selected.setSelected(false);
                         mSelectorRect.setEmpty();
                     }
                 } else {
                     positionSelector(INVALID_POSITION, selected);
                 }
                 mSelectedStart = (mIsVertical ? selected.getTop() : selected.getLeft());
             } else {
                 if (mTouchMode > TOUCH_MODE_DOWN && mTouchMode < TOUCH_MODE_DRAGGING) {
                     View child = getChildAt(mMotionPosition - mFirstPosition);
                     if (child != null) {
                         positionSelector(mMotionPosition, child);
                     }
                 } else {
                     mSelectedStart = 0;
                     mSelectorRect.setEmpty();
                 }
                 // Even if there is not selected position, we may need to restore
                 // focus (i.e. something focusable in touch mode)
                 if (hasFocus() && focusLayoutRestoreView != null) {
                     focusLayoutRestoreView.requestFocus();
                 }
             }
             // Tell focus view we are done mucking with it, if it is still in
             // our view hierarchy.
             if (focusLayoutRestoreView != null
                     && focusLayoutRestoreView.getWindowToken() != null) {
                 focusLayoutRestoreView.onFinishTemporaryDetach();
             }
             mLayoutMode = LAYOUT_NORMAL;
             mDataChanged = false;
             mNeedSync = false;
             setNextSelectedPositionInt(mSelectedPosition);
             if (mItemCount > 0) {
                 checkSelectionChanged();
             }
             invokeOnItemScrollListener();
         } finally {
             if (!blockLayoutRequests) {
                 mBlockLayoutRequests = false;
                 mDataChanged = false;
             }
         }
     }
     protected boolean recycleOnMeasure() {
         return true;
     }
     private void offsetChildren(int offset) {
         final int childCount = getChildCount();
         for (int i = 0; i < childCount; i++) {
             final View child = getChildAt(i);
             if (mIsVertical) {
                 child.offsetTopAndBottom(offset);
             } else {
                 child.offsetLeftAndRight(offset);
             }
         }
     }
     private View moveSelection(View oldSelected, View newSelected, int delta, int start,
             int end) {
         final int selectedPosition = mSelectedPosition;
         final int oldSelectedStart = (mIsVertical ? oldSelected.getTop() : oldSelected.getLeft());
         final int oldSelectedEnd = (mIsVertical ? oldSelected.getBottom() : oldSelected.getRight());
         View selected = null;
         if (delta > 0) {
             /*
              * Case 1: Scrolling down.
              */
             /*
              *     Before           After
              *    |       |        |       |
              *    +-------+        +-------+
              *    |   A   |        |   A   |
              *    |   1   |   =>   +-------+
              *    +-------+        |   B   |
              *    |   B   |        |   2   |
              *    +-------+        +-------+
              *    |       |        |       |
              *
              *    Try to keep the top of the previously selected item where it was.
              *    oldSelected = A
              *    selected = B
              */
             // Put oldSelected (A) where it belongs
             oldSelected = makeAndAddView(selectedPosition - 1, oldSelectedStart, true, false);
             final int itemMargin = mItemMargin;
             // Now put the new selection (B) below that
             selected = makeAndAddView(selectedPosition, oldSelectedEnd + itemMargin, true, true);
             final int selectedStart = (mIsVertical ? selected.getTop() : selected.getLeft());
             final int selectedEnd = (mIsVertical ? selected.getBottom() : selected.getRight());
             // Some of the newly selected item extends below the bottom of the list
             if (selectedEnd > end) {
                 // Find space available above the selection into which we can scroll upwards
                 final int spaceBefore = selectedStart - start;
                 // Find space required to bring the bottom of the selected item fully into view
                 final int spaceAfter = selectedEnd - end;
                 // Don't scroll more than half the size of the list
                 final int halfSpace = (end - start) / 2;
                 int offset = Math.min(spaceBefore, spaceAfter);
                 offset = Math.min(offset, halfSpace);
                 if (mIsVertical) {
                     oldSelected.offsetTopAndBottom(-offset);
                     selected.offsetTopAndBottom(-offset);
                 } else {
                     oldSelected.offsetLeftAndRight(-offset);
                     selected.offsetLeftAndRight(-offset);
                 }
             }
             // Fill in views before and after
             fillBefore(mSelectedPosition - 2, selectedStart - itemMargin);
             adjustViewsStartOrEnd();
             fillAfter(mSelectedPosition + 1, selectedEnd + itemMargin);
         } else if (delta < 0) {
             /*
              * Case 2: Scrolling up.
              */
             /*
              *     Before           After
              *    |       |        |       |
              *    +-------+        +-------+
              *    |   A   |        |   A   |
              *    +-------+   =>   |   1   |
              *    |   B   |        +-------+
              *    |   2   |        |   B   |
              *    +-------+        +-------+
              *    |       |        |       |
              *
              *    Try to keep the top of the item about to become selected where it was.
              *    newSelected = A
              *    olSelected = B
              */
             if (newSelected != null) {
                 // Try to position the top of newSel (A) where it was before it was selected
                 final int newSelectedStart = (mIsVertical ? newSelected.getTop() : newSelected.getLeft());
                 selected = makeAndAddView(selectedPosition, newSelectedStart, true, true);
             } else {
                 // If (A) was not on screen and so did not have a view, position
                 // it above the oldSelected (B)
                 selected = makeAndAddView(selectedPosition, oldSelectedStart, false, true);
             }
             final int selectedStart = (mIsVertical ? selected.getTop() : selected.getLeft());
             final int selectedEnd = (mIsVertical ? selected.getBottom() : selected.getRight());
             // Some of the newly selected item extends above the top of the list
             if (selectedStart < start) {
                 // Find space required to bring the top of the selected item fully into view
                 final int spaceBefore = start - selectedStart;
                // Find space available below the selection into which we can scroll downwards
                 final int spaceAfter = end - selectedEnd;
                 // Don't scroll more than half the height of the list
                 final int halfSpace = (end - start) / 2;
                 int offset = Math.min(spaceBefore, spaceAfter);
                 offset = Math.min(offset, halfSpace);
                 if (mIsVertical) {
                     selected.offsetTopAndBottom(offset);
                 } else {
                     selected.offsetLeftAndRight(offset);
                 }
             }
             // Fill in views above and below
             fillBeforeAndAfter(selected, selectedPosition);
         } else {
             /*
              * Case 3: Staying still
              */
             selected = makeAndAddView(selectedPosition, oldSelectedStart, true, true);
             final int selectedStart = (mIsVertical ? selected.getTop() : selected.getLeft());
             final int selectedEnd = (mIsVertical ? selected.getBottom() : selected.getRight());
             // We're staying still...
             if (oldSelectedStart < start) {
                 // ... but the top of the old selection was off screen.
                 // (This can happen if the data changes size out from under us)
                 int newEnd = selectedEnd;
                 if (newEnd < start + 20) {
                     // Not enough visible -- bring it onscreen
                     if (mIsVertical) {
                         selected.offsetTopAndBottom(start - selectedStart);
                     } else {
                         selected.offsetLeftAndRight(start - selectedStart);
                     }
                 }
             }
             // Fill in views above and below
             fillBeforeAndAfter(selected, selectedPosition);
         }
         return selected;
     }
     void confirmCheckedPositionsById() {
         // Clear out the positional check states, we'll rebuild it below from IDs.
         mCheckStates.clear();
         for (int checkedIndex = 0; checkedIndex < mCheckedIdStates.size(); checkedIndex++) {
             final long id = mCheckedIdStates.keyAt(checkedIndex);
             final int lastPos = mCheckedIdStates.valueAt(checkedIndex);
             final long lastPosId = mAdapter.getItemId(lastPos);
             if (id != lastPosId) {
                 // Look around to see if the ID is nearby. If not, uncheck it.
                 final int start = Math.max(0, lastPos - CHECK_POSITION_SEARCH_DISTANCE);
                 final int end = Math.min(lastPos + CHECK_POSITION_SEARCH_DISTANCE, mItemCount);
                 boolean found = false;
                 for (int searchPos = start; searchPos < end; searchPos++) {
                     final long searchId = mAdapter.getItemId(searchPos);
                     if (id == searchId) {
                         found = true;
                         mCheckStates.put(searchPos, true);
                         mCheckedIdStates.setValueAt(checkedIndex, searchPos);
                         break;
                     }
                 }
                 if (!found) {
                     mCheckedIdStates.delete(id);
                     checkedIndex--;
                     mCheckedItemCount--;
                 }
             } else {
                 mCheckStates.put(lastPos, true);
             }
         }
     }
     private void handleDataChanged() {
         if (mChoiceMode.compareTo(ChoiceMode.NONE) != 0 && mAdapter != null && mAdapter.hasStableIds()) {
             confirmCheckedPositionsById();
         }
         mRecycler.clearTransientStateViews();
         final int itemCount = mItemCount;
         if (itemCount > 0) {
             int newPos;
             int selectablePos;
             // Find the row we are supposed to sync to
             if (mNeedSync) {
                 // Update this first, since setNextSelectedPositionInt inspects it
                 mNeedSync = false;
                 mPendingSync = null;
                 switch (mSyncMode) {
                 case SYNC_SELECTED_POSITION:
                     if (isInTouchMode()) {
                         // We saved our state when not in touch mode. (We know this because
                         // mSyncMode is SYNC_SELECTED_POSITION.) Now we are trying to
                         // restore in touch mode. Just leave mSyncPosition as it is (possibly
                         // adjusting if the available range changed) and return.
                         mLayoutMode = LAYOUT_SYNC;
                         mSyncPosition = Math.min(Math.max(0, mSyncPosition), itemCount - 1);
                         return;
                     } else {
                         // See if we can find a position in the new data with the same
                         // id as the old selection. This will change mSyncPosition.
                         newPos = findSyncPosition();
                         if (newPos >= 0) {
                             // Found it. Now verify that new selection is still selectable
                             selectablePos = lookForSelectablePosition(newPos, true);
                             if (selectablePos == newPos) {
                                 // Same row id is selected
                                 mSyncPosition = newPos;
                                 if (mSyncHeight == getHeight()) {
                                     // If we are at the same height as when we saved state, try
                                     // to restore the scroll position too.
                                     mLayoutMode = LAYOUT_SYNC;
                                 } else {
                                     // We are not the same height as when the selection was saved, so
                                     // don't try to restore the exact position
                                     mLayoutMode = LAYOUT_SET_SELECTION;
                                 }
                                 // Restore selection
                                 setNextSelectedPositionInt(newPos);
                                 return;
                             }
                         }
                     }
                     break;
                 case SYNC_FIRST_POSITION:
                     // Leave mSyncPosition as it is -- just pin to available range
                     mLayoutMode = LAYOUT_SYNC;
                     mSyncPosition = Math.min(Math.max(0, mSyncPosition), itemCount - 1);
                     return;
                 }
             }
             if (!isInTouchMode()) {
                 // We couldn't find matching data -- try to use the same position
                 newPos = getSelectedItemPosition();
                 // Pin position to the available range
                 if (newPos >= itemCount) {
                     newPos = itemCount - 1;
                 }
                 if (newPos < 0) {
                     newPos = 0;
                 }
                 // Make sure we select something selectable -- first look down
                 selectablePos = lookForSelectablePosition(newPos, true);
                 if (selectablePos >= 0) {
                     setNextSelectedPositionInt(selectablePos);
                     return;
                 } else {
                     // Looking down didn't work -- try looking up
                     selectablePos = lookForSelectablePosition(newPos, false);
                     if (selectablePos >= 0) {
                         setNextSelectedPositionInt(selectablePos);
                         return;
                     }
                 }
             } else {
                 // We already know where we want to resurrect the selection
                 if (mResurrectToPosition >= 0) {
                     return;
                 }
             }
         }
         // Nothing is selected. Give up and reset everything.
         mLayoutMode = LAYOUT_FORCE_TOP;
         mSelectedPosition = INVALID_POSITION;
         mSelectedRowId = INVALID_ROW_ID;
         mNextSelectedPosition = INVALID_POSITION;
         mNextSelectedRowId = INVALID_ROW_ID;
         mNeedSync = false;
         mPendingSync = null;
         mSelectorPosition = INVALID_POSITION;
         checkSelectionChanged();
     }
     private int reconcileSelectedPosition() {
         int position = mSelectedPosition;
         if (position < 0) {
             position = mResurrectToPosition;
         }
         position = Math.max(0, position);
         position = Math.min(position, mItemCount - 1);
         return position;
     }
     boolean resurrectSelection() {
         final int childCount = getChildCount();
         if (childCount <= 0) {
             return false;
         }
         int selectedStart = 0;
         int selectedPosition;
         final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft());
         final int end =
                 (mIsVertical ? getHeight() - getPaddingBottom() : getWidth() - getPaddingRight());
         final int firstPosition = mFirstPosition;
         final int toPosition = mResurrectToPosition;
         boolean down = true;
         if (toPosition >= firstPosition && toPosition < firstPosition + childCount) {
             selectedPosition = toPosition;
             final View selected = getChildAt(selectedPosition - mFirstPosition);
             selectedStart = (mIsVertical ? selected.getTop() : selected.getLeft());
         } else if (toPosition < firstPosition) {
             // Default to selecting whatever is first
             selectedPosition = firstPosition;
             for (int i = 0; i < childCount; i++) {
                 final View child = getChildAt(i);
                 final int childStart = (mIsVertical ? child.getTop() : child.getLeft());
                 if (i == 0) {
                     // Remember the position of the first item
                     selectedStart = childStart;
                 }
                 if (childStart >= start) {
                     // Found a view whose top is fully visible
                     selectedPosition = firstPosition + i;
                     selectedStart = childStart;
                     break;
                 }
             }
         } else {
             selectedPosition = firstPosition + childCount - 1;
             down = false;
             for (int i = childCount - 1; i >= 0; i--) {
                 final View child = getChildAt(i);
                 final int childStart = (mIsVertical ? child.getTop() : child.getLeft());
                 final int childEnd = (mIsVertical ? child.getBottom() : child.getRight());
                 if (i == childCount - 1) {
                     selectedStart = childStart;
                 }
                 if (childEnd <= end) {
                     selectedPosition = firstPosition + i;
                     selectedStart = childStart;
                     break;
                 }
             }
         }
         mResurrectToPosition = INVALID_POSITION;
         mTouchMode = TOUCH_MODE_REST;
         reportScrollStateChange(OnScrollListener.SCROLL_STATE_IDLE);
         mSpecificStart = selectedStart;
         selectedPosition = lookForSelectablePosition(selectedPosition, down);
         if (selectedPosition >= firstPosition && selectedPosition <= getLastVisiblePosition()) {
             mLayoutMode = LAYOUT_SPECIFIC;
             updateSelectorState();
             setSelectionInt(selectedPosition);
             invokeOnItemScrollListener();
         } else {
             selectedPosition = INVALID_POSITION;
         }
         return selectedPosition >= 0;
     }
     /**
      * If there is a selection returns false.
      * Otherwise resurrects the selection and returns true if resurrected.
      */
     boolean resurrectSelectionIfNeeded() {
         if (mSelectedPosition < 0 && resurrectSelection()) {
             updateSelectorState();
             return true;
         }
         return false;
     }
     private int getChildWidthMeasureSpec(LayoutParams lp) {
         if (!mIsVertical && lp.width == LayoutParams.WRAP_CONTENT) {
             return MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
         } else if (mIsVertical) {
             final int maxWidth = getWidth() - getPaddingLeft() - getPaddingRight();
             return MeasureSpec.makeMeasureSpec(maxWidth, MeasureSpec.EXACTLY);
         } else {
             return MeasureSpec.makeMeasureSpec(lp.width, MeasureSpec.EXACTLY);
         }
     }
     private int getChildHeightMeasureSpec(LayoutParams lp) {
         if (mIsVertical && lp.height == LayoutParams.WRAP_CONTENT) {
             return MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
         } else if (!mIsVertical) {
             final int maxHeight = getHeight() - getPaddingTop() - getPaddingBottom();
             return MeasureSpec.makeMeasureSpec(maxHeight, MeasureSpec.EXACTLY);
         } else {
             return MeasureSpec.makeMeasureSpec(lp.height, MeasureSpec.EXACTLY);
         }
     }
     private void measureChild(View child) {
         measureChild(child, (LayoutParams) child.getLayoutParams());
     }
     private void measureChild(View child, LayoutParams lp) {
         final int widthSpec = getChildWidthMeasureSpec(lp);
         final int heightSpec = getChildHeightMeasureSpec(lp);
         child.measure(widthSpec, heightSpec);
     }
     private void relayoutMeasuredChild(View child) {
         final int w = child.getMeasuredWidth();
         final int h = child.getMeasuredHeight();
         final int childLeft = getPaddingLeft();
         final int childRight = childLeft + w;
         final int childTop = child.getTop();
         final int childBottom = childTop + h;
         child.layout(childLeft, childTop, childRight, childBottom);
     }
     private void measureScrapChild(View scrapChild, int position, int secondaryMeasureSpec) {
         LayoutParams lp = (LayoutParams) scrapChild.getLayoutParams();
         if (lp == null) {
             lp = generateDefaultLayoutParams();
             scrapChild.setLayoutParams(lp);
         }
         lp.viewType = mAdapter.getItemViewType(position);
         lp.forceAdd = true;
         final int widthMeasureSpec;
         final int heightMeasureSpec;
         if (mIsVertical) {
             widthMeasureSpec = secondaryMeasureSpec;
             heightMeasureSpec = getChildHeightMeasureSpec(lp);
         } else {
             widthMeasureSpec = getChildWidthMeasureSpec(lp);
             heightMeasureSpec = secondaryMeasureSpec;
         }
         scrapChild.measure(widthMeasureSpec, heightMeasureSpec);
     }
     /**
      * Measures the height of the given range of children (inclusive) and
      * returns the height with this TwoWayView's padding and item margin heights
      * included. If maxHeight is provided, the measuring will stop when the
      * current height reaches maxHeight.
      *
      * @param widthMeasureSpec The width measure spec to be given to a child's
      *            {@link View#measure(int, int)}.
      * @param startPosition The position of the first child to be shown.
      * @param endPosition The (inclusive) position of the last child to be
      *            shown. Specify {@link #NO_POSITION} if the last child should be
      *            the last available child from the adapter.
      * @param maxHeight The maximum height that will be returned (if all the
      *            children don't fit in this value, this value will be
      *            returned).
      * @param disallowPartialChildPosition In general, whether the returned
      *            height should only contain entire children. This is more
      *            powerful--it is the first inclusive position at which partial
      *            children will not be allowed. Example: it looks nice to have
      *            at least 3 completely visible children, and in portrait this
      *            will most likely fit; but in landscape there could be times
      *            when even 2 children can not be completely shown, so a value
      *            of 2 (remember, inclusive) would be good (assuming
      *            startPosition is 0).
      * @return The height of this TwoWayView with the given children.
      */
     private int measureHeightOfChildren(int widthMeasureSpec, int startPosition, int endPosition,
             final int maxHeight, int disallowPartialChildPosition) {
         final int paddingTop = getPaddingTop();
         final int paddingBottom = getPaddingBottom();
         final ListAdapter adapter = mAdapter;
         if (adapter == null) {
             return paddingTop + paddingBottom;
         }
         // Include the padding of the list
         int returnedHeight = paddingTop + paddingBottom;
         final int itemMargin = mItemMargin;
         // The previous height value that was less than maxHeight and contained
         // no partial children
         int prevHeightWithoutPartialChild = 0;
         int i;
         View child;
         // mItemCount - 1 since endPosition parameter is inclusive
         endPosition = (endPosition == NO_POSITION) ? adapter.getCount() - 1 : endPosition;
         final RecycleBin recycleBin = mRecycler;
         final boolean shouldRecycle = recycleOnMeasure();
         final boolean[] isScrap = mIsScrap;
         for (i = startPosition; i <= endPosition; ++i) {
             child = obtainView(i, isScrap);
             measureScrapChild(child, i, widthMeasureSpec);
             if (i > 0) {
                 // Count the item margin for all but one child
                 returnedHeight += itemMargin;
             }
             // Recycle the view before we possibly return from the method
             if (shouldRecycle) {
                 recycleBin.addScrapView(child, -1);
             }
             returnedHeight += child.getMeasuredHeight();
             if (returnedHeight >= maxHeight) {
                 // We went over, figure out which height to return.  If returnedHeight > maxHeight,
                 // then the i'th position did not fit completely.
                 return (disallowPartialChildPosition >= 0) // Disallowing is enabled (> -1)
                             && (i > disallowPartialChildPosition) // We've past the min pos
                             && (prevHeightWithoutPartialChild > 0) // We have a prev height
                             && (returnedHeight != maxHeight) // i'th child did not fit completely
                         ? prevHeightWithoutPartialChild
                         : maxHeight;
             }
             if ((disallowPartialChildPosition >= 0) && (i >= disallowPartialChildPosition)) {
                 prevHeightWithoutPartialChild = returnedHeight;
             }
         }
         // At this point, we went through the range of children, and they each
         // completely fit, so return the returnedHeight
         return returnedHeight;
     }
     /**
      * Measures the width of the given range of children (inclusive) and
      * returns the width with this TwoWayView's padding and item margin widths
      * included. If maxWidth is provided, the measuring will stop when the
      * current width reaches maxWidth.
      *
      * @param heightMeasureSpec The height measure spec to be given to a child's
      *            {@link View#measure(int, int)}.
      * @param startPosition The position of the first child to be shown.
      * @param endPosition The (inclusive) position of the last child to be
      *            shown. Specify {@link #NO_POSITION} if the last child should be
      *            the last available child from the adapter.
      * @param maxWidth The maximum width that will be returned (if all the
      *            children don't fit in this value, this value will be
      *            returned).
      * @param disallowPartialChildPosition In general, whether the returned
      *            width should only contain entire children. This is more
      *            powerful--it is the first inclusive position at which partial
      *            children will not be allowed. Example: it looks nice to have
      *            at least 3 completely visible children, and in portrait this
      *            will most likely fit; but in landscape there could be times
      *            when even 2 children can not be completely shown, so a value
      *            of 2 (remember, inclusive) would be good (assuming
      *            startPosition is 0).
      * @return The width of this TwoWayView with the given children.
      */
     private int measureWidthOfChildren(int heightMeasureSpec, int startPosition, int endPosition,
             final int maxWidth, int disallowPartialChildPosition) {
         final int paddingLeft = getPaddingLeft();
         final int paddingRight = getPaddingRight();
         final ListAdapter adapter = mAdapter;
         if (adapter == null) {
             return paddingLeft + paddingRight;
         }
         // Include the padding of the list
         int returnedWidth = paddingLeft + paddingRight;
         final int itemMargin = mItemMargin;
         // The previous height value that was less than maxHeight and contained
         // no partial children
         int prevWidthWithoutPartialChild = 0;
         int i;
         View child;
         // mItemCount - 1 since endPosition parameter is inclusive
         endPosition = (endPosition == NO_POSITION) ? adapter.getCount() - 1 : endPosition;
         final RecycleBin recycleBin = mRecycler;
         final boolean shouldRecycle = recycleOnMeasure();
         final boolean[] isScrap = mIsScrap;
         for (i = startPosition; i <= endPosition; ++i) {
             child = obtainView(i, isScrap);
             measureScrapChild(child, i, heightMeasureSpec);
             if (i > 0) {
                 // Count the item margin for all but one child
                 returnedWidth += itemMargin;
             }
             // Recycle the view before we possibly return from the method
             if (shouldRecycle) {
                 recycleBin.addScrapView(child, -1);
             }
             returnedWidth += child.getMeasuredHeight();
             if (returnedWidth >= maxWidth) {
                 // We went over, figure out which width to return.  If returnedWidth > maxWidth,
                 // then the i'th position did not fit completely.
                 return (disallowPartialChildPosition >= 0) // Disallowing is enabled (> -1)
                             && (i > disallowPartialChildPosition) // We've past the min pos
                             && (prevWidthWithoutPartialChild > 0) // We have a prev width
                             && (returnedWidth != maxWidth) // i'th child did not fit completely
                         ? prevWidthWithoutPartialChild
                         : maxWidth;
             }
             if ((disallowPartialChildPosition >= 0) && (i >= disallowPartialChildPosition)) {
                 prevWidthWithoutPartialChild = returnedWidth;
             }
         }
         // At this point, we went through the range of children, and they each
         // completely fit, so return the returnedWidth
         return returnedWidth;
     }
     private View makeAndAddView(int position, int offset, boolean flow, boolean selected) {
         final int top;
         final int left;
         if (mIsVertical) {
             top = offset;
             left = getPaddingLeft();
         } else {
             top = getPaddingTop();
             left = offset;
         }
         if (!mDataChanged) {
             // Try to use an existing view for this position
             final View activeChild = mRecycler.getActiveView(position);
             if (activeChild != null) {
                 // Found it -- we're using an existing child
                 // This just needs to be positioned
                 setupChild(activeChild, position, top, left, flow, selected, true);
                 return activeChild;
             }
         }
         // Make a new view for this position, or convert an unused view if possible
         final View child = obtainView(position, mIsScrap);
         // This needs to be positioned and measured
         setupChild(child, position, top, left, flow, selected, mIsScrap[0]);
         return child;
     }
     @TargetApi(11)
     private void setupChild(View child, int position, int top, int left,
             boolean flow, boolean selected, boolean recycled) {
         final boolean isSelected = selected && shouldShowSelector();
         final boolean updateChildSelected = isSelected != child.isSelected();
         final int touchMode = mTouchMode;
         final boolean isPressed = touchMode > TOUCH_MODE_DOWN && touchMode < TOUCH_MODE_DRAGGING &&
                 mMotionPosition == position;
         final boolean updateChildPressed = isPressed != child.isPressed();
         final boolean needToMeasure = !recycled || updateChildSelected || child.isLayoutRequested();
         // Respect layout params that are already in the view. Otherwise make some up...
         LayoutParams lp = (LayoutParams) child.getLayoutParams();
         if (lp == null) {
             lp = generateDefaultLayoutParams();
         }
         lp.viewType = mAdapter.getItemViewType(position);
         if (recycled && !lp.forceAdd) {
             attachViewToParent(child, (flow ? -1 : 0), lp);
         } else {
             lp.forceAdd = false;
             addViewInLayout(child, (flow ? -1 : 0), lp, true);
         }
         if (updateChildSelected) {
             child.setSelected(isSelected);
         }
         if (updateChildPressed) {
             child.setPressed(isPressed);
         }
         if (mChoiceMode.compareTo(ChoiceMode.NONE) != 0 && mCheckStates != null) {
             if (child instanceof Checkable) {
                 ((Checkable) child).setChecked(mCheckStates.get(position));
             } else if (getContext().getApplicationInfo().targetSdkVersion
                     >= Build.VERSION_CODES.HONEYCOMB) {
                 child.setActivated(mCheckStates.get(position));
             }
         }
         if (needToMeasure) {
             measureChild(child, lp);
         } else {
             cleanupLayoutState(child);
         }
         final int w = child.getMeasuredWidth();
         final int h = child.getMeasuredHeight();
         final int childTop = (mIsVertical && !flow ? top - h : top);
         final int childLeft = (!mIsVertical && !flow ? left - w : left);
         if (needToMeasure) {
             final int childRight = childLeft + w;
             final int childBottom = childTop + h;
             child.layout(childLeft, childTop, childRight, childBottom);
         } else {
             child.offsetLeftAndRight(childLeft - child.getLeft());
             child.offsetTopAndBottom(childTop - child.getTop());
         }
     }
     void fillGap(boolean down) {
         final int childCount = getChildCount();
         if (down) {
             final int paddingStart = (mIsVertical ? getPaddingTop() : getPaddingLeft());
             final int lastEnd;
             if (mIsVertical) {
                 lastEnd = getChildAt(childCount - 1).getBottom();
             } else {
                 lastEnd = getChildAt(childCount - 1).getRight();
             }
             final int offset = (childCount > 0 ? lastEnd + mItemMargin : paddingStart);
             fillAfter(mFirstPosition + childCount, offset);
             correctTooHigh(getChildCount());
         } else {
             final int end;
             final int firstStart;
             if (mIsVertical) {
                 end = getHeight() - getPaddingBottom();
                 firstStart = getChildAt(0).getTop();
             } else {
                 end = getWidth() - getPaddingRight();
                 firstStart = getChildAt(0).getLeft();
             }
             final int offset = (childCount > 0 ? firstStart - mItemMargin : end);
             fillBefore(mFirstPosition - 1, offset);
             correctTooLow(getChildCount());
         }
     }
     private View fillBefore(int pos, int nextOffset) {
         View selectedView = null;
         final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft());
         while (nextOffset > start && pos >= 0) {
             boolean isSelected = (pos == mSelectedPosition);
             View child = makeAndAddView(pos, nextOffset, false, isSelected);
             if (mIsVertical) {
                 nextOffset = child.getTop() - mItemMargin;
             } else {
                 nextOffset = child.getLeft() - mItemMargin;
             }
             if (isSelected) {
                 selectedView = child;
             }
             pos--;
         }
         mFirstPosition = pos + 1;
         return selectedView;
     }
     private View fillAfter(int pos, int nextOffset) {
         View selectedView = null;
         final int end =
                 (mIsVertical ? getHeight() - getPaddingBottom() : getWidth() - getPaddingRight());
         while (nextOffset < end && pos < mItemCount) {
             boolean selected = (pos == mSelectedPosition);
             View child = makeAndAddView(pos, nextOffset, true, selected);
             if (mIsVertical) {
                 nextOffset = child.getBottom() + mItemMargin;
             } else {
                 nextOffset = child.getRight() + mItemMargin;
             }
             if (selected) {
                 selectedView = child;
             }
             pos++;
         }
         return selectedView;
     }
     private View fillSpecific(int position, int offset) {
         final boolean tempIsSelected = (position == mSelectedPosition);
         View temp = makeAndAddView(position, offset, true, tempIsSelected);
         // Possibly changed again in fillBefore if we add rows above this one.
         mFirstPosition = position;
         final int itemMargin = mItemMargin;
         final int offsetBefore;
         if (mIsVertical) {
             offsetBefore = temp.getTop() - itemMargin;
         } else {
             offsetBefore = temp.getLeft() - itemMargin;
         }
         final View before = fillBefore(position - 1, offsetBefore);
         // This will correct for the top of the first view not touching the top of the list
         adjustViewsStartOrEnd();
         final int offsetAfter;
         if (mIsVertical) {
             offsetAfter = temp.getBottom() + itemMargin;
         } else {
             offsetAfter = temp.getRight() + itemMargin;
         }
         final View after = fillAfter(position + 1, offsetAfter);
         final int childCount = getChildCount();
         if (childCount > 0) {
             correctTooHigh(childCount);
         }
         if (tempIsSelected) {
             return temp;
         } else if (before != null) {
             return before;
         } else {
             return after;
         }
     }
     private View fillFromOffset(int nextOffset) {
         mFirstPosition = Math.min(mFirstPosition, mSelectedPosition);
         mFirstPosition = Math.min(mFirstPosition, mItemCount - 1);
         if (mFirstPosition < 0) {
             mFirstPosition = 0;
         }
         return fillAfter(mFirstPosition, nextOffset);
     }
     private View fillFromMiddle(int start, int end) {
         final int size = end - start;
         int position = reconcileSelectedPosition();
         View selected = makeAndAddView(position, start, true, true);
         mFirstPosition = position;
         if (mIsVertical) {
             int selectedHeight = selected.getMeasuredHeight();
             if (selectedHeight <= size) {
                 selected.offsetTopAndBottom((size - selectedHeight) / 2);
             }
         } else {
             int selectedWidth = selected.getMeasuredWidth();
             if (selectedWidth <= size) {
                 selected.offsetLeftAndRight((size - selectedWidth) / 2);
             }
         }
         fillBeforeAndAfter(selected, position);
         correctTooHigh(getChildCount());
         return selected;
     }
     private void fillBeforeAndAfter(View selected, int position) {
         final int itemMargin = mItemMargin;
         final int offsetBefore;
         if (mIsVertical) {
             offsetBefore = selected.getTop() - itemMargin;
         } else {
             offsetBefore = selected.getLeft() - itemMargin;
         }
         fillBefore(position - 1, offsetBefore);
         adjustViewsStartOrEnd();
         final int offsetAfter;
         if (mIsVertical) {
             offsetAfter = selected.getBottom() + itemMargin;
         } else {
             offsetAfter = selected.getRight() + itemMargin;
         }
         fillAfter(position + 1, offsetAfter);
     }
     private View fillFromSelection(int selectedTop, int start, int end) {
         final int selectedPosition = mSelectedPosition;
         View selected;
         selected = makeAndAddView(selectedPosition, selectedTop, true, true);
         final int selectedStart = (mIsVertical ? selected.getTop() : selected.getLeft());
         final int selectedEnd = (mIsVertical ? selected.getBottom() : selected.getRight());
         // Some of the newly selected item extends below the bottom of the list
         if (selectedEnd > end) {
             // Find space available above the selection into which we can scroll
             // upwards
             final int spaceAbove = selectedStart - start;
             // Find space required to bring the bottom of the selected item
             // fully into view
             final int spaceBelow = selectedEnd - end;
             final int offset = Math.min(spaceAbove, spaceBelow);
             // Now offset the selected item to get it into view
             selected.offsetTopAndBottom(-offset);
         } else if (selectedStart < start) {
             // Find space required to bring the top of the selected item fully
             // into view
             final int spaceAbove = start - selectedStart;
             // Find space available below the selection into which we can scroll
             // downwards
             final int spaceBelow = end - selectedEnd;
             final int offset = Math.min(spaceAbove, spaceBelow);
             // Offset the selected item to get it into view
             selected.offsetTopAndBottom(offset);
         }
         // Fill in views above and below
         fillBeforeAndAfter(selected, selectedPosition);
         correctTooHigh(getChildCount());
         return selected;
     }
     private void correctTooHigh(int childCount) {
         // First see if the last item is visible. If it is not, it is OK for the
         // top of the list to be pushed up.
         final int lastPosition = mFirstPosition + childCount - 1;
         if (lastPosition != mItemCount - 1 || childCount == 0) {
             return;
         }
         // Get the last child ...
         final View lastChild = getChildAt(childCount - 1);
         // ... and its end edge
         final int lastEnd;
         if (mIsVertical) {
             lastEnd = lastChild.getBottom();
         } else {
             lastEnd = lastChild.getRight();
         }
         // This is bottom of our drawable area
         final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft());
         final int end =
                 (mIsVertical ? getHeight() - getPaddingBottom() : getWidth() - getPaddingRight());
         // This is how far the end edge of the last view is from the end of the
         // drawable area
         int endOffset = end - lastEnd;
         View firstChild = getChildAt(0);
         int firstStart = (mIsVertical ? firstChild.getTop() : firstChild.getLeft());
         // Make sure we are 1) Too high, and 2) Either there are more rows above the
         // first row or the first row is scrolled off the top of the drawable area
         if (endOffset > 0 && (mFirstPosition > 0 || firstStart < start))  {
             if (mFirstPosition == 0) {
                 // Don't pull the top too far down
                 endOffset = Math.min(endOffset, start - firstStart);
             }
             // Move everything down
             offsetChildren(endOffset);
             if (mFirstPosition > 0) {
                 firstStart = (mIsVertical ? firstChild.getTop() : firstChild.getLeft());
                 // Fill the gap that was opened above mFirstPosition with more rows, if
                 // possible
                 fillBefore(mFirstPosition - 1, firstStart - mItemMargin);
                 // Close up the remaining gap
                 adjustViewsStartOrEnd();
             }
         }
     }
     private void correctTooLow(int childCount) {
         // First see if the first item is visible. If it is not, it is OK for the
         // bottom of the list to be pushed down.
         if (mFirstPosition != 0 || childCount == 0) {
             return;
         }
         final View first = getChildAt(0);
         final int firstStart = (mIsVertical ? first.getTop() : first.getLeft());
         final int start = (mIsVertical ? getPaddingTop() : getPaddingLeft());
         final int end;
         if (mIsVertical) {
             end = getHeight() - getPaddingBottom();
         } else {
             end = getWidth() - getPaddingRight();
         }
         // This is how far the start edge of the first view is from the start of the
         // drawable area
         int startOffset = firstStart - start;
         View last = getChildAt(childCount - 1);
         int lastEnd = (mIsVertical ? last.getBottom() : last.getRight());
         int lastPosition = mFirstPosition + childCount - 1;
         // Make sure we are 1) Too low, and 2) Either there are more columns/rows below the
         // last column/row or the last column/row is scrolled off the end of the
         // drawable area
         if (startOffset > 0) {
             if (lastPosition < mItemCount - 1 || lastEnd > end)  {
                 if (lastPosition == mItemCount - 1) {
                     // Don't pull the bottom too far up
                     startOffset = Math.min(startOffset, lastEnd - end);
                 }
                 // Move everything up
                 offsetChildren(-startOffset);
                 if (lastPosition < mItemCount - 1) {
                     lastEnd = (mIsVertical ? last.getBottom() : last.getRight());
                     // Fill the gap that was opened below the last position with more rows, if
                     // possible
                     fillAfter(lastPosition + 1, lastEnd + mItemMargin);
                     // Close up the remaining gap
                     adjustViewsStartOrEnd();
                 }
             } else if (lastPosition == mItemCount - 1) {
                 adjustViewsStartOrEnd();
             }
         }
     }
     private void adjustViewsStartOrEnd() {
         if (getChildCount() == 0) {
             return;
         }
         final View firstChild = getChildAt(0);
         int delta;
         if (mIsVertical) {
             delta = firstChild.getTop() - getPaddingTop() - mItemMargin;
         } else {
             delta = firstChild.getLeft() - getPaddingLeft() - mItemMargin;
         }
         if (delta < 0) {
             // We only are looking to see if we are too low, not too high
             delta = 0;
         }
         if (delta != 0) {
             offsetChildren(-delta);
         }
     }
     @TargetApi(14)
     private SparseBooleanArray cloneCheckStates() {
         if (mCheckStates == null) {
             return null;
         }
         SparseBooleanArray checkedStates;
         if (Build.VERSION.SDK_INT >= 14) {
             checkedStates = mCheckStates.clone();
         } else {
             checkedStates = new SparseBooleanArray();
             for (int i = 0; i < mCheckStates.size(); i++) {
                 checkedStates.put(mCheckStates.keyAt(i), mCheckStates.valueAt(i));
             }
         }
         return checkedStates;
     }
     private int findSyncPosition() {
         int itemCount = mItemCount;
         if (itemCount == 0) {
             return INVALID_POSITION;
         }
         final long idToMatch = mSyncRowId;
         // If there isn't a selection don't hunt for it
         if (idToMatch == INVALID_ROW_ID) {
             return INVALID_POSITION;
         }
         // Pin seed to reasonable values
         int seed = mSyncPosition;
         seed = Math.max(0, seed);
         seed = Math.min(itemCount - 1, seed);
         long endTime = SystemClock.uptimeMillis() + SYNC_MAX_DURATION_MILLIS;
         long rowId;
         // first position scanned so far
         int first = seed;
         // last position scanned so far
         int last = seed;
         // True if we should move down on the next iteration
         boolean next = false;
         // True when we have looked at the first item in the data
         boolean hitFirst;
         // True when we have looked at the last item in the data
         boolean hitLast;
         // Get the item ID locally (instead of getItemIdAtPosition), so
         // we need the adapter
         final ListAdapter adapter = mAdapter;
         if (adapter == null) {
             return INVALID_POSITION;
         }
         while (SystemClock.uptimeMillis() <= endTime) {
             rowId = adapter.getItemId(seed);
             if (rowId == idToMatch) {
                 // Found it!
                 return seed;
             }
             hitLast = (last == itemCount - 1);
             hitFirst = (first == 0);
             if (hitLast && hitFirst) {
                 // Looked at everything
                 break;
             }
             if (hitFirst || (next && !hitLast)) {
                 // Either we hit the top, or we are trying to move down
                 last++;
                 seed = last;
                 // Try going up next time
                 next = false;
             } else if (hitLast || (!next && !hitFirst)) {
                 // Either we hit the bottom, or we are trying to move up
                 first--;
                 seed = first;
                 // Try going down next time
                 next = true;
             }
         }
         return INVALID_POSITION;
     }
     @TargetApi(16)
     private View obtainView(int position, boolean[] isScrap) {
         isScrap[0] = false;
         View scrapView = mRecycler.getTransientStateView(position);
         if (scrapView != null) {
             return scrapView;
         }
         scrapView = mRecycler.getScrapView(position);
         final View child;
         if (scrapView != null) {
             child = mAdapter.getView(position, scrapView, this);
             if (child != scrapView) {
                 mRecycler.addScrapView(scrapView, position);
             } else {
                 isScrap[0] = true;
             }
         } else {
             child = mAdapter.getView(position, null, this);
         }
         if (ViewCompat.getImportantForAccessibility(child) == ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_AUTO) {
             ViewCompat.setImportantForAccessibility(child, ViewCompat.IMPORTANT_FOR_ACCESSIBILITY_YES);
         }
         if (mHasStableIds) {
             LayoutParams lp = (LayoutParams) child.getLayoutParams();
             if (lp == null) {
                 lp = generateDefaultLayoutParams();
             } else if (!checkLayoutParams(lp)) {
                 lp = generateLayoutParams(lp);
             }
             lp.id = mAdapter.getItemId(position);
             child.setLayoutParams(lp);
         }
         if (mAccessibilityDelegate == null) {
             mAccessibilityDelegate = new ListItemAccessibilityDelegate();
         }
         ViewCompat.setAccessibilityDelegate(child, mAccessibilityDelegate);
         return child;
     }
     void resetState() {
         removeAllViewsInLayout();
         mSelectedStart = 0;
         mFirstPosition = 0;
         mDataChanged = false;
         mNeedSync = false;
         mPendingSync = null;
         mOldSelectedPosition = INVALID_POSITION;
         mOldSelectedRowId = INVALID_ROW_ID;
         mOverScroll = 0;
         setSelectedPositionInt(INVALID_POSITION);
         setNextSelectedPositionInt(INVALID_POSITION);
         mSelectorPosition = INVALID_POSITION;
         mSelectorRect.setEmpty();
         invalidate();
     }
     private void rememberSyncState() {
         if (getChildCount() == 0) {
             return;
         }
         mNeedSync = true;
         if (mSelectedPosition >= 0) {
             View child = getChildAt(mSelectedPosition - mFirstPosition);
             mSyncRowId = mNextSelectedRowId;
             mSyncPosition = mNextSelectedPosition;
             if (child != null) {
                 mSpecificStart = (mIsVertical ? child.getTop() : child.getLeft());
             }
             mSyncMode = SYNC_SELECTED_POSITION;
         } else {
             // Sync the based on the offset of the first view
             View child = getChildAt(0);
             ListAdapter adapter = getAdapter();
             if (mFirstPosition >= 0 && mFirstPosition < adapter.getCount()) {
                 mSyncRowId = adapter.getItemId(mFirstPosition);
             } else {
                 mSyncRowId = NO_ID;
             }
             mSyncPosition = mFirstPosition;
             if (child != null) {
                 mSpecificStart = child.getTop();
             }
             mSyncMode = SYNC_FIRST_POSITION;
         }
     }
     private ContextMenuInfo createContextMenuInfo(View view, int position, long id) {
         return new AdapterContextMenuInfo(view, position, id);
     }
     @TargetApi(11)
     private void updateOnScreenCheckedViews() {
         final int firstPos = mFirstPosition;
         final int count = getChildCount();
         final boolean useActivated = getContext().getApplicationInfo().targetSdkVersion
                 >= Build.VERSION_CODES.HONEYCOMB;
         for (int i = 0; i < count; i++) {
             final View child = getChildAt(i);
             final int position = firstPos + i;
             if (child instanceof Checkable) {
                 ((Checkable) child).setChecked(mCheckStates.get(position));
             } else if (useActivated) {
                 child.setActivated(mCheckStates.get(position));
             }
         }
     }
     @Override
     public boolean performItemClick(View view, int position, long id) {
         boolean checkedStateChanged = false;
         if (mChoiceMode.compareTo(ChoiceMode.MULTIPLE) == 0) {
             boolean checked = !mCheckStates.get(position, false);
             mCheckStates.put(position, checked);
             if (mCheckedIdStates != null && mAdapter.hasStableIds()) {
                 if (checked) {
                     mCheckedIdStates.put(mAdapter.getItemId(position), position);
                 } else {
                     mCheckedIdStates.delete(mAdapter.getItemId(position));
                 }
             }
             if (checked) {
                 mCheckedItemCount++;
             } else {
                 mCheckedItemCount--;
             }
             checkedStateChanged = true;
         } else if (mChoiceMode.compareTo(ChoiceMode.SINGLE) == 0) {
             boolean checked = !mCheckStates.get(position, false);
             if (checked) {
                 mCheckStates.clear();
                 mCheckStates.put(position, true);
                 if (mCheckedIdStates != null && mAdapter.hasStableIds()) {
                     mCheckedIdStates.clear();
                     mCheckedIdStates.put(mAdapter.getItemId(position), position);
                 }
                 mCheckedItemCount = 1;
             } else if (mCheckStates.size() == 0 || !mCheckStates.valueAt(0)) {
                 mCheckedItemCount = 0;
             }
             checkedStateChanged = true;
         }
         if (checkedStateChanged) {
             updateOnScreenCheckedViews();
         }
         return super.performItemClick(view, position, id);
     }
     private boolean performLongPress(final View child,
             final int longPressPosition, final long longPressId) {
         // CHOICE_MODE_MULTIPLE_MODAL takes over long press.
         boolean handled = false;
         OnItemLongClickListener listener = getOnItemLongClickListener();
         if (listener != null) {
             handled = listener.onItemLongClick(TwoWayView.this, child,
                     longPressPosition, longPressId);
         }
         if (!handled) {
             mContextMenuInfo = createContextMenuInfo(child, longPressPosition, longPressId);
             handled = super.showContextMenuForChild(TwoWayView.this);
         }
         if (handled) {
             performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
         }
         return handled;
     }
     @Override
     protected LayoutParams generateDefaultLayoutParams() {
         if (mIsVertical) {
             return new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
         } else {
             return new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);
         }
     }
     @Override
     protected LayoutParams generateLayoutParams(ViewGroup.LayoutParams lp) {
         return new LayoutParams(lp);
     }
     @Override
     protected boolean checkLayoutParams(ViewGroup.LayoutParams lp) {
         return lp instanceof LayoutParams;
     }
     @Override
     public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
         return new LayoutParams(getContext(), attrs);
     }
     @Override
     protected ContextMenuInfo getContextMenuInfo() {
         return mContextMenuInfo;
     }
     @Override
     public Parcelable onSaveInstanceState() {
         Parcelable superState = super.onSaveInstanceState();
         SavedState ss = new SavedState(superState);
         if (mPendingSync != null) {
             ss.selectedId = mPendingSync.selectedId;
             ss.firstId = mPendingSync.firstId;
             ss.viewStart = mPendingSync.viewStart;
             ss.position = mPendingSync.position;
             ss.height = mPendingSync.height;
             return ss;
         }
         boolean haveChildren = (getChildCount() > 0 && mItemCount > 0);
         long selectedId = getSelectedItemId();
         ss.selectedId = selectedId;
         ss.height = getHeight();
         if (selectedId >= 0) {
             ss.viewStart = mSelectedStart;
             ss.position = getSelectedItemPosition();
             ss.firstId = INVALID_POSITION;
         } else if (haveChildren && mFirstPosition > 0) {
             // Remember the position of the first child.
             // We only do this if we are not currently at the top of
             // the list, for two reasons:
             //
             // (1) The list may be in the process of becoming empty, in
             // which case mItemCount may not be 0, but if we try to
             // ask for any information about position 0 we will crash.
             //
             // (2) Being "at the top" seems like a special case, anyway,
             // and the user wouldn't expect to end up somewhere else when
             // they revisit the list even if its content has changed.
             View child = getChildAt(0);
             ss.viewStart = (mIsVertical ? child.getTop() : child.getLeft());
             int firstPos = mFirstPosition;
             if (firstPos >= mItemCount) {
                 firstPos = mItemCount - 1;
             }
             ss.position = firstPos;
             ss.firstId = mAdapter.getItemId(firstPos);
         } else {
             ss.viewStart = 0;
             ss.firstId = INVALID_POSITION;
             ss.position = 0;
         }
         if (mCheckStates != null) {
             ss.checkState = cloneCheckStates();
         }
         if (mCheckedIdStates != null) {
             final LongSparseArray<Integer> idState = new LongSparseArray<Integer>();
             final int count = mCheckedIdStates.size();
             for (int i = 0; i < count; i++) {
                 idState.put(mCheckedIdStates.keyAt(i), mCheckedIdStates.valueAt(i));
             }
             ss.checkIdState = idState;
         }
         ss.checkedItemCount = mCheckedItemCount;
         return ss;
     }
     @Override
     public void onRestoreInstanceState(Parcelable state) {
         SavedState ss = (SavedState) state;
         super.onRestoreInstanceState(ss.getSuperState());
         mDataChanged = true;
         mSyncHeight = ss.height;
         if (ss.selectedId >= 0) {
             mNeedSync = true;
             mPendingSync = ss;
             mSyncRowId = ss.selectedId;
             mSyncPosition = ss.position;
             mSpecificStart = ss.viewStart;
             mSyncMode = SYNC_SELECTED_POSITION;
         } else if (ss.firstId >= 0) {
             setSelectedPositionInt(INVALID_POSITION);
             // Do this before setting mNeedSync since setNextSelectedPosition looks at mNeedSync
             setNextSelectedPositionInt(INVALID_POSITION);
             mSelectorPosition = INVALID_POSITION;
             mNeedSync = true;
             mPendingSync = ss;
             mSyncRowId = ss.firstId;
             mSyncPosition = ss.position;
             mSpecificStart = ss.viewStart;
             mSyncMode = SYNC_FIRST_POSITION;
         }
         if (ss.checkState != null) {
             mCheckStates = ss.checkState;
         }
         if (ss.checkIdState != null) {
             mCheckedIdStates = ss.checkIdState;
         }
         mCheckedItemCount = ss.checkedItemCount;
         requestLayout();
     }
     public static class LayoutParams extends ViewGroup.LayoutParams {
         /**
          * Type of this view as reported by the adapter
          */
         int viewType;
         /**
          * The stable ID of the item this view displays
          */
         long id = -1;
         /**
          * The position the view was removed from when pulled out of the
          * scrap heap.
          * @hide
          */
         int scrappedFromPosition;
         /**
          * When a TwoWayView is measured with an AT_MOST measure spec, it needs
          * to obtain children views to measure itself. When doing so, the children
          * are not attached to the window, but put in the recycler which assumes
          * they've been attached before. Setting this flag will force the reused
          * view to be attached to the window rather than just attached to the
          * parent.
          */
         boolean forceAdd;
         public LayoutParams(int width, int height) {
             super(width, height);
             if (this.width == MATCH_PARENT) {
                 Log.w(LOGTAG, "Constructing LayoutParams with width FILL_PARENT " +
                         "does not make much sense as the view might change orientation. " +
                         "Falling back to WRAP_CONTENT");
                 this.width = WRAP_CONTENT;
             }
             if (this.height == MATCH_PARENT) {
                 Log.w(LOGTAG, "Constructing LayoutParams with height FILL_PARENT " +
                         "does not make much sense as the view might change orientation. " +
                         "Falling back to WRAP_CONTENT");
                 this.height = WRAP_CONTENT;
             }
         }
         public LayoutParams(Context c, AttributeSet attrs) {
             super(c, attrs);
             if (this.width == MATCH_PARENT) {
                 Log.w(LOGTAG, "Inflation setting LayoutParams width to MATCH_PARENT - " +
                         "does not make much sense as the view might change orientation. " +
                         "Falling back to WRAP_CONTENT");
                 this.width = MATCH_PARENT;
             }
             if (this.height == MATCH_PARENT) {
                 Log.w(LOGTAG, "Inflation setting LayoutParams height to MATCH_PARENT - " +
                         "does not make much sense as the view might change orientation. " +
                         "Falling back to WRAP_CONTENT");
                 this.height = WRAP_CONTENT;
             }
         }
         public LayoutParams(ViewGroup.LayoutParams other) {
             super(other);
             if (this.width == MATCH_PARENT) {
                 Log.w(LOGTAG, "Constructing LayoutParams with height MATCH_PARENT - " +
                         "does not make much sense as the view might change orientation. " +
                         "Falling back to WRAP_CONTENT");
                 this.width = WRAP_CONTENT;
             }
             if (this.height == MATCH_PARENT) {
                 Log.w(LOGTAG, "Constructing LayoutParams with height MATCH_PARENT - " +
                         "does not make much sense as the view might change orientation. " +
                         "Falling back to WRAP_CONTENT");
                 this.height = WRAP_CONTENT;
             }
         }
     }
     class RecycleBin {
         private RecyclerListener mRecyclerListener;
         private int mFirstActivePosition;
         private View[] mActiveViews = new View[0];
         private ArrayList<View>[] mScrapViews;
         private int mViewTypeCount;
         private ArrayList<View> mCurrentScrap;
         private SparseArrayCompat<View> mTransientStateViews;
         public void setViewTypeCount(int viewTypeCount) {
             if (viewTypeCount < 1) {
                 throw new IllegalArgumentException("Can't have a viewTypeCount < 1");
             }
             @SuppressWarnings({"unchecked", "rawtypes"})
             ArrayList<View>[] scrapViews = new ArrayList[viewTypeCount];
             for (int i = 0; i < viewTypeCount; i++) {
                 scrapViews[i] = new ArrayList<View>();
             }
             mViewTypeCount = viewTypeCount;
             mCurrentScrap = scrapViews[0];
             mScrapViews = scrapViews;
         }
         public void markChildrenDirty() {
             if (mViewTypeCount == 1) {
                 final ArrayList<View> scrap = mCurrentScrap;
                 final int scrapCount = scrap.size();
                 for (int i = 0; i < scrapCount; i++) {
                     scrap.get(i).forceLayout();
                 }
             } else {
                 final int typeCount = mViewTypeCount;
                 for (int i = 0; i < typeCount; i++) {
                     final ArrayList<View> scrap = mScrapViews[i];
                     final int scrapCount = scrap.size();
                     for (int j = 0; j < scrapCount; j++) {
                         scrap.get(j).forceLayout();
                     }
                 }
             }
             if (mTransientStateViews != null) {
                 final int count = mTransientStateViews.size();
                 for (int i = 0; i < count; i++) {
                     mTransientStateViews.valueAt(i).forceLayout();
                 }
             }
         }
         public boolean shouldRecycleViewType(int viewType) {
             return viewType >= 0;
         }
         void clear() {
             if (mViewTypeCount == 1) {
                 final ArrayList<View> scrap = mCurrentScrap;
                 final int scrapCount = scrap.size();
                 for (int i = 0; i < scrapCount; i++) {
                     removeDetachedView(scrap.remove(scrapCount - 1 - i), false);
                 }
             } else {
                 final int typeCount = mViewTypeCount;
                 for (int i = 0; i < typeCount; i++) {
                     final ArrayList<View> scrap = mScrapViews[i];
                     final int scrapCount = scrap.size();
                     for (int j = 0; j < scrapCount; j++) {
                         removeDetachedView(scrap.remove(scrapCount - 1 - j), false);
                     }
                 }
             }
             if (mTransientStateViews != null) {
                 mTransientStateViews.clear();
             }
         }
         void fillActiveViews(int childCount, int firstActivePosition) {
             if (mActiveViews.length < childCount) {
                 mActiveViews = new View[childCount];
             }
             mFirstActivePosition = firstActivePosition;
             final View[] activeViews = mActiveViews;
             for (int i = 0; i < childCount; i++) {
                 View child = getChildAt(i);
                 // Note:  We do place AdapterView.ITEM_VIEW_TYPE_IGNORE in active views.
                 //        However, we will NOT place them into scrap views.
                 activeViews[i] = child;
             }
         }
         View getActiveView(int position) {
             final int index = position - mFirstActivePosition;
             final View[] activeViews = mActiveViews;
             if (index >= 0 && index < activeViews.length) {
                 final View match = activeViews[index];
                 activeViews[index] = null;
                 return match;
             }
             return null;
         }
         View getTransientStateView(int position) {
             if (mTransientStateViews == null) {
                 return null;
             }
             final int index = mTransientStateViews.indexOfKey(position);
             if (index < 0) {
                 return null;
             }
             final View result = mTransientStateViews.valueAt(index);
             mTransientStateViews.removeAt(index);
             return result;
         }
         void clearTransientStateViews() {
             if (mTransientStateViews != null) {
                 mTransientStateViews.clear();
             }
         }
         View getScrapView(int position) {
             if (mViewTypeCount == 1) {
                 return retrieveFromScrap(mCurrentScrap, position);
             } else {
                 int whichScrap = mAdapter.getItemViewType(position);
                 if (whichScrap >= 0 && whichScrap < mScrapViews.length) {
                     return retrieveFromScrap(mScrapViews[whichScrap], position);
                 }
             }
             return null;
         }
         @TargetApi(14)
         void addScrapView(View scrap, int position) {
             LayoutParams lp = (LayoutParams) scrap.getLayoutParams();
             if (lp == null) {
                 return;
             }
             lp.scrappedFromPosition = position;
             final int viewType = lp.viewType;
             final boolean scrapHasTransientState = ViewCompat.hasTransientState(scrap);
             // Don't put views that should be ignored into the scrap heap
             if (!shouldRecycleViewType(viewType) || scrapHasTransientState) {
                 if (scrapHasTransientState) {
                     if (mTransientStateViews == null) {
                         mTransientStateViews = new SparseArrayCompat<View>();
                     }
                     mTransientStateViews.put(position, scrap);
                 }
                 return;
             }
             if (mViewTypeCount == 1) {
                 mCurrentScrap.add(scrap);
             } else {
                 mScrapViews[viewType].add(scrap);
             }
             // FIXME: Unfortunately, ViewCompat.setAccessibilityDelegate() doesn't accept
             // null delegates.
             if (Build.VERSION.SDK_INT >= 14) {
                 scrap.setAccessibilityDelegate(null);
             }
             if (mRecyclerListener != null) {
                 mRecyclerListener.onMovedToScrapHeap(scrap);
             }
         }
         @TargetApi(14)
         void scrapActiveViews() {
             final View[] activeViews = mActiveViews;
             final boolean multipleScraps = (mViewTypeCount > 1);
             ArrayList<View> scrapViews = mCurrentScrap;
             final int count = activeViews.length;
             for (int i = count - 1; i >= 0; i--) {
                 final View victim = activeViews[i];
                 if (victim != null) {
                     final LayoutParams lp = (LayoutParams) victim.getLayoutParams();
                     int whichScrap = lp.viewType;
                     activeViews[i] = null;
                     final boolean scrapHasTransientState = ViewCompat.hasTransientState(victim);
                     if (!shouldRecycleViewType(whichScrap) || scrapHasTransientState) {
                         if (scrapHasTransientState) {
                             removeDetachedView(victim, false);
                             if (mTransientStateViews == null) {
                                 mTransientStateViews = new SparseArrayCompat<View>();
                             }
                             mTransientStateViews.put(mFirstActivePosition + i, victim);
                         }
                         continue;
                     }
                     if (multipleScraps) {
                         scrapViews = mScrapViews[whichScrap];
                     }
                     lp.scrappedFromPosition = mFirstActivePosition + i;
                     scrapViews.add(victim);
                     // FIXME: Unfortunately, ViewCompat.setAccessibilityDelegate() doesn't accept
                     // null delegates.
                     if (Build.VERSION.SDK_INT >= 14) {
                         victim.setAccessibilityDelegate(null);
                     }
                     if (mRecyclerListener != null) {
                         mRecyclerListener.onMovedToScrapHeap(victim);
                     }
                 }
             }
             pruneScrapViews();
         }
         private void pruneScrapViews() {
             final int maxViews = mActiveViews.length;
             final int viewTypeCount = mViewTypeCount;
             final ArrayList<View>[] scrapViews = mScrapViews;
             for (int i = 0; i < viewTypeCount; ++i) {
                 final ArrayList<View> scrapPile = scrapViews[i];
                 int size = scrapPile.size();
                 final int extras = size - maxViews;
                 size--;
                 for (int j = 0; j < extras; j++) {
                     removeDetachedView(scrapPile.remove(size--), false);
                 }
             }
             if (mTransientStateViews != null) {
                 for (int i = 0; i < mTransientStateViews.size(); i++) {
                     final View v = mTransientStateViews.valueAt(i);
                     if (!ViewCompat.hasTransientState(v)) {
                         mTransientStateViews.removeAt(i);
                         i--;
                     }
                 }
             }
         }
         void reclaimScrapViews(List<View> views) {
             if (mViewTypeCount == 1) {
                 views.addAll(mCurrentScrap);
             } else {
                 final int viewTypeCount = mViewTypeCount;
                 final ArrayList<View>[] scrapViews = mScrapViews;
                 for (int i = 0; i < viewTypeCount; ++i) {
                     final ArrayList<View> scrapPile = scrapViews[i];
                     views.addAll(scrapPile);
                 }
             }
         }
         View retrieveFromScrap(ArrayList<View> scrapViews, int position) {
             int size = scrapViews.size();
             if (size <= 0) {
                 return null;
             }
             for (int i = 0; i < size; i++) {
                 final View scrapView = scrapViews.get(i);
                 final LayoutParams lp = (LayoutParams) scrapView.getLayoutParams();
                 if (lp.scrappedFromPosition == position) {
                     scrapViews.remove(i);
                     return scrapView;
                 }
             }
             return scrapViews.remove(size - 1);
         }
     }
     @Override
     public void setEmptyView(View emptyView) {
         super.setEmptyView(emptyView);
         mEmptyView = emptyView;
         updateEmptyStatus();
     }
     @Override
     public void setFocusable(boolean focusable) {
         final ListAdapter adapter = getAdapter();
         final boolean empty = (adapter == null || adapter.getCount() == 0);
         mDesiredFocusableState = focusable;
         if (!focusable) {
             mDesiredFocusableInTouchModeState = false;
         }
         super.setFocusable(focusable && !empty);
     }
     @Override
     public void setFocusableInTouchMode(boolean focusable) {
         final ListAdapter adapter = getAdapter();
         final boolean empty = (adapter == null || adapter.getCount() == 0);
         mDesiredFocusableInTouchModeState = focusable;
         if (focusable) {
             mDesiredFocusableState = true;
         }
         super.setFocusableInTouchMode(focusable && !empty);
     }
     private void checkFocus() {
         final ListAdapter adapter = getAdapter();
         final boolean focusable = (adapter != null && adapter.getCount() > 0);
         // The order in which we set focusable in touch mode/focusable may matter
         // for the client, see View.setFocusableInTouchMode() comments for more
         // details
         super.setFocusableInTouchMode(focusable && mDesiredFocusableInTouchModeState);
         super.setFocusable(focusable && mDesiredFocusableState);
         if (mEmptyView != null) {
             updateEmptyStatus();
         }
     }
     private void updateEmptyStatus() {
         final boolean isEmpty = (mAdapter == null || mAdapter.isEmpty());
         if (isEmpty) {
             if (mEmptyView != null) {
                 mEmptyView.setVisibility(View.VISIBLE);
                 setVisibility(View.GONE);
             } else {
                 // If the caller just removed our empty view, make sure the list
                 // view is visible
                 setVisibility(View.VISIBLE);
             }
             // We are now GONE, so pending layouts will not be dispatched.
             // Force one here to make sure that the state of the list matches
             // the state of the adapter.
             if (mDataChanged) {
                 onLayout(false, getLeft(), getTop(), getRight(), getBottom());
             }
         } else {
             if (mEmptyView != null) {
                 mEmptyView.setVisibility(View.GONE);
             }
             setVisibility(View.VISIBLE);
         }
     }
     private class AdapterDataSetObserver extends DataSetObserver {
         private Parcelable mInstanceState = null;
         @Override
         public void onChanged() {
             mDataChanged = true;
             mOldItemCount = mItemCount;
             mItemCount = getAdapter().getCount();
             // Detect the case where a cursor that was previously invalidated has
             // been re-populated with new data.
             if (TwoWayView.this.mHasStableIds && mInstanceState != null
                     && mOldItemCount == 0 && mItemCount > 0) {
                 TwoWayView.this.onRestoreInstanceState(mInstanceState);
                 mInstanceState = null;
             } else {
                 rememberSyncState();
             }
             checkFocus();
             requestLayout();
         }
         @Override
         public void onInvalidated() {
             mDataChanged = true;
             if (TwoWayView.this.mHasStableIds) {
                 // Remember the current state for the case where our hosting activity is being
                 // stopped and later restarted
                 mInstanceState = TwoWayView.this.onSaveInstanceState();
             }
             // Data is invalid so we should reset our state
             mOldItemCount = mItemCount;
             mItemCount = 0;
             mSelectedPosition = INVALID_POSITION;
             mSelectedRowId = INVALID_ROW_ID;
             mNextSelectedPosition = INVALID_POSITION;
             mNextSelectedRowId = INVALID_ROW_ID;
             mNeedSync = false;
             checkFocus();
             requestLayout();
         }
     }
     static class SavedState extends BaseSavedState {
         long selectedId;
         long firstId;
         int viewStart;
         int position;
         int height;
         int checkedItemCount;
         SparseBooleanArray checkState;
         LongSparseArray<Integer> checkIdState;
         /**
          * Constructor called from {@link TwoWayView#onSaveInstanceState()}
          */
         SavedState(Parcelable superState) {
             super(superState);
         }
         /**
          * Constructor called from {@link #CREATOR}
          */
         private SavedState(Parcel in) {
             super(in);
             selectedId = in.readLong();
             firstId = in.readLong();
             viewStart = in.readInt();
             position = in.readInt();
             height = in.readInt();
             checkedItemCount = in.readInt();
             checkState = in.readSparseBooleanArray();
             final int N = in.readInt();
             if (N > 0) {
                 checkIdState = new LongSparseArray<Integer>();
                 for (int i = 0; i < N; i++) {
                     final long key = in.readLong();
                     final int value = in.readInt();
                     checkIdState.put(key, value);
                 }
             }
         }
         @Override
         public void writeToParcel(Parcel out, int flags) {
             super.writeToParcel(out, flags);
             out.writeLong(selectedId);
             out.writeLong(firstId);
             out.writeInt(viewStart);
             out.writeInt(position);
             out.writeInt(height);
             out.writeInt(checkedItemCount);
             out.writeSparseBooleanArray(checkState);
             final int N = checkIdState != null ? checkIdState.size() : 0;
             out.writeInt(N);
             for (int i = 0; i < N; i++) {
                 out.writeLong(checkIdState.keyAt(i));
                 out.writeInt(checkIdState.valueAt(i));
             }
         }
         @Override
         public String toString() {
             return "TwoWayView.SavedState{"
                     + Integer.toHexString(System.identityHashCode(this))
                     + " selectedId=" + selectedId
                     + " firstId=" + firstId
                     + " viewStart=" + viewStart
                     + " height=" + height
                     + " position=" + position
                     + " checkState=" + checkState + "}";
         }
         public static final Parcelable.Creator<SavedState> CREATOR
                 = new Parcelable.Creator<SavedState>() {
             @Override
             public SavedState createFromParcel(Parcel in) {
                 return new SavedState(in);
             }
             @Override
             public SavedState[] newArray(int size) {
                 return new SavedState[size];
             }
         };
     }
     private class SelectionNotifier implements Runnable {
         @Override
         public void run() {
             if (mDataChanged) {
                 // Data has changed between when this SelectionNotifier
                 // was posted and now. We need to wait until the AdapterView
                 // has been synched to the new data.
                 if (mAdapter != null) {
                     post(this);
                 }
             } else {
                 fireOnSelected();
                 performAccessibilityActionsOnSelected();
             }
         }
     }
     private class WindowRunnnable {
         private int mOriginalAttachCount;
         public void rememberWindowAttachCount() {
             mOriginalAttachCount = getWindowAttachCount();
         }
         public boolean sameWindow() {
             return hasWindowFocus() && getWindowAttachCount() == mOriginalAttachCount;
         }
     }
     private class PerformClick extends WindowRunnnable implements Runnable {
         int mClickMotionPosition;
         @Override
         public void run() {
             if (mDataChanged) {
                 return;
             }
             final ListAdapter adapter = mAdapter;
             final int motionPosition = mClickMotionPosition;
             if (adapter != null && mItemCount > 0 &&
                 motionPosition != INVALID_POSITION &&
                 motionPosition < adapter.getCount() && sameWindow()) {
                 final View child = getChildAt(motionPosition - mFirstPosition);
                 if (child != null) {
                     performItemClick(child, motionPosition, adapter.getItemId(motionPosition));
                 }
             }
         }
     }
     private final class CheckForTap implements Runnable {
         @Override
         public void run() {
             if (mTouchMode != TOUCH_MODE_DOWN) {
                 return;
             }
             mTouchMode = TOUCH_MODE_TAP;
             final View child = getChildAt(mMotionPosition - mFirstPosition);
             if (child != null && !child.hasFocusable()) {
                 mLayoutMode = LAYOUT_NORMAL;
                 if (!mDataChanged) {
                     setPressed(true);
                     child.setPressed(true);
                     layoutChildren();
                     positionSelector(mMotionPosition, child);
                     refreshDrawableState();
                     positionSelector(mMotionPosition, child);
                     refreshDrawableState();
                     final boolean longClickable = isLongClickable();
                     if (mSelector != null) {
                         Drawable d = mSelector.getCurrent();
                         if (d != null && d instanceof TransitionDrawable) {
                             if (longClickable) {
                                 final int longPressTimeout = ViewConfiguration.getLongPressTimeout();
                                 ((TransitionDrawable) d).startTransition(longPressTimeout);
                             } else {
                                 ((TransitionDrawable) d).resetTransition();
                             }
                         }
                     }
                     if (longClickable) {
                         triggerCheckForLongPress();
                     } else {
                         mTouchMode = TOUCH_MODE_DONE_WAITING;
                     }
                 } else {
                     mTouchMode = TOUCH_MODE_DONE_WAITING;
                 }
             }
         }
     }
     private class CheckForLongPress extends WindowRunnnable implements Runnable {
         @Override
         public void run() {
             final int motionPosition = mMotionPosition;
             final View child = getChildAt(motionPosition - mFirstPosition);
             if (child != null) {
                 final long longPressId = mAdapter.getItemId(mMotionPosition);
                 boolean handled = false;
                 if (sameWindow() && !mDataChanged) {
                     handled = performLongPress(child, motionPosition, longPressId);
                 }
                 if (handled) {
                     mTouchMode = TOUCH_MODE_REST;
                     setPressed(false);
                     child.setPressed(false);
                 } else {
                     mTouchMode = TOUCH_MODE_DONE_WAITING;
                 }
             }
         }
     }
     private class CheckForKeyLongPress extends WindowRunnnable implements Runnable {
         public void run() {
             if (!isPressed() || mSelectedPosition < 0) {
                 return;
             }
             final int index = mSelectedPosition - mFirstPosition;
             final View v = getChildAt(index);
             if (!mDataChanged) {
                 boolean handled = false;
                 if (sameWindow()) {
                     handled = performLongPress(v, mSelectedPosition, mSelectedRowId);
                 }
                 if (handled) {
                     setPressed(false);
                     v.setPressed(false);
                 }
             } else {
                 setPressed(false);
                 if (v != null) {
                     v.setPressed(false);
                 }
             }
         }
     }
     private static class ArrowScrollFocusResult {
         private int mSelectedPosition;
         private int mAmountToScroll;
         /**
          * How {@link TwoWayView#arrowScrollFocused} returns its values.
          */
         void populate(int selectedPosition, int amountToScroll) {
             mSelectedPosition = selectedPosition;
             mAmountToScroll = amountToScroll;
         }
         public int getSelectedPosition() {
             return mSelectedPosition;
         }
         public int getAmountToScroll() {
             return mAmountToScroll;
         }
     }
     private class ListItemAccessibilityDelegate extends AccessibilityDelegateCompat {
         @Override
         public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfoCompat info) {
             super.onInitializeAccessibilityNodeInfo(host, info);
             final int position = getPositionForView(host);
             final ListAdapter adapter = getAdapter();
             // Cannot perform actions on invalid items
             if (position == INVALID_POSITION || adapter == null) {
                 return;
             }
             // Cannot perform actions on disabled items
             if (!isEnabled() || !adapter.isEnabled(position)) {
                 return;
             }
             if (position == getSelectedItemPosition()) {
                 info.setSelected(true);
                 info.addAction(AccessibilityNodeInfoCompat.ACTION_CLEAR_SELECTION);
             } else {
                 info.addAction(AccessibilityNodeInfoCompat.ACTION_SELECT);
             }
             if (isClickable()) {
                 info.addAction(AccessibilityNodeInfoCompat.ACTION_CLICK);
                 info.setClickable(true);
             }
             if (isLongClickable()) {
                 info.addAction(AccessibilityNodeInfoCompat.ACTION_LONG_CLICK);
                 info.setLongClickable(true);
             }
         }
         @Override
         public boolean performAccessibilityAction(View host, int action, Bundle arguments) {
             if (super.performAccessibilityAction(host, action, arguments)) {
                 return true;
             }
             final int position = getPositionForView(host);
             final ListAdapter adapter = getAdapter();
             // Cannot perform actions on invalid items
             if (position == INVALID_POSITION || adapter == null) {
                 return false;
             }
             // Cannot perform actions on disabled items
             if (!isEnabled() || !adapter.isEnabled(position)) {
                 return false;
             }
             final long id = getItemIdAtPosition(position);
             switch (action) {
             case AccessibilityNodeInfoCompat.ACTION_CLEAR_SELECTION:
                 if (getSelectedItemPosition() == position) {
                     setSelection(INVALID_POSITION);
                     return true;
                 }
                 return false;
             case AccessibilityNodeInfoCompat.ACTION_SELECT:
                 if (getSelectedItemPosition() != position) {
                     setSelection(position);
                     return true;
                 }
                 return false;
             case AccessibilityNodeInfoCompat.ACTION_CLICK:
                 if (isClickable()) {
                     return performItemClick(host, position, id);
                 }
                 return false;
             case AccessibilityNodeInfoCompat.ACTION_LONG_CLICK:
                 if (isLongClickable()) {
                     return performLongPress(host, position, id);
                 }
                 return false;
             }
             return false;
         }
     }
 }

The Tor Browser / annotate

mobile/android/base/widget/TwoWayView.java@b8a032363ba2 (annotated)

mobile/android/base/widget/TwoWayView.java