/*
* 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 language governing permissions and
* limitations under the License.
*/
package com.example.android.supportv7.widget;
import com.example.android.supportv7.R;
import android.animation.Animator;
import android.animation.ValueAnimator;
import android.annotation.TargetApi;
import android.app.Activity;
import android.content.Context;
import android.os.Build;
import android.os.Bundle;
import android.support.v4.util.ArrayMap;
import android.support.v4.view.MenuItemCompat;
import android.support.v4.view.ViewCompat;
import android.support.v4.view.ViewPropertyAnimatorListener;
import android.support.v7.widget.DefaultItemAnimator;
import android.support.v7.widget.RecyclerView;
import android.util.DisplayMetrics;
import android.util.TypedValue;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.TextView;
import java.util.ArrayList;
import java.util.List;
public class AnimatedRecyclerView extends Activity {
private static final int SCROLL_DISTANCE = 80; // dp
private RecyclerView mRecyclerView;
private int mNumItemsAdded = 0;
ArrayList<String> mItems = new ArrayList<String>();
MyAdapter mAdapter;
boolean mAnimationsEnabled = true;
boolean mPredictiveAnimationsEnabled = true;
RecyclerView.ItemAnimator mCachedAnimator = null;
boolean mEnableInPlaceChange = true;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.animated_recycler_view);
ViewGroup container = (ViewGroup) findViewById(R.id.container);
mRecyclerView = new RecyclerView(this);
mCachedAnimator = createAnimator();
mCachedAnimator.setChangeDuration(2000);
mRecyclerView.setItemAnimator(mCachedAnimator);
mRecyclerView.setLayoutManager(new MyLayoutManager(this));
mRecyclerView.setHasFixedSize(true);
mRecyclerView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT));
for (int i = 0; i < 6; ++i) {
mItems.add("Item #" + i);
}
mAdapter = new MyAdapter(mItems);
mRecyclerView.setAdapter(mAdapter);
container.addView(mRecyclerView);
CheckBox enableAnimations = (CheckBox) findViewById(R.id.enableAnimations);
enableAnimations.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
if (isChecked && mRecyclerView.getItemAnimator() == null) {
mRecyclerView.setItemAnimator(mCachedAnimator);
} else if (!isChecked && mRecyclerView.getItemAnimator() != null) {
mRecyclerView.setItemAnimator(null);
}
mAnimationsEnabled = isChecked;
}
});
CheckBox enablePredictiveAnimations =
(CheckBox) findViewById(R.id.enablePredictiveAnimations);
enablePredictiveAnimations.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
mPredictiveAnimationsEnabled = isChecked;
}
});
CheckBox enableInPlaceChange = (CheckBox) findViewById(R.id.enableInPlaceChange);
enableInPlaceChange.setChecked(mEnableInPlaceChange);
enableInPlaceChange.setOnCheckedChangeListener(
new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
mEnableInPlaceChange = isChecked;
}
});
}
private RecyclerView.ItemAnimator createAnimator() {
return new DefaultItemAnimator() {
List<ItemChangeAnimator> mPendingChangeAnimations = new ArrayList<>();
ArrayMap<RecyclerView.ViewHolder, ItemChangeAnimator> mRunningAnimations
= new ArrayMap<>();
ArrayMap<MyViewHolder, Long> mPendingSettleList = new ArrayMap<>();
@Override
public void runPendingAnimations() {
super.runPendingAnimations();
for (ItemChangeAnimator anim : mPendingChangeAnimations) {
anim.start();
mRunningAnimations.put(anim.mViewHolder, anim);
}
mPendingChangeAnimations.clear();
for (int i = mPendingSettleList.size() - 1; i >=0; i--) {
final MyViewHolder vh = mPendingSettleList.keyAt(i);
final long duration = mPendingSettleList.valueAt(i);
ViewCompat.animate(vh.textView).translationX(0f).alpha(1f)
.setDuration(duration).setListener(
new ViewPropertyAnimatorListener() {
@Override
public void onAnimationStart(View view) {
dispatchAnimationStarted(vh);
}
@Override
public void onAnimationEnd(View view) {
ViewCompat.setTranslationX(vh.textView, 0f);
ViewCompat.setAlpha(vh.textView, 1f);
dispatchAnimationFinished(vh);
}
@Override
public void onAnimationCancel(View view) {
}
}).start();
}
mPendingSettleList.clear();
}
@Override
public ItemHolderInfo recordPreLayoutInformation(RecyclerView.State state,
RecyclerView.ViewHolder viewHolder,
@AdapterChanges int changeFlags, List<Object> payloads) {
MyItemInfo info = (MyItemInfo) super
.recordPreLayoutInformation(state, viewHolder, changeFlags, payloads);
info.text = ((MyViewHolder) viewHolder).textView.getText();
return info;
}
@Override
public ItemHolderInfo recordPostLayoutInformation(RecyclerView.State state,
RecyclerView.ViewHolder viewHolder) {
MyItemInfo info = (MyItemInfo) super.recordPostLayoutInformation(state, viewHolder);
info.text = ((MyViewHolder) viewHolder).textView.getText();
return info;
}
@Override
public boolean canReuseUpdatedViewHolder(RecyclerView.ViewHolder viewHolder) {
return mEnableInPlaceChange;
}
@Override
public void endAnimation(RecyclerView.ViewHolder item) {
super.endAnimation(item);
for (int i = mPendingChangeAnimations.size() - 1; i >= 0; i--) {
ItemChangeAnimator anim = mPendingChangeAnimations.get(i);
if (anim.mViewHolder == item) {
mPendingChangeAnimations.remove(i);
anim.setFraction(1f);
dispatchChangeFinished(item, true);
}
}
for (int i = mRunningAnimations.size() - 1; i >= 0; i--) {
ItemChangeAnimator animator = mRunningAnimations.get(item);
if (animator != null) {
animator.end();
mRunningAnimations.removeAt(i);
}
}
for (int i = mPendingSettleList.size() - 1; i >= 0; i--) {
final MyViewHolder vh = mPendingSettleList.keyAt(i);
if (vh == item) {
mPendingSettleList.removeAt(i);
dispatchChangeFinished(item, true);
}
}
}
@Override
public boolean animateChange(RecyclerView.ViewHolder oldHolder,
RecyclerView.ViewHolder newHolder, ItemHolderInfo preInfo,
ItemHolderInfo postInfo) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR1
|| oldHolder != newHolder) {
return super.animateChange(oldHolder, newHolder, preInfo, postInfo);
}
return animateChangeApiHoneycombMr1(oldHolder, newHolder, preInfo, postInfo);
}
@TargetApi(Build.VERSION_CODES.HONEYCOMB_MR1)
private boolean animateChangeApiHoneycombMr1(RecyclerView.ViewHolder oldHolder,
RecyclerView.ViewHolder newHolder,
ItemHolderInfo preInfo, ItemHolderInfo postInfo) {
endAnimation(oldHolder);
MyItemInfo pre = (MyItemInfo) preInfo;
MyItemInfo post = (MyItemInfo) postInfo;
MyViewHolder vh = (MyViewHolder) oldHolder;
CharSequence finalText = post.text;
if (pre.text.equals(post.text)) {
// same content. Just translate back to 0
final long duration = (long) (getChangeDuration()
* (ViewCompat.getTranslationX(vh.textView) / vh.textView.getWidth()));
mPendingSettleList.put(vh, duration);
// we set it here because previous endAnimation would set it to other value.
vh.textView.setText(finalText);
} else {
// different content, get out and come back.
vh.textView.setText(pre.text);
final ItemChangeAnimator anim = new ItemChangeAnimator(vh, finalText,
getChangeDuration()) {
@Override
public void onAnimationEnd(Animator animation) {
setFraction(1f);
dispatchChangeFinished(mViewHolder, true);
}
@Override
public void onAnimationStart(Animator animation) {
dispatchChangeStarting(mViewHolder, true);
}
};
mPendingChangeAnimations.add(anim);
}
return true;
}
@Override
public ItemHolderInfo obtainHolderInfo() {
return new MyItemInfo();
}
};
}
@TargetApi(Build.VERSION_CODES.HONEYCOMB_MR1)
abstract private static class ItemChangeAnimator implements
ValueAnimator.AnimatorUpdateListener, Animator.AnimatorListener {
CharSequence mFinalText;
ValueAnimator mValueAnimator;
MyViewHolder mViewHolder;
final float mMaxX;
final float mStartRatio;
public ItemChangeAnimator(MyViewHolder viewHolder, CharSequence finalText, long duration) {
mViewHolder = viewHolder;
mMaxX = mViewHolder.itemView.getWidth();
mStartRatio = ViewCompat.getTranslationX(mViewHolder.textView) / mMaxX;
mFinalText = finalText;
mValueAnimator = ValueAnimator.ofFloat(0f, 1f);
mValueAnimator.addUpdateListener(this);
mValueAnimator.addListener(this);
mValueAnimator.setDuration(duration);
mValueAnimator.setTarget(mViewHolder.itemView);
}
void setFraction(float fraction) {
fraction = mStartRatio + (1f - mStartRatio) * fraction;
if (fraction < .5f) {
ViewCompat.setTranslationX(mViewHolder.textView, fraction * mMaxX);
ViewCompat.setAlpha(mViewHolder.textView, 1f - fraction);
} else {
ViewCompat.setTranslationX(mViewHolder.textView, (1f - fraction) * mMaxX);
ViewCompat.setAlpha(mViewHolder.textView, fraction);
maybeSetFinalText();
}
}
@Override
public void onAnimationUpdate(ValueAnimator valueAnimator) {
setFraction(valueAnimator.getAnimatedFraction());
}
public void start() {
mValueAnimator.start();
}
@Override
public void onAnimationEnd(Animator animation) {
maybeSetFinalText();
ViewCompat.setAlpha(mViewHolder.textView, 1f);
}
public void maybeSetFinalText() {
if (mFinalText != null) {
mViewHolder.textView.setText(mFinalText);
mFinalText = null;
}
}
public void end() {
mValueAnimator.cancel();
}
@Override
public void onAnimationStart(Animator animation) {
}
@Override
public void onAnimationCancel(Animator animation) {
}
@Override
public void onAnimationRepeat(Animator animation) {
}
}
private static class MyItemInfo extends DefaultItemAnimator.ItemHolderInfo {
CharSequence text;
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
MenuItemCompat.setShowAsAction(menu.add("Layout"), MenuItemCompat.SHOW_AS_ACTION_IF_ROOM);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
mRecyclerView.requestLayout();
return super.onOptionsItemSelected(item);
}
@SuppressWarnings("unused")
public void checkboxClicked(View view) {
ViewGroup parent = (ViewGroup) view.getParent();
boolean selected = ((CheckBox) view).isChecked();
MyViewHolder holder = (MyViewHolder) mRecyclerView.getChildViewHolder(parent);
mAdapter.selectItem(holder, selected);
}
@SuppressWarnings("unused")
public void itemClicked(View view) {
ViewGroup parent = (ViewGroup) view;
MyViewHolder holder = (MyViewHolder) mRecyclerView.getChildViewHolder(parent);
final int position = holder.getAdapterPosition();
if (position == RecyclerView.NO_POSITION) {
return;
}
mAdapter.toggleExpanded(holder);
mAdapter.notifyItemChanged(position);
}
public void deleteSelectedItems(View view) {
int numItems = mItems.size();
if (numItems > 0) {
for (int i = numItems - 1; i >= 0; --i) {
final String itemText = mItems.get(i);
boolean selected = mAdapter.mSelected.get(itemText);
if (selected) {
removeAtPosition(i);
}
}
}
}
private String generateNewText() {
return "Added Item #" + mNumItemsAdded++;
}
public void d1a2d3(View view) {
removeAtPosition(1);
addAtPosition(2, "Added Item #" + mNumItemsAdded++);
removeAtPosition(3);
}
private void removeAtPosition(int position) {
if(position < mItems.size()) {
mItems.remove(position);
mAdapter.notifyItemRemoved(position);
}
}
private void addAtPosition(int position, String text) {
if (position > mItems.size()) {
position = mItems.size();
}
mItems.add(position, text);
mAdapter.mSelected.put(text, Boolean.FALSE);
mAdapter.mExpanded.put(text, Boolean.FALSE);
mAdapter.notifyItemInserted(position);
}
public void addDeleteItem(View view) {
addItem(view);
deleteSelectedItems(view);
}
public void deleteAddItem(View view) {
deleteSelectedItems(view);
addItem(view);
}
public void addItem(View view) {
addAtPosition(3, "Added Item #" + mNumItemsAdded++);
}
/**
* A basic ListView-style LayoutManager.
*/
class MyLayoutManager extends RecyclerView.LayoutManager {
private static final String TAG = "MyLayoutManager";
private int mFirstPosition;
private final int mScrollDistance;
public MyLayoutManager(Context c) {
final DisplayMetrics dm = c.getResources().getDisplayMetrics();
mScrollDistance = (int) (SCROLL_DISTANCE * dm.density + 0.5f);
}
@Override
public boolean supportsPredictiveItemAnimations() {
return mPredictiveAnimationsEnabled;
}
@Override
public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
int parentBottom = getHeight() - getPaddingBottom();
final View oldTopView = getChildCount() > 0 ? getChildAt(0) : null;
int oldTop = getPaddingTop();
if (oldTopView != null) {
oldTop = Math.min(oldTopView.getTop(), oldTop);
}
// Note that we add everything to the scrap, but we do not clean it up;
// that is handled by the RecyclerView after this method returns
detachAndScrapAttachedViews(recycler);
int top = oldTop;
int bottom = top;
final int left = getPaddingLeft();
final int right = getWidth() - getPaddingRight();
int count = state.getItemCount();
for (int i = 0; mFirstPosition + i < count && top < parentBottom; i++, top = bottom) {
View v = recycler.getViewForPosition(mFirstPosition + i);
RecyclerView.LayoutParams params = (RecyclerView.LayoutParams) v.getLayoutParams();
addView(v);
measureChild(v, 0, 0);
bottom = top + v.getMeasuredHeight();
v.layout(left, top, right, bottom);
if (mPredictiveAnimationsEnabled && params.isItemRemoved()) {
parentBottom += v.getHeight();
}
}
if (mAnimationsEnabled && mPredictiveAnimationsEnabled && !state.isPreLayout()) {
// Now that we've run a full layout, figure out which views were not used
// (cached in previousViews). For each of these views, position it where
// it would go, according to its position relative to the visible
// positions in the list. This information will be used by RecyclerView to
// record post-layout positions of these items for the purposes of animating them
// out of view
View lastVisibleView = getChildAt(getChildCount() - 1);
if (lastVisibleView != null) {
RecyclerView.LayoutParams lastParams =
(RecyclerView.LayoutParams) lastVisibleView.getLayoutParams();
int lastPosition = lastParams.getViewLayoutPosition();
final List<RecyclerView.ViewHolder> previousViews = recycler.getScrapList();
count = previousViews.size();
for (int i = 0; i < count; ++i) {
View view = previousViews.get(i).itemView;
RecyclerView.LayoutParams params =
(RecyclerView.LayoutParams) view.getLayoutParams();
if (params.isItemRemoved()) {
continue;
}
int position = params.getViewLayoutPosition();
int newTop;
if (position < mFirstPosition) {
newTop = view.getHeight() * (position - mFirstPosition);
} else {
newTop = lastVisibleView.getTop() + view.getHeight() *
(position - lastPosition);
}
view.offsetTopAndBottom(newTop - view.getTop());
}
}
}
}
@Override
public RecyclerView.LayoutParams generateDefaultLayoutParams() {
return new RecyclerView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.WRAP_CONTENT);
}
@Override
public boolean canScrollVertically() {
return true;
}
@Override
public int scrollVerticallyBy(int dy, RecyclerView.Recycler recycler,
RecyclerView.State state) {
if (getChildCount() == 0) {
return 0;
}
int scrolled = 0;
final int left = getPaddingLeft();
final int right = getWidth() - getPaddingRight();
if (dy < 0) {
while (scrolled > dy) {
final View topView = getChildAt(0);
final int hangingTop = Math.max(-topView.getTop(), 0);
final int scrollBy = Math.min(scrolled - dy, hangingTop);
scrolled -= scrollBy;
offsetChildrenVertical(scrollBy);
if (mFirstPosition > 0 && scrolled > dy) {
mFirstPosition--;
View v = recycler.getViewForPosition(mFirstPosition);
addView(v, 0);
measureChild(v, 0, 0);
final int bottom = topView.getTop(); // TODO decorated top?
final int top = bottom - v.getMeasuredHeight();
v.layout(left, top, right, bottom);
} else {
break;
}
}
} else if (dy > 0) {
final int parentHeight = getHeight();
while (scrolled < dy) {
final View bottomView = getChildAt(getChildCount() - 1);
final int hangingBottom = Math.max(bottomView.getBottom() - parentHeight, 0);
final int scrollBy = -Math.min(dy - scrolled, hangingBottom);
scrolled -= scrollBy;
offsetChildrenVertical(scrollBy);
if (scrolled < dy && state.getItemCount() > mFirstPosition + getChildCount()) {
View v = recycler.getViewForPosition(mFirstPosition + getChildCount());
final int top = getChildAt(getChildCount() - 1).getBottom();
addView(v);
measureChild(v, 0, 0);
final int bottom = top + v.getMeasuredHeight();
v.layout(left, top, right, bottom);
} else {
break;
}
}
}
recycleViewsOutOfBounds(recycler);
return scrolled;
}
@Override
public View onFocusSearchFailed(View focused, int direction,
RecyclerView.Recycler recycler, RecyclerView.State state) {
final int oldCount = getChildCount();
if (oldCount == 0) {
return null;
}
final int left = getPaddingLeft();
final int right = getWidth() - getPaddingRight();
View toFocus = null;
int newViewsHeight = 0;
if (direction == View.FOCUS_UP || direction == View.FOCUS_BACKWARD) {
while (mFirstPosition > 0 && newViewsHeight < mScrollDistance) {
mFirstPosition--;
View v = recycler.getViewForPosition(mFirstPosition);
final int bottom = getChildAt(0).getTop(); // TODO decorated top?
addView(v, 0);
measureChild(v, 0, 0);
final int top = bottom - v.getMeasuredHeight();
v.layout(left, top, right, bottom);
if (v.isFocusable()) {
toFocus = v;
break;
}
}
}
if (direction == View.FOCUS_DOWN || direction == View.FOCUS_FORWARD) {
while (mFirstPosition + getChildCount() < state.getItemCount() &&
newViewsHeight < mScrollDistance) {
View v = recycler.getViewForPosition(mFirstPosition + getChildCount());
final int top = getChildAt(getChildCount() - 1).getBottom();
addView(v);
measureChild(v, 0, 0);
final int bottom = top + v.getMeasuredHeight();
v.layout(left, top, right, bottom);
if (v.isFocusable()) {
toFocus = v;
break;
}
}
}
return toFocus;
}
public void recycleViewsOutOfBounds(RecyclerView.Recycler recycler) {
final int childCount = getChildCount();
final int parentWidth = getWidth();
final int parentHeight = getHeight();
boolean foundFirst = false;
int first = 0;
int last = 0;
for (int i = 0; i < childCount; i++) {
final View v = getChildAt(i);
if (v.hasFocus() || (v.getRight() >= 0 && v.getLeft() <= parentWidth &&
v.getBottom() >= 0 && v.getTop() <= parentHeight)) {
if (!foundFirst) {
first = i;
foundFirst = true;
}
last = i;
}
}
for (int i = childCount - 1; i > last; i--) {
removeAndRecycleViewAt(i, recycler);
}
for (int i = first - 1; i >= 0; i--) {
removeAndRecycleViewAt(i, recycler);
}
if (getChildCount() == 0) {
mFirstPosition = 0;
} else {
mFirstPosition += first;
}
}
@Override
public void onItemsAdded(RecyclerView recyclerView, int positionStart, int itemCount) {
if (positionStart < mFirstPosition) {
mFirstPosition += itemCount;
}
}
@Override
public void onItemsRemoved(RecyclerView recyclerView, int positionStart, int itemCount) {
if (positionStart < mFirstPosition) {
mFirstPosition -= itemCount;
}
}
}
class MyAdapter extends RecyclerView.Adapter {
private int mBackground;
List<String> mData;
ArrayMap<String, Boolean> mSelected = new ArrayMap<String, Boolean>();
ArrayMap<String, Boolean> mExpanded = new ArrayMap<String, Boolean>();
public MyAdapter(List<String> data) {
TypedValue val = new TypedValue();
AnimatedRecyclerView.this.getTheme().resolveAttribute(
R.attr.selectableItemBackground, val, true);
mBackground = val.resourceId;
mData = data;
for (String itemText : mData) {
mSelected.put(itemText, Boolean.FALSE);
mExpanded.put(itemText, Boolean.FALSE);
}
}
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
MyViewHolder h = new MyViewHolder(getLayoutInflater().inflate(R.layout.selectable_item,
null));
h.textView.setMinimumHeight(128);
h.textView.setFocusable(true);
h.textView.setBackgroundResource(mBackground);
return h;
}
@Override
public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
String itemText = mData.get(position);
MyViewHolder myViewHolder = (MyViewHolder) holder;
myViewHolder.boundText = itemText;
myViewHolder.textView.setText(itemText);
boolean selected = false;
if (mSelected.get(itemText) != null) {
selected = mSelected.get(itemText);
}
myViewHolder.checkBox.setChecked(selected);
Boolean expanded = mExpanded.get(itemText);
if (Boolean.TRUE.equals(expanded)) {
myViewHolder.textView.setText("More text for the expanded version");
} else {
myViewHolder.textView.setText(itemText);
}
}
@Override
public int getItemCount() {
return mData.size();
}
public void selectItem(MyViewHolder holder, boolean selected) {
mSelected.put(holder.boundText, selected);
}
public void toggleExpanded(MyViewHolder holder) {
mExpanded.put(holder.boundText, !mExpanded.get(holder.boundText));
}
}
static class MyViewHolder extends RecyclerView.ViewHolder {
public TextView textView;
public CheckBox checkBox;
public String boundText;
public MyViewHolder(View v) {
super(v);
textView = (TextView) v.findViewById(R.id.text);
checkBox = (CheckBox) v.findViewById(R.id.selected);
}
@Override
public String toString() {
return super.toString() + " \"" + textView.getText() + "\"";
}
}
}