/*

* Copyright (C) 2006 The Android Open Source Project

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package android.widget;

import android.annotation.Nullable;

import android.os.Bundle;

import android.os.Trace;

import com.android.internal.R;

import com.android.internal.util.Predicate;

import com.google.android.collect.Lists;

import android.annotation.IdRes;

import android.annotation.NonNull;

import android.content.Context;

import android.content.Intent;

import android.content.res.TypedArray;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.graphics.PixelFormat;

import android.graphics.Rect;

import android.graphics.drawable.Drawable;

import android.util.AttributeSet;

import android.util.MathUtils;

import android.util.SparseBooleanArray;

import android.view.FocusFinder;

import android.view.KeyEvent;

import android.view.SoundEffectConstants;

import android.view.View;

import android.view.ViewDebug;

import android.view.ViewGroup;

import android.view.ViewHierarchyEncoder;

import android.view.ViewParent;

import android.view.ViewRootImpl;

import android.view.accessibility.AccessibilityNodeInfo;

import android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction;

import android.view.accessibility.AccessibilityNodeInfo.CollectionInfo;

import android.view.accessibility.AccessibilityNodeInfo.CollectionItemInfo;

import android.view.accessibility.AccessibilityNodeProvider;

import android.widget.RemoteViews.RemoteView;

import java.util.ArrayList;

/*

* Implementation Notes:

*

* Some terminology:

*

* index - index of the items that are currently visible

* position - index of the items in the cursor

*/

/**

* A view that shows items in a vertically scrolling list. The items

* come from the {@link ListAdapter} associated with this view.

*

* <p>See the <a href="{@docRoot}guide/topics/ui/layout/listview.html">List View</a>

* guide.</p>

*

* @attr ref android.R.styleable#ListView_entries

* @attr ref android.R.styleable#ListView_divider

* @attr ref android.R.styleable#ListView_dividerHeight

* @attr ref android.R.styleable#ListView_headerDividersEnabled

* @attr ref android.R.styleable#ListView_footerDividersEnabled

*/

@RemoteView

