The Tor Browser / file revision

 /*

  * 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();