Java tutorial
/* * Thanks to Niek Haarman for the original idea * https://github.com/nhaarman/ListViewAnimations/blob/master/lib-core/src/main/java/com/nhaarman/listviewanimations/appearance/ViewAnimator.java * * * ****************************************************************************** * Copyright (c) 2015 Gabriele Mariotti. * * 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.dalingge.gankio.common.widgets.recyclerview.anim.adapter.helper; import android.animation.Animator; import android.animation.AnimatorSet; import android.annotation.SuppressLint; import android.os.Bundle; import android.os.Parcelable; import android.os.SystemClock; import android.support.annotation.NonNull; import android.support.annotation.Nullable; import android.support.v4.view.ViewCompat; import android.support.v7.widget.GridLayoutManager; import android.support.v7.widget.LinearLayoutManager; import android.support.v7.widget.RecyclerView; import android.util.Log; import android.util.SparseArray; import android.view.View; /** * A class which decides whether given Views should be animated based on their position: each View should only be animated once. * It also calculates proper animation delays for the views. */ public class ViewAnimator { /* Saved instance state keys */ private static final String SAVEDINSTANCESTATE_FIRSTANIMATEDPOSITION = "savedinstancestate_firstanimatedposition"; private static final String SAVEDINSTANCESTATE_LASTANIMATEDPOSITION = "savedinstancestate_lastanimatedposition"; private static final String SAVEDINSTANCESTATE_SHOULDANIMATE = "savedinstancestate_shouldanimate"; /* Default values */ /** * The default delay in millis before the first animation starts. */ private static final int INITIAL_DELAY_MILLIS = 150; /** * The default delay in millis between view animations. */ private static final int DEFAULT_ANIMATION_DELAY_MILLIS = 100; /** * The default duration in millis of the animations. */ private static final int DEFAULT_ANIMATION_DURATION_MILLIS = 300; /* Fields */ /** * The ListViewWrapper containing the ListView implementation. */ @NonNull private final RecyclerView mRecyclerView; /** * The active Animators. Keys are hashcodes of the Views that are animated. */ @NonNull private final SparseArray<Animator> mAnimators = new SparseArray<>(); /** * The delay in millis before the first animation starts. */ private int mInitialDelayMillis = INITIAL_DELAY_MILLIS; /** * The delay in millis between view animations. */ private int mAnimationDelayMillis = DEFAULT_ANIMATION_DELAY_MILLIS; /** * The duration in millis of the animations. */ private int mAnimationDurationMillis = DEFAULT_ANIMATION_DURATION_MILLIS; /** * The start timestamp of the first animation, as returned by {@link SystemClock#uptimeMillis()}. */ private long mAnimationStartMillis; /** * The position of the item that is the first that was animated. */ private int mFirstAnimatedPosition; /** * The position of the last item that was animated. */ private int mLastAnimatedPosition; /** * Whether animation is enabled. When this is set to false, no animation is applied to the views. */ private boolean mShouldAnimate = true; /** * Creates a new ViewAnimator, using the given {@link RecyclerView}. * * @param recyclerView the {@code ListViewWrapper} which wraps the implementation of the ListView used. */ public ViewAnimator(@NonNull final RecyclerView recyclerView) { mRecyclerView = recyclerView; mAnimationStartMillis = -1; mFirstAnimatedPosition = -1; mLastAnimatedPosition = -1; } /** * Call this method to reset animation status on all views. */ public void reset() { for (int i = 0; i < mAnimators.size(); i++) { mAnimators.get(mAnimators.keyAt(i)).cancel(); } mAnimators.clear(); mFirstAnimatedPosition = -1; mLastAnimatedPosition = -1; mAnimationStartMillis = -1; mShouldAnimate = true; } /** * Set the starting position for which items should animate. Given position will animate as well. * Will also call {@link #enableAnimations()}. * * @param position the position. */ public void setShouldAnimateFromPosition(final int position) { enableAnimations(); mFirstAnimatedPosition = position - 1; mLastAnimatedPosition = position - 1; } /** * Set the starting position for which items should animate as the first position which isn't currently visible on screen. This call is also valid when the {@link View}s * haven't been drawn yet. Will also call {@link #enableAnimations()}. */ public void setShouldAnimateNotVisible() { enableAnimations(); mFirstAnimatedPosition = ((LinearLayoutManager) mRecyclerView.getLayoutManager()) .findLastVisibleItemPosition(); mLastAnimatedPosition = ((LinearLayoutManager) mRecyclerView.getLayoutManager()) .findLastVisibleItemPosition(); } /** * Sets the value of the last animated position. Views with positions smaller than or equal to given value will not be animated. */ void setLastAnimatedPosition(final int lastAnimatedPosition) { mLastAnimatedPosition = lastAnimatedPosition; } /** * Sets the delay in milliseconds before the first animation should start. Defaults to {@value #INITIAL_DELAY_MILLIS}. * * @param delayMillis the time in milliseconds. */ public void setInitialDelayMillis(final int delayMillis) { mInitialDelayMillis = delayMillis; } /** * Sets the delay in milliseconds before an animation of a view should start. Defaults to {@value #DEFAULT_ANIMATION_DELAY_MILLIS}. * * @param delayMillis the time in milliseconds. */ public void setAnimationDelayMillis(final int delayMillis) { mAnimationDelayMillis = delayMillis; } /** * Sets the duration of the animation in milliseconds. Defaults to {@value #DEFAULT_ANIMATION_DURATION_MILLIS}. * * @param durationMillis the time in milliseconds. */ public void setAnimationDurationMillis(final int durationMillis) { mAnimationDurationMillis = durationMillis; } /** * Enables animating the Views. This is the default. */ public void enableAnimations() { mShouldAnimate = true; } /** * Disables animating the Views. Enable them again using {@link #enableAnimations()}. */ public void disableAnimations() { mShouldAnimate = false; } /** * Cancels any existing animations for given View. */ public void cancelExistingAnimation(@NonNull final View view) { int hashCode = view.hashCode(); Animator animator = mAnimators.get(hashCode); if (animator != null) { animator.end(); mAnimators.remove(hashCode); } } /** * Animates given View if necessary. * * @param position the position of the item the View represents. * @param view the View that should be animated. */ public void animateViewIfNecessary(final int position, @NonNull final View view, @NonNull final Animator[] animators) { if (mShouldAnimate && position > mLastAnimatedPosition) { if (mFirstAnimatedPosition == -1) { mFirstAnimatedPosition = position; } animateView(position, view, animators); mLastAnimatedPosition = position; } } /** * Animates given View. * * @param view the View that should be animated. */ private void animateView(final int position, @NonNull final View view, @NonNull final Animator[] animators) { if (mAnimationStartMillis == -1) { mAnimationStartMillis = SystemClock.uptimeMillis(); } ViewCompat.setAlpha(view, 0); AnimatorSet set = new AnimatorSet(); set.playTogether(animators); set.setStartDelay(calculateAnimationDelay(position)); set.setDuration(mAnimationDurationMillis); set.start(); mAnimators.put(view.hashCode(), set); } /** * Returns the delay in milliseconds after which animation for View with position mLastAnimatedPosition + 1 should start. */ @SuppressLint("NewApi") private int calculateAnimationDelay(final int position) { int delay; int lastVisiblePosition = ((LinearLayoutManager) mRecyclerView.getLayoutManager()) .findLastCompletelyVisibleItemPosition(); int firstVisiblePosition = ((LinearLayoutManager) mRecyclerView.getLayoutManager()) .findFirstCompletelyVisibleItemPosition(); if (mLastAnimatedPosition > lastVisiblePosition) lastVisiblePosition = mLastAnimatedPosition; int numberOfItemsOnScreen = lastVisiblePosition - firstVisiblePosition; int numberOfAnimatedItems = position - 1 - mFirstAnimatedPosition; if (numberOfItemsOnScreen + 1 < numberOfAnimatedItems) { delay = mAnimationDelayMillis; if (mRecyclerView.getLayoutManager() instanceof GridLayoutManager) { int numColumns = ((GridLayoutManager) mRecyclerView.getLayoutManager()).getSpanCount(); delay += mAnimationDelayMillis * (position % numColumns); Log.d("GAB", "Delay[" + position + "]=*" + lastVisiblePosition + "|" + firstVisiblePosition + "|"); } } else { int delaySinceStart = (position - mFirstAnimatedPosition) * mAnimationDelayMillis; delay = Math.max(0, (int) (-SystemClock.uptimeMillis() + mAnimationStartMillis + mInitialDelayMillis + delaySinceStart)); } Log.d("GAB", "Delay[" + position + "]=" + delay + "|" + lastVisiblePosition + "|" + firstVisiblePosition + "|"); return delay; } /** * Returns a Parcelable object containing the AnimationAdapter's current dynamic state. */ @NonNull public Parcelable onSaveInstanceState() { Bundle bundle = new Bundle(); bundle.putInt(SAVEDINSTANCESTATE_FIRSTANIMATEDPOSITION, mFirstAnimatedPosition); bundle.putInt(SAVEDINSTANCESTATE_LASTANIMATEDPOSITION, mLastAnimatedPosition); bundle.putBoolean(SAVEDINSTANCESTATE_SHOULDANIMATE, mShouldAnimate); return bundle; } /** * Restores this AnimationAdapter's state. * * @param parcelable the Parcelable object previously returned by {@link #onSaveInstanceState()}. */ public void onRestoreInstanceState(@Nullable final Parcelable parcelable) { if (parcelable instanceof Bundle) { Bundle bundle = (Bundle) parcelable; mFirstAnimatedPosition = bundle.getInt(SAVEDINSTANCESTATE_FIRSTANIMATEDPOSITION); mLastAnimatedPosition = bundle.getInt(SAVEDINSTANCESTATE_LASTANIMATEDPOSITION); mShouldAnimate = bundle.getBoolean(SAVEDINSTANCESTATE_SHOULDANIMATE); } } }