src/com/android/deskclock/ItemAnimator.java - platform/packages/apps/DeskClock - Git at Google

 /*
  * Copyright (C) 2016 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.deskclock;

 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
 import android.animation.PropertyValuesHolder;
 import android.support.annotation.NonNull;
 import android.support.v4.util.ArrayMap;
 import android.support.v7.widget.RecyclerView.State;
 import android.support.v7.widget.RecyclerView.ViewHolder;
 import android.support.v7.widget.SimpleItemAnimator;
 import android.view.View;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;

 import static android.view.View.TRANSLATION_Y;
 import static android.view.View.TRANSLATION_X;

 public class ItemAnimator extends SimpleItemAnimator {

     private final List<Animator> mAddAnimatorsList = new ArrayList<>();
     private final List<Animator> mRemoveAnimatorsList = new ArrayList<>();
     private final List<Animator> mChangeAnimatorsList = new ArrayList<>();
     private final List<Animator> mMoveAnimatorsList = new ArrayList<>();

     private final Map<ViewHolder, Animator> mAnimators = new ArrayMap<>();

     @Override
     public boolean animateRemove(final ViewHolder holder) {
         endAnimation(holder);

         final float prevAlpha = holder.itemView.getAlpha();

         final Animator removeAnimator = ObjectAnimator.ofFloat(holder.itemView, View.ALPHA, 0f);
         removeAnimator.setDuration(getRemoveDuration());
         removeAnimator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationStart(Animator animator) {
                 dispatchRemoveStarting(holder);
             }

             @Override
             public void onAnimationEnd(Animator animator) {
                 animator.removeAllListeners();
                 mAnimators.remove(holder);
                 holder.itemView.setAlpha(prevAlpha);
                 dispatchRemoveFinished(holder);
             }
         });
         mRemoveAnimatorsList.add(removeAnimator);
         mAnimators.put(holder, removeAnimator);
         return true;
     }

     @Override
     public boolean animateAdd(final ViewHolder holder) {
         endAnimation(holder);

         final float prevAlpha = holder.itemView.getAlpha();
         holder.itemView.setAlpha(0f);

         final Animator addAnimator = ObjectAnimator.ofFloat(holder.itemView, View.ALPHA, 1f)
                 .setDuration(getAddDuration());
         addAnimator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationStart(Animator animator) {
                 dispatchAddStarting(holder);
             }

             @Override
             public void onAnimationEnd(Animator animator) {
                 animator.removeAllListeners();
                 mAnimators.remove(holder);
                 holder.itemView.setAlpha(prevAlpha);
                 dispatchAddFinished(holder);
             }
         });
         mAddAnimatorsList.add(addAnimator);
         mAnimators.put(holder, addAnimator);
         return true;
     }

     @Override
     public boolean animateMove(final ViewHolder holder, int fromX, int fromY, int toX, int toY) {
         endAnimation(holder);

         final int deltaX = toX - fromX;
         final int deltaY = toY - fromY;
         final long moveDuration = getMoveDuration();

         if (deltaX == 0 && deltaY == 0) {
             dispatchMoveFinished(holder);
             return false;
         }

         final View view = holder.itemView;
         final float prevTranslationX = view.getTranslationX();
         final float prevTranslationY = view.getTranslationY();
         view.setTranslationX(-deltaX);
         view.setTranslationY(-deltaY);

         final ObjectAnimator moveAnimator;
         if (deltaX != 0 && deltaY != 0) {
             final PropertyValuesHolder moveX = PropertyValuesHolder.ofFloat(TRANSLATION_X, 0f);
             final PropertyValuesHolder moveY = PropertyValuesHolder.ofFloat(TRANSLATION_Y, 0f);
             moveAnimator = ObjectAnimator.ofPropertyValuesHolder(holder.itemView, moveX, moveY);
         } else if (deltaX != 0) {
             final PropertyValuesHolder moveX = PropertyValuesHolder.ofFloat(TRANSLATION_X, 0f);
             moveAnimator = ObjectAnimator.ofPropertyValuesHolder(holder.itemView, moveX);
         } else {
             final PropertyValuesHolder moveY = PropertyValuesHolder.ofFloat(TRANSLATION_Y, 0f);
             moveAnimator = ObjectAnimator.ofPropertyValuesHolder(holder.itemView, moveY);
         }

         moveAnimator.setDuration(moveDuration);
         moveAnimator.setInterpolator(AnimatorUtils.INTERPOLATOR_FAST_OUT_SLOW_IN);
         moveAnimator.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationStart(Animator animator) {
                 dispatchMoveStarting(holder);
             }

             @Override
             public void onAnimationEnd(Animator animator) {
                 animator.removeAllListeners();
                 mAnimators.remove(holder);
                 view.setTranslationX(prevTranslationX);
                 view.setTranslationY(prevTranslationY);
                 dispatchMoveFinished(holder);
             }
         });
         mMoveAnimatorsList.add(moveAnimator);
         mAnimators.put(holder, moveAnimator);

         return true;
     }

     @Override
     public boolean animateChange(@NonNull final ViewHolder oldHolder,
             @NonNull final ViewHolder newHolder, @NonNull ItemHolderInfo preInfo,
             @NonNull ItemHolderInfo postInfo) {
         endAnimation(oldHolder);
         endAnimation(newHolder);

         final long changeDuration = getChangeDuration();
         List<Object> payloads = preInfo instanceof PayloadItemHolderInfo
                 ? ((PayloadItemHolderInfo) preInfo).getPayloads() : null;

         if (oldHolder == newHolder) {
             final Animator animator = ((OnAnimateChangeListener) newHolder)
                     .onAnimateChange(payloads, preInfo.left, preInfo.top, preInfo.right,
                             preInfo.bottom, changeDuration);
             if (animator == null) {
                 dispatchChangeFinished(newHolder, false);
                 return false;
             }
             animator.addListener(new AnimatorListenerAdapter() {
                 @Override
                 public void onAnimationStart(Animator animator) {
                     dispatchChangeStarting(newHolder, false);
                 }

                 @Override
                 public void onAnimationEnd(Animator animator) {
                     animator.removeAllListeners();
                     mAnimators.remove(newHolder);
                     dispatchChangeFinished(newHolder, false);
                 }
             });
             mChangeAnimatorsList.add(animator);
             mAnimators.put(newHolder, animator);
             return true;
         } else if (!(oldHolder instanceof OnAnimateChangeListener) ||
                 !(newHolder instanceof OnAnimateChangeListener)) {
             // Both holders must implement OnAnimateChangeListener in order to animate.
             dispatchChangeFinished(oldHolder, true);
             dispatchChangeFinished(newHolder, true);
             return false;
         }

         final Animator oldChangeAnimator = ((OnAnimateChangeListener) oldHolder)
                 .onAnimateChange(oldHolder, newHolder, changeDuration);
         if (oldChangeAnimator != null) {
             oldChangeAnimator.addListener(new AnimatorListenerAdapter() {
                 @Override
                 public void onAnimationStart(Animator animator) {
                     dispatchChangeStarting(oldHolder, true);
                 }

                 @Override
                 public void onAnimationEnd(Animator animator) {
                     animator.removeAllListeners();
                     mAnimators.remove(oldHolder);
                     dispatchChangeFinished(oldHolder, true);
                 }
             });
             mAnimators.put(oldHolder, oldChangeAnimator);
             mChangeAnimatorsList.add(oldChangeAnimator);
         } else {
             dispatchChangeFinished(oldHolder, true);
         }

         final Animator newChangeAnimator = ((OnAnimateChangeListener) newHolder)
                 .onAnimateChange(oldHolder, newHolder, changeDuration);
         if (newChangeAnimator != null) {
             newChangeAnimator.addListener(new AnimatorListenerAdapter() {
                 @Override
                 public void onAnimationStart(Animator animator) {
                     dispatchChangeStarting(newHolder, false);
                 }

                 @Override
                 public void onAnimationEnd(Animator animator) {
                     animator.removeAllListeners();
                     mAnimators.remove(newHolder);
                     dispatchChangeFinished(newHolder, false);
                 }
             });
             mAnimators.put(newHolder, newChangeAnimator);
             mChangeAnimatorsList.add(newChangeAnimator);
         } else {
             dispatchChangeFinished(newHolder, false);
         }

         return true;
     }

     @Override
     public boolean animateChange(ViewHolder oldHolder,
             ViewHolder newHolder, int fromLeft, int fromTop, int toLeft, int toTop) {
         /* Unused */
         throw new IllegalStateException("This method should not be used");
     }

     @Override
     public void runPendingAnimations() {
         final AnimatorSet removeAnimatorSet = new AnimatorSet();
         removeAnimatorSet.playTogether(mRemoveAnimatorsList);
         mRemoveAnimatorsList.clear();

         final AnimatorSet addAnimatorSet = new AnimatorSet();
         addAnimatorSet.playTogether(mAddAnimatorsList);
         mAddAnimatorsList.clear();

         final AnimatorSet changeAnimatorSet = new AnimatorSet();
         changeAnimatorSet.playTogether(mChangeAnimatorsList);
         mChangeAnimatorsList.clear();

         final AnimatorSet moveAnimatorSet = new AnimatorSet();
         moveAnimatorSet.playTogether(mMoveAnimatorsList);
         mMoveAnimatorsList.clear();

         final AnimatorSet pendingAnimatorSet = new AnimatorSet();
         pendingAnimatorSet.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animator) {
                 animator.removeAllListeners();
                 dispatchFinishedWhenDone();
             }
         });
         // Required order: removes, then changes & moves simultaneously, then additions. There are
         // redundant edges because changes or moves may be empty, causing the removes to incorrectly
         // play immediately.
         pendingAnimatorSet.play(removeAnimatorSet).before(changeAnimatorSet);
         pendingAnimatorSet.play(removeAnimatorSet).before(moveAnimatorSet);
         pendingAnimatorSet.play(changeAnimatorSet).with(moveAnimatorSet);
         pendingAnimatorSet.play(addAnimatorSet).after(changeAnimatorSet);
         pendingAnimatorSet.play(addAnimatorSet).after(moveAnimatorSet);
         pendingAnimatorSet.start();
     }

     @Override
     public void endAnimation(ViewHolder holder) {
         final Animator animator = mAnimators.get(holder);

         mAnimators.remove(holder);
         mAddAnimatorsList.remove(animator);
         mRemoveAnimatorsList.remove(animator);
         mChangeAnimatorsList.remove(animator);
         mMoveAnimatorsList.remove(animator);

         if (animator != null) {
             animator.end();
         }

         dispatchFinishedWhenDone();
     }

     @Override
     public void endAnimations() {
         final List<Animator> animatorList = new ArrayList<>(mAnimators.values());
         for (Animator animator : animatorList) {
             animator.end();
         }
         dispatchFinishedWhenDone();
     }

     @Override
     public boolean isRunning() {
         return !mAnimators.isEmpty();
     }

     private void dispatchFinishedWhenDone() {
         if (!isRunning()) {
             dispatchAnimationsFinished();
         }
     }

     @Override
     public @NonNull ItemHolderInfo recordPreLayoutInformation(@NonNull State state,
             @NonNull ViewHolder viewHolder, @AdapterChanges int changeFlags,
             @NonNull List<Object> payloads) {
         final ItemHolderInfo itemHolderInfo = super.recordPreLayoutInformation(state, viewHolder,
                 changeFlags, payloads);
         if (itemHolderInfo instanceof PayloadItemHolderInfo) {
             ((PayloadItemHolderInfo) itemHolderInfo).setPayloads(payloads);
         }
         return itemHolderInfo;
     }

     @Override
     public ItemHolderInfo obtainHolderInfo() {
         return new PayloadItemHolderInfo();
     }

     @Override
     public boolean canReuseUpdatedViewHolder(@NonNull ViewHolder viewHolder,
             @NonNull List<Object> payloads) {
         final boolean defaultReusePolicy = super.canReuseUpdatedViewHolder(viewHolder, payloads);
         // Whenever we have a payload, this is an in-place animation.
         return !payloads.isEmpty() || defaultReusePolicy;
     }

     private static final class PayloadItemHolderInfo extends ItemHolderInfo {
         private final List<Object> mPayloads = new ArrayList<>();

         void setPayloads(List<Object> payloads) {
             mPayloads.clear();
             mPayloads.addAll(payloads);
         }

         List<Object> getPayloads() {
             return mPayloads;
         }
     }

     public interface OnAnimateChangeListener {
         Animator onAnimateChange(ViewHolder oldHolder, ViewHolder newHolder, long duration);
         Animator onAnimateChange(List<Object> payloads, int fromLeft, int fromTop, int fromRight,
                 int fromBottom, long duration);
     }
 }
	/*
	* Copyright (C) 2016 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.deskclock;

	import android.animation.Animator;
	import android.animation.AnimatorListenerAdapter;
	import android.animation.AnimatorSet;
	import android.animation.ObjectAnimator;
	import android.animation.PropertyValuesHolder;
	import android.support.annotation.NonNull;
	import android.support.v4.util.ArrayMap;
	import android.support.v7.widget.RecyclerView.State;
	import android.support.v7.widget.RecyclerView.ViewHolder;
	import android.support.v7.widget.SimpleItemAnimator;
	import android.view.View;

	import java.util.ArrayList;
	import java.util.List;
	import java.util.Map;

	import static android.view.View.TRANSLATION_Y;
	import static android.view.View.TRANSLATION_X;

	public class ItemAnimator extends SimpleItemAnimator {

	private final List<Animator> mAddAnimatorsList = new ArrayList<>();
	private final List<Animator> mRemoveAnimatorsList = new ArrayList<>();
	private final List<Animator> mChangeAnimatorsList = new ArrayList<>();
	private final List<Animator> mMoveAnimatorsList = new ArrayList<>();

	private final Map<ViewHolder, Animator> mAnimators = new ArrayMap<>();

	@Override
	public boolean animateRemove(final ViewHolder holder) {
	endAnimation(holder);

	final float prevAlpha = holder.itemView.getAlpha();

	final Animator removeAnimator = ObjectAnimator.ofFloat(holder.itemView, View.ALPHA, 0f);
	removeAnimator.setDuration(getRemoveDuration());
	removeAnimator.addListener(new AnimatorListenerAdapter() {
	@Override
	public void onAnimationStart(Animator animator) {
	dispatchRemoveStarting(holder);
	}

	@Override
	public void onAnimationEnd(Animator animator) {
	animator.removeAllListeners();
	mAnimators.remove(holder);
	holder.itemView.setAlpha(prevAlpha);
	dispatchRemoveFinished(holder);
	}
	});
	mRemoveAnimatorsList.add(removeAnimator);
	mAnimators.put(holder, removeAnimator);
	return true;
	}

	@Override
	public boolean animateAdd(final ViewHolder holder) {
	endAnimation(holder);

	final float prevAlpha = holder.itemView.getAlpha();
	holder.itemView.setAlpha(0f);

	final Animator addAnimator = ObjectAnimator.ofFloat(holder.itemView, View.ALPHA, 1f)
	.setDuration(getAddDuration());
	addAnimator.addListener(new AnimatorListenerAdapter() {
	@Override
	public void onAnimationStart(Animator animator) {
	dispatchAddStarting(holder);
	}

	@Override
	public void onAnimationEnd(Animator animator) {
	animator.removeAllListeners();
	mAnimators.remove(holder);
	holder.itemView.setAlpha(prevAlpha);
	dispatchAddFinished(holder);
	}
	});
	mAddAnimatorsList.add(addAnimator);
	mAnimators.put(holder, addAnimator);
	return true;
	}

	@Override
	public boolean animateMove(final ViewHolder holder, int fromX, int fromY, int toX, int toY) {
	endAnimation(holder);

	final int deltaX = toX - fromX;
	final int deltaY = toY - fromY;
	final long moveDuration = getMoveDuration();

	if (deltaX == 0 && deltaY == 0) {
	dispatchMoveFinished(holder);
	return false;
	}

	final View view = holder.itemView;
	final float prevTranslationX = view.getTranslationX();
	final float prevTranslationY = view.getTranslationY();
	view.setTranslationX(-deltaX);
	view.setTranslationY(-deltaY);

	final ObjectAnimator moveAnimator;
	if (deltaX != 0 && deltaY != 0) {
	final PropertyValuesHolder moveX = PropertyValuesHolder.ofFloat(TRANSLATION_X, 0f);
	final PropertyValuesHolder moveY = PropertyValuesHolder.ofFloat(TRANSLATION_Y, 0f);
	moveAnimator = ObjectAnimator.ofPropertyValuesHolder(holder.itemView, moveX, moveY);
	} else if (deltaX != 0) {
	final PropertyValuesHolder moveX = PropertyValuesHolder.ofFloat(TRANSLATION_X, 0f);
	moveAnimator = ObjectAnimator.ofPropertyValuesHolder(holder.itemView, moveX);
	} else {
	final PropertyValuesHolder moveY = PropertyValuesHolder.ofFloat(TRANSLATION_Y, 0f);
	moveAnimator = ObjectAnimator.ofPropertyValuesHolder(holder.itemView, moveY);
	}

	moveAnimator.setDuration(moveDuration);
	moveAnimator.setInterpolator(AnimatorUtils.INTERPOLATOR_FAST_OUT_SLOW_IN);
	moveAnimator.addListener(new AnimatorListenerAdapter() {
	@Override
	public void onAnimationStart(Animator animator) {
	dispatchMoveStarting(holder);
	}

	@Override
	public void onAnimationEnd(Animator animator) {
	animator.removeAllListeners();
	mAnimators.remove(holder);
	view.setTranslationX(prevTranslationX);
	view.setTranslationY(prevTranslationY);
	dispatchMoveFinished(holder);
	}
	});
	mMoveAnimatorsList.add(moveAnimator);
	mAnimators.put(holder, moveAnimator);

	return true;
	}

	@Override
	public boolean animateChange(@NonNull final ViewHolder oldHolder,
	@NonNull final ViewHolder newHolder, @NonNull ItemHolderInfo preInfo,
	@NonNull ItemHolderInfo postInfo) {
	endAnimation(oldHolder);
	endAnimation(newHolder);

	final long changeDuration = getChangeDuration();
	List<Object> payloads = preInfo instanceof PayloadItemHolderInfo
	? ((PayloadItemHolderInfo) preInfo).getPayloads() : null;

	if (oldHolder == newHolder) {
	final Animator animator = ((OnAnimateChangeListener) newHolder)
	.onAnimateChange(payloads, preInfo.left, preInfo.top, preInfo.right,
	preInfo.bottom, changeDuration);
	if (animator == null) {
	dispatchChangeFinished(newHolder, false);
	return false;
	}
	animator.addListener(new AnimatorListenerAdapter() {
	@Override
	public void onAnimationStart(Animator animator) {
	dispatchChangeStarting(newHolder, false);
	}

	@Override
	public void onAnimationEnd(Animator animator) {
	animator.removeAllListeners();
	mAnimators.remove(newHolder);
	dispatchChangeFinished(newHolder, false);
	}
	});
	mChangeAnimatorsList.add(animator);
	mAnimators.put(newHolder, animator);
	return true;
	} else if (!(oldHolder instanceof OnAnimateChangeListener) \|\|
	!(newHolder instanceof OnAnimateChangeListener)) {
	// Both holders must implement OnAnimateChangeListener in order to animate.
	dispatchChangeFinished(oldHolder, true);
	dispatchChangeFinished(newHolder, true);
	return false;
	}

	final Animator oldChangeAnimator = ((OnAnimateChangeListener) oldHolder)
	.onAnimateChange(oldHolder, newHolder, changeDuration);
	if (oldChangeAnimator != null) {
	oldChangeAnimator.addListener(new AnimatorListenerAdapter() {
	@Override
	public void onAnimationStart(Animator animator) {
	dispatchChangeStarting(oldHolder, true);
	}

	@Override
	public void onAnimationEnd(Animator animator) {
	animator.removeAllListeners();
	mAnimators.remove(oldHolder);
	dispatchChangeFinished(oldHolder, true);
	}
	});
	mAnimators.put(oldHolder, oldChangeAnimator);
	mChangeAnimatorsList.add(oldChangeAnimator);
	} else {
	dispatchChangeFinished(oldHolder, true);
	}

	final Animator newChangeAnimator = ((OnAnimateChangeListener) newHolder)
	.onAnimateChange(oldHolder, newHolder, changeDuration);
	if (newChangeAnimator != null) {
	newChangeAnimator.addListener(new AnimatorListenerAdapter() {
	@Override
	public void onAnimationStart(Animator animator) {
	dispatchChangeStarting(newHolder, false);
	}

	@Override
	public void onAnimationEnd(Animator animator) {
	animator.removeAllListeners();
	mAnimators.remove(newHolder);
	dispatchChangeFinished(newHolder, false);
	}
	});
	mAnimators.put(newHolder, newChangeAnimator);
	mChangeAnimatorsList.add(newChangeAnimator);
	} else {
	dispatchChangeFinished(newHolder, false);
	}

	return true;
	}

	@Override
	public boolean animateChange(ViewHolder oldHolder,
	ViewHolder newHolder, int fromLeft, int fromTop, int toLeft, int toTop) {
	/* Unused */
	throw new IllegalStateException("This method should not be used");
	}

	@Override
	public void runPendingAnimations() {
	final AnimatorSet removeAnimatorSet = new AnimatorSet();
	removeAnimatorSet.playTogether(mRemoveAnimatorsList);
	mRemoveAnimatorsList.clear();

	final AnimatorSet addAnimatorSet = new AnimatorSet();
	addAnimatorSet.playTogether(mAddAnimatorsList);
	mAddAnimatorsList.clear();

	final AnimatorSet changeAnimatorSet = new AnimatorSet();
	changeAnimatorSet.playTogether(mChangeAnimatorsList);
	mChangeAnimatorsList.clear();

	final AnimatorSet moveAnimatorSet = new AnimatorSet();
	moveAnimatorSet.playTogether(mMoveAnimatorsList);
	mMoveAnimatorsList.clear();

	final AnimatorSet pendingAnimatorSet = new AnimatorSet();
	pendingAnimatorSet.addListener(new AnimatorListenerAdapter() {
	@Override
	public void onAnimationEnd(Animator animator) {
	animator.removeAllListeners();
	dispatchFinishedWhenDone();
	}
	});
	// Required order: removes, then changes & moves simultaneously, then additions. There are
	// redundant edges because changes or moves may be empty, causing the removes to incorrectly
	// play immediately.
	pendingAnimatorSet.play(removeAnimatorSet).before(changeAnimatorSet);
	pendingAnimatorSet.play(removeAnimatorSet).before(moveAnimatorSet);
	pendingAnimatorSet.play(changeAnimatorSet).with(moveAnimatorSet);
	pendingAnimatorSet.play(addAnimatorSet).after(changeAnimatorSet);
	pendingAnimatorSet.play(addAnimatorSet).after(moveAnimatorSet);
	pendingAnimatorSet.start();
	}

	@Override
	public void endAnimation(ViewHolder holder) {
	final Animator animator = mAnimators.get(holder);

	mAnimators.remove(holder);
	mAddAnimatorsList.remove(animator);
	mRemoveAnimatorsList.remove(animator);
	mChangeAnimatorsList.remove(animator);
	mMoveAnimatorsList.remove(animator);

	if (animator != null) {
	animator.end();
	}

	dispatchFinishedWhenDone();
	}

	@Override
	public void endAnimations() {
	final List<Animator> animatorList = new ArrayList<>(mAnimators.values());
	for (Animator animator : animatorList) {
	animator.end();
	}
	dispatchFinishedWhenDone();
	}

	@Override
	public boolean isRunning() {
	return !mAnimators.isEmpty();
	}

	private void dispatchFinishedWhenDone() {
	if (!isRunning()) {
	dispatchAnimationsFinished();
	}
	}

	@Override
	public @NonNull ItemHolderInfo recordPreLayoutInformation(@NonNull State state,
	@NonNull ViewHolder viewHolder, @AdapterChanges int changeFlags,
	@NonNull List<Object> payloads) {
	final ItemHolderInfo itemHolderInfo = super.recordPreLayoutInformation(state, viewHolder,
	changeFlags, payloads);
	if (itemHolderInfo instanceof PayloadItemHolderInfo) {
	((PayloadItemHolderInfo) itemHolderInfo).setPayloads(payloads);
	}
	return itemHolderInfo;
	}

	@Override
	public ItemHolderInfo obtainHolderInfo() {
	return new PayloadItemHolderInfo();
	}

	@Override
	public boolean canReuseUpdatedViewHolder(@NonNull ViewHolder viewHolder,
	@NonNull List<Object> payloads) {
	final boolean defaultReusePolicy = super.canReuseUpdatedViewHolder(viewHolder, payloads);
	// Whenever we have a payload, this is an in-place animation.
	return !payloads.isEmpty() \|\| defaultReusePolicy;
	}

	private static final class PayloadItemHolderInfo extends ItemHolderInfo {
	private final List<Object> mPayloads = new ArrayList<>();

	void setPayloads(List<Object> payloads) {
	mPayloads.clear();
	mPayloads.addAll(payloads);
	}

	List<Object> getPayloads() {
	return mPayloads;
	}
	}

	public interface OnAnimateChangeListener {
	Animator onAnimateChange(ViewHolder oldHolder, ViewHolder newHolder, long duration);
	Animator onAnimateChange(List<Object> payloads, int fromLeft, int fromTop, int fromRight,
	int fromBottom, long duration);
	}
	}