Update smoothScrollToPosition to move faster for large offsets (441b437b) · Commits · e / os / android_frameworks_base

api/current.txt

+3 −1

Original line number	Diff line number	Diff line
		@@ -31627,10 +31627,12 @@ package android.widget {
		method public int getCheckedItemPosition();
		method public android.util.SparseBooleanArray getCheckedItemPositions();
		method public int getChoiceMode();
		method public int getFirstPositionForRow(int);
		method public int getListPaddingBottom();
		method public int getListPaddingLeft();
		method public int getListPaddingRight();
		method public int getListPaddingTop();
		method public int getRowForPosition(int);
		method public android.view.View getSelectedView();
		method public android.graphics.drawable.Drawable getSelector();
		method public java.lang.CharSequence getTextFilter();
		@@ -31676,6 +31678,7 @@ package android.widget {
		method public void setRemoteViewsAdapter(android.content.Intent);
		method public void setScrollIndicators(android.view.View, android.view.View);
		method public void setScrollingCacheEnabled(boolean);
		method public void setSelectionFromTop(int, int);
		method public void setSelector(int);
		method public void setSelector(android.graphics.drawable.Drawable);
		method public void setSmoothScrollbarEnabled(boolean);
		@@ -32791,7 +32794,6 @@ package android.widget {
		method public void setOverscrollHeader(android.graphics.drawable.Drawable);
		method public void setSelection(int);
		method public void setSelectionAfterHeaderView();
		method public void setSelectionFromTop(int, int);
		method public void smoothScrollByOffset(int);
		}

core/java/android/widget/AbsListView.java

+343 −8

Original line number	Diff line number	Diff line
		@@ -36,6 +36,7 @@ import android.text.TextWatcher;
		import android.util.AttributeSet;
		import android.util.Log;
		import android.util.LongSparseArray;
		import android.util.MathUtils;
		import android.util.SparseArray;
		import android.util.SparseBooleanArray;
		import android.util.StateSet;
		@@ -60,6 +61,8 @@ import android.view.ViewTreeObserver;
		import android.view.accessibility.AccessibilityEvent;
		import android.view.accessibility.AccessibilityManager;
		import android.view.accessibility.AccessibilityNodeInfo;
		import android.view.animation.AccelerateDecelerateInterpolator;
		import android.view.animation.AnimationUtils;
		import android.view.animation.Interpolator;
		import android.view.animation.LinearInterpolator;
		import android.view.inputmethod.BaseInputConnection;
		@@ -418,7 +421,7 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te
		/**
		* Handles scrolling between positions within the list.
		*/
		PositionScroller mPositionScroller;
		SubPositionScroller mPositionScroller;

		/**
		* The offset in pixels form the top of the AdapterView to the top
		@@ -4840,14 +4843,14 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te
		*/
		public void smoothScrollToPosition(int position) {
		if (mPositionScroller == null) {
		mPositionScroller = new PositionScroller();
		mPositionScroller = new SubPositionScroller();
		}
		mPositionScroller.start(position);
		}

		/**
		* Smoothly scroll to the specified adapter position. The view will scroll
		* such that the indicated position is displayed <code>offset</code> pixels from
		* such that the indicated position is displayed <code>offset</code> pixels below
		* the top edge of the view. If this is impossible, (e.g. the offset would scroll
		* the first or last item beyond the boundaries of the list) it will get as close
		* as possible. The scroll will take <code>duration</code> milliseconds to complete.
		@@ -4859,14 +4862,14 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te
		*/
		public void smoothScrollToPositionFromTop(int position, int offset, int duration) {
		if (mPositionScroller == null) {
		mPositionScroller = new PositionScroller();
		mPositionScroller = new SubPositionScroller();
		}
		mPositionScroller.startWithOffset(position, offset, duration);
		}

		/**
		* Smoothly scroll to the specified adapter position. The view will scroll
		* such that the indicated position is displayed <code>offset</code> pixels from
		* such that the indicated position is displayed <code>offset</code> pixels below
		* the top edge of the view. If this is impossible, (e.g. the offset would scroll
		* the first or last item beyond the boundaries of the list) it will get as close
		* as possible.
		@@ -4877,9 +4880,9 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te
		*/
		public void smoothScrollToPositionFromTop(int position, int offset) {
		if (mPositionScroller == null) {
		mPositionScroller = new PositionScroller();
		mPositionScroller = new SubPositionScroller();
		}
		mPositionScroller.startWithOffset(position, offset);
		mPositionScroller.startWithOffset(position, offset, offset);
		}

		/**
		@@ -4893,7 +4896,7 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te
		*/
		public void smoothScrollToPosition(int position, int boundPosition) {
		if (mPositionScroller == null) {
		mPositionScroller = new PositionScroller();
		mPositionScroller = new SubPositionScroller();
		}
		mPositionScroller.start(position, boundPosition);
		}
		@@ -6992,4 +6995,336 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te
		return null;
		}
		}

		/**
		* Returns the height of a row, which is computed as the maximum height of
		* the items in the row.
		*
		* @param row the row index
		* @return row height in pixels
		*/
		private int getHeightForRow(int row) {
		final int firstRowPosition = getFirstPositionForRow(row);
		final int lastRowPosition = getFirstPositionForRow(row + 1);
		int maxHeight = 0;
		for (int i = firstRowPosition; i < lastRowPosition; i++) {
		final int height = getHeightForPosition(i);
		if (height > maxHeight) {
		maxHeight = height;
		}
		}
		return maxHeight;
		}

		/**
		* Returns the height of the view for the specified position.
		*
		* @param position the item position
		* @return view height in pixels
		*/
		int getHeightForPosition(int position) {
		final int firstVisiblePosition = getFirstVisiblePosition();
		final int childCount = getChildCount();
		final int index = position - firstVisiblePosition;
		if (position >= 0 && position < childCount) {
		final View view = getChildAt(index);
		return view.getHeight();
		} else {
		final View view = obtainView(position, mIsScrap);
		view.measure(mWidthMeasureSpec, MeasureSpec.UNSPECIFIED);
		final int height = view.getMeasuredHeight();
		mRecycler.addScrapView(view, position);
		return height;
		}
		}

		/**
		* Returns the row for the specified item position.
		*
		* @param position the item position
		* @return the row index
		*/
		public int getRowForPosition(int position) {
		return position;
		}

		/**
		* Returns the first item position within the specified row.
		*
		* @param row the row
		* @return the item position
		*/
		public int getFirstPositionForRow(int row) {
		return row;
		}

		/**
		* Sets the selected item and positions the selection y pixels from the top edge
		* of the ListView. (If in touch mode, the item will not be selected but it will
		* still be positioned appropriately.)
		*
		* @param position Index (starting at 0) of the data item to be selected.
		* @param y The distance from the top edge of the ListView (plus padding) that the
		* item will be positioned.
		*/
		public void setSelectionFromTop(int position, int y) {
		if (mAdapter == null) {
		return;
		}

		if (!isInTouchMode()) {
		position = lookForSelectablePosition(position, true);
		if (position >= 0) {
		setNextSelectedPositionInt(position);
		}
		} else {
		mResurrectToPosition = position;
		}

		if (position >= 0) {
		mLayoutMode = LAYOUT_SPECIFIC;
		mSpecificTop = mListPadding.top + y;

		if (mNeedSync) {
		mSyncPosition = position;
		mSyncRowId = mAdapter.getItemId(position);
		}

		if (mPositionScroller != null) {
		mPositionScroller.stop();
		}
		requestLayout();
		}
		}

		class SubPositionScroller {
		private static final int DEFAULT_SCROLL_DURATION = 200;

		private SubScroller mSubScroller;

		/**
		* The target offset in pixels between the top of the list and the top
		* of the target position.
		*/
		private int mOffset;

		/**
		* Scroll the minimum amount to get the target view entirely on-screen.
		*/
		private void scrollToPosition(final int targetPosition, final boolean useOffset,
		final int offset, final int boundPosition, final int duration) {
		stop();

		if (mDataChanged) {
		// Wait until we're back in a stable state to try this.
		mPositionScrollAfterLayout = new Runnable() {
		@Override
		public void run() {
		scrollToPosition(
		targetPosition, useOffset, offset, boundPosition, duration);
		}
		};
		return;
		}

		final int firstPosition = getFirstVisiblePosition();
		final int lastPosition = firstPosition + getChildCount();
		final int targetRow = getRowForPosition(targetPosition);
		final int firstRow = getRowForPosition(firstPosition);
		final int lastRow = getRowForPosition(lastPosition);
		if (useOffset \|\| targetRow <= firstRow) {
		// Offset so the target row is top-aligned.
		mOffset = offset;
		} else if (targetRow >= lastRow - 1) {
		// Offset so the target row is bottom-aligned.
		final int listHeight = getHeight() - getPaddingTop() - getPaddingBottom();
		mOffset = listHeight - getHeightForPosition(targetPosition);
		} else {
		// Don't scroll, target is entirely on-screen.
		return;
		}

		float endSubRow = targetRow;
		if (boundPosition != INVALID_POSITION) {
		final int boundRow = getRowForPosition(boundPosition);
		if (boundRow >= firstRow && boundRow < lastRow) {
		endSubRow = computeBoundSubRow(targetRow, boundRow);
		}
		}

		final View firstChild = getChildAt(0);
		if (firstChild == null) {
		return;
		}

		final int firstChildHeight = firstChild.getHeight();
		final float startOffsetRatio;
		if (firstChildHeight == 0) {
		startOffsetRatio = 1;
		} else {
		startOffsetRatio = -firstChild.getTop() / (float) firstChildHeight;
		}

		final float startSubRow = firstRow + startOffsetRatio;
		if (startSubRow == endSubRow && mOffset == 0) {
		// Don't scroll, target is already in position.
		return;
		}

		if (mSubScroller == null) {
		mSubScroller = new SubScroller();
		}
		mSubScroller.startScroll(startSubRow, endSubRow, duration);

		postOnAnimation(mAnimationFrame);
		}

		private float computeBoundSubRow(int targetRow, int boundRow) {
		// Compute the target and offset as a sub-position.
		int remainingOffset = mOffset;
		int targetHeight = getHeightForRow(targetRow - 1);
		while (remainingOffset > 0) {
		remainingOffset -= targetHeight;
		targetRow--;
		targetHeight = getHeightForRow(targetRow - 1);
		}

		final float targetOffsetRatio;
		if (targetHeight == 0) {
		targetOffsetRatio = 1;
		} else {
		targetOffsetRatio = remainingOffset / (float) targetHeight;
		}

		final float targetSubRow = targetRow - targetOffsetRatio;
		mOffset = 0;

		if (targetSubRow >= boundRow) {
		// End position would push the bound position above the list.
		return boundRow;
		}

		// Compute the closest possible sub-position that wouldn't push the
		// bound position's view further below the list.
		final int listHeight = getHeight() - getPaddingTop() - getPaddingBottom();
		final int boundHeight = getHeightForRow(boundRow);
		int endRow = boundRow;
		int totalHeight = boundHeight;
		int endHeight;
		do {
		endRow--;
		endHeight = getHeightForRow(endRow);
		totalHeight += endHeight;
		} while (totalHeight < listHeight && endRow > 0);

		final float endOffsetRatio;
		if (endHeight == 0) {
		endOffsetRatio = 1;
		} else {
		endOffsetRatio = (totalHeight - listHeight) / (float) endHeight;
		}

		final float boundSubRow = endRow + endOffsetRatio;
		return Math.max(boundSubRow, targetSubRow);
		}

		public void start(int position, int boundPosition) {
		scrollToPosition(position, false, 0, boundPosition, DEFAULT_SCROLL_DURATION);
		}

		public void startWithOffset(int position, int offset, int duration) {
		scrollToPosition(position, true, offset, INVALID_POSITION, duration);
		}

		public void start(int position) {
		scrollToPosition(position, false, 0, INVALID_POSITION, DEFAULT_SCROLL_DURATION);
		}

		public void stop() {
		removeCallbacks(mAnimationFrame);
		}

		private void onAnimationFrame() {
		final boolean shouldPost = mSubScroller.computePosition();
		final float subRow = mSubScroller.getPosition();

		final int row = (int) subRow;
		final int position = getFirstPositionForRow(row);
		final int rowHeight = getHeightForRow(row);
		final int offset = (int) (rowHeight * (subRow - row));
		final int addOffset = (int) (mOffset * mSubScroller.getInterpolatedValue());
		setSelectionFromTop(position, -offset + addOffset);

		if (shouldPost) {
		postOnAnimation(mAnimationFrame);
		}
		}

		private Runnable mAnimationFrame = new Runnable() {
		@Override
		public void run() {
		onAnimationFrame();
		}
		};
		}

		/**
		* Scroller capable of returning floating point positions.
		*/
		private static class SubScroller {
		private final Interpolator mInterpolator;

		private float mStartPosition;
		private float mEndPosition;
		private long mStartTime;
		private long mDuration;

		private float mPosition;
		private float mInterpolatedValue;

		public SubScroller() {
		this(null);
		}

		public SubScroller(Interpolator interpolator) {
		if (interpolator == null) {
		mInterpolator = new AccelerateDecelerateInterpolator();
		} else {
		mInterpolator = interpolator;
		}
		}

		public void startScroll(float startPosition, float endPosition, int duration) {
		mStartPosition = startPosition;
		mEndPosition = endPosition;
		mDuration = duration;

		mStartTime = AnimationUtils.currentAnimationTimeMillis();
		mPosition = startPosition;
		mInterpolatedValue = 0;
		}

		public boolean computePosition() {
		final long elapsed = AnimationUtils.currentAnimationTimeMillis() - mStartTime;
		final float value;
		if (mDuration <= 0) {
		value = 1;
		} else {
		value = MathUtils.constrain(elapsed / (float) mDuration, 0, 1);
		}

		mInterpolatedValue = mInterpolator.getInterpolation(value);
		mPosition = (mEndPosition - mStartPosition) * mInterpolatedValue + mStartPosition;

		return elapsed < mDuration;
		}

		public float getPosition() {
		return mPosition;
		}

		public float getInterpolatedValue() {
		return mInterpolatedValue;
		}
		}
		}

