android.view.animation.Animation#AnimationListener()源码实例Demo

private void startScaleDownReturnToStartAnimation(final CircleImageView view, int from,
                                                  Animation.AnimationListener listener) {
    mFrom = from;
    if (isAlphaUsedForScale()) {
        mStartingScale = bProgress.getAlpha();
    } else {
        mStartingScale = ViewCompat.getScaleX(view);
    }
    mScaleDownToStartAnimation = new Animation() {
        @Override
        public void applyTransformation(float interpolatedTime, Transformation t) {
            float targetScale = (mStartingScale + (-mStartingScale * interpolatedTime));
            setAnimationProgress(view, targetScale);
            moveToStart(interpolatedTime);
        }
    };
    mScaleDownToStartAnimation.setDuration(SCALE_DOWN_DURATION);
    if (listener != null) {
        view.setAnimationListener(listener);
    }
    view.clearAnimation();
    view.startAnimation(mScaleDownToStartAnimation);
}
 

public static void collapse(@NonNull final View v, @Nullable Animation.AnimationListener listener) {
    final int initialHeight = v.getMeasuredHeight();

    Animation a = new Animation() {
        @Override
        protected void applyTransformation(float interpolatedTime, Transformation t) {
            if (interpolatedTime == 1) {
                v.setVisibility(View.GONE);
            } else {
                v.getLayoutParams().height = initialHeight - (int) (initialHeight * interpolatedTime);
                v.requestLayout();
            }
        }

        @Override
        public boolean willChangeBounds() {
            return true;
        }
    };

    if (listener != null) a.setAnimationListener(listener);

    a.setDuration((int) (initialHeight / v.getContext().getResources().getDisplayMetrics().density));
    v.startAnimation(a);
}
 

private void animateOffsetToStartPosition(int from, Animation.AnimationListener listener) {
    if (mScale) {
        // Scale the item back down
        startScaleDownReturnToStartAnimation(from, listener);
    } else {
        mFrom = from;
        mAnimateToStartPosition.reset();
        mAnimateToStartPosition.setDuration(ANIMATE_TO_START_DURATION);
        mAnimateToStartPosition.setInterpolator(mDecelerateInterpolator);
        if (listener != null) {
            mCircleView.setAnimationListener(listener);
        }
        mCircleView.clearAnimation();
        mCircleView.startAnimation(mAnimateToStartPosition);
    }
}
 

private void animateOffsetToCorrectPosition(int from, Animation.AnimationListener listener) {
    mFrom = from;
    mAnimateToCorrectPosition.reset();
    mAnimateToCorrectPosition.setDuration(ANIMATE_TO_TRIGGER_DURATION);
    mAnimateToCorrectPosition.setInterpolator(mDecelerateInterpolator);
    if (listener != null) {
        mCircleView.setAnimationListener(listener);
    }
    mCircleView.clearAnimation();
    mCircleView.startAnimation(mAnimateToCorrectPosition);
}
 

/**
 * 获取一个缩小动画
 *
 * @param durationMillis    时间
 * @param animationListener 监听
 * @return 一个缩小动画
 */
public static ScaleAnimation getLessenScaleAnimation(long durationMillis, Animation.AnimationListener animationListener) {
    ScaleAnimation scaleAnimation = new ScaleAnimation(1.0f, 0.0f, 1.0f,
            0.0f, ScaleAnimation.RELATIVE_TO_SELF,
            ScaleAnimation.RELATIVE_TO_SELF);
    scaleAnimation.setDuration(durationMillis);
    scaleAnimation.setAnimationListener(animationListener);

    return scaleAnimation;
}
 

private void startScaleDownAnimation(Animation.AnimationListener listener) {
    mScaleDownAnimation = new Animation() {
        @Override
        public void applyTransformation(float interpolatedTime, Transformation t) {
            setAnimationProgress(1 - interpolatedTime);
        }
    };
    mScaleDownAnimation.setDuration(SCALE_DOWN_DURATION);
    mCircleView.setAnimationListener(listener);
    mCircleView.clearAnimation();
    mCircleView.startAnimation(mScaleDownAnimation);
}
 

private void startScaleDownAnimation(Animation.AnimationListener listener) {
    mScaleDownAnimation = new Animation() {
        @Override
        public void applyTransformation(float interpolatedTime, Transformation t) {
            setAnimationProgress(1 - interpolatedTime);
        }
    };
    mScaleDownAnimation.setDuration(SCALE_DOWN_DURATION);
    mCircleView.setAnimationListener(listener);
    mCircleView.clearAnimation();
    mCircleView.startAnimation(mScaleDownAnimation);
}
 

private void animateOffsetToCorrectPosition(Animation.AnimationListener listener) {
    mAnimateToCorrectPosition.reset();
    mAnimateToCorrectPosition.setDuration(ANIMATE_TO_TRIGGER_DURATION);
    mAnimateToCorrectPosition.setInterpolator(mDecelerateInterpolator);
    if (listener != null)
        mCircleView.setAnimationListener(listener);
    mCircleView.clearAnimation();
    mCircleView.startAnimation(mAnimateToCorrectPosition);
}
 

public void hide(@Nullable Animation.AnimationListener listener) {
    hide(DEFAULT_DURATION, listener);
}
 

public void setAnimationListener(Animation.AnimationListener listener) {
    mListener = listener;
}
 

public void setAnimationListener(Animation.AnimationListener listener) {
    mListener = listener;
}
 

public void setAnimationListener(Animation.AnimationListener listener) {
    mListener = listener;
}
 

public void setAnimationListener(Animation.AnimationListener listener) {
    mListener = listener;
}
 

public void setAnimationListener(Animation.AnimationListener listener) {
	mListener = listener;
}
 

public void setAnimationListener(Animation.AnimationListener listener) {
    mListener = listener;
}
 

public Animation.AnimationListener getAnimationListener() {
    return listener;
}
 

public void setAnimationListener(Animation.AnimationListener listener) {
    mListener = listener;
}
 

@Override
public void setLayoutAnimationListener(Animation.AnimationListener animationListener) {
    animation.setAnimationListener(animationListener);
}
 

/**
 * 获取一个由完全显示变为不可见的透明度渐变动画
 *
 * @param durationMillis    持续时间
 * @param animationListener 动画监听器
 * @return 一个由完全显示变为不可见的透明度渐变动画
 */
public static AlphaAnimation getHiddenAlphaAnimation(long durationMillis, Animation.AnimationListener animationListener) {
    return getAlphaAnimation(1.0f, 0.0f, durationMillis, animationListener);
}
 

/**
 * 获取一个根据视图自身中心点旋转的动画
 *
 * @param durationMillis    动画持续时间
 * @param animationListener 动画监听器
 * @return 一个根据中心点旋转的动画
 */
public static RotateAnimation getRotateAnimationByCenter(long durationMillis, Animation.AnimationListener animationListener) {
    return getRotateAnimation(0f, 359f, Animation.RELATIVE_TO_SELF, 0.5f,
            Animation.RELATIVE_TO_SELF, 0.5f, durationMillis,
            animationListener);
}