Drawable加入动画机制（二）

在上篇文章中，我们介绍了一种给Drawable加入动画机制的方法

Drawable加入动画机制（一）

下面来介绍下我根据这个机制写的三段式动画，效果如下图

首先在AnimationScaleState中加入了一个中间Scale参数——mMidScale，

如果在调用前设置了中间Scale，则实现三段式动画

重写start()，如果Mid不为0，则Repeat三次，把Duration变为三段

    @Override
    public void start()
    {
        if(mState.mAnimating){
            return;
        }

        if(mState.mInterpolator == null){
            mState.mInterpolator = new LinearInterpolator();
        }

        if(mState.mTransformation == null){
            mState.mTransformation = new Transformation();
        }
        else{
            mState.mTransformation.clear();
        }

        if(mState.mAnimation == null){
            mState.mAnimation = new AlphaAnimation(0.0f, 1.0f);
        }
        else{
            mState.mAnimation.reset();
        }
        //setup for 3-phased animation
        if(mState.mMidScale != 0){
            mState.mAnimation.setDuration(mState.mDuration / 3);
            mState.mAnimation.setRepeatMode(Animation.RESTART);
            mState.mAnimation.setRepeatCount(2);
            hasMidScale = true;
        }
        mState.mAnimation.setDuration(mState.mDuration);
        mState.mAnimation.setInterpolator(mState.mInterpolator);
        mState.mAnimation.setStartTime(Animation.START_ON_FIRST_FRAME);
        mState.mAnimating = true;

        invalidateSelf();
    }

然后再重写draw

如果MidScale为0，那就实现一段动画

如果不为空，则用animStep标注当前步骤，并逐阶段计算新Scale

同时针对上一篇中提出的问题，加入了动画结束后的stop机制，如果不加入此机制，State中的AlphaAnimation会一直执行下去

    @Override
    public void draw(Canvas canvas)
    {
        final AnimationScaleState st = mState;

        if(st.mDrawable == null){
            return;
        }

        final Rect bounds = (st.mUseBounds ? getBounds() : mTmpRect);

        int saveCount = canvas.save();
        canvas.scale(st.mScale, st.mScale,
                bounds.left + bounds.width()  / 2,
                bounds.top  + bounds.height() / 2);
        st.mDrawable.draw(canvas);
        canvas.restoreToCount(saveCount);

        if (st.mAnimating) {
            long animTime = AnimationUtils.currentAnimationTimeMillis();
            st.mAnimation.getTransformation(animTime, st.mTransformation);
            float transformation = st.mTransformation.getAlpha();
            if (!hasMidScale) {
                st.mScale = (st.mMinScale
                        + (st.mMaxScale - st.mMinScale) * (st.mInvert ? (1.0f - transformation) : transformation));

                invalidateSelf();
                if (transformation == 1.0f)
                    stop();
            }
            // An implementation of 3-Phased Animation using AlphaAnimation
            else {
                if (animStep == 1) {
                    st.mScale = (st.mMidScale
                            + (st.mMaxScale - st.mMidScale) * (st.mInvert ? (1.0f - transformation) : transformation));
                    if (transformation == 1.0f) {
                        animStep = 2;
                    }
                } else if (animStep == 2) {
                    st.mScale = (st.mMaxScale
                            - (st.mMaxScale - st.mMinScale) * (st.mInvert ? (1.0f - transformation) : transformation));
                    if (transformation == 1.0f){
                        animStep = 3;
                    }
                } else if (animStep == 3) {
                    st.mScale = (st.mMinScale
                            + (st.mMidScale - st.mMinScale) * (st.mInvert ? (1.0f - transformation) : transformation));
                    if (transformation == 1.0f) {
                        animStep = 1;
                        stop();
                    }
                }
                invalidateSelf();
            }

        }

    }

Git地址：

点击打开链接