core/java/android/widget/GridView.java

+10 −0

Original line number	Diff line number	Diff line
		@@ -1026,6 +1026,16 @@ public class GridView extends AbsListView {
		return didNotInitiallyFit;
		}

		@Override
		public int getRowForPosition(int position) {
		return position / mNumColumns;
		}

		@Override
		public int getFirstPositionForRow(int row) {
		return row * mNumColumns;
		}

		@Override
		protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
		// Sets up mListPadding

core/java/android/widget/ListView.java

+78 −39

Original line number	Diff line number	Diff line
		@@ -1891,45 +1891,6 @@ public class ListView extends AbsListView {
		setSelectionFromTop(position, 0);
		}

		/**
		* Sets the selected item and positions the selection y pixels from the top edge
		* of the ListView. (If in touch mode, the item will not be selected but it will
		* still be positioned appropriately.)
		*
		* @param position Index (starting at 0) of the data item to be selected.
		* @param y The distance from the top edge of the ListView (plus padding) that the
		* item will be positioned.
		*/
		public void setSelectionFromTop(int position, int y) {
		if (mAdapter == null) {
		return;
		}

		if (!isInTouchMode()) {
		position = lookForSelectablePosition(position, true);
		if (position >= 0) {
		setNextSelectedPositionInt(position);
		}
		} else {
		mResurrectToPosition = position;
		}

		if (position >= 0) {
		mLayoutMode = LAYOUT_SPECIFIC;
		mSpecificTop = mListPadding.top + y;

		if (mNeedSync) {
		mSyncPosition = position;
		mSyncRowId = mAdapter.getItemId(position);
		}

		if (mPositionScroller != null) {
		mPositionScroller.stop();
		}
		requestLayout();
		}
		}

		/**
		* Makes the item at the supplied position selected.
		*
		@@ -3745,6 +3706,84 @@ public class ListView extends AbsListView {
		return new long[0];
		}

		@Override
		int getHeightForPosition(int position) {
		final int height = super.getHeightForPosition(position);
		if (shouldAdjustHeightForDivider(position)) {
		return height + mDividerHeight;
		}
		return height;
		}

		private boolean shouldAdjustHeightForDivider(int itemIndex) {
		final int dividerHeight = mDividerHeight;
		final Drawable overscrollHeader = mOverScrollHeader;
		final Drawable overscrollFooter = mOverScrollFooter;
		final boolean drawOverscrollHeader = overscrollHeader != null;
		final boolean drawOverscrollFooter = overscrollFooter != null;
		final boolean drawDividers = dividerHeight > 0 && mDivider != null;

		if (drawDividers) {
		final boolean fillForMissingDividers = isOpaque() && !super.isOpaque();
		final int itemCount = mItemCount;
		final int headerCount = mHeaderViewInfos.size();
		final int footerLimit = (itemCount - mFooterViewInfos.size());
		final boolean isHeader = (itemIndex < headerCount);
		final boolean isFooter = (itemIndex >= footerLimit);
		final boolean headerDividers = mHeaderDividersEnabled;
		final boolean footerDividers = mFooterDividersEnabled;
		if ((headerDividers \|\| !isHeader) && (footerDividers \|\| !isFooter)) {
		final ListAdapter adapter = mAdapter;
		if (!mStackFromBottom) {
		final boolean isLastItem = (itemIndex == (itemCount - 1));
		if (!drawOverscrollFooter \|\| !isLastItem) {
		final int nextIndex = itemIndex + 1;
		// Draw dividers between enabled items, headers
		// and/or footers when enabled and requested, and
		// after the last enabled item.
		if (adapter.isEnabled(itemIndex) && (headerDividers \|\| !isHeader
		&& (nextIndex >= headerCount)) && (isLastItem
		\|\| adapter.isEnabled(nextIndex) && (footerDividers \|\| !isFooter
		&& (nextIndex < footerLimit)))) {
		return true;
		} else if (fillForMissingDividers) {
		return true;
		}
		}
		} else {
		final int start = drawOverscrollHeader ? 1 : 0;
		final boolean isFirstItem = (itemIndex == start);
		if (!isFirstItem) {
		final int previousIndex = (itemIndex - 1);
		// Draw dividers between enabled items, headers
		// and/or footers when enabled and requested, and
		// before the first enabled item.
		if (adapter.isEnabled(itemIndex) && (headerDividers \|\| !isHeader
		&& (previousIndex >= headerCount)) && (isFirstItem \|\|
		adapter.isEnabled(previousIndex) && (footerDividers \|\| !isFooter
		&& (previousIndex < footerLimit)))) {
		return true;
		} else if (fillForMissingDividers) {
		return true;
		}
		}
		}
		}
		}

		return false;
		}

		@Override
		public int getRowForPosition(int position) {
		return position;
		}

		@Override
		public int getFirstPositionForRow(int row) {
		return row;
		}

		@Override
		public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
		super.onInitializeAccessibilityEvent(event);