一次Android動畫工具類的封裝

賈亦真亦賈發表於2019-04-15

起因

最近在做一個元件化框架的封裝，現在開發到一些常用工具類的封裝了，突然意識到好像還沒有做動畫的工具類，於是開始著手開發之。

思路

既然要做動畫，肯定是要做屬性動畫的工具類的封裝了，由於補間動畫和逐幀動畫並不能改變目標動畫主題的實際屬性，在Android的開發中已經越來越少人去用這兩個動畫框架做開發了，而屬性動畫則相對的越來越廣泛的使用在開發過程中了，於是這次的工具類的封裝，只針對屬性動畫來封裝。

屬性動畫對應的類叫做ObjectAnimator,主要就是用這個類來實現動畫的一些基礎設定，其具體的使用方式我就不寫了，有興趣的朋友可以自行學習屬性動畫的相關知識。

封裝屬性動畫工具類不可避免的還要考慮到屬性動畫的組合播放動畫的需求，而屬性動畫的組合播放有大約三種方式：

1.使用AnimatorSet的Builder來組合播放 AnimatorSet.Builder是一個使用的動畫工具類，用於方便向AnimatorSet新增動畫以及設定各種動畫之間的關係。在 AnimatorSet.Builder中，共宣告瞭after(long)、after(Animator)、before(Animator)、with(Animator)等四個方法。

after(delay) 設定動畫延遲delay時間後播放
after(anim) 設定在anim動畫結束後播放此動畫
before(anim) 設定此動畫早於anim播放
with(anim) 設定此動畫與anim一起播放

然後再呼叫paly(anim)方法來鏈式呼叫動畫

AnimatorSet set=new AnimatorSet();
set.play(anim1).before(anim2).with(anim3).after(anim4);
複製程式碼

我們注意到他是先執行的after，然後是play和with同時執行，最後執行的before。所以大家記住這個順序，無論怎麼寫，都是這個執行順序。

2.使用AnimatorSet的playSequentially

API

playSequentially(List items)：新增一組動畫，播放順序為逐一播放 playSequentially(Animator… items)：新增一組動畫，播放順序為逐一播放

AnimatorSet bouncer = new AnimatorSet();
ObjectAnimator objectAnimatorA = ObjectAnimator.ofFloat(btnProperty, PropertyConstant.PROPERTY_TRANSLATION_X, 0f, 300f);
ObjectAnimator objectAnimatorB = ObjectAnimator.ofFloat(btnProperty, PropertyConstant.PROPERTY_TRANSLATION_Y, 0f, 300f);
ObjectAnimator objectAnimatorC = ObjectAnimator.ofFloat(btnProperty, PropertyConstant.PROPERTY_ROTATION, 0f, 360f);

bouncer.playSequentially(objectAnimatorA, objectAnimatorB, objectAnimatorC);

bouncer.setDuration(6000);
bouncer.start();
複製程式碼

3.使用AnimatorSet的palyTogether

API

playTogether(Collection items)：新增一組動畫，播放順序為一起播放 playTogether(Animator… items)：新增一組動畫，播放順序為一起播放

AnimatorSet bouncer = new AnimatorSet();
ObjectAnimator objectAnimatorA = ObjectAnimator.ofFloat(btnProperty, PropertyConstant.PROPERTY_TRANSLATION_X, 0f, 300f);
ObjectAnimator objectAnimatorB = ObjectAnimator.ofFloat(btnProperty, PropertyConstant.PROPERTY_TRANSLATION_Y, 0f, 300f);
ObjectAnimator objectAnimatorC = ObjectAnimator.ofFloat(btnProperty, PropertyConstant.PROPERTY_ROTATION, 0f, 360f);

bouncer.playSequentially(objectAnimatorA, objectAnimatorB, objectAnimatorC);

bouncer.setDuration(6000);
bouncer.start();
複製程式碼

掌握以上的知識點後，我的思路是，其實最後就是對執行方式的封裝，所謂的執行方式就是如何正常的呼叫play,playSequentially和playTogether三個方法，這裡需要合理的封裝。

還有就是對於監聽介面的封裝，每個ObjectAnimator都有三個介面：

Animator.AnimatorListener 對整個動畫生命週期的監聽

anim.addListener(new Animator.AnimatorListener() {
        @Override
        public void onAnimationStart(Animator animator) {
            Toast.makeText(MainActivity.this, "start", Toast.LENGTH_LONG).show();
        }

        @Override
        public void onAnimationEnd(Animator animator) {
            Toast.makeText(MainActivity.this, "End", Toast.LENGTH_LONG).show();
        }

        @Override
        public void onAnimationCancel(Animator animator) {
            Toast.makeText(MainActivity.this, "Cancel", Toast.LENGTH_LONG).show();
        }

        @Override
        public void onAnimationRepeat(Animator animator) {
            Toast.makeText(MainActivity.this, "rapeat", Toast.LENGTH_LONG).show();
        }
    });
    anim.start();
