package com.ov3rk1ll.kinocast.ui.helper.layout;
/*
* Copyright (C) 2014 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 languag`e governing permissions and
* limitations under the License.
*/
import android.content.Context;
import android.graphics.PointF;
import android.os.Parcel;
import android.os.Parcelable;
import android.support.v4.view.ViewCompat;
import android.support.v7.widget.LinearSmoothScroller;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import java.util.List;
/**
* A {@link android.support.v7.widget.RecyclerView.LayoutManager} implementation which provides
* similar functionality to {@link android.widget.ListView}.
*/
public abstract class BaseLayoutManager extends RecyclerView.LayoutManager {
private static final String TAG = "LinearLayoutManager";
protected static final boolean DEBUG = false;
public static final int HORIZONTAL = LinearLayout.HORIZONTAL;
public static final int VERTICAL = LinearLayout.VERTICAL;
public static final int INVALID_OFFSET = Integer.MIN_VALUE;
/**
* While trying to find next view to focus, LinearLayoutManager will not try to scroll more
* than
* this factor times the total space of the list. If layout is vertical, total space is the
* height minus padding, if layout is horizontal, total space is the width minus padding.
*/
private static final float MAX_SCROLL_FACTOR = 0.33f;
/**
* Current orientation. Either {@link #HORIZONTAL} or {@link #VERTICAL}
*/
protected int mOrientation;
/**
* Helper class that keeps temporary rendering state.
* It does not keep state after rendering is complete but we still keep a reference to re-use
* the same object.
*/
protected RenderState mRenderState;
/**
* Many calculations are made depending on orientation. To keep it clean, this interface
* helps {@link BaseLayoutManager} make those decisions.
* Based on {@link #mOrientation}, an implementation is lazily created in
* {@link #ensureRenderState} method.
*/
OrientationHelper mOrientationHelper;
/**
* We need to track this so that we can ignore current position when it changes.
*/
private boolean mLastStackFromEnd;
/**
* Defines if layout should be calculated from end to start.
*
* @see #mShouldReverseLayout
*/
private boolean mReverseLayout = false;
/**
* This keeps the final value for how LayoutManager shouls start laying out views.
* It is calculated by checking {@link #getReverseLayout()} and View's layout direction.
* {@link #onLayoutChildren(android.support.v7.widget.RecyclerView.Recycler, android.support.v7.widget.RecyclerView.State)} is run.
*/
protected boolean mShouldReverseLayout = false;
/**
* Works the same way as {@link android.widget.AbsListView#setStackFromBottom(boolean)} and
* it supports both orientations.
* see {@link android.widget.AbsListView#setStackFromBottom(boolean)}
*/
private boolean mStackFromEnd = false;
/**
* When LayoutManager needs to scroll to a position, it sets this variable and requests a
* layout which will check this variable and re-layout accordingly.
*/
private int mPendingScrollPosition = RecyclerView.NO_POSITION;
/**
* Used to keep the offset value when {@link #scrollToPositionWithOffset(int, int)} is
* called.
*/
private int mPendingScrollPositionOffset = INVALID_OFFSET;
private SavedState mPendingSavedState = null;
/**
* Creates a vertical LinearLayoutManager
*
* @param context Current context, will be used to access resources.
*/
public BaseLayoutManager(Context context) {
this(context, VERTICAL, false);
}
/**
* @param context Current context, will be used to access resources.
* @param orientation Layout orientation. Should be {@link #HORIZONTAL} or {@link
* #VERTICAL}.
* @param reverseLayout When set to true, renders the layout from end to start.
*/
public BaseLayoutManager(Context context, int orientation, boolean reverseLayout) {
setOrientation(orientation);
setReverseLayout(reverseLayout);
}
/**
* {@inheritDoc}
*/
@Override
public RecyclerView.LayoutParams generateDefaultLayoutParams() {
return new RecyclerView.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
ViewGroup.LayoutParams.WRAP_CONTENT);
}
@Override
public Parcelable onSaveInstanceState() {
if (mPendingSavedState != null) {
return new SavedState(mPendingSavedState);
}
SavedState state = new SavedState();
if (getChildCount() > 0) {
boolean didLayoutFromEnd = mLastStackFromEnd ^ mShouldReverseLayout;
state.mAnchorLayoutFromEnd = didLayoutFromEnd;
if (didLayoutFromEnd) {
final View refChild = getChildClosestToEnd();
state.mAnchorOffset = mOrientationHelper.getEndAfterPadding() -
mOrientationHelper.getDecoratedEnd(refChild);
state.mAnchorPosition = getPosition(refChild);
} else {
final View refChild = getChildClosestToStart();
state.mAnchorPosition = getPosition(refChild);
state.mAnchorOffset = mOrientationHelper.getDecoratedStart(refChild) -
mOrientationHelper.getStartAfterPadding();
}
} else {
state.mAnchorPosition = 0;
state.mAnchorOffset = 0;
}
state.mStackFromEnd = mStackFromEnd;
state.mReverseLayout = mReverseLayout;
state.mOrientation = mOrientation;
return state;
}
@Override
public void onRestoreInstanceState(Parcelable state) {
if (state instanceof SavedState) {
mPendingSavedState = (SavedState) state;
requestLayout();
if (DEBUG) {
Log.d(TAG, "loaded saved state");
}
} else if (DEBUG) {
Log.d(TAG, "invalid saved state class");
}
}
/**
* @return true if {@link #getOrientation()} is {@link #HORIZONTAL}
*/
@Override
public boolean canScrollHorizontally() {
return mOrientation == HORIZONTAL;
}
/**
* @return true if {@link #getOrientation()} is {@link #VERTICAL}
*/
@Override
public boolean canScrollVertically() {
return mOrientation == VERTICAL;
}
/**
* Compatibility support for {@link android.widget.AbsListView#setStackFromBottom(boolean)}
*/
public void setStackFromEnd(boolean stackFromEnd) {
if (mPendingSavedState != null && mPendingSavedState.mStackFromEnd != stackFromEnd) {
// override pending state
mPendingSavedState.mStackFromEnd = stackFromEnd;
}
if (mStackFromEnd == stackFromEnd) {
return;
}
mStackFromEnd = stackFromEnd;
requestLayout();
}
public boolean getStackFromEnd() {
return mStackFromEnd;
}
/**
* Returns the current orientaion of the layout.
*
* @return Current orientation.
* @see #mOrientation
* @see #setOrientation(int)
*/
public int getOrientation() {
return mOrientation;
}
/**
* Sets the orientation of the layout. {@link android.support.v7.widget.LinearLayoutManager}
* will do its best to keep scroll position.
*
* @param orientation {@link #HORIZONTAL} or {@link #VERTICAL}
*/
public void setOrientation(int orientation) {
if (orientation != HORIZONTAL && orientation != VERTICAL) {
throw new IllegalArgumentException("invalid orientation.");
}
if (mPendingSavedState != null && mPendingSavedState.mOrientation != orientation) {
// override pending state
mPendingSavedState.mOrientation = orientation;
}
if (orientation == mOrientation) {
return;
}
mOrientation = orientation;
mOrientationHelper = null;
requestLayout();
}
/**
* Calculates the view layout order. (e.g. from end to start or start to end)
* RTL layout support is applied automatically. So if layout is RTL and
* {@link #getReverseLayout()} is {@code true}, elements will be laid out starting from left.
*/
private void resolveShouldLayoutReverse() {
// A == B is the same result, but we rather keep it readable
if (mOrientation == VERTICAL || !isLayoutRTL()) {
mShouldReverseLayout = mReverseLayout;
} else {
mShouldReverseLayout = !mReverseLayout;
}
}
/**
* Returns if views are laid out from the opposite direction of the layout.
*
* @return If layout is reversed or not.
* @see {@link #setReverseLayout(boolean)}
*/
public boolean getReverseLayout() {
return mReverseLayout;
}
/**
* Used to reverse item traversal and layout order.
* This behaves similar to the layout change for RTL views. When set to true, first item is
* rendered at the end of the UI, second item is render before it etc.
* <p/>
* For horizontal layouts, it depends on the layout direction.
* When set to true, If {@link android.support.v7.widget.RecyclerView} is LTR, than it will
* render from RTL, if {@link android.support.v7.widget.RecyclerView}} is RTL, it will render
* from LTR.
* <p/>
* If you are looking for the exact same behavior of
* {@link android.widget.AbsListView#setStackFromBottom(boolean)}, use
* {@link #setStackFromEnd(boolean)}
*/
public void setReverseLayout(boolean reverseLayout) {
if (mPendingSavedState != null && mPendingSavedState.mReverseLayout != reverseLayout) {
// override pending state
mPendingSavedState.mReverseLayout = reverseLayout;
}
if (reverseLayout == mReverseLayout) {
return;
}
mReverseLayout = reverseLayout;
requestLayout();
}
/**
* {@inheritDoc}
*/
@Override
public View findViewByPosition(int position) {
final int childCount = getChildCount();
if (childCount == 0) {
return null;
}
final int firstChild = getPosition(getChildAt(0));
final int viewPosition = position - firstChild;
if (viewPosition >= 0 && viewPosition < childCount) {
return getChildAt(viewPosition);
}
return null;
}
/**
* <p>Returns the amount of extra space that should be rendered by LinearLayoutManager.
* By default, {@link android.support.v7.widget.LinearLayoutManager} lays out 1 extra page of
* items while smooth scrolling and 0 otherwise. You can override this method to implement your
* custom layout pre-cache logic.</p>
* <p>Laying out invisible elements will eventually come with performance cost. On the other
* hand, in places like smooth scrolling to an unknown location, this extra content helps
* LayoutManager to calculate a much smoother scrolling; which improves user experience.</p>
* <p>You can also use this if you are trying to pre-render your upcoming views.</p>
*
* @return The extra space that should be laid out (in pixels).
*/
protected int getExtraLayoutSpace(RecyclerView.State state) {
if (state.hasTargetScrollPosition()) {
return mOrientationHelper.getTotalSpace();
} else {
return 0;
}
}
@Override
public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state,
int position) {
LinearSmoothScroller linearSmoothScroller =
new LinearSmoothScroller(recyclerView.getContext()) {
@Override
public PointF computeScrollVectorForPosition(int targetPosition) {
return BaseLayoutManager.this
.computeScrollVectorForPosition(targetPosition);
}
};
linearSmoothScroller.setTargetPosition(position);
startSmoothScroll(linearSmoothScroller);
}
public PointF computeScrollVectorForPosition(int targetPosition) {
if (getChildCount() == 0) {
return null;
}
final int firstChildPos = getPosition(getChildAt(0));
final int direction = targetPosition < firstChildPos != mShouldReverseLayout ? -1 : 1;
if (mOrientation == HORIZONTAL) {
return new PointF(direction, 0);
} else {
return new PointF(0, direction);
}
}
/**
* {@inheritDoc}
*/
@Override
public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
// layout algorithm:
// 1) by checking children and other variables, find an anchor coordinate and an anchor
// item position.
// 2) fill towards start, stacking from bottom
// 3) fill towards end, stacking from top
// 4) scroll to fulfill requirements like stack from bottom.
// create render state
if (DEBUG) {
Log.d(TAG, "is pre layout:" + state.isPreLayout());
}
if (mPendingSavedState != null) {
setOrientation(mPendingSavedState.mOrientation);
setReverseLayout(mPendingSavedState.mReverseLayout);
setStackFromEnd(mPendingSavedState.mStackFromEnd);
mPendingScrollPosition = mPendingSavedState.mAnchorPosition;
}
ensureRenderState();
// resolve layout direction
resolveShouldLayoutReverse();
// validate scroll position if exists
if (mPendingScrollPosition != RecyclerView.NO_POSITION) {
// validate it
if (mPendingScrollPosition < 0 || mPendingScrollPosition >= state.getItemCount()) {
mPendingScrollPosition = RecyclerView.NO_POSITION;
mPendingScrollPositionOffset = INVALID_OFFSET;
if (DEBUG) {
Log.e(TAG, "ignoring invalid scroll position " + mPendingScrollPosition);
}
}
}
// this value might be updated if there is a target scroll position without an offset
boolean layoutFromEnd = mShouldReverseLayout ^ mStackFromEnd;
final boolean stackFromEndChanged = mLastStackFromEnd != mStackFromEnd;
int anchorCoordinate, anchorItemPosition;
if (mPendingScrollPosition != RecyclerView.NO_POSITION) {
// if child is visible, try to make it a reference child and ensure it is fully visible.
// if child is not visible, align it depending on its virtual position.
anchorItemPosition = mPendingScrollPosition;
if (mPendingSavedState != null) {
// Anchor offset depends on how that child was laid out. Here, we update it
// according to our current view bounds
layoutFromEnd = mPendingSavedState.mAnchorLayoutFromEnd;
if (layoutFromEnd) {
anchorCoordinate = mOrientationHelper.getEndAfterPadding() -
mPendingSavedState.mAnchorOffset;
} else {
anchorCoordinate = mOrientationHelper.getStartAfterPadding() +
mPendingSavedState.mAnchorOffset;
}
} else if (mPendingScrollPositionOffset == INVALID_OFFSET) {
View child = findViewByPosition(mPendingScrollPosition);
if (child != null) {
final int startGap = mOrientationHelper.getDecoratedStart(child)
- mOrientationHelper.getStartAfterPadding();
final int endGap = mOrientationHelper.getEndAfterPadding() -
mOrientationHelper.getDecoratedEnd(child);
final int childSize = mOrientationHelper.getDecoratedMeasurement(child);
if (childSize > mOrientationHelper.getTotalSpace()) {
// item does not fit. fix depending on layout direction
anchorCoordinate = layoutFromEnd ? mOrientationHelper.getEndAfterPadding()
: mOrientationHelper.getStartAfterPadding();
} else if (startGap < 0) {
anchorCoordinate = mOrientationHelper.getStartAfterPadding();
layoutFromEnd = false;
} else if (endGap < 0) {
anchorCoordinate = mOrientationHelper.getEndAfterPadding();
layoutFromEnd = true;
} else {
anchorCoordinate = layoutFromEnd
? mOrientationHelper.getDecoratedEnd(child)
: mOrientationHelper.getDecoratedStart(child);
}
} else { // item is not visible.
if (getChildCount() > 0) {
// get position of any child, does not matter
int pos = getPosition(getChildAt(0));
if (mPendingScrollPosition < pos == mShouldReverseLayout) {
anchorCoordinate = mOrientationHelper.getEndAfterPadding();
layoutFromEnd = true;
} else {
anchorCoordinate = mOrientationHelper.getStartAfterPadding();
layoutFromEnd = false;
}
} else {
anchorCoordinate = layoutFromEnd ? mOrientationHelper.getEndAfterPadding()
: mOrientationHelper.getStartAfterPadding();
}
}
} else {
// override layout from end values for consistency
if (mShouldReverseLayout) {
anchorCoordinate = mOrientationHelper.getEndAfterPadding()
- mPendingScrollPositionOffset;
layoutFromEnd = true;
} else {
anchorCoordinate = mOrientationHelper.getStartAfterPadding()
+ mPendingScrollPositionOffset;
layoutFromEnd = false;
}
}
} else if (getChildCount() > 0 && !stackFromEndChanged) {
if (layoutFromEnd) {
View referenceChild = getChildClosestToEnd();
anchorCoordinate = mOrientationHelper.getDecoratedEnd(referenceChild);
anchorItemPosition = getPosition(referenceChild);
} else {
View referenceChild = getChildClosestToStart();
anchorCoordinate = mOrientationHelper.getDecoratedStart(referenceChild);
anchorItemPosition = getPosition(referenceChild);
}
} else {
anchorCoordinate = layoutFromEnd ? mOrientationHelper.getEndAfterPadding() :
mOrientationHelper.getStartAfterPadding();
anchorItemPosition = mStackFromEnd ? state.getItemCount() - 1 : 0;
}
detachAndScrapAttachedViews(recycler);
final int extraForStart;
final int extraForEnd;
final int extra = getExtraLayoutSpace(state);
boolean before = state.getTargetScrollPosition() < anchorItemPosition;
if (before == mShouldReverseLayout) {
extraForEnd = extra;
extraForStart = 0;
} else {
extraForStart = extra;
extraForEnd = 0;
}
// first fill towards start
updateRenderStateToFillStart(anchorItemPosition, anchorCoordinate);
mRenderState.mExtra = extraForStart;
if (!layoutFromEnd) {
mRenderState.mCurrentPosition += mRenderState.mItemDirection;
}
fill(recycler, mRenderState, state, false);
int startOffset = mRenderState.mOffset;
// fill towards end
updateRenderStateToFillEnd(anchorItemPosition, anchorCoordinate);
mRenderState.mExtra = extraForEnd;
if (layoutFromEnd) {
mRenderState.mCurrentPosition += mRenderState.mItemDirection;
}
fill(recycler, mRenderState, state, false);
int endOffset = mRenderState.mOffset;
// changes may cause gaps on the UI, try to fix them.
if (getChildCount() > 0) {
// because layout from end may be changed by scroll to position
// we re-calculate it.
// find which side we should check for gaps.
if (mShouldReverseLayout ^ mStackFromEnd) {
int fixOffset = fixLayoutEndGap(endOffset, recycler, state, true);
startOffset += fixOffset;
endOffset += fixOffset;
fixOffset = fixLayoutStartGap(startOffset, recycler, state, false);
startOffset += fixOffset;
endOffset += fixOffset;
} else {
int fixOffset = fixLayoutStartGap(startOffset, recycler, state, true);
startOffset += fixOffset;
endOffset += fixOffset;
fixOffset = fixLayoutEndGap(endOffset, recycler, state, false);
startOffset += fixOffset;
endOffset += fixOffset;
}
}
// If there are scrap children that we did not layout, we need to find where they did go
// and layout them accordingly so that animations can work as expected.
// This case may happen if new views are added or an existing view expands and pushes
// another view out of bounds.
if (getChildCount() > 0 && !state.isPreLayout() && supportsPredictiveItemAnimations()) {
// to make the logic simpler, we calculate the size of children and call fill.
int scrapExtraStart = 0, scrapExtraEnd = 0;
final List<RecyclerView.ViewHolder> scrapList = recycler.getScrapList();
final int scrapSize = scrapList.size();
final int firstChildPos = getPosition(getChildAt(0));
for (int i = 0; i < scrapSize; i++) {
RecyclerView.ViewHolder scrap = scrapList.get(i);
final int position = scrap.getPosition();
final int direction = position < firstChildPos != mShouldReverseLayout
? RenderState.LAYOUT_START : RenderState.LAYOUT_END;
if (direction == RenderState.LAYOUT_START) {
scrapExtraStart += mOrientationHelper.getDecoratedMeasurement(scrap.itemView);
} else {
scrapExtraEnd += mOrientationHelper.getDecoratedMeasurement(scrap.itemView);
}
}
if (DEBUG) {
Log.d(TAG, "for unused scrap, decided to add " + scrapExtraStart
+ " towards start and " + scrapExtraEnd + " towards end");
}
mRenderState.mScrapList = scrapList;
if (scrapExtraStart > 0) {
View anchor = getChildClosestToStart();
updateRenderStateToFillStart(getPosition(anchor), startOffset);
mRenderState.mExtra = scrapExtraStart;
mRenderState.mAvailable = 0;
mRenderState.mCurrentPosition += mShouldReverseLayout ? 1 : -1;
fill(recycler, mRenderState, state, false);
}
if (scrapExtraEnd > 0) {
View anchor = getChildClosestToEnd();
updateRenderStateToFillEnd(getPosition(anchor),
endOffset);
mRenderState.mExtra = scrapExtraEnd;
mRenderState.mAvailable = 0;
mRenderState.mCurrentPosition += mShouldReverseLayout ? -1 : 1;
fill(recycler, mRenderState, state, false);
}
mRenderState.mScrapList = null;
}
mPendingScrollPosition = RecyclerView.NO_POSITION;
mPendingScrollPositionOffset = INVALID_OFFSET;
mLastStackFromEnd = mStackFromEnd;
mPendingSavedState = null; // we don't need this anymore
if (DEBUG) {
validateChildOrder();
}
}
/**
* @return The final offset amount for children
*/
private int fixLayoutEndGap(int endOffset, RecyclerView.Recycler recycler,
RecyclerView.State state, boolean canOffsetChildren) {
int gap = mOrientationHelper.getEndAfterPadding() - endOffset;
int fixOffset = 0;
if (gap > 0) {
fixOffset = -scrollBy(-gap, recycler, state);
} else {
return 0; // nothing to fix
}
// move offset according to scroll amount
endOffset += fixOffset;
if (canOffsetChildren) {
// re-calculate gap, see if we could fix it
gap = mOrientationHelper.getEndAfterPadding() - endOffset;
if (gap > 0) {
mOrientationHelper.offsetChildren(gap);
return gap + fixOffset;
}
}
return fixOffset;
}
/**
* @return The final offset amount for children
*/
private int fixLayoutStartGap(int startOffset, RecyclerView.Recycler recycler,
RecyclerView.State state, boolean canOffsetChildren) {
int gap = startOffset - mOrientationHelper.getStartAfterPadding();
int fixOffset = 0;
if (gap > 0) {
// check if we should fix this gap.
fixOffset = -scrollBy(gap, recycler, state);
} else {
return 0; // nothing to fix
}
startOffset += fixOffset;
if (canOffsetChildren) {
// re-calculate gap, see if we could fix it
gap = startOffset - mOrientationHelper.getStartAfterPadding();
if (gap > 0) {
mOrientationHelper.offsetChildren(-gap);
return fixOffset - gap;
}
}
return fixOffset;
}
private void updateRenderStateToFillEnd(int itemPosition, int offset) {
mRenderState.mAvailable = mOrientationHelper.getEndAfterPadding() - offset;
mRenderState.mItemDirection = mShouldReverseLayout ? RenderState.ITEM_DIRECTION_HEAD :
RenderState.ITEM_DIRECTION_TAIL;
mRenderState.mCurrentPosition = itemPosition;
mRenderState.mLayoutDirection = RenderState.LAYOUT_END;
mRenderState.mOffset = offset;
mRenderState.mScrollingOffset = RenderState.SCOLLING_OFFSET_NaN;
}
private void updateRenderStateToFillStart(int itemPosition, int offset) {
mRenderState.mAvailable = offset - mOrientationHelper.getStartAfterPadding();
mRenderState.mCurrentPosition = itemPosition;
mRenderState.mItemDirection = mShouldReverseLayout ? RenderState.ITEM_DIRECTION_TAIL :
RenderState.ITEM_DIRECTION_HEAD;
mRenderState.mLayoutDirection = RenderState.LAYOUT_START;
mRenderState.mOffset = offset;
mRenderState.mScrollingOffset = RenderState.SCOLLING_OFFSET_NaN;
}
protected boolean isLayoutRTL() {
return getLayoutDirection() == ViewCompat.LAYOUT_DIRECTION_RTL;
}
void ensureRenderState() {
if (mRenderState == null) {
mRenderState = new RenderState();
}
if (mOrientationHelper == null) {
mOrientationHelper = mOrientation == HORIZONTAL ? createHorizontalOrientationHelper()
: createVerticalOrientationHelper();
}
}
/**
* <p>Scroll the RecyclerView to make the position visible.</p>
* <p/>
* <p>RecyclerView will scroll the minimum amount that is necessary to make the
* target position visible. If you are looking for a similar behavior to
* {@link android.widget.ListView#setSelection(int)} or
* {@link android.widget.ListView#setSelectionFromTop(int, int)}, use
* {@link #scrollToPositionWithOffset(int, int)}.</p>
* <p/>
* <p>Note that scroll position change will not be reflected until the next layout call.</p>
*
* @param position Scroll to this adapter position
* @see #scrollToPositionWithOffset(int, int)
*/
@Override
public void scrollToPosition(int position) {
mPendingScrollPosition = position;
mPendingScrollPositionOffset = INVALID_OFFSET;
requestLayout();
}
/**
* <p>Scroll to the specified adapter position with the given offset from layout start.</p>
* <p/>
* <p>Note that scroll position change will not be reflected until the next layout call.</p>
* <p/>
* <p>If you are just trying to make a position visible, use {@link
* #scrollToPosition(int)}.</p>
*
* @param position Index (starting at 0) of the reference item.
* @param offset The distance (in pixels) between the start edge of the item view and
* start edge of the RecyclerView.
* @see #setReverseLayout(boolean)
* @see #scrollToPosition(int)
*/
public void scrollToPositionWithOffset(int position, int offset) {
mPendingScrollPosition = position;
mPendingScrollPositionOffset = offset;
requestLayout();
}
/**
* {@inheritDoc}
*/
@Override
public int scrollHorizontallyBy(int dx, RecyclerView.Recycler recycler,
RecyclerView.State state) {
if (mOrientation == VERTICAL) {
return 0;
}
return scrollBy(dx, recycler, state);
}
/**
* {@inheritDoc}
*/
@Override
public int scrollVerticallyBy(int dy, RecyclerView.Recycler recycler,
RecyclerView.State state) {
if (mOrientation == HORIZONTAL) {
return 0;
}
return scrollBy(dy, recycler, state);
}
@Override
public int computeHorizontalScrollOffset(RecyclerView.State state) {
if (getChildCount() == 0) {
return 0;
}
final int topPosition = getPosition(getChildClosestToStart());
return mShouldReverseLayout ? state.getItemCount() - 1 - topPosition : topPosition;
}
@Override
public int computeVerticalScrollOffset(RecyclerView.State state) {
if (getChildCount() == 0) {
return 0;
}
final int topPosition = getPosition(getChildClosestToStart());
return mShouldReverseLayout ? state.getItemCount() - 1 - topPosition : topPosition;
}
@Override
public int computeHorizontalScrollExtent(RecyclerView.State state) {
return getChildCount();
}
@Override
public int computeVerticalScrollExtent(RecyclerView.State state) {
return getChildCount();
}
@Override
public int computeHorizontalScrollRange(RecyclerView.State state) {
return state.getItemCount();
}
@Override
public int computeVerticalScrollRange(RecyclerView.State state) {
return state.getItemCount();
}
private void updateRenderState(int layoutDirection, int requiredSpace,
boolean canUseExistingSpace, RecyclerView.State state) {
mRenderState.mExtra = getExtraLayoutSpace(state);
mRenderState.mLayoutDirection = layoutDirection;
int fastScrollSpace;
if (layoutDirection == RenderState.LAYOUT_END) {
// get the first child in the direction we are going
final View child = getChildClosestToEnd();
// the direction in which we are traversing children
mRenderState.mItemDirection = mShouldReverseLayout ? RenderState.ITEM_DIRECTION_HEAD
: RenderState.ITEM_DIRECTION_TAIL;
mRenderState.mCurrentPosition = getPosition(child) + mRenderState.mItemDirection;
mRenderState.mOffset = mOrientationHelper.getDecoratedEnd(child);
// calculate how much we can scroll without adding new children (independent of layout)
fastScrollSpace = mOrientationHelper.getDecoratedEnd(child)
- mOrientationHelper.getEndAfterPadding();
} else {
final View child = getChildClosestToStart();
mRenderState.mItemDirection = mShouldReverseLayout ? RenderState.ITEM_DIRECTION_TAIL
: RenderState.ITEM_DIRECTION_HEAD;
mRenderState.mCurrentPosition = getPosition(child) + mRenderState.mItemDirection;
mRenderState.mOffset = mOrientationHelper.getDecoratedStart(child);
fastScrollSpace = -mOrientationHelper.getDecoratedStart(child)
+ mOrientationHelper.getStartAfterPadding();
}
mRenderState.mAvailable = requiredSpace;
if (canUseExistingSpace) {
mRenderState.mAvailable -= fastScrollSpace;
}
mRenderState.mScrollingOffset = fastScrollSpace;
}
private int scrollBy(int dy, RecyclerView.Recycler recycler, RecyclerView.State state) {
if (getChildCount() == 0 || dy == 0) {
return 0;
}
ensureRenderState();
final int layoutDirection = dy > 0 ? RenderState.LAYOUT_END : RenderState.LAYOUT_START;
final int absDy = Math.abs(dy);
updateRenderState(layoutDirection, absDy, true, state);
final int freeScroll = mRenderState.mScrollingOffset;
final int consumed = freeScroll + fill(recycler, mRenderState, state, false);
if (consumed < 0) {
if (DEBUG) {
Log.d(TAG, "Don't have any more elements to scroll");
}
return 0;
}
final int scrolled = absDy > consumed ? layoutDirection * consumed : dy;
mOrientationHelper.offsetChildren(-scrolled);
if (DEBUG) {
Log.d(TAG, "scroll req: " + dy + " scrolled: " + scrolled);
}
return scrolled;
}
/**
* Recycles children between given indices.
*
* @param startIndex inclusive
* @param endIndex exclusive
*/
private void recycleChildren(RecyclerView.Recycler recycler, int startIndex, int endIndex) {
if (startIndex == endIndex) {
return;
}
if (DEBUG) {
Log.d(TAG, "Recycling " + Math.abs(startIndex - endIndex) + " items");
}
if (endIndex > startIndex) {
for (int i = endIndex - 1; i >= startIndex; i--) {
removeAndRecycleViewAt(i, recycler);
}
} else {
for (int i = startIndex; i > endIndex; i--) {
removeAndRecycleViewAt(i, recycler);
}
}
}
/**
* Recycles views that went out of bounds after scrolling towards the end of the layout.
*
* @param recycler Recycler instance of {@link android.support.v7.widget.RecyclerView}
* @param dt This can be used to add additional padding to the visible area. This is used
* to
* detect children that will go out of bounds after scrolling, without actually
* moving them.
*/
private void recycleViewsFromStart(RecyclerView.Recycler recycler, int dt) {
if (dt < 0) {
if (DEBUG) {
Log.d(TAG, "Called recycle from start with a negative value. This might happen"
+ " during layout changes but may be sign of a bug");
}
return;
}
final int limit = mOrientationHelper.getStartAfterPadding() + dt;
final int childCount = getChildCount();
if (mShouldReverseLayout) {
for (int i = childCount - 1; i >= 0; i--) {
View child = getChildAt(i);
if (mOrientationHelper.getDecoratedEnd(child) > limit) {// stop here
recycleChildren(recycler, childCount - 1, i);
return;
}
}
} else {
for (int i = 0; i < childCount; i++) {
View child = getChildAt(i);
if (mOrientationHelper.getDecoratedEnd(child) > limit) {// stop here
recycleChildren(recycler, 0, i);
return;
}
}
}
}
/**
* Recycles views that went out of bounds after scrolling towards the start of the layout.
*
* @param recycler Recycler instance of {@link android.support.v7.widget.RecyclerView}
* @param dt This can be used to add additional padding to the visible area. This is used
* to detect children that will go out of bounds after scrolling, without
* actually moving them.
*/
private void recycleViewsFromEnd(RecyclerView.Recycler recycler, int dt) {
final int childCount = getChildCount();
if (dt < 0) {
if (DEBUG) {
Log.d(TAG, "Called recycle from end with a negative value. This might happen"
+ " during layout changes but may be sign of a bug");
}
return;
}
final int limit = mOrientationHelper.getEndAfterPadding() - dt;
if (mShouldReverseLayout) {
for (int i = 0; i < childCount; i++) {
View child = getChildAt(i);
if (mOrientationHelper.getDecoratedStart(child) < limit) {// stop here
recycleChildren(recycler, 0, i);
return;
}
}
} else {
for (int i = childCount - 1; i >= 0; i--) {
View child = getChildAt(i);
if (mOrientationHelper.getDecoratedStart(child) < limit) {// stop here
recycleChildren(recycler, childCount - 1, i);
return;
}
}
}
}
/**
* Helper method to call appropriate recycle method depending on current render layout
* direction
*
* @param recycler Current recycler that is attached to RecyclerView
* @param renderState Current render state. Right now, this object does not change but
* we may consider moving it out of this view so passing around as a
* parameter for now, rather than accessing {@link #mRenderState}
* @see #recycleViewsFromStart(android.support.v7.widget.RecyclerView.Recycler, int)
* @see #recycleViewsFromEnd(android.support.v7.widget.RecyclerView.Recycler, int)
* @see android.support.v7.widget.LinearLayoutManager.RenderState#mLayoutDirection
*/
protected void recycleByRenderState(RecyclerView.Recycler recycler, RenderState renderState) {
if (renderState.mLayoutDirection == RenderState.LAYOUT_START) {
recycleViewsFromEnd(recycler, renderState.mScrollingOffset);
} else {
recycleViewsFromStart(recycler, renderState.mScrollingOffset);
}
}
/**
* The magic functions :). Fills the given layout, defined by the renderState. This is fairly
* independent from the rest of the {@link android.support.v7.widget.LinearLayoutManager}
* and with little change, can be made publicly available as a helper class.
*
* @param recycler Current recycler that is attached to RecyclerView
* @param renderState Configuration on how we should fill out the available space.
* @param state Context passed by the RecyclerView to control scroll steps.
* @param stopOnFocusable If true, filling stops in the first focusable new child
* @return Number of pixels that it added. Useful for scoll functions.
*/
protected abstract int fill(RecyclerView.Recycler recycler, RenderState renderState,
RecyclerView.State state, boolean stopOnFocusable);
/**
* Converts a focusDirection to orientation.
*
* @param focusDirection One of {@link android.view.View#FOCUS_UP}, {@link android.view.View#FOCUS_DOWN},
* {@link android.view.View#FOCUS_LEFT}, {@link android.view.View#FOCUS_RIGHT},
* {@link android.view.View#FOCUS_BACKWARD}, {@link android.view.View#FOCUS_FORWARD}
* or 0 for not applicable
* @return {@link RenderState#LAYOUT_START} or {@link RenderState#LAYOUT_END} if focus direction
* is applicable to current state, {@link RenderState#INVALID_LAYOUT} otherwise.
*/
private int convertFocusDirectionToLayoutDirection(int focusDirection) {
switch (focusDirection) {
case View.FOCUS_BACKWARD:
return RenderState.LAYOUT_START;
case View.FOCUS_FORWARD:
return RenderState.LAYOUT_END;
case View.FOCUS_UP:
return mOrientation == VERTICAL ? RenderState.LAYOUT_START
: RenderState.INVALID_LAYOUT;
case View.FOCUS_DOWN:
return mOrientation == VERTICAL ? RenderState.LAYOUT_END
: RenderState.INVALID_LAYOUT;
case View.FOCUS_LEFT:
return mOrientation == HORIZONTAL ? RenderState.LAYOUT_START
: RenderState.INVALID_LAYOUT;
case View.FOCUS_RIGHT:
return mOrientation == HORIZONTAL ? RenderState.LAYOUT_END
: RenderState.INVALID_LAYOUT;
default:
if (DEBUG) {
Log.d(TAG, "Unknown focus request:" + focusDirection);
}
return RenderState.INVALID_LAYOUT;
}
}
/**
* Convenience method to find the child closes to start. Caller should check it has enough
* children.
*
* @return The child closes to start of the layout from user's perspective.
*/
private View getChildClosestToStart() {
return getChildAt(mShouldReverseLayout ? getChildCount() - 1 : 0);
}
/**
* Convenience method to find the child closes to end. Caller should check it has enough
* children.
*
* @return The child closes to end of the layout from user's perspective.
*/
private View getChildClosestToEnd() {
return getChildAt(mShouldReverseLayout ? 0 : getChildCount() - 1);
}
/**
* Returns the adapter position of the first visible view.
* <p/>
* Note that, this value is not affected by layout orientation or item order traversal.
* ({@link #setReverseLayout(boolean)}). Views are sorted by their positions in the adapter,
* not in the layout.
* <p/>
* If RecyclerView has item decorators, they will be considered in calculations as well.
* <p/>
* LinearLayoutManager may pre-cache some views that are not necessarily visible. Those views
* are ignored in this method.
*
* @return The adapter position of the first visible item or {@link android.support.v7.widget.RecyclerView#NO_POSITION} if
* there aren't any visible items.
* @see #findFirstCompletelyVisibleItemPosition()
* @see #findLastVisibleItemPosition()
*/
public int findFirstVisibleItemPosition() {
return findOneVisibleChild(0, getChildCount(), false);
}
/**
* Returns the adapter position of the first fully visible view.
* <p/>
* Note that bounds check is only performed in the current orientation. That means, if
* LinearLayoutManager is horizontal, it will only check the view's left and right edges.
*
* @return The adapter position of the first fully visible item or
* {@link android.support.v7.widget.RecyclerView#NO_POSITION} if there aren't any visible items.
* @see #findFirstVisibleItemPosition()
* @see #findLastCompletelyVisibleItemPosition()
*/
public int findFirstCompletelyVisibleItemPosition() {
return findOneVisibleChild(0, getChildCount(), true);
}
/**
* Returns the adapter position of the last visible view.
* <p/>
* Note that, this value is not affected by layout orientation or item order traversal.
* ({@link #setReverseLayout(boolean)}). Views are sorted by their positions in the adapter,
* not in the layout.
* <p/>
* If RecyclerView has item decorators, they will be considered in calculations as well.
* <p/>
* LinearLayoutManager may pre-cache some views that are not necessarily visible. Those views
* are ignored in this method.
*
* @return The adapter position of the last visible view or {@link android.support.v7.widget.RecyclerView#NO_POSITION} if
* there aren't any visible items.
* @see #findLastCompletelyVisibleItemPosition()
* @see #findFirstVisibleItemPosition()
*/
public int findLastVisibleItemPosition() {
return findOneVisibleChild(getChildCount() - 1, -1, false);
}
/**
* Returns the adapter position of the last fully visible view.
* <p/>
* Note that bounds check is only performed in the current orientation. That means, if
* LinearLayoutManager is horizontal, it will only check the view's left and right edges.
*
* @return The adapter position of the last fully visible view or
* {@link android.support.v7.widget.RecyclerView#NO_POSITION} if there aren't any visible items.
* @see #findLastVisibleItemPosition()
* @see #findFirstCompletelyVisibleItemPosition()
*/
public int findLastCompletelyVisibleItemPosition() {
return findOneVisibleChild(getChildCount() - 1, -1, true);
}
int findOneVisibleChild(int fromIndex, int toIndex, boolean completelyVisible) {
final int start = mOrientationHelper.getStartAfterPadding();
final int end = mOrientationHelper.getEndAfterPadding();
final int next = toIndex > fromIndex ? 1 : -1;
for (int i = fromIndex; i != toIndex; i += next) {
final View child = getChildAt(i);
final int childStart = mOrientationHelper.getDecoratedStart(child);
final int childEnd = mOrientationHelper.getDecoratedEnd(child);
if (childStart < end && childEnd > start) {
if (completelyVisible) {
if (childStart >= start && childEnd <= end) {
return getPosition(child);
}
} else {
return getPosition(child);
}
}
}
return RecyclerView.NO_POSITION;
}
@Override
public View onFocusSearchFailed(View focused, int focusDirection,
RecyclerView.Recycler recycler,
RecyclerView.State state) {
resolveShouldLayoutReverse();
if (getChildCount() == 0) {
return null;
}
final int layoutDir = convertFocusDirectionToLayoutDirection(focusDirection);
if (layoutDir == RenderState.INVALID_LAYOUT) {
return null;
}
final View referenceChild;
if (layoutDir == RenderState.LAYOUT_START) {
referenceChild = getChildClosestToStart();
} else {
referenceChild = getChildClosestToEnd();
}
ensureRenderState();
final int maxScroll = (int) (MAX_SCROLL_FACTOR * (mOrientationHelper.getEndAfterPadding() -
mOrientationHelper.getStartAfterPadding()));
updateRenderState(layoutDir, maxScroll, false, state);
mRenderState.mScrollingOffset = RenderState.SCOLLING_OFFSET_NaN;
fill(recycler, mRenderState, state, true);
final View nextFocus;
if (layoutDir == RenderState.LAYOUT_START) {
nextFocus = getChildClosestToStart();
} else {
nextFocus = getChildClosestToEnd();
}
if (nextFocus == referenceChild || !nextFocus.isFocusable()) {
return null;
}
return nextFocus;
}
/**
* Used for debugging.
* Logs the internal representation of children to default logger.
*/
private void logChildren() {
Log.d(TAG, "internal representation of views on the screen");
for (int i = 0; i < getChildCount(); i++) {
View child = getChildAt(i);
Log.d(TAG, "item " + getPosition(child) + ", coord:"
+ mOrientationHelper.getDecoratedStart(child));
}
Log.d(TAG, "==============");
}
/**
* Used for debugging.
* Validates that child views are laid out in correct order. This is important because rest of
* the algorithm relies on this constraint.
* <p/>
* In default layout, child 0 should be closest to screen position 0 and last child should be
* closest to position WIDTH or HEIGHT.
* In reverse layout, last child should be closes to screen position 0 and first child should
* be closest to position WIDTH or HEIGHT
*/
protected void validateChildOrder() {
Log.d(TAG, "validating child count " + getChildCount());
if (getChildCount() < 1) {
return;
}
int lastPos = getPosition(getChildAt(0));
int lastScreenLoc = mOrientationHelper.getDecoratedStart(getChildAt(0));
if (mShouldReverseLayout) {
for (int i = 1; i < getChildCount(); i++) {
View child = getChildAt(i);
int pos = getPosition(child);
int screenLoc = mOrientationHelper.getDecoratedStart(child);
if (pos < lastPos) {
logChildren();
throw new RuntimeException("detected invalid position. loc invalid? " +
(screenLoc < lastScreenLoc));
}
if (screenLoc > lastScreenLoc) {
logChildren();
throw new RuntimeException("detected invalid location");
}
}
} else {
for (int i = 1; i < getChildCount(); i++) {
View child = getChildAt(i);
int pos = getPosition(child);
int screenLoc = mOrientationHelper.getDecoratedStart(child);
if (pos < lastPos) {
logChildren();
throw new RuntimeException("detected invalid position. loc invalid? " +
(screenLoc < lastScreenLoc));
}
if (screenLoc < lastScreenLoc) {
logChildren();
throw new RuntimeException("detected invalid location");
}
}
}
}
@Override
public boolean supportsPredictiveItemAnimations() {
return true;
}
/**
* Helper class that keeps temporary state while {LayoutManager} is filling out the empty
* space.
*/
protected static class RenderState {
final static String TAG = "LayoutManager#Render";
final static int LAYOUT_START = -1;
final static int LAYOUT_END = 1;
final static int INVALID_LAYOUT = Integer.MIN_VALUE;
final static int ITEM_DIRECTION_HEAD = -1;
final static int ITEM_DIRECTION_TAIL = 1;
final static int SCOLLING_OFFSET_NaN = Integer.MIN_VALUE;
/**
* Pixel offset where rendering should start
*/
int mOffset;
/**
* Number of pixels that we should fill, in the layout direction.
*/
int mAvailable;
/**
* Current position on the adapter to get the next item.
*/
int mCurrentPosition;
/**
* Defines the direction in which the data adapter is traversed.
* Should be {@link #ITEM_DIRECTION_HEAD} or {@link #ITEM_DIRECTION_TAIL}
*/
int mItemDirection;
/**
* Defines the direction in which the layout is filled.
* Should be {@link #LAYOUT_START} or {@link #LAYOUT_END}
*/
int mLayoutDirection;
/**
* Used when RenderState is constructed in a scrolling state.
* It should be set the amount of scrolling we can make without creating a new view.
* Settings this is required for efficient view recycling.
*/
int mScrollingOffset;
/**
* Used if you want to pre-layout items that are not yet visible.
* The difference with {@link #mAvailable} is that, when recycling, distance rendered for
* {@link #mExtra} is not considered to avoid recycling visible children.
*/
int mExtra = 0;
/**
* When LLM needs to layout particular views, it sets this list in which case, RenderState
* will only return views from this list and return null if it cannot find an item.
*/
List<RecyclerView.ViewHolder> mScrapList = null;
/**
* @return true if there are more items in the data adapter
*/
boolean hasMore(RecyclerView.State state) {
return mCurrentPosition >= 0 && mCurrentPosition < state.getItemCount();
}
/**
* Gets the view for the next element that we should render.
* Also updates current item index to the next item, based on {@link #mItemDirection}
*
* @return The next element that we should render.
*/
View next(RecyclerView.Recycler recycler) {
if (mScrapList != null) {
return nextFromLimitedList();
}
final View view = recycler.getViewForPosition(mCurrentPosition);
mCurrentPosition += mItemDirection;
return view;
}
/**
* Returns next item from limited list.
* <p/>
* Upon finding a valid VH, sets current item position to VH.itemPosition + mItemDirection
*
* @return View if an item in the current position or direction exists if not null.
*/
private View nextFromLimitedList() {
int size = mScrapList.size();
RecyclerView.ViewHolder closest = null;
int closestDistance = Integer.MAX_VALUE;
for (int i = 0; i < size; i++) {
RecyclerView.ViewHolder viewHolder = mScrapList.get(i);
final int distance = (viewHolder.getPosition() - mCurrentPosition) * mItemDirection;
if (distance < 0) {
continue; // item is not in current direction
}
if (distance < closestDistance) {
closest = viewHolder;
closestDistance = distance;
if (distance == 0) {
break;
}
}
}
if (DEBUG) {
Log.d(TAG, "layout from scrap. found view:?" + (closest != null));
}
if (closest != null) {
mCurrentPosition = closest.getPosition() + mItemDirection;
return closest.itemView;
}
return null;
}
void log() {
Log.d(TAG, "avail:" + mAvailable + ", ind:" + mCurrentPosition + ", dir:" +
mItemDirection + ", offset:" + mOffset + ", layoutDir:" + mLayoutDirection);
}
}
OrientationHelper createVerticalOrientationHelper() {
return new OrientationHelper() {
@Override
public int getEndAfterPadding() {
return getHeight() - getPaddingBottom();
}
@Override
public void offsetChildren(int amount) {
offsetChildrenVertical(amount);
}
@Override
public int getStartAfterPadding() {
return getPaddingTop();
}
@Override
public int getDecoratedMeasurement(View view) {
final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
view.getLayoutParams();
return getDecoratedMeasuredHeight(view) + params.topMargin + params.bottomMargin;
}
@Override
public int getDecoratedMeasurementInOther(View view) {
final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
view.getLayoutParams();
return getDecoratedMeasuredWidth(view) + params.leftMargin + params.rightMargin;
}
@Override
public int getDecoratedEnd(View view) {
final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
view.getLayoutParams();
return getDecoratedBottom(view) + params.bottomMargin;
}
@Override
public int getDecoratedStart(View view) {
final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
view.getLayoutParams();
return getDecoratedTop(view) - params.topMargin;
}
@Override
public int getTotalSpace() {
return getHeight() - getPaddingTop() - getPaddingBottom();
}
};
}
OrientationHelper createHorizontalOrientationHelper() {
return new OrientationHelper() {
@Override
public int getEndAfterPadding() {
return getWidth() - getPaddingRight();
}
@Override
public void offsetChildren(int amount) {
offsetChildrenHorizontal(amount);
}
@Override
public int getStartAfterPadding() {
return getPaddingLeft();
}
@Override
public int getDecoratedMeasurement(View view) {
final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
view.getLayoutParams();
return getDecoratedMeasuredWidth(view) + params.leftMargin + params.rightMargin;
}
@Override
public int getDecoratedMeasurementInOther(View view) {
final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
view.getLayoutParams();
return getDecoratedMeasuredHeight(view) + params.topMargin + params.bottomMargin;
}
@Override
public int getDecoratedEnd(View view) {
final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
view.getLayoutParams();
return getDecoratedRight(view) + params.rightMargin;
}
@Override
public int getDecoratedStart(View view) {
final RecyclerView.LayoutParams params = (RecyclerView.LayoutParams)
view.getLayoutParams();
return getDecoratedLeft(view) - params.leftMargin;
}
@Override
public int getTotalSpace() {
return getWidth() - getPaddingLeft() - getPaddingRight();
}
};
}
/**
* Helper interface to offload orientation based decisions
*/
static interface OrientationHelper {
/**
* @param view The view element to check
* @return The first pixel of the element
* @see #getDecoratedEnd(android.view.View)
*/
int getDecoratedStart(View view);
/**
* @param view The view element to check
* @return The last pixel of the element
* @see #getDecoratedStart(android.view.View)
*/
int getDecoratedEnd(View view);
/**
* @param view The view element to check
* @return Total space occupied by this view
*/
int getDecoratedMeasurement(View view);
/**
* @param view The view element to check
* @return Total space occupied by this view in the perpendicular orientation to current one
*/
int getDecoratedMeasurementInOther(View view);
/**
* @return The very first pixel we can draw.
*/
int getStartAfterPadding();
/**
* @return The last pixel we can draw
*/
int getEndAfterPadding();
/**
* Offsets all children's positions by the given amount
*
* @param amount Value to add to each child's layout parameters
*/
void offsetChildren(int amount);
/**
* Returns the total space to layout.
*
* @return Total space to layout children
*/
int getTotalSpace();
}
static class SavedState implements Parcelable {
int mOrientation;
int mAnchorPosition;
int mAnchorOffset;
boolean mReverseLayout;
boolean mStackFromEnd;
boolean mAnchorLayoutFromEnd;
public SavedState() {
}
SavedState(Parcel in) {
mOrientation = in.readInt();
mAnchorPosition = in.readInt();
mAnchorOffset = in.readInt();
mReverseLayout = in.readInt() == 1;
mStackFromEnd = in.readInt() == 1;
mAnchorLayoutFromEnd = in.readInt() == 1;
}
public SavedState(SavedState other) {
mOrientation = other.mOrientation;
mAnchorPosition = other.mAnchorPosition;
mAnchorOffset = other.mAnchorOffset;
mReverseLayout = other.mReverseLayout;
mStackFromEnd = other.mStackFromEnd;
mAnchorLayoutFromEnd = other.mAnchorLayoutFromEnd;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(mOrientation);
dest.writeInt(mAnchorPosition);
dest.writeInt(mAnchorOffset);
dest.writeInt(mReverseLayout ? 1 : 0);
dest.writeInt(mStackFromEnd ? 1 : 0);
dest.writeInt(mAnchorLayoutFromEnd ? 1 : 0);
}
public static final Creator<SavedState> CREATOR
= new Creator<SavedState>() {
@Override
public SavedState createFromParcel(Parcel in) {
return new SavedState(in);
}
@Override
public SavedState[] newArray(int size) {
return new SavedState[size];
}
};
}
}