public class ListView extends AbsListView {

/**

* Used to indicate a no preference for a position type.

*/

static final int NO_POSITION = -1;

/**

* When arrow scrolling, ListView will never scroll more than this factor

* times the height of the list.

*/

private static final float MAX_SCROLL_FACTOR = 0.33f;

/**

* When arrow scrolling, need a certain amount of pixels to preview next

* items. This is usually the fading edge, but if that is small enough,

* we want to make sure we preview at least this many pixels.

*/

private static final int MIN_SCROLL_PREVIEW_PIXELS = 2;

/**

* A class that represents a fixed view in a list, for example a header at the top

* or a footer at the bottom.

*/

public class FixedViewInfo {

/** The view to add to the list */

public View view;

/** The data backing the view. This is returned from {@link ListAdapter#getItem(int)}. */

public Object data;

/** <code>true</code> if the fixed view should be selectable in the list */

public boolean isSelectable;

}

private ArrayList<FixedViewInfo> mHeaderViewInfos = Lists.newArrayList();

private ArrayList<FixedViewInfo> mFooterViewInfos = Lists.newArrayList();

Drawable mDivider;

int mDividerHeight;

Drawable mOverScrollHeader;

Drawable mOverScrollFooter;

private boolean mIsCacheColorOpaque;

private boolean mDividerIsOpaque;

private boolean mHeaderDividersEnabled;

private boolean mFooterDividersEnabled;

private boolean mAreAllItemsSelectable = true;

private boolean mItemsCanFocus = false;

// used for temporary calculations.

private final Rect mTempRect = new Rect();

private Paint mDividerPaint;

// the single allocated result per list view; kinda cheesey but avoids

// allocating these thingies too often.

private final ArrowScrollFocusResult mArrowScrollFocusResult = new ArrowScrollFocusResult();

// Keeps focused children visible through resizes

private FocusSelector mFocusSelector;

public ListView(Context context) {

this(context, null);

}

public ListView(Context context, AttributeSet attrs) {

this(context, attrs, R.attr.listViewStyle);

}

public ListView(Context context, AttributeSet attrs, int defStyleAttr) {

this(context, attrs, defStyleAttr, 0);

}

public ListView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {

super(context, attrs, defStyleAttr, defStyleRes);

final TypedArray a = context.obtainStyledAttributes(

attrs, R.styleable.ListView, defStyleAttr, defStyleRes);

final CharSequence[] entries = a.getTextArray(R.styleable.ListView_entries);

if (entries != null) {

setAdapter(new ArrayAdapter<>(context, R.layout.simple_list_item_1, entries));

}

final Drawable d = a.getDrawable(R.styleable.ListView_divider);

if (d != null) {

// Use an implicit divider height which may be explicitly

// overridden by android:dividerHeight further down.

setDivider(d);

}

final Drawable osHeader = a.getDrawable(R.styleable.ListView_overScrollHeader);

if (osHeader != null) {

setOverscrollHeader(osHeader);

}

final Drawable osFooter = a.getDrawable(R.styleable.ListView_overScrollFooter);

if (osFooter != null) {

setOverscrollFooter(osFooter);

}

// Use an explicit divider height, if specified.

if (a.hasValueOrEmpty(R.styleable.ListView_dividerHeight)) {

final int dividerHeight = a.getDimensionPixelSize(

R.styleable.ListView_dividerHeight, 0);

if (dividerHeight != 0) {

setDividerHeight(dividerHeight);

}

}

mHeaderDividersEnabled = a.getBoolean(R.styleable.ListView_headerDividersEnabled, true);

mFooterDividersEnabled = a.getBoolean(R.styleable.ListView_footerDividersEnabled, true);

a.recycle();

}

/**

* @return The maximum amount a list view will scroll in response to

* an arrow event.

*/

public int getMaxScrollAmount() {

return (int) (MAX_SCROLL_FACTOR * (mBottom - mTop));

}

/**

* Make sure views are touching the top or bottom edge, as appropriate for

* our gravity

*/

private void adjustViewsUpOrDown() {

final int childCount = getChildCount();

int delta;

if (childCount > 0) {

View child;

if (!mStackFromBottom) {

// Uh-oh -- we came up short. Slide all views up to make them

// align with the top

child = getChildAt(0);

delta = child.getTop() - mListPadding.top;

if (mFirstPosition != 0) {

// It's OK to have some space above the first item if it is

// part of the vertical spacing

delta -= mDividerHeight;

}

if (delta < 0) {

// We only are looking to see if we are too low, not too high

delta = 0;

}

} else {

// we are too high, slide all views down to align with bottom

child = getChildAt(childCount - 1);

delta = child.getBottom() - (getHeight() - mListPadding.bottom);

if (mFirstPosition + childCount < mItemCount) {

// It's OK to have some space below the last item if it is

// part of the vertical spacing

delta += mDividerHeight;

}

if (delta > 0) {

delta = 0;

}

}

if (delta != 0) {

offsetChildrenTopAndBottom(-delta);

}

}

}

/**

* Add a fixed view to appear at the top of the list. If this method is

* called more than once, the views will appear in the order they were

* added. Views added using this call can take focus if they want.

* <p>

* Note: When first introduced, this method could only be called before

* setting the adapter with {@link #setAdapter(ListAdapter)}. Starting with

* {@link android.os.Build.VERSION_CODES#KITKAT}, this method may be

* called at any time. If the ListView's adapter does not extend

* {@link HeaderViewListAdapter}, it will be wrapped with a supporting

* instance of {@link WrapperListAdapter}.

*

* @param v The view to add.

* @param data Data to associate with this view

* @param isSelectable whether the item is selectable

*/

public void addHeaderView(View v, Object data, boolean isSelectable) {

final FixedViewInfo info = new FixedViewInfo();

info.view = v;

info.data = data;

info.isSelectable = isSelectable;

mHeaderViewInfos.add(info);

mAreAllItemsSelectable &= isSelectable;

// Wrap the adapter if it wasn't already wrapped.

if (mAdapter != null) {

if (!(mAdapter instanceof HeaderViewListAdapter)) {

mAdapter = new HeaderViewListAdapter(mHeaderViewInfos, mFooterViewInfos, mAdapter);

}

// In the case of re-adding a header view, or adding one later on,

// we need to notify the observer.

if (mDataSetObserver != null) {

mDataSetObserver.onChanged();

}

}

}

/**

* Add a fixed view to appear at the top of the list. If addHeaderView is

* called more than once, the views will appear in the order they were

* added. Views added using this call can take focus if they want.

* <p>

* Note: When first introduced, this method could only be called before

* setting the adapter with {@link #setAdapter(ListAdapter)}. Starting with

* {@link android.os.Build.VERSION_CODES#KITKAT}, this method may be

* called at any time. If the ListView's adapter does not extend

* {@link HeaderViewListAdapter}, it will be wrapped with a supporting

* instance of {@link WrapperListAdapter}.

*

* @param v The view to add.

*/

public void addHeaderView(View v) {

addHeaderView(v, null, true);

}

@Override

public int getHeaderViewsCount() {

return mHeaderViewInfos.size();

}

/**

* Removes a previously-added header view.

*

* @param v The view to remove

* @return true if the view was removed, false if the view was not a header

* view

*/

public boolean removeHeaderView(View v) {

if (mHeaderViewInfos.size() > 0) {

boolean result = false;

if (mAdapter != null && ((HeaderViewListAdapter) mAdapter).removeHeader(v)) {

if (mDataSetObserver != null) {

mDataSetObserver.onChanged();

}

result = true;

}

removeFixedViewInfo(v, mHeaderViewInfos);

return result;

}

return false;

}

private void removeFixedViewInfo(View v, ArrayList<FixedViewInfo> where) {

int len = where.size();

for (int i = 0; i < len; ++i) {

FixedViewInfo info = where.get(i);

if (info.view == v) {

where.remove(i);

break;

}

}

}

/**

* Add a fixed view to appear at the bottom of the list. If addFooterView is

* called more than once, the views will appear in the order they were

* added. Views added using this call can take focus if they want.

* <p>

* Note: When first introduced, this method could only be called before

* setting the adapter with {@link #setAdapter(ListAdapter)}. Starting with

* {@link android.os.Build.VERSION_CODES#KITKAT}, this method may be

* called at any time. If the ListView's adapter does not extend

* {@link HeaderViewListAdapter}, it will be wrapped with a supporting

* instance of {@link WrapperListAdapter}.

*

* @param v The view to add.

* @param data Data to associate with this view

* @param isSelectable true if the footer view can be selected

*/

public void addFooterView(View v, Object data, boolean isSelectable) {

final FixedViewInfo info = new FixedViewInfo();

info.view = v;

info.data = data;

info.isSelectable = isSelectable;

mFooterViewInfos.add(info);

mAreAllItemsSelectable &= isSelectable;

// Wrap the adapter if it wasn't already wrapped.

if (mAdapter != null) {

if (!(mAdapter instanceof HeaderViewListAdapter)) {

mAdapter = new HeaderViewListAdapter(mHeaderViewInfos, mFooterViewInfos, mAdapter);

}

// In the case of re-adding a footer view, or adding one later on,

// we need to notify the observer.

if (mDataSetObserver != null) {

mDataSetObserver.onChanged();

}

}

}

/**

* Add a fixed view to appear at the bottom of the list. If addFooterView is

* called more than once, the views will appear in the order they were

* added. Views added using this call can take focus if they want.

* <p>

* Note: When first introduced, this method could only be called before

* setting the adapter with {@link #setAdapter(ListAdapter)}. Starting with

* {@link android.os.Build.VERSION_CODES#KITKAT}, this method may be

* called at any time. If the ListView's adapter does not extend

* {@link HeaderViewListAdapter}, it will be wrapped with a supporting

* instance of {@link WrapperListAdapter}.

*

* @param v The view to add.

*/

public void addFooterView(View v) {

addFooterView(v, null, true);

}

@Override

public int getFooterViewsCount() {

return mFooterViewInfos.size();

}

/**

* Removes a previously-added footer view.

*

* @param v The view to remove

* @return

* true if the view was removed, false if the view was not a footer view

*/

public boolean removeFooterView(View v) {

if (mFooterViewInfos.size() > 0) {

boolean result = false;

if (mAdapter != null && ((HeaderViewListAdapter) mAdapter).removeFooter(v)) {

if (mDataSetObserver != null) {

mDataSetObserver.onChanged();

}

result = true;

}

removeFixedViewInfo(v, mFooterViewInfos);

return result;

}

return false;

}

/**

* Returns the adapter currently in use in this ListView. The returned adapter

* might not be the same adapter passed to {@link #setAdapter(ListAdapter)} but

* might be a {@link WrapperListAdapter}.

*

* @return The adapter currently used to display data in this ListView.

*

* @see #setAdapter(ListAdapter)

*/

@Override

public ListAdapter getAdapter() {

return mAdapter;

}

/**

* Sets up this AbsListView to use a remote views adapter which connects to a RemoteViewsService

* through the specified intent.

* @param intent the intent used to identify the RemoteViewsService for the adapter to connect to.

*/

@android.view.RemotableViewMethod

public void setRemoteViewsAdapter(Intent intent) {

super.setRemoteViewsAdapter(intent);

}

/**

* Sets the data behind this ListView.

*

* The adapter passed to this method may be wrapped by a {@link WrapperListAdapter},

* depending on the ListView features currently in use. For instance, adding

* headers and/or footers will cause the adapter to be wrapped.

*

* @param adapter The ListAdapter which is responsible for maintaining the

* data backing this list and for producing a view to represent an

* item in that data set.

*

* @see #getAdapter()

*/

@Override

public void setAdapter(ListAdapter adapter) {

if (mAdapter != null && mDataSetObserver != null) {

mAdapter.unregisterDataSetObserver(mDataSetObserver);

}

resetList();

mRecycler.clear();

if (mHeaderViewInfos.size() > 0|| mFooterViewInfos.size() > 0) {

mAdapter = new HeaderViewListAdapter(mHeaderViewInfos, mFooterViewInfos, adapter);

} else {

mAdapter = adapter;

}

mOldSelectedPosition = INVALID_POSITION;

mOldSelectedRowId = INVALID_ROW_ID;

// AbsListView#setAdapter will update choice mode states.

super.setAdapter(adapter);

if (mAdapter != null) {

mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();

mOldItemCount = mItemCount;

mItemCount = mAdapter.getCount();

checkFocus();

mDataSetObserver = new AdapterDataSetObserver();

mAdapter.registerDataSetObserver(mDataSetObserver);

mRecycler.setViewTypeCount(mAdapter.getViewTypeCount());

int position;

if (mStackFromBottom) {

position = lookForSelectablePosition(mItemCount - 1, false);

} else {

position = lookForSelectablePosition(0, true);

}

setSelectedPositionInt(position);

setNextSelectedPositionInt(position);

if (mItemCount == 0) {

// Nothing selected

checkSelectionChanged();

}

} else {

mAreAllItemsSelectable = true;

checkFocus();

// Nothing selected

checkSelectionChanged();

}

requestLayout();

}

/**

* The list is empty. Clear everything out.

*/

@Override

void resetList() {

// The parent's resetList() will remove all views from the layout so we need to

// cleanup the state of our footers and headers

clearRecycledState(mHeaderViewInfos);

clearRecycledState(mFooterViewInfos);

super.resetList();

mLayoutMode = LAYOUT_NORMAL;

}

private void clearRecycledState(ArrayList<FixedViewInfo> infos) {

if (infos != null) {

final int count = infos.size();

for (int i = 0; i < count; i++) {

final View child = infos.get(i).view;

final LayoutParams p = (LayoutParams) child.getLayoutParams();

if (p != null) {

p.recycledHeaderFooter = false;

}

}

}

}

/**

* @return Whether the list needs to show the top fading edge

*/

private boolean showingTopFadingEdge() {

final int listTop = mScrollY + mListPadding.top;

return (mFirstPosition > 0) || (getChildAt(0).getTop() > listTop);

}

/**

* @return Whether the list needs to show the bottom fading edge

*/

private boolean showingBottomFadingEdge() {

final int childCount = getChildCount();

final int bottomOfBottomChild = getChildAt(childCount - 1).getBottom();

final int lastVisiblePosition = mFirstPosition + childCount - 1;

final int listBottom = mScrollY + getHeight() - mListPadding.bottom;

return (lastVisiblePosition < mItemCount - 1)

|| (bottomOfBottomChild < listBottom);

}

@Override

public boolean requestChildRectangleOnScreen(View child, Rect rect, boolean immediate) {

int rectTopWithinChild = rect.top;

// offset so rect is in coordinates of the this view

rect.offset(child.getLeft(), child.getTop());

rect.offset(-child.getScrollX(), -child.getScrollY());

final int height = getHeight();

int listUnfadedTop = getScrollY();

int listUnfadedBottom = listUnfadedTop + height;

final int fadingEdge = getVerticalFadingEdgeLength();

if (showingTopFadingEdge()) {

// leave room for top fading edge as long as rect isn't at very top

if ((mSelectedPosition > 0) || (rectTopWithinChild > fadingEdge)) {

listUnfadedTop += fadingEdge;

}

}

int childCount = getChildCount();

int bottomOfBottomChild = getChildAt(childCount - 1).getBottom();

if (showingBottomFadingEdge()) {

// leave room for bottom fading edge as long as rect isn't at very bottom

if ((mSelectedPosition < mItemCount - 1)

|| (rect.bottom < (bottomOfBottomChild - fadingEdge))) {

listUnfadedBottom -= fadingEdge;

}

}

int scrollYDelta = 0;

if (rect.bottom > listUnfadedBottom && rect.top > listUnfadedTop) {

// need to MOVE DOWN to get it in view: move down just enough so

// that the entire rectangle is in view (or at least the first

// screen size chunk).

if (rect.height() > height) {

// just enough to get screen size chunk on

scrollYDelta += (rect.top - listUnfadedTop);

} else {

// get entire rect at bottom of screen

scrollYDelta += (rect.bottom - listUnfadedBottom);

}

// make sure we aren't scrolling beyond the end of our children

int distanceToBottom = bottomOfBottomChild - listUnfadedBottom;

scrollYDelta = Math.min(scrollYDelta, distanceToBottom);

} else if (rect.top < listUnfadedTop && rect.bottom < listUnfadedBottom) {

// need to MOVE UP to get it in view: move up just enough so that

// entire rectangle is in view (or at least the first screen

// size chunk of it).

if (rect.height() > height) {

// screen size chunk

scrollYDelta -= (listUnfadedBottom - rect.bottom);

} else {

// entire rect at top

scrollYDelta -= (listUnfadedTop - rect.top);

}

// make sure we aren't scrolling any further than the top our children

int top = getChildAt(0).getTop();

int deltaToTop = top - listUnfadedTop;

scrollYDelta = Math.max(scrollYDelta, deltaToTop);

}

final boolean scroll = scrollYDelta != 0;

if (scroll) {

scrollListItemsBy(-scrollYDelta);

positionSelector(INVALID_POSITION, child);

mSelectedTop = child.getTop();

invalidate();

}

return scroll;

}

/**

* {@inheritDoc}

*/

@Override

void fillGap(boolean down) {

final int count = getChildCount();

if (down) {

int paddingTop = 0;

if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {

paddingTop = getListPaddingTop();

}

final int startOffset = count > 0 ? getChildAt(count - 1).getBottom() + mDividerHeight :

paddingTop;

fillDown(mFirstPosition + count, startOffset);

correctTooHigh(getChildCount());

} else {

int paddingBottom = 0;

if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {

paddingBottom = getListPaddingBottom();

}

final int startOffset = count > 0 ? getChildAt(0).getTop() - mDividerHeight :

getHeight() - paddingBottom;

fillUp(mFirstPosition - 1, startOffset);

correctTooLow(getChildCount());

}

}

/**

* Fills the list from pos down to the end of the list view.

*

* @param pos The first position to put in the list

*

* @param nextTop The location where the top of the item associated with pos

* should be drawn

*

* @return The view that is currently selected, if it happens to be in the

* range that we draw.

*/

private View fillDown(int pos, int nextTop) {

View selectedView = null;

int end = (mBottom - mTop);

if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {

end -= mListPadding.bottom;

}

while (nextTop < end && pos < mItemCount) {

// is this the selected item?

boolean selected = pos == mSelectedPosition;

View child = makeAndAddView(pos, nextTop, true, mListPadding.left, selected);

nextTop = child.getBottom() + mDividerHeight;

if (selected) {

selectedView = child;

}

pos++;

}

setVisibleRangeHint(mFirstPosition, mFirstPosition + getChildCount() - 1);

return selectedView;

}

/**

* Fills the list from pos up to the top of the list view.

*

* @param pos The first position to put in the list

*

* @param nextBottom The location where the bottom of the item associated

* with pos should be drawn

*

* @return The view that is currently selected

*/

private View fillUp(int pos, int nextBottom) {

View selectedView = null;

int end = 0;

if ((mGroupFlags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK) {

end = mListPadding.top;

}

while (nextBottom > end && pos >= 0) {

// is this the selected item?

boolean selected = pos == mSelectedPosition;

View child = makeAndAddView(pos, nextBottom, false, mListPadding.left, selected);

nextBottom = child.getTop() - mDividerHeight;

if (selected) {

selectedView = child;

}

pos--;

}

mFirstPosition = pos + 1;

setVisibleRangeHint(mFirstPosition, mFirstPosition + getChildCount() - 1);

return selectedView;

}

/**

* Fills the list from top to bottom, starting with mFirstPosition

*

* @param nextTop The location where the top of the first item should be

* drawn

*

* @return The view that is currently selected

*/

private View fillFromTop(int nextTop) {

mFirstPosition = Math.min(mFirstPosition, mSelectedPosition);

mFirstPosition = Math.min(mFirstPosition, mItemCount - 1);

if (mFirstPosition < 0) {

mFirstPosition = 0;

}

return fillDown(mFirstPosition, nextTop);

}

/**

* Put mSelectedPosition in the middle of the screen and then build up and

* down from there. This method forces mSelectedPosition to the center.

*

* @param childrenTop Top of the area in which children can be drawn, as

* measured in pixels

* @param childrenBottom Bottom of the area in which children can be drawn,

* as measured in pixels

* @return Currently selected view

*/

private View fillFromMiddle(int childrenTop, int childrenBottom) {

int height = childrenBottom - childrenTop;

int position = reconcileSelectedPosition();

View sel = makeAndAddView(position, childrenTop, true,

mListPadding.left, true);

mFirstPosition = position;

int selHeight = sel.getMeasuredHeight();

if (selHeight <= height) {

sel.offsetTopAndBottom((height - selHeight) / 2);

}

fillAboveAndBelow(sel, position);

if (!mStackFromBottom) {

correctTooHigh(getChildCount());

} else {

correctTooLow(getChildCount());

}

return sel;

}

/**

* Once the selected view as been placed, fill up the visible area above and

* below it.

*

* @param sel The selected view

* @param position The position corresponding to sel

*/

private void fillAboveAndBelow(View sel, int position) {

final int dividerHeight = mDividerHeight;

if (!mStackFromBottom) {

fillUp(position - 1, sel.getTop() - dividerHeight);

adjustViewsUpOrDown();

fillDown(position + 1, sel.getBottom() + dividerHeight);

} else {

fillDown(position + 1, sel.getBottom() + dividerHeight);

adjustViewsUpOrDown();

fillUp(position - 1, sel.getTop() - dividerHeight);

}

}

/**

* Fills the grid based on positioning the new selection at a specific

* location. The selection may be moved so that it does not intersect the

* faded edges. The grid is then filled upwards and downwards from there.

*

* @param selectedTop Where the selected item should be

* @param childrenTop Where to start drawing children

* @param childrenBottom Last pixel where children can be drawn

* @return The view that currently has selection

*/

private View fillFromSelection(int selectedTop, int childrenTop, int childrenBottom) {

int fadingEdgeLength = getVerticalFadingEdgeLength();

final int selectedPosition = mSelectedPosition;

View sel;

final int topSelectionPixel = getTopSelectionPixel(childrenTop, fadingEdgeLength,

selectedPosition);

final int bottomSelectionPixel = getBottomSelectionPixel(childrenBottom, fadingEdgeLength,

selectedPosition);

sel = makeAndAddView(selectedPosition, selectedTop, true, mListPadding.left, true);

// Some of the newly selected item extends below the bottom of the list

if (sel.getBottom() > bottomSelectionPixel) {

// Find space available above the selection into which we can scroll

// upwards

final int spaceAbove = sel.getTop() - topSelectionPixel;

// Find space required to bring the bottom of the selected item

// fully into view

final int spaceBelow = sel.getBottom() - bottomSelectionPixel;

final int offset = Math.min(spaceAbove, spaceBelow);

// Now offset the selected item to get it into view

sel.offsetTopAndBottom(-offset);

} else if (sel.getTop() < topSelectionPixel) {

// Find space required to bring the top of the selected item fully

// into view

final int spaceAbove = topSelectionPixel - sel.getTop();

// Find space available below the selection into which we can scroll

// downwards

final int spaceBelow = bottomSelectionPixel - sel.getBottom();

final int offset = Math.min(spaceAbove, spaceBelow);

// Offset the selected item to get it into view

sel.offsetTopAndBottom(offset);

}

// Fill in views above and below

fillAboveAndBelow(sel, selectedPosition);

if (!mStackFromBottom) {

correctTooHigh(getChildCount());

} else {

correctTooLow(getChildCount());

}

return sel;

}

/**

* Calculate the bottom-most pixel we can draw the selection into

*

* @param childrenBottom Bottom pixel were children can be drawn

* @param fadingEdgeLength Length of the fading edge in pixels, if present

* @param selectedPosition The position that will be selected

* @return The bottom-most pixel we can draw the selection into

*/

private int getBottomSelectionPixel(int childrenBottom, int fadingEdgeLength,

int selectedPosition) {

int bottomSelectionPixel = childrenBottom;

if (selectedPosition != mItemCount - 1) {

bottomSelectionPixel -= fadingEdgeLength;

}

return bottomSelectionPixel;

}

/**

* Calculate the top-most pixel we can draw the selection into

*

* @param childrenTop Top pixel were children can be drawn

* @param fadingEdgeLength Length of the fading edge in pixels, if present

* @param selectedPosition The position that will be selected

* @return The top-most pixel we can draw the selection into

*/

private int getTopSelectionPixel(int childrenTop, int fadingEdgeLength, int selectedPosition) {

// first pixel we can draw the selection into

int topSelectionPixel = childrenTop;

if (selectedPosition > 0) {

topSelectionPixel += fadingEdgeLength;

}

return topSelectionPixel;

}

/**

* Smoothly scroll to the specified adapter position. The view will

* scroll such that the indicated position is displayed.

* @param position Scroll to this adapter position.

*/

@android.view.RemotableViewMethod

public void smoothScrollToPosition(int position) {

super.smoothScrollToPosition(position);

}

/**

* Smoothly scroll to the specified adapter position offset. The view will

* scroll such that the indicated position is displayed.

* @param offset The amount to offset from the adapter position to scroll to.

*/

@android.view.RemotableViewMethod

public void smoothScrollByOffset(int offset) {

super.smoothScrollByOffset(offset);

}

/**

* Fills the list based on positioning the new selection relative to the old

* selection. The new selection will be placed at, above, or below the

* location of the new selection depending on how the selection is moving.

* The selection will then be pinned to the visible part of the screen,

* excluding the edges that are faded. The list is then filled upwards and

* downwards from there.

*

* @param oldSel The old selected view. Useful for trying to put the new

* selection in the same place

* @param newSel The view that is to become selected. Useful for trying to

* put the new selection in the same place

* @param delta Which way we are moving

* @param childrenTop Where to start drawing children

* @param childrenBottom Last pixel where children can be drawn

* @return The view that currently has selection

*/

private View moveSelection(View oldSel, View newSel, int delta, int childrenTop,

int childrenBottom) {

int fadingEdgeLength = getVerticalFadingEdgeLength();

final int selectedPosition = mSelectedPosition;

View sel;

final int topSelectionPixel = getTopSelectionPixel(childrenTop, fadingEdgeLength,

selectedPosition);

final int bottomSelectionPixel = getBottomSelectionPixel(childrenTop, fadingEdgeLength,

selectedPosition);

if (delta > 0) {

/*

* Case 1: Scrolling down.

*/

/*

* Before After

* | | | |

* +-------+ +-------+

* | A | | A |

* | 1 | => +-------+

* +-------+ | B |

* | B | | 2 |

* +-------+ +-------+

* | | | |

*

* Try to keep the top of the previously selected item where it was.

* oldSel = A

* sel = B

*/

// Put oldSel (A) where it belongs

oldSel = makeAndAddView(selectedPosition - 1, oldSel.getTop(), true,

mListPadding.left, false);

final int dividerHeight = mDividerHeight;

// Now put the new selection (B) below that

sel = makeAndAddView(selectedPosition, oldSel.getBottom() + dividerHeight, true,

mListPadding.left, true);

// Some of the newly selected item extends below the bottom of the list