複製程式碼

ValueAnimator.AnimatorUpdateListener 對於該動畫逐幀的監聽

ValueAnimator vanim = ValueAnimator.ofInt(0,10,20);
    vanim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator valueAnimator) {

   //如果之前的ValueAnimtor指定的是Int的i話，那麼返回的Value就是int型別，
   也就是返回值型別與你建立的型別一致
            int value = (int) valueAnimator.getAnimatedValue();
        }
    });
複製程式碼

Animator.AnimatorPauseListener 對於該動畫的暫停和播放的監聽

new Animator.AnimatorPauseListener() {
            @Override
            public void onAnimationPause(Animator animator) {
                
            }

            @Override
            public void onAnimationResume(Animator animator) {

            }
        }
複製程式碼

由於我的初步構想是使用建造者模式的鏈式呼叫模式來設計我的工具類，如果按照普通的寫法，那麼整個監聽介面的設定將會是災難性的，因為所有的監聽介面的設定都是混亂的，所以這裡必須處理，我的思路是，學習SpringSecurity的鏈式呼叫設計，為每個型別的監聽設定自己的類，然後再讓工具主類呼叫該型別的監聽介面，然後設定完畢後，在通過該監聽介面類的and（）方法回到工具類的主型別來，這樣在鏈式呼叫的時候就有一個起止順序，不會混亂執行了，而且如果不用設定監聽，不呼叫監聽類設定也不會影響主類的執行。

擷取關鍵程式碼,以Play方法的監聽介面設定為例：

/**
*工具類的主類
**/
public static class AnimatorSetWrap{
     PlayAnimationListener playListener;
     public PlayAnimationListener toAddPlayListener(){
            playListener=new PlayAnimationListener(this);
            return playListener;
        }
  }

/**
     * Play方法對應的ObjectAnimator的監聽例項
     */
    public static class PlayAnimationListener implements IAnimatorListener<PlayAnimationListener>{

        private  Animator.AnimatorListener animatorListener;
        private ValueAnimator.AnimatorUpdateListener updateListener;
        private Animator.AnimatorPauseListener pauseListener;

        public AnimatorSetWrap animatorSetWrap;
        public  PlayAnimationListener(AnimatorSetWrap animatorSetWrap){
                this.animatorSetWrap=animatorSetWrap;
        }
        @Override
        public PlayAnimationListener setAnimatorListener(Animator.AnimatorListener animatorListener) {
            this.animatorListener=animatorListener;
            return this;
        }

        @Override
        public PlayAnimationListener setUpdateListener(ValueAnimator.AnimatorUpdateListener animatorListener) {
            this.updateListener=animatorListener;
            return this;
        }

        @Override
        public PlayAnimationListener setPauseListener(Animator.AnimatorPauseListener animatorListener) {
            this.pauseListener=animatorListener;
            return this;
        }
        @Override
        public AnimatorSetWrap and(){
            return animatorSetWrap;
        }
    }

/**
     * 動畫監聽的公用模板介面
     * @param <T>
     */
    interface IAnimatorListener<T>{
        /**
         * 設定AnimatorListener的方法
         * @param listener
         * @return
         */
        T setAnimatorListener(Animator.AnimatorListener listener);

        /**
         * 設定AnimatorUpdateListener的方法
         * @param listener
         * @return
         */
        T setUpdateListener(ValueAnimator.AnimatorUpdateListener listener);

        /**
         * 設定AnimatorPauseListener的方法
         * @param listener
         * @return
         */
        T setPauseListener(Animator.AnimatorPauseListener listener);

        /**
         * 橋接動畫監聽與動畫工具類的方法
         * @return
         */
        AnimatorSetWrap and();
    }
複製程式碼

具體的使用方法：

AnimatorUtil.AnimatorSetWrap  animatorSetWrapDemo=new AnimatorSetWrap().toAddPlayListener().setUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator valueAnimator) {
                LogUtils.e("數值:"+valueAnimator.getAnimatedValue());
            }
        }).and();
複製程式碼

通過這種鏈式呼叫，只要呼叫到and()方法就又回到了AnimatorSetWrap工具類的例項，剩下就可以繼續呼叫其他動畫的方法並播放動畫了。

程式碼

說了這麼多，就把我的工具類程式碼分享給大家吧，可能還不完善，有什麼問題大家一起探討：

import android.animation.Animator;
import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.animation.TimeInterpolator;
import android.animation.ValueAnimator;
import android.os.Build;
import android.support.annotation.Nullable;
import android.support.annotation.Size;
import android.view.View;
import android.view.animation.LinearInterpolator;

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

/**
 * 動畫工具類
 *@package com.dhcc.commonutils
 *@author jasoncool
 *@createDate 2018/11/20 16:16
 *@description
 **/
