/*
* Copyright (C) 2013 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 com.android.photos.views;
import android.content.Context;
import android.content.res.TypedArray;
import android.database.DataSetObserver;
import android.graphics.Canvas;
import android.support.v4.view.MotionEventCompat;
import android.support.v4.view.VelocityTrackerCompat;
import android.support.v4.view.ViewCompat;
import android.support.v4.widget.EdgeEffectCompat;
import android.util.AttributeSet;
import android.util.Log;
import android.util.SparseArray;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.widget.ListAdapter;
import android.widget.OverScroller;
import java.util.ArrayList;
public class GalleryThumbnailView extends ViewGroup {
public interface GalleryThumbnailAdapter extends ListAdapter {
/**
* @param position Position to get the intrinsic aspect ratio for
* @return width / height
*/
float getIntrinsicAspectRatio(int position);
}
private static final String TAG = "GalleryThumbnailView";
private static final float ASPECT_RATIO = (float) Math.sqrt(1.5f);
private static final int LAND_UNITS = 2;
private static final int PORT_UNITS = 3;
private GalleryThumbnailAdapter mAdapter;
private final RecycleBin mRecycler = new RecycleBin();
private final AdapterDataSetObserver mObserver = new AdapterDataSetObserver();
private boolean mDataChanged;
private int mOldItemCount;
private int mItemCount;
private boolean mHasStableIds;
private int mFirstPosition;
private boolean mPopulating;
private boolean mInLayout;
private int mTouchSlop;
private int mMaximumVelocity;
private int mFlingVelocity;
private float mLastTouchX;
private float mTouchRemainderX;
private int mActivePointerId;
private static final int TOUCH_MODE_IDLE = 0;
private static final int TOUCH_MODE_DRAGGING = 1;
private static final int TOUCH_MODE_FLINGING = 2;
private int mTouchMode;
private final VelocityTracker mVelocityTracker = VelocityTracker.obtain();
private final OverScroller mScroller;
private final EdgeEffectCompat mLeftEdge;
private final EdgeEffectCompat mRightEdge;
private int mLargeColumnWidth;
private int mSmallColumnWidth;
private int mLargeColumnUnitCount = 8;
private int mSmallColumnUnitCount = 10;
public GalleryThumbnailView(Context context) {
this(context, null);
}
public GalleryThumbnailView(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public GalleryThumbnailView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
final ViewConfiguration vc = ViewConfiguration.get(context);
mTouchSlop = vc.getScaledTouchSlop();
mMaximumVelocity = vc.getScaledMaximumFlingVelocity();
mFlingVelocity = vc.getScaledMinimumFlingVelocity();
mScroller = new OverScroller(context);
mLeftEdge = new EdgeEffectCompat(context);
mRightEdge = new EdgeEffectCompat(context);
setWillNotDraw(false);
setClipToPadding(false);
}
@Override
public void requestLayout() {
if (!mPopulating) {
super.requestLayout();
}
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int widthMode = MeasureSpec.getMode(widthMeasureSpec);
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
int widthSize = MeasureSpec.getSize(widthMeasureSpec);
int heightSize = MeasureSpec.getSize(heightMeasureSpec);
if (widthMode != MeasureSpec.EXACTLY) {
Log.e(TAG, "onMeasure: must have an exact width or match_parent! " +
"Using fallback spec of EXACTLY " + widthSize);
}
if (heightMode != MeasureSpec.EXACTLY) {
Log.e(TAG, "onMeasure: must have an exact height or match_parent! " +
"Using fallback spec of EXACTLY " + heightSize);
}
setMeasuredDimension(widthSize, heightSize);
float portSpaces = mLargeColumnUnitCount / PORT_UNITS;
float height = getMeasuredHeight() / portSpaces;
mLargeColumnWidth = (int) (height / ASPECT_RATIO);
portSpaces++;
height = getMeasuredHeight() / portSpaces;
mSmallColumnWidth = (int) (height / ASPECT_RATIO);
}
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
mInLayout = true;
populate();
mInLayout = false;
final int width = r - l;
final int height = b - t;
mLeftEdge.setSize(width, height);
mRightEdge.setSize(width, height);
}
private void populate() {
if (getWidth() == 0 || getHeight() == 0) {
return;
}
// TODO: Handle size changing
// final int colCount = mColCount;
// if (mItemTops == null || mItemTops.length != colCount) {
// mItemTops = new int[colCount];
// mItemBottoms = new int[colCount];
// final int top = getPaddingTop();
// final int offset = top + Math.min(mRestoreOffset, 0);
// Arrays.fill(mItemTops, offset);
// Arrays.fill(mItemBottoms, offset);
// mLayoutRecords.clear();
// if (mInLayout) {
// removeAllViewsInLayout();
// } else {
// removeAllViews();
// }
// mRestoreOffset = 0;
// }
mPopulating = true;
layoutChildren(mDataChanged);
fillRight(mFirstPosition + getChildCount(), 0);
fillLeft(mFirstPosition - 1, 0);
mPopulating = false;
mDataChanged = false;
}
final void layoutChildren(boolean queryAdapter) {
// TODO
// final int childCount = getChildCount();
// for (int i = 0; i < childCount; i++) {
// View child = getChildAt(i);
//
// if (child.isLayoutRequested()) {
// final int widthSpec = MeasureSpec.makeMeasureSpec(child.getMeasuredWidth(), MeasureSpec.EXACTLY);
// final int heightSpec = MeasureSpec.makeMeasureSpec(child.getMeasuredHeight(), MeasureSpec.EXACTLY);
// child.measure(widthSpec, heightSpec);
// child.layout(child.getLeft(), child.getTop(), child.getRight(), child.getBottom());
// }
//
// int childTop = mItemBottoms[col] > Integer.MIN_VALUE ?
// mItemBottoms[col] + mItemMargin : child.getTop();
// if (span > 1) {
// int lowest = childTop;
// for (int j = col + 1; j < col + span; j++) {
// final int bottom = mItemBottoms[j] + mItemMargin;
// if (bottom > lowest) {
// lowest = bottom;
// }
// }
// childTop = lowest;
// }
// final int childHeight = child.getMeasuredHeight();
// final int childBottom = childTop + childHeight;
// final int childLeft = paddingLeft + col * (colWidth + itemMargin);
// final int childRight = childLeft + child.getMeasuredWidth();
// child.layout(childLeft, childTop, childRight, childBottom);
// }
}
/**
* Obtain the view and add it to our list of children. The view can be made
* fresh, converted from an unused view, or used as is if it was in the
* recycle bin.
*
* @param startPosition Logical position in the list to start from
* @param x Left or right edge of the view to add
* @param forward If true, align left edge to x and increase position.
* If false, align right edge to x and decrease position.
* @return Number of views added
*/
private int makeAndAddColumn(int startPosition, int x, boolean forward) {
int columnWidth = mLargeColumnWidth;
int addViews = 0;
for (int remaining = mLargeColumnUnitCount, i = 0;
remaining > 0 && startPosition + i >= 0 && startPosition + i < mItemCount;
i += forward ? 1 : -1, addViews++) {
if (mAdapter.getIntrinsicAspectRatio(startPosition + i) >= 1f) {
// landscape
remaining -= LAND_UNITS;
} else {
// portrait
remaining -= PORT_UNITS;
if (remaining < 0) {
remaining += (mSmallColumnUnitCount - mLargeColumnUnitCount);
columnWidth = mSmallColumnWidth;
}
}
}
int nextTop = 0;
for (int i = 0; i < addViews; i++) {
int position = startPosition + (forward ? i : -i);
View child = obtainView(position, null);
if (child.getParent() != this) {
if (mInLayout) {
addViewInLayout(child, forward ? -1 : 0, child.getLayoutParams());
} else {
addView(child, forward ? -1 : 0);
}
}
int heightSize = (int) (.5f + (mAdapter.getIntrinsicAspectRatio(position) >= 1f
? columnWidth / ASPECT_RATIO
: columnWidth * ASPECT_RATIO));
int heightSpec = MeasureSpec.makeMeasureSpec(heightSize, MeasureSpec.EXACTLY);
int widthSpec = MeasureSpec.makeMeasureSpec(columnWidth, MeasureSpec.EXACTLY);
child.measure(widthSpec, heightSpec);
int childLeft = forward ? x : x - columnWidth;
child.layout(childLeft, nextTop, childLeft + columnWidth, nextTop + heightSize);
nextTop += heightSize;
}
return addViews;
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
mVelocityTracker.addMovement(ev);
final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
switch (action) {
case MotionEvent.ACTION_DOWN:
mVelocityTracker.clear();
mScroller.abortAnimation();
mLastTouchX = ev.getX();
mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
mTouchRemainderX = 0;
if (mTouchMode == TOUCH_MODE_FLINGING) {
// Catch!
mTouchMode = TOUCH_MODE_DRAGGING;
return true;
}
break;
case MotionEvent.ACTION_MOVE: {
final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
if (index < 0) {
Log.e(TAG, "onInterceptTouchEvent could not find pointer with id " +
mActivePointerId + " - did StaggeredGridView receive an inconsistent " +
"event stream?");
return false;
}
final float x = MotionEventCompat.getX(ev, index);
final float dx = x - mLastTouchX + mTouchRemainderX;
final int deltaY = (int) dx;
mTouchRemainderX = dx - deltaY;
if (Math.abs(dx) > mTouchSlop) {
mTouchMode = TOUCH_MODE_DRAGGING;
return true;
}
}
}
return false;
}
@Override
public boolean onTouchEvent(MotionEvent ev) {
mVelocityTracker.addMovement(ev);
final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
switch (action) {
case MotionEvent.ACTION_DOWN:
mVelocityTracker.clear();
mScroller.abortAnimation();
mLastTouchX = ev.getX();
mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
mTouchRemainderX = 0;
break;
case MotionEvent.ACTION_MOVE: {
final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
if (index < 0) {
Log.e(TAG, "onInterceptTouchEvent could not find pointer with id " +
mActivePointerId + " - did StaggeredGridView receive an inconsistent " +
"event stream?");
return false;
}
final float x = MotionEventCompat.getX(ev, index);
final float dx = x - mLastTouchX + mTouchRemainderX;
final int deltaX = (int) dx;
mTouchRemainderX = dx - deltaX;
if (Math.abs(dx) > mTouchSlop) {
mTouchMode = TOUCH_MODE_DRAGGING;
}
if (mTouchMode == TOUCH_MODE_DRAGGING) {
mLastTouchX = x;
if (!trackMotionScroll(deltaX, true)) {
// Break fling velocity if we impacted an edge.
mVelocityTracker.clear();
}
}
} break;
case MotionEvent.ACTION_CANCEL:
mTouchMode = TOUCH_MODE_IDLE;
break;
case MotionEvent.ACTION_UP: {
mVelocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
final float velocity = VelocityTrackerCompat.getXVelocity(mVelocityTracker,
mActivePointerId);
if (Math.abs(velocity) > mFlingVelocity) { // TODO
mTouchMode = TOUCH_MODE_FLINGING;
mScroller.fling(0, 0, (int) velocity, 0,
Integer.MIN_VALUE, Integer.MAX_VALUE, 0, 0);
mLastTouchX = 0;
ViewCompat.postInvalidateOnAnimation(this);
} else {
mTouchMode = TOUCH_MODE_IDLE;
}
} break;
}
return true;
}
/**
*
* @param deltaX Pixels that content should move by
* @return true if the movement completed, false if it was stopped prematurely.
*/
private boolean trackMotionScroll(int deltaX, boolean allowOverScroll) {
final boolean contentFits = contentFits();
final int allowOverhang = Math.abs(deltaX);
final int overScrolledBy;
final int movedBy;
if (!contentFits) {
final int overhang;
final boolean up;
mPopulating = true;
if (deltaX > 0) {
overhang = fillLeft(mFirstPosition - 1, allowOverhang);
up = true;
} else {
overhang = fillRight(mFirstPosition + getChildCount(), allowOverhang);
up = false;
}
movedBy = Math.min(overhang, allowOverhang);
offsetChildren(up ? movedBy : -movedBy);
recycleOffscreenViews();
mPopulating = false;
overScrolledBy = allowOverhang - overhang;
} else {
overScrolledBy = allowOverhang;
movedBy = 0;
}
if (allowOverScroll) {
final int overScrollMode = ViewCompat.getOverScrollMode(this);
if (overScrollMode == ViewCompat.OVER_SCROLL_ALWAYS ||
(overScrollMode == ViewCompat.OVER_SCROLL_IF_CONTENT_SCROLLS && !contentFits)) {
if (overScrolledBy > 0) {
EdgeEffectCompat edge = deltaX > 0 ? mLeftEdge : mRightEdge;
edge.onPull((float) Math.abs(deltaX) / getWidth());
ViewCompat.postInvalidateOnAnimation(this);
}
}
}
return deltaX == 0 || movedBy != 0;
}
/**
* Important: this method will leave offscreen views attached if they
* are required to maintain the invariant that child view with index i
* is always the view corresponding to position mFirstPosition + i.
*/
private void recycleOffscreenViews() {
final int height = getHeight();
final int clearAbove = 0;
final int clearBelow = height;
for (int i = getChildCount() - 1; i >= 0; i--) {
final View child = getChildAt(i);
if (child.getTop() <= clearBelow) {
// There may be other offscreen views, but we need to maintain
// the invariant documented above.
break;
}
if (mInLayout) {
removeViewsInLayout(i, 1);
} else {
removeViewAt(i);
}
mRecycler.addScrap(child);
}
while (getChildCount() > 0) {
final View child = getChildAt(0);
if (child.getBottom() >= clearAbove) {
// There may be other offscreen views, but we need to maintain
// the invariant documented above.
break;
}
if (mInLayout) {
removeViewsInLayout(0, 1);
} else {
removeViewAt(0);
}
mRecycler.addScrap(child);
mFirstPosition++;
}
}
final void offsetChildren(int offset) {
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
child.layout(child.getLeft() + offset, child.getTop(),
child.getRight() + offset, child.getBottom());
}
}
private boolean contentFits() {
final int childCount = getChildCount();
if (childCount == 0) return true;
if (childCount != mItemCount) return false;
return getChildAt(0).getLeft() >= getPaddingLeft() &&
getChildAt(childCount - 1).getRight() <= getWidth() - getPaddingRight();
}
private void recycleAllViews() {
for (int i = 0; i < getChildCount(); i++) {
mRecycler.addScrap(getChildAt(i));
}
if (mInLayout) {
removeAllViewsInLayout();
} else {
removeAllViews();
}
}
private int fillRight(int pos, int overhang) {
int end = (getRight() - getLeft()) + overhang;
int nextLeft = getChildCount() == 0 ? 0 : getChildAt(getChildCount() - 1).getRight();
while (nextLeft < end && pos < mItemCount) {
pos += makeAndAddColumn(pos, nextLeft, true);
nextLeft = getChildAt(getChildCount() - 1).getRight();
}
final int gridRight = getWidth() - getPaddingRight();
return getChildAt(getChildCount() - 1).getRight() - gridRight;
}
private int fillLeft(int pos, int overhang) {
int end = getPaddingLeft() - overhang;
int nextRight = getChildAt(0).getLeft();
while (nextRight > end && pos >= 0) {
pos -= makeAndAddColumn(pos, nextRight, false);
nextRight = getChildAt(0).getLeft();
}
mFirstPosition = pos + 1;
return getPaddingLeft() - getChildAt(0).getLeft();
}
@Override
public void computeScroll() {
if (mScroller.computeScrollOffset()) {
final int x = mScroller.getCurrX();
final int dx = (int) (x - mLastTouchX);
mLastTouchX = x;
final boolean stopped = !trackMotionScroll(dx, false);
if (!stopped && !mScroller.isFinished()) {
ViewCompat.postInvalidateOnAnimation(this);
} else {
if (stopped) {
final int overScrollMode = ViewCompat.getOverScrollMode(this);
if (overScrollMode != ViewCompat.OVER_SCROLL_NEVER) {
final EdgeEffectCompat edge;
if (dx > 0) {
edge = mLeftEdge;
} else {
edge = mRightEdge;
}
edge.onAbsorb(Math.abs((int) mScroller.getCurrVelocity()));
ViewCompat.postInvalidateOnAnimation(this);
}
mScroller.abortAnimation();
}
mTouchMode = TOUCH_MODE_IDLE;
}
}
}
@Override
public void draw(Canvas canvas) {
super.draw(canvas);
if (!mLeftEdge.isFinished()) {
final int restoreCount = canvas.save();
final int height = getHeight() - getPaddingTop() - getPaddingBottom();
canvas.rotate(270);
canvas.translate(-height + getPaddingTop(), 0);
mLeftEdge.setSize(height, getWidth());
if (mLeftEdge.draw(canvas)) {
postInvalidateOnAnimation();
}
canvas.restoreToCount(restoreCount);
}
if (!mRightEdge.isFinished()) {
final int restoreCount = canvas.save();
final int width = getWidth();
final int height = getHeight() - getPaddingTop() - getPaddingBottom();
canvas.rotate(90);
canvas.translate(-getPaddingTop(), width);
mRightEdge.setSize(height, width);
if (mRightEdge.draw(canvas)) {
postInvalidateOnAnimation();
}
canvas.restoreToCount(restoreCount);
}
}
/**
* Obtain a populated view from the adapter. If optScrap is non-null and is not
* reused it will be placed in the recycle bin.
*
* @param position position to get view for
* @param optScrap Optional scrap view; will be reused if possible
* @return A new view, a recycled view from mRecycler, or optScrap
*/
private final View obtainView(int position, View optScrap) {
View view = mRecycler.getTransientStateView(position);
if (view != null) {
return view;
}
// Reuse optScrap if it's of the right type (and not null)
final int optType = optScrap != null ?
((LayoutParams) optScrap.getLayoutParams()).viewType : -1;
final int positionViewType = mAdapter.getItemViewType(position);
final View scrap = optType == positionViewType ?
optScrap : mRecycler.getScrapView(positionViewType);
view = mAdapter.getView(position, scrap, this);
if (view != scrap && scrap != null) {
// The adapter didn't use it; put it back.
mRecycler.addScrap(scrap);
}
ViewGroup.LayoutParams lp = view.getLayoutParams();
if (view.getParent() != this) {
if (lp == null) {
lp = generateDefaultLayoutParams();
} else if (!checkLayoutParams(lp)) {
lp = generateLayoutParams(lp);
}
view.setLayoutParams(lp);
}
final LayoutParams sglp = (LayoutParams) lp;
sglp.position = position;
sglp.viewType = positionViewType;
return view;
}
public GalleryThumbnailAdapter getAdapter() {
return mAdapter;
}
public void setAdapter(GalleryThumbnailAdapter adapter) {
if (mAdapter != null) {
mAdapter.unregisterDataSetObserver(mObserver);
}
// TODO: If the new adapter says that there are stable IDs, remove certain layout records
// and onscreen views if they have changed instead of removing all of the state here.
clearAllState();
mAdapter = adapter;
mDataChanged = true;
mOldItemCount = mItemCount = adapter != null ? adapter.getCount() : 0;
if (adapter != null) {
adapter.registerDataSetObserver(mObserver);
mRecycler.setViewTypeCount(adapter.getViewTypeCount());
mHasStableIds = adapter.hasStableIds();
} else {
mHasStableIds = false;
}
populate();
}
/**
* Clear all state because the grid will be used for a completely different set of data.
*/
private void clearAllState() {
// Clear all layout records and views
removeAllViews();
// Reset to the top of the grid
mFirstPosition = 0;
// Clear recycler because there could be different view types now
mRecycler.clear();
}
@Override
protected LayoutParams generateDefaultLayoutParams() {
return new LayoutParams(LayoutParams.WRAP_CONTENT);
}
@Override
protected LayoutParams generateLayoutParams(ViewGroup.LayoutParams lp) {
return new LayoutParams(lp);
}
@Override
protected boolean checkLayoutParams(ViewGroup.LayoutParams lp) {
return lp instanceof LayoutParams;
}
@Override
public ViewGroup.LayoutParams generateLayoutParams(AttributeSet attrs) {
return new LayoutParams(getContext(), attrs);
}
public static class LayoutParams extends ViewGroup.LayoutParams {
private static final int[] LAYOUT_ATTRS = new int[] {
android.R.attr.layout_span
};
private static final int SPAN_INDEX = 0;
/**
* The number of columns this item should span
*/
public int span = 1;
/**
* Item position this view represents
*/
int position;
/**
* Type of this view as reported by the adapter
*/
int viewType;
/**
* The column this view is occupying
*/
int column;
/**
* The stable ID of the item this view displays
*/
long id = -1;
public LayoutParams(int height) {
super(MATCH_PARENT, height);
if (this.height == MATCH_PARENT) {
Log.w(TAG, "Constructing LayoutParams with height MATCH_PARENT - " +
"impossible! Falling back to WRAP_CONTENT");
this.height = WRAP_CONTENT;
}
}
public LayoutParams(Context c, AttributeSet attrs) {
super(c, attrs);
if (this.width != MATCH_PARENT) {
Log.w(TAG, "Inflation setting LayoutParams width to " + this.width +
" - must be MATCH_PARENT");
this.width = MATCH_PARENT;
}
if (this.height == MATCH_PARENT) {
Log.w(TAG, "Inflation setting LayoutParams height to MATCH_PARENT - " +
"impossible! Falling back to WRAP_CONTENT");
this.height = WRAP_CONTENT;
}
TypedArray a = c.obtainStyledAttributes(attrs, LAYOUT_ATTRS);
span = a.getInteger(SPAN_INDEX, 1);
a.recycle();
}
public LayoutParams(ViewGroup.LayoutParams other) {
super(other);
if (this.width != MATCH_PARENT) {
Log.w(TAG, "Constructing LayoutParams with width " + this.width +
" - must be MATCH_PARENT");
this.width = MATCH_PARENT;
}
if (this.height == MATCH_PARENT) {
Log.w(TAG, "Constructing LayoutParams with height MATCH_PARENT - " +
"impossible! Falling back to WRAP_CONTENT");
this.height = WRAP_CONTENT;
}
}
}
private class RecycleBin {
private ArrayList<View>[] mScrapViews;
private int mViewTypeCount;
private int mMaxScrap;
private SparseArray<View> mTransientStateViews;
public void setViewTypeCount(int viewTypeCount) {
if (viewTypeCount < 1) {
throw new IllegalArgumentException("Must have at least one view type (" +
viewTypeCount + " types reported)");
}
if (viewTypeCount == mViewTypeCount) {
return;
}
ArrayList<View>[] scrapViews = new ArrayList[viewTypeCount];
for (int i = 0; i < viewTypeCount; i++) {
scrapViews[i] = new ArrayList<View>();
}
mViewTypeCount = viewTypeCount;
mScrapViews = scrapViews;
}
public void clear() {
final int typeCount = mViewTypeCount;
for (int i = 0; i < typeCount; i++) {
mScrapViews[i].clear();
}
if (mTransientStateViews != null) {
mTransientStateViews.clear();
}
}
public void clearTransientViews() {
if (mTransientStateViews != null) {
mTransientStateViews.clear();
}
}
public void addScrap(View v) {
final LayoutParams lp = (LayoutParams) v.getLayoutParams();
if (ViewCompat.hasTransientState(v)) {
if (mTransientStateViews == null) {
mTransientStateViews = new SparseArray<View>();
}
mTransientStateViews.put(lp.position, v);
return;
}
final int childCount = getChildCount();
if (childCount > mMaxScrap) {
mMaxScrap = childCount;
}
ArrayList<View> scrap = mScrapViews[lp.viewType];
if (scrap.size() < mMaxScrap) {
scrap.add(v);
}
}
public View getTransientStateView(int position) {
if (mTransientStateViews == null) {
return null;
}
final View result = mTransientStateViews.get(position);
if (result != null) {
mTransientStateViews.remove(position);
}
return result;
}
public View getScrapView(int type) {
ArrayList<View> scrap = mScrapViews[type];
if (scrap.isEmpty()) {
return null;
}
final int index = scrap.size() - 1;
final View result = scrap.get(index);
scrap.remove(index);
return result;
}
}
private class AdapterDataSetObserver extends DataSetObserver {
@Override
public void onChanged() {
mDataChanged = true;
mOldItemCount = mItemCount;
mItemCount = mAdapter.getCount();
// TODO: Consider matching these back up if we have stable IDs.
mRecycler.clearTransientViews();
if (!mHasStableIds) {
recycleAllViews();
}
// TODO: consider repopulating in a deferred runnable instead
// (so that successive changes may still be batched)
requestLayout();
}
@Override
public void onInvalidated() {
}
}
}