一次Androidアニメーションツール類のパッケージ

36148 ワード

の原因となる
最近、コンポーネント化されたフレームワークのパッケージを作っていますが、今では一般的なツールクラスのパッケージが開発されています.突然、まだアニメーションをしていないようなツールクラスがあることに気づき、開発に着手しました.
構想
アニメーションを作る以上、属性アニメーションを作るツールクラスのカプセル化に違いないが、補間アニメーションとフレームごとのアニメーションはターゲットアニメーションのテーマの実際の属性を変えることができないため、Androidの開発ではこの2つのアニメーションフレームワークを開発する人が少なくなっているが、属性アニメーションは相対的に開発過程で広く使われているため、今回のツールクラスのカプセル化は、属性アニメーションだけをカプセル化している.
属性のアニメーションの対応するクラスはObjectAnimatorと言って、主にこのクラスでアニメーションのいくつかの基礎の設定を実現して、その具体的な使い方は私は書かないで、興味のある友达は自分で属性のアニメーションの関連する知識を学ぶことができます.
アトリビュートアニメーションをカプセル化するツールクラスは、アトリビュートアニメーションの組み合わせによるアニメーションの再生の必要性を考慮することが避けられません.アトリビュートアニメーションの組み合わせには、約3つの方法があります.
1.AnimatorSetのBuilderを使用してAnimatorSet.を組み合わせて再生する.Builderは、AnimatorSetにアニメーションを追加したり、さまざまなアニメーションの関係を設定したりするのに便利なアニメーションツールクラスです.AnimatorSet.Builderでは、after(long)、after(Animator)、before(Animator)、with(Animator)の4つのメソッドが宣言されています.

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):アニメーションのセットを追加し、再生順序が1つずつ再生する

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の3つの方法で、ここで合理的なパッケージが必要です.
また、傍受インタフェースのパッケージについては、ObjectAnimatorごとに3つのインタフェースがあります.

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{

        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 
     */
    interface IAnimatorListener{
        /**
         *   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 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{

        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{

        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{

        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{

        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{

        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 
     */
    interface IAnimatorListener{
        /**
         *   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();

上のアニメーションの呼び出し方法は私が落書きしたので、具体的にはツールクラスの使用方法をプレゼンテーションするために、あなたは自分の呼び出し方法に変えることができます.

Python. パラメータ

Androidで<br>ラベルの使用及び注意事項