public class AnimatorUtils {

    public static final String ALPHA="Alpha";
    public static final String TRANSX="TranslationX";
    public static final String TRANSY="TranslationY";
    public static final String SCALEX="ScaleX";
    public static final String SCALEY="ScaleY";
    public static final String ROTATION="Rotation";
    public static final String ROTATIONX="RotationX";
    public static final String ROTATIONY="RotationY";

    /**
     * 預設的TimeInterpolator,前後減速，中間加速
     */
    private static final TimeInterpolator sDefaultInterpolator =
            new LinearInterpolator();

    public static AnimatorSetWrap createAnimator() {
        return new AnimatorSetWrap();
    }

    /**
     * @param interpolator 預設的TimeInterpolator
     * @return
     */
    public static AnimatorSetWrap createAnimator(TimeInterpolator interpolator) {
        return new AnimatorSetWrap(interpolator);
    }

    /**
     * 屬性動畫組合
     * 屬性動畫組合對應的是AnimatorSet類，我們只需要new他就好。
     *
     * 它對應的主要有這四個方法，play，before，with，after。
     * 這四個方法裡面全都是填入往後兒們的animator類，
     * 但是先後執行順序不一樣，分別對應著開啟，最後，同步，最開始執行。
     * 我們注意到他是先執行的after，然後是play和with同時執行，最後執行的before。
     * 所以大家記住這個順序，無論怎麼寫，都是這個執行順序。
     *
     */
    public static class AnimatorSetWrap{

        private View mView;
        /**
         * 不設定預設插值器時，工具類自帶的預設插值器
         */
        private TimeInterpolator mTimeInterpolator;
        /**
         * 判斷play方法只允許執行一次的布林值
         */
        boolean mIsPlaying=false;
        /**
         * 聯合動畫的動畫容器
         */
        private AnimatorSet mAnimatorSet;
        /**
         * 聯合動畫的動畫構造器
         */
        private AnimatorSet.Builder mAnimatorBuilder;
        /**
         * 預設執行時間
         */
        private int mDuration=1000;
        /**
         * play的監聽器類
         */
        PlayAnimationListener playListener;
        /**
         * before的監聽器類
         */
        BeforeAnimationListener beforeListener;
        /**
         * with的監聽器類
         */
        WithAnimationListener withListener;
        /**
         * after的監聽器類
         */
        AfterAnimationListener afterListener;
        /**
         * then的監聽器類
         */
        ThenAnimationListener thenListener;
        /**
         * 順序播放或者同時播放時儲存動畫的列表容器
         */
        List<Animator> mAnimatorList;
        /**
         * 是否已經初始化then動畫
         */
        boolean mHasInitThenAnim=false;

        private AnimatorSetWrap(){
          this(sDefaultInterpolator);
        }

        /**
         * 構造方法
         * 主要是負責
         * 1.初始化預設的插值器 mTimeInterpolator
         * 2.初始化聯合動畫Set mAnimatorSet
         * 3.初始化順序或同時播放動畫容器 mAnimatorList
         * @param interpolator
         */
        private AnimatorSetWrap(TimeInterpolator interpolator) {
            mTimeInterpolator = interpolator;
            mAnimatorSet = new AnimatorSet();
            mAnimatorList=new ArrayList<>(16);
        }

        /**
         * Play動畫的監聽啟動方法
         * 如果要監聽play動畫先呼叫這個方法
         * @return
         */
        public PlayAnimationListener toAddPlayListener(){
            playListener=new PlayAnimationListener(this);
            return playListener;
        }
        /**
         * Before動畫的監聽啟動方法
         * 如果要監聽Before動畫先呼叫這個方法
         * @return
         */
        public BeforeAnimationListener toAddBeforeListener(){
            beforeListener=new BeforeAnimationListener(this);
            return beforeListener;
        }
        /**
         * With動畫的監聽啟動方法
         * 如果要監聽With動畫先呼叫這個方法
         * @return
         */
        public WithAnimationListener toAddWithListener(){
            withListener=new WithAnimationListener(this);
            return withListener;
        }
        /**
         * After動畫的監聽啟動方法
         * 如果要監聽After動畫先呼叫這個方法
         * @return
         */
        public AfterAnimationListener toAddAfterListener(){
            afterListener=new AfterAnimationListener(this);
            return afterListener;
        }

        /**
         * 順序或同時播放動畫執行時的監聽方法
         * 要先於Then方法進行呼叫
         * @return
         */
        public ThenAnimationListener toAddThenListener(){
            thenListener=new ThenAnimationListener(this);
            return thenListener;
        }

        /**
         *  順序或者同時播放動畫時的呼叫方法
         *  在其內部生成一個Animator並將該Animator加入到mAnimatorList中備用
         * @param view 動畫執行的主體View
         * @param animName 動畫型別
         * @param interpolator 動畫插值器 如果不設定就用預設的
         * @param repeatCount 重複次數
         * @param duration 執行時間
         * @param values 動畫執行的值
         * @return
         */
        public AnimatorSetWrap then(View view, String animName, @Nullable TimeInterpolator interpolator, @Size(min = 0,max=Integer.MAX_VALUE) int repeatCount, @Size(min = 0,max=Integer.MAX_VALUE) int duration, float... values){
            LogUtils.e("addThen");
            if(view==null){
                throw new RuntimeException("view 不能為空");
            }
            mIsPlaying = true;
            mView = view;
            ObjectAnimator thenAnimator = ObjectAnimator.ofFloat(view,animName,values);
            thenAnimator.setInterpolator(interpolator==null?mTimeInterpolator:interpolator);
            thenAnimator.setRepeatCount(repeatCount<0?0:repeatCount);
            thenAnimator.setDuration(duration<0?mDuration:duration);
            if (thenListener!=null&&thenListener.animatorListener != null) {
                thenAnimator.addListener(thenListener.animatorListener);
            }
            if(thenListener!=null&&thenListener.updateListener!=null){
                thenAnimator.addUpdateListener(thenListener.updateListener);
            }
            if(thenListener!=null&&thenListener.pauseListener!=null){
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    thenAnimator.addPauseListener(thenListener.pauseListener);
                }else{
                    throw new RuntimeException("SDK最小要求19");
                }
            }
            mAnimatorList.add(thenAnimator);
            return this;
        }

        public AnimatorSetWrap then(Animator animator) {
            mAnimatorList.add(animator);
            return this;
        }

        public AnimatorSetWrap then(AnimatorSetWrap animator) {
            mAnimatorList.add(animator.getAnimatorSet());
            return this;
        }

        /**
         * AnimatorSet的Play方法，整個動畫過程只能呼叫一次
         * 並且一旦執行play方法將會清除掉mAnimatorList中儲存的順序或同時執行的方法例項
         * @param view 方法主體
         * @param animName 動畫型別
         * @param interpolator 插值器
         * @param repeatCount 重複次數
         * @param duration 動畫時長
         * @param values 動畫執行值
         * @return
         */
        public AnimatorSetWrap play(View view, String animName, @Nullable TimeInterpolator interpolator, @Size(min = 0,max=Integer.MAX_VALUE) int repeatCount, @Size(min = 0,max=Integer.MAX_VALUE) int duration, float... values){
            LogUtils.e("play");
            if(mIsPlaying){
                throw new RuntimeException("AnimatorSetWrap.play()方法只能呼叫一次");
            }
            if(view==null){
                throw new RuntimeException("view 不能為空");
            }
            mIsPlaying = true;
            mView = view;
            ObjectAnimator playAnimator = ObjectAnimator.ofFloat(view,animName,values);
            playAnimator.setInterpolator(interpolator==null?mTimeInterpolator:interpolator);
            playAnimator.setRepeatCount(repeatCount<0?0:repeatCount);
            playAnimator.setDuration(duration<0?mDuration:duration);
            if (playListener!=null&&playListener.animatorListener != null) {
                playAnimator.addListener(playListener.animatorListener);
            }
            if(playListener!=null&&playListener.updateListener!=null){
                playAnimator.addUpdateListener(playListener.updateListener);
            }
            if(playListener!=null&&playListener.pauseListener!=null){
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    playAnimator.addPauseListener(playListener.pauseListener);
                }else{
                    throw new RuntimeException("SDK最小要求19");
                }
            }
            mAnimatorList.clear();
            mAnimatorBuilder=mAnimatorSet.play(playAnimator);
            return this;
        }

        public AnimatorSetWrap play(Animator animator) {
            mAnimatorList.clear();
            mAnimatorBuilder = mAnimatorSet.play(animator);
            return this;
        }

        public AnimatorSetWrap play(AnimatorSetWrap animator) {
            mAnimatorList.clear();
            mAnimatorBuilder = mAnimatorSet.play(animator.getAnimatorSet());
            return this;
        }

        /**
         * AnimatorSet的Before方法
         * @param view 動畫執行的主體View
         * @param animName 動畫型別
         * @param interpolator 插值器
         * @param repeatCount 重複次數
         * @param duration 動畫執行時長
         * @param values 動畫執行數值
         * @return
         */
        public AnimatorSetWrap before(View view, String animName,@Nullable TimeInterpolator interpolator, @Size(min = 0,max=Integer.MAX_VALUE)  int repeatCount,@Size(min = 0,max=Integer.MAX_VALUE)int duration, float... values){
            LogUtils.e("before");
            if(view==null){
                throw new RuntimeException("view 不能為空");
            }
            ObjectAnimator beforeAnimator = ObjectAnimator.ofFloat(view,
                    animName, values).setDuration(duration);
            beforeAnimator.setInterpolator(interpolator==null?mTimeInterpolator:interpolator);
            beforeAnimator.setRepeatCount(repeatCount<0?0:repeatCount);
            beforeAnimator.setDuration(duration<0?mDuration:duration);
            if (beforeListener!=null&&beforeListener.animatorListener != null) {
                beforeAnimator.addListener(beforeListener.animatorListener);
            }
            if(beforeListener!=null&&beforeListener.updateListener!=null){
                beforeAnimator.addUpdateListener(beforeListener.updateListener);
            }
            if(beforeListener!=null&&beforeListener.pauseListener!=null){
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    beforeAnimator.addPauseListener(beforeListener.pauseListener);
                }else{
                    throw new RuntimeException("SDK最小要求19");
                }
            }
            mAnimatorBuilder = mAnimatorBuilder.before(beforeAnimator);
            return this;
        }

        public AnimatorSetWrap before(Animator animator) {
            mAnimatorBuilder = mAnimatorBuilder.before(animator);
            return this;
        }

        public AnimatorSetWrap before(AnimatorSetWrap animator) {
            mAnimatorBuilder = mAnimatorBuilder.before(animator.getAnimatorSet());
            return this;
        }


        public AnimatorSetWrap with(View view, String animName,@Nullable TimeInterpolator interpolator,@Size(min = 0,max=Integer.MAX_VALUE) int repeatCount,@Size(min = 0,max=Integer.MAX_VALUE)int duration, float... values){
            LogUtils.e("with");
            if(view==null){
                throw new RuntimeException("view 不能為空");
            }
            ObjectAnimator withAnimator = ObjectAnimator.ofFloat(view,
                    animName, values).setDuration(duration);
            withAnimator.setInterpolator(interpolator==null?mTimeInterpolator:interpolator);
            withAnimator.setRepeatCount(repeatCount<0?0:repeatCount);
            withAnimator.setDuration(duration<0?mDuration:duration);
            if (withListener!=null&&withListener.animatorListener != null) {
                withAnimator.addListener(withListener.animatorListener);
            }
            if(withListener!=null&&withListener.updateListener!=null){
                withAnimator.addUpdateListener(withListener.updateListener);
            }
            if(withListener!=null&&withListener.pauseListener!=null){
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    withAnimator.addPauseListener(withListener.pauseListener);
                }else{
                    throw new RuntimeException("SDK最小要求19");
                }
            }
            mAnimatorBuilder = mAnimatorBuilder.with(withAnimator);
            return this;
        }

        public AnimatorSetWrap with(Animator animator) {
            mAnimatorBuilder = mAnimatorBuilder.with(animator);
            return this;
        }

        public AnimatorSetWrap with(AnimatorSetWrap animator) {
            mAnimatorBuilder = mAnimatorBuilder.with(animator.getAnimatorSet());
            return this;
        }



        public AnimatorSetWrap after(View view, String animName,@Nullable TimeInterpolator interpolator,@Size(min = 0,max=Integer.MAX_VALUE) int repeatCount,@Size(min = 0,max=Integer.MAX_VALUE) int duration, float... values){
            LogUtils.e("after");
            if(view==null){
                throw new RuntimeException("view 不能為空");
            }
            ObjectAnimator afterAnimator = ObjectAnimator.ofFloat(view,
                    animName, values).setDuration(duration);
            afterAnimator.setInterpolator(interpolator==null?mTimeInterpolator:interpolator);
            afterAnimator.setRepeatCount(repeatCount<0?0:repeatCount);
            afterAnimator.setDuration(duration<0?mDuration:duration);
            if (afterListener!=null&&afterListener.animatorListener != null) {
                afterAnimator.addListener(afterListener.animatorListener);
            }
            if(afterListener!=null&&afterListener.updateListener!=null){
                afterAnimator.addUpdateListener(afterListener.updateListener);
            }
            if(afterListener!=null&&afterListener.pauseListener!=null){
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    afterAnimator.addPauseListener(afterListener.pauseListener);
                }else{
                    throw new RuntimeException("SDK最小要求19");
                }
            }
            mAnimatorBuilder = mAnimatorBuilder.after(afterAnimator);
            return this;
        }

        public AnimatorSetWrap after(Animator animator) {
            mAnimatorBuilder = mAnimatorBuilder.after(animator);
            return this;
        }

        public AnimatorSetWrap after(AnimatorSetWrap animator) {
            mAnimatorBuilder = mAnimatorBuilder.after(animator.getAnimatorSet());
            return this;
        }


        public AnimatorSetWrap after(long delay) {
            mAnimatorBuilder.after(delay);
            return this;
        }

        /**
         * 直接執行動畫，該動畫操作主要用作執行AnimatorSet的組合動畫
         * 如果mAnimatorList不為0 則執行逐一播放動畫
         */
        public void playAnim() {
            if(mAnimatorList.size()>0){
                readyThen(true);
            }
            mAnimatorSet.start();
        }

        /**
         * 在一定時長內執行完該組合動畫
         * 如果mAnimatorList不為0 則執行逐一播放動畫
         * @param duration 動畫時長
         */
        public void playAnim(long duration) {
            if(mAnimatorList.size()>0){
                readyThen(true);
            }
            mAnimatorSet.setDuration(duration);
            mAnimatorSet.start();
        }

        /**
         *  延遲一定時長播放動畫
         *  如果mAnimatorList不為0 則執行逐一播放動畫
         * @param delay 延遲時長
         */
        public void playAnimDelay(long delay) {
            if(mAnimatorList.size()>0){
                readyThen(true);
            }
            mAnimatorSet.setStartDelay(delay);
            mAnimatorSet.start();
        }

        /**
         * 直接執行動畫，該動畫操作主要用作執行AnimatorSet的組合動畫
         */
        public void playAnim(boolean isSequentially) {
            readyThen(isSequentially);
            mAnimatorSet.start();
        }

        /**
         * 在一定時長內執行完該組合動畫
         * @param duration 動畫時長
         */
        public void playAnim(boolean isSequentially,long duration) {
            readyThen(isSequentially);
            mAnimatorSet.setDuration(duration);
            mAnimatorSet.start();
        }

        /**
         *  延遲一定時長播放動畫
         * @param delay 延遲時長
         */
        public void playAnimDelay(boolean isSequentially,long delay) {
            readyThen(isSequentially);
            mAnimatorSet.setStartDelay(delay);
            mAnimatorSet.start();
        }

        /**
         *  順序播放動畫
         * @param isSequentially  是逐一播放還是同時播放
         */
        private void readyThen(boolean isSequentially){
            // 只在第一次啟動時初始化
            if (mHasInitThenAnim) {
                return;
            }
            mHasInitThenAnim = true;
            if (mAnimatorList.size() > 0) {
                AnimatorSet set = new AnimatorSet();
                if(isSequentially){
                    set.playSequentially(mAnimatorList);
                }else{
                    set.playTogether(mAnimatorList);
                }
                mAnimatorBuilder.before(set);
            }
        }
        /**
         * 取消動畫
         */
        public void cancel() {
            mAnimatorSet.cancel();
            mAnimatorList.clear();
        }

        /**
         * 獲取AnimatorSet的例項
         * @return
         */
        private AnimatorSet getAnimatorSet() {
            return mAnimatorSet;
        }

        /**
         * 為AnimatorSet設定監聽
         * @param listener
         * @return
         */
        public AnimatorSetWrap setAnimatorSetListener(Animator.AnimatorListener listener) {
            mAnimatorSet.addListener(listener);
            return this;
        }

        /**
         * 取消AnimatorSet的監聽
         * @param listener
         */
        public void removeSetListner(Animator.AnimatorListener listener) {
            mAnimatorSet.removeListener(listener);
        }

        /**
         * 取消全部AnimatorSet的監聽
         */
        public void removeAllLSetisteners() {
            mAnimatorSet.removeAllListeners();
        }

        /**
         * 判斷一個View是否在當前的螢幕中可見（肉眼真實可見）
         * @param mView
         * @return 返回true則可見
         */
        public static boolean isVisibleOnScreen(View mView) {
            if (mView == null) {
                return false;
            }
            return mView.getWindowVisibility() == View.VISIBLE
                    && mView.getVisibility() == View.VISIBLE && mView.isShown();
        }
    }

    /**
     * Play方法對應的ObjectAnimator的監聽例項
     */
    public static class PlayAnimationListener implements IAnimatorListener<PlayAnimationListener>{

        private  Animator.AnimatorListener animatorListener;
        private ValueAnimator.AnimatorUpdateListener updateListener;
        private Animator.AnimatorPauseListener pauseListener;

        public AnimatorSetWrap animatorSetWrap;
        public  PlayAnimationListener(AnimatorSetWrap animatorSetWrap){
                this.animatorSetWrap=animatorSetWrap;
        }
        @Override
        public PlayAnimationListener setAnimatorListener(Animator.AnimatorListener animatorListener) {
            this.animatorListener=animatorListener;
            return this;
        }

        @Override
        public PlayAnimationListener setUpdateListener(ValueAnimator.AnimatorUpdateListener animatorListener) {
            this.updateListener=animatorListener;
            return this;
        }

        @Override
        public PlayAnimationListener setPauseListener(Animator.AnimatorPauseListener animatorListener) {
            this.pauseListener=animatorListener;
            return this;
        }
        @Override
        public AnimatorSetWrap and(){
            return animatorSetWrap;
        }
    }


    public static class BeforeAnimationListener implements IAnimatorListener<BeforeAnimationListener>{

        private  Animator.AnimatorListener animatorListener;
        private ValueAnimator.AnimatorUpdateListener updateListener;
        private Animator.AnimatorPauseListener pauseListener;

        public AnimatorSetWrap animatorSetWrap;
        public  BeforeAnimationListener(AnimatorSetWrap animatorSetWrap){
            this.animatorSetWrap=animatorSetWrap;
        }
        @Override
        public AnimatorSetWrap and() {
            return animatorSetWrap;
        }

        @Override
        public BeforeAnimationListener setAnimatorListener(Animator.AnimatorListener listener) {
            this.animatorListener=listener;
            return this;
        }

        @Override
        public BeforeAnimationListener setUpdateListener(ValueAnimator.AnimatorUpdateListener listener) {
            this.updateListener=listener;
            return this;
        }

        @Override
        public BeforeAnimationListener setPauseListener(Animator.AnimatorPauseListener listener) {
            this.pauseListener=listener;
            return this;
        }
    }


    public static class WithAnimationListener implements IAnimatorListener<WithAnimationListener>{

        private  Animator.AnimatorListener animatorListener;
        private ValueAnimator.AnimatorUpdateListener updateListener;
        private Animator.AnimatorPauseListener pauseListener;

        public AnimatorSetWrap animatorSetWrap;
        public  WithAnimationListener(AnimatorSetWrap animatorSetWrap){
            this.animatorSetWrap=animatorSetWrap;
        }
        @Override
        public AnimatorSetWrap and() {
            return animatorSetWrap;
        }

        @Override
        public WithAnimationListener setAnimatorListener(Animator.AnimatorListener listener) {
            this.animatorListener=listener;
            return this;
        }

        @Override
        public WithAnimationListener setUpdateListener(ValueAnimator.AnimatorUpdateListener listener) {
            this.updateListener=listener;
            return this;
        }

        @Override
        public WithAnimationListener setPauseListener(Animator.AnimatorPauseListener listener) {
            this.pauseListener=listener;
            return this;
        }
    }

    public static class AfterAnimationListener implements IAnimatorListener<AfterAnimationListener>{

        private  Animator.AnimatorListener animatorListener;
        private ValueAnimator.AnimatorUpdateListener updateListener;
        private Animator.AnimatorPauseListener pauseListener;

        public AnimatorSetWrap animatorSetWrap;
        public  AfterAnimationListener(AnimatorSetWrap animatorSetWrap){
            this.animatorSetWrap=animatorSetWrap;
        }
        @Override
        public AnimatorSetWrap and() {
            return animatorSetWrap;
        }

        @Override
        public AfterAnimationListener setAnimatorListener(Animator.AnimatorListener listener) {
            this.animatorListener=listener;
            return this;
        }

        @Override
        public AfterAnimationListener setUpdateListener(ValueAnimator.AnimatorUpdateListener listener) {
            this.updateListener=listener;
            return this;
        }

        @Override
        public AfterAnimationListener setPauseListener(Animator.AnimatorPauseListener listener) {
            this.pauseListener=listener;
            return this;
        }
    }


    public static class ThenAnimationListener implements IAnimatorListener<ThenAnimationListener>{

        private  Animator.AnimatorListener animatorListener;
        private ValueAnimator.AnimatorUpdateListener updateListener;
        private Animator.AnimatorPauseListener pauseListener;

        public AnimatorSetWrap animatorSetWrap;
        public  ThenAnimationListener(AnimatorSetWrap animatorSetWrap){
            this.animatorSetWrap=animatorSetWrap;
        }
        @Override
        public AnimatorSetWrap and() {
            return animatorSetWrap;
        }

        @Override
        public ThenAnimationListener setAnimatorListener(Animator.AnimatorListener listener) {
            this.animatorListener=listener;
            return this;
        }

        @Override
        public ThenAnimationListener setUpdateListener(ValueAnimator.AnimatorUpdateListener listener) {
            this.updateListener=listener;
            return this;
        }

        @Override
        public ThenAnimationListener setPauseListener(Animator.AnimatorPauseListener listener) {
            this.pauseListener=listener;
            return this;
        }
    }

    /**
     * 動畫監聽的公用模板介面
     * @param <T>
     */
    interface IAnimatorListener<T>{
        /**
         * 設定AnimatorListener的方法
         * @param listener
         * @return
         */
        T setAnimatorListener(Animator.AnimatorListener listener);

        /**
         * 設定AnimatorUpdateListener的方法
         * @param listener
         * @return
         */
        T setUpdateListener(ValueAnimator.AnimatorUpdateListener listener);

        /**
         * 設定AnimatorPauseListener的方法
         * @param listener
         * @return
         */
        T setPauseListener(Animator.AnimatorPauseListener listener);

        /**
         * 橋接動畫監聽與動畫工具類的方法
         * @return
         */
        AnimatorSetWrap and();
    }

}
複製程式碼

使用方法：

AnimatorUtils.createAnimator().play(viewAnimator,AnimatorUtils.ROTATIONY,null,0,1000,0,360).toAddThenListener().setUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator valueAnimator) {
                LogUtils.e("then1:"+valueAnimator.getAnimatedValue());
            }
        }).and().then(viewAnimator, AnimatorUtils.TRANSY, null, -1, -2, 0, 100, 200, 300, 200, 100, 0).toAddThenListener().setUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator valueAnimator) {
                LogUtils.e("then2:"+valueAnimator.getAnimatedValue());
            }
        }).and().then(viewAnimator, AnimatorUtils.SCALEX, new LinearInterpolator(), 0, 1000,  0, 10).toAddWithListener().setUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator valueAnimator) {
                LogUtils.e("with1:"+valueAnimator.getAnimatedValue());
            }
        }).and().with(viewAnimator, AnimatorUtils.SCALEY, new LinearInterpolator(), 0, 1000,  0, 10).toAddWithListener().setAnimatorListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animator) {
                LogUtils.e("with2:onAnimationStart");
            }

            @Override
            public void onAnimationEnd(Animator animator) {

            }

            @Override
            public void onAnimationCancel(Animator animator) {

            }

            @Override
            public void onAnimationRepeat(Animator animator) {

            }
        }).and().with(viewAnimator, AnimatorUtils.ALPHA, new LinearInterpolator(), 0, 1000,  1, 0,1)
        //.playSequentially(2000);
        .playAnim();
複製程式碼

上面的動畫呼叫方法是我亂寫的，具體就是為了演示工具類的使用方法，你可以改成自己的呼叫方法。

Android常用工具類的封裝
2018-04-27
Android封裝
封裝Date工具類
2018-10-30
封裝
封裝Redis工具類
2024-06-25
封裝Redis
【JavaScript框架封裝】實現一個類似於JQuery的動畫框架的封裝
2018-07-19
JavaScript框架封裝jQuery動畫
封裝avalonia指定元件允許拖動的工具類
2023-02-28
封裝元件
RN自定義元件封裝 - 播放類似PPT動畫
2018-04-07
元件封裝動畫
Android之Activity基類封裝
2019-01-15
Android封裝
關於緩動動畫函式的封裝
2019-01-11
動畫函式封裝
5.Hibernate工具類的簡易封裝
2018-12-29
封裝
關於TornadoFx和Android的全域性配置工具類封裝實現及思路解析
2022-05-28
Android封裝
Flutter的移動端相機快門動畫封裝
2019-08-08
Flutter動畫封裝
JavaFx 生成二維碼工具類封裝
2023-04-28
Java封裝
Android 原生 SQLite 資料庫的一次封裝實踐
2020-08-10
AndroidSQLite資料庫封裝
封裝一個簡單的動畫函式
2020-09-28
封裝動畫函式
iOS微信支付接入以及工具類封裝
2018-04-03
iOS封裝
Android專案篇（二）：開源庫及工具的封裝
2018-05-29
Android封裝
一、類的封裝性
2024-05-30
封裝
前端簡潔並實用的工具類函式封裝
2018-03-06
前端函式封裝
Android中Retrofit的封裝使用
2020-12-19
Android封裝
web自動化框架—BasePage 類的簡單封裝
2021-05-16
Web框架封裝
javascript封裝動畫函式（勻速、變速）
2020-11-15
JavaScript封裝動畫函式
十五、類與封裝的概念
2019-05-13
封裝
Retrofit+okhttp+Rxjava封裝網路請求工具類
2019-01-03
HTTPRxJava封裝
Android動畫
2019-03-27
Android動畫
android 動畫
2018-08-28
Android動畫
Android結合DataBinding封裝的BaseBindingAdapter
2018-08-13
Android封裝APT
WebAPIs-06：動畫函式封裝 + 觸屏事件
2020-10-19
WebAPI動畫函式封裝事件
Swift 核心動畫面向協議擴充套件封裝
2019-01-31
Swift動畫協議套件封裝
通過Handler封裝的網路請求資料的工具類NetUtils
2018-12-09
封裝
Android工具類庫
2018-03-14
Android
2020-10-18 BeanUtils工具類，簡化資料封裝
2020-10-18
Bean封裝
Android 動畫之屬性動畫
2019-05-07
Android動畫
c#封裝DBHelper類
2018-09-27
C#封裝
4、類和物件—封裝
2020-11-14
物件封裝
自用驗證類封裝
2020-12-02
封裝
Android Room封裝成一個類似Redis的快取資料庫的效果
2018-05-25
AndroidOOM封裝Redis快取資料庫
Android架構系列-封裝自己的okhttp
2019-03-01
Android架構封裝HTTP
Android 動畫初探
2018-10-23
Android動畫

一次Android動畫工具類的封裝

起因

思路

API

API

程式碼

相關文章